New Features and Enhancements
Java 2 Platform Standard Edition 5.0 is a major feature release. The features listed below are introduced in 5.0 since the previous major release (1.4.0).
For highlights of the new features, also see J2SETM 5.0 in a Nutshell. For issues, see JDK 5.0 release notes.
- Performance Enhancements
- Java Language Features
- Enhanced for Loop
- Typesafe Enums
- Static Import
- Metadata (Annotations)
- Virtual Machine
- Class Data Sharing
- Garbage Collector Ergonomics
- Server-Class Machine Detection
- Thread Priority Changes
- Fatal Error Handling
- High-Precision Timing Support
- Base Libraries
- Lang and Util Packages
- Improved Support for Environment Variables
- JavaBeansTM Component Architecture
- Collections Framework
- Java API for XML Processing (JAXP)
- Bit Manipulation Operations
- Concurrency Utilities
- Monitoring and Management
- Integration Libraries
- Remote Method Invocation (RMI)
- Java Database Connectivity (JDBC)
- CORBA, Java IDL, and Java RMI-IIOP
- Java Naming and Directory InterfaceTM (JNDI)
- User Interface
- Java Sound Technology
- Java 2DTM Technology
- Image I/O
- General Deployment
- Java Web Start
- Tools and Tool Architecture
- Java Virtual Machine Tool Interface (JVMTI)
- Java Platform Debugger Architecture (JPDA)
- Java Compiler (javac)
- Javadoc Tool
- Annotation Processing Tool (
- Java TM 2 Platform, Standard Edition 5.0 Trouble-Shooting and Diagnostic Guide
- OS & Hardware Platforms
- Supported System Configurations
- 64-Bit AMD Opteron Processors
For a synopsis of performance enhancements, see Performance Enhancements.
For more information see New Language Features.
GenericsThis long-awaited enhancement to the type system allows a type or method to operate on objects of various types while providing compile-time type safety. It adds compile-time type safety to the Collections Framework and eliminates the drudgery of casting. Refer to JSR 14.
Enhanced for LoopThis new language construct eliminates the drudgery and error-proneness of iterators and index variables when iterating over collections and arrays. Refer to JSR 201 .
Autoboxing/UnboxingThis facility eliminates the drudgery of manual conversion between primitive types (such as int) and wrapper types (such as Integer). Refer to JSR 201 .
Typesafe EnumsThis flexible object-oriented enumerated type facility allows you to create enumerated types with arbitrary methods and fields. It provides all the benefits of the Typesafe Enum pattern ("Effective Java," Item 21) without the verbosity and the error-proneness. Refer to JSR 201.
VarargsThis facility eliminates the need for manually boxing up argument lists into an array when invoking methods that accept variable-length argument lists. Refer to JSR 201.
Static ImportThis facility lets you avoid qualifying static members with class names without the shortcomings of the "Constant Interface antipattern." Refer to JSR 201.
Metadata (Annotations)This language feature lets you avoid writing boilerplate code under many circumstances by enabling tools to generate it from annotations in the source code. This leads to a "declarative" programming style where the programmer says what should be done and tools emit the code to do it. Also it eliminates the need for maintaining "side files" that must be kept up to date with changes in source files. Instead the information can be maintained in the source file. Refer to JSR 175.
Class Data SharingThe class data sharing feature is aimed at reducing application startup time and footprint. The installation process loads a set of classes from the system jar file into a private, internal representation, then dumps that representation to a "shared archive" file. During subsequent JVM invocations, the shared archive is memory-mapped in, saving the cost of loading those classes and allowing much of the JVM's metadata for these classes to be shared among multiple JVM processes. For more information, click the above link.
Garbage Collector ErgonomicsThe parallel collector has been enhanced to monitor and adapt to the memory needs of the application. You can specify performance goals for applications and the JVM will tune the size of the Java heap to meet those performance goals with the smallest application footprint consistent with those goals. The goal of this adaptive policy is to eliminate the need to tune command-line options to achieve the best performance. For a synopsis of garbage collection features, click the above link.
Server-Class Machine DetectionAt application startup, the launcher can attempt to detect whether the application is running on a "server-class" machine.
Thread Priority ChangesThread priority mapping has changed somewhat allowing Java threads and native threads that do not have explicitly set priorities to compete on an equal footing.
Fatal Error HandlingThe fatal error reporting mechanism has been enhanced to provide improved diagnostic output and reliability.
High-Precision Timing SupportThe method
System.nanoTime()has been added, providing access to a nanosecond-granularity time source for relative time measurements. The actual precision of the time values returned by System.nanoTime() is platform-dependent.
Lang and Util PackagesFor a synopsis of java.lang and java.util enhancements, click the above link.
NetworkingFor a synopsis of added networking features, click the above link.
SecurityThis release of J2SE offers significant enhancements for security. It provides better support for security tokens, support for more security standards (SASL, OCSP, TSP), improvements for scalability (SSLEngine) and performance, plus many enhancements in the crypto and Java GSS areas. For details see the above link.
InternationalizationEnhancements are as follows:
- Character handling is now based on version 4.0 of the Unicode standard. This affects the
Stringclasses in the
java.lang package, the collation and bidirectional text analysis functionality in the
java.text package, character classes in the
java.util.regexpackage, and many other parts of the J2SE. As part of this upgrade, support for supplementary characters has been specified by the JSR 204 expert group and implemented throughout the J2SE. See the article Supplementary Characters in the Java Platform, the Java Specification Request 204, and the
Characterclass documentation for more information.
- The DecimalFormat class has been enhanced to format and parse
BigIntegervalues without loss of precision. Formatting of such values is enhanced automatically; parsing into BigDecimal needs to be enabled using the
- Vietnamese is now supported in all locale sensitive functionality in the
java.textpackages. See the Supported Locales document for complete information on supported locales and writing systems.
Improved Support for Environment VariablesThe
System.getenv(String)method is no longer deprecated. The new
System.getenv()method allows access to the process environment as a
ProcessBuilderclass provides a more convenient way to invoke subprocesses than does Runtime.exec. In particular, ProcessBuilder makes it easy to start a subprocess with a modified process environment (that is, one based on the parent's process environment, but with a few changes).
FormatterAn interpreter for printf-style format strings, the
Formatterclass provides support for layout justification and alignment, common formats for numeric, string, and date/time data, and locale-specific output. Common Java types such as
java.util.Calendarare supported. Limited formatting customization for arbitrary user types is provided through the
java.util.Scannerclass can be used to convert text into primitives or
Strings. Since it is based on the
java.util.regexpackage, it also offers a way to conduct regular expression based searches on streams, file data, strings, or implementors of the
ReflectionHave added support for generics, annotations, enums and have added convenience methods. Also have generified the class java.lang.Class.
JavaBeans Component ArchitectureA subclass of
IndexedPropertyChangeEventhas been added to support bound properties that use an index to identify the part of the bean that changed. Also, methods have been added to the
PropertyChangeSupportclass to support firing indexed property change events.
Collections FrameworkThe Collections Framework has been enhanced in the following ways:
- Three new language features are targeted at collections: Generics, Enhanced
forLoop, and Autoboxing.
- Three new interfaces have been added to the framework (two of which are part of
- Two concrete implementations of
Queuehave been added, as well as one skeletal implementation.
- Five blocking queue implementations have been added, and one
Setimplementations are provided for use with typesafe enums.
- Special-purpose copy-on-write
Setimplementations have been added.
- Wrapper implementations are provided to add dynamic type-safety for most collection interfaces.
- Several new algorithms are provided for manipulating collections.
- Methods are provided to compute hash codes and string representations for arrays.
Java API for XML Processing (JAXP)Click the above link for details or refer to JSR 206.
Bit Manipulation OperationsThe wrapper classes (
Char) now support common bit manipulation operations which include
MathThe numerical functionality provided by the libraries has been augmented in several ways:
BigDecimalclass has added support for fixed-precision floating-point computation. Refer to JSR 13.
StrictMathlibraries include hyperbolic transcendental functions (sinh, cosh, tanh), cube root, base 10 logarithm, etc.
- Hexadecimal floating-point support - To allow precise and predictable specification of particular floating-point values, hexadecimal notation can be used for floating-point literals and for string to floating-point conversion methods in
java.lang.instrumentpackage provides services that allow Java programming agents to instrument programs running on the Java virtual machine. The intrumentation mechanism is modification of the bytecodes of methods.
SerializationSupport has been added to handle enumerated types which are new in version 5.0. The rules for serializing an enum instance differ from those for serializing an "ordinary" serializable object: the serialized form of an enum instance consists only of its enum constant name, along with information identifying its base enum type. Deserialization behavior differs as well--the class information is used to find the appropriate enum class, and the Enum.valueOf method is called with that class and the received constant name in order to obtain the enum constant to return.
java.util.concurrent.lockspackages provide a powerful, extensible framework of high-performance, scalable, thread-safe building blocks for developing concurrent classes and applications, including thread pools, thread-safe collections, semaphores, a task scheduling framework, task synchronization utilities, atomic variables, and locks. The addition of these packages to the core class library frees the programmer from the need to craft these utilities by hand, in much the same manner that the Collections Framework did for data structures. Additionally, these packages provide low-level primitives for advanced concurrent programming which take advantage of concurrency support provided by the processor, enabling programmers to implement high-performance, highly scalable concurrent algorithms in the Java language to a degree not previously possible without resorting to native code. Refer to JSR 166 .
java.lang.Threadclass has the following enhancements:
- Thread priority handling has changed; see the above link for details.
Thread.Stateenum class and the new
getState()API are provided for querying the execution state of a thread.
- The new thread dump API - the
getAllStackTracesmethods in the
Threadclass - provides a programmatic way to obtain the stack trace of a thread or all threads.
uncaughtExceptionHandlermechanism, previously available only through the ThreadGroup class, is now available directly through the Thread class.
- A new form of the
sleep()method is provided which allows for sleep times smaller than one millisecond.
Monitoring and ManagementThis release of J2SE offers significant enhancements for monitoring and management for the Java platform. See the above link for details.
- Monitoring and management API for the Java virtual machine
java.lang.managementpackage provides the interface for monitoring and managing the Java virtual machine.
- Monitoring and management API for the logging facility
java.util.logging.LoggingMXBeaninterface is the management interface for the logging facility.
- JMX instrumentation of the Java virtual machine
The Java virtual machine (JVM) has built-in instrumentation that enables you to monitor and manage it using JMX. You can easily start a JMX agent for monitoring and managing remote or local Java VMs instrumentation or of any application with JMX instrumentation. See Monitoring and Management Using JMX for details.
- The SNMP agent publishes the standard MIB for the Java virtual machine instrumentation as defined by JSR 163. For more information, see SNMP Monitoring and Management.
- JavaTM Management Extensions
JMXTM API version 1.2 and the RMI connector of the JMX Remote API version 1.0 are included in J2SE 5 release. The JMX API allows you to instrument libraries and applications for monitoring and management. The RMI connector allows this instrumentation to be remotely accessible. See the JMX documentation for more details.
Remote Method Invocation (RMI)RMI has been enhanced in the following areas:
- Dynamic Generation of Stub Classes - This release adds support for the dynamic generation of stub classes at runtime, obviating the need to use the Java Remote Method Invocation (Java RMI) stub compiler, rmic, to pregenerate stub classes for remote objects. Note that rmic must still be used to pregenerate stub classes for remote objects that need to support clients running on earlier versions.
- Standard SSL/TLS Socket Factory Classes - This release adds standard Java RMI socket factory classes,
javax.rmi.ssl.SslRMIServerSocketFactory, which communicate over the Secure Sockets Layer (SSL) or Transport Layer Security (TLS) protocols using the Java Secure Socket Extension (JSSE).
- Launching rmid or a Java RMI Server from inetd/xinetd - A new feature, provided by the
System.inheritedChannelmethod, allows an application to obtain a channel (
java.nio.channels.ServerSocketChannel, for example) inherited from the process that launched the virtual machine (VM). Such an inherited channel can be used to either service a single incoming connection (as with
SocketChannel) or accept multiple incoming connections (as with
ServerSocketChannel). Therefore, Java networking applications launched by inetd (Solaris(tm) Operating System) or xinetd (Linux) can now obtain the
ServerSocketChannelinherited from inetd/xinetd.
Java Database Connectivity (JDBC)
RowSetinterface, part of the
javax.sqlpackage, introduced in J2SE version 1.4, provides a lightweight means of passing data between components.
At this release, as an aid to developers, the
RowSetinterface has been implemented (as JSR 114) in five of the more common ways a
RowSetobject can be used. These implementations provide a standard that developers are free to use as is or to extend.
Following are the five standard implementations:
JdbcRowSet- used to encapsulate a result set or a driver that is implemented to use JDBC technology
CachedRowSet- disconnects from its data source and operates independently except when it is getting data from the data source or writing modified data back to the data source. This makes it a lightweight container for as much data as it can store in memory.
CachedRowSetand is used to get a subset of data
CachedRowSetand is used to get an SQL
JOINof data from multiple
CachedRowSetand is used for XML data. It describes tabular components in XML using a standardized XML schema.
CORBA, Java IDL, and Java RMI-IIOP
Enhancements to CORBA, Java IDL, and Java RMI-IIOP are discussed in Changes in CORBA Features Between J2SE 1.4.x and 5.0.
Java Naming and Directory InterfaceTM (JNDI)JNDI provides the following new features.
- Enhancements to javax.naming.NameClassPair to access the fullname from the directory/naming service
- Support for standard LDAP controls: Manage Referral Control, Paged Results Control and Sort Control
- Support for manipulation of LDAP names.
- To render multilingual text, using logical fonts, 2D now takes advantage of installed host OS fonts for all supported writing systems. For example, if you run in a Thai locale environment, but have Korean fonts installed, both Thai and Korean are rendered. The J2RE now also automatically detects physical fonts that are installed into its lib/fonts/fallback directory and adds these physical fonts to all logical fonts for 2D rendering.
- AWT now uses the Unicode APIs on Windows 2000/XP. As a result, some of its components can handle text without being restricted by Windows locale settings. For example, AWT text components can accept and display text in the Devanagari writing system regardless of the Windows locale settings.
Java Sound Technology
- Ports are now available on all platforms (RFE 4782900).
- MIDI device i/o is now available on all platforms (RFE's 4812168, 4782924).
- Optimized direct audio access is implemented on all platforms (RFEs 4908240 and 4908879). It is enabled by default on systems which offer native mixing (i.e. Linux ALSA with hardware mixing, Solaris Mixer enabled, Windows DirectSound).
- The new real-time Sequencer works with all MIDI devices and allows unlimited Transmitters (RFE 4773012).
sound.propertiesconfiguration file allows choice of default devices (RFE 4776511). For details, see
- MidiDevices can query connected Receivers and Transmitters (RFE 4931387, methods MidiDevice.getReceiver and MidiDevice.getTransmitter).
MidiFileFormatnow have properties that allow further description and qualification of the format (RFEs 4925767 and 4666845).
- A set of ease-of-use methods allow easier retrieval of lines from AudioSystem (RFE 4896221).
- The Sequencer interface is extended with loop methods, for seamless looping of specific portions of a MIDI sequence (RFE 4204105).
- Java Sound no longer prevents the VM from exiting (bug 4735740).
Java 2DTM TechnologyAdded 2D features include expanded Linux and Solaris printer support, new methods for creating fonts from files and streams, and new methods related to VolatileImages and hardware acceleration of images. A number of internal changes to text rendering code greatly improve its robustness, performance, and scalability. Other performance work includes hardware-accelerated rendering using OpenGL (disabled by default).
Image I/OThe Image I/O system now has readers and writers for BMP and WBMP formats.
AWTVersion 5.0 features many AWT enhancements and bug fixes, including some that have often been requested by our customers. Most notably, the new
MouseInfoclass makes it possible to determine the mouse location on the desktop. New
Windowmethods make it possible to specify the default location for a newly created window (or frame), appropriate to the platform. Another
Windowenhancement makes it possible to ensure that a window (or frame) is always on top. (This feature does not work for some window managers on Solaris/Linux.) In the area of data transfer, the new
DropTargetDragEventAPI allows the drop target to access transfer data during the drag operation.
SwingWith the 1.4.2 release we provided two new look and feels for Swing: XP and GTK. Rather than taking a break, in 5.0 we're providing two more look and feels: Synth, a skinnable look and feel, and Ocean, a new theme for Metal. Beyond look and feels, we've added printing support to JTable, which makes it trivial to get a beautiful printed copy of a JTable. Lastly, after seven years, we've made jFrame.add equivalent to jFrame.getContentPane().add().
General DeploymentPack200, a new hyper-compression format for JAR files defined by JSR 200, can significantly reduce the download size of JAR files used in Java Webstart applications and Java Plug-in applets.
For a synopsis of general deployment features and enhancements, click the General Deployment link above.
Java Web Start DeploymentFor a synopsis of Java Web Start deployment features and enhancements, click the above link.
Java Virtual Machine Tool Interface (JVMTI)JVMTI is a new native programming interface for use by development and monitoring tools. It provides both a way to inspect the state and to control the execution of applications running in the Java virtual machine (VM). JVMTI is intended to provide a VM interface for the full breadth of tools that need access to VM state, including but not limited to: profiling, debugging, monitoring, thread analysis, and coverage analysis tools.
JVMTI will replace the now deprecated JVMPI and JVMDI in the next major release of J2SE.
Java Platform Debugger Architecture (JPDA)JPDA itself has many new features, described in more detail on the JPDA enhancements page.
- A read-only subset of JDI has been defined. This subset can be used on a debuggee in which no debug code can be executed (such as a core file or a process that is hung or was not started in debug mode). The subset allows creation of JDI connectors for use in debugging such debuggees.
- A service provider interface for connectors and transports allows debugger vendors, or even end users, to create their own JDI connectors and transports and plug them into the JPDA reference implementation. For example, a connector could be provided to use SSL to communicate between the debugger and debuggee.
- JDI supports the new language features (generics, enums, and varargs).
- The lowest layer of JPDA, the Java Virtual Machine Debugger Interface (JVMDI), has been deprecated and will be removed in the next major J2SE release. Replacing it is the Java Virtual Machine Tool Interface (JVMTI). This is a more general interface that allows profiling to be done as well as debugging. The current profiling interface, Java Virtual Machine Profiling Interface(JVMPI) is also deprecated and will be removed in the next major release.
- The JPDA reference implementation includes new JDI connectors that allow corefiles and hung processes to be debugged.
Java Compiler (javac)Compiler options include:
-source 1.5- Enable 1.5 specific language features to be used in source files. (
-target 1.5is implied.)
-target 1.5- Allow javac to use 1.5 specific features in the libraries and virtual machine.
-Xlint- Enable javac to produce warning messages about legal, but suspect and often problematic, program constructs. An example would be declaring a class that implements
Serializablebut does not define a
-d32- Indicate a 32-bit Solaris or Linux platform.
-d64- Indicate a 64-bit Solaris or Linux platform.
-target cldc1.0- Generate class files suitable for use on VMs in Connected Limited Device Configuration (CLDC) version 1.0 and later. The compiler generates stack maps making the use of the preverifier unnecessary.
New Programmatic Interface
com.sun.tools.javac.Mainclass provides two static methods to invoke the compiler from a program. See the man page for details.
Javadoc ToolSee What's New in Javadoc 5.0
Annotation Processing Tool (
aptis a new command-line utility for annotation processing. It includes a set of reflective APIs and supporting infrastructure to process program annotations.
Java TM 2 Platform, Standard Edition 5.0 Trouble-Shooting and Diagnostic GuideThis guide provides descriptions of tools, options, and other items for use in analyzing problems. It contains suggestions about what to try before submitting a bug report and what data to collect for a report.
Supported System ConfigurationsFor more information, click the above link.
64-Bit AMD Opteron ProcessorsWith J2SE 5, AMD Opteron processors are supported by the server VM on Suse Linux and on Windows 2003.
Copyright © 2004 Sun Microsystems, Inc. All Rights Reserved.