java集合collection

框架图

1 List

1.1 ArrayList

1 不带泛型参数

	// 1 创建空的动态数组对象。如果不带泛型，则可存放任何对象
		ArrayList list = new ArrayList();
		// 默认10个空间的容积 new ArrayList(可以指定初始容积)
		// 2 获取真实的容量
		System.out.println(list.size());
		// 3 添加元素
		list.add("aaaa");// 往末尾添加元素
		list.add("bbbb");// 往末尾添加元素
		list.add(0, "cccc");// 在指定的位置 ，插入元素,把原先位置的元素顶到下一个位置
		list.add(100); // 插入整数。
		list.add("cccc"); 
		list.set(2, "xxxx");// 对指定位置的元素，直接赋值。
		System.out.println(list.size());
		for(Object e:list){
			System.out.print(e+" ");
		}
		System.out.println();
		// 4 获取第2个元素的值
		Object obj = list.get(2);
		System.out.println("序号为2的元素是：" + obj);
		obj = list.get(3);
		System.out.println("序号为3的元素是：" + obj);

		// 5 元素的查找。找不到返回-1。
		int pos = list.indexOf("cccc"); // 首次出现的序号
		System.out.println("首次位置是：" + pos);
		pos = list.lastIndexOf("cccc"); // 最后依次出现的序号
		System.out.println("末次位置是：" + pos);

		// 6 元素的删除。实际只是将引用从数组中去除，并不直接删除元素本身。
		System.out.println("删除序号为4的元素："+list.remove(4)); // 按序号删除。删除序号为4的元素 。//
		System.out.println("删除指定元素："+list.remove("cccc")); // 指定元素删除。返回是否删除成功！
		// 7 数组的清空
		list.clear();
		// 8 判断数组是否是空数组
		System.out.println("是否为空:" + list.isEmpty());
		
		System.out.println(list.size());

0
5
cccc aaaa xxxx 100 cccc 
序号为2的元素是：xxxx
序号为3的元素是：100
首次位置是：0
末次位置是：4
删除序号为4的元素：cccc
删除指定元素：true
是否为空:true
0

2 遍历

	ArrayList list = new ArrayList();
		list.add(10);
		list.add(9);
		list.add(8);
		list.add(7);
		// 1 标准for循环.i代表元素的序号
		for (int i = 0; i < list.size(); i++) {
			Object obj = list.get(i);
			System.out.print(obj + "\t");
		}
		System.out.println("************");
		// 2 增强for循环。全部遍历，由ArrayList类规定遍历的规则。
		// 本质上使用的也是迭代器。
		for (Object obj : list) {
			System.out.print(obj + "\t");
		}
		System.out.println("************");

		// 3 迭代器遍历
		Iterator it = list.iterator(); // 获取集合的起点
		while (it.hasNext()) // 只要还有下一站
		{
			Object obj = it.next();// 往前走，并返回下个元素
			System.out.print(obj + "\t");
		}
		System.out.println("************");

10	9	8	7	************
10	9	8	7	************
10	9	8	7	************

3 exe1

ArrayList list = new ArrayList();
		list.add(10.0f);
		list.add("aaa");
		list.add(2);

		// 使用for循环进行依次输出。-- "遍历"

		for (int i = 0; i < list.size(); i++) {
			Object obj = list.get(i);

			System.out.print(obj + " ");
			// 如果元素是字符串，那么输出字符串的长度
			// 左边对象 是否是 右边的类型
			if (obj instanceof java.lang.String) {
				// 向下转型成子类对象
				String str = (String) obj;
				System.out.print("长度为:" + str.length() + " ");
			}
		}
		System.out.println();

10.0 aaa 长度为:3 2 

4 exe2

