aufführen

Eine Sammlung mit Elementreihenfolge wie ein Array
- ArrayList
- LinkedList
Vektor (ArrayList bevorzugt verwenden)

ArrayList

Elemente können später hinzugefügt oder gelöscht werden
cf: Array ist nicht möglich
Auf das Lesen und Schreiben (Direktzugriff) des Wertes nach Indexwert kann in einer bestimmten Zeit unabhängig von der Position zugegriffen werden **
** Das häufige Einfügen und Löschen von Werten ist langsam **
Die Neuzuweisung des Speichers erfolgt automatisch, wenn der zum Zeitpunkt des Einfügens reservierte Speicherbereich überschritten wird.
→ ** Wenn die Anzahl der Elemente im Voraus erwartet wird, deklarieren wir die Größe **
var data = new ArrayList <String> (30);


import java.util.ArrayList;
import java.util.Arrays;
public class Main {
  public static void main(String[] args) {
    var list = new ArrayList<Integer>(Arrays.asList(10, 15, 30, 60));
    var list2 = new ArrayList<Integer>(Arrays.asList(1, 5, 3, 6));
    var list3 = new ArrayList<Integer>(Arrays.asList(1, 2, 3));

    for (var i : list) {
      System.out.println(i / 5); //2,3,6,12
    }
    //Elementanzahl
    System.out.println(list.size()); //4
    //Holen Sie sich das 0. Element
    System.out.println(list.get(0)); //10
    //Enthält es das angegebene Element?
    System.out.println(list.contains(30)); //true
    //Ort finden
    System.out.println(list.indexOf(30));  //2
    //Suche nach Position von hinten
    System.out.println(list.lastIndexOf(30)); //2
    //Ist die Liste leer?
    System.out.println(list.isEmpty());    //false
    //0. Element löschen
    System.out.println(list.remove(0));   //10
    System.out.println(list);             //[15, 30, 60]
    //Sammlung einfügen
    list.addAll(list2);
    System.out.println(list); //[15, 30, 60, 1, 5, 3, 6]
    //Löschen Sie alle Elemente in der Sammlung
    list.removeAll(list3);
    System.out.println(list); //[15, 30, 60, 5, 6]
    //0. Elementsatz
    list.set(0, 100);
    var data = list.toArray();
    System.out.println(Arrays.toString(data)); //[100, 30, 60, 5, 6]
  }
}

LinkedList

** Referenzelemente mit bidirektionalen Links **
Nicht zum Lesen und Schreiben von Elementen nach Indexwert geeignet
Das Einfügen / Löschen von Elementen ist schnell
Keine Notwendigkeit, Elemente zu bewegen, nur Austausch der vorderen und hinteren Glieder
** Elemente nacheinander einfügen, Zugriffsliste in der Reihenfolge **: ** LinkedList **
** Vorhandene Elemente abrufen oder neu schreiben **: ** ArrayList **

import java.util.Arrays;
import java.util.LinkedList;

public class Main {
  public static void main(String[] args) {

    var list = new LinkedList<String>(Arrays.asList("丑", "Tora", "U."));
    list.addFirst("Kind");
    list.addLast("Tatsu");
    System.out.println(list); //[Kind,丑,Tora,U.,Tatsu]
    System.out.println(list.getFirst()); //Kind
    System.out.println(list.getLast()); //Tatsu
    System.out.println(list.removeFirst()); //Kind
    System.out.println(list.removeLast()); //Tatsu
    System.out.println(list); //[丑,Tora,U.]
  } 
}

einstellen

Elemente können nicht dupliziert werden. Wird verwendet, wenn Sie an der Aufnahme von Elementen interessiert sind
- HashSet
- LinkedHashSet
- TreeSet

HashSet

Verwalten Sie die Bestellung nicht

import java.util.Arrays;
import java.util.HashSet;

