Java基础笔记:Collection集合框架

Collection框架

Collection:单列集合类的根接口,用于存储一系列符合某种规则的元素,它有两个重要的子接口,分别是java.util.Listjava.util.Set
List的特点是元素有序、元素可重复Set的特点是元素无序,而且不可重复
List接口的主要实现类有java.util.ArrayListjava.util.LinkedList以及java.util.Vector
Set接口的主要实现类有java.util.HashSetjava.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修饰保证线程安全但效率低下,使用场景较少
截取部分源码↓↓↓↓
Java基础笔记:Collection集合框架_第1张图片

List接口实现类HasSet

在JDK1.8之前,底层采用数组+链表实现,即使用链表处理冲突,同一hash值的链表都存储在一个链表里。 但是当位于一个桶中的元素较多,即hash值相等的元素较多时,通过key值依次查找的效率较低。
而JDK1.8中,存储采用数组+链表+红黑树实现,当链表长度超过阈值(8)时,将链表转换为红黑树,这样大大减少了查找 时间。 简单的来说,哈希表是由数组+链表+红黑树(JDK1.8增加了红黑树部分)实现的。
Java基础笔记:Collection集合框架_第2张图片

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------------");
    }

你可能感兴趣的:(Java基础笔记)