JAVA-B2 Collections Collections Framework Diagramm Was sind Collections Vorteile

Collection Interfaces Core-Collection-Interfaces (Begriff, Ziele, Standard) Liste der Core Interfaces List Set Queue Dequeue SortedSet NavigableSet Map SortedMap NavigableMap Collections Zusammenfassung @!Beispiele+Links

Das Interface Collection Das Superinterface Diagramm Diagramm Collection-Standard-Methoden Zusammenfassung

Implementierungsklassen Implementierungsklassen Diagramm Array[T]> Lists ArrayList<E> LinkedList<E> CopyWriteOnList<E> Set<E> Implementations HashSet<E> TreeSet<E> EnumSet<E> CopyWriteOnArraySet<E> Queue<E> Implementations LinkedList<E> PriorityQueue<E> Deque<E> Implementations LinkedList<E> ArrayDeque<E> Map<E> Implementations HashMap<K,V> LinkedHashMap<K,V> TreeMap<K,V> WeakHashMap<K,V> IdentityHashMap<K,V> EnumMap<K,V> ConcurrentHashMap<K,V>** ConcurrentSkipList<K,V>** SortedSet<E> Implementations TreeSet<E> EnumSet<E> BlockingQueue<E> Implementations ArrayBlockingQueue<E> LinkedBlockingQueue<E> LinkedBlockingQueue<E> PriorityBlockingQueue<E> SynchronousQueue<E> DelayQueue<E> Legacy Types für Listen Vector Hashtable Stack Stack HashSet<E> HashSet<E> @!Descriptions @!Examples @!Index/Examples

Overview

JAVA-B2 | Overview

In diesem Teil JAVA-B2 befassen wir uns als Vertiefung zur Themen der objektorientierten Programmierung in Java mit der Einführung mitunter in das Java Collection Framework. Collection Interfaces und zugehörige Implementierungsklassen werden von allen Java Packages in sehr großem Umfang genutzt.

[ ]

Abbildung: Java Tiers B

(ContentInstance ContentInstance-Java-Tiers-B)

JAVA-B2 | Collections Framework

Collections

Das Java Collections Framework von Java, Java 8, Java 16

In der Einführung in Collection geben wir einen Einblick, was Collections sind, wie man mit Collections als Entwickler bessere Programme realisiert und für alle Beteiligten den Job etwas einfacher macht.

Wir geben einen Überblick über die zentralen Elemente welche in der Summe des Java Collection Framework bilden: Die Collection Interfaces, die Implementierungsklassen für Collections sowie auch die zugehörigen Algorithmen von Collections in Java.

JAVA-B2 | Collections Core-Interfaces

Übersicht über alle Collections Core-Interfaces

In der Einführung in Collection geben wir einen Einblick, was Collections sind, wie man mit Collections als Entwickler bessere Programme realisiert und für alle Beteiligten den Job etwas einfacher macht.

Wir geben einen Überblick über die zentralen Elemente welche in der Summe des Java Collection Framework bilden: Die Collection Interfaces, die Implementierungsklassen für Collections sowie auch die zugehörigen Algorithmen von Collections in Java.

JAVA-B2 | Collections «Collection Interface»

Das Superinterface «Collection»

Das Interface «Collection» ist das Superinterface für alle weiteren Interfaces im Java Collection Framework und stellt dahingehend mit seinen Methoden auch den Standard für alle Implementierungsklassen dar.

Seit Java 8 wurde im Zusammenhang mit dem Java Collection Framework die Stream API eingeführt und für alle Implementierungklassen über das Collection-Interface durchgesetzt. Das Verständnis dieses Interfaces Collection ist die zwingende Voraussetzung für das Verständnis der Nutzer der übrigen Interfaces und Klassen.

JAVA-B2 | Collections Implementierungsklassen

Implementierungsklassen der jeweiligen Interfaces

Das Java Collections Framework beinhaltet eine Reihe von Implementierungsklassen, von denen mitunter ArrayList<T> als List sowie HashMap<K,V> und LinkedHashMap<K,V> zum Grundlagenwissen zählen.

Diese Implementierungsklassen sind eine Option, wie man Sammlungen von Daten als Alternative zu Arrays erstellen und verwalten kann, auch wenn die zugehörigen Instanzen zumeist in Variablen gespeichert werden, deren Typ ein Interfaces ist.

Lambda-Expressions

Collection | Lambda-Expressions (Querverweis)

Die Syntax sowie auch die Besonderheiten beim Scope von Lambda-Expressions hat ein eigenes Kapitel, siehe JAVA-B1 Lambda-Expressions.

