精通Java泛型与集合

3星 · 超过75%的资源需积分: 12 39 浏览量更新于2024-07-18 收藏 2.13MB PDF 举报

"Java Generics and Collections 由 Maurice Naftalin 和 Philip Wadler 合著，这是一本全面的指南，旨在帮助读者掌握自 Java 发布以来最重要的变化——泛型和扩展的集合库。这本书详细介绍了如何充分利用 Java 5 和 Java 6 中引入的新特性，同时解决了很多开发者在使用这些新特性时遇到的困惑。" 在 Java 泛型方面，本书涵盖了以下几个关键知识点： 1. **类型参数与泛型方法**：泛型是 Java 中引入的一种机制，允许在定义类、接口和方法时指定一个或多个类型参数，从而增强代码的类型安全性和重用性。类型参数允许我们创建可以处理多种数据类型的通用代码。 2. **自动装箱与拆箱**：这是 Java 5 引入的一项特性，使得基本类型与对应的包装类之间可以无缝转换。例如，将 `int` 自动转换为 `Integer`，反之亦然，无需手动进行转换操作。 3. **foreach 循环**：也称为增强 for 循环，提供了一种简洁的方式来遍历集合或数组中的元素，简化了循环结构，提高了代码的可读性。 4. **可变参数（varargs）**：允许方法接受一个不定数量的参数，这些参数被当作数组处理，增强了方法调用的灵活性。在 Java 集合框架方面，书中的内容包括： - **子类型和通配符**：讨论了如何在泛型中使用通配符来放宽类型限制，如 "? extends T" 表示任何 T 的子类型，以及 "? super T" 表示任何 T 的超类型。 - **与遗留代码的兼容性**：讲解如何在泛型库与旧版客户端代码之间以及泛型客户端与旧版库之间进行交互，以确保向后兼容性。 - **泛型与反射**：在使用泛型时，反射是一个重要的工具，因为泛型在运行时被擦除，所以需要理解如何通过反射访问和操作泛型类型信息。 - **集合库的设计模式**：书中探讨了如何利用设计模式有效地使用和扩展 Java 集合框架，包括选择合适的集合类型（如 List, Set, Queue 等），以及如何优化它们的性能和功能。 "Java Generics and Collections" 是一本深入浅出的指南，它不仅解释了泛型和集合库的基础知识，还涵盖了它们的高级特性和实际应用，对于想要提升 Java 编程技能的开发者来说，是一本不可或缺的参考书。通过阅读这本书，读者能够更高效地编写类型安全、易于维护的代码，并充分挖掘 Java 集合框架的潜力。

similar and the semantics are deliberately different.

Syntactically, angle brackets were chosen because they are familiar to C++ users,

and because square brackets would be hard to parse. However, there is one

difference in syntax. In C++, nested parameters require extra spaces, so you see

things like this:

List< List<String> >

In Java, no spaces are required, and it's fine to write this:

List<List<String>>

You may use extra spaces if you prefer, but they're not required. (In C++, a problem

arises because >> without the space denotes the right-shift operator. Java fixes the

problem by a trick in the grammar.)

Semantically, Java generics are defined by erasure, whereas C++ templates are

defined by expansion. In C++ templates, each instance of a template at a new type

is compiled separately. If you use a list of integers, a list of strings, and a list of lists

of string, there will be three versions of the code. If you use lists of a hundred

different types, there will be a hundred versions of the codea problem known as code

bloat. In Java, no matter how many types of lists you use, there is always one

version of the code, so bloat does not occur.

Expansion may lead to more efficient implementation than erasure, since it offers

more opportunities for optimization, particularly for primitive types such as int. For

code that is manipulating large amounts of datafor instance, large arrays in scientific

computingthis difference may be significant. However, in practice, for most purposes

the difference in efficiency is not important, whereas the problems caused by code

bloat can be crucial.

In C++, you also may instantiate a template with a constant value rather than a

type, making it possible to use templates as a sort of "macroprocessor on steroids"

that can perform arbitrarily complex computations at compile time. Java generics are

deliberately restricted to types, to keep them simple and easy to understand.

1.2. Boxing and Unboxing

Recall that every type in Java is either a reference type or a primitive type. A

reference type is any class, instance, or array type. All reference types are subtypes

of class Object, and any variable of reference type may be set to the value null. As

shown in the following table, there are eight primitive types, and each of these has a

corresponding library class of reference type. The library classes are located in the

package java.lang.

public static int sum (List<Integer> ints) {

int s = 0;

for (int n : ints) { s += n; }

return s;

}

