1. Sammlungen in Java
Sammlungskurse in Java sind die am häufigsten verwendeten und bequemsten Klassen in der Java -Programmierung. Als Containerklasse kann die Sammlungsklasse jede Art von Daten speichern und natürlich auch bestimmte Typen in Kombination mit Generika speichern (Generika sind jedoch nur während der Kompilierungsperiode gültig und werden zur Laufzeit gelöscht). Was in der Sammelklasse gespeichert wird, ist nur ein Hinweis auf das Objekt, kein Verweis auf das Objekt selbst. Die Kapazität der Sammlungsklasse kann während des Betriebs dynamisch erweitert werden und bietet auch viele bequeme Methoden, wie das Finden der Vereinigung und die Schnittstelle der Sammlung.
2. Sammlungsklassenstruktur
Sammlungen in Java umfassen mehrere Datenstrukturen, z. B. verknüpfte Listen, Warteschlangen, Hash -Tabellen usw. In Bezug auf die Erbschaftsstruktur einer Klasse können sie in zwei Kategorien unterteilt werden. Eine wird von der Sammlungsschnittstelle geerbt. Diese Art der Sammlung enthält Sammlungskurse wie List, Set und Warteschlange. Die andere Klasse wird von der Kartenschnittstelle vererbt, die hauptsächlich Sammlungsklassen im Zusammenhang mit Hash -Tabellen enthält. Schauen wir uns die Erbschaftsstrukturdiagramme dieser beiden Kategorien an:
1. LISTE, SETEN UND WANDEN
Die grüne gepunktete Linie in der Abbildung repräsentiert die Implementierung, die grüne durchgezogene Linie repräsentiert die Vererbung zwischen Schnittstellen und die blaue durchgezogene Linie stellt das Vererbung zwischen Klassen dar.
(1) Liste: Wir verwenden weitere Listen, einschließlich ArrayList und LinkedList. Der Unterschied zwischen diesen beiden ist ebenfalls sehr offensichtlich, was aus ihren Namen ersichtlich ist. Die zugrunde liegende ArrayList wird über Arrays implementiert, sodass die Zufallszugriffsgeschwindigkeit relativ schnell ist, die Effizienz ist jedoch in Fällen, in denen häufige Ergänzungen und Löschungen erforderlich sind, relativ niedrig. Für die LinkedList wird die zugrunde liegende Ebene durch verknüpfte Listen implementiert, sodass der Zugangs- und Löschvorgang einfacher zu vervollständigen ist, aber die Effizienz des Zufallszugriffs ist relativ niedrig.
Schauen wir uns zunächst die Insertionseffizienz von beiden an:
Paket com.paddx.test.collection; import Java.util.ArrayList; importieren java.util.linkedList; public class listetest {public static void main (String [] args) {für (int i =; i <; i ++) {} long start = system.currentTimillis (); LinkedList <NeGeger> (); for (int i =; i <; i ++) {linkedList.add (, i);} Long End = System.currentTimillis (); System.out.println (Ende - Start); i =; i <; i ++) {ArrayList.Add (, i);} System.out.println (System.currentTimillis () - Ende);}}Hier sind die Ergebnisse der lokalen Ausführung:
Dreiundzwanzig
1227
Es ist ersichtlich, dass in diesem Fall die Insertionseffizienz der LinkedList viel höher ist als die von ArrayList, natürlich ist dies eine relativ extreme Situation. Vergleichen wir die Effizienz des Zufallszugriffs zwischen den beiden:
Paket com.paddx.test.collection; import Java.util.ArrayList; importieren java.util.linkedlist; importieren java.util.random; LinkedList <Gesinger> (); for (int i =; i <; i ++) {linkedList.add (i);} ArrayList <Ganzzahl> ArrayList = new ArrayList <GanzEger> (); für (int i =; i <; i ++) {arrayList.add (i);} long start = system.currentTimemillis (); für (int i =; i <; i ++) {int j = random.Nextint (i+); int k = linkedList.get (j);} long End = System.currentTimemillis (); System.out.Out.println (end - start); für (int i; i <; i ++) {int j = random.next (i+); ArrayList.get (j);} System.out.println (System.currentTimemillis () - Ende);}}Hier ist das Ergebnis meiner Ausführung:
5277
6
Es ist offensichtlich, dass der Zufallszugriffseffizienz von ArrayList mehrere Größenordnungen höher ist als die LinkedList. Durch diese beiden Code -Teile sollten wir in der Lage sein, den Unterschied zwischen LinkedList und ArrayList und den Anpassungsszenarien deutlicher zu wissen. Was Vector betrifft, ist es eine thread-sichere Version von ArrayList, während Stack der Stapeldatenstruktur entspricht. Diese beiden werden weniger häufig verwendet, so dass ich hier kein Beispiel geben werde.
(2) Warteschlange: Im Allgemeinen kann sie direkt mit LinkedList erfolgen. Aus dem oben genannten Klassendiagramm, das die LinkedList von Deque erbt, ist auch ersichtlich, sodass die LinkedList die Funktion einer Doppel-Warteschlange hat. Prioritätsqueue wird durch die Bereitstellung einer Priorität für jedes Element gekennzeichnet, und Elemente mit hoher Priorität werden von der Warteschlange vor Priorität eingeräumt.
(3) SET: Der Hauptunterschied zwischen Set und List besteht darin, dass die festgelegte Elemente nicht wiederholt werden können, während die Liste die Wiederholung von Elementen ermöglichen kann. Um die Wiederholung von Elementen zu beurteilen, müssen wir auf der Grundlage der Hash -Methode und der gleichmäßigen Methode des Objekts entscheiden. Dies ist auch der Grund, warum wir normalerweise die HashCode -Methode und die gleiche Methode für Elementklassen in einer Sammlung überschreiben. Nehmen wir ein Beispiel, um den Unterschied zwischen Set und Liste sowie der Rolle der HashCode -Methode und der Equals -Methode zu sehen:
Paket com.paddx.test.collection; import Java.util.ArrayList; Import Java.util.hashset; Import Java.util.set; öffentliche Klasse Setting {public static void main (String [] args) {Person p1 = New Person ("LXP", 10); Person p2 = new Person ("lxp", 10) p3 = p3 = new person ("new person (" lxp ", 10) p3 = p3 = new person (" new person ("lxp", 10; Person ("lxp", 20); ArrayList <Person> list = new ArrayList <Person> (); list.add (p1); System.out.println ("--------------"); list.add (p2); list.size ()); system.out.println ("---------------"); set <Person> set = new Hashset <person> (); set.add (p1); System.out.println ("-------------------------------------------- size = "+set.size ());} statische Klasse Person {private String name; private int age; public person (String name, int age) {this.name = name; this.age = älter;}@oversidepublic boolean Equals (Objekt O) {System.out.println (" CALL Equals (). ! Die Ausführungsergebnisse des obigen Codes sind wie folgt:
------------
------------
Listgröße = 3
---- Divide Line ----
Rufen Sie HashCode (), Alter = 10 an
------------
Rufen Sie HashCode (), Alter = 10 an
Call Equals (); name = lxp
------------
Rufen Sie HashCode (), Alter = 20 an
SET SIZE = 2
Aus den Ergebnissen werden keine zusätzlichen Vorgänge ausgeführt, wenn das Element zur Liste hinzugefügt wird und wiederholt werden kann. Bevor Sie sich anschließen, müssen Sie zuerst die HashCode -Methode ausführen. Wenn der zurückgegebene Wert bereits im Satz vorhanden ist, müssen Sie die Equals -Methode weiter ausführen. Wenn das von der Equals -Methode zurückgegebene Ergebnis ebenfalls wahr ist, beweist es, dass das Element bereits existiert und das neue Element vom alten Element überschrieben wird. Wenn der zurückgegebene HashCode -Wert unterschiedlich ist, fügen Sie den Satz direkt hinzu. Denken Sie hier daran, dass für Elemente in einer Sammlung Elemente mit unterschiedlichen Hashcode -Werten ungleich sein müssen, aber für Elemente mit ungleichem HashCode -Werten können die gleichen sein.
Der Unterschied zwischen Hashset und LinkedHashset besteht darin, dass letzteres sicherstellen kann, dass die Reihenfolge der in den Satz eingefügten Elemente mit der Ausgangsreihenfolge übereinstimmt. Der Unterschied zwischen Tresset besteht darin, dass seine Sortierung im Komparator sortiert ist und standardmäßig in der natürlichen Reihenfolge der Zeichen in aufsteigender Reihenfolge angeordnet ist.
(4) ITERABLE: Aus dieser Abbildung können Sie sehen, dass die Sammlungsklasse iterable erbt. Die Funktion dieser Schnittstelle besteht darin, Element-Traversal bereitzustellen, dh alle Sammlungsklassen (mit Ausnahme von MAP-bezogenen Klassen) liefern Element-Traversalfunktionen. Iterable enthält Iterator des Iterators, und sein Quellcode lautet wie folgt. Wenn Sie mit dem Iteratormodus vertraut sind, sollte dies leicht zu verstehen sein.
public interface iterator <e> {boolean hasNext (); e next (); void remove ();}2. Karte:
Der größte Vorteil der Kartentypsammlung besteht darin, dass seine Suchffizienz relativ hoch ist und die zeitliche Komplexität von O (1) idealerweise erreicht werden kann. Die am häufigsten verwendete Karte ist HashMap. Der Unterschied zwischen LinkedHasMap und HashMap besteht darin, dass der erstere sicherstellen kann, dass die Reihenfolge der in den Satz eingefügten Elemente mit der Ausgangsreihenfolge übereinstimmt. Der Unterschied zwischen diesen beiden und Treemap besteht darin, dass Treemap nach Schlüsselwerten sortiert wird. Natürlich hat seine zugrunde liegende Umsetzung auch wesentliche Unterschiede. Beispielsweise ist die zugrunde liegende Schicht von Hashmap eine Hash -Tabelle, während die zugrunde liegende Schicht von Treemap ein Baum ist. Schauen wir uns nun den Unterschied zwischen Treemap und LinkedHasMap an:
package com.paddx.test.collection;import java.util.Iterator;import java.util.LinkedHashMap;import java.util.Map;import java.util.TreeMap;public class MapTest {public static void main(String[] args) {Map<String,String> treeMap = new TreeMap<String,String>();Map<String,String> linkedMap = new LinkedHasMap <String, String> (); TREEMAP.PUT ("B", NULL); TREEMAP.PUT ("C", NULL); TREEMAP.PUT ("A", NULL); für (iterator <string> iter = TREEMAP.KEYSet (). Iterator (); iter.hasnext ();) {System.out.println ("Treemap ="+iter.next ());} System.out.prin tln ("---------- 分割线 ----------"); linkedMap.put ("B", null); linkedMap.put ("C", null); linkedMap.put ("a", null); für (Iterator <string> iter = linkedMap.keyset (). Iterator (); iter.hasnext ();) {System.out.println ("linkedHashMap ="+iter.next ());}}} Führen Sie den obigen Code aus und das Ausführungsergebnis lautet wie folgt:
TREEMAP = a
Treemap = b
Treemap = c
-------------------------
LinkedHasMap = b
LinkedHasMap = c
LinkedHasMap = a
Aus den laufenden Ergebnissen ist offensichtlich, dass der Unterschied zwischen Treemap und LinkedHasMap deutlich gesehen wird. Ersteres wird nach String -Sortierung ausgegeben, während letzteres durch Einfügungsreihenfolge ausgegeben wird. Sorgfältige Leser können feststellen, dass der Unterschied zwischen HashMap und Treemap mit den zuvor genannten Unterschieden zwischen Hashset und Treeset übereinstimmt. Bei der Durchführung von Quellcodeanalyse in Zukunft können wir feststellen, dass Hashset und Treeset im Wesentlichen durch HashMap bzw. Treemap implementiert werden, sodass ihre Unterschiede natürlich gleich sind. Hashtable wird jetzt selten verwendet. Der Hauptunterschied zu HashMap besteht darin, dass Hashtable mit Gewinde sicher ist, aber aufgrund seiner geringen Effizienz wird normalerweise Hashmap verwendet. In einer Umgebung mit mehreren Threaden wird normalerweise stattdessen CurrentHasMap verwendet.
3. Zusammenfassung
In diesem Artikel wird nur das Java -Sammlungsrahmen und seine Erbschaftsbeziehung insgesamt vorgestellt. Zusätzlich zu den oben genannten Klassen bieten Sammlungen auch zwei Werkzeugklassen: Sammlungen und Arrays. Darüber hinaus ist die Sortierung in der Sammlung eng mit vergleichbarem und vergleichbarem Zusammenhang verbunden. In einem nachfolgenden Artikel wird der oben genannte Quellcode der Klassenimplementierung in JDK im Detail analysiert.