Java(List集合的子类)

List集合的子类

一、ArrayList集合（实现类）

1、特点

1、底层数据结构是：数组（元素增删慢，查找快）；
2、此实现不是同步的（多线程）、线程不安全；
3、ArrayList使用无参构造函数创建对象时，Object数组默认的容量时10，当长度不够时，会增长0.5倍；

2、创建对象格式

ArrayList<?> arrayList = new ArrayList<>();或者
Collection<?> c  = new ArrayList<>();//多态

3、ArrayList为什么是长度不可变的？

ArrayList 底层是通过数组实现的，数组在创建的时候必须要指定其大小，那么基于数组实现无法直接达到长度可变。

4、ArrayList 是如何达到长度可变的？

ArrayList 通过创建一个大于现有数组长度的数组，并将原数组数据按顺序拷贝到新数组变相完成长度可变的。

5、遍历操作

toArray():数组遍历
iterator()：迭代器遍历
foreach()：增强for循环，底层是迭代器
listIterator()：列表迭代
listIterator(index)：从指定位置列表迭代
for() size()和get()

6、去重复操作

1、新建一个新的集合
        遍历老的集合，
        如果新的集合里面包含有这个老的集合元素，
        就把老集合的元素添加到新的集合
2、冒泡排序、快速排序等数据结构方法去重

例题

 public static void main(String[] args) {
            //创建集合对象
            List li = new ArrayList();
            //创建员工对象
            Employee emp0 = new Employee(2021, "张三", 18, 9000);
            Employee emp1 = new Employee(2022, "李四", 18, 9000);
            Employee emp2 = new Employee(2022, "李四", 18, 9000);
            Employee emp3 = new Employee(2022, "王五", 18, 9000);
            Employee emp4 = new Employee(2022, "李四", 21, 9000);
            //把Employee对象添加到list集合
            li.add(emp0);
            li.add(emp1);
            li.add(emp2);
            li.add(emp3);
            li.add(emp4);
            //2.要求员工不能够存储重复元素 [2种方法]
    //        //第一种
    //        //先创建新集合
    //        List newList = new ArrayList();
    //        //遍历老集合
    //        for (Object obj : li) {
    //            if (!newList.contains(obj)) {//如果新集合里面不包括老集合的元素，则添加
    //                newList.add(obj);
    //            }
    //        }
    ////把新集合赋值给老集合
    //        li = newList;
    ////遍历输出
    //        for (Object obj : li) {
    //            System.out.println(obj);
    //        }

            System.out.println("--------------------");
            //第二种：选择排序算法：第一个元素依次和后面的元素进行比较
            for (int i = 0; i < li.size(); i++) {
                for (int j = i+1; j <li.size() ; j++) {
                    if(li.get(i).equals(li.get(j))){
                        li.remove(j);
                        j--;
                    }
                }
            }
            for (Object obj:li) {
                System.out.println(obj);
            }

            //4.要求使用至少四种方式遍历员工对象
            System.out.println("----------1------------");
            //第一种
            //Collection toArray
            Object[] objs = li.toArray();
            for (Object obj: objs) {
                System.out.println(obj);
            }
            System.out.println("----------2-------------------");
            //第二种 迭代器
            Iterator iterator = li.iterator();
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
            System.out.println("------------3----------------");
            //foreach
            for (Object obj: li) {
                System.out.println(obj);
            }
            System.out.println("---------------4----------------");
    //for循环
            for (Iterator it  = li.iterator();it.hasNext(); System.out.println(it.next()) );
            System.out.println("------------5--------------");
    //list遍历：列表迭代器
            ListIterator listIterator = li.listIterator();
    //先正向遍历后才能逆向遍历
            while (listIterator.hasNext()){
                System.out.println(listIterator.next());
            }

            System.out.println("----------------6--------------");
            while (listIterator.hasPrevious()){
                System.out.println(listIterator.previous());
            }
        }

7、常用方法

//添加
        // boolean add(E e) 将指定的元素添加到此列表的尾部。
        // void add(int index, E element) 将指定的元素插入此列表中的指定位置。

        //boolean addAll(Collection<? extends E> c) 按照指定集合的迭代器所返回的元素顺序，将该集合中的所有元素添加到此列表的尾部。
        //boolean addAll(int index, Collection<? extends E> c)从指定的位置开始，将指定集合中的所有元素插入到此列表中。

//移除
        //void clear() 移除此列表中的所有元素。

        //E remove(int index) 移除此列表中指定位置上的元素。
        //boolean remove(Object o) 移除此列表中首次出现的指定元素（如果存在）。
        //protected  void removeRange(int fromIndex, int toIndex) 移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。

//判断
        //boolean contains(Object o) 如果此列表中包含指定的元素，则返回 true。
        //boolean isEmpty() 如果此列表中没有元素，则返回 true

//获取
        // E get(int index) 返回此列表中指定位置上的元素。

        //int indexOf(Object o) 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。

        // int size() 返回此列表的长度

//替换
        //E set(int index, E element) 用指定的元素替代此列表中指定位置上的元素。

//数组
        //Object[] toArray() 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。

二、LinkedList集合（实现类）

特点：

1、底层数据结构是：链表
2、具有堆栈、队列或双端队列的操作。
3、有list集合特点和双端队列的特点
4、插入和删除效率高，查询和修改效率低
5、线程不安全
6、存储有序
7、可以存储null值
8、元素允许重复
9、可以通过索引操作节点
注意：使用LinkedList集合特有的方法，不能使用多态

创建对象格式

LinkedList<?> linkedList = new LinkedList<>();

特有方法

List集合的方法都有，下面介绍一下LinkedList的特有方法

//添加
       //void addFirst(E e) 将指定元素插入此列表的开头。
        // void addLast(E e) 将指定元素添加到此列表的结尾。

        //boolean offerFirst(E e) 在此列表的开头插入指定的元素。
        //boolean offerLast(E e) 在此列表末尾插入指定的元素。

        //void push(E e) 将元素推入此列表所表示的堆栈。

//移除
        //E removeFirst() 移除并返回此列表的第一个元素。
        //E removeLast() 移除并返回此列表的最后一个元素。相当于remove()

        //E pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
        //E pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

        //E pop() 从此列表所表示的堆栈处弹出第一个元素。相当于removeFirst()

// 获取
        // E getFirst() 返回此列表的第一个元素。
        //E getLast() 返回此列表的最后一个元素。

        //E peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
        //E peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

三、Vector集合（实现类）

特点

1、底层数据结构是：数组（有索引、查询快、增删慢）
2、线程安全（单线程）

特有方法

// Enumeration<E> elements() 返回此向量的组件的枚举。相当于迭代器iterator().hasNext()
//E elementAt(int index) 返回指定索引处的组件。 相当于迭代器iterator().Next()