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. See the Generics
Tutorial. (JSR 14)
Enhanced for
Loop - This new language construct eliminates the
drudgery and error-proneness of iterators and index
variables when iterating over collections and arrays. (JSR
201)
Autoboxing/Unboxing -
This facility eliminates the drudgery of manual conversion
between primitive types (such as int) and wrapper types
(such as Integer). (JSR
201)
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. (JSR
201)
Varargs - This
facility eliminates the need for manually boxing up
argument lists into an array when invoking methods that
accept variable-length argument lists.
Static Import -
This facility lets you avoid qualifying static members with
class names without the shortcomings of the "Constant
Interface antipattern." (JSR
201)
Annotations
(Metadata) - 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. (JSR
175)
NOTE: The @Deprecated annotation provides a
way to deprecate program elements. See How and When
To Deprecate APIs.
Generics papers
JSR14: Adding Generic Types to the Java Programming
Language
Assertion Facility -
Assertions are boolean expressions that the programmer
believes to be true concerning the state of a computer
program. For example, after sorting a list, the programmer
might assert that the list is in ascending order.
Evaluating assertions at runtime to confirm their validity
is one of the most powerful tools for improving code
quality, as it quickly uncovers the programmer's
misconceptions concerning a program's behavior.