Question

我应该在包含许多不同电子邮件地址的文件中读取并使用数组打印出来。问题是我需要消除重复的电子邮件。

我能够让我的try / catch工作并打印出电子邮件地址。但是，我不知道如何删除重复项。我还没有理解哈希码或如何使用Set。任何帮助将不胜感激。

这是我到目前为止所做的：

import java.util.Scanner;
import java.io.*;

public class Duplicate {
   public static void main(String[] args) {

      Scanner keyboard = new Scanner(System.in);
      System.out.println("Enter file name: ");
      String fileName = keyboard.nextLine();
      if (fileName.equals("")) {
         System.out.println("Error: User did not specify a file name.");
      } else {
         Scanner inputStream = null;

         try {
            inputStream = new Scanner(new File(fileName));
         } catch (FileNotFoundException e) {
            System.out.println("Error: " + fileName + " does not exist.");
            System.exit(0);
         }

         String[] address = new String[100];

         int i = 0;
         while (inputStream.hasNextLine()) {
            String email = inputStream.nextLine();
            // System.out.println(email);

            address[i] = email;
            System.out.println(address[i]);
            i++;
         }
      }
   }
}

Answer 1

简单的解决方案是使用Set of java，

所以设置自动删除重复值

并且在你的代码中你有数组而不是直接使用代码转换数组

Set<T> mySet = new HashSet<T>(Arrays.asList(someArray));

Answer 2

了解Set。学习它所花费的时间少于编写不使用它的时间。

我会帮你的。替换这个：

String[] address = new String[100];

用这个：

Set<String> addresses = new HashSet<String>();

而且：

address[i] = email;

用这个：

addresses.add(email);

您不再需要i了。

你已经完成了。如果您想打印出所有内容：

for (String address : addresses) {
     System.out.println (address);
}

这几乎涵盖了它。希望一切都自动排序？将上面的HashSet替换为TreeSet。现在请阅读this excellent tutorial，以便下次您可以更快地完成所有工作。

Answer 3

您可以尝试遍历数组中的每个元素，将其添加到另一个元素，检查第二个数组是否包含下一个项目，如果它跳过它。然后用第二个替换第一个数组。（ArrayList在这种情况下更好。）

这样的事情：

List<String> FinalList = new ArrayList<String>();
for(string temp : adress)
{
if(!FinalList.contains(temp))
  FinalList.add(temp);
}

Answer 4

将它们改为HashSet。这将为您处理重复。

Set<String> addresses = new HashSet<String>();
addresses.add("a@a.com");
addresses.add("a@a.com");
addresses.add("a@a.com");
System.out.println(addresses.size());

将打印1。

Answer 5

根据需要使用ArrayUtil类。除了删除重复项之外，我还写了一些方法。无需使用任何Collection框架类即可实现此类。

public class ArrayUtils {
/**
 * Removes all duplicate elements from an array. 
 * @param arr Array from which duplicate elements are to be removed.
 * @param removeAllDuplicates true if remove all duplicate values, false otherwise 
 * @return Array of unique elements.
 */
public static int[] removeDuplicate(int[] arr, boolean removeAllDuplicates)         {
    int size = arr.length;

    for (int i = 0; i < size;) {
        boolean flag = false;

        for (int j = i + 1; j < size;) {
            if (arr[i] == arr[j]) {
                flag = true;
                shrinkArray(arr, j, size);
                size--;
            } else
                j++;
        }

        if (flag && removeAllDuplicates) {
            shrinkArray(arr, i, size);
            size--;
        } else
            i++;
    }

    int unique[] = new int[size];
    for (int i = 0; i < size; i++)
        unique[i] = arr[i];

    return unique;
}

/**
 * Removes duplicate elements from an array. 
 * @param arr Array from which duplicate elements are to be removed.
 * @return Array of unique elements.
 */
public static int[] removeDuplicate(int[] arr) {
    return removeDuplicate(arr, false);
}


private static void shrinkArray(int[] arr, int pos, int size) {
    for (int i = pos; i < size - 1; i++) {
        arr[i] = arr[i + 1];
    }
}

/**
 * Displays the array.
 * @param arr The array to be displayed.
 */
public static void displayArray(int arr[]) {
    System.out.println("\n\nThe Array Is:-\n");

    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i] + "\t");
    }
}