Die eigentliche Zielsetzung unabhängig von der Syntax von Lambdas besteht darin, Methoden wie Werte referenzieren zu können. Da @FunctionalInterface annotierte Interfaces den Typ von Lambdas definieren, steht die Funktionale Programmierung in Zusammenhang mit JAVA-B1 Nested Classes, JAVA-B1 Anonymous Class, JAVA-B1 Lambda-Expressions, JAVA-B1 Interface-Default-Methods JAVA-B1 Method-References.

https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

java.util.concurrent

Collection | java.util.concurrent

Nebenläufige Programmierung, asynchrone Programmierung, Multithreading, Threads, Runnables, Multi-Prozessor-Anwendungen, synchronized als Keyword: Spannend wird es bei JAVA immer dann, wenn man nicht nur ein Programm zweimal startet sondern innerhalb eines Programms die selbe Methode in zwei und mehr Prozessen auf verschiedenen Prozessoren durchlaufen wird und sich ggf. gegenseitig die lokalen Variablen überschreiben. Das sollte man mal richtig verstanden haben.

Im Zuge der Einführung der Stream-API wird für die parallele Verarbeitung inzwischen aber parallelStream() verwendet, so dass die Verwendung von new Thread(..) verzichten wird.

Auf parallele, nebenläufige Programmierung, Threads, Runnables, Multithreading, asynchrone Programmierung wird in Asynchrone Programmierung und Thread-Pools eingegangen.

java.util.concurrent.Flow: Flow-Controlled Components mit Publisher, welche Items produzieren, Subscribers welche ein oder mehr Items als Consumer verbrauchen, alles organisiert und gemanaged durch Subscription. Flow entspricht der Reactive-Streams Spezifikation, JAVA JDK 9 (https://www.reactive-streams.org/).

https://docs.oracle.com/en/java/javase/18/docs/api/java.base/java/util/concurrent/package-summary.html
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Flow.html

Flow.Processor (T,R) - A component that acts as both a Subscriber and Publisher, Flow.Publisher (T) - A producer of items (and related control messages) received by Subscribers, Flow.Subscriber (T) - A receiver of messages, Flow.Subscription - Message control linking a Flow.Publisher and Flow.Subscriber.

ExecutorService ForkJoinPool.commonPool() Future (?)

class OneShotPublisher implements Publisher<Boolean> { private final ExecutorService executor = ForkJoinPool.commonPool(); // daemon-based private boolean subscribed; // true after first subscribe public synchronized void subscribe(Subscriber<? super Boolean> subscriber) { if (subscribed) subscriber.onError(new IllegalStateException()); // only one allowed else { subscribed = true; subscriber.onSubscribe(new OneShotSubscription(subscriber, executor)); } } static class OneShotSubscription implements Subscription { private final Subscriber<? super Boolean> subscriber; private final ExecutorService executor; private Future<?> future; // to allow cancellation private boolean completed; OneShotSubscription(Subscriber<? super Boolean> subscriber, ExecutorService executor) { this.subscriber = subscriber; this.executor = executor; } public synchronized void request(long n) { if (!completed) { completed = true; if (n <= 0) { IllegalArgumentException ex = new IllegalArgumentException(); executor.execute(() -> subscriber.onError(ex)); } else { future = executor.submit(() -> { subscriber.onNext(Boolean.TRUE); subscriber.onComplete(); }); } } } public synchronized void cancel() { completed = true; if (future != null) future.cancel(false); } } } class SampleSubscriber<T> implements Subscriber<T> { final Consumer<? super T> consumer; Subscription subscription; final long bufferSize; long count; SampleSubscriber(long bufferSize, Consumer<? super T> consumer) { this.bufferSize = bufferSize; this.consumer = consumer; } public void onSubscribe(Subscription subscription) { long initialRequestSize = bufferSize; count = bufferSize - bufferSize / 2; // re-request when half consumed (this.subscription = subscription).request(initialRequestSize); } public void onNext(T item) { if (--count <= 0) subscription.request(count = bufferSize - bufferSize / 2); consumer.accept(item); } public void onError(Throwable ex) { ex.printStackTrace(); } public void onComplete() {} } class UnboundedSubscriber<T> implements Subscriber<T> { public void onSubscribe(Subscription subscription) { subscription.request(Long.MAX_VALUE); // effectively unbounded } public void onNext(T item) { use(item); } public void onError(Throwable ex) { ex.printStackTrace(); } public void onComplete() {} void use(T item) { ... } }

JAVA-B2