[Java] Sammlungsframework

Was ist eine Sammlung?

• ** Satz von Objekten **
• java.utul-Paket: Bietet generische Klassen / Schnittstellen (** Sammlungsframework **) für die Arbeit mit Sammlungsstrukturen
• Ich möchte es zuerst verwenden, wenn ich mich mit einer Reihe von Objekten befasse

Sammlungsschnittstelle

• Grundlagen des Sammlungsrahmens
• Implementierungsklasse für jede Subschnittstelle
• ** Liste **: Bestellt, Elemente können dupliziert werden
• ArrayList: Array mit variabler Länge
• LinkedList: Liste der verknüpften Strukturen
• ** Set **: Elemente können nicht dupliziert werden
• HashSet: Elementmenge in beliebiger Reihenfolge gespeichert
• LinkedHashSet: Elementmenge, die in der Reihenfolge der Hinzufügung gespeichert ist
• TreeSet: Elementmenge sortiert nach Schlüssel
• ** Warteschlange **: Erstes / Letztes Element hinzufügen / entfernen. Verwendung für Warteschlange / Stapel
• ArrayDeque: Warteschlange für beide Enden
• LinkedList: Wie LinkedList
• ** Map **: Verwalten nach Schlüssel / Wert, keine doppelten Schlüssel
• HashMap: Grundlegende Karte
• TreeMap: Karte nach Schlüssel sortiert

Sammlungsinstanziierung

• List<String> data = new ArrayList<>();

** Oberflächentyp **

