自己翻译的Java.In.A.Nutshell.5th中泛型一章，欢迎拍砖把文章砸的漂亮一些

[size=14]做些说明吧：转网页的东西，改起来稍觉得的麻烦，就可能滞后。不过pdf文件会不定时的及时更新[/size]

4.1. Generic Types
Generic types and methods are the defining new feature of Java 5.0. A generic type is defined using one or more type variables and has one or more methods that use a type variable as a placeholder for an argument or return type. For example, the type java.util.List is a generic type: a list that holds elements of some type represented by the placeholder E. This type has a method named add(), declared to take an argument of type E, and a method named get(), declared to return a value of type E.

4.1. 泛型

泛类型和泛型方法是Java5.0中的新特性。一种泛类型用一个或多个泛型变量定义，可以有一个或多个，泛型变量做参数占位符或做返回值的方法。例如，类型 java.util.List 是一种泛类型：一个 list ，它的元素类型是E 这个占位符表示的类型。这个类型有一个叫 add() 的方法，有一个参数类型为 E ，有一个名叫 get() 的方法，返回一个类型为 E 的值。

In order to use a generic type like this, you specify actual types for the type variable (or variables), producing a parameterized type such as List.[1] The reason to specify this extra type information is that the compiler can provide much stronger compile-time type checking for you, increasing the type safety of your programs. This type checking prevents you from adding a String[], for example, to a List that is intended to hold only String objects. Also, the additional type information enables the compiler to do some casting for you. The compiler knows that the get( ) method of a List (for example) returns a String object: you are no longer required to cast a return value of type Object to a String.

为了可以象往常一样使用泛类型，你需要为泛型变量（或是变量）指定一个实际的类型，产生一个参数化类型，就象 List 。这样做的原因是，为编译器提供一个特定的类型信息，让它可以在编译期为你做类型检查，这样可以大大增加你程序的类型安全。例如，有一个 List 打算容纳 String 类型的对象，这种类型安全检查阻止你增加一个String[] 的元素。而且，这附加的类型信息使编译器帮你做些造型的活儿。例如，编译器知道 List 的 get() 方法返回一个String类型对象，你不再需要把Object类型的返回值造型成一个String类型的对象。

[1] Throughout this chapter, I've tried to consistently use the term " generic type" to mean a type that declares one or more type variables and the term "parameterized type" to mean a generic type that has had actual type arguments substituted for its type varaiables. In common usage, however, the distinction is not a sharp one and the terms are sometimes used interchangeably.

[1] 整个这章，我们将统一使用这些术语。"泛类型"：意味着一个类型，可以声明一个或多个泛型变量。"参数化类型"，意味着一个（运行期的）泛类型，表示它的泛型变量被实际类型做为参数值替换了。但在通常的应用中，两个术语的差别不是太明显，有时还可以替换。

The collections classes of the java.util package have been made generic in Java 5.0, and you will probably use them frequently in your programs. Typesafe collections are the canonical use case for generic types. Even if you never define generic types of your own and never use generic types other than the collections classes in java.util, the benefits of typesafe collections are so significant that they justify the complexity of this major new language feature.

在Java 5.0中，包java.util中的Collection类都已经被泛化了，你可能会在程序中频繁的用到它们。类型安全的Collection是应用泛类型的典范。可能你还从没有定义过自己的泛类型，也从没用过Collection（在包 java.uitl中）之外的泛类型，但类型安全的Collection的好处是显而易见的，它将证实这个新的，复杂的，主要且重要的语言特性。

We begin by exploring the basic use of generics in typesafe collections, then delve into more complex details about the use of generic types. Next we cover type parameter wildcards and bounded wildcards. After describing how to use generic types, we explain how to write your own generic types and generic methods. Our coverage of generics concludes with a tour of important generic types in the core Java API. It explores these types and their use in depth in order to provide a deeper understanding of how generics work.

我们将从探索类型安全的Collection的基本泛化用法开始，然后深入泛类型用法更为复杂的细节。接下来，我们将覆盖泛型参数通配符和边界通配符。再说明怎么用泛类型，我们将阐述怎样写自己的泛类型和泛型方法。我们涉及的泛型知识包括了 Java API 中关于泛类型的主要部分。深入的探讨了这些类型和他们的用法，为的是更深入的理解泛型是如何工作的。

4.1.1. Typesafe Collections
4.1.1.类型安全的Collection

