Java高级--集合

集合的概念

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

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

集合接口分为：Collection和Map，list、set

集合是一个动态的数组，数组的长度是不可变的，集合长度是可变的

集合中的类型

类关系图

集合中常用集合类的继承关系

Collection接口

Collection表示一组对象，这些对象也被称为Collection的元素。一些Collection允许有重复的元素（例如List），但是另一些则不允许有重复的元素，即可为无序的（如Set）。

List集合

List集合特点

元素有序
每一个元素都存在一个索引
元素可以重复

Map集合

Map集合特点

元素无序
元素通过键值对的方式进行存储
键不可重复，值可以重复

Map集合概述

（1）Map是一个存储键值对元素的集合。
（2）将键映射到值的对象。一个映射不能包含重复的键，每个键最多只能映射到一个值。
（3）Map集合和Collection集合的区别：
Map集合存储的元素是成对出现的（键值对）。MAP集合的键是唯一的，值是可重复的。
Collection集合存储的元素是单独出现的。Collection集合的儿子Set是唯一的，List是可重复的。
Map集合的数据结构只针对键有效，跟值无关。
Collection集合的数据结构是针对元素有效

Set集合

Set集合特点

元素无序
元素是通过连表进行存储的
元素不可重复

ArrayList集合概述

集合只能存储引用数据类型
ArrayList是顺序结构
特点：查询快，增删慢、线程不安全，效率高

ArrayList案例

// 创建ArrayList
         ArrayList list = new ArrayList();
         //.add方法在最末尾添加元素
         list.add("1");
         list.add("2");
         list.add("3");
         list.add("4");
         // 将下面的元素添加到第1个（索引为0）位置
         list.add(0, "5"); 
         // 获取第1个元素
         System.out.println("the first element is: "+ list.get(0));
         // 删除“3”
         list.remove("3");
         // 获取ArrayList的大小
         System.out.println("Arraylist size=: "+ list.size());
         // 判断list中是否包含"3"
         System.out.println("ArrayList contains 3 is: "+                              	list.contains(3));
         // 设置第2个元素为10
         list.set(1, "10");
         // 通过Iterator遍历ArrayList
         for(Iterator iter = list.iterator(); iter.hasNext(); ) {
             System.out.println("next is: "+ iter.next());
         } 

LinkedList概述

LinkedList底层数据结构是链表
特点查询慢，增删快，线程不安全，效率高

LinkedList案例

LinkedList llist = new LinkedList();
        //---- 添加操作 ----
        // 依次添加1,2,3
        llist.add("1");
        llist.add("2");
        llist.add("3");
        // 将“4”添加到第一个位置
        llist.add(1, "4");
 // 删除“栈顶元素”
        System.out.println("llist .pop():"+llist .pop());
        // 取出“栈顶元素”
        System.out.println("llist .peek():"+llist .peek());
        // 打印“栈”
        System.out.println("llist :"+stack);
   // 删除(队列的第一个元素)
        System.out.println("llist.remove():"+llist.remove());
        // 读取(队列的第一个元素)
        System.out.println("llist.element():"+llist.element());
        // 打印“队列”
        System.out.println("llist:"+llist);
 // 输出大小
        System.out.println("size:"+llist.size());

HashMap集合概述

1、HashMap是可以序列化的。是线程不安全的。
2、HashMap的底层主要是基于数组和链表实现的，它之所以有相当快的查询速度主要是因为它是通过计算散列码来决定存储位置的。
3、HashMap中主要是通过key的hashCode来计算hash值

