1  集合类简介

集合类存放于java.util包中。

集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用(reference)。

集合类型主要有3种：list(集)、set(列表)和map(映射)。

具体关系如下：

Collection

List

├LinkedList

├ArrayList

└Vector

└Stack

Set

├HashSet

├TreeSet

└Linked HashSet

Map

├Hashtable

├HashMap

└WeakHashMap

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素(Elements)。一些Collection允许有相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。

所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。

如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：

Iterator it = collection.iterator(); // 获得一个迭代子
while(it.hasNext()) {
Object obj = it.next(); // 得到下一个元素
}

2List介绍及简单使用

介绍：List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置，类似于数组下标)来访问List中的元素，这类似于Java的数组。和下面要提到的Set不同，List允许有相同的元素。

除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素， 还能向前或向后遍历。

实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

实例：查找 List 中的最大最小值

以下实例演示了如何使用 Collections类的 max() 和 min() 方法来获取List中最大最小值：

import java.util.*;public classMain {public static voidmain(String[] args) {
List list= Arrays.asList("one Two three Four five six one three Four".split(" "));
System.out.println(list);
System.out.println("最大值: " +Collections.max(list));
System.out.println("最小值: " +Collections.min(list));
}}

以上代码运行输出结果为：

[one, Two, three, Four, five, six, one, three, Four]

最大值: three

最小值: Four

2.1LinkedList介绍及简单使用

介绍：LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.

LinkedList的构造函数如下

1. public LinkedList():  ——生成空的链表

2. public LinkedList(Collection col):  复制构造函数

实例：获取链表的第一个和最后一个元素

importjava.util.LinkedList;public classLinkedListTest{public static voidmain(String[] args) {
LinkedList lList = new LinkedList();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
System.out.println("链表的第一个元素是 : " +lList.getFirst());
System.out.println("链表最后一个元素是 : " +lList.getLast());
}
}

2.2ArrayList介绍及简单使用

介绍：ArrayList就是传说中的动态数组，换种说法，就是Array的复杂版本，它提供了如下一些好处：

动态的增加和减少元素

实现了ICollection和IList接口

灵活的设置数组的大小

实例：