• Sie können die Abhängigkeit von der Klasse minimieren, indem Sie den Schnittstellentyp anstelle des Variablentyps (Implementierungstyp) verwenden.
• NG Beispiel: Es ist nicht gut, den reellen Zahlentyp als Argument zu übergeben, da es sich um
  ArrayList <String> data = new ArrayList <> ();
  `public void run (ArrayList data) {…} handelt. ``
• → ** Wenn Sie von Anfang an List <String> als Schnittstellentyp festlegen, können Sie problemlos zu LinkedList wechseln! ** ** **
• List<String> data = new LinkedList<>();

** Generische Syntax **

• ** Mechanismus zum Binden generischer Klassen / Methoden an bestimmte Typen **
• Im Fall von List <String> wird dem Allzwecktyp (List) eine Zeichenfolge zugewiesen, die zu einer ** Liste ** wird, in der Zeichenketten gespeichert werden!
• Umgekehrt betrachten nicht generische Sammlungen alle Elemente als Objekttypen (alle Typen können zugewiesen werden), erfordern eine explizite Typumwandlung und können keine unbeabsichtigten Typwerte erkennen. ..
  Strng str = (String) data.get (0)
• → ** Verwenden Sie eine typsichere Generika-Syntax! ** ** **
• Optional, wenn der Elementtyp auf der linken Seite offensichtlich ist (** Diamantoperator **)
  List <String> data = new ArrayList <> ();

Idiom

Initialisieren Sie die Sammlung zum Zeitpunkt der Instanziierung

import java.util.ArrayList;
public class Main {
  public static void main(String[] args) {
    //Anonyme Klasse
    var data = new ArrayList<String>() {
      //Initialisierungsblock
      {
        add("neko");
        add("inu");
        add("tori");
      }
    };
    System.out.println(data);//[neko, inu, tori]
  }
}

Prozess in Sammlung in der Reihenfolge mit Erweiterung für

• Intern Syntaxzucker der while-Anweisung mit ** Iterator ** (vereinfachte Syntax)
• Iterator-Schnittstellenmethoden
• ** hasNext **: Bestätigung der Existenz der folgenden Elemente
• ** next **: Verschieben und zum nächsten Element gelangen
• ** entfernen **: Aktuelles Element entfernen

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>() {
      {
        add("neko");
        add("inu");
        add("kuma");
      }
    };
    //Prozess unter Abholung in der richtigen Reihenfolge
    for (var s : data) {
      System.out.println(s); //neko inu kuma
    }
    //Bei Verwendung eines Iterators
    //     var itr = data.iterator();
    //     while (itr.hasNext()) {
    //      System.out.println(itr.next());
    //     }
  }
}

Löschen Sie Elemente in einer Schleife

• Beachten Sie, dass die Erweiterung für zu "ConcurrentModificationException" führt

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>() {
      {
        add("neko");
        add("inu");
        add("niwatori");
      }
    };

    var ite = data.iterator();
    while (ite.hasNext()) {
      System.out.println(ite.next()); //neko inu niwatori
      ite.remove();
    }
    System.out.println(data); //[]
  }
}

//NG Beispiel:Erweiterung für
    for (var s : data) {
      System.out.println(s);
      data.remove(s);
    }

Lesen Sie die Liste in umgekehrter Reihenfolge

• Holen Sie sich das ListIterator-Objekt mit der listIterator-Methode
• ** vorherige Methode **: Zum vorherigen Element wechseln
• ** hasPrevious-Methode **: Bestätigen Sie die Existenz des vorherigen Elements
• Geben Sie die Startposition für das Lesen im Argument listIterator an

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>() {
      {
        add("neko");
        add("inu");
        add("shimaenaga");
      }
    };
    //Stellen Sie das Ende auf die Startposition
    var ite = data.listIterator(data.size());
    while (ite.hasPrevious()) {
      System.out.println(ite.previous()); //shimaenaga inu neko
    }
  }
}

Array- und Sammlungskonvertierung

• Grundsätzlich ist die Menge der Objekte ** eher eine Sammlung als ein Array ** (Affinität zur objektorientierten Syntax)

Vom Array zur Liste

• ** asList-Methode **
• Die konvertierte Liste ist nur ein Array, das die Liste abdeckt!
• Änderungen an der Liste wirken sich auf das ursprüngliche Array aus und können nicht zur Liste hinzugefügt oder daraus entfernt werden
• → ** Mit der Collections.addAll-Methode duplizieren **

//NG Beispiel: Vorhandene Zeichenfolge in Liste konvertieren, Wert in konvertierte Liste hinzufügen und löschen
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
    var data = new String[] { "cat", "dog", "bird"};
    var list = Arrays.asList(data);
    list.set(0, "neko");
    System.out.println(list); //[neko, dog, bird]
    System.out.println(Arrays.toString(data)); //[neko, dog, bird]
    //list.add("inu"); //UnsupportedOperationException
    //list.remove(0);  //UnsupportedOperationException
  }
}

//OK Beispiel: Konvertieren Sie eine vorhandene Zeichenfolge in eine Liste, fügen Sie der konvertierten Liste Werte hinzu und löschen Sie sie
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Main {
  public static void main(String[] args) {
    var data = new String[] { "cat", "dog", "bird" };
    var list = new ArrayList<String>();
    Collections.addAll(list, data);
    list.set(0, "neko");
    list.add("inu");
    System.out.println(list); //[neko, dog, bird, inu]
    list.remove(1);

    System.out.println(list); //[neko, bird, inu]
    System.out.println(Arrays.toString(data)); //[cat, dog, bird]
  }
}

Von der Sammlung zum Array

• ** toArray-Methode **
• Legen Sie alle Elemente fest, wenn sie in das Argumentarray passen
• Wenn es nicht passt, generieren Sie dasselbe Array wie das Argument und setzen Sie dann alle Elemente
• Wenn das Auflistungselement nicht in ein Array-Element konvertiert werden kann, geben Sie "ArrayStoreException" ein
• Da die Elemente bis zum letzten kopiert werden, wirken sich Operationen in der Liste der Konvertierungsquellen nicht auf das Array aus.

import java.util.ArrayList;
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>(Arrays.asList("cat", "dog", "bird"));
    //Kopieren Sie den Inhalt in ein Array mit der gleichen Größe wie die Liste
    var strs = new String[data.size()];
    data.toArray(strs);
    //Fügen Sie nur Daten zur Konvertierungsquellenliste hinzu
    data.set(0, "neko");
    System.out.println(Arrays.toString(strs)); //[cat, dog, bird]
    //Nur die Liste der Konvertierungsquellen hat sich geändert
    System.out.println(data); //[neko, dog, bird]
  }
}

In eine unveränderliche Sammlung konvertieren

• ** nicht modifizierbare Methode **
• Wenn Sie versuchen, es zu ändern, "UnsupportedOperationException"
• Wenn es sich bei dem Element um einen Referenztyp handelt, können Inhaltsänderungen (z. B. StringBuilder) möglicherweise nicht eingeschränkt werden.
• Of Methode kann auch direkt unveränderliche Sammlung generieren (Java 9 oder höher)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>(Arrays.asList("cat", "dog", "bird"));
    //Unveränderliche Liste erstellen
    var udata = Collections.unmodifiableList(data);
    udata.set(0, "neko"); //UnsupportedOperationException
    udata.add("inu");  //UnsupportedOperationException
  }
}

//Der Inhalt von Sammlungselementen kann in StringBuilder geändert werden
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<StringBuilder>(Arrays.asList(
        new StringBuilder("Hallo"),
        new StringBuilder("Kame-san"),
        new StringBuilder("Yo")));
    var udata = Collections.unmodifiableList(data);
    udata.get(0).append("Kameyo");
    System.out.println(udata); //[Hallo,Kame-san,Yo]
  }
}

//Unveränderliche Sammlung, die direkt von der of-Methode generiert wird
import java.util.List;
public class Main {
  public static void main(String[] args) {
    var data = List.of("cat", "dog", "bird");
    System.out.println(data);
    data.set(0, "neko"); //UnsupportedOperationException
  }
}

Leere Sammlungsgenerierung

• Wenn der Rückgabewert eine Erfassungsmethode ist, wenn der Rückgabewert leer ist ** Gibt die Sammlung anstelle von null zurück **
• ** emptyList / emptySet / emptyMap-Methode **
• return Collections.emptyList();

Synchronisierte Sammlungsgenerierung

• ** Synchronisierte Sammlung **: Methode zur Unterstützung mehrerer Threads (= exklusive Verarbeitung)
• ** synchronizedCollection / synchronizedList / synchronizedSet / synchronizedMap-Methode **
• Kann sicher in einer Multithread-Umgebung verwendet werden (= ** thread-sicher **)
• var data = Collections.synchronizedList(new ArrayList<String>());
• Bessere parallele Sammlungsgenerierung
  • CopyOnWriteArrayList / CopyOnWriteArraySet / ConcurrentHashMap
• var map = new ConcurrentHashMap<String,String>();