The java.util package includes the Java Collections Framework for working with sets and lists of objects and mappings from key objects to value objects. Collections are covered in Chapter 5. Here, we discuss the fact that in Java 5.0 the collections classes use type parameters to identify the type of the objects in the collection. This is not the case in Java 1.4 and earlier. Without generics, the use of collections requires the programmer to remember the proper element type for each collection. When you create a collection in Java 1.4, you know what type of objects you intend to store in that collection, but the compiler cannot know this. You must be careful to add elements of the appropriate type. And when querying elements from a collection, you must write explicit casts to convert them from Object to their actual type. Consider the following Java 1.4 code:

在包 java.util 中包含了 Java 的Collection框架(set、list--关于对象、map--关于关键字对象和值对象的对)。 Collection 将在第五章讨论。这里我们只讨论有关在 Java 5.0 的Collection类中，用泛型参数标识Collection对象类型的内容。这在 Java 1.4 或是更早的 Java 版本中，没有这个用法。在没有泛型应用Collection的时候，需要程序员正确记得每个Collection的每个元素的类型。当我们建立一个 Java 1.4 的Collection时，你知道打算把什么样的类型对象放入这个Collection中，但是编译器不知道这些。你增加元素时必须小心正确性。并且当获取一个Collection的元素时，你必须显示的造型对象Object 到它们实际的类型。思考在 Java 1.4 中的如下代码：

public static void main(String[] args) {
    // This list is intended to hold only strings.
      // 这个list仅容纳字符串对象。
    // The compiler doesn't know that so we have to remember ourselves.
    // 编译器不知道这些，我们必须自己记住。
    List wordlist = new ArrayList();  

    // Oops! We added a String[] instead of a String.
    // 哎哟! 我们增加了个String[]元素，而不是String类型的。
    // The compiler doesn't know that this is an error.
    // 编译器是不知道那个错误的
    wordlist.add(args);

    // Since List can hold arbitrary objects, the get() method returns
// Object.  Since the list is intended to hold strings, we cast the
// return value to String but get a ClassCastException because of
// the error above.
// 因为 List 能容纳任意的对象，方法仅返回Object的对象。因为这个 list 打算
// 存储字符串的，我们把返回值转换成字符串，但却因为上面的错误得到了一个
// ClassCastException的异常。

    String word = (String)wordlist.get(0);
}

Generic types solve the type safety problem illustrated by this code. List and the other collection classes in java.util have been rewritten to be generic. As mentioned above, List has been redefined in terms of a type variable named E that represents the type of the elements of the list. The add( ) method is redefined to expect an argument of type E instead of Object and get( ) has been redefined to return E instead of Object.

泛类型就是解决上面示例的安全性问题的。在包java.utiil中的List和其他的Collection类都应用泛型重写过了。在上面说到的，List已被应用泛型变量 E (表示 list 中元素的类型) 重新定义过了， add() 方法被重定义成，要求传递一个类型为E而不是Object的参数；get()方法被重定义成返回一个类型为E而不是 Object 的值。

In Java 5.0, when we declare a List variable or create an instance of an ArrayList, we specify the actual type we want E to represent by placing the actual type in angle brackets following the name of the generic type. A List that holds strings is a List, for example. Note that this is much like passing an argument to a method, except that we use types rather than values and angle brackets instead of parentheses.

在 Java 5.0 ,当我们声明一个List变量或是创建一个ArrayList的实例时，我们指定一个实际少泛型替换类型占位符E，这个实际类型被放到泛类型名后的尖括号内。例如，一个容纳字符串类型的List就这样写List。注意，这个很象一个有合法参数的方法，除了我们用类型替换了值，用尖括号替换了圆括号。

The elements of the java.util collection classes must be objects; they cannot be used with primitive values. The introduction of generics does not change this. Generics do not work with primitives: we can't declare a Set, or a List for example. Note, however, that the autoboxing and autounboxing features of Java 5.0 make working with a Set or a List just as easy as working directly with char and int values. (See Chapter 2 for details on autoboxing and autounboxing).

包java.util中的类的元素必须是对象；它们不能用原生类型。引进泛型并不能改变这一点。泛型应用不是针对原生类型的。例如，我们不能声明Set或是List。但是，注意了，由于Java 5.0自动装箱和自动拆箱的新特性，我们可以应用Set或是List，而直接使用char和int的值(参见第二章关于自动装箱和自动拆箱的详细讲述)。

In Java 5.0, the example above would be rewritten as follows:

在Java 5.0，上面的例子可能被重写成如下形式：

