Fehler bei Ein-/Ausgabe-Operationen werden in Java traditionell über eine geprüfte Ausnahme vom Typ IOException gemeldet. Bei Frameworks ist das zum Teil etwas lästig, sodass Java 8 eine Wrapper-Klasse im Paket java.io aufgenommen hat, die eine geprüfte IOException in einer ungeprüften UncheckedIOException mantelt.

class java.io.UncheckedIOException
extends RuntimeException

§ UncheckedIOException(IOException cause)
Ummantelt cause.

§ UncheckedIOException(String message, IOException cause)
Ummantelt cause mit einer zusätzlichen Meldung.

Bisher macht die Java-Bibliothek nur an einer Stelle von diesem Ausnahmetyp Gebrauch, und das ist bei lines() der Klasse BufferedReader, damit bei der Stream-API die geprüften Ausnahmen nicht im Wege stehen.

Der BufferedReader bietet neben den einfachen geerbten Lese-Methoden der Oberklasse Reader zwei weitere praktische Methoden:

· String readLine(): liest eine Zeile, und liefert am Ende null, wenn die letzte Zeile erreicht wurde.

· Stream<String> lines(): Liefert einen Stream von Strings. Neu in Java 8.

So ist einfach ein Programm formuliert, welches alle Zeilen einer Datei abläuft:

try ( BufferedReader in = Files.newBufferedReader( Paths.get( "lyrics.txt" ), StandardCharsets.ISO_8859_1 ) ) {

for ( String line; (line = in.readLine()) != null; )

  System.out.println( line );

}

catch ( IOException e ) {

  e.printStackTrace();

}

Beispiel

Mit der Stream-API sieht es ähnlich aus; kurz skizziert:

try ( BufferedReader in = Files.newBufferedReader( … ) ) {

  in.lines().forEach( System.out::println );

}

Falls es beim Lesen über den Stream zu einem Fehler kommt, wird eine RuntimeException vom Typen UncheckedIOException ausgelöst.

In Java 8 vergrößert sich die Schnittstelle um zwei Default-Methoden:

interface java.lang.CharSequence

§ default IntStream chars()

§ default IntStream codePoints()

Alle implementierenden Klassen bieten ab Java 8 diese beiden zusätzlichen Methoden. Die Bedeutung von default und Schnittstellen im Allgemeinen bleibt ein Detail aus Kapitel 6, an dieser Stelle wollen wir nur den Vorteil betonen, dass chars() gut dafür verwendet werden kann, über die Zeilen zu laufen. Allerdings hat das nichts mit dem erweiterten for zu tun, sondern mit einem anderen Programmieridiom.

Beispiel

Laufe über eine Zeichenkette und gib jedes Zeichen aus.

"Drama is life with the dull bits left out. (Hitchcock)".chars().forEach( c ->

System.out.print( (char) c )

);

Neben der Möglichkeit ein Feld mit festen Werten zu füllen, sind in Java 8 noch ein paar Methoden setAll(…)/parallelSetAll(…) hinzugekommen. Die Methoden durchlaufen ein gegebenes Feld und rufen eine bestimmte Methode für jeden Index auf, die zur Initialisierung verwendet wird.

Beispiel

Fülle ein double-Feld mit Zufallszahlen:

double[] randoms = new double[10];

Arrays.setAll( randoms, v -> Math.random() );

System.out.println( Arrays.toString( randoms ));

Das Beispiel nutzt eine spezielle Syntax, die sogenannten Lambda-Ausdrücke, um die Funktion zu beschreiben.

• static void setAll(double[] array, IntToDoubleFunction generator)
• static void setAll(int[] array, IntUnaryOperator generator)
• static void setAll(long[] array, IntToLongFunction generator)
• static <T> void setAll(T[] array, IntFunction<? extends T> generator)
• static void parallelSetAll(double[] array, IntToDoubleFunction generator)
• static void parallelSetAll(int[] array, IntUnaryOperator generator)
• static void parallelSetAll(long[] array, IntToLongFunction generator)
• static <T> void parallelSetAll(T[] array, IntFunction<? extends T> generator)
  Läuft ein gegebenes Feld komplett ab und übergibt dabei dem generator Schritt für Schritt den Index. Der Generator bildet den Index auf einen Wert ab, der wiederum zur Feldinitialisierung genutzt wird.

