Wie definiere ich den Vergleicher auf SortedSet <> wie TreeSet <>?

Question

Ich mag eine lexikalische sortierte Liste von Strings machen, also ging ich mit dem Grunde SortedSet

1) Set<String> words = new SortedSet<String>(){} 

und erkennen, dass SortedSet eine abstrakte Klasse ist, in dem ich die comapartor Methode zu implementieren. Also ging ich und suchte auf Google und fand heraus, dass TreeSet besser ist, und ich kann seine vordefinierte Vergleichsmethode verwenden.

2) SortedSet<String> words = new TreeSet<String>(){} 

Als ich zu Java Docs ging, erkannte ich, dass TreeSet AbstractSet statt SortedSet erweitert. Frage 1 - Kann jemand erklären, wie die 2. Zeile noch funktioniert (wie ich verallgemeinere nicht das Set, das ich normalerweise tun würde, stattdessen verwende ich zwei völlig verschiedene Klassen ohne Eltern Kind Beziehung). Frage 2 - wie definiert man Komparator von SortedSet, die als TreeSet arbeiten wird. Also hier ist der Arbeits Code mit TreeSet

SortedSet<String> words = new TreeSet<>(); 
    Scanner scanner1 = new Scanner(System.in); 
    String s1 = scanner1.nextLine(); 
    int a = scanner1.nextInt(); 
    while(s1.length()>a){ 
     words.add(s1.substring(0,a)); 
     s1 = s1.substring(a); 
    } 
    Iterator itr = words.iterator(); 
    while(itr!= null&&itr.hasNext()){ 
     System.out.println(itr.next()); 
    } 

Normalen Eingang

welcometojava 
3 

Erwartete Ausgabe

com 
eto 
jav 
wel 

Bearbeiten-1 Für die Antwort der Frage 2, erwarte ich so etwas wie diese

Set<String> words = new SortedSet<String>() { 
     @Override 
     public Comparator<? super String> comparator() { 
      return null; 
     } 
     ...... 

Ich möchte im Grunde lernen, wie man einen grundlegenden Komparator "wie" in TreeSet während SortedSet? Ich verstehe, dass, wenn es eine natürliche Ordnung gibt, ich keinen neuen Komparator definieren muss.

Answer 1

Antwort 1:

TreeSet<T> implementiert die NavigableSet<T>-Schnittstelle, die Set<T>SortedSet<T>, die auch erweitert erstreckt.

Die Schnittstellen selbst sortieren nicht wirklich, die konkrete Klasse tut es.

So:

Set<String> myStrings = new TreeSet<>(); 
// Add a bunch of strings 
// ... 
for (String s : myStrings) { 
System.out.println(s); 
} 

würden Sie sie noch in sortierter Reihenfolge haben.

Antwort 2:

Zum einen für Klassen, die bereits Comparable<T> implementieren, können Sie die Comparator für die TreeSet, als „natürliche Ordnung“ auslassen wird durch die Verwendung der Comparable<T> ‚s compareTo Methode gemeint.

Ansonsten können Sie eine Comparator Instanz als der TreeMap Konstruktor erstes Argument liefern:

Set<String> myStrings = new TreeSet<>(new Comparator<String>() { 
     @Override 
     public int compare(String o1, String o2) { 
      // Define comparing logic here 
      return o1.compareTo(o2); 
     } 
    }); 

oder verwenden Java 8 Lambdas:

Set<String> myStrings = new TreeSet<>((o1, o2) -> o1.compareTo(o2)); 

Answer 2

TreeSet implementiert NavigableSet, was wiederum SortedSet erweitert, weshalb Zeile 2) funktioniert. Siehe TreeSet Java doc.

Für den zweiten Teil, versuchen Sie dies:

SortedSet<String> ts = new TreeSet<String>(new TSComparator()); 

class TSComparator implements Comparator<String>{ 

    @Override 
    public int compare(String str1, String str2) { 
     return str1.compareTo(str2); 
    } 

} 

Answer 3

Ihre Frage zu beantworten,

TreeSet implementiert auch NavigableSet die SortedSet

public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, java.io.Serializable 

public interface NavigableSet<E> extends SortedSet<E> 

standardmäßig Art erweitert wird geschehen, basierend auf natürliche Reihenfolge und die grundlegenden primitiven Wrapper (Integer, Long, ...) implementiert Comparable Schnittstelle, also keine Notwendigkeit, diezu implementieren, wenn die Sammlung hält Wrapper von Primitives und natürliche Ordnung zu erwarten ist

Aber Ihre benutzerdefinierte Klasse sollte Vergleichbare implementieren, wenn es in TreeSet sonst ClassCastException bestellt werden sollte, wird geworfen werden, sobald Sie das zweite Element hinzufügen

Answer 4

SortedSet<T> keine ist abstrakte Klasse, es ist eine Schnittstelle.

TreeSet<T> tut SortedSet<T> implementieren, aber nicht direkt: die Kette der Erbschaft geht wie folgt:

Set<T>-SortedSet<T> - NavigableSet<T>

Deshalb ist die Zuordnung SortedSet<String> words = new TreeSet<String>() Werke: TreeSet<T> ist ein NavigableSet<T> und NavigableSet<T> ist a SortedSet<T>, so ist die Zuordnung legal.

Wenn Sie keinen expliziten Komparator angeben, verwendet TreeSet<T> 's natürliche Reihenfolge, die von T' s Implementierung von Comparable<T> geliefert wird.