Why does the argument have type List<Integer> and not List<int>? Because type

parameters must always be bound to reference types, not primitive types. Why does

the result have type int and not Integer? Because result types may be either

primitive or reference types, and it is more efficient to use the former than the latter.

Unboxing occurs when each Integer in the list ints is bound to the variable n of type

int.

We could rewrite the method, replacing each occurrence of int with Integer:

public static Integer sumInteger(List<Integer> ints) {

Integer s = 0;

for (Integer n : ints) { s += n; }

return s;

}

This code compiles but performs a lot of needless work. Each iteration of the loop

unboxes the values in s and n, performs the addition, and boxes up the result again.

With Sun's current compiler, measurements show that this version is about 60

percent slower than the original.

Look Out for This! One subtlety of boxing and unboxing is that == is defined

differently on primitive and on reference types. On type int, it is defined by equality

of values, and on type Integer, it is defined by object identity. So both of the

following assertions succeed using Sun's JVM:

List<Integer> bigs = Arrays.asList(100,200,300);

assert sumInteger(bigs) == sum(bigs);

assert sumInteger(bigs) != sumInteger(bigs); // not recommended

In the first assertion, unboxing causes values to be compared, so the results are

equal. In the second assertion, there is no unboxing, and the two method calls

return distinct Integer objects, so the results are unequal even though both Integer

objects represent the same value, 600. We recommend that you never use == to

compare values of type Integer. Either unbox first, so == compares values of type

int, or else use equals to compare values of type Integer.

A further subtlety is that boxed values may be cached. Caching is required when

boxing an int or short value between -128 and 127, a char value between '\u0000'

and '\u007f', a byte, or a boolean; and caching is permitted when boxing other

values. Hence, in contrast to our earlier example, we have the following:

List<Integer> smalls = Arrays.asList(1,2,3);

assert sumInteger(smalls) == sum(smalls);

assert sumInteger(smalls) == sumInteger(smalls); // not recommended

This is because 6 is smaller than 128, so boxing the value 6 always returns exactly

the same object. In general, it is not specified whether boxing the same value twice

should return identical or distinct objects, so the inequality assertion shown earlier

may either fail or succeed depending on the implementation. Even for small values,

for which == will compare values of type Integer

correctly, we recommend against its

use. It is clearer and cleaner to use equals rather than == to compare values of

reference type, such as Integer or String.

1.3. Foreach

Here, again, is our code that computes the sum of a list of integers.

List<Integer> ints = Arrays.asList(1,2,3);

int s = 0;

for (int n : ints) { s += n; }

assert s == 6;

The loop in the third line is called a foreach loop even though it is written with the

keyword for. It is equivalent to the following:

for (Iterator<Integer> it = ints.iterator(); it.hasNext(); ) {

int n = it.next();

s += n;

}

The emphasized code corresponds to what was written by the user, and the

unemphasized code is added in a systematic way by the compiler. It introduces the

variable it of type Iterator<Integer> to iterate over the list ints of type

List<Integer>. In general, the compiler invents a new name that is guaranteed not

to clash with any name already in the code. Note that unboxing occurs when the

expression it.next() of type Integer is assigned to the variable n of type int.

The foreach loop can be applied to any object that implements the interface

Iterable<E> (in package java.lang), which in turn refers to the interface Iterator<E>

(in package java.util). These define the methods iterator, hasNext, and next, which

are used by the translation of the foreach loop (iterators also have a method remove,

which is not used by the translation):

interface Iterable<E> {

public Iterator<E> iterator();

}

interface Iterator<E> {

public boolean hasNext();

public E next();

public void remove();

}

All collections, sets, and lists in the Collections Framework implement the

Iterable<E> interface; and classes defined by other vendors or users may implement

剩余262页未读，继续阅读

ByrWHZ

粉丝: 0
资源: 3

精通Java泛型与集合

[Java泛型和集合].(Java.Generics.and.Collections).文字版

Java Generics and Collections (Java泛型与集合)

Java-Generics-and-Collections-2:Java Generics and Collections Java泛型和集合

Java Generics and Collections.chm

java-generics-collections:Java核心中的泛型和集合

Java_Generics_and_Collections

Java-Generics-and-Collections

Java_Generics_And_Collections__2006.zip_Java Collections

Java-Generics-and-Collections-Example:Java泛型和集合的示例

[Java泛型和集合].(Java.Generics.and.Collections).Maurice.Naftalin&Philip.Wadler.文字版

最新资源