Java基础笔记：Collection集合框架

Collection框架

Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。
List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。
List接口的主要实现类有java.util.ArrayList，java.util.LinkedList以及java.util.Vector。
Set接口的主要实现类有java.util.HashSet，java.util.TreeSet以及java.util.LinkedHashSet。

extends

extends

implements

implements

implements

implements

implements

extends

Collection

List

Set

ArrayList

LinkedList

Vector

HashSet

TreeSet

LinkedHashSet

Collection接口定义的方法

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。

@Test
    public void collection_Test() {
        //他的实现类ArrayList，LinkedList，Vector，HashSet，LinkedHashSet，TreeSet都可以使用
        Collection<Integer> ints = new ArrayList<Integer>();
        //添加元素
        for (int i = 1; i < 11; i++) { ints.add(i); }
        //删除指定元素
        ints.remove(2);
        //查看是否存在指定元素
        System.out.println(ints.contains(7));//OUTPUT：true
        //判断是否为空
        System.out.println(ints.isEmpty());//OUTPUT：false
        //返回集合中元素个数
        System.out.println(ints.size());//OUTPUT：10
        //将集合转换为数组并返回
        Object[] objects = ints.toArray();
        //清空集合
        ints.clear();
    }

遍历集合的方法：Iterator迭代器

/**
     * 迭代器：JDK专门提供了一个接口java.util.Iterator用来对集合进行遍历
     * 可以使用Collection.iterator()获取Iterator接口实现类
     * 除了使用Iterator接口实现类还需要借助Iterator接口中的方法
     * hasNext()：判断下一个元素是否存在
     * next()：取出并返回下一个元素
     * 迭代器的原理：在取元素之前先判断集合下一个位置中有没有元素，如果有就指针下移把元素取出来，再继续判断
     *              一直将所有元素全部取出，直到判断集合中没有元素。
     *              遍历结束后指针会停留在集合末尾位置，想要实现再次遍历就必须再次声明一个迭代器
     */
    @Test
    public void iterator_Test(){
        Collection<Integer> arrayList = new ArrayList();
        for (int i = 1; i < 11; i++) { arrayList.add(i); }
        //获取Iterator接口实现类
        Iterator iterator = arrayList.iterator();
        //结合hasNext()和next()实现遍历
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println(arrayList.size());
    }

遍历集合的方法： foreach（增强for）

/**
     * 增强for循环
     * 底层的实现方法还是利用了迭代器，利用for循环的格式简化了迭代器的书写，是JDK1.5之后出现的新特性
     * 增强for循环可以遍历集合或者是数组
     */
    @Test
    public void foreach_Test(){
        Collection<Integer> arrayList = new ArrayList();
        for (int i = 1; i < 11; i++) { arrayList.add(i); }
        //使用增强for循环遍历集合
        for(int i : arrayList){
            System.out.println(i);
        }
    }

继承Collection下的List接口实现类：ArrayList

/**
     * Collection接口的子接口ArrayList接口
     * 特点：
     * 1、有序的集合，存储元素和取出元素的顺序是一致的
     * 2、有索引，包含了一些带索引的方法
     * 3、允许存储重复的元素
     * List除了继承了Collection定义的方法外，还额外定义其特有的方法
     * add()：将指定的元素，添加到集合中指定的位置上
     * get()：返回集合中指定位置的元素
     * remove():移除并返回指定位置上的元素
     * set()：指定一个元素替换指定位置上的元素，并返回更新前的元素
     */
    @Test
    public void ArrayList_Test(){
        ArrayList list = new ArrayList();
        //添加元素
        for (int i = 1; i < 11; i++) { list.add(i); }
        //向指定位置上添加元素
        list.add(10,11);
        //返回指定位置上的元素
        System.out.println(list.get(0));//OUTPUT:1
        //删除指定位置上的元素
        System.out.println(list.remove(9));//OUTPUT:10
        //设置指定位置上的元素
        System.out.println(list.set(9, 10));//OUTPUT:11
    }

继承Collection下的List接口实现类：LinkedList

/**
     *  List接口实现类LinkedList
     *  特点：
     *  1、底层是双向链表结构，查询慢增删快
     *  2、实现类额外定义了大量操作首尾元素的方法
     */
    @Test
    public void linkedList(){
        LinkedList linkedList = new LinkedList();
        for (int i = 1; i < 11; i++) { linkedList.add(i); }
        //将元素插入列表开头
        linkedList.addFirst(0);
        //将元素插入列表末尾
        linkedList.addLast(11);
        //将元素添加至列表开头，实现功能和addFirst一致
        linkedList.push("First");
        //获取开头元素
        linkedList.getFirst();
        //获取末尾元素
        linkedList.getLast();
        //删除开头元素
        linkedList.removeFirst();
        //删除末尾元素
        linkedList.removeLast();
        //弹出末尾元素，实现功能和removeLast一致
        linkedList.pop();
        //判断集合是否存在元素
        linkedList.isEmpty();
    }

继承Collection下的List接口实现类：Vector

List接口的古老实现类JDK1.0，时就已经存在
源码底层方法几乎都被synchronized修饰保证线程安全但效率低下，使用场景较少
截取部分源码↓↓↓↓

List接口实现类HasSet

在JDK1.8之前，底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。 但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。
而JDK1.8中，存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找 时间。 简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的。

Collections操作集合的工具类

/**
     *  Collections操作集合的工具类
     */
    @Test
    public void collections_Test(){
        //添加多个元素
        ArrayList arrayList = new ArrayList();
        Collections.addAll(arrayList,1,2,3,4,5,6,7,8);
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next());
        }
        System.out.println("\n------------");
        //打乱集合的元素顺序
        Collections.shuffle(arrayList);
        Iterator iterator1 = arrayList.iterator();
        while (iterator1.hasNext()){
            System.out.print(iterator1.next());
        }
        System.out.println("\n------------");
        //排序
        Collections.sort(arrayList);//默认是升序
        Iterator iterator2 = arrayList.iterator();
        while (iterator2.hasNext()){
            System.out.print(iterator2.next());
        }
        System.out.println("\n------------");
        Collections.sort(arrayList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;//降序
//                return o2-o1;//升序
            }
        });
        Iterator iterator3 = arrayList.iterator();
        while (iterator3.hasNext()){
            System.out.print(iterator3.next());
        }
        System.out.println("\n------------");

        //在对自定义类进行排序时必须保证类实现了comparable接口并重写了其中的compareTo()抽象方法,自定义比较方法
        //或者直接使用匿名实现Comparator接口的compare方法
        ArrayList arrayList1 = new ArrayList();
        Collections.addAll(arrayList1,new Ponse("小王",12),new Ponse("小李",17),new Ponse("小刘",11));
        Collections.sort(arrayList1, new Comparator<Ponse>() {
            @Override
            public int compare(Ponse o1, Ponse o2) {
                return o2.getAge()-o1.getAge();
            }
        });
        Iterator iterator4 = arrayList1.iterator();
        while (iterator4.hasNext()){
            System.out.print(iterator4.next());
        }
        System.out.println("\n------------");
    }