ArrayList List = newArrayList();for( int i=0;i <10;i++ ) //给数组增加10个Int元素
List.Add(i);//..程序做一些处理
List.RemoveAt(5);//将第6个元素移除
for( int i=0;i <3;i++ ) //再增加3个元素
List.Add(i+20);
Int32[] values= (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组

2.3Vector介绍及简单使用

介绍：

Vector类实现了一个动态数组。和ArrayList和相似，但是两者是不同的：

Vector是同步访问的。

Vector包含了许多传统的方法，这些方法不属于集合框架。

Vector主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况。

Vector类支持4种构造方法。

第一种构造方法创建一个默认的向量，默认大小为10：

Vector()

第二种构造方法创建指定大小的向量。

Vector(int size)

第三种构造方法创建指定大小的向量，并且增量用incr指定.增量表示向量每次增加的元素数目。

Vector(int size,int incr)

第四中构造方法创建一个包含集合c元素的向量：

Vector(Collection c)

实例：

import java.util.*;public classVectorDemo {public static voidmain(String args[]) {//initial size is 3, increment is 2
Vector v = new Vector(3, 2);
System.out.println("Initial size: " +v.size());
System.out.println("Initial capacity: " +v.capacity());
v.addElement(new Integer(1));
v.addElement(new Integer(2));
v.addElement(new Integer(3));
v.addElement(new Integer(4));
System.out.println("Capacity after four additions: " +v.capacity());
v.addElement(new Double(5.45));
System.out.println("Current capacity: " +v.capacity());
v.addElement(new Double(6.08));
v.addElement(new Integer(7));
System.out.println("Current capacity: " +v.capacity());
v.addElement(new Float(9.4));
v.addElement(new Integer(10));
System.out.println("Current capacity: " +v.capacity());
v.addElement(new Integer(11));
v.addElement(new Integer(12));
System.out.println("First element: " +(Integer)v.firstElement());
System.out.println("Last element: " +(Integer)v.lastElement());if(v.contains(new Integer(3)))
System.out.println("Vector contains 3.");//enumerate the elements in the vector.
Enumeration vEnum =v.elements();
System.out.println("\nElements in vector:");while(vEnum.hasMoreElements())
System.out.print(vEnum.nextElement()+ " ");
System.out.println();
}}
以上实例编译运行结果如下：
Initial size: 0
Initial capacity: 3
Capacity after four additions: 5
Current capacity: 5
Current capacity: 7
Current capacity: 9
First element: 1Last element: 12Vector contains 3.
Elements in vector:1 2 3 4 5.45 6.08 7 9.4 10 11 12

2.3.1Stack介绍及简单使用

介绍：

栈是Vector的一个子类，它实现了一个标准的后进先出的栈。

堆栈只定义了默认构造函数，用来创建一个空栈。 堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法。

Stack()

除了由Vector定义的所有方法，自己也定义了一些方法：

序号

方法描述

1

boolean empty()

测试堆栈是否为空。

2

Object peek( )

查看堆栈顶部的对象，但不从堆栈中移除它。

3

Object pop( )

移除堆栈顶部的对象，并作为此函数的值返回该对象。

4

Object push(Object element)

把项压入堆栈顶部。

5

int search(Object element)

返回对象在堆栈中的位置，以 1 为基数。

实例：

下面的程序说明这个集合所支持的几种方法

import java.util.*;public classStackDemo {static void showpush(Stack st, inta) {
st.push(newInteger(a));
System.out.println("push(" + a + ")");
System.out.println("stack: " +st);
}static voidshowpop(Stack st) {
System.out.print("pop -> ");
Integer a=(Integer) st.pop();
System.out.println(a);
System.out.println("stack: " +st);
}public static voidmain(String args[]) {
Stack st= newStack();
System.out.println("stack: " +st);
showpush(st,42);
showpush(st,66);
showpush(st,99);
showpop(st);
showpop(st);
showpop(st);try{
showpop(st);
}catch(EmptyStackException e) {
System.out.println("empty stack");
}
}}

以上实例编译运行结果如下：

stack: [ ]
push(42)
stack: [42]
push(66)
stack: [42, 66]
push(99)
stack: [42, 66, 99]
pop-> 99stack: [42, 66]
pop-> 66stack: [42]
pop-> 42stack: [ ]
pop-> empty stack

3Set介绍

介绍：

Set不保存重复的元素。Set中最常被使用的是测试归属性，你可以很容易的询问某个对象是否在某个Set中。Set具有与Collection完全一样的接口，因此没有任何额外的功能。实际上Set就是Collection，只是行为不同。

实现了Set接口的主要有HashSet、TreeSet、LinkedHashSet这几个共同点就是每个相同的项只保存一份。他们也有不同点，区别如下：

3.1 HashSet介绍及简单使用

介绍：

HashSet使用的是相当复杂的方式来存储元素的，使用HashSet能够最快的获取集合中的元素，效率非常高(以空间换时间)。会根据hashcode和equals来庞端是否是同一个对象，如果hashcode一样，并且equals返回true，则是同一个对象，不能重复存放。

实例：

packagecom.set;importjava.util.HashSet;importjava.util.Set;classStudent{intid;public Student(intid) {this.id =id;
}
@OverridepublicString toString() {return this.id+"";
}
@Overridepublic inthashCode() {return this.id;
}
@Overridepublic booleanequals(Object obj) {if (obj instanceofStudent){
Student stu=(Student) obj;if (stu.id == this.id)return true;
}return false;
}
}public classHashSetTest {public static voidmain(String[] args) {
Set set = new HashSet();
Student s1= new Student(1);
Student s2= new Student(1);
Student s3= new Student(2);
set.add(s1);
set.add(s2);
set.add(s3);for(Student s : set) {
System.out.println(s);
}
}
}

正如上例所示，重写了hashCode()和equals()方法来区分同意对象后，就不能存放同以对象了。如果注释这两个方法，则所有Student对象视为不同对象，都可以存放。

3.2 TreeSet介绍及简单使用

介绍：

TreeSet也不能存放重复对象，但是TreeSet会自动排序，如果存放的对象不能排序则会报错，所以存放的对象必须指定排序规则。排序规则包括自然排序和客户排序。

①自然排序：TreeSet要添加哪个对象就在哪个对象类上面实现java.lang.Comparable接口，并且重写comparaTo()方法，返回0则表示是同一个对象，否则为不同对象。

②客户排序：建立一个第三方类并实现java.util.Comparator接口。并重写方法。定义集合形式为TreeSet ts = new TreeSet(new第三方类());

实例：

下面一个例子用TreeSet存放自然排序的对象：

packagecom.set;importjava.util.Set;importjava.util.TreeSet;class Student1 implements Comparable{intid;public Student1(intid) {this.id =id;
}
@OverridepublicString toString() {return this.id+"";
}
@Overridepublic inthashCode() {return this.id;
}
@Overridepublic booleanequals(Object obj) {if (obj instanceofStudent1){
Student1 stu=(Student1) obj;if (stu.id == this.id)return true;
}return false;
}public intcompareTo(Student1 o) {return (this.id-o.id);
}
}public classTreeSetTest {public static voidmain(String[] args) {
Set set = new TreeSet();
Student1 s1= new Student1(5);
Student1 s2= new Student1(1);
Student1 s3= new Student1(2);
Student1 s4= new Student1(4);
Student1 s5= new Student1(3);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);for(Student1 s : set) {
System.out.println(s);
}
}
}

输出结果为：

1

2