In Java 8 sind neue Sortiermethoden hinzugekommen, die für sehr große Felder geeignet sind. Bei den neuen parallelSort(…)-Methoden verwendet die Bibliothek mehrere Threads um Teile parallel zu sortieren, was die Geschwindigkeit erhöhen kann. Eine Garantie ist das aber nicht, denn ein Performance-Vorteil ergibt sich wirklich nur bei großen Feldern.

class java.util.Arrays

§ static void parallelSort(byte[] a)

§ static void parallelSort(byte[] a, int fromIndex, int toIndex)

§ static void parallelSort(char[] a)

§ static void parallelSort(char[] a, int fromIndex, int toIndex)

§ static void parallelSort(short[] a)

§ static void parallelSort(short[] a, int fromIndex, int toIndex)

§ static void parallelSort(int[] a)

§ static void parallelSort(int[] a, int fromIndex, int toIndex)

§ static void parallelSort(long[] a)

§ static void parallelSort(long[] a, int fromIndex, int toIndex)

§ static void parallelSort(float[] a)

§ static void parallelSort(float[] a, int fromIndex, int toIndex)

§ static void parallelSort(double[] a)

§ static void parallelSort(double[] a, int fromIndex, int toIndex)

§ static <T extends Comparable<? super T>> void parallelSort(T[] a)

§ static <T extends Comparable<? super T>> void parallelSort(T[] a, int fromIndex, int toIndex)

§ static <T> void parallelSort(T[] a, Comparator<? super T> c)

§ static <T> void parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)

Der verwendete Algorithmus ist einfach zu verstehen: zunächst wird das Feld ist Teilfelder partitioniert, die werden dann parallel sortiert und dann zu einem größeren sortierten Feld zusammengelegt. Das Verfahren nennt sich auch parallel sort-merge.

Der Überlauf einer mathematischen Operation führt zu einem positiven oder negativen Unendlich.

Beispiel

Multiplikation zweier wirklich großer Werte:

System.out.println( 1E300 * 1E20 ); // Infinity
System.out.println( –1E300 * 1E20 ); // -Infinity

Für die Werte deklariert die Java-Bibliothek in Double und Float zwei Konstanten; zusammen mit der größten und kleinsten darstellbaren Fließkommazahl sind das:

Wert für	Float	Double
positiv unendlich	Float.POSITIVE_INFINITY	Double.POSITIVE_INFINITY
negativ unendlich	Float.NEGATIVE_INFINITY	Double.NEGATIVE_INFINITY
kleinster Wert	Float.MIN_VALUE	Double.MIN_VALUE
größter Wert	Float.MAX_VALUE	Double.MAX_VALUE

Tabelle 1.8: Spezialwerte und ihre Konstanten

Das Minimum für double-Werte liegt bei etwa 10^–324 und das Maximum bei etwa 10^308. Weiterhin deklarieren Double und Float Konstanten für MAX_EXPONENT/MIN_EXPONENT.

Hinweis

Die Anzeige des Über-/Unterlaufs und des undefinierten Ergebnisses gibt es nur bei Fließkommazahlen, nicht aber bei Ganzzahlen.

public final class java.lang.Float/Double
extends Number
implements Comparable<Float/Double>

§ static boolean isInfinite(float/double v)
Liefert true, wenn v entweder POSITIVE_INFINITY oder NEGATIVE_INFINITY ist.

§ static boolean isFinite(float/double d)
Liefert true, wenn d eine endliche Zahl ist. Neu in Java 8.

Anweisungen von Code lassen sich in eine Methode eines Objekts setzen und auf diese Weise weitergeben. Das ist eine häufige Notwendigkeit, für die das Paket java.util.function eine einfache funktionale Schnittstelle Consumer vorgibt:

interface java.util.function.Consumer<T>

