Hauptinhalt
Datenstruktur
List集合
Set集合
Collections
Unterrichtsziele
能够说出List集合特点
能够说出常见的数据结构
能够说出数组结构特点
能够说出栈结构特点
能够说出队列结构特点
能够说出单向链表结构特点
能够说出Set集合的特点
能够说出哈希表的特点
使用HashSet集合存储自定义元素
能够说出可变参数的格式
能够使用集合工具类
能够使用Comparator比较器进行排序
Kapitel 1 Datenstruktur
2.1 Wozu dient die Datenstruktur?
Wenn Sie die Containerklassen in Java verwenden, haben Sie jemals darüber nachgedacht, wie ArrayList wie ein unendlich expandierendes Array oder wie eine verknüpfte Liste ist
. Einfach zu verwenden? Einfach zu bedienen, dies ist die Verwendung der Datenstruktur, aber Sie verwenden sie unwissentlich.
Realer Speicher, die Werkzeuge und Modelle, die wir verwenden. Jede Datenstruktur hat ihre eigenen Vor- und Nachteile. Denken Sie darüber nach, ob die von Google verwendeten Daten
Arrays von Speicher verwenden. Können wir die benötigten Daten leicht finden? Der Algorithmus, wie das schnellste Einfügen, Suchen und Löschen
unter so vielen Daten durchgeführt wird , wird ebenfalls schneller ausgeführt.
Unser Java ist eine objektorientierte Sprache, genau wie ein automatisches Auto, und die C-Sprache ist wie ein manueller Jeep. Was ist mit der Datenstruktur? Es ist das Funktionsprinzip des Getriebes. Sie
können ein automatisches Auto von Punkt A nach Punkt B fahren, ohne zu wissen, wie das Getriebe funktioniert, und es darf nicht langsamer sein als jemand, der es weiß. Das Schreiben von Programmen ist
dasselbe wie das Autofahren. Erfahrung kann eine große Rolle spielen. Wenn Sie jedoch nicht wissen, wie die unterste Schicht funktioniert, können Sie jederzeit fahren und weder
ein Auto reparieren noch bauen. Natürlich ist der Datenstrukturinhalt relativ groß und es ist relativ zeitaufwändig, im Detail zu studieren, und es ist unmöglich, ihn über Nacht zu erreichen. Wir werden allgemeine Datenstrukturen einführen
: Stapel, Warteschlangen, Arrays, verknüpfte Listen und rot-schwarze Bäume. Als Einführung in Datenstrukturen verstehen Sie einfach deren Eigenschaften
.
2.2 Gemeinsame Datenstrukturen
Übliche Strukturen für die Datenspeicherung sind: Stapel, Warteschlangen, Arrays, verknüpfte Listen und rot-schwarze Bäume. Schauen wir uns das separat an:
Stapel
栈：stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其
他任何位置进行添加、查找、删除等操作。
Einfach ausgedrückt: Unter Verwendung der Struktur der Sammlung weist der Zugriff auf Elemente die folgenden Merkmale auf
先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹
夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的
子弹。
栈的入口、出口的都是栈的顶端位置。
Hier sind zwei Substantive, die Aufmerksamkeit benötigen:
Schieben des Stapels: Es bedeutet, Elemente zu speichern. Das heißt, das Element wird an der oberen Position des Stapels gespeichert, und die vorhandenen Elemente im Stapel werden nacheinander um eine Position nach unten verschoben.
Pop den Stapel: nimm einfach das Element. Das heißt, das Element an der oberen Position des Stapels wird herausgenommen, und die vorhandenen Elemente im Stapel bewegen sich nacheinander um eine Position an die Oberseite des Stapels.
Warteschlange
队列：queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，
而在表的另一端进行删除。
Einfach ausgedrückt weist der Zugriff auf Elemente unter Verwendung dieser strukturierten Menge die folgenden Merkmale auf:
先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，小火车过山
洞，车头先进去，车尾后进去；车头先出来，车尾后出来。
Der Eingang und Ausgang der Warteschlange nehmen jeweils eine Seite ein. In der folgenden Abbildung ist beispielsweise die linke Seite der Eingang und die rechte Seite der Ausgang.
Array
数组:Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出
租屋，有 100 个房间，从 001 到 100 每个房间都有固定编号，通过编号就可以快速找到租房子的人。
Einfach ausgedrückt weist der Zugriff auf Elemente mithilfe dieser strukturierten Sammlung die folgenden Merkmale auf:
查找元素快：通过索引，可以快速访问指定位置的元素
Das Hinzufügen und Löschen von Elementen ist langsam
Element an der angegebenen Indexposition hinzufügen: Sie müssen ein neues Array erstellen, das angegebene neue Element an der angegebenen Indexposition speichern und dann das ursprüngliche Array-Element rooten
Kopieren Sie gemäß dem Index an die entsprechende Indexposition des neuen Arrays. Wie nachfolgend dargestellt
Geben Sie die Indexposition an, um das Element zu löschen: Es muss ein neues Array erstellt werden, und das ursprüngliche Array-Element wird an die Position kopiert, die dem Index des neuen Arrays gemäß dem Index entspricht
Das Element an der angegebenen Indexposition im ursprünglichen Array wird nicht in das neue Array kopiert. Wie nachfolgend dargestellt
Verknüpfte Liste
链表:linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时i动态生成。每
个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。我们常说的
链表结构有单向链表与双向链表，那么这里给大家介绍的是单向链表。
Einfach ausgedrückt weist der Zugriff auf Elemente unter Verwendung dieser strukturierten Menge die folgenden Merkmale auf:
Mehrere Knoten sind über Adressen verbunden. Wenn beispielsweise mehrere Personen Hände halten, verwendet jede Person ihre rechte Hand, um nacheinander die linke Hand der Person zu halten
In Analogie sind mehrere Personen miteinander verbunden.
Langsame Suche nach Elementen: Um ein Element zu finden, müssen Sie die verbundenen Knoten durchsuchen und nacheinander nach dem angegebenen Element suchen
Schnelles Hinzufügen und Löschen von Elementen:
Element hinzufügen: Es muss nur die Adresse des nächsten Elements geändert werden.
Element löschen: Es muss nur die Adresse des nächsten Elements geändert werden.
Roter schwarzer Baum
二叉树：binary tree ,是每个结点不超过 2 的有序树（tree） 。
Ein einfaches Verständnis ist eine Struktur, die dem Baum in unserem Leben ähnlich ist, außer dass jeder Knoten höchstens zwei untergeordnete Knoten haben kann.
Ein Binärbaum ist eine Baumstruktur mit höchstens zwei Teilbäumen pro Knoten. Der obere Knoten wird als Wurzelknoten bezeichnet, und die beiden Seiten werden als "linker Teilbaum" und "rechter Teilbaum" bezeichnet.
Wie gezeigt:
Es handelt sich um einen interessanteren Binärbaum, der als rot-schwarzer Baum bezeichnet wird. Der rot-schwarze Baum selbst ist ein binärer Suchbaum. Nach dem Einfügen eines Knotens befindet sich der Baum noch
Es ist ein binärer Suchbaum. Dies bedeutet, dass die Schlüsselwerte des Baums noch in Ordnung sind.
Rot-Schwarz-Baum-Einschränkungen:
1. Knoten können rot oder schwarz sein
2. Der Wurzelknoten ist schwarz
3. Blattknoten (insbesondere leere Knoten) sind schwarz
4. Die untergeordneten Knoten jedes roten Knotens sind schwarz
5. Die Anzahl der schwarzen Knoten auf allen Pfaden von einem Knoten zu jedem Blattknoten ist gleich
Merkmale von rot-schwarzen Bäumen:
Die Geschwindigkeit ist extrem hoch und nähert sich dem ausgeglichenen Baum. Die minimale und maximale Anzahl von Blattelementen beträgt nicht mehr als das Doppelte
Kapitel 2 Listensammlung
Nachdem wir die Verwendung der Collection-Oberfläche beherrschen, werfen wir einen Blick auf die Unterklassen in der Collection-Oberfläche. Welche Eigenschaften haben sie?
Als Nächstes lernen wir einige häufig verwendete Unterklassen in Collection kennen (Sammlung java.util.List, Sammlung java.util.Set).
1.1 Einführung in die List-Oberfläche
Die Schnittstelle java.util.List erbt von der Collection-Schnittstelle und ist ein wichtiger Zweig der einspaltigen Collection. Es ist üblich,
die Objekte, die die List-Schnittstelle implementieren, als List-Collection zu bezeichnen. Doppelte Elemente sind in der List-Auflistung zulässig. Alle Elemente werden linear gespeichert
. Auf das angegebene Element in der Auflistung kann über den Index im Programm zugegriffen werden . Ein weiteres Merkmal der List-Sammlung besteht darin, dass die Elemente sortiert sind, dh die Reihenfolge, in der die Elemente gespeichert und herausgenommen werden, ist dieselbe.
Lassen Sie uns nach dem Lesen der API Folgendes zusammenfassen:
Funktionen der Benutzeroberfläche auflisten:
1. 它是一个元素存取有序的集合。例如，存元素的顺序是 11 、 22 、 33 。那么集合中，元素的存储就是按照 11 、
22 、 33 的顺序完成的）。
2. Es handelt sich um eine Sammlung mit einem Index, und die Elemente in der Sammlung können über den Index genau bearbeitet werden (aus demselben Grund wie der Index des Arrays).
3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
tips:我们在基础班的时候已经学习过List接口的子类java.util.ArrayList类，该类中的方法都是来自List中定
义。
1.2 Allgemeine Methoden in der List-Oberfläche
Als Unterschnittstelle der Collection-Auflistung erbt List nicht nur alle Methoden in der Collection-Schnittstelle, sondern fügt auch einige
eindeutige Methoden zum Betreiben der Auflistung basierend auf dem Elementindex wie folgt hinzu:
public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
public E get(int index):返回集合中指定位置的元素。
public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
Die einzigartigen Methoden der List-Auflistung beziehen sich alle auf den Index. Wir haben ihn in der Basisklasse gelernt. Lassen Sie uns ihn daher noch einmal überprüfen:
public^ class^ ListDemo {
public static void main(String[] args) {
// 创建List集合对象
List<String> list = new ArrayList<String>();
// 往 尾部添加 指定元素
list.add("图图");
list.add("小美");
list.add("不高兴");
System.out.println(list);
// add(int index,String s) 往指定位置添加
list.add( 1 ,"没头脑");
System.out.println(list);
// String remove(int index) 删除指定位置元素 返回被删除元素
// 删除索引位置为 2 的元素
System.out.println("删除索引位置为 2 的元素");
System.out.println(list.remove( 2 ));
System.out.println(list);
// String set(int index,String s)
// 在指定位置 进行 元素替代（改）
// 修改指定位置元素
list.set( 0 , "三毛");
System.out.println(list);
// String get(int index) 获取指定位置元素
// 跟size() 方法一起用 来 遍历的
for(int i = 0 ;i<list.size();i++){
System.out.println(list.get(i));
}
//还可以使用增强for
for (String string : list) {
Kapitel 3 Unterklassen der Liste
3.1 ArrayList-Sammlung
Die Struktur des Datenspeichers der Sammlung java.util.ArrayList ist eine Array-Struktur. Das Hinzufügen und Löschen von Elementen ist langsam und das Suchen schnell. Da die in der täglichen Entwicklung
am häufigsten verwendeten Funktionen das Abfragen von Daten und das Durchlaufen von Daten sind, ist ArrayList die am häufigsten verwendete Sammlung.
Viele Programmierer verwenden ArrayList, um Anforderungen während der Entwicklung sehr beiläufig zu erfüllen, und sind nicht streng. Diese Verwendung wird nicht empfohlen.
3.2 LinkedList-Sammlung
java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。
LinkedList是一个双向链表，那么双向链表是什么样子的呢，我们用个图了解下
In der tatsächlichen Entwicklung umfasst das Hinzufügen und Löschen eines Auflistungselements häufig erste und letzte Operationen, und LinkedList bietet eine große Anzahl von ersten und letzten Operationen.
Wir können diese Methoden verstehen als:
public void addFirst(E e):将指定元素插入此列表的开头。
public void addLast(E e):将指定元素添加到此列表的结尾。
public E getFirst():返回此列表的第一个元素。
public E getLast():返回此列表的最后一个元素。
public E removeFirst():移除并返回此列表的第一个元素。
public E removeLast():移除并返回此列表的最后一个元素。
public E pop():从此列表所表示的堆栈处弹出一个元素。
public void push(E e):将元素推入此列表所表示的堆栈。
public boolean isEmpty()：如果列表不包含元素，则返回true。
for (String string : list) {
System.out.println(string);
}
}
}
LinkedList ist eine Unterklasse von List. Die Methoden LinkedList in List sind alle verfügbar. Wir werden sie hier nicht im Detail vorstellen. Wir müssen nur
die eindeutigen Methoden von LinkedList verstehen . Während der Entwicklung kann die LinkedList-Auflistung auch als Stapel- oder Warteschlangenstruktur verwendet werden. (Verstehe einfach)
Methodendemonstration:
Kapitel 4 Schnittstelle einstellen
java.util.Set java.util.List-Schnittstellen und -Schnittstellen, wie sie von der Collection-Schnittstelle geerbt wurden, die mit der Collection of Party im
Grunde dieselbe Methode verbindet, und keine Erweiterung der Collection-Schnittstellenfunktion, jedoch strenger als die Collection-Schnittstelle . Im Gegensatz zur List-Schnittstelle
sind die Elemente in der Set-Schnittstelle ungeordnet, und bestimmte Regeln werden verwendet, um sicherzustellen, dass sich die gespeicherten Elemente nicht wiederholen.
Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet这两个集合。
tips:Set集合取出元素的方式可以采用：迭代器、增强for。
3.1 Einführung in die HashSet-Sammlung
java.util.HashSet ist eine Implementierungsklasse der Set-Schnittstelle. Die darin gespeicherten Elemente sind nicht wiederholbar und die Elemente sind alle ungeordnet (dh die Zugriffsfolge ist
inkonsistent). Die zugrunde liegende Implementierung von java.util.HashSet ist eigentlich eine Unterstützung von java.util.HashMap. Da wir es noch nicht gelernt haben,
lösen wir es zuerst .
HashSet bestimmt den Speicherort des Elements in der Auflistung anhand des Hashwerts des Objekts, sodass es einen guten Zugriff und eine gute Suchleistung bietet.
Die Art und Weise, wie die Eindeutigkeit des Elements sichergestellt wird, hängt vom HashCode und den Methoden equals ab.
Lassen Sie uns zuerst Set Collection Storage verwenden, das Phänomen betrachten und dann das Prinzip erklären:
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<String> link = new LinkedList<String>();
//添加元素
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
System.out.println(link);
// 获取元素
System.out.println(link.getFirst());
System.out.println(link.getLast());
// 删除元素
System.out.println(link.removeFirst());
System.out.println(link.removeLast());
while (!link.isEmpty()) { //判断集合是否为空
System.out.println(link.pop()); //弹出集合中的栈顶元素
}
System.out.println(link);
}
}
public class HashSetDemo {
public static void main(String[] args) {
//创建 Set集合
Die Ausgabe lautet wie folgt, was darauf hinweist, dass doppelte Elemente nicht in der Sammlung gespeichert werden können:
tips:根据结果我们发现字符串"cba"只存储了一个，也就是说重复的元素set集合不存储。
2.2 Datenstruktur des HashSet-Sammlungsspeichers (Hash-Tabelle)
Was ist eine Hash-Tabelle?
Vor JDK 1.8 wurde die unterste Ebene der Hash-Tabelle durch Array + verknüpfte Liste implementiert, dh die verknüpfte Liste wurde zur Behandlung von Konflikten verwendet, und die verknüpften Listen mit demselben Hashwert wurden in einer verknüpften Liste gespeichert.
Wenn sich jedoch viele Elemente in einem Bucket befinden, dh wenn viele Elemente mit gleichen Hashwerten vorhanden sind, ist die Effizienz der sequentiellen Suche nach Schlüsselwerten gering. In JDK1.8 wird die
Speicherung von Hash- Tabellen durch Array + verknüpfte Liste + rot-schwarzer Baum realisiert. Wenn die Länge der verknüpften Liste den Schwellenwert (8) überschreitet, wird die verknüpfte Liste in einen rot-schwarzen Baum konvertiert, wodurch die Suchzeit erheblich verkürzt
wird.
Einfach ausgedrückt wird die Hash-Tabelle durch ein Array + eine verknüpfte Liste + einen rot-schwarzen Baum implementiert (JDK1.8 fügt den rot-schwarzen Baumteil hinzu), wie in der folgenden Abbildung gezeigt.
Wenn Sie dieses Bild sehen, muss jemand fragen, wie dieses gespeichert ist.
Um das Verständnis für alle zu erleichtern, erklären wir dies anhand eines Speicherflussdiagramms:
HashSet<String> set = new HashSet<String>();
//添加元素
set.add(new String("cba"));
set.add("abc");
set.add("bac");
set.add("cba");
//遍历
for (String name : set) {
System.out.println(name);
}
}
}
cba
abc
bac
Alles in allem optimiert die Einführung von rot-schwarzen Bäumen in JDK1.8 die Leistung von HashMap erheblich, sodass wir sicherstellen müssen, dass die Eindeutigkeit der HashSet-Auflistungselemente
tatsächlich gemäß den Methoden hashCode und equals des Objekts bestimmt wird. Wenn wir ein benutzerdefiniertes Objekt in der Auflistung speichern,
müssen wir zur Sicherstellung seiner Eindeutigkeit die Methoden hashCode und equals überschreiben, um eine Vergleichsmethode zu erstellen, die zum aktuellen Objekt gehört.
2.3 HashSet speichert benutzerdefinierte Typelemente
Wenn Sie benutzerdefinierte Typelemente in HashSet speichern, müssen Sie die Methoden hashCode und equals im Objekt neu schreiben und eine eigene Vergleichsmethode
erstellen, um sicherzustellen, dass die Objekte in der HashSet-Auflistung eindeutig sind
Erstellen Sie eine benutzerdefinierte Schülerklasse
public^ class^ Student {
private String name;
private int age;
public Student() {
}}
public Student (String name, int age) { this.name = name; this.age = Alter; }}
public String getName () { return name; }}
public void setName (String name) { this.name = name; }}
public int getAge () { Rückgabealter; }}
public void setAge (int age) { this.age = age; }}
@Override
public boolean equals (Object o) { if (this == o) return true; if (o == null || getClass ()! = o.getClass ()) gibt false zurück; Student Student = (Student) o; Rückgabealter == student.age && Objects.equals (name, student.name); }}
@Override
public int hashCode () { return Objects.hash (Name, Alter); } }
öffentliche Klasse HashSetDemo2 { public static void main (String [] args) { // Sammlungsobjekt erstellen In dieser Sammlung werden Objekte vom Typ Student gespeichert. HashSet stuSet = new HashSet (); // Student speichern stu = new Student ("Yuqian", 43) ; stuSet.add (stu); stuSet.add (neuer Schüler ("郭德刚", 44)); stuSet.add (neuer Schüler ("于谦", 43)); stuSet.add (neuer Schüler ("郭 麒麟"), 23)); stuSet.add (stu);
für (Student stu2: stuSet) {
2.3 LinkedHashSet
Wir wissen, dass HashSet garantiert, dass die Elemente eindeutig sind, aber die Elemente in keiner Reihenfolge gespeichert werden. Was sollten wir also tun, um die Reihenfolge sicherzustellen?
Unter HashSet gibt es eine Unterklasse java.util.LinkedHashSet, eine Datenspeicherstruktur, die eine verknüpfte Liste und eine Hash-Tabelle kombiniert.
Der Demo-Code lautet wie folgt:
1.9 Variable Parameter
Wenn wir nach JDK1.5 eine Methode definieren, die mehrere Parameter akzeptieren muss und die mehreren Parametertypen gleich sind, können wir sie auf das folgende Format vereinfachen
Formel:
In der Tat ist dieses Schreiben völlig gleichbedeutend mit
Nur die letztere Definition muss das Array beim Aufruf übergeben, und die erstere kann Daten direkt übergeben.
Nach JDK1.5. Vereinfachte Operationen sind erschienen. … Wird für Parameter verwendet, die als variable Parameter bezeichnet werden.
System.out.println(stu2);
}
}
}
执行结果：
Student [name=郭德纲, age= 44 ]
Student [name=于谦, age= 43 ]
Student [name=郭麒麟, age= 23 ]
public class LinkedHashSetDemo {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<String>();
set.add("bbb");
set.add("aaa");
set.add("abc");
set.add("bbc");
Iterator<String> it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
结果：
bbb
aaa
abc
bbc
Modifikator Rückgabewert Typ Methodenname (Parametertyp ... formaler Parametername) {}
Modifikator Rückgabewert Typ Methodenname (Parametertyp [] formaler Parametername) {}
Es stellt auch ein Array dar. Wenn Sie diese Methode jedoch mit variablen Parametern aufrufen, müssen Sie kein Array erstellen (dies ist die Einfachheit) und die Elemente direkt zum Array hinzufügen
Tatsächlich übergibt die kompilierte Klassendatei diese Elemente als tatsächliche Parameter und kapselt sie in ein Array, bevor sie übergeben wird. Diese Aktionen werden
beim Kompilieren der .class-Datei automatisch ausgeführt.
Code-Demo:
tips: 上述add方法在同一个类中，只能存在一个。因为会发生调用的不确定性
注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末
尾位置。
Kapitel 5 Sammlungen
2.1 Allgemeine Funktionen
java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：
public class ChangeArgs {
public static void main(String[] args) {
int[] arr = { 1 , 4 , 62 , 431 , 2 };
int sum = getSum(arr);
System.out.println(sum);
// 6 7 2 12
// 求 这几个元素和 6 7 2 12
int sum2 = getSum( 6 , 7 , 2 , 12 , 2121 );
System.out.println(sum2);
}
/*
* 完成数组 所有元素的求和 原始写法
public static int getSum(int[] arr){
int sum = 0;
for(int a : arr){
sum += a;
}
return sum;
}
*/
//可变参数写法
public static int getSum(int... arr) {
int sum = 0 ;
for (int a : arr) {
sum += a;
}
return sum;
}
}
public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排
序。
Code-Demo:
Nach der Code-Demonstration haben wir festgestellt, dass unsere Sammlung in der richtigen Reihenfolge angeordnet ist. Diese Reihenfolge ist jedoch die Standardreihenfolge. Wenn Sie die Reihenfolge angeben möchten, dann
Wie es geht?
Wir haben festgestellt, dass es eine andere Methode gibt, die nicht erwähnt wird: die öffentliche statische Leersortierung (Listenliste, Komparator <? Super T>):
Sortieren Sie die Elemente in der Sammlung nach den angegebenen Regeln. Erklären Sie als nächstes die Anordnung der angegebenen Regeln.
2.2 Komparator
Lassen Sie uns zuerst diese Methode studieren
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
Aber diesmal ist es ein String-Typ.
public class CollectionsDemo {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
//原来写法
//list.add(12);
//list.add(14);
//list.add(15);
//list.add(1000);
//采用工具类 完成 往集合中添加元素
Collections.addAll(list, 5 , 222 , 1 ， 2 );
System.out.println(list);
//排序方法
Collections.sort(list);
System.out.println(list);
}
}
结果：
[ 5 , 222 , 1 , 2 ]
[ 1 , 2 , 5 , 222 ]
Ergebnis:
Wir verwenden die Standardregeln, um die Zeichenfolgen zu sortieren. Wie werden die Standardregeln definiert?
Apropos Sortieren, um es einfach auszudrücken: Vergleichen Sie die Größe zwischen zwei Objekten. Dann gibt es zwei Möglichkeiten, die Implementierung in JAVA zu vergleichen. Eine ist starrer
Verwenden Sie die Schnittstelle java.lang.Comparable, um eine zu erreichen. Eine ist flexibel, wenn ich die Sortierung in der ausgewählten
Schnittstelle java.util.Comparator durchführen muss, um den Vorgang abzuschließen.
Dann erfordert die Sortierung nach der von uns verwendeten Methode der öffentlichen statischen Leersortierung (Listenliste) tatsächlich, dass der Typ sortiert wird. Sie
muss die Schnittstelle Comparable implementieren, um die Vergleichsfunktion abzuschließen. Der String-Typ lautet wie folgt:
Die String-Klasse implementiert diese Schnittstelle und vervollständigt die Definition der Vergleichsregeln. Dies erschwert jedoch das Schreiben dieser Regel. Wenn die Zeichenfolge beispielsweise
in absteigender Reihenfolge des ersten Zeichens sortiert werden soll, muss der Quellcode von String geändert werden. Dies ist unmöglich, also können wir zu diesem Zeitpunkt verwenden
Die Methode der öffentlichen statischen Leersortierung (Listenliste, Komparator <? Super T>) wird flexibel ausgeführt. Hierbei handelt es sich um die
Komparatorschnittstelle, die sich im Paket java.util befindet. Die Sortierung ist eine der Funktionen, die der Komparator implementieren kann. Diese Schnittstelle stellt dar Ein Komparator, der
Komparator ist vergleichbar! Wie der Name schon sagt, handelt es sich um eine Sortierung. In Laienbegriffen ist es notwendig, zwei Objekte zu vergleichen, die an erster Stelle stehen und an zweiter Stelle stehen. Dann lautet die Vergleichsmethode:
public int compare(String o1, String o2)：比较其两个参数的顺序。
两个对象比较的结果有三种：大于，等于，小于。
如果要按照升序排序， 则o1 小于o2，返回（负数），相等返回 0 ， 01 大于 02 返回（正数） 如果要按照
降序排序 则o1 小于o2，返回（正数），相等返回 0 ， 01 大于 02 返回（负数）
Die Operation ist wie folgt:
public class CollectionsDemo2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("cba");
list.add("aba");
list.add("sba");
list.add("nba");
//排序方法
Collections.sort(list);
System.out.println(list);
}
}
[aba, cba, nba, sba]
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
public class CollectionsDemo3 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("cba");
list.add("aba");
list.add("sba");
list.add("nba");
//排序方法 按照第一个单词的降序
Collections.sort(list, new Comparator<String>() {
Die Ergebnisse sind wie folgt:
2.3 Beschreiben Sie kurz den Unterschied zwischen Comparable- und Comparator-Schnittstellen.
Vergleichbar: Sortieren Sie die Objekte jeder Klasse, die sie implementiert, zwangsweise. Diese Sortierung wird als natürliche Sortierung der Klasse bezeichnet, und die compareTo-Methode der Klasse
wird als natürliche Vergleichsmethode bezeichnet. Sie können compareTo () nur einmal in einer Klasse implementieren und den Code der Klasse nicht häufig ändern, um die gewünschte Sortierung zu erzielen. Die
Liste der Objekte (und Arrays), die diese Schnittstelle implementieren , kann automatisch nach Collections.sort (und Arrays.sort) sortiert werden. Die Objekte können als
Schlüssel in einer geordneten Karte oder als Elemente in einer geordneten Menge verwendet werden, ohne einen Komparator anzugeben.
Der Komparator sortiert ein Objekt zwangsweise als Ganzes. Der Komparator kann an die
Sortiermethode (z. B. Collections.sort oder Arrays.sort) übergeben werden, um eine genaue Kontrolle über die Sortierreihenfolge zu ermöglichen. Sie können Comparator auch verwenden, um die Reihenfolge bestimmter Datenstrukturen (z. B. geordnete Mengen oder
geordnete Karten) zu steuern oder um Sammlungen von Objekten zu sortieren, die keine natürliche Reihenfolge haben.
2.4 Übung
Erstellen Sie eine Schülerklasse und speichern Sie sie in der ArrayList-Auflistung, um den angegebenen Sortiervorgang abzuschließen.
Schüler Anfangsklasse
@Override
public int compare(String o1, String o2) {
return o2.charAt( 0 ) ‐ o1.charAt( 0 );
}
});
System.out.println(list);
}
}
[sba, nba, cba, aba]
public class Student{
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
Testkategorie:
Es wurde festgestellt, dass das Programm einen Fehler gemeldet hat, als wir die Collections.sort () -Methode aufgerufen haben.
Grund: Wenn die Elemente in der Auflistung sortiert werden sollen, müssen Sie die Schnittstelle Comparable implementieren.
Daher haben wir eine Implementierung der Schülerklasse wie folgt abgeschlossen:
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Demo {
public static void main(String[] args) {
// 创建四个学生对象 存储到集合中
ArrayList<Student> list = new ArrayList<Student>();
list.add(new Student("rose", 18 ));
list.add(new Student("jack", 16 ));
list.add(new Student("abc", 16 ));
list.add(new Student("ace", 17 ));
list.add(new Student("mark", 16 ));
/ *
Sortieren Sie die Schüler in aufsteigender Reihenfolge nach Alter
* /
// Collections.sort(list);//要求 该list中元素类型 必须实现比较器Comparable接口
for (Student student : list) {
System.out.println(student);
}
}}
}}
Testen Sie erneut, der Code ist in Ordnung und der Effekt ist wie folgt:
2.5 Erweiterung
Wenn Sie unabhängige Definitionsregeln verwenden möchten, können Sie mit Collections.sort (Listenliste, Vergleicher c) Ihre eigenen
Regeln definieren :
bewirken:
Wenn Sie weitere Regeln wünschen, können Sie auf den folgenden Code verweisen:
public class Student implements Comparable<Student>{
....
@Override
public int compareTo(Student o) {
return this.age‐o.age;//升序
}
}
Student{name='jack', age= 16 }
Student{name='abc', age= 16 }
Student{name='mark', age= 16 }
Student{name='ace', age= 17 }
Student{name='rose', age= 18 }
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o2.getAge()‐o1.getAge();//以学生的年龄降序
}
});
Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='jack', age=16}
Student{name='abc', age=16}
Student{name='mark', age=16}
Der Effekt ist wie folgt:
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// 年龄降序
int result = o2.getAge()‐o1.getAge();//年龄降序
if(result== 0 ){//第一个规则判断完了 下一个规则 姓名的首字母 升序
result = o1.getName().charAt( 0 )‐o2.getName().charAt( 0 );
}
return result;
}
});
Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='abc', age=16}
Student{name='jack', age=16}
Student{name='mark', age=16}