What's New in Java?

This page lists some of the main things added to Java in recent releases. By the author of O'Reilly's popular Java Cookbook, this page is maintained (every so often) at http://www.darwinsys.com/whatsnew.html.

New in Java 7 (expected early 2010)

This is still not finalized, but will probably include Closures, better support in the JVM for other languages, and lots more.

New Product: JavaFX (January 2009)

JavaFX is a new graphics language and API based on the Java machine and runtime. Primarily, it's what we've long needed: a compositional API for Swing and 2D graphics. JavaFX can be used in Applets, in Java WebStart, in desktop applications, and (very importantly) on mobile devices. Scope this out at Sun's new javafx.com site.

New in Java 6 (2007)

Java SE 6 (Java SDK 1.6) continues the trend, but most of the changes are in the libraries; there are no major changes in the language.

Performance enhancements. Running a Java 5 app on Java 6 even without recompilation will run faster.
Java Scripting - it's not just BeanShell anymore. The new package javax.scripting allows access to about 20 different languages from within a running JVM - some are Java based and run in-VM, others spawn external scripting processes. But the access is unified so you don't have to know how it works. Just ask for a "Scripting Engine" and feed it your (or, your users'!) scripts.
XML SOAP-based Web Services (JAX-WS) supported directly in Java SE - just add a few annotations and go! Works with JAXB (Java API for XML Binding) which converts between objects and XML. JAX-WS and JAXB are also supported in Java EE 5.
JDBC4 (enhancements) and bundled Java Database based on Apache Derby (great for in-JVM testing of database code without deploying a database, similar to HyperSonic or HSQL).
Compiler API exposed, for those needing to generate and compile code on the fly.
Annotations plug-ins (added runtime support for annotation processing).
Many Swing GUI Improvements.

For more details, see Sun's Java SE 6 article.

New in Java 5 (2005)

Java 5 (Java SDK 1.5) is now called Java SE (Standard Edition), e.g., the "Java 2" part has been dropped from the name). Java SE 5 features important new features, some of which change the language in ways that are not backwards compatible:

Annotation types. An annotation is a way of attaching metadata to source. Annotations look like class names but with an @ at the front. Annotations may be compile time, as in the famous example:
```
	@Override
	public boolean equals(Mytype other) { ... }
	
```
This code mistakenly overloads rather than overrides; prior to this compile time annotation (whose full name is java.lang.Override), it would not be noticed and the code would fail mysteriously much later. With the override, a Java 5 compiler is obligated to report it as an error!
Run-time annotations appear in the .class file, and can be interrogated at run time. Almost all maintained frameworks (current versions of Hibernate, Spring, Java EE 5, and anything newer) use annotations to eliminate XML configuration.
Generic types. Java now allows the developer of a class to specify specific types as parameters, instead of using Object and having to cast. This results in better type safety, because the compiler can better check arguments at compile time. Old code like:
```
List list = new ArrayList();
...
String s = (String)list.get(0);
		
```
can and should be re-written as
```
List<String> list = new ArrayList<String>();
...
String s = list.get(0);
		
```

Enumeration types. Java now has enum as a keyword to create class-like enumerations. For example:

	enum Color {
		RED, BLUE, GREEN
	};

	public static void main(String[] args) {
		Color color = Color.RED;
		String line = getLine();
		if (line != null)
			color = Color.valueOf(line);
		switch (color) {
		case RED:
			System.out.println("You like dark apples");
			break;
		case GREEN:
			System.out.println("You like light apples");
			break;
		case BLUE:
			System.out.println("You like blue balloons");
			break;
		}
	}

Old code that uses enum as a variable, as in

Enumeration enum;

will have to be changed.

AutoBoxing - automatic conversion between primitives and their wrappers.
```
Integer val = new Integer(42);
int i = val;
System.out.println(i);
```
will now work. For that matter, the first line can be just:
```
Integer val = 42;
```
new 'for' loop syntax based on generic collections and Iterable (which includes enums):
```
	for (Color c : Color.values()) {
		...
	}
```

Printf, scanf, String.format, etc. Provide OO versions of this ancient functionality.

	System.out.printf("Hello %s of %s%n", "World", "Java");
	String x = String.format("The meaning of the %s is %d?", "universe", 42);

Variable argument lists (a.k.a. 'Varargs'):

	public void process(String line, Integer ... nums) {
		for (int i : nums) {
			System.out.println("A number is " + i);
		}
	}

Lots more - see the Java 5 documentation.

New in Java 4 (J2SE 1.4, 2003)

Although Java 4 has been out for a long time, some Java developers still don't know about some of its new features:

Regular Expressions, a concise and precise pattern-matching specification (java.lang.String, java.util.regex.*)
The New IO package, for more efficient I/O and networking
Lots more - see the Java 1.4 documentation.