/**
 * Initializes the array with a given value.
 * @param arr The array to be initialized.
 * @param withValue The value with which the array is to be initialized.
 */
public static void initializeArray(int[] arr, int withValue) {
    for (int i = 0; i < arr.length; i++) {
        arr[i] = withValue;
    }
}

/**
 * Checks whether an element is there in the array. 
 * @param arr The array in which the element is to be found.
 * @param element The element that is to be found.
 * @return True if found false otherwise
 */
public static boolean contains(int arr[], int element) {
    for(int i=0; i< arr.length; i++) {
        if(arr[i] == element)
            return true;
    }

    return false;
}

/**
 * Removes a element from an array.
 * @param arr The array from which the element is to removed.
 * @param element The element to be removed
 * @return The size of the array after removing.
 */
public static int removeElement(int[] arr, int element) {
    int size = arr.length;
    for(int i=0; i< arr.length; i++){
        if(arr[i] == element){
            shrinkArray(arr, i, arr.length);
            size--;
        }
    }
    return size;
}

/**
 * Counts unique elements in an array.
 * @param arr The required array.
 * @return Unique element count.
 */
public static int uniqueElementCount(int arr[]) {
    int count = 0;
    int uniqueCount=0;
    int[] consideredElements = new int[arr.length];

    initializeArray(consideredElements, 0);

    for(int i=0;i<arr.length;i++) {
        int element = arr[i];
        for(int j=i+1;j<arr.length; j++){
            if(element != arr[j] && !contains(consideredElements, element)){
                consideredElements[count++] = element;
            }
        }
    }

    for(int i=0;i< consideredElements.length;i++)
        if(consideredElements[i]!=0)
            uniqueCount++;

    return uniqueCount;
}
}

Answer 6

请使用以下代码删除整数数组中的重复项。

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package test123;

import java.util.ArrayList;
import java.util.HashSet;

/**
 *
 * @author krawler
 */
public class Test123 {

    /**
     * @param args the command line arguments
     */
     public static ArrayList<Integer> removeDuplicates(ArrayList<Integer> list) {

	// Store unique items in result.
	ArrayList<Integer> result = new ArrayList<>();

	HashSet<Integer> set = new HashSet<>();

	
	for (Integer item : list) {

	   
	    if (!set.contains(item)) {
		result.add(item);
		set.add(item);
	    }
	}
	return result;
    }

    public static void main(String[] args) {

	ArrayList<Integer> list = new ArrayList<>();
	list.add(12);
	list.add(12);
	list.add(8);
	list.add(6);
	list.add(4);
	list.add(4);
        list.add(2);
        list.add(1); 
           //int a[]={12,12,8,6,4,4,2,1}
	
	ArrayList<Integer> unique = removeDuplicates(list);
	for (int element : unique) {
	    System.out.println(element);
	}
    }
}

/*run:
12
8
6
4
2
1
BUILD SUCCESSFUL (total time: 0 seconds)*/

Answer 7

如果你想删除重复项，你可以尝试这样的事情：

String[] address = new String[100]; // the array that contains all addresses
ArrayList<String> uniqueAddresses = new ArrayList<String>(); // create arraylist to contain all non-repeated addresses
for(String addr : address){ // cycle through the entire array
   if(!uniqueAddresses.contain(addr)){ // check if the address already there
      uniqueAddresses.add(addr); // add it
   }
}

Answer 8

使用 String 数组 address – 以下lambda的性能应与 { {1}} -解决方案
需要Java 8或更高版本

Set

btw：此解决方案保留了Arrays.stream( address ).distinct().toArray( String[]::new );数组中地址的顺序

Answer 9

我头脑中的第一件事是对数组进行排序，然后检查下一个元素是否等于当前元素。如果是这样，删除当前元素。

哦，当你不知道文件中存储了多少封电子邮件时，数组可能不是最好的方式。我会采用某种列表，这样我就不必关心文件中有多少个电子邮件地址了。

Answer 10

你可以编写一个在数组上运行的函数，一次只收一封电子邮件，当它找到相同的地址时，只需将其设置为null。当您在阵列上运行以进行打印时，请创建条件以仅在非空

时打印电子邮件

Java从数组中删除重复项？

10 个答案: