Effective Java

// type of the array won't be E[]; it will always be Object[]!
@SuppressWarnings("unchecked") 
public Stack() {
elements = (E[]) new Object[DEFAULT_INITIAL_CAPACITY];
}
The second way to eliminate the generic array creation error in 
Stack
is to
change the type of the field 
elements
from 
E[]
to 
Object[]
. If you do this, you’ll
get a different error:
Stack.java:19: incompatible types
found: Object, required: E
E result = elements[--size];
^
You can change this error into a warning by casting the element retrieved from the
array to 
E
, but you will get a warning:
Stack.java:19: warning: [unchecked] unchecked cast
found: Object, required: E
E result = 
(E)
elements[--size];
^

---

ITEM 29: FAVOR GENERIC TYPES
133
Because 
E
is a non-reifiable type, there’s no way the compiler can check the
cast at runtime. Again, you can easily prove to yourself that the unchecked cast is
safe, so it’s appropriate to suppress the warning. In line with the advice of Item 27,
we suppress the warning only on the assignment that contains the unchecked cast,
not on the entire 
pop
method:
// Appropriate suppression of unchecked warning
public E pop() {
if (size == 0)
throw new EmptyStackException();
// push requires elements to be of type E, so cast is correct
@SuppressWarnings("unchecked") 
E result = 
(E) elements[--size];
elements[size] = null; // Eliminate obsolete reference
return result;
}
Both techniques for eliminating the generic array creation have their
adherents. The first is more readable: the array is declared to be of type 
E[]
,
clearly indicating that it contains only 
E
instances. It is also more concise: in a
typical generic class, you read from the array at many points in the code; the first
technique requires only a single cast (where the array is created), while the second
requires a separate cast each time an array element is read. Thus, the first
technique is preferable and more commonly used in practice. It does, however,
cause 
heap pollution
(Item 32): the runtime type of the array does not match its
compile-time type (unless 
E
happens to be 
Object
). This makes some
programmers sufficiently queasy that they opt for the second technique, though
the heap pollution is harmless in this situation.
The following program demonstrates the use of our generic 
Stack
class. The
program prints its command line arguments in reverse order and converted to
uppercase. No explicit cast is necessary to invoke 
String
’s 
toUpperCase
method
on the elements popped from the stack, and the automatically generated cast is
guaranteed to succeed: