java集合框架

1、java集合架构支持3种类型的集合：规则集（Set），线性表（List），和图（Map），分别定义在Set，List，Map中。Set实例存储一组互不相同的元素（集合），List实例存储一组顺序排列的元素（表），Map存储一组 对象---关键值的映射
总的架构如下，非常重要，包含继承关系，实现的分类，一目了然：
Collection接口：　
　　　　　　　Set接口：
　　　　　　　　　　　　HashSet具体类
　　　　　　　　　　　　LinkedHashSet具体类
　　　　　　　　　　　　TreeSet具体类
　　　　　　　List接口：　
　　　　　　　　　　　　ArrayList具体类
　　　　　　　　　　　　LinkedList具体类
　　　　　　　　　　　　向量类Vector具体类
　　　　　　　　　　　　Stack具体类
Map接口：
　　　　　　　HashMap类
　　　　　　　LinkedHashMap类
　　　　　　　TreeMap类　
　　
2、集合Collection接口  

--Collection 是任何对象组，元素各自独立，通常拥有相同的套用规则。Set List由它派生。

Collection 和 Collections的区别。  

Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。  

Collection是个java.util下的接口，它是各种集合结构的父接口


基本操作  增加元素add(Object obj); addAll(Collection c);  

删除元素 remove(Object obj); removeAll(Collection c); 

求交集 retainAll(Collection c); 

删除元素 remove(Object obj); removeAll(Collection c); 

求交集 retainAll(Collection c);  

访问/遍历集合元素的好办法是使用Iterator接口(迭代器用于取代Enumeration)

3、Set接口

Set：不允许重复，无序，允许1个null值。
实现类：HashSet-基于散列表的集，加进散列表的元素要实现hashCode()方法  

      LinkedHashSet-对集迭代时，按增加顺序返回元素 

     TreeSet-基于（平衡）树的数据结构   

注：LinkedHashSet只是按照添加的的先后顺序在存储时保持顺序，要给集合元素添加顺序属性，需要使用TreeSet（集合元素有排序关系）。

TreeSet实现排序的2种方式：

》1.通过TreeSet(Comparator<? super E> comparator) 构造方法指定TreeSet的比较
（1).构造装入TreeSet的java bean

例如：

package src;


public class Foo {

private int num;

public int getNum() {
return num;
}

public void setNum(int num) {
this.num = num;
}

public String toString()
{
return "foo:" + this.getNum() + ",";
}
}

(2).自己实现比较器

例如：

package src;

import java.util.Comparator;

public class MyComparator implements Comparator<Foo> {

public int compare(Foo f1,Foo f2) {

if (f1.getNum() > f2.getNum())
{
return 1;
}
else if (f1.getNum() == f2.getNum())
{
return 0;
}
else
{
return -1;
}
}
}

(3)new TreeSet时指定比较器

TreeSet<Foo> set = new TreeSet(new MyComparator());

》2.使用TreeSet()构造方法，并对需要添加到set集合中的元素实现Comparable接口进行排序；
(1).构造bean，需要实现Comparable接口，并重写compareTo()方法，compareTo方法中定义排序的方式

package src;

public class Foo implements Comparable{

private int num;

public int getNum() {
return num;
}

public void setNum(int num) {
this.num = num;
}

public String toString()
{
return "foo:" + this.getNum() + ",";
}

public int compareTo(Object obj) {
if (obj instanceof Foo)
{
Foo foo = (Foo)obj;
if (this.num > foo.getNum())
{
return 1;
}
else if (this.num == foo.getNum())
{
return 0;
}
else
{
return -1;
}

}
return 0;
}
}

(2).创建TreeSet时直接使用构造TreeSet()方法

TreeSet<Foo> set = new TreeSet();

4、List接口
  ArrayList（不同步）：使用数组实现的动态扩展容量的list
  LinkedList：是链式实现的list。
  Vector（同步）类：它除了包含访问和修改向量的同步方法之外，跟ArrayList一样。
   Stack类：它继承自Vector类，，但一般只作为栈的功能来使用，不要去使用Vector里面的功能
注：
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Stack;
import java.util.Vector;