ArrayList<Student> list = new ArrayList<Student>();
		// 2 添加学生
		list.add(new Student("白1", 18));
		list.add(new Student("白2", 28));
		list.add(new Student("白3", 38));
		list.add(new Student("白4", 88));

		// 3 删除第3个学生
		Student stu = list.remove(2);
		System.out.println("被删除的学生信息是:" + stu);

		// 使用迭代器进行遍历时，尽量不要在循环的内部进行删除

		// 4 遍历学生
		// 使用标准for进行遍历，允许在循环中删除元素
		for (int i = 0; i < list.size(); i++) {
			Student s = list.get(i);
			if (s.getScore() > 70) {
				list.remove(s);
				i--; // 删除后，该序号需要重新访问依次
			}
		}

		for (Student s : list) {
			System.out.println(s);
		}

被删除的学生信息是:Student [score=38.0, sname=白3]
Student [score=18.0, sname=白1]
Student [score=28.0, sname=白2]

5 ListIterator

 List<String> a=new ArrayList<String>();
        a.add("a");
        a.add("b");
        a.add("c");
        System.out.println("a集合："+a);
        
        List<String> b=new ArrayList<String>();
        b.add("d");
        b.add("e");
        b.add("f");
        b.add("g");
        System.out.println("b集合："+b);
        
        //ListIterator在Iterator基础上添加了add(),previous()和hasPrevious()方法
        ListIterator<String> aIter=a.listIterator();
        
        //普通的Iterator只有三个方法，hasNext()，next()和remove()
        Iterator<String> bIter=b.iterator();
        
        //在a中，间隔交叉得插入b中的元素
        while(bIter.hasNext()){
            if(aIter.hasNext()){
                aIter.next();
            }
            aIter.add(bIter.next());
        }
        System.out.println("在a中，间隔交叉得插入b中的元素:"+a);
        
        //在b中每两个元素删除后一个元素
        bIter=b.iterator();
        
        while(bIter.hasNext()){
            bIter.next();
            if(bIter.hasNext()){
                bIter.next();//remove跟next是成对出现的，remove总是删除前序
                bIter.remove();
            }
        }
        System.out.println("在b中每两个元素删除后一个元素:"+b);
        
        //删除a中所有的b中的元素
        a.removeAll(b);
        System.out.println("删除a中所有的b中的元素:"+a);

a集合：[a, b, c]
b集合：[d, e, f, g]
在a中，间隔交叉得插入b中的元素:[a, d, b, e, c, f, g]
在b中每两个元素删除后一个元素:[d, f]
删除a中所有的b中的元素:[a, b, e, c, g]

1.2 LinkedList

LinkedList<String> list = new LinkedList<String>();
		
		list.addFirst("aaaa"); //添加到最前 相当于add(0,obj);
		list.addLast("bbbb");//添加到最后。相当于add
		list.add(0,"dd");
		for(String str:list){
			System.out.println(str);
		}

dd
aaaa
bbbb

1.3 ArrayList 和LinkedList添加数据比较

		List<String> list = new ArrayList<String>();
		LinkedList<String> link = new LinkedList<String>();
		// 生产数据
		for (int i = 0; i < 100000; i++) {
			list.add("dfghdffdhghdfghdfghians" + i);
			link.add("dfghdffdhghdfghdfghians" + i);
		}
		// 标记开始时间
		long startlist = System.currentTimeMillis();
		// 在list中间插入数据
		for (int i = 0; i < 10000; i++) {
			list.add((9999 + i), "asdfasdfaasdf");
		}
		// 标记结束时间
		long endlist = System.currentTimeMillis();
		System.out.println("list time===" + (endlist - startlist));

		// 标记开始时间
		long startLink = System.currentTimeMillis();
		// 在link中间插入数据
		for (int i = 0; i < 10000; i++) {
			link.add((9999 + i), "asdfasdfaasdf");
		}
		// 标记结束时间
		long endLink = System.currentTimeMillis();
		System.out.println("link time-----" + (endLink - startLink));
		
		/**	某一次测试
		 *  5：	 	list time===437 link time-----78
		 *	5000:	list time===417 link time-----694 
		 *	9999：	list time===406 link time-----1406
		 * 结论：插入位置越靠前，linkList的插入速度越快！
		 * 原因分析：因为LinkedList在插入时需要向移动指针到指定节点， 才能开始插入,，一旦要插入的位置比较远，
		 * LinkedList就需要一步一步的移动指针， 直到移动到插入位置，这就解释了， 为什么节点值越大， 时间越长，
		 * 因为指针移动需要时间。
		 */

