1. WHAT’S COMING IN JAVA SE 7
MARKO ŠTRUKELJ
PARSEK

2. JAVA SE 7
• Feature set not specified yet
• JSR not created yet
• Many different API, library, and framework efforts
aiming for inclusion
• Early Access downloads available:
– Java SE 7 EA
– Open JDK
• Release expected summer 2009 at the earliest

3. FOCUS
• Focus on (as claimed by Sun):
– Multiple languages support
– Modularity
– Rich clients
• Plus the usual:
– API updates and language enhancements
– Performance

4. SOME LANGUAGE ENHANCEMENTS
– Modules
– Annotations extensions
– Strings in switch statements
– Closures
– Try catch syntax improvement
– Enum comparisons

5. SOME API UPDATES
• New I/O version 2
• JMX 2.0

6. MODULE SYSTEM (JSR-277)
• Introduce mandatory and consistent versioning
and dependency meta info
• Integrate versioned dependencies with
classloading
• Introduce new packaging system – JAM archives,
and module repositories to store and serve the
content of these archives.
• Introduce a scope that’s less than public but more
than package-private to improve hiding of non-api
classes

7. MODULE SCOPE - LESS THAN PUBLIC, MORE THAN PACKAGE PRIVATE
:: com/company/util/ImageUtils.java ::com/company/util/impl/OSHacks.java
package com.company.util; package com.company.util.impl;
public class ImageUtils { public class OSHacks {
... OSHacks.callConvert(); public callConvert() {...}
} }

8. MODULE SCOPE - LESS THAN PUBLIC, MORE THAN PACKAGE PRIVATE
:: com/company/util/ImageUtils.java ::com/company/util/impl/OSHacks.java
module com.company.util; module com.company.util;
package com.company.util; package com.company.util.impl;
public class ImageUtils { module class OSHacks {
... OSHacks.callConvert(); module callConvert() {...}
} }
:: com/company/util/module-info.java
@Version(“1.0”)
@ImportModule(name=“java.se.core”, version=“1.7+”)
@ExportResources({“schemas/**”})
module com.company.util;

9. MODULE SYSTEM (JSR-277)
• JAM file - like JAR but more stringent meta
data requirements
– Can contain jars, native libraries, resources ...
– Module definition info and dependencies
specified through annotations
• Repositories implemented at API level
– You can implement custom repositories and
plug them into the module system.

10. MODULE SYSTEM (JSR-277)
– bootstrap repository (java.* classes)
contains quot;java.sequot; module - implicitly imported
– system-wide runtime repository (versioned
global libraries)
– user repository
– application repository - on the fly at app
startup - when application not installed in
system repository

12. ANNOTATIONS ON JAVA TYPES (JSR-308)
• Catch more errors at compile time
– You’ll be able to put annotation in more places
– Type use:
• List<@NonNull String> keys;
– @NonNull, @Interned, @Readonly,
@Immutable

13. LANGUAGE ENHANCEMENTS - IMPROVED TRY-CATCH
Motivation: prevent code repetition
try {
... someCall();
} catch(IllegalArgumentException, IOException e) {
log.warn(“We expected that, moving on ...: ”, e);
} catch(Exception e) {
log.error();
throw e;
}

14. LANGUAGE ENHANCEMENTS – SAFE RETHROW
Motivation: prevent code repetition
public void test() throws E1, E2 {
try {
... someCall();
} catch(final Throwable ex) {
log.error(“error: “, ex);
throw ex;
}
}

15. LANGUAGE ENHANCEMENTS – ENUM COMPARISON
Motivation: improve usability and readability
enum Size {SMALL, MEDIUM, LARGE};
Size mySize, yourSize;
...
if (mySize < yourSize) {
...
}

16. LANGUAGE ENHANCEMENTS – STRINGS IN SWITCH STATEMENTS
Motivation: improve usability and readability
switch(val) {
case “true”:
case “yes”:
return true;
case “false”:
return false;
default:
throw new IllegalArgumentException(“Wrong value: ” + val);
}

17. LANGUAGE ENHANCEMENTS - JBBA CLOSURES PROPOSAL
• What are closures?
Thread t = new Thread(new Runnable() {
public void run() {
doSomething();
}
});

18. LANGUAGE ENHANCEMENTS - CLOSURES
• Couldn’t we have something like
Thread t = new Thread({ =>
doSomething();
});
• Motivation: reduce boilerplate

19. LANGUAGE ENHANCEMENTS - CLOSURES
Connection con = ds.getConnection();
con.use({ =>
ps = con.prepareStatement(...);
...
}); // connection will automatically be closed
• Motivation: automatic resource cleanup, remove a whole
class of errors – i.e. make connection leak impossible

20. LANGUAGE ENHANCEMENTS - CLOSURES
Double highestGpa = students
.withFilter( { Student s => (s.graduation ==
THIS_YEAR)} )
.withMapping( { Student s => s.gpa } )
.max();
• Motivation: express a data processing algorithm
in clean and short form that is parallelism-
agnostic

21. API UPDATES – NEW I/O 2 (JSR-203)
– copying, moving files
– symbolic links support
– file change notification (watch service)
– file attributes
– efficient file tree walking
– path name manipulation
– pluggable FileSystem providers

22. API UPDATES – NEW I/O 2 (JSR-203)
Path home = Path.get(quot;/home/user1quot;);
Path profile = home.resolve(quot;.profilequot;);
profile.copyTo(home.resolve(quot;.profile.bakquot;),
REPLACE_EXISTING, COPY_ATTRIBUTES);

23. API UPDATES – NEW I/O 2 (JSR-203)
– java.nio.file
– java.nio.file.attribute
– interoperability with java.io
File srcFile = new File(“/home/user1/file.txt”);
File destFile = new File(“/home/user1/file2.txt”);
srcFile.getFileRef().copyTo(destFile.getFileRef());

24. API UPDATES – JMX 2.0
• Use annotations to turn POJOs into MBeans.
(JSR-255)
• There is also a new standard to access
management services remotely through web
services - interoperable with .NET (JSR-262)

25. NEW APIS
• New Date and Time API (JSR-310)
(implemented in Joda-Time library)

26. FORK-JOIN CONCURRENCY API (JSR-166)
Fine-grained parallel computation framework
based on divide-and-conquer and work-stealing
Double highestGpa = students
.withFilter( { Student s => (s.graduation ==
THIS_YEAR)} )
.withMapping( { Student s => s.gpa } )
.max();

27. BEANS VALIDATION FRAMEWORK (JSR-303)
Constraints via annotations (like in Hibernate
Validator)
– @NotNull, @NotEmpty
– @Min(value=), @Max(value=)
– @Length(min=, max=), @Range(min=,max=)
– @Past/@Future, @Email

28. SOME OTHER STUFF – NEW GARBAGE COLLECTOR
• Garbage first (G1) garbage collector
– Parallel, concurrent – makes good use of
multiple native threads (fast)
– Generational – segments the heap and gives
different attention to different segments (fast)
– High throughput (fast)
– Compacting – efficient memory use – but
takes most of GC processing time (slow)

29. SOME OTHER STUFF – JAVA FX
• A new scripting language and a whole set
of APIs for building rich GUIs
– Motivation: finally make UI development easy
for GUI, multimedia applications, vector
graphics, animation, rich internet applications
... Compete with AIR and Silverlight
– JavaFX Script
– Swing enhancements (JWebPane ... )
– Java Media Components