java集合

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.TreeSet;


public class CollectionList {
	
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		
		//ArrayList
		Collection c = new ArrayList();
		c.add("李大妈");
		c.add(6);
		System.out.println(c.size());//2
		c.remove(6);
		System.out.println(c.size());//1
		System.out.println(c.contains("李大妈"));//true 判断是否有这个元素。
		c.add("J2EE");
		c.add("权威指南");
		c.add(11);
		System.out.println(c);//[李大妈, J2EE, 权威指南, 11]
		
		//HashSet 不是同步的，如果多个线程同时访问一个HashSet，必须通过代码保证其同步。集合元素可以使null
		//无序，不可重复。
		Collection book = new HashSet();
		book.add("权威指南");
		book.add(11);
		//C 集合是否包含book集合（C与book集合相同，C集合可以比book集合多）
		System.out.println(c.containsAll(book));
		//C集合减轻book集合里元素 ,反过来的话book集合元素就减没了。
		c.removeAll(book);
		System.out.println(c);//[李大妈, J2EE]
		//清除C集合元素
	    c.clear();
	    System.out.println(c);//[]
	    //book集合里只剩下C集合也同时包含的元素(取交集)
	    book.retainAll(c);
	    System.out.println(book);//[]
	    
	    //Iterator 迭代器的用法
	    Collection coll = new HashSet();
	    coll.add("矮矮");
	    coll.add("哥哥");
	    coll.add("暨南大学");
	    coll.add(555); 
	    Iterator it = coll.iterator();
	    while (it.hasNext()) {
	    	//因为不确定什么类型，所以用OBject对象
			Object obj = it.next();
	
			System.out.println(obj);
			
		}
	    
	    //TreeSet 类 TreeSet是SortedSet接口（上一层接口是Set）的唯一实现类
	    //有序的
	    TreeSet nums = new TreeSet();
	
	    nums.add(1 );
	    nums.add(2 );
	    nums.add(3);
	    nums.add(4);
	    nums.add(5);
	    
	    System.out.println(nums);//[-1, 2, 7, 33]自动从小到大排序。
	    //第一个元素
	    System.out.println(nums.first());
	    //最后一个元素
	    System.out.println(nums.last());
	    //返回小于4的子集
	    System.out.println(nums.headSet(4));
	    //返回大于4的子集
	    System.out.println(nums.tailSet(4));
	    //返回大于1小于4的子集
	    System.out.println(nums.subSet(1, 4));
	    
	    //List接口 集合 有序的、可重复的、每个元素可以根据索引来找到。
	    List b = new ArrayList();
	    b.add(new String("aa"));
	    b.add(new String("bb"));
	    b.add(new String("cc"));
	    b.add(new String("dd"));
	    System.out.println(b);//[aa, bb, cc, dd]
	    
	    // 新建的元素插在集合的第二个位置，原来的集合不会覆盖，会往后推移一个位置。
	    b.add(1,new String("ee"));
	    Iterator itb =  b.iterator();
	    while (itb.hasNext()) {
	    	System.out.println(itb.next());	//aa ee bb cc dd
		}
	    //删除第三个元素。
	   b.remove(2);//
	   System.out.println(b);//[aa, ee, cc, dd]
	   //判断指定元素的位置 输出 1  说明在元素在集合的第二个位置 输出-1说明找不到集合。
	   System.out.println(b.indexOf(new String("ee")));//1
	   //截取第二个到第三个元素
	   System.out.println(b.subList(1, 2));//[ee]
	   
	   //ListIterator 迭代器用法
	    ListIterator listI = b.listIterator();
	    while (listI.hasNext()) {
			System.out.println(listI.next());//aa ee cc dd  迭代的时候加* 不会在这打印出来。
			//向上一次迭代的元素后面加
			listI.add("*");
		}
	    System.out.println("------------"+b);//[aa, *, ee, *, cc, *, dd, *]
	    //向后迭代
	    while(listI.hasPrevious())
	    {
	    	System.out.println(listI.previous());//* dd * cc * ee * aa
	    }
	    
