Trouver des entrées en double dans la Collection

Est-il un outil ou à la bibliothèque pour trouver les doublons dans une Collection selon des critères spécifiques qui peuvent être mises en œuvre?

À me faire comprendre: je veux comparer les entrées les uns aux autres selon des critères spécifiques. Je crois donc que Predicate retour juste true ou false n'est pas suffisant.

Je ne peux pas utiliser equals.

De quelle façon aimeriez-vous préciser la déduplication des critères? Comme un prédicat binaire?
Voulez-vous trouver les doublons, ou supprimer?
En fait, il suffisait juste de savoir si il y a des doublons.
Parlez - ah, alors vous pouvez simplement comparer la taille de la collection résultant de Samuel Rossille, la réponse à la taille de la collection d'origine.
Veuillez voir mon édité question.

OriginalL'auteur | 2012-05-25

  1. 7

    Il dépend de la sémantique de l'critère:

    Si votre critère est toujours le même pour une classe donnée, et est inhérente à la notion sous-jacente, vous devriez mettre en œuvre equals et hashCode et l'utilisation d'un ensemble.

    Si votre critère dépend du contexte, org.apache.commons.les collections.CollectionUtils.sélectionnez(java.util.Collection, org.apache.commons.les collections.Prédicat) pourrait être la bonne solution pour vous.

    Je veux comparer les entrées entre les uns des autres, pas à des critères arbitraires.

    OriginalL'auteur Samuel Rossille

  2. 4

    Si vous voulez trouver doublons, plutôt que de simplement les enlever, une approche pourrait être de lancer la Collection dans un tableau, trier le tableau par l'intermédiaire d'un Comparateur qui implémente vos critères, puis de façon linéaire à pied à travers la matrice, à la recherche de doubles adjacentes.

    Voici un croquis (pas testé):

       MyComparator myComparator = new MyComparator();
   MyType[] myArray = myList.toArray();
   Arrays.sort( myArray, myComparator );
   for ( int i = 1; i < myArray.length; ++i ) {
      if ( 0 == myComparator.compare( myArray[i - 1], myArray[i] )) {
         //Found a duplicate!
      }
   }

    Edit: De votre commentaire, vous voulez juste savoir si il y sont les doublons. L'approche ci-dessus fonctionne pour cela aussi. Mais vous pouvez plus simplement, il suffit de créer un projet java.util.SortedSet avec un Comparateur. Voici un croquis:

       MyComparator myComparator = new MyComparator();
   TreeSet treeSet = new TreeSet( myComparator );
   treeSet.addAll( myCollection );
   boolean containsDuplicates = (treeSet.size() != myCollection.size());

    OriginalL'auteur Andy Thomas

  3. 3

    Vous pouvez adapter un jeu Java pour la recherche de doublons parmi les objets d'un type arbitraire: l'enveloppe de votre cible, à un cours privé wrapper qui évalue l'égalité en fonction de vos critères, et de construire un ensemble de papiers d'emballage.

    Ici est un peu long exemple qui illustre cette technique. Il considère deux personnes avec le même prénom à l'égalité, et de sorte qu'il détecte trois copies dans le tableau de cinq objets.

    import java.util.*;
import java.lang.*;
class Main {
static class Person {
private String first;
private String last;
public String getFirst() {return first;}
public String getLast() {return last;}
public Person(String f, String l) {
first = f;
last = l;
}
public String toString() {
return first+" "+last;
}
}
public static void main (String[] args) throws java.lang.Exception {
List<Person> people = new ArrayList<Person>();
people.add(new Person("John", "Smith"));
people.add(new Person("John", "Scott"));
people.add(new Person("Jack", "First"));
people.add(new Person("John", "Walker"));
people.add(new Person("Jack", "Black"));
Set<Object> seen = new HashSet<Object>();
for (Person p : people) {
final Person thisPerson = p;
class Wrap {
public int hashCode() { return thisPerson.getFirst().hashCode(); }
public boolean equals(Object o) {
Wrap other = (Wrap)o;
return other.wrapped().getFirst().equals(thisPerson.getFirst());
}
public Person wrapped() { return thisPerson; }
};
Wrap wrap = new Wrap();
if (seen.add(wrap)) {
System.out.println(p + " is new");
} else {
System.out.println(p + " is a duplicate");
}
}
}
}

    Vous pouvez jouer avec cet exemple sur ideone [lien].

    +1: intéressant! Juste n'ai aucune idée de l'efficacité.
    Si votre fonction de hachage est bonne, l'efficacité est la même qu'avec toute table de hachage, ce qui est O(1) pour chaque élément, ou O(N) pour l'ensemble de la collection.
    dasblinkenlight: je suis un peu préoccupé par l'écharpe de création de l'objet, même si je sais qu'ils seront partis en dehors de la boucle.
    Java est très efficace à la création de petits objets (et que ces objets sont minuscules). Malheureusement, Java ne dispose pas d'un concept parallèle .NET comparateur d'égalité - qui permettrait de trouver une solution qui évite temporaire des objets tout à fait.

    OriginalL'auteur dasblinkenlight

  4. 2

    Vous pouvez utiliser une carte et lors de l'itération sur la collecte de mettre les éléments dans la carte (les prédicats constitueraient les principaux) et si il y a déjà une entrée que vous avez trouvé un duplicata.

    Pour plus d'informations, voir ici: Trouver les doublons dans une collection

    OriginalL'auteur Thomas

  5. 2

    J'ai créé une nouvelle interface semblable à la IEqualityComparer<T> interface dans .NET.

    Une telle EqualityComparator<T> je puis passez à la méthode suivante qui détecte les doublons.

    public static <T> boolean hasDuplicates(Collection<T> collection,
EqualsComparator<T> equalsComparator) {
List<T> list = new ArrayList<>(collection);
for (int i = 0; i < list.size(); i++) {
T object1 = list.get(i);
for (int j = (i + 1); j < list.size(); j++) {
T object2 = list.get(j);
if (object1 == object2
|| equalsComparator.equals(object1, object2)) {
return true;
}
}
}
return false;
}

    Cette façon, je peux personnaliser le rapport à mes besoins.

    OriginalL'auteur

  6. 0

    Treeset vous permet de faire cela facilement:

    Set uniqueItems = new TreeSet<>(yourComparator);
List<?> duplicates = objects.stream().filter(o -> !uniqueItems.add(o)).collect(Collectors.toList());

    yourComarator est utilisé lors de l'appel de uniqueItems.add(o), qui ajoute l'élément à l'ensemble et retourne true si l'élément est unique. Si le comparateur considère que l'élément est un doublon, add(o) retournera false.

    Noter que l'élément equals méthode doit être cohérente avec yourComarator comme par le TreeSet documentation pour que cela fonctionne.

    OriginalL'auteur Tadhg

  7. -2

    De réitérer la ArrayList qui contient des doublons et de les ajouter à la HashSet. Lorsque le complément de la méthode renvoie false dans le HashSet connectez-vous tout simplement le double de la console.

    Comme l'OP dit, il ne peut pas utiliser equals(). Un HashSet utilise hashCode() et equals(). Il ne peut donc pas utiliser un HashSet.

    OriginalL'auteur Nagendra