Notizen

Java Collections

tagsjava
  • Hilfsklassen aus java.util, die Daten speichern und organisieren
  • Enthält Interfaces, konkrete Klassen, die Schnittstelle implementieren, Algorithmen, z.B. zur Suche oder zum Sortieren

Das Interface Collection

  • Basis-Interface für alle Collections (Listen und Sets)

Methoden

boolean add(E e)
// Entfernt alle Elemente aus dieser Collection
void clear() 
boolean contains(Object o) 
boolean isEmpty()
boolean remove(Object o)
// Entfernt Element wenn der Filter erfüllt wird
boolean removeIf(Predicate<E> filter)
int size()
 
// Liefert ein Object-Array mit den Elementen dieser Collection
Object[] toArray()
// Füllt das T-Array a mit den Elementen und liefert es zurück
<T> T[] toArray(T[] a)
// Erzeugt ein T-Array mit den Elementen
<T> T[] toArray (IntFunction<T[]> generator)

Bulk operations:

// Vereinigung
boolean addAll(Collection<E> c)
// Gibt true zurück, falls alle Elemente aus c in dieser Collection enthalten sind
boolean containsAll(Collection<E> c)
// Mengen voneinander abziehen
boolean removeAll(Collection<E> c)
// Schnittmenge
boolean retainAll(Collection<E> c)

Das Interface List

List ist zunächst eine unveränderliche Liste

Implementierungen

  • ArrayList - Volldynamisches Array
  • LinkedList - Doppelt verkettete Liste

Listen erzeugen

List.of() erzeugt eine immutable Liste. Wenn man die Liste bearbeiten möchte, z.B. mit set, muss man sie erst z.B. in eine ArrayList umwandeln:

List<String> list = new ArrayList<>(List.of("Anton", "Peter", "Fritz", "Hans", "Erika", "Berthold", "Ernie", "Rayan"));

Methoden

void add(int index, E element)
E get(int index)
// Liefert den Index des ersten/letzten o, falls vorhanden, sonst -1
int indexOf(Object o)
int lastIndexOf(Object o) 
E remove(int index)
E set(int index, E element) // Ersetzt das Element
// Sortiert gemäß dem Comparator, oder bei null per implementierten Comparable interface
void sort(Comparator<E> c)

Zusätzliche Methoden bei LinkedList

void addFirst(E e)
void addLast(E e)
E getFirst()
E getLast()
E removeFirst()
E removeLast()

Das Interface Iterable

Dieses Interface hat eine wichtige Methode:

Iterator<T> iterator()

Diese gibt eine Instanz von Iterator zurück.

Der Iterator

Er besitzt zwei wichtige Methoden:

boolean hasNext()
T next()

Diese müssen implementiert werden.

Anwendung

Wenn Iterable implementiert wurde, lässt sich über die Klasse iterieren:

// List<T> hat bereits Iterable implementiert
List<String> strings = Arrays.asList("Java", "ist", "Cool");
 
// Daher ist ein solches Durchlaufen per enhanced for möglich:
for (String s : strings) { 
    System.out.println(s); 
}
 
// Dies ist äquivalent zu:
Iterator<String> it = strings.iterator();
while (it.hasNext()) {
    String s = it.next();
    System.out.println(s);
}

Das Interface Set

  • Mengen, beinhalten max 1 selbes Element
  • Set.of() für immutable Sets erlaubt keine doppelten Elemente. Set<Integer> set = Set.of(1, 1, 1); wirft eine Exception.
  • Konstruktoren für mutable Sets erlauben doppelte Elemente, nehmen aber nur eins auf. Set<Integer> set = new HashSet<>(List.of(1, 1, 1)); wäre erlaubt.

Implementierungen

  • HashSet - Speichert Inhalte mit Hashes
  • TreeSet - Speichert Inhalte durch Vergleiche
    • kann entweder instantiiert werden ohne Parameter (dann müssen die Elemente Comparable implementieren) oder mit einem Comparator als Parameter

Auf Gleichheit testen

Um auf Gleichheit zu Testen (z.B. wird dies in Sets gemacht, damit nur ein gleiches Element vorkommt), müssen in den Elementen die Methoden boolean equals(Object o) und int hashCode() implementiert werden. Die Methode hash(Object... values) bietet eine komfortable Methode zur Erzeugung qualitativ hochwertiger Hashes.

Das Interface Map

Implementierungen

  • HashMap
  • LinkedHashMap
  • TreeMap

Maps erzeugen

Map<Integer, String> map = new TreeMap<>(); 
map.put(18776, "Meier");

Methoden

// Löscht alle Einträge aus der Map
void clear()
boolean containsKey(Objekt key)
boolean containsValue(Object value)
int size()
 
// Liefert die Menge aller entries
Set<Map.Entry<K,V>> entrySet()
// Liefert die Menge aller keys
Set<K> keySet()
// Liefert alle Werte dieser Map als Collection
Collection<V> values()
 
V get(Object key)
V getOrDefault(Object key, V val)
V put(K key, V val)
V putIfAbsent(K key, V val)
V remove(Object key)
V replace(K key, V val)
 
// Fabrikmethoden
// akzeptieren bis zu 10 Schlüssel-Wert-Paare
Map<K,V> Map.of(K key, V value, K key, V value, ...)
Map<K,V> Map.ofEntries(Map.entry<K,V>, Map.entry<K,V>, ...)

Schlüssel-Wert-Paar Map.Entry

Methoden:

K getKey()
V getValue()

Beispiel:

for (Map.Entry<String, String> entry : m.entrySet()) {
    System.out.println(entry.getKey() + "-" + entry.getValue());
}

Entries sortieren

static <K extends Comparable<K>,V> Comparator<Map.Entry<K,V>>
comparingByKey ()
// bzw.
comparingByKey (Comparator<K> c)
 
static <K,V extends Comparable<V>> Comparator<Map.Entry<K,V>>
comparingByValue ()
// bzw.
comparingByValue (Comparator<V> c)

Funktionen in java.lang.Object

Klasseninstanz zurückgeben

// Gibt Klasseninstanz zurück
public final native Class<?> getClass();
// Darauf lässt sich z.B. getName() aufrufen

Objekte Klonen

protected native Object clone() throws CloneNotSupportedException;
  • Klassen, die clone() anbieten, müssen das Interface Cloneable implementieren.
  • Object.clone() kopiert alle Membervariable, indem es Referenzkopien anlegt (=flache Kopie).
  • Wird eine tiefe Kopie gewünscht, muss diese manuell implementiert werden.

Backlinks