Java 7 (AKA Java 1.7.0) is out! What does this mean, is this a Big Deal like Java 3 or 5 or a snoozer like Java 6 or something in the middle like Java 4? It all depends on what you do with it, but for most Java developers, we’re looking at a Java 4-ish release. There are some new APIs, and some really nice syntax cleanup, but ultimately it’s not a big deal.
Here’s the list of what’s changed:
The stuff I hope I don’t have to care about (AKA The Boring Stuff)
These are the under-the-hood changes I will probably only encounter when debugging someone else’s code.
Strict class-file checking
I’m not entirely sure what this is, and it doesn’t seem like too many other people are either. I think it means that Java 7 files have to declare themselves as different than previous versions and do some pre-verification as part of compilation. I don’t know if this is actually something new or just declared baggage.
As specified in JSR 202, which was part of Java SE 6, and in the recently-approved maintenance revision of JSR 924, class files of version 51 (SE 7) or later must be verified with the typechecking verifier; the VM must not fail over to the old inferencing verifier.
Upgrade class-loader architecture
Fixes some deadlock issues when writing non-hierarchal custom classloaders. If you’re writing custom classloaders, this is probably great news. Unfortunately if you’re writing custom classloaders you’re pretty much screwed with or without this improvement.
More information here.
Method to close a URLClassLoader
Pretty self-explanatory. if you’re using a URLClassLoader, you may at some point want to close it. Now you can.
More information here.
SCTP (Stream Control Transmission Protocol)
From what I can gather SCTP is somewhere between UDP’s lightweight “spray and pray” approach and TCP’s heavy-duty “armored convoy”. Seems like a good choice for modern media narrowcasting and always-on sensor networks, but don’t quote me on that.
More information here.
SDP (Sockets Direct Protocol)
Implementation-specific support for reliable, high-performance network streams over Infiniband connections on Solaris and Linux.
SDP and/or Infiniband seem to networking where you can get more throughput by bypassing the nosy TCP stack, but without completely ignoring it. Kind of like flashing your badge to the security guard and letting all your friends in, I think?
More information here.
Use the Windows Vista IPv6 stack
I’m assuming that this also applies to Windows 7, but I’ll worry about this when my great-grandkids finally make the switch to IPv6 in 2132.
TLS 1.2
Better than TLS 1.1! (TLS 1.2 is SSL 3.3).
More information here.
Elliptic-curve cryptography (ECC)
The official description sums it up:
A portable implementation of the standard Elliptic Curve Cryptographic (ECC) algorithms, so that all Java applications can use ECC out-of-the-box.
XRender pipeline for Java 2D
Now, when you aren’t gaming, you can leverage some of your GPU power to do image rendering and manipulation in Java instead of just mining BitCoins.
Create new platform APIs for 6u10 graphics features
Let’s you use opacity and non-rectangluar shapes in your Java GUI apps.
More information here.
Nimbus look-and-feel for Swing
Your Swing apps can now look like outdated OS X apps.
More information here.
Swing JLayer component
Useful way to write less spaghetti when trying to make Java GUI apps behave like other modern frameworks.
More information here.
Gervill sound synthesizer
Looks like a decent audio synthesis toolkit. Not sure if this really needs to be in the JDK but now you can add reverb to your log file monitor’s beeping.
More information here.
The important stuff I don’t really use (AKA The Stuff I’m Glad Someone Thought Of)
These are the changes that probably only help if you’re on the cutting edge of certain facets of using Java. Eventually these will probably benefit us all but I doubt many people were waiting for these.
Unicode 6.0
Also self-explanatory, new version of Unicode. Has the new Indian Rupee Sign (?) and over 2,000 other new glyphs, so it’s certainly important if you use those, but otherwise not so much. I don’t know enough about switching versions of Unicode to say if this is something to be worried about, but if you have lots of it in your app, it’s probably safe to say you should do some major tests before switching.
More information here.
Locale enhancement
Locale was previously based on RFC 1766, now it is based on BCP 47 and UTR 35.
This isn’t just new data, this is a new data structure, as the number and classification of languages on computers has evolved beyond the capabilities of RFC 1766. I’ve always been glad that Java is so robust in it’s internationalization support even though I’ve never really taken advantage of most of it.
Separate user locale and user-interface locale
Now this is interesting, but I can’t find any good use cases yet. My guess is that this is part of Java’s ongoing push towards multi-platform/multi-language interfaces, notably Android. You can set a Locale (and the rules a locale dictates) not only on geo/cultural basis but on a device/environment basis. Locale.Category only has two entries but I wouldn’t be surprised if more of them creep in in future versions.
JDBC 4.1
java.sql.Connection, java.sql.Statement, and java.sql.ResultSet are AutoCloseable (see try-with-resources below).
Also, you can now get RowSets from a RowSetFactory that you get from a RowSetProvider. If you’re still writing JDBC this probably makes your life easier, but only in the “at least I”m not writing custom classloaders” way.
Update the XML stack
Upgrade the components of the XML stack to the most recent stable versions: JAXP 1.4, JAXB 2.2a, and JAX-WS 2.2
Your XML library is always a version that’s too old or too new, so you might as well go with the new one.
The important stuff I don’t use yet (AKA The Cool Stuff)
InvokeDynamic – Support for dynamically-typed languages (JSR 292)
The short version is that this makes things better for people implementing dynamically-typed languages on the JVM, like Clojure. While the JVM is actually less statically typed than you might think if you’ve only used it via normal Java, methods in particular were difficult for these languages.
The long version is here.
Enhanced MBeans
I’ve never knowingly used MBeans (Managed Beans), but they do seem useful for large systems. Regardless, they’ve been enhanced:
Enhancements to the existing com.sun.management MBeans to report the recent CPU load of the whole system, the CPU load of the JVM process, and to send JMX notifications when GC events occur (this feature previously included an enhanced JMX Agent, but that was dropped due to lack of time).
The Important Stuff I Use (AKA The Good Stuff)
These are the reasons I’ve even bothered to look at Java 7. I’ll probably write a follow-up on each of these when I have some experience with them.
JSR 203: More new I/O APIs for the Java platform (NIO.2)
I’m including this here because I’m actually doing some data/file work where this will come in handy. Basically this exposes a lot of I/O and Filesystem functionality that you previously had to dip into native libraries for, like actually telling the OS to copy a file rather than reading and writing the data yourself. If you’re not doing any file-based work right now, keep a mental note to look into this the next time you type “File”.
More information here.
NIO.2 filesystem provider for zip/jar archives
Included here for similar reasons as the previous item, but I think it’s pretty cool that you can treat a zip file as a filesystem and operate within it. Unfortunately it looks like the basic implementation is read-only, but I’m guessing the pieces are there for a read/write version.
More information here.
Concurrency and collections updates (jsr166y)
java.util.concurrent, as far as I’m concerned, is something everyone who considers him/herself a senior Java dev should be familiar with. It’s rare that your code will not be able to take advantage of it in some way. One of the missing pieces was a good fork/join component, where you can split jobs and wait for them all to complete in parallel before moving on. I actually built a version of this approach (sadly not open sourced), so I’m eager to tinker with the new standard one. I expect that list most of the concurrent library you’ll need to sprinkle in some of your own helper code to make things elegant, but the hard parts are solved and built and ready for assembly.
More information here.
Project Coin – Small language enhancements (JSR 334)
Ah, the sugary goodness that you’ve been waiting for.
More information here (PDF).
Summary
So basically, a bunch of “nice to have” stuff. Code will be a little cleaner, resources will be closed a little more often. GUI apps will be a little fancier. Some more people might try concurrency. Programs will run a little faster. The next thing you know we’ll be looking at Java 8…