public class Main {
  public static void main(String[] args) {
    //Doppelte Elemente ignorieren
    var hs = new HashSet<Integer>(Arrays.asList(1, 20, 30, 10, 30, 60, 15));
    var hs2 = new HashSet<Integer>(Arrays.asList(10 ,20 ,99));

    //System.out.println(hs);
    System.out.println(hs.size()); //6
    System.out.println(hs.isEmpty()); //false
    //Enthält es ein bestimmtes Element?
    System.out.println(hs.contains(1)); //true  
    //Enthält es alle angegebenen Elemente?
    System.out.println(hs.containsAll(hs2)); //false
    //Löschen Sie das angegebene Element
    System.out.println(hs.remove(1)); //true 
    System.out.println(hs); //[20, 10, 60, 30, 15]
    //Wenn das angegebene Element nicht in der Menge enthalten ist, fügen Sie alle hinzu (Summenmenge)
    hs.addAll(hs2);
    System.out.println(hs); //[99, 20, 10, 60, 30, 15]
    //Löschen Sie alle Nichtelemente in der Sammlung (Produktsatz).
    hs.retainAll(hs2);
    System.out.println(hs); //[99, 20, 10]
    
    var hs3 = new HashSet<Integer>(Arrays.asList(1, 10 , 20));
    //Löschen Sie alle angegebenen Elemente(Differenz gesetzt)
    hs.removeAll(hs3);
    System.out.println(hs);  //[99]
  }
}

TreeSet

Sortiertes Set
Zusätzliche Elemente werden automatisch sortiert

import java.util.Arrays;
import java.util.TreeSet;

public class Main {
  public static void main(String[] args) {
    var ts = new TreeSet<Integer>(Arrays.asList(1, 20, 30, 10, 60, 15));
    System.out.println(ts); //[1, 10, 15, 20, 30, 60]
    //In umgekehrter Reihenfolge sortieren
    System.out.println(ts.descendingSet()); //[60, 30, 20, 15, 10, 1]
    //Holen Sie sich das kleinste über dem angegebenen Element
    System.out.println(ts.ceiling(15));     //15
    //Holen Sie sich das größte kleiner als das angegebene Element
    System.out.println(ts.lower(15));       //10
    //Holen Sie sich mehr als angegebene Elemente
    System.out.println(ts.tailSet(15));     //[15, 20, 30, 60]
    //Holen Sie sich diejenigen, die kleiner als das angegebene Element sind, einschließlich derjenigen, die im zweiten Argument true gleich sind
    System.out.println(ts.headSet(30, true)); //[1, 10, 15, 20, 30]
  }
}

Karte

Verwalten mit eindeutigen Schlüssel / Wert-Paaren
Zugriff auf Informationen per Schlüssel anstelle von Index
Erbt die Collection-Schnittstelle nicht (Map kann nicht so wie sie ist an die Erweiterung übergeben werden)
- HashMap
- IdentityHashMap
- WeakHashMap
- LinkedHashMap
- TreeMap
HashTable (HashMap hat Priorität)

HashMap

Die Schlüsselbestellung kann nicht garantiert werden
Objekte mit interner Hash-Tabelle verwalten
** Hash-Wert ist ein beliebiger Int, der basierend auf dem Objektwert berechnet wird **
Gleiche Objekte haben gleiche Hashwerte
Hinweis 1: ** Implementierung der hashCode-Methode **
Methode zum Ermitteln des Hashwerts eines Objekts
** Objekte mit demselben Wert geben denselben Hashwert zurück **
** Ordnungsgemäß verteilt, um Doppelarbeit zu vermeiden **
Hinweis 2: ** Hash-Tabellengröße **
** Groß genug für die Anzahl der zu speichernden Elemente **
Die Neuzuweisung von Hash-Tabellen erfolgt, wenn Elemente eine bestimmte Größe überschreiten
- var data = new HashMap<String,String>(30, 0.8F)

import java.util.HashMap;
import java.util.Map;


public class Main {
  public static void main(String[] args) {
    var map = new HashMap<String, String>(Map.of("Cat", "Katze",
      "Dog", "Inu", "Bird", "Tori"));
    //Ist der angegebene Schlüssel enthalten?
    System.out.println(map.containsKey("Dog")); //true
    //Gibt an, ob der angegebene Wert enthalten ist
    System.out.println(map.containsValue("Katze")); //true
    //Ist die Karte leer?
    System.out.println(map.isEmpty()); //false
    //Holen Sie sich alle Schlüssel
    for (var key : map.keySet()) {
      System.out.println(key); //Dog Bird Cat
    }
    //Holen Sie sich alle Werte
    for (var value : map.values()) {
      System.out.println(value); //Inutori Katze
    }
    //Ändern Sie den Wert des angegebenen Schlüssels in value
    map.replace("Cat", "neko");
    //Angegebener Schlüsselwert/Wert(old)Wert(new)ändern
    map.replace("Bird", "Tori", "tori");
    //Holen Sie sich alle Elemente
    for (var entry : map.entrySet()) {
      System.out.println(entry.getKey() + ":" + entry.getValue()); //Dog:Inu Bird:tori Cat:neko
    }
  }
}