public class OldCollection {
	static void vector(){
		//实现可变长度的对象数组
		//组件可以使用整型下标访问
		//线程安全

		Vector vector = new Vector();
		vector.add("a");
		vector.add("b");
		vector.add("c");
		vector.add("d");
		vector.add("e");
		System.out.println(vector);
		
		
		//老的迭代器  里面没有删除的方法
		Enumeration enumeration = vector.elements();
		while(enumeration.hasMoreElements()){
			System.out.println(enumeration.nextElement());
		}
		
		for (Iterator iter = vector.iterator(); iter.hasNext();) {
			Object element = (Object) iter.next();
			if(element.equals("c")){
				iter.remove();
			}
		}
		System.out.println(vector);
	}
	static void stack(){
		Stack stack = new Stack();
		//先进后出  
		stack.push(1);//压入栈顶
		stack.push(2);//压入栈顶
		stack.push(3);//压入栈顶
		stack.push(4);//压入栈顶
		stack.push(5);//压入栈顶
		
		
		int count = stack.size();
		for (int i = 0; i < count; i++) {
			System.out.println("查看栈顶:"+stack.peek());
			//System.out.println(stack.pop());//移除并返回值		
		}
		
	}
	
	static void linkedList() {
		LinkedList linkedList = new LinkedList();
		linkedList.add("center");
		linkedList.addFirst("first");
		linkedList.addLast("last");
		System.out.println(linkedList);
		linkedList.removeFirst();
		System.out.println(linkedList);
		linkedList.removeLast();
		System.out.println(linkedList);

	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//vector();
		//stack();
		linkedList();

	}

}

5、Map接口
（1）实现类
HashMap：效率高
LikedHashMap：按照添加顺序存储，可以按添加顺序取出
TreeHashMap：排序性

（2）处理Map的三种集合  

关键字集KeySet()  

数值集value() 

项目集enrySet() 
（3）Map.Entry接口
getKey()
getValue()
setValue()

import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

public class TestMap {
	/**
	 * 关键字唯一 将键映射至值的对象 每个键最多都只能映射至一个值 无序排列 键值对
	 * 键不可以重复，值可以重复
	 */

	static void mapFunction() {
		HashMap map = new HashMap();
		map.put("a", "aaaa");
		map.put("key1", "value1");
		map.put("key2", "value2");
		map.put("key3", "value3");
		map.put("key4", "value4");
		map.put("yy", "vyyy");
		map.put("yy", "same");// 覆盖前面的键值对
		System.out.println("map=" + map);
		int size = map.size();//集合的键值对个数
		
		Object get = map.get("key2");//通过键获得值
		System.out.println("get="+get);
		boolean containsKey = map.containsKey(new String("yy"));// true 是否包含键
		boolean containsValue = map.containsValue("same");//是否包含值
		map.remove("key1");// 移除键值对s
		System.out.println("map=" + map);
//		map.clear();
		System.out.println("isEmpty="+map.isEmpty());//判断map是否包含键值对
		Map map2 = new HashMap();
		map2.put("1", "11");
		map2.put("2", "22");
		map.putAll(map2);
		
		System.out.println("map=" + map);
		
//		for (int i = 0; i < 100; i++) {
//			map.put(i, i*i);			
//		}
//		
//		int i  = 8;
//		System.out.println(map.get(i));
	}
	
	
	static void mapIterator() {
		//三种迭代 
		// 1 键set  keySet
		// 2 值集合 collection  values
		//3   键值对实体 entrySet  set里面存放的是entry对象
		Map map = new Hashtable();
		map.put("keya", "valuea");
		map.put("keyb", "valueb");
		map.put("keyc", "valuec");
		System.out.println("迭代一 键set集合");
		Set keySet = map.keySet();
		for (Iterator iter = keySet.iterator(); iter.hasNext();) {
			Object key = (Object) iter.next();
			Object value = map.get(key);
			System.out.println(key+":"+value);			
		}
		
		System.out.println("迭代二  value集合 collection");
		Collection values = map.values();
		for (Iterator iter = values.iterator(); iter.hasNext();) {
			Object value = (Object) iter.next();
			System.out.println(value);			
		}
		
		System.out.println("迭代三  键值对的实体set视图");
		Set entrySet = map.entrySet();
		for (Iterator iter = entrySet.iterator(); iter.hasNext();) {
			Entry entry = (Entry) iter.next();
			System.out.println(entry.getKey()+":"+entry.getValue());
			if(entry.getKey().equals("keya")){				
				entry.setValue("修改后的值");
			}
		}
		
		System.out.println(map);
		
		
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		mapIterator();
		

	}

}

6、迭代器Iterator快速失败机制
Iterator是获取集合中元素的过程，实际上帮助获取集合中的元素。
快速失败：报出的异常为 java.util.ConcurrentModificationException 异常
当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。

当使用 fail-fast iterator 对 Collection 或 Map 进行迭代操作过程中尝试直接修改 Collection / Map 的内容时，即使是在单线程下运行， java.util.ConcurrentModificationException 异常也将被抛出。
　　Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。
　　所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。