3

4

5

3.3 Linked HashSet介绍

介绍：LinkedHashSet按照插入顺序保存对象，同时还保存了HashSet的查询速度。

4Map介绍及简单使用

介绍：

Map接口中键和值一一映射.可以通过键来获取值。

给定一个键和一个值，你可以将该值存储在一个Map对象.之后，你可以通过键来访问对应的值。

当访问的值不存在的时候，方法就会抛出一个NoSuchElementException异常.

当对象的类型和Map里元素类型不兼容的时候，就会抛出一个ClassCastException异常。

当在不允许使用Null对象的Map中使用Null对象，会抛出一个NullPointerException异常。

当尝试修改一个只读的Map时，会抛出一个UnsupportedOperationException异常。

序号

方法描述

1

void clear( )

从此映射中移除所有映射关系(可选操作)。

2

boolean containsKey(Object k)

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

3

boolean containsValue(Object v)

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

4

Set entrySet( )

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

5

boolean equals(Object obj)

比较指定的对象与此映射是否相等。

6

Object get(Object k)

返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。

7

int hashCode( )

返回此映射的哈希码值。

8

boolean isEmpty( )

如果此映射未包含键-值映射关系，则返回 true。

9

Set keySet( )

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

10

Object put(Object k, Object v)

将指定的值与此映射中的指定键关联(可选操作)。

11

void putAll(Map m)

从指定映射中将所有映射关系复制到此映射中(可选操作)。

12

Object remove(Object k)

如果存在一个键的映射关系，则将其从此映射中移除(可选操作)。

13

int size( )

返回此映射中的键-值映射关系数。

14

Collection values( )

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

实例：

import java.util.*;public classCollectionsDemo {public static voidmain(String[] args) {
Map m1= newHashMap();
m1.put("Zara", "8");
m1.put("Mahnaz", "31");
m1.put("Ayan", "12");
m1.put("Daisy", "14");
System.out.println();
System.out.println(" Map Elements");
System.out.print("\t" +m1);
}}

以上实例编译运行结果如下：

Map Elements
{Mahnaz=31, Ayan=12, Daisy=14, Zara=8}

4.1Hashtable介绍及简单使用

介绍：

Hashtable是原始的java.util的一部分， 是一个Dictionary具体的实现 。

然而，Java 2 重构的Hashtable实现了Map接口，因此，Hashtable现在集成到了集合框架中。它和HashMap类很相似，但是它支持同步。

像HashMap一样，Hashtable在哈希表中存储键/值对。当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值。

然后，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。

实例：

下面的程序说明这个数据结构支持的几个方法：

import java.util.*;public classHashTableDemo {public static voidmain(String args[]) {//Create a hash map
Hashtable balance = newHashtable();
Enumeration names;
String str;doublebal;
balance.put("Zara", new Double(3434.34));
balance.put("Mahnaz", new Double(123.22));
balance.put("Ayan", new Double(1378.00));
balance.put("Daisy", new Double(99.22));
balance.put("Qadir", new Double(-19.08));//Show all balances in hash table.
names =balance.keys();while(names.hasMoreElements()) {
str=(String) names.nextElement();
System.out.println(str+ ": " +balance.get(str));
}
System.out.println();//Deposit 1,000 into Zara's account
bal = ((Double)balance.get("Zara")).doubleValue();
balance.put("Zara", new Double(bal+1000));
System.out.println("Zara's new balance: " +balance.get("Zara"));
}}

以上实例编译运行结果如下：

Qadir: -19.08Zara: 3434.34Mahnaz: 123.22Daisy: 99.22Ayan: 1378.0Zara's new balance: 4434.34

4.2HashMap简单使用

介绍：以下实例演示了如何使用 Collection 类的 iterator() 方法来遍历集合：

import java.util.*;public classMain {public static voidmain(String[] args) {
HashMap< String, String> hMap =
new HashMap< String, String>();
hMap.put("1", "1st");
hMap.put("2", "2nd");
hMap.put("3", "3rd");
Collection cl=hMap.values();
Iterator itr=cl.iterator();while(itr.hasNext()) {
System.out.println(itr.next());
}
}}

以上代码运行输出结果为：

3rd

2nd

1st

4.3WeakHashMap介绍

介绍：

WeakHashMap实现了Map接口，是HashMap的一种实现，他使用弱引用作为内部数据的存储方案，WeakHashMap可以作为简单缓存表的解决方案，当系统内存不够的时候，垃圾收集器会自动的清除没有在其他任何地方被引用的键值对。

如果需要用一张很大的HashMap作为缓存表，那么可以考虑使用WeakHashMap，当键值不存在的时候添加到表中，存在即取出其值。

WeakHashMap weakMap = new WeakHashMap();for(int i = 0; i < 10000; i++){
Integer ii= newInteger(i);
weakMap.put(ii,new byte[i]);
}