java: Comparateur et Treeset pour supprimer les doublons

j'ai une classe java comme ce

public class A {

    private String field1;
    private String field2;

    //getters, setters but no equals and hashcode
}

et une liste des objets de cette classe, je veux supprimer de cette liste toutes les copies des éléments qui a le même champ1 ou même champ2, donc, j'ai 2 Comparateurs

public class Comparator1 implements Comparator<A> {
    public int compare(A o1, A o2) {

        return o1.getField1().compareToIgnoreCase( o2.getField1() );
    }
}

public class Comparator2 implements Comparator<A> {
    public int compare(A o1, A o2) {

        return o1.getField2().compareToIgnoreCase(o2.getField2());
    }
}

afin de faire la tâche-je utiliser treeset comme

TreeSet<A> ts1 = new TreeSet<A>(new Comparator1())
ts1.addAll(list)

TreeSet<A> ts2 = new TreeSet<A>(new Comparator2())
ts2.addAll(ts1)

list.clear()
list.addAll(ts2)

mais comment puis-je faire la même chose en utilisant simplement un comparateur et un treeset ?

Merci pour l'aide

Mise à jour:

Merci à tous pour les réponses, mais après les avoir lu, je ne sais pas si c'est la bonne approche pour le problème réel.

Dans mon cas réel champ1 est comme un numéro de téléphone et champ2 est comme un nom.
Donc je ne veux pas appeler le même numéro de téléphone, plus d'une fois (c'est la première treeset d'supprime les doublons) et je ne veux pas l'appeler plusieurs fois le même nom (la deuxième treeset d'supprime les doublons)

Vous pouvez modifier la catégorie, mais j'aimerais savoir si cette approche est ok pour résoudre le vrai problème.

Si cette approche est correcte, à partir de votre question, je vois que, sans modifier la classe n'est pas possible d'utiliser un comparateur de

Grâce

L'ajout de equals() et hashCode() à A est donc pas une option? L'extension de A aussi non?
j'ai mis à jour la question

OriginalL'auteur res1 | 2011-04-09

1

Vous ne pouvez pas, et il n'est pas clair pour moi que ce que vous essayez de faire est bien défini.

Savez-vous que votre approche actuelle dépend à la fois de l'ordre dans lequel les éléments sont ajoutés et que vous vérifiez champ1 ou champ2 d'abord pour les doublons? Imaginez-vous eu ces objets de la classe A:
```
A ab = new A("a", "b");
A cb = new A("c", "b");
A cd = new A("c", "d");
```
Vérification champ1 donne d'abord le résultat [ab] ou [ab, cd], selon l'ordre ajouté.

Vérification champ2 donne d'abord le résultat [cb] ou [ab, cd], selon l'ordre ajouté.

C'est assez étrange comportement. Est-ce que vous avez prévu? Je ne pense pas qu'il est possible de reproduire cela avec un seul TreeSet et Comparateur dans le cas général.

j'ai mis à jour ma question avec plus d'information
votre mise à jour n'est pas à clarifier le problème. Beaux-semblant "un" est un nom et "c" est un nom et "b" est un numéro de téléphone et "d" est un numéro de téléphone. Parfois avec ces trois paires, vous n'appelez "a" à "b", jamais appeler "c" à tous, et de ne jamais appeler le numéro de "d" à tous. Est-ce que vous est-il destiné? Si non, veuillez préciser ce que vous voulez arriver dans cette situation.
en regardant votre cas de test ce n'est pas ce que je veux, je veux obtenir le [ab, cd] comme le résultat et non la [ab].

OriginalL'auteur rlibby
2

Vous ne pouvez pas utiliser un comparateur de trier par deux critères en même temps, donc il n'y a aucun moyen réel pour aller mieux que deux TreeSets dans votre cas. Bien sûr, vous pouvez les envelopper dans une structure de données.

(Alternativement, vous pouvez utiliser deux HashMaps, ayant chacun une des chaînes clés - ce sera plus rapide en moyenne, mais il est plus compliqué à programmer.)

OriginalL'auteur Paŭlo Ebermann
0
```
public static <A extends Comparable<?>>  TreeSet<A> getTreeSet(Collection<A> list){
    TreeSet<A> result = new TreeSet<A>();
    HashSet<A> unique = new HashSet<A>();
    unique.addAll(list);
    result.addAll(unique);
    return result;
}
```
Fonction générique qui ajoute des éléments à hashset pour les rendre uniques, puis de les déposer à TreeSet trier. Vous pouvez l'utiliser avec: TreeSet<A> ts1 = getTreeSet(list);.

Cette approche fonctionne bien pour une liste fixe.

@BalusC Non, cela suppose
```
public class A implements Comparable<A> {

    private String field1;
    private String field2;

    @Override
    public int compareTo(A o) {
        //No null checks, because it's illegal anyways.
        int tmp = 0;
        if ((tmp = field1.compareToIgnoreCase(o.field1)) != 0)
            return tmp;
        if ((tmp = field2.compareToIgnoreCase(o.field2)) != 0)
            return tmp;
        return tmp;
    }
    //getters, setters but no equals and hashcode
}
```
Cela suppose que equals() et hashCode() est mis en œuvre sur A.
Je wounder comment vous avez déchiffré : A extends Comparable<?>.
Ah j'ai raté cette partie. Eh bien, j'ai compris que la modification de la A n'est pas une option. Seulement je ne comprends pas comment les HashSet est nécessaire dans cet exemple.
A n'est pas déclarée comme final, de sorte qu'il peut extend Un et de l'utiliser à la place.
L'extension de A implique plus de changements dans le reste du code à l'aide de la classe. Si il est aussi utilisé en interne par certaines 3ème partie de l'API, alors il pourrait ne pas être une option viable.

OriginalL'auteur Margus

Si votre intention est de faire deux niveaux de tri(première: Numéro de téléphone, et la deuxième:Nom de), vous pouvez utiliser le code suivant, où le double contrôle est effectué à la fois contre le champs(champ1 et champ2). Comme nous sommes déjà à l'aide de compareTo pour les deux champs, il n'est pas nécessaire d'utiliser est égal à et hashcode. Mais il est toujours une bonne pratique à utiliser hashcode et est égal à.

public class A implements Comparable<A> {

private String field1;
private String field2;

public A(String number, String name) {
    this.field1 = number;
    this.field2 = name;
}

//First level sorting will be done by field1. 
//If field1 is equal then second level sorting will be done on field2
@Override
public int compareTo(A o) {
    int compareTo = field1.compareTo(o.getNumber());
    if(compareTo==0){
        return field2.compareTo(o.getName());
    }
    return compareTo;
}

public String getNumber() {
    return field1;
}

public String getName() {
    return field2;
}

}

OriginalL'auteur Jagadeesh

 import java.util.ArrayList;
import java.util.Arrays;
import java.util.Set;
import java.util.TreeSet;
import java.util.Comparator;
import java.util.List;
public class RemoveDuplicate {
public static void main(String[] args) {
Set<Student> set = new TreeSet<Student>();
List<Student> students = Arrays.asList(new Student("Student1", "1005"), new Student("Student2", "1004"),
new Student("Student3", "1003"), new Student("Student6", "1002"), new Student("Student5", "1001"),
new Student("Student6", "1000"));
//Sorting Using Lambda
students.sort(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
return s1.getId().compareTo(s2.getId());
}
});
System.out.println(students);
set.addAll(students);
System.out.println("\n***** After removing duplicates *******\n");
final ArrayList<Student> newList = new ArrayList<Student>(set);
/** Printing original list **/
System.out.println(newList);
}
}
class Student implements Comparable<Student> {
private String name;
private String id;
public Student(String name, String id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@Override
public String toString() {
return "\n" + "Name=" + name + "   Id=" + id;
}
@Override
public int compareTo(Student o1) {
if (o1.getName().equalsIgnoreCase(this.name)) {
return 0;
}
return 1;
}
//public static Comparator<Student> StudentIdComparator = (Student
//s1,Student s2) -> s1.getId().compareTo(s2.getId());
}

Tri Basée sur l'ID et la Suppression des Doublons Basé sur le Nom

OriginalL'auteur shyam sanju

Vous devez vous connecter pour publier un commentaire.