第8章 Java泛型与集合类

第8章 Java 泛型与集合类

核心内容：

1. 集合的作用与概念

2. 泛型的作用与用法。

3. Set 、List 、Map 的用法

4. Iterator 、Enumeration 的用法

8.1 早期的集合类

集合可理解为一个容器，该容器主要指映射（map ）、集合（set ）、列表（list ）、散列表（hashtable ）等抽象数据结构。容器可以包含有多个元素，这些元素通常是一些Java 对象。针对上述抽象数据结构所定义的一些标准编程接口称之为集合框架。集合框架主要是由一组精心设计的接口、类和隐含在其中的算法所组成，通过它们可以采用集合的方式完成Java 对象的存储、获取、操作以及转换等功能。集合框架的设计是严格按照面向对象的思想进行设计的，它对上述所提及的抽象数据结构和算法进行了封装。封装的好处是提供一个易用的、标准的编程接口，使得在实际编程中不需要再定义类似的数据结构，直接引用集合框架中的接口即可，提高了编程的效率和质量。此外还可以在集合框架的基础上完成如堆栈、队列和多线程安全访问等操作。

在集合框架中有几个基本的集合接口，分别是Collection 接口、List 接口、Set 接口和Map 接口，它们所构成的层次关系如图8-1所示。

图8-1 集合框架层次关系图

（1） Collection 接口是一组允许重复的对象。

（2） Set 接口继承Collection ，但不允许集合中出现重复元素。

（3） List 接口继承Collection ，允许集合中有重复，并引入位置索引。 （4）

Map 接口与Collection 接口无任何关系，Map 的典型应用是访问按关键字存储的值，

所包含的是键—值对，而不是单个独立的元素。

作为对上述接口的实现，Java 语言目前主要提供下述类的定义，如表8-1所示

Collection 接口

Set 接口 List 接口

Map 接口

表8-1 集合接口及其类的实现

接口集合类的实现历史集合类

Set HashSet

TreeSet

List ArrayList V ector

LinkedList Stack

Map HashMap Hashtable

TreeMap

由于在JDK1.5当中增加了泛型，我们把JDK1.5之前不支持泛型的集合类称之为早期集合类。早期的集合有个缺点：当我们把一个对象存放到集合里后，集合就会“忘记”这个对象的数据类型，当再次取出该对象时，该对象的编译类型就变成了Object类型。早期的集合之所以被设计成这样，是因为设计集合的程序员不知道我们需要用它来保存什么类型的对象。所以他们把集合设计成能保存任何类型的对象。但这样做也带来了两个问题：一、集合对元素类型没有任何限制，例如只想创建一个保存String类型的集合，但是程序也允许把boolean类型的对象存放在该集合当中，这样容易引发异常。二、由于把对象保存在集合当中时，集合忘记了对象的数据类型，只知道它存放的是Object类型，因此取出集合元素后通常要进行强制类型转换。这种强制类型转换既会增加程序的复杂度，也可能引发ClassCastException。

【例8-1】Test.java 早期集合类

1 import java.util.ArrayList;

2 import java.util.Iterator;

3 import java.util.List;

4 public class Test {

5 public static void main(String[] args) {

6 List list=new ArrayList();

7 list.add("beijing");

8 list.add("wuhan");

9 list.add("shanghai");

10 //list.add(4);

11 for(int i=0;i

12 String s=(String)list.get(i);

13 System.out.println(s);

14 }

15 }

16 }

输出结果:

D:\JA V A\8>java Test

beijing

wuhan

shanghai

程序说明：

上述程序的第6行是创建一个List集合对象，第7、8、9行是向该集合当中添了一个3个String类型的对象元素，第11、12、13、14行是通过for循环将集合当中的元素取出，转换为String类型并输出。

上述程序只是创建了一个List对象，而且只用List对象来保存字符串对象。但是对于保存在List对象当中的数据类型我们不能做任何的限制。如果在程序的第10行，我们不小心把一个int类型的数据保存到List当中，就将导致程序在第12行出现ClassCastException 异常。自JDK1.5以后，Java引入了泛型的概念，允许我们在创建集合时指定集合元素的类型。这样添加数据元素到集合中时会做类型检查。如果要添加的数据元素与指定的数据类型不匹配，编译时会报错。

8.2 泛型

在面向对象编程语言中，多态算是一种泛化机制。例如，你可以将方法的参数类型设为基类，那么该方法就可以接受从这个基类中导出的任何类作为参数。这样的方法更加通用一些，可应用的地方也多一些。但有时候，拘泥于类的单继承体系，也会使程序受限太多。如果方法的参数是一个接口，而不是一个类，这种限制就放松了许多。因为任何实现了该接口的类都能够满足该方法。可是有时候，即便使用了接口，对程序的约束也还是太强了。因为一旦指明了接口，就要求你的代码必须使用特定的接口。而我们希望达到的目的是编写更通用的代码，要使代码能够应用于“某种不具体的类型”，而不是一个具体的接口或类。在Java SE 5中增加了泛型机制。“泛型”这个术语的意思是：“适用于许多的类型”。泛型实现了参数化类型的概念，使代码可以应用于多种类型。

8.2.1 泛型类

一个泛型类就是具有一个或多个类型变量的类。本节使用一个简单的Pair类作为例子。

public class Pair{

private T first;

private T second;

public Pair(){first=null; second=null;}

public Pair(T first,T second){this.first=first; this.second=second;}

public T getFirst(){return first;}

public T getSecond(){return second;}

public void setFirst(T newV alue){first=newV alue;}

public void setSecond(T newV alue){second=newV alue;}

}

Pair类引入了一个类型变量T，用尖括号< >括起来，并放在类名的后面。泛型类可以有多个类型变量。例如，可以定义Pair类，其中第一个成员变量和第二个成员变量使用不同的类型：

public clas s Pair{…..}

类定义中的类型变量指定方法的返回类型以及成员变量和局部变量的类型。例如：

private T first;

用具体的类型替换类型变量就可以实例化泛型类型，例如：Pair可以将结果想像成带有构造器的普通类:

public class Pair{

private String first;

private String second;

public Pair(){first=null; second=null;}

public Pair(String first,String second){this.first=first; this.second=second;}

public String getFirst(){return first;}

public String getSecond(){return second;}

public void setFirst(String newV alue){first=newV alue;}

public void setSecond(String newV alue){second=newV alue;}

}

【例8-2】PairTest.java 泛型类

1 public class PairTest{

2 public static void main(String[] args){

3 Pair pair=new Pair("Hello","Java");

4 System.out.println("first="+pair.getFirst());

5 System.out.println("second="+pair.getSecond());

6 }

7 }

输出结果：

D:\JA V A\8>java PairTest