public static void main(String[] args) {
    // This list can only hold String objects
// 这个 list 仅能容纳字符串对象
    List wordlist = new ArrayList();

    // args is a String[], not String, so the compiler won't let us do this
      // args 是 String [] 类型的，不是String，因此编译器不让那么做。
    wordlist.add(args);  // Compilation error!  // 编译错误！

    // We can do this, though.  
// Notice the use of the new for/in looping statement
// 然后，我们可以这么做
    // 注意这个新的for/in的用法
    for(String arg : args) wordlist.add(arg);

    // No cast is required.  List.get() returns a String.
      // 不需要造型转换。 List.get() 返回一个字符串。
    String word = wordlist.get(0);
}

Note that this code isn't much shorter than the nongeneric example it replaces. The cast, which uses the word String in parentheses, is replaced with the type parameter, which places the word String in angle brackets. The difference is that the type parameter has to be declared only once, but the list can be used any number of times without a cast. This would be more apparent in a longer example. But even in cases where the generic syntax is more verbose than the nongeneric syntax, it is still very much worth using generics because the extra type information allows the compiler to perform much stronger error checking on your code. Errors that would only be apparent at runtime can now be detected at compile time. Furthermore, the compilation error appears at the exact line where the type safety violation occurs. Without generics, a ClassCastException can be thrown far from the actual source of the error.

可以看到这段代码并不比非泛型的短多少。圆号形式的造型转换被尖括号的泛型参数替代了。不同的是，泛型参数只声明了一次，而list可以用很多次，且不用造型转换。在比较长的代码中这是显而易见的。但是，泛型语法比非泛型语法要繁琐很多，可是这是非常值得的，因为附加的类型信息允许编译器对你的代码执行强类型错误检查。这样运行期的错误可以在编译时就被找到。特别是，编译期里违反类型安全错误可以精确到行。若无泛型，一个ClassCastException的异常将会在源代码中很远的位置抛出。

Just as methods can have any number of arguments, classes can have more than one type variable. The java.util.Map interface is an example. A Map is a mapping from key objects to value objects. The Map interface declares one type variable to represent the type of the keys and one variable to represent the type of the values. As an example, suppose you want to map from String objects to Integer objects:

正如方法可以很多的参数一样，类可以有不止一种泛型变量。java.util.Map接口就是一个例子。一个Map是一个关键字对象和值对象的对。Map接口声明了一个表示关键字对象类型的泛型变量和一个表示值对象类型的泛型变量。例如，我们假定你有一个关键字类型为String，值类型为Integer的map：

public static void main(String[] args) {
    // A map from strings to their position in the args[] array
      // 一个关键字为字符串类型，表示args[] 数组位置的map
    Map map = new HashMap();

    // Note that we use autoboxing to wrap i in an Integer object.
      // 注意了，我们用自动装箱把i放进Integer的对象中。
    for(int i=0; i < args.length; i++) map.put(args[i], i);  

    // Find the array index of a word.  Note no cast is required!
      // 查找数组中的一个单词。注意，不需要造型！
    Integer position = map.get("hello");

    // We can also rely on autounboxing to convert directly to an int,
    // but this throws a NullPointerException if the key does not exist 
    // in the map
      // 但是这个关键字在 map 中不存在，会抛出一个NullPointerException异常
     // 我也可以直接依靠自动拆箱把对象转化成int的值。

    int pos = map.get("world");
}

A parameterized type like List is itself a type and can be used as the value of a type parameter for some other type. You might see code like this:

一个象List的 参数化类型是它自己的一个类型，可以作为值用作其他类型的参数化类型。你可以看下面的代码：

// Look at all those nested angle brackets!
// 注意看这些嵌套的尖括号！
Map>> map = getWeirdMap();

// The compiler knows all the types and we can write expressions
// 编译器我们写的表达式的所有类型
// like this without casting.  We might still get NullPointerException
// 象这种没有造型转换的。当然，我们仍然可能在运行时，得到 NullPointerException 异常
// or ArrayIndexOutOfBounds at runtime, of course.
// 或是 ArrayIndexOutOfBounds 异常
int value = map.get(key).get(0).get(0)[0];

// Here's how we break that expression down step by step.
// 在这我们怎么样一步步断句。
List> listOfLists = map.get(key);
List listOfIntArrays = listOfLists.get(0);
int[] array = listOfIntArrays.get(0);
int element = array[0];

In the code above, the get( ) methods of java.util.List and java.util.Map return a list or map element of type E and V respectively. Note, however, that generic types can use their variables in more sophisticated ways. Look up List in the reference section of this book, and you'll find that its iterator( ) method is declared to return an Iterator. That is, the method returns an instance of a parameterized type whose actual type parameter is the same as the actual type parameter of the list. To illustrate this concretely, here is a way to obtain the first element of a List without calling get(0).

