List集合

List集合

List集合是一个有序且元素可以重复的集合，List是一个接口，直接父接口是Collection

其中常用的接口有：ArrayList和LinkedList接口

ArrayList与LinkedList的区别：
相同点：两者都是List接口的实现类，提供的API的功能逻辑是一样的
不同点：两者的底层实现原理不同，ArrayList底层是基于数组实现的，
而LinkedList是基于线性链表实现的，前者查找快，增删慢；后者查找慢，增删快

List接口的接口方法

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() 
从这个列表中移除所有的元素（可选操作）。  
boolean contains(Object o) 
返回 true如果这个列表包含指定元素。  
boolean containsAll(Collection<?> c) 
返回 true如果这个列表包含指定集合的所有元素。  
boolean equals(Object o) 
将指定的对象与此列表进行比较，以进行相等性。  
E get(int index) 
返回此列表中指定位置的元素。  
int hashCode() 
返回此列表的哈希代码值。  
int indexOf(Object o) 
返回此列表中指定元素的第一个出现的索引，或-如果此列表不包含元素，或- 1。  
boolean isEmpty() 
返回 true如果此列表不包含元素。  
Iterator<E> iterator() 
在这个列表中的元素上返回一个正确的顺序。  
int lastIndexOf(Object o) 
返回此列表中指定元素的最后一个发生的索引，或-如果此列表不包含元素，或- 1。  
ListIterator<E> listIterator() 
返回列表元素的列表迭代器（在适当的顺序）。  
ListIterator<E> listIterator(int index) 
在列表中的元素上返回列表迭代器（在适当的顺序），从列表中的指定位置开始。  
E remove(int index) 
移除此列表中指定位置的元素（可选操作）。  
boolean remove(Object o) 
从该列表中移除指定元素的第一个发生，如果它是存在的（可选操作）。  
boolean removeAll(Collection<?> c) 
从这个列表中移除包含在指定集合中的所有元素（可选操作）。  
default void replaceAll(UnaryOperator<E> operator) 
用将运算符应用到该元素的结果替换此列表中的每个元素。  
boolean retainAll(Collection<?> c) 
仅保留包含在指定集合中的列表中的元素（可选操作）。  
E set(int index, E element) 
用指定元素替换此列表中指定位置的元素（可选操作）。  
int size() 
返回此列表中元素的数目。  
default void sort(Comparator<? super E> c) 
分类列表使用提供的 Comparator比较元素。  
default Spliterator<E> spliterator() 
创建此列表中的元素的 Spliterator。  
List<E> subList(int fromIndex, int toIndex) 
返回一个视图之间的指定 fromIndex，包容，和 toIndex这份名单的部分，独家。  
Object[] toArray() 
返回一个数组，包含在这个列表中的所有元素在适当的顺序（从第一个到最后一个元素）。  
<T> T[] toArray(T[] a) 
返回一个数组，包含在这个列表中的所有元素在适当的顺序（从第一到最后一个元素）；返回数组的运行时类型是指定的数组的运行时类型。  

package com.tedu.cn.collections;

import com.tedu.cn.collections.entity.Student;
import org.junit.Test;

import java.util.*;

public class Demo3 {
    @Test
    public void m1() {
        List list = new ArrayList();
        /**
         * 向List集合中添加元素
         * List集合是一个有序（添加的顺序就是元素在集合里面的顺序），元素可以重复的集合
         * 所以List集合是一个有序且可重复集
         */
        list.add(1);
        list.add(5);
        list.add(5);
        list.add(7);
        for (Object o : list) {
            System.out.println(o);
        }
    }

    @Test
    public void m2() {
        List list = new LinkedList();
        list.add(5);
        list.add(5);
        list.add(21);
        list.add(9);
        for (Object o : list) {
            System.out.println(o);
        }
    }

    /**
     * 由于ArrayList集合是基于数组实现的，那么可以通过下标的形式去访问ArrayList集合里面的元素
     * List提供了一个get（int index）获取对应元素
     */
    @Test
    public void m3() {
        List list = new ArrayList();
        list.add(5);
        list.add(8);
        list.add(6);
        list.add(0);
        /**
         * 根据下标访问集合里的元素
         */
        System.out.println(list.get(0));
        /**
         * 根据下标修改元素
         * List提供了一个API叫get（int index，Object，object）
         */
        list.set(0, "hello");
        System.out.println(list.get(0));
    }

    /**
     * 指定位置添加元素add(int index,Object element)
     * 删除指定位置元素remove(int index)
     */
    @Test
    public void m4() {
        List list = new ArrayList();
        list.add(5);
        list.add(8);
        list.add(9);
        list.add(0);
        list.add(2, "hello");
        for (Object o : list) {
            System.out.println(o);
        }
        list.remove(2);
    }