IdentityHashMap

IdentityHashMap ** Schlüssel nach Identität beurteilen (== Operator) **
vgl.: Standard-HashMap wird ** nach Gleichheit beurteilt (Gleichheitsmethode) **

//Wenn bei HashMap der Wert gleich ist, wird er überschrieben und nur ein Eintrag registriert.
//Für IdentityHashMap Schlüssel1,Da 2 ein anderes Objekt ist, wird es als ein anderer Schlüssel angesehen.
import java.util.HashMap;
import java.util.IdentityHashMap;
public class Main {
  public static void main(String[] args) {
    var key1 = Integer.valueOf(256);
    var key2 = Integer.valueOf(256);

    //var data = new HashMap<Integer, String>() {
    var data = new IdentityHashMap<Integer, String>() {
      {
        put(key1, "Hoge");
        put(key2, "Foo");
      }
    };  
    //System.out.println(data); //{256=Foo} 
    System.out.println(data);   //{256=Foo, 256=Hoge}
  }
}

WeakHashMap

Schlüssel mit ** schwachen Referenzen verwalten **
Wenn der Schlüssel außerhalb der aktuellen Karte nicht referenziert wird, wird er einer Speicherbereinigung unterzogen.
cf: Standard HashMap ist ** starke Referenz **
Nicht für die Speicherbereinigung geeignet, solange die Karte den Schlüssel enthält

TreeMap

Garantiebestellung
Verwalten Sie Schlüssel mit ** Rot-Schwarz-Baum **
** Knoten ** (Knoten)
Bis zu 2 untergeordnete Knoten pro Knoten
Linker untergeordneter Knoten <Aktueller Knoten <Rechter untergeordneter Knoten
Schließlich zu der Stelle hinzugefügt, die die Größenbeziehung des Knotens erfüllt

//Schlüssel können in lexikalischer Reihenfolge sortiert werden
import java.util.Map;
import java.util.TreeMap;

public class Main {
  public static void main(String[] args) {
    var data = new TreeMap<String, String>(Map.of("Cat", "Katze",
        "Dog", "Inu", "Bird", "Tori"));
    for (var key : data.keySet()) {
      System.out.println(key); //Bird Cat Dog
    }
  }
}

Schlüsselreihenfolge

Nach dem TreeMap-Standard werden Zeichenfolgen nach Wörterbuch und Zahlen nach Größe sortiert.
Anpassbar mit Lambda-Stil

//Nach Schlüssellänge sortieren
import java.util.TreeMap;
// import java.util.Comparator;

public class Main {
  public static void main(String[] args) {
    var data = new TreeMap<String, String>(
        (x, y) -> x.length() - y.length()
      );
//Für anonyme Klassen
//    var data = new TreeMap<String, String>(new Comparator<String>(){
//      @Override
//      public int compare(String x, String y) {
//        return x.length() - y.length();
//      }
//    });

      data.put("Cat", "Katze");
      data.put("Shiba inu", "Shiba Inu");
      data.put("Bird", "Tori");
      System.out.println(data); //{Cat=Katze, Bird=Tori, Shiba inu=Shiba Inu}
  }
}

Array / Liste sortieren

** Sortiermethode **

//Nach Zeichenfolgenlänge in aufsteigender Reihenfolge sortieren
import java.util.ArrayList;
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {  

    var data = new String[] { "Cat", "Shiba inu", "Bird", "Poodle" };
    Arrays.sort(data, (x, y) -> x.length() - y.length());
    System.out.println(Arrays.toString(data)); //[Cat, Bird, Poodle, Shiba inu]

    var list = new ArrayList<String>(Arrays.asList("Cat", "Shiba inu", "Bird", "Poodle"));
    list.sort((x, y) -> x.length() - y.length());
    System.out.println(list); //[Cat, Bird, Poodle, Shiba inu]
  }
}