在上面的代码里， java.util.List 和 java.util.Map 的 get() 方法返回一个 list 或是类型分别为 E 和 V 的 map 。但是注意，这些泛类型能用更高级的方式表示他们的变量。参见本书有关 List 的参考说明，你将发现它的 iterator() 方法被声明成返回一个 Iterator 类型。那就是，方法返回一个参数化类型的实例，它的实际泛型参数和 list 的实际泛型参数相同。为了具体证明这一点，这有一个方法可以得到 List 的第一个元素而不用调用 get(0) 方法

List words = // ...initialized elsewhere...  ...其他什么地方初始化...
Iterator iterator = words.iterator();
String firstword = iterator.next();

4.1.2. Understanding Generic Types
4.1.2.理解泛类型
This section delves deeper into the details of generic type usage, explaining the following topics:

· The consequences of using generic types without type parameters

· The parameterized type hierarchy

· A hole in the compile-time type safety of generic types and a patch to ensure runtime type safety

· Why arrays of parameterized types are not typesafe

这部分将深入 generic type 的详细用法，简述以下主题：

应用没有泛型参数的泛类型的结果
参数化类型的层次
一个编译期的泛类型漏洞和一个保证运行期类型安全的补救办法
为什么数组的参数化类型是不安全的
4.1.2.1 Raw types and unchecked warnings
4.1.2.1原始类型和未检查的警告

Even though the Java collection classes have been modified to take advantage of generics, you are not required to specify type parameters to use them. A generic type used without type parameters is known as a raw type. Existing pre-5.0 code continues to work: you simply write all the casts that you're already used to writing, and you put up with some pestering from the compiler. Consider the following code that stores objects of mixed types into a raw List:

尽管 Java Collection类引入了泛型的优点，但是你不需要在用它们的时候指明泛型参数。没有泛型参数的泛类型将作为原始类型。现有的 5.0 以前的代码可以继续工作：你可以象以前一样简单的写所有的造型转换，然后忍受一些编译器的纠缠。思考下面用原始 List 存储混合类型对象的代码：

List l = new ArrayList();
l.add("hello");  
l.add(new Integer(123));
Object o = l.get(0);

This code works fine in Java 1.4. If we compile it using Java 5.0, however, javac compiles the code but prints this complaint:

在Java 1.4下，这些代码会工作的很好。但如果用 Java 5.0 编译， javac 编译代码但会列出这个抱怨：

Note: Test.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
注意：Test.java 使用了一个未检查或是不安全的操作。
注意：重新用 -Xlint:unchecked 参数编译查看详细信息。


When we recompile with the -Xlint option as suggested, we see these warnings:

当我们用建议的 -Xlint 选项编译后，看到了这样的警告：

Test.java:6: warning: [unchecked]
    unchecked call to add(E) as a member of the raw type java.util.List
        l.add("hello");  
         ^
Test.java:7: warning: [unchecked]
    unchecked call to add(E) as a member of the raw type java.util.List
        l.add(new Integer(123));
         ^

The compiler warns us about the add( ) calls because it cannot ensure that the values being added to the list have the correct types. It is letting us know that because we've used a raw type, it cannot verify that our code is typesafe. Note that the call to get( ) is okay because it is extracting an element that is already safely in the list.

编译器给了我们关于调用 add() 方法的警告，因为它不能确定被增加到 list 中的值有正确的类型。这让我们知道我们用的是一个原始类型，它不能验证我们的代码是安全的。注意， get() 方法的调用是对的，因为它正在析取的元素已经安全的存储在 list 中了。

If you get unchecked warnings on files that do not use any of the new Java 5.0 features, you can simply compile them with the -source 1.4 flag, and the compiler won't complain. If you can't do that, you can ignore the warnings, suppress them with an @SuppressWarnings("unchecked") annotation (see Section 4.3 later in this chapter) or upgrade your code to specify a type parameter.[2] The following code, for example, compiles with no warnings and still allows you to add objects of mixed types to the list:

如果你的文件因为没有用到 Java 5.0 的新特性，而得到 unchecked 警告；你可以简单用的加 -source 1.4 参数编译，这样编译器将不再抱怨。如果你不那样做，你可以忽略这些警告，也可用 annotation (参见本章稍后的4.3部分)中的 @SuppressWarnings("uncheckd") 压制这些警告，或者，用泛型参数更新你的代码。例如下面的代码，当有你增加混合对象到 list 时，编译器将不再发出警告：

[2] At the time of this writing, javac does not yet honor the @SuppressWarnings annotation. It is expected to do so in Java 5.1.

[2] 就在本书写作时 ，javac 还不能兑现 annotation 的@SuppressWarnings操作。它将可以在Java 5.1版本中实现。

List