first=Hello

second=Java

程序分析：

上述程序的第3行创建了一个泛型类对象pair,并指定该对象的成员变量的类型为String 类型。并调用其带String类型参数的构造方法对其进行初始化。将pair对象的第一个成员变量first的值设置为"Hello"，第二个成员变量second的值设置为"Java"。第4，5行分别调用pair对象的getFirst()、getSecond()方法获得成员变量first、second的值并输出到控制台。

8.2.2 泛型方法

前面已经介绍了如何定义一个泛型类。实际上，还可以定义一个带有参数类型的方法即泛型方法。泛型方法使得该方法能够独立于类而产生变化，泛型方法所在的类可以是泛型类，也可以不是泛型类。创建一个泛型方法常用的形式如下：

[访问修饰符] [static] [final] <参数类型列表> 返回值方法名( [形式参数列表] )

下面我们在GenericMethod类当中声明一个f ( )泛型方法，用于返回调用该方法时，所传入的参数类型的类名。

【例8-3】GnericMethodTest.java 泛型方法

1 class GenericMethod{

2 public void f(T x){

3 System.out.println(x.getClass().getName());

4 }

5 }

6

7 public class GenericMethodTest{

8 public static void main(String[] args){

9 GenericMethod gm=new GenericMethod();

10 gm.f(" ");

11 gm.f(1);

12 gm.f(1.0f);

13 gm.f('c');

14 gm.f(gm);

15 }

16 }

输出结果：

D:\JA V A\8>java GenericMethodTest

https://www.doczj.com/doc/418163005.html,ng.String

https://www.doczj.com/doc/418163005.html,ng.Integer

https://www.doczj.com/doc/418163005.html,ng.Float

https://www.doczj.com/doc/418163005.html,ng.Character

GenericMethod

程序分析：

上述程序的第9行创建了一个GenericMethod类型的对象gm。第10行调用该对象的f()方法，并传递参数为""。f()方法通过getClass()方法获取传入参数""的类别，并通过getName()方法获取该类别的名字，然后输出到控制台。同理，第11~14行分别将1、1.0f、'c'、gm所属类别的名字输出到标准控制台。

注意：当使用泛型类时，必须在创建对象的时候指定类型参数的值，而使用泛型方法的时候，通常不必指明参数类型，因为编译器会为我们找出具体的类型。这称为类型参数推断。因此我们可以像调用普通方法一样调用f()，编译器会根据调用f()时传入的参数类型与泛型类型进行匹配。

8.2.3 泛型接口

除了泛型类和泛型方法，还可以使用泛型接口。泛型接口的定义与泛型类非常相似，它的声明形式如下：

interface 接口名<类型参数表>

下面我们创建了一个名为MinMax的接口，用来返回某个对象集的最小值或最大值interface MinMax>{

T min();

T max();

}

MinMax接口类型参数T是有界类型，它必须是Comparable的子类。注意到Comparable本身也是一个泛型类，它是由系统定义在类库中的，可以用来比较两个对象的大小。接下来我们定义一个类MyClass来实现这个接口

