Jug java7

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;
}
}

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;
} 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 = ["Riga", "London", "Tokio"];
Set<String> countries = { "LV", "LT", "EE" };
Map<String, Double> atomicWeights = { "H" : 1.0079,
"He" : 4.0026, "Li" : 6.941 };
String city = cities[0];
Double weight = atomicWeights["H"];

Closures
#{ int x -> x + 1 }
#{ System.out.println("Hello, World!") }
list.forEach(#{ e -> System.out.println(e) });
Arrays.sort(array, #{ a, b -> a.compareToIgnoreCase(b) });

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 "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, "println",
MethodType.methodType(void.class, String.class));
hndl.<void>invokeGeneric(System.out, "Hello, MethodHandle!");
}

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("World");
}
static {
Linkage.registerBootstrapMethod("bootstrap");
}
public static void greet(String str) {
System.out.println("Hello, dynamic " + 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 – Paths
java.nio.file.Path – a replacement for java.io.File
File file = new File("index.html");
Path path = Paths.get("index.html");
Path path = new File("index.html").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");
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("*.{c,h,cpp,hpp,java}")) {
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() + " : “
+ event.context());
}
watchKey.reset();
}

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/

Jug java7

More Related Content

What's hot (20)

Similar to Jug java7 (20)

More from Dmitry Buzdin (20)

Recently uploaded (20)

Jug java7