Java学习笔记14-容器—List接口

1.List接口

特点：可以存放很多数据，List中的数据可以重复，数据是有序的， 存放的顺序与内部真实存储的顺序相同，添加了null元素

新增方法：根据索引操作数据的方法

List容器的特点：泛型: 规定集合存储数据的类型 | 规定数据的类型

                            表示 : <数据类型> 数据类型只能为引用数据类型

                            位置 : 定义在数据类型的后面

                            优点 : 帮助增强程序的稳定性与可读性

//实例代码-List容器与新增方法（用ArrayList实现类实现）
public class Class001_List {
    public static void main(String[] args) {
        //List容器
        List<String> list = new ArrayList();
        //List<Integer> list2 = new ArrayList();
        list.add(null);
        list.add(null);
        list.add("abc");
        list.add("cde");
        list.add("mnb");
        System.out.println(list);
        //新增方法
        //void add(int index, E element) 将指定元素插入此列表中的指定位置（可选操作）。
        list.add(1,"你好");
        System.out.println(list);

        //E get(int index) 返回此列表中指定位置的元素。
        System.out.println(list.get(3));;

        //int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
        //int lastIndexOf(Object o) 返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
        System.out.println(list.lastIndexOf(null));

        //static <E> List<E> of(E... elements) 返回包含任意数量元素的不可修改列表。
        List<Integer> list1 = List.of(1,2,3,4,5);
        System.out.println(list1);

        //E remove(int index) 删除此列表中指定位置的元素（可选操作）。
        System.out.println(list.remove(2));
        System.out.println(list);
        //E set(int index, E element) 用指定的元素替换此列表中指定位置的元素（可选操作）。
        System.out.println(list.set(4,"nb"));
        System.out.println(list);
        //List<E> subList(int fromIndex, int toIndex) 返回指定的 fromIndex （包含）和 toIndex （不包括）之间的此列表部分的视图。
        System.out.println(list.subList(1,3));
        System.out.println(list);
        //Object[] toArray()
        System.out.println(Arrays.toString(list.toArray()));

    }
}

2.List的遍历

（1）List集合遍历方式: 1.普通for循环

                              2.增强for循环

                              3.iterator迭代器

                              4.listIterator 列表迭代器

（2）迭代器(Iterator)

        实现Collection接口的容器类都有一个 iterator 方法用以返回一个实现了Iterator接口的对 象。

Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作。

Iterator接口定义了如下方法：

•  boolean hasNext(); //判断是否有元素没有被遍历
•  Object next(); //返回游标当前位置的元素并将游标移动到下一个位置        
•  void remove(); //删除游标左面的元素，在执行完next之后该 ,操作只能执行一次

//实例代码-定义: 一个list集合,存储你喜欢的漫威英雄人物
//         如果包含灭霸,就向集合中添加一个惊奇队长
public class Class003_List {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("钢铁侠");
        list.add("美国队长");
        list.add("黑寡妇");
        list.add("灭霸");
        list.add("毒液");
        System.out.println(list);
        //1. contains
        /*if(list.contains("灭霸")){
            list.add("惊奇队长");
        }
        System.out.println(list);*/

        //2.普通for
       /* for(int i=0;i<list.size();i++){
            if("灭霸".equals(list.get(i))){
                list.add("惊奇队长");
            }
        }
        System.out.println(list);*/

        //3.foreach（增强for循环）
        //ConcurrentModificationException 当不允许这样的修改时，检测到对象的并发修改的方法可能抛出此异常。
      /*  for(String str : list){
            if("灭霸".equals(str)){
                list.add("惊奇队长");
            }
        }
        System.out.println(list);*/

        //4.迭代器 iterator
        /*for(Iterator<String> it =  list.iterator();it.hasNext();){
            if("灭霸".equals( it.next())){
                list.add("惊奇队长");
            }
        }
        System.out.println(list);*/

        //5.列表迭代器
        //1)获取列表迭代器对象
      /*  ListIterator<String> it2 =  list.listIterator();
        //2)判断是否存在下一个|上一个元素
        //正向遍历
        while(it2.hasNext()){
            //3)获取上一个或者下一个元素 | 操作集合
            System.out.println(it2.nextIndex());
            System.out.println(it2.next());
            *//*if("灭霸".equals( it2.next())){
                it2.add("惊奇队长");
            }*//*
        }
        System.out.println(list);*/

        //反向遍历
        ListIterator<String> it3 = list.listIterator(4);
        while(it3.hasPrevious()){
            System.out.println(it3.previousIndex()+"-->"+it3.previous());
        }
    }
}

 3.List接口的实现类

（1）ArrayList

                底层实现：可变数组

                特点：根据索引做查询效率高

                            增删效率低，设计到新数组的创建，数据的拷贝等问题

                 应用场景：大量做查询，少量做增删的时候适用ArrayList

                 扩容：int newCapacity = oldCapacity + (oldCapacity >> 1); 通过Arrays.copyOf方法实现扩容,每次扩容原容量的1.5倍。（初始容量为10）

新增内容: void forEach(Consumer<? super E> action) 对 Iterable每个元素执行给定操作，直到处理 Iterable所有元素或操作引发异常。

遍历方式：1.普通for 2.增强for 3.iterator迭代器 4.listIterator迭代器

//实例代码-List接口的实现类ArrayList
public class Class004_List{
    public static void main(String[] args) {
        //ArrayList() 构造一个初始容量为10的空列表。
        //多态的形势
        List<String> list = new ArrayList<>();
        //ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
        //ArrayList(Collection<? extends E> c) 按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。
        //添加
        list.add("haha");
        list.add("hehe");
        System.out.println(list);
        //遍历输出每一个元素
        list.forEach(System.out::println);

    }
}

(2)Vector 向量(了解)

Vector与 ArrayList之间的区别:
    1.同步问题
        ArrayList 线程不安全|不同步,相对效率高
        Vector    线程安全|同步
    2.扩容问题
        ArrayList 每次扩容原容量的1.5倍,更有利于节约内存
        Vector    每次扩容原容量的2倍）

（3）LinkedList          

                底层结构: 双向链表

                特点: 根据索引查询效率低 做增删效率高

                应用场景: 大量做增删少量做查询的时候适合使用

                新增功能: 新增了一些可以直接操作头尾的方法

//实例代码-List接口实现类 LinkedList
public class Class005_LinkedList {
    public static void main(String[] args) {
        //链表结构
        LinkedList<Double> linked = new LinkedList<>();
        linked.add(1.1);
        linked.add(2.1);
        linked.add(3.1);
        linked.add(4.1);
        System.out.println(linked);
        //在首位添加元素
        linked.addFirst(0.1);
        //在末尾添加元素
        linked.addLast(5.1);
        System.out.println(linked);
        //移除首位的元素
        System.out.println(linked.removeFirst());
        System.out.println(linked);
    }
}