Java lernen durch Ausprobieren!

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen:
api:documentation:collections:start

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.


—api:documentation:collections:start [2024/08/31 10:03] (aktuell) – angelegt - Externe Bearbeitung 127.0.0.1
Zeile 1: Zeile 1:
 +====== Collections ======
 +<WRAP center round info 80%>
 +Das **Collections-Framework** bietet Klassen zum Speichern von Listen, Maps (Schlüssel-Wert-Speicher), Sets (Mengen) und Stacks (Stapelspeichern). Mit Hilfe von **Generics** kann man den Datentyp der zu speichernden Objekte bei der Deklaration der Collection angeben, so dass man die Daten ohne Casten gleich mit dem richtigen Datentyp zurückerhält, z.B.
 +<code myJava>
 +ArrayList<String> liste = new ArrayList<>();    // <String> bedeutet: Diese ArrayList speichert Objekte der Klasse String. 
 +liste.add("Test");
 +String t = liste.get(0);
 +</code>
 +Man kann alle Collections-Klassen aber auch ohne Generic-Syntax nutzen, muss dann beim Entnehmen der Objekte aber auf den korrekten Datentyp casten, z.B.
 +<code myJava>
 +ArrayList liste = new ArrayList();    // Diese Liste speichert beliebige Objekte 
 +liste.add("Test");
 +String t = <String>liste.get(0);
 +</code>
 +</WRAP>
 + \\ \\ 
 +
 +
 +===== ArrayList =====
 +<WRAP center round info 80%>
 +ArrayLists sind Listen, bei denen man in konstanter Zeit auf das i-te Element lesend zugreifen kann. Dafür ist das Speichern von Werten manchmal etwas langsamer. \\ \\ 
 +Im "Inneren" haben ''ArrayList'' Objekte ein Array, das etwas größer dimensioniert ist als die Anzahl der in der ''ArrayList'' enthaltenen Elemente. Ist das Array voll, dann wird ein deutlich größeres Array reserviert, und anschließend werden die Elemente vom alten in das neue Array kopiert. Das alte Array wird danach verworfen. \\ \\ 
 +Der Vorteil von ArrayLists gegenüber Arrays besteht darin, dass Anfangs keine Maximalgröße festgelegt werden muss. Dafür brauchen die ArrayLists etwas mehr Speicher als Arrays und sind etwas langsamer.
 +**Methoden:**
 +  * ''add(element)'' fügt am Ende der Liste ein Element hinzu
 +  * ''get(index)'' gibt das index-te Element zurück. Das erste Element hat den Index 0.
 +  * ''add(index, element)'' fügt das Element an der Stelle ''index'' in die Liste ein und verschiebt alle nachfolgenden Elemente nach hinten.
 +  * ''size()'' gibt die Anzahl der Elemente in der Liste zurück
 +  * ''remove(element)'' entfernt - falls vorhanden - das Element aus der Liste.
 +  * ''remove(index)'' entfernt das Element mit dem angegebenen Index aus der Liste
 +  * ''clear()'' entfernt alle Elemente aus der Liste.
 +  * ''contains(element)'' gibt genau dann ''true'' zurück, wenn die Liste das Element enthält.
 +  * ''indexOf(element)'': Falls das Element in der Liste enthalten ist, wird der Index des Elements zurückgegeben, ansonsten -1.
 +  * ''addAll(liste)'' fügt der Liste alle Elemente der übergebenen Liste hinzu. Letztere wird dabei nicht verändert.
 +</WRAP>
 +
 +
 +<HTML>
 +
 +<div class="java-online" style="height: 400px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'ArrayListExample'}">
 +
 +<script type="text/plain" title="ArrayListExample.java">
 +// Das <String> bedeutet: Diese ArrayList speichert String-Objekte.
 +ArrayList<String> namen = new ArrayList(); 
 +
 +println("Gib so viele Namen ein, wie Du möchtest. Am Ende gib' x ein, dann gibt der Rechner alle eingegebenen Namen aus.");
 +while(true) {
 +   String name = Input.readString("Name:");
 +   if(name != "x") {
 +      namen.add(name); 
 +   } else {
 +      break;   // Beende die while-Wiederholung
 +   }
 +}
 +
 +for(int i = 0; i < namen.size(); i++) {
 +   println(namen.get(i));
 +}
 +
 +println("\nUnd jetzt zufällig vertauscht:");
 +Collections.shuffle(namen);
 +for (int i = 0; i < namen.size(); i++) {
 +   println(namen.get(i));
 +}
 +</script>
 +
 +</div>
 +
 +</HTML>
 +
 +
 +===== Vereinfachte for-Wiederholung =====
 +
 +<HTML>
 +
 +<div class="java-online" style="height: 400px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'ArrayListExample2'}">
 +
 +<script type="text/plain" title="ArrayListExample2.java">
 +ArrayList<String> namen = new ArrayList();   // diese ArrayList speichert String-Objekte.
 +
 +println("Gib so viele Namen ein, wie Du möchtest. Am Ende gib' x ein, dann gibt der Rechner alle eingegebenen Namen aus.");
 +while(true) {
 +   String name = Input.readString("Name:");
 +   if(name != "x") {
 +      namen.add(name); 
 +   } else {
 +      break;   // Beende die while-Wiederholung
 +   }
 +}
 +
 +// Will man über alle Elemente eines Arrays iterieren, so geht das am besten mit
 +// der vereinfachten for-Wiederholung
 +for(String n: namen) {        // Lies: "Für alle Strings n aus namen"
 +   println(n);
 +}
 +</script>
 +
 +</div>
 +
 +</HTML>
 +
 +
 +===== HashMap =====
 +<WRAP center round info 80%>
 +Hashmaps verwendet man, um Schlüssel-Wert-Paare zu speichern. Sie können bei Angabe des Schlüssels den passenden Wert finden und zurückgeben.
 +  * Die Methode put(schlüssel, wert) speichert ein Schlüssel-Wert-Paar
 +  * Die Methode get(schlüssel) liefert den zum Schlüssel gehörenden Wert zurück.
 +Wird zu einem in der ''HashMap'' schon vorhandenen Schlüssel erneut ein Schlüssel-Wert-Paar mit identischem Schlüssel gespeichert, so überschreibt es das zuvor gespeicherte Schlüssel-Wert-Paar. \\ \\ 
 +**Methoden:**
 +  * ''put(key, value)'' speichert das Schlüssel-Wert-Paar in der ''HashMap''. Existiert zum übergebenen Schlüssel schon ein Paar in der ''HashMap'', so wird es mit dem neuen Paar überschrieben.
 +  * ''get(key)'' gibt den zum Schlüssel gehörigen Wert zurück. Falls es in der ''HashMap'' zum übergebenen Schlüssel keinen Wert gibt, dann wird ''null'' zurückgegeben.
 +  * ''size()'' gibt die Anzahl der gespeicherten Schlüssel-Wert-Paare zurück.
 +  * ''clear()'' löscht alle Schlüssel-Wert-Paare aus der ''HashMap''.
 +  * ''isEmpty()'' gibt genau dann ''true'' zurück, wenn die ''HashMap'' keine Schlüssel-Wert-Paare enthält.
 +  * ''containsKey(key)'' gibt genau dann ''true'' zurück, wenn zum übergebenen Schlüssel ein Schlüssel-Wert-Paar gespeichert ist.
 +  * ''containsValue(value)'' gibt genau dann ''true'' zurück, wenn in der ''HashMap'' ein Schlüssel-Wert-Paar mit dem übergebenen Wert gespeichert ist.
 +</WRAP>
 +
 +
 +<HTML>
 +
 +<div class="java-online" style="height: 400px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'HashMapExample'}">
 +
 +<script type="text/plain" title="HashMapExample.java">
 +HashMap<String, Integer> berghöhenMap = new HashMap();     // Diese HashMap bildet String-Schlüssel auf Integer-Werte ab.
 +
 +berghöhenMap.put("Mount Everest", 8848);
 +berghöhenMap.put("K2", 8611);
 +berghöhenMap.put("Kanchenjunga", 8586);
 +berghöhenMap.put("Lhotse I", 8516);
 +
 +while(true) {
 +   String berg = Input.readString("Geben Sie einen Berg ein:");
 +   Integer höhe = berghöhenMap.get(berg);
 +   
 +   if(höhe == null) {
 +      println("Über diesen Berg habe ich leider keine Informationen gespeichert.");
 +   } else {
 +      println("Der " + berg + " ist " + höhe + " m hoch.");
 +   }
 +}
 +</script>
 +
 +</div>
 +
 +</HTML>
 +
 +
 +===== HashSet =====
 +<WRAP center round info 80%>
 +HashSets bilden Mengen aus der Mathematik nach. Wie diese können sie Elemente speichern, jedoch jedes höchstens ein Mal. \\ \\ 
 +**Methoden:**
 +  * ''add(element)'' fügt dem ''HashSet'' das Element hinzu.
 +  * ''addAll(hashSet)'' fügt dem ''HashSet'' jedes Element des übergebenen HashSets hinzu. Letzteres wird dabei nicht verändert.
 +  * ''contains(element)'' gibt genau dann ''true'' zurück, wenn sich das Element im ''HashSet'' befindet.
 +  * ''isEmpty()'' gibt genau dann ''true'' zurück, wenn das ''HashSet'' keine Elemente enthält.
 +  * ''remove(element)'' entfernt das Element - falls vorhanden - aus dem ''HashSet''.
 +  * ''clear()'' entfernt alle Elemente aus dem ''HashSet''.
 +  * ''size()'' gibt die Anzahl der Elemente im ''HashSet'' zurück.
 +</WRAP>
 +
 +
 +<HTML>
 +
 +<div class="java-online" style="height: 400px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'HashSetExample'}">
 +
 +<script type="text/plain" title="HashSetExample.java">
 +HashSet<String> set = new HashSet();   // <String> bedeutet: Dies ist ein HashSet mit String-Elementen drin.
 +
 +set.add("Max");
 +set.add("Julia");
 +set.add("Max");
 +set.add("Lisa");
 +
 +for(String name : set) {
 +   println(name);
 +}
 +
 +println();
 +println(set.contains("Max"), Color.gray);
 +println(set.contains("Martin"), Color.gray);
 +
 +println();
 +set.remove("Max");
 +for(String name : set) {
 +   println(name, Color.yellow);
 +}
 +</script>
 +
 +</div>
 +
 +</HTML>
 +
 +
 +===== Stack =====
 +<WRAP center round info 80%>
 +Ein ''Stack'' (deutsch: "Stapelspeicher" oder "Kellerspeicher", [[https://de.wikipedia.org/wiki/Stapelspeicher|siehe auch hier]]) ist eine Datenstruktur, die sich wie ein Stapel Papier verhält: Man kann beliebig viele Elemente mit der Methode ''push'' "auf den Stack legen", wobei das letzte immer "zuoberst" zum Liegen kommt. Nimmt man die Elemente mit der Methode ''pop'' wieder "vom Stack herunter", so erhält man sie in umgekehrter
 +Reihenfolge zurück, d.h. immer das oberste zuerst.  \\ \\ 
 +**Methoden:**
 +  * ''push(element)'' fügt ein Element "oben" auf dem Stack hinzu
 +  * ''pop()'' nimmt das oberste Element vom Stack und gibt es zurück
 +  * ''peek()'' gibt das oberste Element zurück, belässt es aber auf dem Stack
 +  * ''size()'' gibt die Anzahl der Elemente auf dem Stack zurück
 +  * ''clear()'' nimmt alle Elemente vom Stack herunter
 +  * ''isEmpty()'' gibt genau dann ''true'' zurück, wenn kein Element auf dem Stack liegt
 +  * ''add(element)'' bewirkt dasselbe wie ''push''
 +  * ''remove(element)'' entfernt - falls vorhanden - das Element aus dem Stack.
 +  * ''contains(element)'' gibt genau dann ''true'' zurück, wenn der Stack das Element enthält.
 +  * ''indexOf(element)'': Falls das Element auf dem Stack enthalten ist, wird der Index des Elements zurückgegeben, ansonsten -1.
 +
 +</WRAP>
 +
 +
 +<HTML>
 +
 +<div class="java-online" style="height: 400px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'StackExample'}">
 +
 +<script type="text/plain" title="StackExample.java">
 +Stack<String> st = new Stack();    // Das <String> bedeutet: Auf diesem Stack können Strings abgelegt werden.
 +
 +st.push("1. Element");
 +st.push("2. Element");
 +st.push("3. Element");
 +st.push("4. Element");
 +
 +println(st.pop());
 +println(st.pop());
 +
 +st.push("5. Element");
 +println(st.pop());
 +println(st.pop());
 +</script>
 +
 +</div>
 +
 +</HTML>
 +
 +===== LinkedList =====
 +<WRAP center round info 80%>
 +Eine ''LinkedList'' ist eine Liste, bei der man Elemente an beiden Enden beliebig hinzufügen oder wegnehmen kann. Im Gegensatz zu einer [[#ArrayList|ArrayList]] wird zum Speichern der Liste aber kein Array verwendet, sondern jedes Element wird in ein "Knoten-Objekt" verpackt und diese speichern zusätzlich Referenzen auf den Vorgänger- und Nachfolgerknoten, [[https://de.wikipedia.org/wiki/Liste_(Datenstruktur)|siehe auch den Wikipedia-Artikel hier.]] \\ \\ 
 +**Methoden:**
 +  * ''add(element)'' fügt am Ende der Liste ein Element hinzu
 +  * ''addLast(element)'' wirkt identisch zu ''add''
 +  * ''push(element)'' wirkt identisch zu ''add''
 +  * ''addFirst(element)'' fügt am Ende der Liste ein Element hinzu
 +  * ''poll()'' entnimmt das Element am Kopf der Liste und gibt es zurück.
 +  * ''peek()'' gibt das Element am Kopf der Liste zurück, verändert die Liste aber dabei nicht.
 +  * ''removeFirstOccurrence(element)'' löscht das erste Element der Liste, das gleich dem übergebenen Element ist.
 +  * ''removeLastOccurrence(element)'' löscht das letzte Element der Liste, das gleich dem übergebenen Element ist.
 +  * ''removeFirst()'' Entnimmt das Element am Anfang der Liste und gibt es zurück.
 +  * ''removeLast()'' Entnimmt das Element am Ende der Liste und gibt es zurück.
 +  * ''pop()'' wirkt identisch zu ''removeLast''.
 +  * ''peekFirst()'' gibt das Element am Anfang der Liste zurück, verändert die Liste aber nicht.
 +  * ''peekLast()'' gibt das Element am Ende der Liste zurück, verändert die Liste aber nicht.
 +  * ''size()'' gibt die Anzahl der Elemente in der Liste zurück
 +  * ''remove(element)'' entfernt - falls vorhanden - das Element aus der Liste.
 +  * ''remove(index)'' entfernt das Element mit dem angegebenen Index aus der Liste
 +  * ''clear()'' entfernt alle Elemente aus der Liste.
 +  * ''contains(element)'' gibt genau dann ''true'' zurück, wenn die Liste das Element enthält.
 +  * ''indexOf(element)'': Falls das Element in der Liste enthalten ist, wird der Index des Elements zurückgegeben, ansonsten -1.
 +  * ''addAll(liste)'' fügt der Liste alle Elemente der übergebenen Liste hinzu. Letztere wird dabei nicht verändert.
 +</WRAP>
 +
 +
 +<HTML>
 +
 +<div class="java-online" style="height: 400px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'LinkedListExample'}">
 +
 +<script type="text/plain" title="LinkedListExample.java">
 +LinkedList<String> liste = new LinkedList<>();
 +
 +liste.addFirst("Element 1");
 +liste.addFirst("Element 2");
 +liste.addFirst("Element 3");
 +liste.addLast("Element 0");
 +
 +println(liste.removeFirst());
 +println(liste.removeLast());
 +
 +println("Rest der Liste: " + liste);
 +</script>
 +
 +</div>
 +
 +</HTML>