Diese Präsentation wurde erfolgreich gemeldet.
Die SlideShare-Präsentation wird heruntergeladen. ×
Anzeige
Anzeige
Anzeige
Anzeige
Anzeige
Anzeige
Anzeige
Anzeige
Anzeige
Anzeige
Anzeige
Anzeige
Nächste SlideShare
Java 8 streams
Java 8 streams
Wird geladen in …3
×

Hier ansehen

1 von 78 Anzeige
Anzeige

Weitere Verwandte Inhalte

Diashows für Sie (20)

Ähnlich wie Java 8 (20)

Anzeige

Aktuellste (20)

Anzeige

Java 8

  1. 1. Java 8 Interesting parts Vaidas Pilkauskas, Kasparas Rudokas Vilnius JUG
  2. 2. Agenda ● Lambda ● Date & Time ● PermGen ● Annotations
  3. 3. Lambda JSR 335
  4. 4. lambda vs. closure A lambda is just an anonymous function. myCollection.filter(e ‑> e.length() >= 5) A closure is any function which closes over the environment in which it was defined. This means that it can access variables not in its parameter list. int minLength = 5; myCollection.filter(new Predicate(){ boolean apply(MyElement e) { return e != null ? e.length >= minLength : false; } })
  5. 5. Project Lambda (JSR 335) ● Language changes ○ Lambda Expression ○ Virtual Extension Method ● Library changes ○ Functional API ○ Parallel collections ○ Bulk Operations
  6. 6. Problem String[] names = {"Alice", "Bob", "Charlie", Dave"}; Arrays.sort(names, new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.compareToIgnoreCase(o2); } });
  7. 7. "tiny" anonymous inner class String[] names = {"Alice", "Bob", "Charlie", Dave"}; Arrays.sort(names, new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.compareToIgnoreCase(o2); } });
  8. 8. "tiny" and useful ● callbacks ● runnables ● event handlers ● comparators ● ...and many other cases
  9. 9. All we need! String[] names = {"Alice", "Bob", "Charlie", Dave"}; Arrays.sort(names, new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.compareToIgnoreCase(o2); } });
  10. 10. Solution - closure String[] names = {"Alice", "Bob", "Charlie", Dave"}; Arrays.sort(names, (o1, o2) -> o1.compareToIgnoreCase(o2));
  11. 11. What do we mean by closures? ● a unit of deferred execution ● code that can be passed as a value ● can be used in an assignment statement ● capture of a surrounding environment
  12. 12. Lambda Expressions s -> s.length() (int x, int y) -> x+y () -> 42 (x, y, z) -> { if (x == y) return x; else { int result = y; for (int i = 1; i < z; i++) result *= i; return result; } }
  13. 13. Lambda Syntax principally because something similar has been generally well-received in other Java-like languages (C# and Scala), and a clearly "better" alternative did not present itself
  14. 14. Lambda ● Effectively final variables
  15. 15. Lambda ● Effectively final variables ● Shadowing
  16. 16. Lambda ● Effectively final variables ● Shadowing ● break, continue must be local
  17. 17. Lambda ● Effectively final variables ● Shadowing ● break, continue must be local ● this - lambda is not an instance method. (this == surrounding context object)
  18. 18. Lambda ● Effectively final variables ● Shadowing ● break, continue must be local ● this - lambda is not an instance method. (this == surrounding context object) ● throw completes method abruptly
  19. 19. Functional Interfaces A functional interface is an interface that has just one abstract method, and thus represents a single function contract.
  20. 20. Functional Interfaces SAM - Single Abstract Method interfaces one method excluding Object methods interface Runnable { void run(); } // Functional interface Foo { boolean equals(Object obj); } // Not functional; equals is already an implicit member interface Comparator<T> { boolean equals(Object obj); int compare(T o1, T o2); } // Functional; Comparator has one abstract non-Object method
  21. 21. Method References Method reference is a shorthand for a lambda invoking just that method System::getProperty "abc"::length String::length super::toString ArrayList::new Arrays.sort(ints, Integer::compareTo);
  22. 22. Method References Static methods simply translate like lambda with same arguments and return type class Math { public static int max(int a, int b) {...} } interface Operator<T> { T eval(T left, T right); } Operator<Integer> lambda = (a, b) -> Math.max(a, b); Operator<Integer> methodRef = Math::max;
  23. 23. Method References Non static method reference of type T translates like lambda with an additional argument of type T Comparator<String> c = (s1, s2) -> s1.compareToIgnoreCase (s2); //translates to: Comparator<String> c = String::compareToIgnoreCase;
  24. 24. Method References Instance method reference translates like lambda with same arguments and return type (and implicit receiver) Callable<Integer> l = () -> "boo".length(); //translates to: Callable<Integer> c = "boo"::length;
  25. 25. Method References String[] names = {"Alice", "Bob", "Charlie", Dave"}; Arrays.sort(names, (o1, o2) -> o1.compareToIgnoreCase(o2)); //translates to String[] names = {"Alice", "Bob", "Charlie", Dave"}; Arrays.sort(names, String::compareToIgnoreCase);
  26. 26. Compatibility Cannot add new interface methods (without forcing current interface users to implement them) But we need new lambda enabled methods (on Java core libraries!)
  27. 27. Default methods (also known as) ● virtual extension methods ● defender methods
  28. 28. Default methods interface NormalInterface { void myNormalMethod(); void myDefaultMethod () default { System.out.println("-> myDefaultMethod"); } } class NormalInterfaceImpl implements NormalInterface { @Override public void myNormalMethod() { System.out.println("-> myNormalMethod"); } }
  29. 29. Functional Collections Major changes in collection API: ● Internal iteration support with Iterable/Stream interfaces (forEach, filter, map, etc)
  30. 30. Functional Collections Major changes in collection API: ● Internal iteration support with Iterable/Stream interfaces (forEach, filter, map, etc) ● Explicit parallel APIs for greater parallelism support. These can be combined with Fork/Join to divide the tasks
  31. 31. Functional Collections Major changes in collection API: ● Internal iteration support with Iterable/Stream interfaces (forEach, filter, map, etc) ● Explicit parallel APIs for greater parallelism support. These can be combined with Fork/Join to divide the tasks ● Greater stress on immutability and avoiding in-place mutation which was done in the conventional for-each loops
  32. 32. Example String[] names = {"Alice", "Bob", "Charlie", "Dave"}; List<String> filteredNames = Streams.stream(names) .filter(e -> e.length() >= 4) .into(new ArrayList<>()); filteredNames.stream().forEach(System.out::println);
  33. 33. Streams ● No storage - nothing is stored in stream
  34. 34. Streams ● No storage - nothing is stored in stream ● Functional in nature - new values are produced
  35. 35. Streams ● No storage - nothing is stored in stream ● Functional in nature - new values are produced ● Laziness-seeking. Many operations can be implemented lazily
  36. 36. Streams ● No storage - nothing is stored in stream ● Functional in nature - new values are produced ● Laziness-seeking. Many operations can be implemented lazily ● Bounds optional. Think of infinite stream
  37. 37. Functional interfaces java.util.functions ● Predicate - a property of the object passed as argument ● Block - an action to be performed with the object passed as argument ● Mapper - transform a T to a U ● ...
  38. 38. Parallelism //sequential int sum = myCollection.stream() .filter(b -> b.getColor() == BLUE) .map(b -> b.getWeight()) .sum(); //parallel int sum = myCollection.parallel() .filter(b -> b.getColor() == BLUE) .map(b -> b.getWeight()) .sum();
  39. 39. Advantages ● Elements may be computed lazily. If we apply a Mapper to a collection of a thousand elements but only iterate over the first three, the remaining elements will never be mapped.
  40. 40. Advantages ● Elements may be computed lazily. If we apply a Mapper to a collection of a thousand elements but only iterate over the first three, the remaining elements will never be mapped. ● Method chaining is encouraged. Hence there's no need to store intermediate results in their own collections.
  41. 41. Advantages ● Elements may be computed lazily. If we apply a Mapper to a collection of a thousand elements but only iterate over the first three, the remaining elements will never be mapped. ● Method chaining is encouraged. Hence there's no need to store intermediate results in their own collections. ● Internal iteration hides implementation decisions. For example, we could parallelize a map() operation just by writing myCollection.parallel().map(e ‑> e.length()).
  42. 42. Try it out today! The prototype compiler is being implemented in OpenJDK. ● Source code is available at http://hg.openjdk.java. net/lambda/lambda ● Binary snapshots of the lambda-enabled JDK prototype are available athttp://jdk8.java.net/lambda IDE support: ● Netbeans 8 Nightly Builds with experimental Lambda support ● IDEA 12 EAP with experimental Lambda support
  43. 43. Date & Time API JSR 310
  44. 44. Oldies: Date ● Mutable
  45. 45. Oldies: Date ● Mutable ● Years being indexed from 1900
  46. 46. Oldies: Date ● Mutable ● Years being indexed from 1900 ● Months being indexed from 0
  47. 47. Oldies: Date ● Mutable ● Years being indexed from 1900 ● Months being indexed from 0 Ex.: Date d = new Date(1L); System.out.println(d.toString());
  48. 48. Oldies: Date ● Mutable ● Years being indexed from 1900 ● Months being indexed from 0 Ex.: Date d = new Date(1L); System.out.println(d.toString()); //Thu Jan 01 02:00:00 EET 1970
  49. 49. Oldies: Calendar ● Mutable
  50. 50. Oldies: Calendar ● Mutable ● Not very convenient (lack of simple field methods)
  51. 51. Oldies: Calendar ● Mutable ● Not very convenient (lack of simple field methods) ● Very difficult to extend (add new calendars)
  52. 52. Oldies: Calendar ● Mutable ● Not very convenient (lack of simple field methods) ● Very difficult to extend (add new calendars) Ex.: Calendar c = Calendar.getInstance(); int weekday = c.get(DAY_OF_WEEK);
  53. 53. Oldies: Calendar ● Mutable ● Not very convenient (lack of simple field methods) ● Very difficult to extend (add new calendars) Ex.: Calendar c = Calendar.getInstance(); int weekday = c.get(DAY_OF_WEEK); Date d = c.getTime();
  54. 54. Under pressure...
  55. 55. JSR 310 ● Immutable
  56. 56. JSR 310 ● Immutable ● Defines consistent language for domain ○ Offset from UTC vs TimeZone ○ Machine vs Human ○ ISO 8601
  57. 57. JSR 310 ● Immutable ● Defines consistent language for domain ○ Offset from UTC vs TimeZone ○ Machine vs Human ○ ISO 8601 ● No old Date/Calendar usage (clean)
  58. 58. JSR 310 ● Immutable ● Defines consistent language for domain ○ Offset from UTC vs TimeZone ○ Machine vs Human ○ ISO 8601 ● No old Date/Calendar usage (clean) ● Extensible
  59. 59. JSR 310 ● Immutable ● Defines consistent language for domain ○ Offset from UTC vs TimeZone ○ Machine vs Human ○ ISO 8601 ● No old Date/Calendar usage (clean) ● Extensible ● Led by JodaTime creator (S. Colebourne)
  60. 60. Example: JSR 310 Clock clock = Clock.systemUTC(); LocalDate localDate = LocalDate.now(clock); //2012-11-13
  61. 61. Example: JSR 310 Clock clock = Clock.systemUTC(); LocalDate localDate = LocalDate.now(clock); //2012-11-13 MonthDay brasilBday = MonthDay.of(JUNE, 21);
  62. 62. Example: JSR 310 Clock clock = Clock.systemUTC(); LocalDate localDate = LocalDate.now(clock); //2012-11-13 MonthDay brasilBday = MonthDay.of(JUNE, 21); ZoneId zoneId = ZoneId.of("America/New_York"); Clock clock = Clock.system(zoneId); ZonedDateTime zonedDateTimeUS = ZonedDateTime.now(clock); //2012-11-11T04:17:58.693-05:00[America/New_York]
  63. 63. Example: JSR 310 import static javax.time.calendrical.LocalPeriodUnit. HOURS; Period p = Period.of(5, HOURS); LocalTime time = LocalTime.now(); LocalTime newTime; newTime = time.plus(5, HOURS); // or newTime = time.plusHours(5); // or newTime = time.plus(p);
  64. 64. Why not Joda Time? ● Machine timelines ● Pluggable chronology ● Nulls ● Internal implementation
  65. 65. VM/GC JEP 122 & JEP 156
  66. 66. PermGen removal ● Java Heap vs PermGen
  67. 67. PermGen removal ● Java Heap vs PermGen
  68. 68. PermGen removal ● Java Heap vs PermGen ● Why it was required anyway?
  69. 69. PermGen removal ● Java Heap vs PermGen ● Why it was required anyway? ● So what?
  70. 70. Annotations JSR 308 & JEP 120
  71. 71. Type Annotations ● In Java 7 we have annotations on declarations Ex.: class SomeClass { … } class ListElement<E> { … } public void v() (int I) { long l; {
  72. 72. Type Annotations ● JSR-308 brings annotations on Type use ● Are an enabler for the checkers framework Ex.: new @Interned MyObject(); myString = (@NonNull String) myObject; void monitorTemperature() throws @Critical TemperatureException { ... }
  73. 73. Repeating Annotations ● Before @Schedules ({ @Schedule(dayOfMonth="Last"), @Schedule(dayOfWeek="Fri", hour="23") ({ public void doPeriodicCleanup() { ... }
  74. 74. Repeating Annotations ● Before @Schedules ({ @Schedule(dayOfMonth="Last"), @Schedule(dayOfWeek="Fri", hour="23") ({ public void doPeriodicCleanup() { ... } ● After @Schedule(dayOfMonth="Last”) @Schedule(dayOfWeek="Fri", hour="23") public void doPeriodicCleanup() { ... }
  75. 75. Q&A
  76. 76. References * Lambda http://stackoverflow.com/questions/220658/what-is-the-difference-between-a-closure-and-a-lambda http://openjdk.java.net/projects/lambda/ http://jcp.org/aboutJava/communityprocess/edr/jsr335/index2.html http://vimeo.com/48577033 (slides: http://www.slideshare.net/tkowalcz/java-gets-a-closure) http://datumedge.blogspot.co.uk/2012/06/java-8-lambdas.html http://www.theserverside.com/news/thread.tss?thread_id=68718 http://medianetwork.oracle.com/video/player/1785479333001 https://oracleus.activeevents.com/connect/sessionDetail.ww?SESSION_ID=6080 https://oracleus.activeevents.com/connect/sessionDetail.ww?SESSION_ID=5089 http://www.lektorium.tv/lecture/?id=14048 http://www.lektorium.tv/lecture/?id=14049 http://blog.xebia.com/2012/11/05/report-will-java-8s-lambda-change-the-face-of-the-world/ http://www.slideshare.net/fsarradin/java-8-lambda http://programmers.stackexchange.com/questions/173441/what-triggered-the-popularity-of-lambda-functions-in-modern-mainstream-programmi?newsletter=1&nlcode=29983% 7c903a http://www.slideshare.net/bje/java-closures * Collections http://www.javabeat.net/2012/05/enhanced-collections-api-in-java-8-supports-lambda-expressions/ http://cr.openjdk.java.net/~briangoetz/lambda/collections-overview.html http://architects.dzone.com/articles/java-collections-api
  77. 77. References * Remove the Permanent Generation http://www.cubrid.org/blog/dev-platform/understanding-jvm-internals/ http://javaeesupportpatterns.blogspot.com/2011/10/java-7-features-permgen-removal.html http://java.dzone.com/articles/busting-permgen-myths https://oracleus.activeevents.com/connect/sessionDetail.ww?SESSION_ID=5135 * JSR 310: Date and Time API http://java.dzone.com/articles/introducing-new-date-and-time http://sourceforge.net/apps/mediawiki/threeten/index.php?title=ThreeTen http://www.infoq.com/news/2010/03/jsr-310 https://docs.google.com/document/pub?id=1rd8yplQZIRz3LxMzpVLuskr1b0HwBmK9PXpdgBYojSw http://sourceforge.net/apps/mediawiki/threeten/index.php?title=User_Guide https://oracleus.activeevents.com/connect/sessionDetail.ww?SESSION_ID=4350 * General Java8 http://openjdk.java.net/projects/jdk8/features http://www.pcadvisor.co.uk/news/software/3401314/oracle-java-upgrades-still-worthwhile-despite-postponed-features/ http://dhruba.name/2011/07/06/oracle-discusses-java-7-8-new-features-on-video/ http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2012/Java-8 http://www.parleys.com/#st=5&id=2850&sl=1 http://www.parleys.com/#st=5&id=2847 https://oracleus.activeevents.com/connect/sessionDetail.ww?SESSION_ID=2872 https://oracleus.activeevents.com/connect/sessionDetail.ww?SESSION_ID=10458
  78. 78. References *Annotations https://oracleus.activeevents.com/connect/sessionDetail.ww?SESSION_ID=4469 https://blogs.oracle.com/abuckley/entry/jsr_308_moves_forward http://jcp.org/en/jsr/detail?id=308 http://openjdk.java.net/jeps/120 http://types.cs.washington.edu/checker-framework/

×