• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content

Loading…

Flash Player 9 (or above) is needed to view presentations.
We have detected that you do not have it on your computer. To install it, go here.

Like this presentation? Why not share!

Jug java7

on

  • 2,098 views

 

Statistics

Views

Total Views
2,098
Views on SlideShare
2,066
Embed Views
32

Actions

Likes
1
Downloads
122
Comments
0

3 Embeds 32

http://jujo00obo2o234ungd3t8qjfcjrs3o6k-a-sites-opensocial.googleusercontent.com 28
http://www.jug.lv 3
http://jugpreview.tumblr.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Jug java7 Jug java7 Presentation Transcript

    • Java 7 new features Java User Group Latvia www.jug.lv
    • Java 7
      • Project began in August 2006
      • JDK7 is done via Open JDK effort
      • Major release – JVM, language and library changes
      • Current status – milestone M10, build b115, planned release Mid 2011
    • Initially planned features
      • Closures – Project Lambda
      • Small language changes – Project Coin
      • Modularity for Java platform – Project Jigsaw
      • Support for dynamically-typed languages
      • Core and IO library extensions
      • Swing and UI related changes
      • Support for updated standards - Unicode, localization, security, cryptography, XML and JDBC
    • Two release plans
      • Plan A
        • All features, release in Mid 2012
      • Plan B
        • JDK 7 minus Lambda, Jigsaw and part of Coin, release in Mid 2011
        • JDK 8, release in late 2012
    • Plan B selected
      • Plan A
        • All features, release in Mid 2012
      • Plan B
        • JDK 7 minus Lambda, Jigsaw and part of Coin, release in Mid 2011
        • JDK 8, release in late 2012
    • Approved feature list
      • JSR 292: Support for Dynamically-Typed Languages (“InvokeDynamic”)
      • Small Language Enhancements (Project Coin)
      • Concurrency and Collections Updates (including the Fork/Join Framework)
      • Upgrade Class-Loader Architecture
      • Unicode 6.0
      • JSR 203: More New I/O APIs (“NIO 2”)
      • Updated cryptography
      • JDBC 4.1
      • Translucent & Shaped Windows
      • Heavyweight/Lightweight Component Mixing
      • Swing: Nimbus Look-and-Feel, JLayer Component
      • Update the XML Stack (JAXP, JAXB, & JAX-WS)
    • Language enhancements - Project Coin
    • Strings in switch statement
      • GregorianCalendar c = new GregorianCalendar();
      • int monthNameToDays(String s, int year) {
      • switch (s) {
      • case "April": case "June":
      • case "September": case "November":
      • return 30;
      • case "January": case "March":
      • case "May": case "July":
      • case "August": case "December":
      • return 31;
      • case "February":
      • return 28 + (c.isLeapYear(year) ? 1 : 0);
      • default :
      • return -1;
      • }
      • }
    • Improved Type Inference for Generic Instance Creation
      • Map <Integer, List<String>> map =
      • new HashMap <Integer, List<String>> ();
      • New “diamond” operator :
      • Map<Integer, List<String>> map = new HashMap<>();
      • List<?> l = new ArrayList<>();
    • Try-with-resources
      • void copy(String src, String dest) throws IOException {
      • InputStream in = new FileInputStream(src);
      • try {
      • OutputStream out = new FileOutputStream(dest);
      • try {
      • byte[] buf = new byte[8 * 1024];
      • int n;
      • while ((n = in.read(buf)) >= 0)
      • out.write(buf, 0, n);
      • } finally {
      • out.close();
      • }
      • } finally {
      • in.close();
      • }
      • }
    • Try-with-resources
      • void copy(String src, String dest) throws IOException {
      • try (InputStream in = new FileInputStream(src);
      • OutputStream out = new FileOutputStream(dest)) {
      • byte[] buf = new byte[8192];
      • int n;
      • while ((n = in.read(buf)) >= 0)
      • out.write(buf, 0, n);
      • }
      • }
    • Try-with-resources
      • void copy(String src, String dest) {
      • try (InputStream in = new FileInputStream(src);
      • OutputStream out = new FileOutputStream(dest)) {
      • byte[] buf = new byte[8192];
      • int n;
      • while ((n = in.read(buf)) >= 0)
      • out.write(buf, 0, n);
      • } catch (IOException e) {
      • e.printStackTrace();
      • }
      • }
    • Try-with-resources
      • package java.lang;
      • public interface AutoCloseable {
      • void close() throws Exception;
      • }
      • package java.io;
      • public interface Closeable extends AutoCloseable {
      • void close() throws IOException;
      • }
    • Multi-catch
      • try {
      • String. class .newInstance();
      • } catch ( final IllegalAccessException | InstantiationException e) {
      • e.printStackTrace();
      • throw e;
      • } catch (Exception e) {
      • // handle exception
      • }
    • Integer and binary literals
      • byte b = 0b00100101;
      • int phoneNumber = 123_456_7890;
      • long creditCardNumber = 1234_5678_9012_3456L;
      • int hexBytes = 0xFF_EC_DE_5E;
    • Simplified Varargs Method Invocation
      • List<String> a = new ArrayList<String>(),
      • b = new ArrayList<String>(),
      • c = new ArrayList<String>();
      • // Warning: [unchecked] unchecked generic array
      • // creation for varargs parameter of type
      • // List<String>[]
      • return Arrays.asList(a, b, c);
    • Language enhancements postponed until Java 8
    • Language enhancements in Java 8
      • Collection literals and indexing
      • List<String> cities = [&quot;Riga&quot;, &quot;London&quot;, &quot;Tokio&quot;];
      • Set<String> countries = { &quot;LV&quot;, &quot;LT&quot;, &quot;EE&quot; };
      • Map<String, Double> atomicWeights = { &quot;H&quot; : 1.0079,
      • &quot;He&quot; : 4.0026, &quot;Li&quot; : 6.941 };
      • String city = cities[0];
      • Double weight = atomicWeights[&quot;H&quot;];
    • Language enhancements in Java 8
      • Closures
      • #{ int x -> x + 1 }
      • #{ System.out.println(&quot;Hello, World!&quot;) }
      • list.forEach(#{ e -> System.out.println(e) });
      • Arrays.sort(array, #{ a, b -> a.compareToIgnoreCase(b) });
    • Language enhancements in Java 8
      • Method references
      • class Person {
      • public static int compareByAge(Person a, Person b) { ... }
      • }
      • Person[] people = ...
      • Arrays.sort(people, #Person.compareByAge);
      • Arrays.sort(people, #Person.compareByAge(Person, Person));
      • Arrays.sort(people, #comparatorHolder.comparePersonByAge);
    • JSR 292 – Support for Dynamically-Typed languages
    • JSR 292 - Overview
      • Dynamic languages on the JVM
      • JSR 223 implemented in JDK6
      • JVM initially designed for statically-typed language
      • 4 bytecode instructions available for method invocations
        • Invokestatic
        • Invokevirtual
        • Invokespecial
        • Invokeinterface
      • new bytecode instruction &quot;invokedynamic“ and Method Handles
      • java.dyn package
    • JSR 292 – Method Handles
      • Method handle is a lightweight pointer or reference to a method
      • java.dyn.MethodHandle
      • Example
      • public void testMethodHandle() throws Throwable {
      • MethodHandle hndl = MethodHandles.lookup().findVirtual(
      • PrintStream. class , &quot;println&quot;,
      • MethodType.methodType( void.class , String. class ));
      • hndl.< void >invokeGeneric(System.out, &quot;Hello, MethodHandle!&quot;);
      • }
    • JSR 292 Invokedynamic – how it works?
      • JVM encounters invokedynamic instruction
      • JVM invokes the bootstrap method
      • The Bootstrap method resolves the method handle
      • The Bootstrap method must be previously registered in JVM
      • Future calls don't require the Bootstrap method invocation
    • JSR 292 InvokeDynamic, Java example
      • public void testDynamic() throws Throwable {
      • InvokeDynamic.< void >greet(&quot;World&quot;);
      • }
      • static {
      • Linkage.registerBootstrapMethod(&quot;bootstrap&quot;);
      • }
      • public static void greet(String str) {
      • System.out.println(&quot;Hello, dynamic &quot; + str);
      • }
      • private static CallSite bootstrap(Class caller, String name, MethodType type) {
      • CallSite site = new CallSite(caller, name, MethodType.make( void.class ));
      • site.setTarget(MethodHandles.lookup().findStatic(Test. class , name, MethodType.make( void.class , String. class )));
      • return site;
      • }
    • NIO.2
    • NIO.2 – Paths
      • java.nio.file.Path – a replacement for java.io.File
      • File file = new File(&quot;index.html&quot;);
      • Path path = Paths.get(&quot;index.html&quot;);
      • Path path = new File(&quot;index.html&quot;).toPath();
      • All Path methods throw exceptions in case of errors
      if (!file.delete()){ ... } try { path.delete(); } catch (IOException e) { ... }
    • NIO.2 – FileSystem
      • Provides interface to file system
      • Default file system is local/platform file system
      • FileSystem local = FileSystems.getDefault();
      • Path p = local.getPath(“filename&quot;);
      • Path p2 = Paths.get(“filename”);
      • Jar and Zip file systems included
    • NIO.2 – DirectoryStream
      • DirectoryStream to iterate over the entries
      • Scales to large directories
      • Filter using glob, regex, or custom filter
      • try (DirectoryStream<Path> stream =
      • dir.newDirectoryStream(&quot;*.{c,h,cpp,hpp,java}&quot;)) {
      • for (Path entry : stream) {
      • ...
      • }
      • }
    • NIO.2 - Files.walkFileTree
      • Walks a file tree rooted at a given starting file
      • Invoke FileVisitor method for each file/directory
      • interface FileVisitor<T> {
      • FileVisitResult preVisitDirectory(T dir);
      • FileVisitResult visitFile(T file, BasicFileAttributes attrs);
      • FileVisitResult visitFileFailed(T file, IOException exc);
      • FileVisitResult postVisitDirectory(T dir, IOException exc);
      • }
      • SimpleFileVisitor – a default implementation
    • NIO.2 - File change notifications
      • Current approach – polling the file system
      • WatchService – watch registered objects (Watchables) for changes
      • WatchService watcher = path.getFileSystem().newWatchService();
      • path.register(watcher, ENTRY_CREATE, ENTRY_MODIFY);
      • for (;;) {
      • WatchKey watchKey = watcher.take();
      • for (WatchEvent event : watchKey.pollEvents()) {
      • System.out.println(event.kind() + &quot; : “
      • + event.context());
      • }
      • watchKey.reset();
      • }
    • Fork/Join framework
    • Fork/Join Framework
      • Multicore era approaching
      • Moore’s Law doesn’t work since ~2003
      • Current solution (java.util.concurrent) has its limitations
        • Coarse grained parallelism
        • Inefficient CPU utilization
      • Solution: Fork/Join framework
    • Fork/Join – Divide and conquer
      • Result solve(Problem problem) {
      • if (problem.size < SEQUENTIAL_THRESHOLD)
      • return solveSequentially(problem);
      • else {
      • Result left, right;
      • INVOKE-IN-PARALLEL {
      • left = solve(extractLeftHalf(problem));
      • right = solve(extractRightHalf(problem));
      • }
      • return combine(left, right);
      • }
      • }
    • Fork/Join - architecture
      • ForkJoinExecutor, ForkJoinTask
      • Each worker thread has it’s own task queue (deque) – no concurrency between treads for tasks
      • Work stealing algorithm – threads are never idle
    • Fork/Join - ParallelArray
      • ParallelArray<T>, ParallelLongArray etc.
      • Supports filtering, mapping, searching, sorting, reducing etc.
    • ParallelArray example
      • ParallelArray<Order> orders = new ParallelArray<>(fjPool, data);
      • double maxAmount = orders
      • . withFilter (madeThisYear)
      • . withMapping (getAmount)
      • . max ();
      • static final Ops.Predicate<Order> madeThisYear = new Ops.Predicate<>() {
      • public boolean op(Order o) {
      • return o.getYear() == thisYear;
      • }
      • };
      • static final Ops.ObjectToDouble<Order> getAmount = new Ops.ObjectToDouble<>() {
      • public double op(Order o) {
      • return o.getAmount();
      • }
      • };
    • Try it yourself
      • Download JDK 7 early access https://jdk7.dev.java.net/
    • Questions