HashMap案例

 // 初始化随机种子
        Random r = new Random();
        // 新建HashMap
        HashMap map = new HashMap();
        // 添加操作
        map.put("one", r.nextInt(10));
        map.put("two", r.nextInt(10));
        map.put("three", r.nextInt(10));
        // 打印出map
        System.out.println("map:"+map );
        // 通过Iterator遍历key-value
        Iterator iter = map.entrySet().iterator();
        while(iter.hasNext()) {
            Map.Entry entry = (Map.Entry)iter.next();
            System.out.println("next : "+ entry.getKey()                                                                                                  	+" - "+entry.getValue());
        }
	// HashMap的键值对个数        
        System.out.println("size:"+map.size());
        // containsKey(Object key) :是否包含键key
        System.out.println("contains key two : 	"+map.containsKey("two"));
        System.out.println("contains key five : 	"+map.containsKey("five"));
        // containsValue(Object value) :是否包含值value
        System.out.println("contains value 0 : 	"+map.containsValue(new Integer(0)));
        // remove(Object key) ： 删除键key对应的键值对
        map.remove("three");
        System.out.println("map:"+map );

增强for循环

增强for概述
简化数组和Collection集合的遍历
格式：
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
在使用增强for循环的时候要注意判空

for (Integer i : list) {
   System.out.print(i + ",");
}

TreeMap概述

TreeMap是基于红黑树实现的。
集合中的映射关系是具有一定顺序的，该映射根据其键的自然顺序进行排序或者根据创建映射时提供的Comparator进行排序
TreeMap中不允许键对象是null。

TreeMap案例

 // 新建TreeMap
        TreeMap tmap = new TreeMap();
        // 添加“键值对”
        tmap.put("a", 101);
        tmap.put("b", 102);
        tmap.put("c", 103);
        tmap.put("d", 104);
        tmap.put("e", 105);
       System.out.printf("tmap.headMap(\"c\"):\n\t%s\n", tmap.headMap("c"));
       System.out.printf("tmap.tailMap(\"c\"):\n\t%s\n", tmap.tailMap("c"));
       System.out.printf("tmap.subMap(\"a\", \"c\"):\n\t%s\n", tmap.subMap("a", "c"));

HashSet集合概述

HashSet线程不安全，效率高，允许存储null元素，元素无序且唯一
HashSet元素唯一

案例

  // 新建HashSet
        HashSet set = new HashSet();
        // 将元素添加到Set中
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        set.add("e");
        // 打印HashSet的实际大小
        System.out.printf("size : %d\n", set.size());
        // 判断HashSet是否包含某个值
        System.out.printf("HashSet contains a :%s\n", set.contains("a"));
        System.out.printf("HashSet contains g :%s\n", set.contains("g"));
        // 删除HashSet中的“e”
        set.remove("e");

TreeSet概述

TreeSet 集合继承于AbstractSet，所以它是一个Set集合，具有Set的属性和方法。 
TreeSet基于TreeMap实现的
底层的数据结构是红黑树（平衡二叉树）。

String val;
        // 新建TreeSet
        TreeSet tSet = new TreeSet();
        // 将元素添加到TreeSet中
        tSet.add("aaa");
        // Set中不允许重复元素
        tSet.add("aaa");
        tSet.add("bbb");
        tSet.add("eee");
        tSet.add("ddd");
        tSet.add("ccc");
        System.out.println("TreeSet:"+tSet);
        // 打印TreeSet的实际大小
        System.out.printf("size : %d\n", tSet.size());
            
// 导航方法
         // lower(小于)
        System.out.printf("lower bbb: %s\n", tSet.lower("bbb"));
        // ceiling(大于)
        System.out.printf("higher bbb: %s\n", tSet.higher("bbb"));
         // headSet()
        System.out.printf("headSet(ccc, true): %s\n", tSet.headSet("ccc", 	true));
        System.out.printf("headSet(ccc, false): %s\n", 	tSet.headSet("ccc", false));
        // tailSet()
        System.out.printf("tailSet(ccc, true): %s\n", tSet.tailSet("ccc", 	true));
        System.out.printf("tailSet(ccc, false): %s\n", tSet.tailSet("ccc", 	false));
        // 删除“ccc”
        tSet.remove("ccc");

泛型概述

泛型就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，然后在使用/调用时传入具体的类型

 List<对象> list = new ArrayList<对象>();
         list.add(对象);
         list.add(对象);