entfernen Sie doppelte Zeichenfolgen in einer Liste in Java

Update:
Ich denke HashSet.add(Object obj) nicht nennen contains. gibt es eine Möglichkeit, das umzusetzen, was ich will(entfernen dup strings groß - /Kleinschreibung ignorieren mit Set)?

Ursprünglichen Frage:
versuchen zu entfernen dups aus einer Liste von Strings in java ist, jedoch in den folgenden code CaseInsensitiveSet.contains(Object ob) ist nicht immer genannt, warum?

public static List<String> removeDupList(List<String>list, boolean ignoreCase){
    Set<String> set = (ignoreCase?new CaseInsensitiveSet():new LinkedHashSet<String>());
    set.addAll(list);

    List<String> res = new Vector<String>(set);
    return res;
}


public class CaseInsensitiveSet  extends LinkedHashSet<String>{

    @Override
    public boolean contains(Object obj){
        //this not getting called.
        if(obj instanceof String){

            return super.contains(((String)obj).toLowerCase());
        }
        return super.contains(obj);
    }

}

Bitte lernen, wie man code formatieren, anstatt mit <pre> Aussagen.
Warum haben Sie sich wischen meine edits?
Wollen Sie behalten die Reihenfolge der strings in der Liste? Wenn ja, für Duplikate, wollen Sie, um die position des ersten oder letzten auftreten?

InformationsquelleAutor user121196 | 2012-12-26

5

contains ist nicht genannt, als LinkedHashSet ist nicht implementiert, die Art und Weise.

Wenn Sie möchten, dass add () - Aufruf enthält (), die Sie benötigen, um es zu überschreiben, wie gut.

Der Grund, warum es nicht umgesetzt, auf diese Weise ist, dass der Aufruf enthält zunächst würde bedeuten, dass Sie zwei lookups statt einer, die wäre langsamer.

InformationsquelleAutor Peter Lawrey

Versuchen

        Set set = new TreeSet(String.CASE_INSENSITIVE_ORDER);
        set.addAll(list);
        return new ArrayList(set);

UPDATE aber als Tom Anderson erwähnt, ist es nicht die Erhaltung der ursprünglichen Ordnung, wenn das ist wirklich ein Problem, versuchen

    Set<String> set = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
    Iterator<String> i = list.iterator();
    while (i.hasNext()) {
        String s = i.next();
        if (set.contains(s)) {
            i.remove();
        }
        else {
            set.add(s);
        }
    }

Drucke

[2, 1]

Wenn der Fragesteller schert sich nicht um die Erhaltung der Ordnung in der Liste, dann ist dies eine ausgezeichnete Antwort. Wenn er das tut, ist traurig, es ist lediglich ein guter.
Richtig, siehe mein update
Beste Antwort. +1

InformationsquelleAutor Evgeniy Dorofeev

3

add() Methode der LinkedHashSet nicht nennen contains() intern andere Methode gewesen wäre, genannt.

Statt einer LinkedHashSet, warum spielst du nicht ein SortedSet mit der groß-und Kleinschreibung Komparator
? Mit der String.CASE_INSENSITIVE_ORDER Komparator

Ihren code reduziert sich auf
```
public static List<String> removeDupList(List<String>list, boolean ignoreCase){
    Set<String> set = (ignoreCase?new TreeSet<String>(String.CASE_INSENSITIVE_ORDER):new LinkedHashSet<String>());
    set.addAll(list);

    List<String> res = new ArrayList<String>(set);
    return res;
}
```
Wenn Sie möchten, beibehalten der Reihenfolge, wie @tom anderson angegeben in seinem Kommentar, die Sie verwenden können, ein Hilfs-LinkedHashSet für die Bestellung.

Können Sie versuchen, hinzufügen das element TreeSet, wenn es true zurück, auch hinzufügen, Sie zu LinkedHashSet sonst nicht.
```
public static List<String> removeDupList(List<String>list){
        Set<String> sortedSet = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
        List<String> orderedList = new ArrayList<String>();
        for(String str : list){
             if(sortedSet.add(str)){ //add returns true, if it is not present already else false
                 orderedList.add(str);
             }
        }
        return orderedList;
    }
```
Wie ich sagte Evgeniy Antwort, dieses nicht beibehalten die Reihenfolge der strings in der Liste, die möglicherweise oder möglicherweise keine Rolle.
Danke für den Hinweis it out. Ich aktualisierte den code zu erhalten, um von den Elementen.
Anstatt den Aufbau orderedSet und dann Konvertierung in ein ArrayList könnte man einfach den Aufbau der ArrayList direkt. Die Tatsache, dass orderedSet ist ein Satz ist nicht wirklich nötig hier.

InformationsquelleAutor Rahul

Versuchen

    public boolean addAll(Collection<? extends String> c) {
            for(String s : c) {
            if(! this.contains(s)) {
                this.add(s);
            }
        }
        return super.addAll(c);
    }
    @Override
    public boolean contains(Object o) {
        //Do your checking here
//     return super.contains(o);
    }

Dies wird sicherstellen, dass die contains-Methode wird aufgerufen, wenn Sie den code zu gehen.

InformationsquelleAutor Yogesh Patil

Hier ist ein anderer Ansatz, mit einem HashSet des strings für die Deduplizierung, doch der Aufbau der Ergebnis-Liste direkt:

public static List<String> removeDupList(List<String> list, boolean ignoreCase) {
    HashSet<String> seen = new HashSet<String>();
    ArrayList<String> deduplicatedList = new ArrayList<String>();
    for (String string : list) {
        if (seen.add(ignoreCase ? string.toLowerCase() : string)) {
            deduplicatedList.add(string);
        }
    }
    return deduplicatedList;
}

Dies ist relativ einfach, macht nur einen Durchlauf über die Elemente, und nicht nur einen Kleinbuchstaben, einen hash-lookup, und dann eine Liste Anhängen für jedes element.

InformationsquelleAutor Tom Anderson

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.