2 Set

2.1 HashSet

 Set<String> set=new HashSet<String>();
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("c");
        set.add("d");
        set.add(null);
        set.add(null);
        //使用Iterator输出集合
        Iterator<String> iter=set.iterator();
        while(iter.hasNext()){
            System.out.print(iter.next()+" ");
        }

主要的特点是：里面不能存放重复元素，而且采用散列的存储方法，所以没有顺序。这里所说的没有顺序是指：元素插入的顺序与输出的顺序不一致

null a b c d 

2.2 TreeSet

		// 整数集。默认是从小到大。
		TreeSet<Integer> set = new TreeSet<Integer>();
		set.add(10);
		set.add(6);
		set.add(6);
		set.add(19);
		set.add(2);

		// 增强for遍历
		for (Integer i : set) {
			System.out.print(i + "\t");
		}
		System.out.println();
		// 字符串集。默认是字典顺序
		TreeSet<String> set2 = new TreeSet<String>();
		set2.add("cc");
		set2.add("bddb");
		set2.add("a");
		set2.add("z");

		// 增强for遍历
		for (String s : set2) {
			System.out.print(s + "\t");
		}

2	6	10	19	
a	bddb	cc	z

2.3自定义比较器

// 自定义比较器类，实现整数按从高到低的比较规则
class MyIntegerComparator implements Comparator<Integer> {

	@Override
	public int compare(Integer o1, Integer o2) {
		if (o1 > o2) // 第1个数越大，返回-1，认为在set的序号越前面
			return -1;
		/*
		 * 如果比较方法不返回0，则说明元素不存在相等的情况，==>允许重复! else if(o1==o2) return 0;
		 */
		else
			return 1;
	}
}

class MyStringComparator implements Comparator<String> {
	@Override
	public int compare(String o1, String o2) {
		if (o1.length() > o2.length())
			return -1;
		else
			return 1;
	}
}

	TreeSet<Integer> set = new TreeSet<Integer>(new MyIntegerComparator());
		set.add(10);
		set.add(6);
		set.add(6);
		set.add(19);
		set.add(2);

		// 增强for遍历
		for (Integer i : set) {
			System.out.print(i + "\t");
		}
		System.out.println();
		// 字符串集。默认是字典顺序
		TreeSet<String> set2 = new TreeSet<String>(new MyStringComparator());
		set2.add("cc");
		set2.add("bddb");
		set2.add("a");
		set2.add("z");

		// 增强for遍历
		for (String s : set2) {
			System.out.print(s + "\t");
		}

19	10	6	6	2	
bddb	cc	a	z	

3 Map

