java8 neue sprachfeatures - lambda/streams/default methods/functionalinterfaces

Neue Sprachfeatures

λλ Lambda-Ausdrücke

MethodMethod::References

default default methods @@ FunctionalInterfaces

≈≈≈≈ Streams

Feb. 2002Java 1.4

Sep. 2004Java 1.5

Dez. 2006Java 1.6

Jul. 2011Java 1.7

Mär. 2014Java 1.8

• Generics• Varargs• Foreach Loop• Static Imports• Autoboxing--------------------

• Java.util.concurrent

• Switch (Strings)• ARM (try-w-R)• Diamond operator• Multi-Exceptions• Num-Literals------------------------

• NIO2

• invokeDynamic

• Lambdas• Method Refs.• Default Meth.• Functional Ifc

• Stream

t

• Assert-------------

• Regex• NIO• Logging• JAXP• JAAS/JSSE

?--------------------------

• Compiler API• Scripting (JSR223)• JAXB Improvements• JAX-WS• JVM (Performance,...)

Feb. 2002Java 1.4

Sep. 2004Java 1.5

Dez. 2006Java 1.6

Jul. 2011Java 1.7

Mär. 2014Java 1.8

• Generics• Varargs• Foreach Loop• Static Imports• Autoboxing--------------------

• Java.util.concurrent

• Switch (Strings)• ARM (try-w-R)• Diamond operator• Multi-Exceptions• Num-Literals------------------------

• NIO2

• invokeDynamic

• Lambdas• Method Refs.• Default Meth.• Functional Ifc

• Stream

t

• Assert-------------

• Regex• NIO• Logging• JAXP• JAAS/JSSE

?--------------------------

• Compiler API• Scripting (JSR223)• JAXB Improvements• JAX-WS• JVM (Performance,...)

C# 2.0Generics

C# 3.0Extension Methods, Lambdas

Nov. 2007



@@ FunctionalInterfacesdefault default methods


x → x * x

(int a, int b) → a* b

(int a, int b) → { return a * b; }

(a, b) → a* b

interface Callback {

public int doit(int x);

};

java.lang.Runnable void run()java.util.concurrent.Callable<V> V call()java.awt.event.ActionListener void actionPerformed(ActionEvent e)java.beans.PropertyChangeListener void propertyChange(PropertyChangeEvent evt)java.io.FileFilter boolean accept(File pathname)java.util.Comparator<T> int compare(T o1, T o2)javax.naming.spi.ObjectFactory Object getObjectInstance(.....)

someThing.addCallback( new Callback() { public int doit(int x) { return x *x; } });

someThing.addCallback( (int x) → { return x *x; } );

someThing.addCallback(

(int x) → { return x *x; } );


(int x) → x *x );


x → x *x );

someThing.addCallback( x → x *x );

someThing.addCallback( new Callback() { public int doit(int x) { return x *x; } });

someThing.addCallback( x → x *x );

x → x * x;

(int a, int b) → a* b;

(int a, int b) → { return a * b; }

(a, b) → a* b;

some.method(Integer::parseInt);

Statische Methode

someList.forEach(MyClass::instMeth);

someList.forEach( (MyClass e) → e.instMeth() );

Ungebundene Instanz-Methode

some.method(System.out::println);

some.method(instance::instmethod);

Gebundene Instanz-Methode

some.method(MyClass::new);

some.method((x) -> new MyClass(x));

Konstruktor

List<Point> points = ….

Iterator<Point> it = points.iterator();

while(it.hasNext()) { Point p = it.next(); …. ….}


Stream<Point> it = points.stream();



Stream<Point> it = points.stream();


XX


points.stream() .map(p->p.x) .filter(v-> v > 0) .distinct() .forEach(out::println) ;

PointPointPointint

PointPointPointint

PointPointPointPointPointPoint

PointPoint

intPoint

intint

Pointint

int

Point

intint

mapmap

filter

distinct

foreach

p p.x→

v v > 0→

out::println


points.stream() .map(p->p.x) .filter(v-> v > 0) .distinct() .forEach(out::println) ;


points.parallelStream() .map(p->p.x) .filter(v-> v > 0) .distinct() .forEach(out::println) ;

interface MyInterface {


static int other(int x){ ...some Implementation } };

interface MyInterface {


default int other(int x){ ...Implementation using this } };

@FunctionalInterface interface MyInterface {


};

package java.util.function

@FunctionalInterface interface Function<T, R> {

R apply(T t);

};


@FunctionalInterface interface BiFunction<T, U, R> {

R apply(T t, U u);

};


@FunctionalInterface interface Consumer<T> {

void accept(T t);

};


@FunctionalInterface interface Supplier<T> {

T get();

};


@FunctionalInterface interface Predicate<T> {

boolean test(T t);

};

Consumer<Integer> outp = (i) -> System.out.println(i);

Function<String, Integer> fun = (s) -> s.length();

Supplier<String> value = () -> "Hello";

outp.accept(fun.apply(value.get()));

Consumer<Integer> outp = (i) -> System.out.println(i);

Function<String, Integer> fun = (s) -> s.length();

Supplier<String> value = () -> "Hello";

outp ( fun ( value() ) );



default default methods @@ FunctionalInterfaces


Weiterführendes:

State of the Lambda – Brian Goetz erklärt die Java 8 Features.http://cr.openjdk.java.net/~briangoetz/lambda/lambda-state-final.html

Lambda – A peek under the hoodhttp://www.youtube.com/watch?v=C_QbkGU_lqY&noredirect=1Brian Goetz erklärt, wie Lambdas implementiert sind.

Lambda/Streams Tutorial auf AngelikaLanger.comhttp://www.angelikalanger.com/Lambdas/Lambdas.html

Lambda-FAQ von Maurice Naftalinhttp://www.lambdafaq.org

Artikel von Angelika Langer und Klaus Kreft in Java Magazin 10.2013 und 11.2013

Java8 complete feature sethttp://openjdk.java.net/projects/jdk8/features

http://cr.openjdk.java.net/~briangoetz/lambda/lambda-state-final.html

http://www.youtube.com/watch?v=C_QbkGU_lqY&noredirect=1

http://www.angelikalanger.com/Lambdas/Lambdas.html

http://openjdk.java.net/projects/jdk8/features

Weiterführendes:

Netbeans 7.4https://netbeans.org/community/releases/74/

Java 8 Early Accesshttps://jdk8.java.net/download.html

Online Compiler – Try Java 8http://www.tryjava8.com

Java 8 Lambdas in Action (MEAP)Raoul-Gabriel Urma, Mario Fusco, and Alan Mycrofthttp://www.manning.com

forEachforEach( (Aufmerksamkeit) ( (Aufmerksamkeit) →→ Vielen Dank Vielen Dank ))

Dirk Detering ©2013Version 0.7

Dieses Projekt ist lizensiert als Inhalt der Creative Commons Namensnennung - Nicht-kommerziell - Weitergabe unter gleichen Bedingungen 3.0 Deutschland-Lizenz. Um eine Kopie der Lizenz zu sehen, besuchen Sie http://creativecommons.org/licenses/by-nc-sa/3.0/de/.

Java is a registered trademark of Oracle and/or its affiliates.

java8 neue sprachfeatures - lambda/streams/default methods/functionalinterfaces

Technology