    /**
     * 遍历list集合
     * 既然List集合是基于数组的原理实现（动态数组）
     * 那么可以使用for循环遍历集合
     * 遍历集合的方法
     * 使用新循环
     * for循环
     * 迭代器
     * Java8提供的lamada表达式的相关接口遍历集合
     */
    @Test
    public void m5() {
        List list = new ArrayList();
        list.add(5);
        list.add(8);
        list.add(0);

        System.out.println("------第一种方式：新循环------");
        for (Object o : list) {
            System.out.println(o);
        }

        System.out.println("------第二种方式：for循环------");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        /**
         * 在使用迭代器遍历元素时，不要用集合删除集合里的元素
         * 否则会出现异常
         * 一定要使用迭代器去删除
         */
        System.out.println("------第三种方式：迭代器循环------");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println("当前遍历的元素：" + iterator.next());
        }

//        System.out.println("------错误删除方法----");
//        while(iterator.hasNext()){
//            Object o=iterator.next();
//            System.out.println("当前遍历的元素："+o);
//            list.remove(o);
//        }

//        System.out.println("------正确删除方法----");
//        while(iterator.hasNext()){
//            Object o=iterator.next();
//            System.out.println("当前遍历的元素："+o);
//            iterator.remove();
//        }
//        System.out.println(list.size());

        System.out.println("------第四种方式：1.8d的forEach API函数式接口------");
        list.forEach(t -> System.out.println("当前迭代元素：" + t));
    }

    /**
     * Java语言的泛型机制，所谓泛型就是让编译器能够在编译的时候识别出的类型
     */
    public void m6() {
        List<String> ls = new ArrayList<>();
        ls.add("hello");
        ls.add("world");
    }

    /**
     * 泛型的使用场景：(大量用于集合中)
     * 1、在接口上使用泛型
     * 2、在类上使用泛型
     * 3、在方法上使用泛型
     * 4、方法的参数上使用泛型
     */
    @Test
    public void m7() {
//        Computer<Integer> computer=new Computer<>();
//        computer.cal(4,5);
        Point<Integer> p = new Point<>(8, 8);
        p.getPoint();
        Point.m1("hello");
    }

    @Test
    public void m8() {
        Set<Student> ss = new HashSet<>();
        Student s1 = new Student();
        Student s2 = new Student();
        ss.add(s1);
        ss.add(s2);
        System.out.println(ss.size());
    }

    /**
     * 小测试：
     * 创建一个List集合  规定这个集合只能存储Integer类型的类型，实现对这个集合的遍历
     */
    @Test
    public void m9() {
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(10);
        list.add(5);
        list.add(3);
        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("-----------------------------------------");
        list.forEach(t -> System.out.println("当前遍历的元素是：" + t));
        Iterator iterator = list.iterator();
        System.out.println("-----------------------------------");
        while (iterator.hasNext()) {
            System.out.println("当前遍历的元素是：" + iterator.next());
        }
    }

    /**
     * 泛型通配符
     * ？
     * ？extends T
     * ？super T
     */
    public void m10() {

        List<?> ls = new ArrayList<>();
        /**
         * ？代表任何一种类型
         * 使用泛型通配符？的时候不能使用add方法添加元素
         * 原因是？的类型不能确定，因此不能添加
         * 但是可以将另一个集合的引用对象赋值给它
         */
        List<Integer> ls01 = new ArrayList<>();
        ls01.add(1);
        ls01.add(2);
        ls01.add(3);
        ls = ls01;//可以这样操作，因为ls01里面的元素的类型完全可以确定
    }

    /**
     * 测试泛型上限 ？ extends T
     * ?表示元素的类型必须是T的子类或者是T的类型本身
     */
    @Test
    public void m11() {
        List<? extends A> ls = new ArrayList<>();
        B b = new B();
        /**
         * ls.add(b)错误
         * 由于？的类型无法确定，所以不能进行add操作
         * 可以将一个已经确定了的类型的集合引用赋值给ls集合
         */
        List<B> bs = new ArrayList<>();
        bs.add(b);
        ls = bs;
        System.out.println(ls.size());
    }

    /**
     * 测试泛型下限
     * ? super T
     * 表示？必须是T的父类类型或者是T类类型
     */
    @Test
    public void m12() {
        List<? super B> ls = new ArrayList<>();
        B b = new B();
        D d = new D();
        ls.add(d);
        ls.add(b);//不能添加父类的类型，只能添加子类或者本类类型，原因是子类类型完全可以确定
        System.out.println(ls.size());

//        A a=new A();
//        List<A> as=new ArrayList<>();
//        as.add(a);
//        ls=as;
//        System.out.println(ls[0]);
        /**
         * 如果要添加元素建议使用？ super T的形式
         * 如果要把一个集合的对象引用赋值为另一个集合，建议使用？extends T的形式
         */
    }

    @Test
    public void m13() {
        List<? extends B> lb = new ArrayList<>();
        B b = new B();
        D d = new D();
        List<B> list = new ArrayList<>();
        list.add(b);
        list.add(d);
        lb = list;
        System.out.println();
    }

    @Test
    public void m14() {
        List<? super B> lb = new ArrayList<>();
        B b = new B();
        List<B> list = new ArrayList<>();
        list.add(b);
        lb = list;
        System.out.println(lb.size());
    }
}