Performance Enhancements

For a synopsis of performance enhancements, see
Performance Enhancements at
http://java.sun.com/j2se/1.5.0/docs/guide/performance/speed.html.

Java Language Features

For more information see
New Language Features at
http://java.sun.com/j2se/1.5.0/docs/guide/language/index.html.

Generics

This 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
and to the generics documentation at
http://java.sun.com/j2se/1.5.0/docs/guide/language/generics.html.

Typesafe Enums

This 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
and to the documentation at
http://java.sun.com/j2se/1.5.0/docs/guide/language/enums.html.

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
and to the documentation at
http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html.

Virtual Machine

Class Data Sharing

The 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, refer to the documentation at
http://java.sun.com/j2se/1.5.0/docs/guide/vm/class-data-sharing.html.

Garbage Collector Ergonomics

The 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,
refer to the documentation at
http://java.sun.com/j2se/1.5.0/docs/guide/vm/gc-ergonomics.html.

Fatal Error Handling

The fatal error reporting mechanism has been enhanced to provide
improved diagnostic output and reliability.

High-Precision Timing Support

The 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.

Networking

Security

This 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 documentation at
http://java.sun.com/j2se/1.5.0/docs/guide/security/index.html.

Internationalization

Enhancements are as follows:

Character handling is now based on version 4.0 of the Unicode standard.
This affects the Character and
String classes in the java.lang package,
the collation and bidirectional text analysis
functionality in the java.text package, character classes in
the
java.util.regex package, 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
Character
class documentation for more information.

The DecimalFormat class
has been enhanced to format and parse
BigDecimal and BigInteger values
without loss of precision. Formatting of such values is
enhanced automatically; parsing into BigDecimal needs to be enabled
using the
setParseBigDecimal
method.

Vietnamese is now supported in all locale sensitive functionality
in the java.util and java.text packages.
See the
Supported Locales
document for complete information on supported locales and writing
systems.

Formatter

An interpreter for printf-style format strings, the Formatter
class 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 byte,
java.math.BigDecimal
, and
java.util.Calendar
are supported. Limited formatting customization for arbitrary user types
is provided through the
java.util.Formattable interface.

Refer to the documentation at
http://java.sun.com/j2se/1.5.0/docs/api/java/util/Formatter.html.

JavaBeans Component Architecture

A subclass of PropertyChangeEvent called
IndexedPropertyChangeEvent has 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 PropertyChangeSupport class to
support firing indexed property change events.
Refer to the documentation at
http://java.sun.com/j2se/1.5.0/docs/guide/beans/index.html.

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 Float and
Double.

Instrumentation

The new java.lang.instrument
package 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.

Serialization

Support has been added to handle enumerated types which are new in version
1.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.

Concurrency Utilities

The java.util.concurrent,
java.util.concurrent.atomic,
and
java.util.concurrent.locks packages 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.

The new thread dump API - the
getStackTrace and
getAllStackTraces methods
in the Thread class - provides
a programmatic way to obtain the stack trace of a thread or all threads.

The
uncaughtExceptionHandler
mechanism, 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 Management

This release of J2SE offers significant
enhancements for monitoring and management for the Java platform.

Monitoring and management API for the Java virtual machine
The new java.lang.management package provides the
interface for monitoring and managing the Java virtual machine.

Monitoring and management API for the logging facility
The new java.util.logging.LoggingMXBean interface
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
at http://java.sun.com/j2se/1.5.0/docs/guide/management/agent.html
for details.

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.
For more details, see the
JMX documentation at
http://java.sun.com/j2se/1.5.0/docs/guide/management/index.html.

Integration Libraries

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.

Launching rmid or a Java RMI Server from inetd/xinetd -
A new feature, provided by the System.inheritedChannel
method, allows an application to obtain a channel
(java.nio.channels.SocketChannel or
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 SocketChannel or
ServerSocketChannel inherited from inetd/xinetd.

Java Database Connectivity (JDBC)

RowSet
interface, part of the
javax.sql
package, introduced in J2SE version 1.4, provides a lightweight
means of passing data between components.

At this release, as an aid to developers, the RowSet
interface has been implemented (as JSR 114) in five of the more common ways a
RowSet object 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.

FilteredRowSet - extends CachedRowSet and is used
to get a subset of data

JoinRowSet - extends CachedRowSet
and is used to get an SQL JOIN of data from multiple
RowSet objects

WebRowSet - extends CachedRowSet
and is used for XML data. It describes tabular components in XML using
a standardized XML schema.

User Interface

Internationalization

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 2DTM Technology

Added 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/O

AWT

Version 1.5.0 features many AWT enhancements and bug fixes,
including some that have often been requested by our customers.
Most notably, the new MouseInfo class makes
it possible to determine the mouse location on the desktop.
New Window methods make it possible to specify
the default location for a newly created window (or frame),
appropriate to the platform.
Another Window enhancement 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 DropTargetDragEvent
API allows the drop target to access transfer data during
the drag operation.

Swing

With the 1.4.2 release we provided two new look and feels for Swing:
XP and GTK. Rather than taking a break, in 1.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().

Java Web Start Deployment

Tools and Tool Architecture

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)

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)

-source 1.5 - Enable 1.5 specific language features to be
used in source files. (-target 1.5 is 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
Serializable but does not define a serialVersionUID.