*  void accept(T t). Führt Operationen mit der Übergabe t durch.

Die accept(…)-Methode bekommt ein Argument – wobei die Implementierung natürlich nicht zwingend darauf zurückgreifen muss – und liefert keine Rückgabe. Transformationen sind damit nicht möglich, denn nur über Umwege kann der Konsument die Ergebnisse speichern, und dafür ist die Schnittstelle nicht gedacht. Consumer-Typen sind eher gedacht als Endglied einer Kette, in der zum Beispiel Dateien in eine Datei geschrieben werden, die vorher verarbeitet wurden.

Immer repräsentieren Konsumenten Code, und eine API kann nun einfach einen Code-Block nach der Art doSomethingWith(myConsumer) annehmen, und ihn etwa in einem Hintergrund-Thread abzuarbeiten, wiederholend auszuführen, nach einer erlaubten Maximaldauer abbrechen, die Zeit messen, …

Beispiel

Implementiere einen Consumer-Wrapper, der die Ausführungszeit eines anderen Konsumenten loggt.

import java.util.function.*;

import java.util.logging.Logger;

class Consumers {

public static <T> Consumer<T> measuringConsumer( Consumer<T> block ) {

return t -> {

long start = System.nanoTime();

block.accept( t );

long duration = System.nanoTime() – start;

Logger.getAnonymousLogger().info( "Ausführungszeit (ms): " + duration );

};

}

}

Folgender Aufruf zeigt die Nutzung:

Consumer<Void> wrap = measuringConsumer( (Void) -> System.out.println( "Test" ) );

wrap.accept( null );

Typ Consumer in der API

In der Java-API zeigt sich der Typ Consumer in der Regel als Argument einer Methode forEach(Consumer), die Datenquellen abläuft und für jedes Element accept(…) aufruft. Interessant ist die Methode an dem Typ Iterable, denn die wichtigen Collection-Datenstrukturen wie ArrayList implementieren diese Schnittstelle.

Beispiel

Gib jedes Element einer Liste auf der Konsole aus:

Arrays.asList(1, 2, 3, 4).forEach( t -> System.out.println( t ) );

Ein Prädikat ist eine Aussage über einen Gegenstand, die wahr oder falsch. Die Frage mit Character.isDigit(‚a‘), ob das Zeichen „a“ eine Ziffer ist, wird mit falsch beantwortet – isDigit ist also ein Prädikat, weil es über einen Gegenstand, einem Zeichen, eine Wahrheitsaussage fällen kann.

Flexibler sind Prädikate, wenn sie als Objekte repräsentiert werden, weil sie dann an unterschiedliche Stellen weitergegeben werden können, wenn etwa über ein Prädikat bestimmt, was aus einer Sammlung gelöscht werden soll oder ob mindestens ein Element in einer Sammlung ist, was ein Prädikat erfüllt.

Das java.util.function-Paket deklariert eine flexible funktionale Schnittstelle Predicate auf folgende Weise:

interface java.util.function.Predicate<T>

* boolean test(T t)
   Führt einen Test auf t durch und liefert true, wenn das Kriterium erfüllt ist.

Beispiel

Der Test, ob ein Zeichen eine Ziffer ist, kann durch Prädikat-Objekte nun auch anders durchgeführt werden:

Predicate<Character> isDigit = (Character c) -> Character.isDigit( c );

System.out.println( isDigit.test(‚a‘) ); // false

Hätte es die Schnittstelle Predicate schon früher in Java 1.0 gegeben, hätte es einer der Methode Character.isDigit(…) gar nicht bedurft, es hätte auch ein Predicate als statische Variable in Character geben können, so dass ein Test dann geschrieben würde als Character.IS_DIGIT.test(…) oder als Rückgabe von einer Methode isDigit(), mit der Nutzung Character.isDigit().test(…). Es ist daher gut möglich, dass sich in Zukunft die API dahingehend verändert, dass Aussagen auf Gegenständen mit Wahrheitsrückgabe nicht mehr als Methoden bei den Klassen realisiert werden, sondern als Prädikat-Objekte angeboten werden. Aber Methoden-Referenzen geben zum Glück die Flexibilität, dass problemlos Methoden als Lambda-Ausdrücke genützt werden können und so kommen wir wieder von Methoden zu Funktionen.

