容器

容器总结：
一个图：容器API的类图结构
一个类：Collections
三个知识点：For、Generric、Auto-boxing/unboxin.
六个接口：Collection接口、Iterator接口、Set接口、List接口、Comparable接口、Map接口.

1.容器的概念
装纳其他对象

2.容器API
（1）J2SDK所提供的容器API位于java.util包内。
（2）容器API的类图结构如下图：

Collection 主接口，定义了存取一组对象的方法，其子接口Set和List分别定义了存储方式；
Set 所装的数据对象，没有顺序并且不可以重复；
List 所装的数据对象，有顺序并且可以重复（如果两个对象互相equals,则重复）；
Map接口 定义了存储“键（key）——值（value）映射对”的方法.

3.Collection接口
例：

import java.util.*;
public class Test{
	public static void main(String[] args){
	Collection c = new ArrayList();
	//可以放入不同类型的对象；
	c.add("hello");
	c.add(new Name("f1","11"));
	c.add(new Integer(100));
	System.out.println(c.size());
	System.out.println(c);
	}
}
class Name{
	private String firstName,lastName;
	public Name(String firstName,String lastName) {
	this.firstName = firstName;
	this.lastName = lastName;
	}
	public String getFirstName() {
	return firstName;
	}
	public String getLastName(){
	return lastName;
	}
	public String toString() {
	return firstName + " " + lastName;
	}
}

输出结果：

3
[hello,f1 11,100]

（1）容器类对象在调用remove、contains 等方法是需要比较对象是否相等，这会涉及到对象类型的equals 方法和hashCode 方法：对于自定义的类型，需要重写equals 和 hashcode 方法以实现自定义的对象相等规则。
注：相等的对象应该具有相等的hashcodes。
（2）增加Name类的equals和hashCode方法如下：

public boolean equals(Object obj){
	if(obj instanceof Name){
	Name name = (Name)obj;
	return (firstName.equals(name.firstName))&&(lastName.equals(name.lastName));
	}
	return super.equals(obj);
}
public int hashCode(){
	return firstName.hashCode();
}

4.Iterator接口
（1）所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了Iterator的对象。
（2）Iterator对象称作迭送器，用以方便的实现对容器内元素的遍历操作。
（3）Iterator接口定义了如下方法：
boolean hasNext(); //判断游标右边是否有元素

Object next(); //返回游标右边的元素并将游标移动到下一个位置（JDK1.4前为Object类型）
void remove(); //删除游标左边的元素，在执行完next之后该操作只能执行一次
（4）Iterator对象的remove方法是在迭送过程中删除元素的唯一安全方法。

5.增强的for循环
（1）增强的for循环对于遍历array或Collection的时候相当简便。
（2）缺陷：
数组：不能方便的访问下标值。
集合：与使用Iterator相比，不能方便的删除集合中的内容；在内部也是调用Iterator。
（3）总结：除了简单遍历并读出其中的内容外，不建议使用增强for。
例：

import java.util.*;
public class EnhancedFor{
	public static void main(String[] agrs){
		int[] arr = {1,2,3};
		for(int i : arr){
			System.out.println(i);
		}
		Collection c = new ArrayList();
		c.add(new String("aaa"));
		c.add(new String("bbb"));
		c.add(new String("ccc"));
		for(int o : c){
			System.out.println(o);
		}
	}
}

输出结果：

1
2
3
aaa
bbb
ccc

6.Set接口
（1）Set接口时Collection的子接口，Set接口没有提供额外的方法，但实现Set接口的容器类中的元素时没有顺序的，而且不可以重复。
（2）Set容器可以与数学中“集合”的概念相对应。
（3）J2SDK API 中所提供的Set容器类有HashSet,TreeSet等。
例：

