The document discusses new features introduced in Java versions 1.4 through 1.8, including lambda expressions, method references, default methods, and streams. Key features include lambda expressions and functional interfaces in Java 8, which allow implementing functional-style code in a more concise way than anonymous classes. Various Java.util.function interfaces like Consumer and Function are also introduced to work with lambda expressions.

1. Neue Sprachfeatures

3. λ Lambda-Ausdrücke
Method::References
Method
default methods
≈≈ Streams
@ FunctionalInterfaces

4. t
Feb. 2002
Java 1.4
•
•
•
•
•
•
Assert
------------Regex
NIO
Logging
JAXP
JAAS/JSSE
Sep. 2004
Java 1.5
•
•
•
•
•
?
Generics
-------------------------Varargs
Compiler API
Foreach Loop
Scripting (JSR223)
JAXB Improvements
Static Imports
JAX-WS
Autoboxing
JVM (Performance,...)
-------------------Java.util.concurrent
•
•
•
•
•
•
•
•
•
•
•
Mär. 2014
Java 1.8
Jul. 2011
Java 1.7
Dez. 2006
Java 1.6
•
•
Switch (Strings)
ARM (try-w-R)
Diamond operator
Multi-Exceptions
Num-Literals
-----------------------NIO2
invokeDynamic
•
•
•
•
•
Lambdas
Method Refs.
Default Meth.
Functional Ifc
Stream

5. C# 3.0
C# 2.0
Generics
t
Extension Methods,
Lambdas
Nov. 2007
Feb. 2002
Java 1.4
•
•
•
•
•
•
Assert
------------Regex
NIO
Logging
JAXP
JAAS/JSSE
Sep. 2004
Java 1.5
•
•
•
•
•
?
Generics
-------------------------Varargs
Compiler API
Foreach Loop
Scripting (JSR223)
JAXB Improvements
Static Imports
JAX-WS
Autoboxing
JVM (Performance,...)
-------------------Java.util.concurrent
•
•
•
•
•
•
•
•
•
•
•
Mär. 2014
Java 1.8
Jul. 2011
Java 1.7
Dez. 2006
Java 1.6
•
•
Switch (Strings)
ARM (try-w-R)
Diamond operator
Multi-Exceptions
Num-Literals
-----------------------NIO2
invokeDynamic
•
•
•
•
•
Lambdas
Method Refs.
Default Meth.
Functional Ifc
Stream

6. λ Lambda-Ausdrücke
Method::References
Method
default methods
≈≈ Streams
@ FunctionalInterfaces

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

8. interface Callback {
public int doit(int x);
};

9. 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(.....)

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

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

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

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

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

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

16. someThing.addCallback(
(int x) → x *x
);

17. someThing.addCallback(
(int x) → x *x
);

18. someThing.addCallback(
(int x) → x *x
);

19. someThing.addCallback(
x → x *x
);

20. someThing.addCallback( x → x *x );

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

22. someThing.addCallback( x → x *x );

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

24. λ Lambda-Ausdrücke
Method::References
Method
default methods
≈≈ Streams
@ FunctionalInterfaces

25. some.method(Integer::parseInt);
Statische Methode

26. someList.forEach(MyClass::instMeth);
someList.forEach( (MyClass e) → e.instMeth() );
Ungebundene Instanz-Methode

27. some.method(System.out::println);
some.method(instance::instmethod);
Gebundene Instanz-Methode

28. some.method(MyClass::new);
some.method((x) -> new MyClass(x));
Konstruktor

29. λ Lambda-Ausdrücke
Method::References
Method
default methods
≈≈ Streams
@ FunctionalInterfaces

30. List<Point> points = ….
Iterator<Point> it = points.iterator();
while(it.hasNext()) {
Point p = it.next();
….
….
}

31. List<Point> points = ….
Stream<Point> it = points.stream();
while(it.hasNext()) {
Point p = it.next();
….
….
}

32. List<Point> points = ….
X
Stream<Point> it = points.stream();
X
while(it.hasNext()) {
Point p = it.next();
….
….
}

33. List<Point> points = ….
points.stream()
.map(p->p.x)
.filter(v-> v > 0)
.distinct()
.forEach(out::println) ;

34. Point
Point
Point
Point
Point
Point
Point
Point
map
p → p.x
int
Point
Point
Point
int
Point
Point
Point
filter
int
int
Point
int
v → v>0
distinct
int
Point
foreach
out::println

35. List<Point> points = ….
points.stream()
.map(p->p.x)
.filter(v-> v > 0)
.distinct()
.forEach(out::println) ;

36. List<Point> points = ….
points.parallelStream()
.map(p->p.x)
.filter(v-> v > 0)
.distinct()
.forEach(out::println) ;

37. λ Lambda-Ausdrücke
Method::References
Method
default methods
≈≈ Streams
@ FunctionalInterfaces

38. interface MyInterface {
public int doit(int x);
static int other(int x){
...some Implementation
}
};

39. interface MyInterface {
public int doit(int x);
default int other(int x){
...Implementation using this
}
};

40. λ Lambda-Ausdrücke
Method::References
Method
default methods
≈≈ Streams
@ FunctionalInterfaces

41. @FunctionalInterface
interface MyInterface {
public int doit(int x);
};

42. package java.util.function
@FunctionalInterface
interface Function<T, R> {
R apply(T t);
};

43. package java.util.function
@FunctionalInterface
interface BiFunction<T, U, R> {
R apply(T t, U u);
};

44. package java.util.function
@FunctionalInterface
interface Consumer<T> {
void accept(T t);
};

45. package java.util.function
@FunctionalInterface
interface Supplier<T> {
T get();
};

46. package java.util.function
@FunctionalInterface
interface Predicate<T> {
boolean test(T t);
};

47. 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()));

48. Consumer<Integer> outp =
(i) -> System.out.println(i);
Function<String, Integer> fun =
(s) -> s.length();
Supplier<String> value =
() -> "Hello";
outp ( fun ( value() ) );

49. λ Lambda-Ausdrücke
Method::References
Method
default methods
≈≈ Streams
@ FunctionalInterfaces

50. 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 hood
http://www.youtube.com/watch?v=C_QbkGU_lqY&noredirect=1
Brian Goetz erklärt, wie Lambdas implementiert sind.
Lambda/Streams Tutorial auf AngelikaLanger.com
http://www.angelikalanger.com/Lambdas/Lambdas.html
Lambda-FAQ von Maurice Naftalin
http://www.lambdafaq.org
Artikel von Angelika Langer und Klaus Kreft in Java Magazin 10.2013 und 11.2013
Java8 complete feature set
http://openjdk.java.net/projects/jdk8/features

51. Weiterführendes:
Netbeans 7.4
https://netbeans.org/community/releases/74/
Java 8 Early Access
https://jdk8.java.net/download.html
Online Compiler – Try Java 8
http://www.tryjava8.com
Java 8 Lambdas in Action (MEAP)
Raoul-Gabriel Urma, Mario Fusco, and Alan Mycroft
http://www.manning.com

52. forEach( (Aufmerksamkeit) → Vielen Dank )

54. Dirk Detering ©2013
Version 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.