class MyClass> implements MinMax{

T [] vals;

MyClass(T [] ob){

vals = ob;

}

public T min(){

T val = vals[0];

for(int i=1; i

if (vals[i].compareTo(val) < 0)

val = vals[i];

return val;

}

public T max(){

T val = vals[0];

for(int i=1; i

if (vals[i].compareTo(val) > 0)

val = vals[i];

return val;

}

}

注意MyClass的声明部分：它的类型参数T必须和要实现的接口中的声明完全一样.反而是接口MinMax的类型参数T最初是写成有界形式的，现在已经不再需要重写一遍。

下面通过一个例子来测试MyClass的运行情况

【例8-4】MyClassTest.java 泛型接口

1 public class MyClassTest{

2 public static void main(String args[]){

3 Integer inums[] = {56,47,23,45,85,12,55};

4 Character chs[] = {'x','w','z','y','b','o','p'};

5 MyClass iob = new MyClass(inums);

6 MyClass cob = new MyClass(chs);

7 System.out.println("Max value in inums: "+iob.max());

8 System.out.println("Min value in inums: "+iob.min());

9 System.out.println("Max value in chs: "+cob.max());

10 System.out.println("Min value in chs: "+cob.min());

11 }

输出结果：

D:\JA V A\8>java MyClassTest

Max value in inums: 85

Min value in inums: 12

Max value in chs: z

Min value in chs: b

程序分析：

上述程序的第3行定义了一个Integer类型的数组inums。第4行定义了一个character 类型的数组chs。第5行创建了一个MyClass类型的对象iob并指定其参数类型为Integer类型。即iob对象的成员变量T[] val为数组inums。第6行创建了一个MyClass类型的对象cob.并指定其参数类型为String类型。即cob对象的成员变量T[] val为数组chs。

8.2.4 通配类型参数

前面介绍的泛型已经可以解决大多数的实际问题，但在某些特殊情况下，仍然会有一些问题无法轻松地解决。以Stats类为例，假设在其中存在一个名为doSomething()的方法，这个方法有一个形式参数，也是Stats类型，如下所示：

class Stats{

T [ ] nums;

Stats (T [ ] obj){

nums = obj;

}

double average(){

double sum = 0.0;

for (int i=0; i

sum += nums[i].doubleV alue();

return sum / nums.length;

}

void doSomething(Stats ob){

System.out.println(ob.getClass().getName());

}

}

下面我们通过StatsTest类来测试Stats运行情况

【例8-4】StatsTest.java 通配类型参数

1 public class StatsTest{

2 public static void main(String args[]){

3 Integer inums[] = {1,2,3,4,5};

4 Stats iobj = new Stats(inums);

5 Double dnums[] = {1.1,2.2,3.3,4.4,5.5};

6 Stats dobj = new Stats(dnums);

7 dobj.doSomething(iobj); //iobj和dobj的类型不相同

8 }

输出结果：

D:\JA V A\8>javac StatsTest.java

StatsTest.java:7: 无法将Stats 中的doSomething(Stats) 应用于(Stats)

dobj.doSomething(iobj); //iobj和dobj的类型不相同

程序分析：

编译时出错是因为在StatsTest类中，dobj.doSomething(iobj);这条语句有问题。dobj是Stats类型，iobj是Stats类型，由于实际类型不同，而声明时用的是：void doSomething(Stats ob)

它的类型参数也是T，与声明对象时的类型参数T相同。于是在实际使用中，就要求iobj 和dobj的类型必须相同。

解决这个问题的办法是使用Java提供的通配符"?"，它的使用形式如下：

genericClassName

现将上面Stats类当中的doSomething（）可以声明成这个样子：

void doSomething(Stats ob)

它表示这个参数ob可以是任意的Stats类型，于是调用该方法的对象就不必和实际参数对象类型一致了。

现执行StatsTest类，查看通配符的效果，输出结果如下：

D:\JA V A\8>java StatsTest

Stats

注意由于泛型类Stats的声明中，T是有上界的：class Stats。故void doSomething(Stats ob) //这里使用了类型通配符

其中，通配符"?"有一个默认的上界，就是Number。如果想改变这个上界，也是可以的，但改变后的上界必须是Number类的子类。比如

Stats ob

但是不能写成这样：

Stats ob

因为Integer是Number的子类，而String不是Number的子类。通配符无法将上界改变得超出泛型类声明时的上界范围, 最后读者需要注意一点，通配符是用来声明一个泛型类的变量的，而不能创建一个泛型类。比如下面这种写法是错误的：

class Stats{……}

8.3 泛型集合类

在JDK1.5中增加了泛型，集合类也开始支持泛型，允许在创建集合对象时通过泛型来指定该集合存储的对象类型。我们把JDK1.5及以后版本中支持泛型的集合类称之为“泛型集合类”，作为对集合接口的实现，Java语言目前主要提供下述集合类的定义，如表9-2所示

表8-2 泛型集合类及对应的非泛型集合类

接口泛型集合类非泛型集合类

Set HashSet HashSet

TreeSet TreeSet

List ArrayList ArrayList

LinkedList LinkedList

Map HashMap HashMap

TreeeMap TreeMap

8.3.1 集合（Set）

集合是指一个不包含重复元素的对象集合，是数学上“集合”概念的一种抽象。其本身是无序的。集合Set接口定义在java.util包中，所定义的方法主要分为两类：（1）集合和元素之间的方法；(2)集合之间的方法。下面介绍详细的方法描述。

1. 描述集合和元素之间的关系的方法

（1）public boolean add(Object element)

将一个元素添加到集合中，如果该元素成功添加到集合中，返回true。

（2）public boolean remove(Object obj)

从这个集合中删除等于obj的对象。如果有匹配的对象被删除，返回true。

（3）public boolean contains(Object obj)

如果集合中包含了一个与obj相等的对象，返回true。

（4）public int size( )

返回当前存储在集合中的元素个数。

（5）public boolean isEmpty( )

如果集合中没有元素，返回true。

（6）public void clear( )

从这个集合中删除所有的元素。

2. 描述集合之间关系的方法

（1）public boolean containsAll(Collection other)

如果这个集合包含other集合中的所有元素，返回true。

（2）public boolean addAll(Collection other)

将other集合中的所有元素添加到这个集合。添加成功返回true。

（3）public boolean removeAll(Collection other)

从这个集合中删除other集合中存在的所有元素。删除成功返回true。

（4）public boolean retainAll(Collection other)

从这个集合中删除所有与other集合中的元素不同的元素。删除成功返回true。

在集合框架中，HashSet类和TreeSet类实现了Set接口。这两个类定义在java.util包中一般情况下，采用HashSet类创建一个无序的集合对象，采用TreeSet类创建有序的集合对象。需要注意的是，添加到TreeSet中的元素必须是可排序的。

【例8-6】HashSetTest.java HashSet类的应用

1 import java.util.HashSet;

2 public class HashSetTest{

3 public static void main(String[] args){

4 boolean b;

5 HashSet s=new HashSet();

6 b=s.add("Hello");

7 System.out.println("添加单词Hello,返回为"+b);

8 b=s.add("Java");

9 System.out.println("添加单词Java,返回为"+b);

10 b=s.add("Hello");

11 System.out.println("添加单词Hello,返回为"+b);

12 b=s.add("world");

13 System.out.println("添加单词world,返回为"+b);

14 for(String element:s)

15 System.out.println(element);

16 }

17 }

输出结果：

D:\JA V A\8>java HashSetTest

添加单词Hello,返回为true

添加单词Java,返回为true

添加单词Hello,返回为false

添加单词world,返回为true

world

Java

Hello

程序说明：

在上述程序第5行创建了一个存放String类型的HashSet 集合对象s。7~13行分别向其中添加了“Hello"、"Java"、“Hello"、"world"共4个字符串。由于Set类型的集合不能存放重复的数据。故在第10行中，向集合当中第二次存放"Hello"字符串时。返回结果为false。第14行调用了for(:)循环来输出集合当中的元素。该循环可以用来输出集合当中的所有元素。类似于迭代器(Iterator)的作用，但使用时要比迭代器更简洁，更方便。由于HashSet集合当中的元素是无序的，故使用for(:)循环输出集合当中的元素时，输出结果也是随机的。该程序每次运行时，结果或都不一样。

【例8-7】TreeSetTest.java TreeSet类的应用

1 import java.util.TreeSet;

2 public class TreeSetTest{

3 public static void main(String[] args){

4 boolean b;

5 TreeSet s=new TreeSet();

6 b=s.add("Hello");

7 System.out.println("添加单词Hello,返回为"+b);

8 b=s.add("Java");

9 System.out.println("添加单词Java,返回为"+b);

10 b=s.add("Hello");

11 System.out.println("添加单词Hello,返回为"+b);

12 b=s.add("world");

13 System.out.println("添加单词world,返回为"+b);

14 for(String element:s)

15 System.out.println(element);

16 }

17 }

输出结果：

D:\JA V A\8>java TreeSetTest

添加单词Hello,返回为true

添加单词Java,返回为true

添加单词Hello,返回为false

添加单词world,返回为true

Hello

Java

World

程序说明：

在上述程序第5行创建了一个存放String类型的TreeSet 集合对象s。7~13行分别向其中添加了“Hello"、"Java"、“Hello"、"world"共4个字符串。由于Set类型的集合不能存放重复的数据。故在第10行中，向集合当中第二次存放"Hello"字符串时。返回结果为false。第14行调用了for(:)循环来输出集合当中的元素。该循环可以用来输出集合当中的所有元素。在本例中采用TreeSet集合，实现了集合元素的有序输出，但这种实现是有代价的，即集合中得元素需要具有可比性。什么是可比性？下面通过例8-8和例8-9说明这个问题。

【例8-8】HashSetDemo1.java HashSet类的应用

1 import java.util.HashSet;

2 public class HashSetDemo1{

3 public static void main(String[] args){

4 HashSet s=new HashSet();

5 s.add("110");

6 s.add(new Integer(110));

7 for(Object element:s)

8 System.out.println(element);

9 }

10 }

输出结果：

D:\JA V A\8>java HashSetDemo1

110

110

程序分析：

上述程序的第4行创建了一个HashSet对象s。第5行向HashSet对象s中添加了一个字符串对象"110"，第6行向HashSet对象s中添加了一个Integer对象110。第7行通过for(:)循环将HashSet对象中元素输出。

【例8-9 】TreeSetDemo1.java TreeSet类的应用

1 import java.util.TreeSet;

2 public class TreeSetDemo1{

3 public static void main(String[] args){

4 TreeSet s=new TreeSet()

5 s.add("110")

6 s.add(new Integer(110));

7 for(Object element:s)

8 System.out.println(element);

9 }

10 }

输出结果:

D:\JA V A\8>java TreeSetDemo1

Exception in thread "main" https://www.doczj.com/doc/418163005.html,ng.ClassCastException: https://www.doczj.com/doc/418163005.html,ng.String cannot

be cast to https://www.doczj.com/doc/418163005.html,ng.Integer

at https://www.doczj.com/doc/418163005.html,pareTo(Unknown Source)

at java.util.TreeMap.put(Unknown Source)

at java.util.TreeSet.add(Unknown Source)

at TreeSetDemo1.main(TreeSetDemo1.java:6)

程序分析：

本例与例8-8其他的程序语句相同，唯一的区别在于例8-8中采用的是创建一个HashSet 对象，而本例中采用的是创建一个TreeSet对象，但运行结果却并不相同。本例的运行结果出现异常，是因为字符串对象和Integer对象不具备可比性，所以TreeSet在对它们进行排序时得到不正确的结果，故抛出异常。在本例中由于构建TreeSet对象时没有指定其存储的数据类型。故字符串对象和Integer对象这两种不具备可比性的对象都存放到TreeSet对象当中。为了避免这种情况。我们可以在声明TreeSet对象的时候指定其存放的数据类型。即使用泛型。

【例8-10】TreeSetDemo2.java TreeSet类的应用

1 import java.util.TreeSet;

2 public class TreeSetDemo1{

3 public static void main(String[] args){

4 TreeSet s=new TreeSet()

5 s.add("110")

6 s.add(new Integer(110));

7 for(Object element:s)

8 System.out.println(element);

9 }

10 }

输出结果：

The method add(String) in the type TreeSet is not applicable for the arguments (Integer) 程序分析：

该程序在编译时会报错。是因为第6行中。存放一个Integer类型的数据到TreeSet集合对象中时，编译器会作类型检查。若发现存放的数据类型与指定的数据类型不一致，就会报错。从而避免集合当中的数据不具备可比性。

8.3.3 列表（List）

列表是指一个有序的对象集合，也称为一个对象序列。通过列表接口，可以利用整数索引（即元素在列表中得位置）对列表中的每个元素有准确的控制，包括访问特定位置的元素对象和查询特定的元素。与集合不同之处在于列表中允许出现重复的元素。在列表接口中，除了在集合中所定义的方法外，还有一系列针对列表中特定位置的方法。列表List接口定义在java.util包中,下面介绍列表接口中针对特定位置的方法。

（1）public void add(int index, E element)

在列表的指定位置索引为index处插入指定元素element。

（2）public boolean addAll(int index, Collection c)

将指定Collection c中的所有元素都插入到列表中的指定位置。

（3）public E get(int index)

返回列表中指定位置的元素。

（4）public int indexOf(Object o)

返回此列表中第一次出现的指定元素的索引；如果列表不包含该元素，则返回-1。（5）public int lastIndexOf(Object o)

返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回-1。（6）public E remove(int index)

移除列表中指定位置的元素。

（7）public E set(int index, E element)

用指定元素替换列表中指定位置的元素。

在集合框架中，实现了列表接口（List）的是ArrayList类和LinkedList类。这两个类定义在java.util包中。ArrayList类是通过数组方式来实现的，相当于可变长度的数组。LinkedList类则是通过链表结构来实现。由于这两个类的实现方式不同，使得相关操作方法的代价也不同。一般说来，若对一个列表结构的开始和结束处有频繁地添加和删除操作时，一般选用LinkedList类所实例化的对象表示该列表。

【例8-11】ArrayListDemo.java ArrayList类应用

1 import java.util.ArrayList;

2 public class ArrayListDemo{

3 public static void main(String[] args){

4 ArrayList list=new ArrayList();

5 list.add("collection");

6 list.add("list");

7 list.add("ArrayList");

8 list.add("LinkedList");

9 for(String s:list);

10 System.out.println(s);

11 list.set(3,"ArrayList");

12 int len=list.size();

13 for(int n=0;n

14 System.out.println(list.get(n));

15 }

16 }

输出结果：

D:\JA V A\8>java ArrayListDemo

collection

list

ArrayList

LinkedList

collection

list

ArrayList

ArrayList

程序分析：

上述程序第4行创建了一个ArrayList类型的对象list,并指定其存储的对象类型为String 类型。第5~8行分别将"collection "、"list"、"ArrayList"、"LinkedList"添加到list中，第9~10行通过for(:)循环输出list集合当中的所有元素。第12行通过set()方法将list集合当中的第4个元素指定为"ArrayList"，第12行通过size()方法获取list当中的元素个数。第13~14行通过for循环输出list当中的所有元素。

通常利用LinkedList对象表示一个堆栈（stack）或队列（queue）。对此LinkedList类中特别定义了一些方法，而这是ArrayList类所不具备的。这些方法用于在列表的开始和结束处添加和删除元素，其方法定义如下：

（1）public void addFirst(E element)

将指定元素插入此列表的开头。

（2）public void addLast(E element)

将指定元素添加到此列表的结尾。

（3）public E removeFirst()

移除并返回此列表的第一个元素。

（4）public E removeLast()

移除并返回此列表的最后一个元素。

【例8-12】LinkedListDemo.java LinkedList类应用

1 import java.util.LinkedList;

2 public class LinkedListDemo{

3 public static void main(String[] args){

4 LinkedList queue=new LinkedList();

5 queue.addFirst("set");

6 queue.addLast("HashSet");

7 queue.addLast("TreeSet");

8 queue.addFirst("List");

9 queue.addLast("ArrayList");

10 queue.addLast("LinkedList");

11 queue.addLast("map");

12 queue.addFirst("collection");

13 System.out.println(queue);

14 queue.removeLast();

15 queue.removeFirst();

16 System.out.println(queue);

17 }

18 }

输出结果：

D:\JA V A\8>java LinkedListDemo

[collection, List, set, HashSet, TreeSet, ArrayList, LinkedList, map]

[List, set, HashSet, TreeSet, ArrayList, LinkedList]

程序分析：

上述程序的第4行创建了一个LinkedList类型的对象queue，并指定其存放的元素类型为String。第5行通过addFirst() 方法在queue中的队首放置元素"set"，第6行通过addLast()方法向queue中添加元素"HashSet",该元素位于"set"元素的后面。第7行通过addLast()方法向queue中添加元素"TreeSet",该元素位于"HashSet"元素的后面。第8行通过addFirst()方法向queue中添加元素"List",该元素位于"set"元素的前面。第9~11行分别通过addLast()方法在元素"TreeSet"后面依次添加了“ArrayList"、"LinkedList"、"map" 三个元素。第12行通过addFirst()方法向queue添加元素”collection"，该元素位于"List"的前面。第13行输出queue 当中的所有元素。第14行通过removeLast()方法删除queue中位于最后的元素"map",第15行通过removeFirst()方法删除queue中位于对首的元素"collection",第16行输出queue当中的所有元素。

8.3.4 映射（Map）

映射接口是与Collection接口相并列的一个接口，该接口描述了不重复的键到值的映射。一个映射对象中不能包含重复的键，且每个键只能映射到一个值。在映射中“键—值”对所描述的对象称为条目（Entry）。Map定义在java.util包中，主要定义三类操作方法：修改、查询和集合视图。

修改操作向映射中添加和删除键—值对，包括如下描述：

（1）public V put(K key,V value)

将指定的值与此映射中的指定键关联。

（2）public V remove(K key)

如果存在一个键的映射关系，则将其从此映射中移除。

（3）public void putAll(Map m)

从指定映射中将所有映射关系复制到此映射中。

查询操作是获得映射的内容，包括如下描述：

（1）public V get(k key)

返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null。（2）public boolean containsKey(Object key)

如果此映射包含指定键的映射关系，则返回true。

（3）public boolean containsV alue(Object value)

如果此映射将一个或多个键映射到指定值，则返回true。

集合视图允许将键、值或条目（“键-值”对）作为集合来处理，包括如下描述：

（1）public Collection values()

返回此映射中包含的值的Collection视图。

（2）public Set keySet()

返回此映射中包含的键的Set 视图

（3）public Set entrySet()

返回此映射中包含的映射关系的Set 视图。

在Map接口中还包含一个Map.Entry接口，其方法描述如下：

（1）public V setV alue(V value)

用指定的值替换与此项对应的值。

（2）public K getKey()

返回与此项对应的键。

（3）public V getV alue()

返回与此项对应的值。

（4）public boolean equals(Object o)

比较指定对象与此项的相等性。如果给定对象也是一个映射项，并且两个项表示相同的映射关系，则返回true。

HashMap类和TreeMap类是集合框架提供的Map接口的实现类。定义在java.util包中。在Map中插入、删除和定位元素，HashMap是最好的选择。如果需要按顺序遍历键，则选择TreeMap。

【例8-13】HashMapDemo.java HashMap类应用

1 import java.util.HashMap;

2 public class HashMapDemo{

3 public static void main(String[] args){

4 HashMap info=new HashMap();

5 info.put("mike","software ");

6 info.put("john","computer ");

7 info.put("potter","network");

8 System.out.println(info);

9 if(info.containsKey("mike"))

10 info.put("mike","network");

11 System.out.println(info);

12

13 }

14 }

输出结果：

D:\JA V A\8>java HashMapDemo

{potter=network, john=computer , mike=software }

{potter=network, john=computer , mike=network}

程序分析：

上述程序中，第4行创建了一个HashMap对象，其存放的键—值对为String类型。第5、6、7行分别把三个String类型的键—对存放到HashMap中。第8行将HashMap里面的键—对输出。第9行引用containsKey()方法来判断HashMap中是否包含指定的键mike，如果存在。第10行将mike所对应的值设置为network.

【例8-14】TreeMapDemo.java TreeMap类应用

1 import java.util.TreeMap;

2 public class TreeMapDemo{

3 public static void main(String[] args){

4 TreeMap info=new TreeMap();

5 info.put("mike","software ");

6 info.put("john","computer ");

7 info.put("potter","network");

8 System.out.println(info);

9 if(info.containsKey("mike"))

10 info.put("mike","network");

11 System.out.println(info);

12

13 }

14 }

输出结果：

D:\JA V A\8>java TreeMapDemo

{john=computer , mike=software , potter=network}

{john=computer , mike=network, potter=network}

程序分析：

例8-14与例8-13基本相同，不同之处在于例8-14中采用TreeMap类对象来实现Map 接口，但最终的输出结果有所不同。从运行结果来看，TreeMap类对象按“键—值”格式输出时，是按照键（字符串对象）的字母顺序排列的。

8.4 Collections类

Collections类只提供了一些静态方法，通过这些方法可以对集合对象进行操作或返回集合对象。下面简单列举其所提供的主要方法。

Collections类中对List对象（即实现List接口的集合类）提供查询、复制、填充、排序和乱序、倒置、交换等方法。其方法定义如下：

（1）public static int binarySearch(List list,Object key)

使用二分搜索法搜索指定列表，以获得指定key的对象。

（2）public static void copy(List dest,List src)

将所有元素从一个列表src复制到另一个列表dest。

（3）public static void fill(List list,Object obj)

使用指定元素obj替换指定列表中的所有元素。

（4）public static void sort(List list)

根据元素的自然顺序对指定列表按升序进行排序。

（5）public static void shuffle(List list)

使用默认随机源对指定列表进行置换。

（6）public static void reverse(List list)

反转指定列表中元素的顺序。

（7）public static void swap(List list,int I,int j)

在指定列表的指定位置处交换元素。

Collections类中对Collection对象（即实现Collection接口的集合类）提供最大和最小值方法，其定义如下：

（1）public static Object max(Collection coll)

根据元素的自然顺序，返回给定collection 的最大元素。

（2）public static Object max(Collection coll,Comparator comp)

根据指定比较器产生的顺序，返回给定collection 的最大元素。

（3）public static Object min(Collection coll)

根据元素的自然顺序返回给定collection 的最小元素。

（4）public static Object min(Collection coll,Comparator comp)

根据指定比较器产生的顺序，返回给定collection 的最小元素。

Collections类所提供的集合同步处理可针对Collection对象、List对象、Map对象和Set 对象，其定义如下：

（1）public static Collection synchronized Collection(Collection c)

返回指定collection支持的同步（线程安全的）collection。

（2）public static Set synchronizedSet(Set s)

返回指定set 支持的同步（线程安全的）set。

（3）public static SortedSet synchronizedSortedSet(SortedSet s)

返回指定有序set 支持的同步（线程安全的）有序set。

（4）public static List synchronizedList(List list)

返回指定列表支持的同步（线程安全的）列表。

（5）public static Map synchronizedMap(Map m)

返回由指定映射支持的同步（线程安全的）映射。

（6）public static SortedMap synchronizedSortedMap(SortedMap m)

返回指定有序映射支持的同步（线程安全的）有序映射。

Collections类所提供的集合只读处理（不可更改）可针对Collection对象、List对象、Map对象和Set对象，其定义如下：

（1）public static Collection unmodifiableCollection（Collection c）

返回指定collection 的不可修改视图。

（2）public static Set unmodifiableSet(Set s)

返回指定set 的不可修改视图。

（3）public static SortedSet unmodifiableSortedSet(Set s)

返回指定有序set 的不可修改视图。

（4）public static List unmodifiableList(List list)

返回指定列表的不可修改视图。

（5）public static Map ummodifiableMap(Map m)

返回指定映射的不可修改视图。

（6）public static SortedMap unmodifiableSortedMap(SortedMap m)

返回指定有序映射的不可修改视图。

Collections类还可针对Set对象、List对象和Map对象建立不可更改的单子(singleton)集合，即集合中仅包含所指定的一个对象，其定义如下：

（1）public static Set singleton(Object obj)

返回一个只包含指定对象的不可变集合。

（2）public static List singletonList(Object obj)

返回一个只包含指定对象的不可变列表。

（3）public static Map singletonMap(Object key,Object value)

返回一个不可变的映射，它只将指定键映射到指定值。

除了上述所列的这些静态方法，Collections类中还包含有三个不可更改的静态集合常量，它们是：

（1）public static final Set EMPTY_SET 空的集合（不可变的）。

（2）public static final List EMPTY_LIST 空的列表（不可变的）。

（3）public static final Map EMPTY_MAP 空的映射（不可变的）。

Collecitions类所包含的方法较为广泛，在实际使用中可以将其与Arrays类所提供的方法进行类比记忆和使用。下面就Collections类的一些常用方法进行相关介绍。

8.4.1 排序

Colletions类所提供的一个重要功能就是针对List对象的排序。由于List对象所包含的是一组对象，因此采用Collections类的排序方法可以将这些对象按其自然升序排列，需注意的是这些对象需具备可比性，否则会抛出ClassCastException异常。所用到的方法主要有如下两个：

（1）public static void sort(List list)

（2）public static void sort(List list,Comparator c)

这两个方法都提供了对List对象的排序功能，不同的是第二个方法更具有灵活性，它可按所指定的比较方式排序，这是通过一个比较器对象来实现（即实现Comparator接口的对象）的。

【例8-15】CollectionsDemo1.java 排序应用

1 import java.util.LinkedList;

2 import java.util.Collections;

3 public class CollectionsDemo1{

4 public static void main(String[] args){

5 LinkedList actors=new LinkedList();

6 actors.add("Jackie Chan");

7 actors.add("Bruce Lee");

8 actors.add("Jet Li ");

9 actors.add("Arnold Schwarzenegger");

10 System.out.println("原始的演员名单:");

11 System.out.println(actors);

12 Collections.sort(actors);

13 System.out.println("排序后的演员名单:");

14 System.out.println(actors);

15 Collections.shuffle(actors);

16 System.out.println("乱序后的演员名单:");

17 System.out.println(actors);

18 }

19 }

输出结果：

D:\JA V A\8>java CollectionsDemo1

原始的演员名单:

[Jackie Chan, Bruce Lee, Jet Li , Arnold Schwarzenegger]

排序后的演员名单:

[Arnold Schwarzenegger, Bruce Lee, Jackie Chan, Jet Li ]

乱序后的演员名单:

[Bruce Lee, Jackie Chan, Jet Li , Arnold Schwarzenegger]

程序分析：

上述程序的第5行构造一个存储String 类型元素的LinkedList对象，接着通过第6~9行语句向该对象中添加了4个字符串对象所表示的演员名字，通过第11行语句将该LinkedList 对象所包含的元素打印出来。第12行语句是完成该LinkedList对象中元素的排序，然后将排好序的元素打印出来。第15行语句完成一个乱序的功能，将LinkedList对象中的元素顺序打乱。

8.4.2 同步

“集合框架”中List、Set和Map类所提供的方法是非同步的，即不是线程安全的，这使得对集合对象的操作更快，效率更高。但若将这些非同步的集合对象应用到多线程的环境下，即在有多个线程同时访问一个集合对象，且至少有一个线程需要更改该对象的情况下，则必须对该集合对象进行外同步操作。该外同步操作通过Collections类所提供的synchronized()方法来实现，通常在集合对象的构造时完成该同步操作。较为典型的示例如下：针对ArrayList类，外同步的实现为：

List list =Collections.synchronizedList(new ArrayList());

此外还要注意，对已同步的集合对象进行迭代操作时，还必须通过关键词synchronized对所获得的迭代器对象进行同步，否则程序会产生不确定的结果。典型实例如下：

List list=Collections.synchronizedList(new ArrayList());

.

Synchronized(list) {

Iterator i=list.iterator();

while(i.hasNext)

foo(i.next());

}

8.4.3 只读

集合的只读处理是指当所有必要的元素都添加到集合后，为避免意外操作修改集合，而对集合所施加的不可更改操作。Collections类可对Collection对象、List对象、Map对象、Set对象、SortMap对象和SortedSet对象进行只读处理。

【例8-16】CollectionDemo2.java 只读应用

1 import java.util.Set;

2 import java.util.HashSet;

3 import java.util.Collections;

4 public class CollectionsDemo2{

5 public static void main(String[] args){

6 Set set=new HashSet();

7 set.add("Tuesday");

8 set.add("Wednsday");

9 set.add("Thursday");

10 set=Collections.unmodifiableSet(set);

11 set.add("Saturday");

12 }

《集合框架及泛型》上机实践内容

《集合框架及泛型》作业 一、根据课上讲解内容，完成演示示例和课堂练习 1、ArrayList获取并打印新闻标题 需求说明：按照以下实现的步骤，使用ArrayList获取和打印新闻标题，显示效果如下图所示： （1）创建多个各类新闻标题对象，包含ID、名称和创建者三个属性； （2）创建存储各类新闻标题的集合对象； （3）按照顺序依次添加各类新闻标题，使用add()方法； （4）获取新闻标题的总数，使用size()方法； （5）根据位置获取相应新闻标题、逐条打印每条新闻标题的名称，使用for 循环遍历。 2、ArrayList存储狗狗信息 需求说明：按照以下实现的步骤，使用ArrayList存储狗狗信息，使用ArrayList的方法对狗狗信息进行删除、读取和判断，显示效果如下图所示：（1）存储多条狗信息，获取狗总数，逐条打印出各条狗信息； （2）删除指定位置的狗，使用remove()方法； （3）判断集合中是否包含指定狗，使用contains()方法；

3、LinkedList添加和删除新闻标题 需求说明：在作业1的基础上，换用LinkedList存储新闻数据，并且使用LinkedList的getFirst()和getLast()方法获取第一条和最后一条数据，以及removeFirst()和removeLast()方法删除第一条和最后一条数据，输出效果如下图所示。 4、集合头尾位置删除和条件狗信息 需求说明：按照作业3的实现方式和所用到LinkedList的方法，实现狗狗信

息的更新并输出，输出效果如图所示。 5、使用Iterator和增强型for循环遍历Set 需求说明：按照以下实现的步骤，使用Iterator和增强型for循环遍历Set，输出效果如下图所示： （1）创建多个各类新闻标题对象，包含ID、名称和创建者三个属性； （2）创建存储各类新闻标题的集合对象； （3）按照顺序依次添加各类新闻标题； （4）获取新闻标题的总数； （5）使用iterator()获取Iterator对象； （6）使用Iterator遍历集合，使用hasNext()方法作为循环条件，判断是否存在另一个可访问的元素； （7）使用增强型for遍历集合；

实验十 泛型与集合框架

实验十泛型与集合框架 1.实验目的 1、掌握LinkedList类和Collections类提供的用于排序和查找链表中 的数据的方法 2、掌握用散列映射来存储数据 3、掌握TreeSet类的使用 2.实验内容 1、根据附录里的源代码，按照注释要求，完成代码填空，使程序能够运行 得出结果。 1）实验1 按身高排序 2）实验2 英汉小字典 3）实验3 演出节目单 4）实验4输出args[]中的单词 2、设计编写程序完成以下任务。 1）仿照实验1编写TV类，要求通过实现Comparable接口规定该类的对象的大小关系，按price值得大小确定大小关系，即电视机按其价格确定之间的大小关系。 2）从控制台输入若干个单词（输入回车结束）放入集合中，将这些单词排序后（忽略大小写）打印出来。 知识点：List接口的实现类、String常用方法 3）请使用LinkedList来模拟一个队列(先进先出的特性): (1)拥有放入对象的方法void put(Object o) (2)取出对象的方法Object get() (3)判断队列当中是否为空的方法boolean isEmpty()；并且，编写测试代码，验证你的队列是否正确。 知识点：List接口的实现类LinkedList常用方法 4）在一个列表中存储以下元素：apple,grape,banana,pear (1)返回集合中的最大的和最小的元素 (2)将集合进行排序，并将排序后的结果打印在控制台上 知识点：Collections类中的方法 3.实验步骤 略 4.评分标准 1.A——内容功能完善，编程风格好，人机接口界面好； 2.B——内容功能完善，编程风格良好，人机接口界面良好；

JAVA实验报告-集合框架与泛型机制

Java 语言程序设计 C 实验报告 集合框架及泛型机制 学生姓名 专业、班级 指导教师 成绩 计算机与信息工程学院 年月日

一、实验目的 学习课程相关章节知识，通过上机练习，掌握以下知识： 1．掌握 List 接口下 ArrayList 及 LinkedList 的使用方法。 2．掌握 Map 接口下 HashMap 及 HashTable的使用方法 3．掌握集合中泛型的使用 二、实验内容 利用集合完成象数据库那样存储数据，并且可以简单查询，利用 map 存储学生信息，字段如下： id ,name,age，实现步骤： （1）创建类，类图如下： （2）在 main 方法编写逻辑代码 （3）运行程序并测试结果 package https://www.doczj.com/doc/418163005.html,; public class Student { private String name ; private int age ; private String id ;

public String getName() { return name ; } public void setName(String name ) { this . name =name ; } public int getAge() { return age ; } public void setAge(int age ) { this. age=age ; } public String getId() { return id; } public void setId(String id) { this. id=id; } public Student(String name ,int age , String id ) { super(); this. name =name ; this. age=age ; this. id=id; } public void sayHi() { System.out.println("name=" +this.getName()+"age=" + this .getAge()+" " + "id=" + this.getId()); } }

JAVA实验报告-集合框架及泛型机制

Java语言程序设计C 实验报告 集合框架及泛型机制 学生姓名 专业、班级 指导教师 成绩 计算机与信息工程学院 年月日 一、实验目的 学习课程相关章节知识,通过上机练习,掌握以下知识:

1.掌握List接口下ArrayList及LinkedList的使用方法。 2.掌握Map接口下HashMap 及HashTable的使用方法 3.掌握集合中泛型的使用 二、实验内容 利用集合完成象数据库那样存储数据,并且可以简单查询,利用map存储学生信息,字段如下: id ,name,age,实现步骤: (1)创建类,类图如下: (2)在main方法编写逻辑代码 (3)运行程序并测试结果 package com、cn; public class Student { private String name; private int age; private String id; public String getName() { return name; } public void setName(String name) {

this、name = name; } public int getAge() { return age; } public void setAge(int age) { this、age = age; } public String getId() { return id; } public void setId(String id) { this、id = id; } public Student(String name, int age, String id) { super(); this、name = name; this、age = age; this、id = id; } public void sayHi() { System、out、println("name="+this、getName()+"age="+this、getAge()+" "+"id="+this、getId()); } } //Databace类 package com、cn; import java、util、Collection; import java、util、HashMap; import java、util、Iterator; public class Databace { private Student a; public Databace() { super(); map=new HashMap(); } public Student getA() { return a; }

实验6 泛型与集合框架_附答案

任务一：用LinkedList存放对象 1.利用面向对象的思想，创建以下类： ●Person类，包含Person的姓名和身份证号码,覆盖Object类的toString() 方法，显示“姓名：XXX 身份证号：XXX”。 ●Student类，继承Person类，包含学生的语文、数学、英文课的成绩，并覆盖 父类的toString()方法，显示“姓名：XXX 身份证号：XXX 语文：XXX 数学：XXX 英文：XXX”。 ●Teacher类，继承Person类，包含教师的工资。并覆盖父类的toString()方 法，显示“姓名：XXX 身份证号：XXX 工资：XXX”。 ●public class Person implements Comparable{ ●String name; ●String ID; ●Person(String s,String i){ ●name=s; ●ID=i; } ●public String toString() { ●String str="姓名："+name+" 身份证号码："+ID; ●return str; } ●public int compareTo(Object arg0) { ●Person p=(Person)arg0; ●return https://www.doczj.com/doc/418163005.html,pareTo(p.ID); } } ●class Student extends Person { ●int Chinese; ●int Math; ●int English; ●Student(String n,String i,int c,int m,int e){ ●super(n,i); ●Chinese=c; ●Math=m; ●English=e; } ●public String toString() { ●String str; ●str=" 语文成绩："+Chinese+" 数学成绩："+Math+" 英语成绩： "+English; ●return super.toString()+str; ●} ●} ●class Teacher extends Person{ ●int salary; ●Teacher(String n,String i,int s){ ●super(n,i); ●salary=s; ●}

学号姓名--集合框架与泛型实验报告

浙江大学城市学院实验报告 课程名称面向对象程序设计 实验项目名称集合框架与泛型 学生姓名专业班级学号 一. 实验目的和要求 1. 了解Java集合框架的接口和实现类 2. 理解泛型类、泛型接口、泛型方法的特点 3. 掌握List接口及其实现类LinkedList、ArrayList 4. 了解Set接口及其实现类HashSet、TreeSet 5. 了解Map及其实现类HashMap、TreeMap 二. 实验内容 1. 分析Java集合框架的接口和实现类的组成 2. 分析泛型类、泛型接口、泛型方法的特点 3. 编程实现：设计学生管理类StudentManager（用List集合管理学生对象） 4. 选作-编程实现：设计学生管理类StudentManager（用Set集合管理学生对象） 5. 选作-编程实现：设计学生管理类StudentManager（用Map管理学生对象） 三. 实验结果与分析（可将程序运行结果截屏，也可分析运行结果） 1. 分析Java集合框架的接口和实现类的组成 请查阅书籍和Java帮助文档，说明Java集合框架的接口组成以及它们的继承关系，并针对每个接口给出具体的实现类。 答： 2. 分析泛型类、泛型接口、泛型方法的特点 请查阅书籍和Java帮助文档，举例说明泛型类、泛型接口、泛型方法的特点。 答： 3. 编程实现：设计学生管理类StudentManager（用List集合管理学生对象）。 StudentManager类的功能包括添加学生、查询学生、删除学生、统计学生成绩等。需要设计表示学生对象的Student类，并用LinkedList或ArrayList集合来管理可被数量的学生对象。另外还需要设计测试类Test来验证StudentManager的功能。 4. 编程实现：设计学生管理类StudentManager（用Set集合管理学生对象）。具体功能 要求同第3题，但是需要用Set的实现类（比如HashSet、TreeSet）管理学生对象。

泛型与集合框架

泛型与集合框架 1.实验目的 1、掌握LinkedList类和Collections类提供的用于排序和查找链表中 的数据的方法 2、掌握用散列映射来存储数据 3、掌握TreeSet类的使用 2.实验内容 1、根据附录里的源代码，完成代码填空，使程序能够运行得出结果。 1）实验1 按身高排序 2）实验2 英汉小字典 3）实验3 演出节目单 4）实验4输出args[]中的单词 2、设计编写程序完成以下任务。 1）仿照实验1编写TV类，要求通过实现Comparable接口规定该类的对象的大小关系，按price值得大小确定大小关系，即电视机按其价格确定之间的大小关系。 2）从控制台输入若干个单词（输入回车结束）放入集合中，将这些单词排序后（忽略大小写）打印出来。 知识点：List接口的实现类、String常用方法 3）请使用LinkedList来模拟一个队列(先进先出的特性): (1)拥有放入对象的方法void put(Object o) (2)取出对象的方法Object get() (3)判断队列当中是否为空的方法boolean isEmpty()；并且，编写测试代码，验证你的队列是否正确。 知识点：List接口的实现类LinkedList常用方法 4）在一个列表中存储以下元素：apple,grape,banana,pear (1)返回集合中的最大的和最小的元素 (2)将集合进行排序，并将排序后的结果打印在控制台上 知识点：Collections类中的方法 3.实验步骤 略 4.评分标准 1.A——内容功能完善，编程风格好，人机接口界面好； 2.B——内容功能完善，编程风格良好，人机接口界面良好； 3.C——完成必做内容；

java集合框架(习题与答案)资料

java 集合框架（习题） 集合框架 Key Point * Collection 接口、Set 接口、List 接口基本操作 * List 接口及其实现类 * Set 接口及其实现类 * 迭代遍历 * Hash 算法与hashCode 方法 * Comparable 接口 * Map 接口及其实现类 * 遍历Map * 泛型 练习 1. 填空 Collection 接口的特点是元素是对象； List 接口的特点是元素有（有|无）顺序，可以（可以|不可以）重复； Set 接口的特点是元素无（有|无）顺序，不可以（可以|不可以）重复；Map 接口的特点是元素是键值对，其中值可以重复，键不可以重复。 2. （List）有如下代码 import java.util.*; public class TestList{ public static void main(String args[]){ List list = new ArrayList(); list.add(“Hello”); list.add(“World”); list.add(1, “Learn”); list.add(1, “Java”); printList(list); } public static void printList(List list){ for(Object obj:list){ String str=(String)obj; System.out.println(obj); } } } 要求： 1) 把//1 处的代码补充完整，要求输出list 中所有元素的内容 2) 写出程序执行的结果Hello java Learn World 3) 如果要把实现类由ArrayList 换为LinkedList，应该改哪里？ArrayList 和LinkedList 使用上有什么区别？实现上有什么区别？

实验13集合框架与泛型实验报告

实验13 集合框架与泛型 一、实验目的和要求 1. 了解Java集合框架的接口和实现类 2. 理解泛型类、泛型接口、泛型方法的特点 3. 掌握List接口及其实现类LinkedList、ArrayList 4. 了解Set接口及其实现类HashSet、TreeSet 5. 了解Map及其实现类HashMap、TreeMap 二、实验内容 1. 分析Java集合框架的接口和实现类的组成 2. 分析泛型类、泛型接口、泛型方法的特点 3. 编程实现：设计学生管理类StudentManager（用List集合管理学生对象） 4. 选作-编程实现：设计学生管理类StudentManager（用Set集合管理学生对象） 5. 选作-编程实现：设计学生管理类StudentManager（用Map管理学生对象） 三、实验步骤 1. 分析Java集合框架的接口和实现类的组成 请查阅书籍和Java帮助文档，说明Java集合框架的接口组成以及它们的继承关系，并针对每个接口给出具体的实现类。 答： 2. 分析泛型类、泛型接口、泛型方法的特点 请查阅书籍和Java帮助文档，举例说明泛型类、泛型接口、泛型方法的特点。 答： 3. 编程实现：设计学生管理类StudentManager（用List集合管理学生对象）。 StudentManager类的功能包括添加学生、查询学生、删除学生、统计学生成绩等。需要设计表示学生对象的Student类，并用LinkedList或ArrayList集合来管理可被数量的学生对象。另外还需要设计测试类Test来验证StudentManager的功能。 4. 编程实现：设计学生管理类StudentManager（用Set集合管理学生对象）。具体功能 要求同第3题，但是需要用Set的实现类（比如HashSet、TreeSet）管理学生对象。 5. 编程实现：设计学生管理类StudentManager（用Map管理学生对象）。具体功能要求