JAVA基础知识点17-容器、List接口、ArrayList、Vector 向量 与 ArrayList 区别、LinkedList

数组的特点:
    定长
    类型一致
    存储多个数据
    索引,根据索引操作数组效率高
    引用数据类型

 容器体系: 系列的容器类
    可变长,操作灵活
    任意类型的数据
    只能存储引用数据类型

public class CollectionDemo02 {
    public static void main(String[] args) {
        //容器对象
        //多态 col能够调用的方法为Collection接口中存在的内容
        Collection col = new ArrayList();
        Collection col2 = new ArrayList();

        //boolean add(E e)  添加
        col.add("zhangsan");
        col.add(123);
        col.add(false);

        col2.add('a');
        col2.add('b');
        col2.add('c');

        System.out.println(col);
        //boolean addAll(Collection<? extends E> c)
        System.out.println(col.addAll(col2));;
        System.out.println(col);
        System.out.println(col2);

        //void clear() 从此集合中删除所有元素（可选操作）。
        //col2.clear();
        System.out.println(col2);

        //boolean isEmpty() 如果此集合不包含任何元素，则返回 true 。
        System.out.println(col2.isEmpty());

        //boolean contains(Object o) 如果此collection包含指定的元素，则返回 true 。
        System.out.println(col.contains("zhangsan"));

        col2.add('d');

        //boolean containsAll(Collection<?> c) 如果此集合包含指定集合中的所有元素，则返回 true 。
        System.out.println(col.containsAll(col2));

        /*
        boolean remove(Object o) 从此集合中移除指定元素的单个实例（如果存在）（可选操作）。
        boolean removeAll(Collection<?> c) 删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。  删除交集
         */
        //System.out.println("删除单个数据:"+col.remove("zhangsan"));

        //System.out.println(col);
        //System.out.println("删除多个数据:"+col.removeAll(col2));
        System.out.println(col);
        System.out.println(col2);

        //boolean retainAll(Collection<?> c) 仅保留此集合中包含在指定集合中的元素（可选操作）。
        System.out.println(col.retainAll(col2));
        System.out.println(col);
        System.out.println(col2);

        System.out.println(col.size());

        //Object[] toArray() 返回包含此集合中所有元素的数组。
        System.out.println(Arrays.toString(col2.toArray()));
        System.out.println(col2.toArray()[0]);

        System.out.println("--------------foreach-------------------");
        for(Object obj:col2){
            System.out.println(obj);
        }

        System.out.println("--------------iterator-------------------");
        //Iterator<E> iterator() 返回此集合中元素的迭代器。
        //1.获取操作某一个集合迭代器
        Iterator it = col2.iterator();
        //2.hashNext() 是否存在下一个元素
        while(it.hasNext()){
            //3.获取下一个元素next()
            System.out.println(it.next());
        }


    }
}

List 接口 : 有序可重复
    新增功能: 一些根据索引操作的方法  of(..)创建集合的同时添加数据,集合不可变  subList()
    遍历方式
        foreach
        iterator迭代器
        for
        列表迭代器 ListIterator

public class ListDemo03 {
    public static void main(String[] args) {
        //创建集合,可以添加任意数据
        //泛型: 规范存储数据的数据类型 <引用数据类型>
        //泛型可以提高代码的可读性,稳定性,帮助检查存储数据的类型
        //引用类型的泛型不能省略
        List<Integer> list = new ArrayList<>();

        list.add(1);
        list.add(0);
        list.add(3);
        list.add(2);
        list.add(5);
        list.add(0);

        list.add(4,10);

        System.out.println(list);

        //当集合中存储的数据也为整数时候,默认以索引为主,没有抛出异常
        list.remove(2);
        //list.remove(10);
        System.out.println(list);

        //int indexOf(Object o)
        System.out.println(list.indexOf(0));

        //static <E> List<E> of(...)   返回包含指定元素的不可修改的列表(数据值,数据个数..)
        System.out.println(List.of());
        List<String> ls = List.of("a","b","c");
        //ls.add("d");  //不可修改
        //ls.remove("a");  //不可修改
        //E set(int index, E element) 用指定的元素替换此列表中指定位置的元素（可选操作）。
        //ls.set(1,"bbb");
        System.out.println(ls.indexOf("a"));
        System.out.println(ls);

        //List<E> subList(int fromIndex, int toIndex) 返回指定的 fromIndex （包含）和 toIndex （不包括）之间的此列表部分的视图。
        List<Integer> list2 = list.subList(1,5);
        System.out.println(list2);

        System.out.println("------------foreach----------------");
        for(String s:ls){
            System.out.println(s);
        }

        System.out.println("------------for----------------");
        //i作为集合的索引
        for(int i=0;i<= ls.size()-1;i++){
            System.out.println(ls.get(i));
        }

        System.out.println("------------iterator----------------");
        //1.获取操作这个集合的迭代器
        Iterator<String> it = ls.iterator();
        //2.判断是否存在下一个元素
        while(it.hasNext()){
            String str = it.next();  //因为存在泛型,素有可以使用String类型接收
            System.out.println(str);
        }
    }
}

 

List接口的实现类
     有序  可重复  都可以根据索引进行操作

 ArrayList
     底层数据结构: 数组|可变数组 (数组:内存中一段连续的内存空间)  (Object[] elementData)
     优点 : 查询,遍历效率高(根据索引)
     缺点 : 添加,删除数据效率较低,创建新数组,数据拷贝
     应用场景 : 大量做查询的时候,少量做修改的时候,适合使用ArrayList存储数据
     使用:
         构造器:
             ArrayList() 构造一个初始容量为10的空列表。  ***  ->不确定集合中存储多少数据,使用
             ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。 ->当确定集合中存储数据的个数范围的时候,可以选择使用
             ArrayList(Collection<? extends E> c) 按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。

         方法:操作内容,根据索引进行操作
     遍历:
     扩容:
         根据空构造构建ArrayList,初始默认空数组,第一次添加数据默认容量为10,存不下了才扩容,每次扩容原容量的1.5倍(int newCapacity = oldCapacity + (oldCapacity >> 1);)
         通过Arrays.copyOf方法扩容
     注意: ArrayList中可以添加null值

Vector 向量 与 ArrayList 区别
     共同点: 底层结构也是数组,特点一样
     不同定:
         1)Vector线程安全,ArrayList线程不安全
         2)扩容:Vector每次扩容原容量的2倍  而ArrayList是1.5倍,所以ArrayList更有利于节省内存

List 接口的实现类
LinkedList 有序可重复
    底层: 双向链表结构
    优点:
        增删效率高
    缺点:
        查询效率低
    应用场景:
        大量做增删,少量做查询,适合使用LinkedList
    构造器:
        LinkedList() 构造一个空列表。
        LinkedList(Collection<? extends E> c) 按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。

    方法: 新增了一些操作链表头尾的方法