目录
二十三、请不要在新代码中使用原生态类型
二十四、消除非受检警告
二十五、列表优先于数组
二十六、优先考虑泛型
二十七、优先考虑泛型方法
二十八、利用有限制通配符来提升API的灵活性
二十九、优先考虑类型安全的异构容器
二十三、请不要在新代码中使用原生态类型
声明中具有一个或者多个类型参数的类或者接口，就是泛型类或接口，如List<E>，这其中E表示List集合中元素的类型。在Java中，相对于每个泛型类都有一个原生类与之对应，即不带任何实际类型参数的泛型名称，如List<E>的原生类型List。他们之间最为明显的区别在于List<E>包含的元素必须是E(泛型)类型，如List<String>，那么他的元素一定是String，否则将产生编译错误。和泛型不同的是，原生类型List可以包含任何类型的元素，因此在向集合插入元素时，即使插入了不同类型的元素也不会引起编译期错误。那么在运行，当List的使用从List中取出元素时，将不得不针对类型作出判断，以保证在进行元素类型转换时不会抛出ClassCastException异常。由此可以看出，泛型集合List<E>不仅可以在编译期发现该类错误，而且在取出元素时不需要再进行类型判断，从而提高了程序的运行时效率。
//原生类型的使用方式
class TestRawType {
private final List stamps = new List();
public static void main(String[] args) {
stamps.add(new Coin(...));
for (Iterator i = stamps.iterator(); i.hasNext(); ) {
Stamp s = (Stamp)i.next(); //这里将抛出类型转换异常
//TODO: do something.
}
}
}
//泛型类型的使用方式
class TestGenericType {
private final List<Stamp> stamps = new List<Stamp>();
public static void main(String[] args) {
stamps.add(new Coin(...)); //该行将直接导致编译错误。
for (Stamp s : stamps) { //这里不再需要类型转换了。
//TODO: do something
}
}
}可以看出，泛型相对于原生态类型在安全性和表达性方面的有着非常明显的优势。使用原生态类型的目的是为了提供兼容性，毕竟泛型是在Java1.5中才推出的。
现在我们比较一下List和List<Object>这两个类型之间的主要区别，尽管这两个集合可以包含任何类型的对象元素，但是前者是类型不安全的，而后者则明确告诉使用者可以存放任意类型的对象元素。另一个区别是，如果void func(List l)改为void func(List<Object> l)，List<String>类型的对象将不能传递给func函数，因为Java将这两个泛型类型视为完全不同的两个类型。
在不确定或者不在乎集合中的元素类型的情况下，你也许会使用原生态类型。假设想要编写一个方法，它有两个集合（set），并从中返回它们共有的元素的数量，下面是用原生态类型编写的方法：
static int numElementsInCommon(Set s1, Set s2) {
int result = 0;
for (Object o1 : s1)
if (s2.contains(o1))
result++;
return result;
}方法可以使用，但是非常危险，不安全。从Java1.5开始，提供了一种安全的替代方法，称作无限制的通配符类型，如果要使用泛型，但不确实或者不关心实际的类型参数，就可以使用一个问号代替。如，泛型Set<E>的无限制通配符类型为Set<?>，这是最普通的参数化Set类型，可以持有任何集合。
static int numElementsInCommon(Set<?> s1, Set<?> s2) {
int result = 0;
for (Object o1 : s1)
if (s2.contains(o1))
result++;
return result;
}在新代码中不要使用原生类型，这条规则有两个例外，两者都源于“泛型信息可以在运行时被擦除”这一事实。在Class对象中必须要使用原生类型。JLS不允许使用Class的参数化类型。换句话说，List.class, String[].class和int.class都是合法的，但是List<String>.class和List<?>.class则是不合法。这条规则的第二个例外与instanceof操作符相关。由于泛型信息可以在运行时被擦除，因此在泛型类型上使用instanceof操作符是非法的。下面是利用泛型来使用instanceof操作符的首选方法：
if (o instanceof Set) {
Set<?> m = (Set<?>)o;
}总之，使用原生态类型会在运行时导致异常，因此不要在代码中使用。Set<Object>是个参数化类型，表示可以包含任何对象类型的一个集合；Set<?>则是一个通配符类型，表示只能包含某种未知对象类型的一个集合；Set则是个原生态类型，它脱离了泛型系统。前两种是安全的，最后一种不安全。
二十四、消除非受检警告
在进行泛型编程时，经常会遇到编译器报出的非受检警告(unchecked cast warnings)，如：Set<Lark> exaltation = new HashSet(); 对于这样的警告要尽可能在编译期予以消除：Set<Lark> exaltation = new HashSet<Lark>();。对于一些比较难以消除的非受检警告，可以通过@SuppressWarnings("unchecked")注解来禁止该警告，前提是你已经对该条语句进行了认真地分析，确认运行期的类型转换不会抛出ClassCastException异常。同时要在尽可能小的范围了应用该注解(SuppressWarnings)，如果可以应用于变量，就不要应用于函数。尽可能不要将该注解应用于Class，这样极其容易掩盖一些可能引发异常的转换。见如下代码：
public <T> T[] toArray(T[] a) {
if (a.length < size)
return (T[])Arrays.copyOf(elements,size,a.getClass());
System.arraycopy(elements,0,a,0,size);
if (a.length > size)
a[size] = null;
return a;
}编译该代码片段时，编译器会针对(T[])Arrays.copyOf(elements,size,a.getClass())语句产生一条非受检警告，现在我们需要做的就是添加一个新的变量，并在定义该变量时加入@SuppressWarnings注解，见如下修订代码：
public <T> T[] toArray(T[] a) {
if (a.length < size) {
//TODO: 加入更多的注释，以便后面的维护者可以非常清楚该转换是安全的
@SuppressWarnings("unchecked") T[] result =
(T[])Arrays.copyOf(elements,size,a.getClass());
return result;
}
System.arraycopy(elements,0,a,0,size);
if (a.length > size)
a[size] = null;
return a;
}
二十五、列表优先于数组
数组和泛型相比，有两个重要的不同点。首先就是数组是协变的，如：Object[] objArray = new Long[10]是合法的，因为Long是Object的子类，与之相反，泛型是不可协变的，如List<Object> objList = new List<Long>()是非法的，将无法通过编译。因此泛型可以保证更为严格的类型安全性，一旦出现插入元素和容器声明时不匹配的现象是，将会在编译期报错。二者的另一个区别是数组是具体化的，因此数组会在运行时才知道并检查它们的元素类型约束。如将一个String对象存储在Long的数组中时，就会得到一个ArrayStoreException异常。相比之下，泛型则是通过擦除来实现的。因此泛型只是在编译时强化类型信息，并在运行时丢弃它们的元素类型信息。擦除就是使泛型可以与没有使用泛型的代码随意进行交互。由此可以得出混合使用泛型和数组是比较危险的，因为Java的编译器禁止了这样的使用方法，一旦使用，将会报编译错误。
当你得到泛型数组创建错误时，最好的解决办法通常是优先使用集合类型List<E>，而不是数组类型E[]。这样可能会损失一些性能或简洁性，但是换回的却是更高的类型安全性和互用性。
static Object reduce(List l, Function f, Object initVal) {
Object[] snapshot = l.toArray();
Object result = initVal;
for (Object o : snapshot) {
result = f.apply(result,o);
}
return result;
}
interface Function {
Object apply(Object arg1, Object arg2);
}从以上函数和接口的定义可以看出，如果他们被定义成泛型函数和泛型接口，将会得到更好的类型安全，同时也没有对他们的功能造成任何影响，见如下修改为泛型的示例代码：
static <E> E reduce(List<E> l,Function<E> f,E initVal) {
E[] snapshot = l.toArray();
E result = initVal;
for (E e : snapshot) {
result = f.apply(result,e);
}
return result;
}
interface Function<E> {
E apply(E arg1,E arg2);
}这样的写法回提示一个编译错误，即E[] snapshot = l.toArray();是无法直接转换并赋值的。修改方式也很简单，直接强转就可以了，如E[] snapshot = (E[])l.toArray();在强转之后，仍然会收到编译器给出的一条警告信息，即无法在运行时检查转换的安全性。尽管结果证明这样的修改之后是可以正常运行的，但是这样的写法确实也是不安全的，更好的办法是通过List<E>替换E[]，见如下修改后的代码：
static <E> E reduce(List<E> l,Function<E> f,E initVal) {
List<E> snapshot;
synchronized(l) {
snapshot = new ArrayList<E>(l);
}
E result = initVal;
for (E e : snapshot) {
result = f.apply(result,e);
}
return result;
} 总而言之，数组和泛型有着不同的类型规则。数组是协变且可以具体变化的；泛型是不可变的且可以被擦除的。因此，数组提供了运行时的类型安全，但是没有编译时的类型安全，泛型则反之。一般来说，数组和泛型不能很好地混合使用。如果你发现自己将它们混合起来使用，并且得到了编译时错误或者警告，你的第一反应应该是用列表代替数组。
二十六、优先考虑泛型
如第6条中的这个简单的堆栈实现：
public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;
public Stack() {
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}
public void push(Object e) {
ensureCapacity();
elements[size++] = e;
}
public Object pop() {
if (size == 0)
throw new EmptyStackException();
Object result = elements[--size];
elements[size] = null;
return result;
}
public boolean isEmpty() {
return size == 0;
}
private void ensureCapacity() {
if (elements.length == size)
elements = Arrays.copyOf(elements,2 * size + 1);
}
}再看与之相对于的泛型集合实现方式：
public class Stack<E> {
private E[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;
public Stack() {
elements = new E[DEFAULT_INITIAL_CAPACITY];
}
public void push(E e) {
ensureCapacity();
elements[size++] = e;
}
public E pop() {
if (size == 0)
throw new EmptyStackException();
E result = elements[--size];
elements[size] = null;
return result;
}
public boolean isEmpty() {
return size == 0;
}
private void ensureCapacity() {
if (elements.length == size)
elements = Arrays.copyOf(elements,2 * size + 1);
}
}上面的泛型集合类Stack<E>在编译时会引发一个编译错误，即elements = new E[DEFAULT_INITIAL_CAPACITY]语句不能直接创建不可具体化类型的数组。第一种修改方式如下：创建Object数组，并将其转换成泛型数组类型，只要我们保证所有push到该数组中的对象均为该类型的对象即可，剩下需要做的就是添加注解以消除该警告：
@SuppressWarning("unchecked")
public Stack() {
elements = (E[])new Object[DEFAULT_INITIAL_CAPACITY];
}第二种修改方法是：将elements域的类型从E[]改为Object[]，并将从数组中获取的元素由Object转换成E，最后在包含未受检转换的任务上禁止警告，而不是在整个方法上：
public class Stack<E> {
private Object[] elements;
public Stack() {
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}
public E pop() {
if (size == 0)
throw new EmptyStackException();
@SuppressWarning("unchecked") E result = (E)elements[--size];
elements[size] = null;
return result;
}
} 由于禁止数组类型的未受检比禁止标量类型的更加危险，所以第二种案发更加安全。但是在实际的泛型类中，代码中会有多个地方需要从数组中读出元素，而选择第二种方案需要多次转换成E，这是第一种方案更加常用的原因。
第25条的优先使用列表与此矛盾，实际上并不能总想在泛型中使用列表。有些泛型如ArrayList，则必须在数组上实现。为了提升性能，其他泛型如HashMap也在数组上实现。注意：泛型的类型参数不能为基本类型：企图创建Stack<int>或者Stack<double>会产生编译时错误，这是Java泛型系统根本的局限性，可以通过使用基本包装类型来避开这条限制。
总而言之，使用泛型比使用需要在客户端代码中进行转换的类型来的更加安全，也更加容易。在设计新类型的时候，要确保它们不需要这种转换就可以使用。这通常意味着要把类做成是泛型的。
二十七、优先考虑泛型方法
和优先选用泛型类一样，我们也应该优先选用泛型方法。特别是静态工具方法尤其适合于泛型化。如Collections.sort()和Collections.binarySearch()等静态方法都泛型化了。下面这个方法返回两个集合的联合：
public static Set union(Set s1, Set s2) {
Set result = new HashSet(s1);
result.addAll(s2);
return result;
}这个方法在编译时会有警告报出。为了修正这些警告，最好的方法就是使该方法变为类型安全的，要将方法声明修改为声明一个类型参数，表示这三个集合的元素类型，并在方法中使用类型参数，见如下修改后的泛型方法代码：
public static <E> Set<E> union(Set<E> s1,Set<E> s2) {
Set<E> result = new HashSet<E>(s1);
result.addAll(s2);
return result;
}对于简单的泛型方法，这样修改后不会产生任何警告，并提供了类型安全性，也更容易使用：
public static void main(String[] args) {
Set<String> guys = new HashSet<String>(Arrays.asList("Tom", "Dick", "Harry"));
Set<String> stooges = new HashSet<String>(Arrays.asList("Larry", "Moe", "Curly"));
Set<String> aflCio = union(guys, stooges);
System.out.println(aflCio);
}很明显，以上代码在等号的两边都显示的给出了类型参数，并且必须是一致的。为了消除这种重复，可以编写一个泛型静态工厂方法，与想要使用的每个构造器相对应，如：
public static <K,V> HashMap<K,V> newHashMap() {
return new HashMap<K,V>();
}我们的调用方式也可以改为：Map<String,List<String>> anagrams = newHashMap();
除了在以上的情形下使用泛型函数之外，我们还可以在泛型单例工厂的模式中应用泛型函数，这些函数通常为无状态的，且不直接操作泛型对象的方法，见如下示例：
public interface UnaryFunction<T> {
T apply(T arg);
}
class SingletonFactory {
private static UnaryFunction<Object> IDENTITY_FUNCTION =
new UnaryFunction<Object>() {
public Object apply(Object arg) { return arg; }
};
@SuppressWarning("unchecked")
public static <T> UnaryFunction<T> identityFunction() {
return (UnaryFunction<T>)IDENTITY_FUNCTION;
}
} 调用方式如下：
public static void main(String[] args) {
String[] strings = {"jute","hemp","nylon"};
UnaryFunction<String> sameString = identityFunction();
for (String s : strings)
System.out.println(sameString.apply(s));
Number[] numbers = {1,2.0,3L};
UnaryFunction<Number> sameNumber = identityFunction();
for (Number n : numbers)
System.out.println(sameNumber.apply(n));
}对于该静态函数，如果我们为类型参数添加更多的限制条件，如参数类型必须是Comparable<T>的实现类，这样我们的函数对象便可以基于该接口做更多的操作，而不仅仅是像上例中只是简单的返回参数对象，见如下代码：
public static <T extends Comparable<T>> T max(List<T> l) {
Iterator<T> i = l.iterator();
T result = i.next();
while (i.hasNext()) {
T t = i.next();
if (t.compareTo(result) > 0)
result = T;
}
return result;
} 总而言之，泛型方法就想泛型对象一样，提供了更为安全的使用方式。
二十八、利用有限制通配符来提升API的灵活性
前面说过，参数哈类型是不可变的，而有时候，我们需要的灵活性要比不可变类型所能提供的更多，如第26条的堆栈：
public class Stack<E> {
public Stack();
public void push(E e);
public E pop();
public boolean isEmpty();
}现在我们需要增加一个方法：
public void pushAll(Iterable<E> src) {
for (E e : src)
push(e);
}但如果我们的E类型为Number，而需要将Integer对象也插入到该容器中，现在的写法将会导致编译错误，因为即使Integer是Number的子类，由于类型参数是不可变的，因此这样的写法也是错误的。需要进行如下的修改：
public void pushAll(Iterable<? extends E> src) {
for (E e : src)
push(e);
}public void popAll(Collection<E> dst) {
while (!isEmpty())
dst.add(pop());
}popAll方法将当前容器中的元素全部弹出，并以此添加到参数集合中。如果Collections中的类型参数和Stack完全一致，这样的写法不会有任何问题，然而在实际的应用中，我们通常会将Collection中的元素视为更通用的对象类型，如Object，见如下应用代码：
Stack<Number> numberStack = new Stack<Number>();
Collection<Object> objs = ...;
numberStack.popAll(objs);由于Collection<Object>不是Collection<Number>的子类型，因此会编译报错。此时将popAll参数类型改为Collection<? super E>：E的某种超类的集合。就可以解决问题：
public void popAll(Collection<? super E> dst) {
while (!isEmpty())
dst.add(pop());
} 现在看看第27条中union方法，下面是声明：public static <E> Set<E> union(Set<E> s1, Set<E> s2);
这里的s1和s2都是生产者，根据PECS原则，它们的声明可以改为：public static <E> Set<E> union(Set<? extends E> s1,Set<? extends E> s2);
注意，不要用通配符类型作为返回类型。修改后的union方法无法进行类型推导，应该增加显示类型参数：
Set<Integer> integers = new Set<Integer>();
Set<Double> doubles = new Set<Double>();
Set<Number> numbers = Union.<Number>union(integers,doubles); 现在我们再来看一下前面也给出过的max方法，其初始声明为：public static <T extends Comparable<T>> T max<List<T> srcList);
下面将逐一给出新声明的解释：
1.函数参数srcList产生了T实例，因此将类型从List<T>改为List<? extends T>。
2.最初T被指定为扩展Comparable<T>，然而Comparable又是T的消费者，用于比较两个T之间的顺序关系。因此参数化类型Comparable<T>被替换为Comparable<? super T>。注：Comparator和Comparable一样，他们始终都是消费者，因此Comparable<? super T> 优先于Comparable<T>。
总而言之，通配符类型虽然比较需要技巧，但是使API变得灵活。如果编写的是将被广泛使用的类库，则一定要适当地利用通配符类型。记住基本的原则：producer-extends, consumer-super(PECS)。还要记住所有的Comparator和Comparable都是消费者。
二十九、优先考虑类型安全的异构容器
泛型通常用于集合，如Set和Map等。这样的用法也就限制了每个容器只能有固定数目的类型参数，一般来说，这也确实是我们想要的。然而有的时候我们需要更多的灵活性，如数据库可以用任意多的Column，如果能以类型安全的方式访问所有Columns就好了，幸运的是有一种方法可以很容易的做到这一点，就是将key进行参数化，而不是将容器参数化，见以下代码：
public class Favorites {
public <T> void putFavorite(Class<T> type,T instance);
public <T> T getFavorite(Class<T> type);
}public static void main(String[] args) {
Favorites f = new Favorites();
f.putFavorite(String.class,"Java");
f.putFavorite(Integer.class,0xcafebabe);
f.putFavorite(Class.class,Favorites.class);
String favoriteString = f.getFavorite(String.class);
int favoriteInteger = f.getFavorite(Integer.class);
Class<?> favoriteClass = f.getFavorite(Class.class);
System.out.printf("%s %x %s\n",favoriteString,favoriteInteger,favoriteClass.getName());
}
//Java cafebabe Favorites这里Favorites实例是类型安全的：当你请求String的时候，它不会给你Integer。同时它也是异构：不像普通的Map，他的所有键都是不同类型的。因此，我们将Favorites称作类型安全的异构容器。下面就是Favorites的具体实现：
public class Favorites {
private Map<Class<?>,Object> favorites = new HashMap<Class<?>,Object>();
public <T> void putFavorite(Class<T> type,T instance) {
if (type == null)
throw new NullPointerException("Type is null");
favorites.put(type,type.cast(instance));
}
public <T> T getFavorite(Class<T> type) {
return type.cast(favorites.get(type));
}
} 可以看出每个Favorites实例都得到一个Map<Class<?>,Object>容器的支持，每个键都可以有一个不同的参数化类型，异构就是从这里来的。由于该容器的值类型为Object，即Map不能保证每个值的类型都与键的类型相同。为了进一步确实类型的安全性，我们在put的时候通过Class.cast()方法将Object参数尝试转换为Class所表示的类型，如果类型不匹配，将会抛出ClassCastException异常。以此同时，在从Map中取出值对象的时候，由于该对象当前的类型是Object，因此我们需要再次利用Class.cast()函数将其转换为我们的目标类型。
总而言之，集合API说明了泛型的一般用法，限制你每个容器只能有固定数目的类型参数。你可以通过将类型参数放在键上而不是容器上来避开这一限制。对于这种类型安全的异构容器，可以用Class对象作为键。以这种方式使用的Class对象称作类型令牌。你也可以使用定制的键的类型。例如，用一个DatabaseRow类型表示一个数据库行（容器），用泛型Column<T>作为它的键。
649
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