Ungenaue Suche

** Holen Sie sich mit der NavigateMap-Oberfläche einen Schlüssel in der Nähe dieses Schlüssels **

import java.util.TreeMap;

public class Main {
  public static void main(String[] args) {
    var data = new TreeMap<String, String>() {
      {
        put("nekko", "Nekko");
        put("nezumi", "Maus");
        put("night", "Nacht");
        put("nature", "Natur");
      }
    };

    var key = "neko";

    if (data.containsKey(key)) {
      System.out.println(key + "Ist" + data.get(key) + "ist.");
    } else {
      System.out.print("Das Wort, nach dem Sie suchen");
      //Holen Sie sich den größten Eintrag mit einem Schlüssel, der kleiner als der angegebene Schlüssel ist
      System.out.print(data.lowerKey(key) + "Oder");
      //Holen Sie sich den kleinsten Eintrag mit einem Schlüssel, der größer als der angegebene Schlüssel ist
      System.out.print(data.higherKey(key));
      System.out.println("Ist es?");
    }
  }
}

LinkedHashMap

Schlüssel mit Linkliste verwalten

import java.util.LinkedHashMap;

public class Main {
  public static void main(String[] args) {
    //Drittes Argument=true ist die Zugriffsreihenfolge
    //Drittes Argument=false ist die Einfügereihenfolge
    var data = new LinkedHashMap<String, String>(10, 0.7f, false) {
      {
        put("aaa", "AIUEO");
        put("bbb", "Kakikukeko");
        put("ccc", "SA Shi Su Se So.");
        put("ddd", "TA Chi Tsu Te zu");
      }
    };
    System.out.println(data.get("ccc"));
    System.out.println(data.get("aaa"));
    System.out.println(data.get("bbb"));
    System.out.println(data.get("ddd"));
    //true
    System.out.println(data); //{ccc=SA Shi Su Se So., aaa=AIUEO, bbb=Kakikukeko, ddd=TA Chi Tsu Te zu}
    //false
    //System.out.println(data); //{aaa=AIUEO, bbb=Kakikukeko, ccc=SA Shi Su Se So., ddd=TA Chi Tsu Te zu}
  }
}

Stapel / Warteschlange

Spezialisiert auf das Ein- und Ausgeben von Werten an beiden Enden der Liste
** Stapel **: Last In First Out (LIFO: Last In First Out / FILO: First In Last Out)
Auszug aus der letzten Operation (Vorgang rückgängig machen usw.)
** Warteschlange **: First In First Out (FIFO)
Auszug aus dem ersten Element (** Warteschlange **)
** Deque-Schnittstelle **: Warteschlange für beide Enden
Sie können Elemente am Anfang / Ende der Liste hinzufügen / abrufen
- ArrayDeque
- LinkedList
- Stack

ArrayDeque

Im Inneren befindet sich ** kreisförmiges Array **
Speichern Sie Elemente in einem beliebigen Bereich (Kopf ~ Schwanz) im Array
Einfügen / Löschen eines Elements ** Verschiebt nur die Anfangs- / Endposition, ohne das Element zu ändern **
Wenn die Endposition aufgrund des Einfügens das Ende des Arrays überschreitet ** Zyklus zum Anfang des Arrays **
Schneller Zugriff auf das erste Element
Deque ist eine Subschnittstelle von Queue, daher kann auch die Queue-Methode verwendet werden

import java.util.ArrayDeque;

public class Main {
  public static void main(String[] args) {
    //Stapel
    var data = new ArrayDeque<Integer>();
    data.addLast(10);
    data.addLast(15);
    data.addLast(30);

    System.out.println(data); //[10, 15, 30]
    System.out.println(data.removeLast()); //30
    System.out.println(data); //[10, 15]
    //Warteschlange
    var data2 = new ArrayDeque<Integer>(); 
    data2.addLast(10);
    data2.addLast(15);
    data2.addLast(30);

    System.out.println(data2); //[10, 15, 30]
    System.out.println(data2.removeFirst()); //10
    System.out.println(data2); //[15, 30]
  }
}

[Java] Sammlungsliste / Set / Map / Stack / Queue

aufführen

einstellen

Karte

Schlüsselreihenfolge

Array / Liste sortieren

Ungenaue Suche

Stapel / Warteschlange