Java Rimuovere i duplicati da una matrice?

Question

Devo leggere in un file contenente molti indirizzi e-mail diversi e stamparli usando un array. Il problema è che ho bisogno di eliminare le e-mail duplicate.

Sono stato in grado di ottenere il mio try/catch lavorando e stampare gli indirizzi e-mail. Tuttavia, non sono sicuro di come rimuovere i duplicati. Non ho ancora una conoscenza di hashcode o di come utilizzare uno Set. Qualsiasi assistenza sarebbe apprezzata.

Ecco quello che ho finora:

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

Si può provare a passare attraverso ogni elemento della matrice, aggiungendolo ad un altro, verificando che la seconda matrice contiene l'elemento successivo, se lo fa saltare esso. Quindi sostituisci il 1 ° array con il 2 °. (ArrayList è meglio in questo caso però).

quindi qualcosa di simile:

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

Answer 2

la prima cosa che viene in mente è quello di ordinare l'array e poi controllare se l'elemento successivo è uguale l'elemento corrente. in tal caso, elimina l'elemento corrente.

oh e quando non si sa quante e-mail sono memorizzate nel file, un array non è probabilmente il modo migliore. Farei una specie di lista, così non mi importa di quanti indirizzi di posta elettronica ci siano nel file.

Answer 3

è possibile scrivere una funzione eseguita sull'array e prendere una e-mail alla volta e quando mai trova lo stesso indirizzo è sufficiente impostarla su null. quando si esegue sulla matrice per stampare, effettuare una condizione di stampare l'e-mail solo se la sua non nullo

Answer 4

La soluzione più semplice è che l'uso Set di java,

quindi impostare rimuovere il valore duplicato automaticamente

e nel codice hai gamma di convertire matrice per impostare direttamente utilizzando il codice

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

Answer 5

Leggerli in un HashSet invece. Questo gestirà i duplicati per te.

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()); 

Stampa 1.

Answer 6

Learn Set. Il tempo che impiegherà per impararlo è inferiore al tempo necessario per codificare qualcosa che non lo usa.

Per iniziare.Sostituire questo:

String[] address = new String[100];

con questo:

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

E questo:

address[i] = email;

con questo:

addresses.add(email);

Non è più necessario il i.

Il gioco è fatto. Se desideri stampare tutto:

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

Questo praticamente lo copre. Vuoi che tutto venga automaticamente ordinato? Sostituire HashSet in precedenza con TreeSet. Ora vai a leggere this excellent tutorial in modo che la prossima volta, puoi fare tutto più velocemente e da solo.

Answer 7

Utilizzare la classe ArrayUtil di cui si ha bisogno. Ho scritto alcuni metodi oltre a rimuovere i duplicati. Questa classe è implementata senza utilizzare alcuna classe di framework 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 8

Utilizzare il codice riportato di seguito per rimuovere i duplicati in un array intero.

/* 
 
* 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) { 
 

 
\t // Store unique items in result. 
 
\t ArrayList<Integer> result = new ArrayList<>(); 
 

 
\t HashSet<Integer> set = new HashSet<>(); 
 

 
\t 
 
\t for (Integer item : list) { 
 

 
\t  
 
\t  if (!set.contains(item)) { 
 
\t \t result.add(item); 
 
\t \t set.add(item); 
 
\t  } 
 
\t } 
 
\t return result; 
 
    } 
 

 
    public static void main(String[] args) { 
 

 
\t ArrayList<Integer> list = new ArrayList<>(); 
 
\t list.add(12); 
 
\t list.add(12); 
 
\t list.add(8); 
 
\t list.add(6); 
 
\t list.add(4); 
 
\t list.add(4); 
 
     list.add(2); 
 
     list.add(1); 
 
      //int a[]={12,12,8,6,4,4,2,1} 
 
\t 
 
\t ArrayList<Integer> unique = removeDuplicates(list); 
 
\t for (int element : unique) { 
 
\t  System.out.println(element); 
 
\t } 
 
    } 
 
} 
 

 
/*run: 
 
12 
 
8 
 
6 
 
4 
 
2 
 
1 
 
BUILD SUCCESSFUL (total time: 0 seconds)*/

Answer 9

Se si desidera rimuovere i duplicati si può provare qualcosa di simile:

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 
    } 
}