3.1 HashMap

		//1 默认容积16
		HashMap<Integer,String> map = new HashMap<Integer, String>();
		//2 添加 。put()返回被替换的value，如果key不重复，返回null
		map.put(null,null);
		System.out.println(map.put(1, "白1"));//null
		System.out.println(map.put(2, "白2"));//mull
		System.out.println(map.put(3, "白3"));//null
		System.out.println(map.put(2, "白4")); //key重复，将2,白2替换掉。//返回2的value 白2
		//3 map的真实容积
		System.out.println(map.size());//4
		//4 !根据key获得value 
		String value = map.get(2);
		System.out.println("key为2的姓名:"+value);
		//5 删除.根据key删除映射对。返回删除对中的value
		map.remove(2);
		value = map.get(2);
		System.out.println("key为2的姓名:"+value);
		//map.isEmpty();
		//map.clear();
		//6 map的遍历
		//方法1：根据keyset()来遍历。
		//a 增强for写法
		Set<Integer> keyset = map.keySet(); //获取键集
		for(Integer k:keyset)
		{
			String v = map.get(k);//根据key获得value
			System.out.println(k+"--"+v);
		}
		System.out.println("=========================");
		//b 迭代器写法
		Iterator<Integer> it = keyset.iterator();
		while(it.hasNext())
		{
			Integer k = it.next(); //获得迭代器的下一个，即下一个key
			String v = map.get(k);//根据key获得value
			System.out.println(k+"--"+v);
		}
		System.out.println("=========================");
		//方法2：根据entrySet()来遍历。
		Set<Entry<Integer,String>> set = map.entrySet();
		//a 增强for
		for(Entry<Integer,String> e:set)
		{
			Integer k = e.getKey();  //从映射对中，直接获得key
			String v = e.getValue(); //从映射对中，直接获得value
			System.out.println(k+"--"+v);
		}
		System.out.println("=========================");
		//b 迭代器
		Iterator<Entry<Integer,String>> it2 = set.iterator();
		while(it2.hasNext())
		{
			Entry<Integer,String> e = it2.next();//迭代器的下一站就是映射对
			Integer k = e.getKey();  //从映射对中，直接获得key
			String v = e.getValue(); //从映射对中，直接获得value
			System.out.println(k+"--"+v);
		}	

null
null
null
白2
4
key为2的姓名:白4
key为2的姓名:null
null--null
1--白1
3--白3
=========================
null--null
1--白1
3--白3
=========================
null--null
1--白1
3--白3
=========================
null--null
1--白1
3--白3

3.2 HashTable

	Hashtable<String,String> table = new Hashtable<String, String>();
		table.put(null,"bbb");//key不允许为null 运行报空指针
		table.put("aaa", null);//value不允许null 运行报空指针
		table.size();

3.3 TreeMap

4 Collections

//自定义比较器类，实现整数按从高到低的比较规则
class MyIntegerComparator implements Comparator<Integer>{

	@Override
	public int compare(Integer o1, Integer o2) {
		if(o1>o2) //第1个数越大，返回-1，认为在set的序号越前面
			return -1;
		/*  如果比较方法不返回0，则说明元素不存在相等的情况，==>允许重复!*/
		
		else if(o1==o2) //给treemap传比较器，必须返回0的分支
			return 0;			
		else
			return 1;
	}	
}

	ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(10);
		list.add(8);
		list.add(9);
		list.add(5);
		list.add(6);
		ArrayList<Integer> list2 = new ArrayList<Integer>();
		list2.add(1);
		list2.add(1);
		list2.add(2);
		list2.add(1);
		list2.add(1);
		list2.add(1);
		//1 拷贝
		Collections.copy(list2,list);
		System.out.println("list2拷贝list中的元素后："+list2);
		//2 倒序
		Collections.reverse(list);
		System.out.println("list倒叙后："+list);
		//3 打乱
		Collections.shuffle(list);
		System.out.println("list打乱后："+list);
		//4 查找
		System.out.println("查找结果:"+Collections.binarySearch(list2, 8));//未排序前返回的都是-1，只有排序后才能正确返回元素对应的索引
		//5 排序
		Collections.sort(list2); //归并排序法
		System.out.println("排序后："+list2);
		//按自定义规则，归并排序法
		Collections.sort(list2,new MyIntegerComparator()); 
		System.out.println("自定义排序规则的排序后："+list2);

list2拷贝list中的元素后：[10, 8, 9, 5, 6, 1]
list倒叙后：[6, 5, 9, 8, 10]
list打乱后：[5, 10, 8, 6, 9]
查找结果:-1
排序后：[1, 5, 6, 8, 9, 10]
自定义排序规则的排序后：[10, 9, 8, 6, 5, 1]