	    //LinkedList 即实现了List集合也实现了queue接口也就是双向队列接口，它是基于链表实现的List类，
	    //对顺序访问集合中的元素进行优化，特别是当插入、删除元素时的速度非常快。
	    LinkedList ll = new LinkedList();
	    ll.add("Ok");
	    // 加入队列的尾部
	    ll.offer("struct");
	    //加入栈
	    ll.push("hibernate");
	    //加入队列头部
	    ll.push("spring");
	    for (int i = 0; i < ll.size(); i++) {
	    	System.err.println(ll.get(i));//spring hibernate struct
		}
	    
	    //访问第一个元素
	    System.out.println("peek:"+ll.peekFirst());
	  //访问最后一个元素
	    System.out.println("peek:"+ll.peekLast());
	    
	  //采用出栈方式，降低一个元素pop出列。
	    System.out.println(ll.pop());//spring出列
	    System.err.println("ll:"+ll);//ll:[hibernate, Ok, struct]
	    //最后一个元素出列
	    ll.pollLast();
	    System.out.println("ll2:"+ll);//ll2:[hibernate, Ok]
         
	    //ArrayList / LinkedList / 性能进行比较
	    /**
	     加入Array元素的时间：297
			加入LinkedList元素的时间：547
			Iterator ArrayList 集合 元素的时间：234
			Iterator LinkedList 集合 元素的时间2：78
			for ArrayList 集合 元素的时间2：16
			
			总结： 添加元素 Array比LinkedList快。
				   用Iterator 遍历集合 LinkedList 比Array快
				   所以遍历集合ArrayList最好用get 最快。
			 如果要经常做插入、删除操作，LinkedList效率比ArrayList/Vertor 快。
	     * */
	    
	    String[] str = new String[9000000];
	    for (int i = 0; i < 9000000; i++) {
			str[i] = String.valueOf(i);
		}
	    Long start = System.currentTimeMillis();
	    ArrayList al = new ArrayList();
	    for (int i = 0; i < str.length; i++) {
			al.add(str[i]);
		}
	    System.out.println("加入Array元素的时间："+(System.currentTimeMillis()-start));
	    start = System.currentTimeMillis();
	    LinkedList l = new LinkedList();
	    for (int i = 0; i < str.length; i++) {
			l.add(str[i]);
		}
	    System.out.println("加入LinkedList元素的时间："+(System.currentTimeMillis()-start));
	    start= System.currentTimeMillis();
	    for(Iterator t = al.iterator();t.hasNext();)
	    {
	    	t.next();
	    }
	    System.out.println("Iterator ArrayList 集合 元素的时间："+(System.currentTimeMillis()-start));
	    
	    start= System.currentTimeMillis();
	    for(Iterator l2 = l.iterator();l2.hasNext();)
	    {
	    	l2.next();
	    }
	    System.out.println("Iterator LinkedList 集合 元素的时间2："+(System.currentTimeMillis()-start));
	    start = System.currentTimeMillis();
	    for (int i = 0; i < str.length; i++) {
	    	al.get(i);
		}
	    System.out.println("for ArrayList 集合 元素的时间2："+(System.currentTimeMillis()-start));
	    
	    
	    //Map 是顶级接口，实现类有HashMap 、Hashtable等实现类。
	    //Map里的Key不能重复，key没有顺序，使用keySet（）方法可以把Map里的集合组成Set集合。
	    //HashMap  和  Hashtable 区别：、
	    //Hashtable是线程安全，所以HashMap比Hashtable性能高，如果有多个线程同时访问使用Hashtable更好。
	    //Hashtable 不允许有ＮＵＬＬ作为Ｋｅｙ和Ｖａｌｕｅ
	   // 都是不能保证顺序的。
	    //
	}
}