import java.util.*;
public static void main(String[] args){
	Set s = new HashSet();
	Set s1 = new HashSet();
	Set s2 = new hashSet();

	s.add("123");
	s.add("45");
	s.add("123");//相同元素不会被加入

	s1.add("a");
	s1.add("b");
	s1.add("c");

	s2.add("d");
	s2.add("a");
	s2.add("b");
 
	//Set和List容器类都具有Constructor(Collection c) 构造方法用以初始化容器类
	Set sn = new HashSet(s1);
	sn.retainAll(s2);//求交集
	Set su = new HashSet(s1);
	su.addAll(s2);
 
	System.out.println(s);
	System.out.println(sn);
	System.out.println(su);
}

输出结果：

[45, 123]
[a,b]
[a,b,c,d]

7.List接口和Comparable接口
（1）List接口是Collection的子接口，实现List接口的容器类元素是有顺序的，而且可以重复。
（2）List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
（3）J2SDK所提供的List容器类有Arraylist,LinkedList等。
（4）类 java.util.Collections 提供了一些静态方法实现了基于List容器的一些常用方法。
（5）所有可以“排序”的类都实现了java.lang.Comparable 接口，Comparable接口中只有一个方法 public int compareTo(Object obj);
该方法：
返回 0 表示 this == obj;
返回正数表示 this > obj;
返回负数表示 this < obj;
（6）实现了Comparable 接口的类通过实现 comparaTo 方法从而确定该类对象的排序方式。

补充：
如何选择数据结构：
Array读快改慢（数组型）；Linked改快读慢（链条型）；Hash两者之间（不常用）。

8.Collections类
类 java.util.Collections 提供了一些静态方法实现了基于List容器的一些常用方法：
void sort(List); 对List容器内的元素排序。
void shuffle(List); 对list容器内的对象进行随机排列。
void reverse(List); 对List容器内的对象进行逆序排列。
void fill(List,Object); 用一个特定的对象重写整个List容器。
void copy(List dest,List src); 将src List容器内容拷贝到的sest List容器。
int bianrySearch(List,Object); 对于顺序的List容器，采用折半查找的方法查找特定对象。

9.Map接口
（1）实现Map接口的类用来存储键-值 对。
（2）Map接口的实现类有HashMap和TreeMap等。
（3）Map类中存储的键-值对通过键来标识，所以键值不能重复。

10.Auto-boxing/unboxing 自动打包/解包
打包：在合适的时机自动将基础类型转换为对象。
解包：在合适的时机自动将对象转换为基础类型。
例：

import java.util.*;
public class TestMap {
	public static void main(String[] args) {
		//  Map m1 = new HashMap();
		Map<String, Integer> m1 = new HashMap<String,Integer>();//泛型
		//  Map m2 = new TreeMap();
		Map<String, Integer> m2 = new HashMap<String,Integer>();
		//  m1.put("one", new Integer(1));
		m1.put("one", 1);//自动打包
		//  m1.put("two", new Integer(2));
		m1.put("two", 2);
		//  m1.put("three", new Integer(3));
		m1.put("three", 3);
		//  m2.put("A", new Integer(1));
		m2.put("A", 1);
		//  m2.put("B", new Integer(2));
		m2.put("B", 2);
		System.out.println(m1.size());
		System.out.println(m1.containsKey("one"));
		//  System.out.println(m2.containsKey(new Integer(1)))
		System.out.println(m2.containsKey(1));
		if(m1.containsValue("one")) {
			//   int i = ((Integer)m1.get("two")).intValue();
			int i = m1.get("one");//自动解包
			System.out.println(i);
		}
		//  Map m3 = new HashMap(m1);
		Map<String, Integer> m3 = new HashMap<String,Integer>(m1);
		m3.putAll(m2);
		System.out.println(m3);
	}
}

输出结果：

3
true
false
{A=1, B=2, two=2, three=3, one=1}

11.泛型（JDK1.5新增）
（1）起因
JDK1.4以前类型不明确：
（a）装入集合的类型都被当作Object对待，从而失去自己的实际类型。
（b）从集合中取出时往往需要转型，效率低，容易产生错误。

（2）解决办法
（a）在定义集合的时候同时定义集合中对象的类型。
（b）可以在定义Collection的时候指定，也可以在循环时用Iterator指定。

（3）好处
增强程序的可读性和稳定性。