En supprimant les doublons d'une Liste en Java à l'aide d'itérateurs

• quand i==0 votre iterator.next() et get(i) serait le même élément, de sorte que vous venez de retirer.
• pour la même liste, mieux vaut ne pas faire iterator.remove() dans un for boucle.
• vous n'avez pas add rien à la newList, et l'a retourné tout simplement
• une suggestion pour cette mission:

vous pourriez d'abord sorte la liste, puis allez à travers elle, si un élément est égale à la précédente, supprimer l'élément. Vous pouvez bien sûr créer une nouvelle liste de tenir ces éléments uniques, si vous le souhaitez.

mes 2 cents

OriginalL'auteur Kent

Vous pouvez simplement créer votre propre itérateur, dont l'objet est seulement de retour d'un double de la valeur une fois.

public class NoDuplicatesIterator<T> implements Iterator<T> {
private final List<T> array;
private final List<T> encountered;
private int index = 0;
public NoDuplicatesIterator(List<T> array) {
this.array = array;
encountered = new ArrayList<>();
}
@Override
public boolean hasNext() {
if (index > array.size() - 1) {
return false;
}
while (encountered.contains(array.get(index)) && index < array.size() - 1) {
index++;
}
return index <= array.size() - 1;
}
@Override
public T next() {
encountered.add(array.get(index));
return array.get(index++);
}
}

Utilisation:

public class Main {
public static void main(String[] args) {
List<Integer> array = Arrays.asList(new Integer[]{100, 2, 2, 1, 1, 2, 3, 3, 15, 4, 4, 5, 6, 7, 7, 8, 99, 99, 100, 99, 2, 77, 23, 14, 2, 15});
NoDuplicatesIterator<Integer> it = new NoDuplicatesIterator(array);
while (it.hasNext()) {
System.out.println(it.next());
}
}
}

OriginalL'auteur Alan Smith

Un autre moyen simple de le faire est comme ci-dessous.

import java.util.HashSet;
import java.util.List;
import java.util.Set;public class Main {
/**
* @param args
*/
public static void main(String args[]) throws SQLException {
System.out.println("Entered Main");
Test();
System.out.println(str);
set.addAll(str);
System.out.println(set);
str.clear();
str.addAll(set);
System.out.println(str);
}
final static List<String> str = new ArrayList<String>();
final static Set<String> set = new HashSet<String>();
public static void Test(){
str.add("A");
str.add("B");
str.add("C");
str.add("C");
str.add("D");
str.add("A");
str.add("B");
str.add("C");
str.add("C");
str.add("D");
str.add("B");
str.add("C");
str.add("B");
str.add("C");
str.add("C");
str.add("D");
str.add("B");
str.add("C");
str.add("C");
str.add("C");
str.add("D");
System.out.println(str);
}

Méthode d'essai pour remplir la liste est copié à partir de Vidyarani Shinde de réponse.

OriginalL'auteur Kishor Raskar

J'ai utilisé les deux avancées de chacun et également tenté par la conversion de ArrayList à HashSet et de nouveau à ArrayList. À la fois de la solution fonctionne très bien. Vous pouvez choisir n'importe quel

public static void main(String[] args) {
ArrayList<String> wordDulicate = new ArrayList<String>();
wordDulicate.add("Tom");
wordDulicate.add("Jones");
wordDulicate.add("Sam");
wordDulicate.add("Jamie");
wordDulicate.add("Robie");
wordDulicate.add("Helen");
wordDulicate.add("Helen");
wordDulicate.add("Helen");
wordDulicate.add("Helen");
wordDulicate.add("Tom");
wordDulicate.add("Troy");
wordDulicate.add("Mika");
wordDulicate.add("Tom");
System.out.println("Array List size"+wordDulicate.size());
ArrayList<String> nonDuplicat=new ArrayList<String>(new HashSet<String>(wordDulicate));
System.out.println("Array List size"+nonDuplicat.size());
ArrayList<String> nonDuplicatThroughIterator=new ArrayList<String>();
for(String each:wordDulicate){
if(!nonDuplicatThroughIterator.contains(each))
nonDuplicatThroughIterator.add(each);
}
System.out.println("Array List size"+nonDuplicatThroughIterator.size());
}

OriginalL'auteur Rizwan Khan

Supposer que ArrayList implémente ListADT, que le ArrayList et ArrayListIterator classes sont mises en œuvre comme prévu, et que BadListException est décochée exception avec un zéro argument du constructeur. Supposons aussi que les éléments null ne peut pas être ajouté à une liste.

J'ai pour valider la méthode en Java spécifié ci-dessous, l'utilisation des itérateurs. Ma solution doit répondre à ces exigences:

1. doit explicitement utiliser des itérateurs pour parcourir les listes (c'est à dire, vous ne pouvez pas utiliser une boucle for ou Java est prolongée pour la boucle)
2. ne devez pas utiliser le contains méthode
3. peut utiliser tout ListADT méthodes (sauf contains) décrits dans le sur la ligne de lecture, y compris ListADT.iterator(), mais ne doit pas utiliser n'importe quel autre List méthodes ne sont pas mentionnés, il y
4. ne doit pas modifier le contenu des paramètres.

Le squelette de la fonction:

public static ListADT<String> union(ListADT<String> list1, ListADT<String> list2) {
//If list1 or list2 (or both list1 and list2) is null, throw a BadListException. 
//If list1 and list2 are both empty, return a new empty list.
//If list1 is empty (but not list2), return a new list containing the strings in
//    list2 with all duplicates removed.
//If list2 is empty (but not list1), return a new list containing the strings in
//    list1 with all duplicates removed.
//Otherwise, create and return a new list that contains the strings in list1 and
//    the strings in list2 with all duplicates removed.
//
//Examples:
// list1: "a","b","c"          list2: "d","e","f"      result: "a","b","c","d","e","f"
// list1: "a","c","b","d"      list2: "e","d","a","f"  result: "a","c","b","d","e","f"
// list1: "a","b","c","b","a"  list2: "c","a","b"      result: "a","b","c"
//
//Note: the list returned does not need to be in any particular order

Je dois m'assurer que ma solution n'utilise que les méthodes qui sont dans les ListADT interface décrite dans la ligne de lecture (y compris une méthode d'itérateur, comme mentionné ci-dessus).

Comment puis-je faire cela?

OriginalL'auteur allyson