Typ Predicate in der API

Es gibt in der Java-API vier Stellen, an denen Prediate-Objekte genutzt werden:

· Als Argument für Lösch-Methoden, um in Sammlungen Elemente zu spezifizieren, die gelöscht werden sollen.

· Bei den Default-Methoden der Predicate-Schnittstelle selbst, um Prädikate zu verknüpfen.

· Bei regulären Ausdrücken, um ein Pattern als Predicate nutzen zu können.

· In der Stream-API, bei der Objekte beim Durchlaufen des Stroms über ein Prädikat identifiziert werden, um sie etwa auszufiltern.

Beispiel

Lösche aus einer Liste mit Zeichen alle die, die Ziffern sind (es bleiben nur Zeichen übrig, etwa Buchstaben).

Predicate<Character> isDigit = (Character c) -> Character.isDigit( c );

List<Character> list = new ArrayList( Arrays.asList( ‚a‘, ‚1‘ ) );

list.removeIf( isDigit );

Default-Methoden von Predicate

Es gibt eine Reihe von Default-Methoden, die die funktionale Schnittstelle Predicate anbietet. Zusammenfassend:

interface java.util.function.Predicate<T>

default Predicate<T> negate()

default Predicate<T> and(Predicate<? super T> p)

default Predicate<T> or(Predicate<? super T> p)

default Predicate<T> xor(Predicate<? super T> p)

Die Methodennamen sprechen für sich.

Beispiel

Lösche aus einer Liste mit Zeichen alle die, die keine Ziffern sind.

Predicate<Character> isDigit = (Character c) -> Character.isDigit( c );

Predicate<Character> isNotDigit = isDigit.negate();

List<Character> list = new ArrayList( Arrays.asList( ‚a‘, ‚1‘ ) );

list.removeIf( isNotDigit );

Funktionale Programmierung hat auch daher etwas akademisches, weil in den Köpfen der Entwickler oftmals dieses Programmierparadigma nur mit mathematischen Funktionen in Verbindung gebracht wird. Und die wenigsten werden tatsächlich Fakultät oder Fibonacci-Zahlen in Programmen benötigen und daher schnell funktionale Programmierung beiseite legen. Doch diese Vorurteile sind unbegründet, und es ist hilfreich, gedanklich funktionale Programmierung von der Mathematik lösen, denn die allermeisten Programme haben nichts mit mathematischen Funktionen im eigentlichen Sinne zu tun.

Betrachten wir die Sortierung von Strings. Ein Comparator ist eine einfache Funktion, mit zwei Parametern und einer Rückgabe. Diese Funktion wiederum wird an die sort(…)-Methode übergeben. Alles das ist funktionale Programmierung, denn wir programmieren Funktionen und übergeben sie. Drei Beispiele (Generics ausgelassen):

Code	Bedeutung
Comparator c = (c1, c2) -> …	Implementiert eine Funktion
Arrays.sort(T[] a, Comparator c)	Nimmt eine Funktion als Argument an
Collections.reverseOrder(Comparator cmp)	Nimmt eine Funktion an und liefert auch eine zurück

Funktionen selbst können in Java nicht übergeben werden, also helfen sich Java-Entwickler mit der Möglichkeit, die Funktionalität in eine Methode zu kapseln, sodass die Funktion zum Objekt mit einer Methode wird, was die Logik realisiert. Lambda-Ausdrücke bzw. Methoden/Konstruktor-Referenzen geben eine kompakte Syntax.

Der Typ Comparator ist eine funktionale Schnittstelle und steht für eine besondere Funktion mit zwei Parametern gleichen Typs und einer Ganzzahl-Rückgabe. Es gibt weitere funktionale Schnittstellen, die etwas flexibler sind als Comparator, in der Weise, dass etwa die Rückgabe statt int auch double oder etwas anderes sein können.