【JAVA集合III-List】

1.List接口

（1）List接口是Collection接口的子接口，看源码：

（2）List集合类特点

• List集合类中的元素有序（即添加顺序和取出顺序一致）、且可重复
• List集合中的每一个元素都有其对应的顺序索引，即支持索引。
• List容器中的元素都对应一个整数型的序号，记载其在容器中的位置，可以根据序号存取容器中的元素。
• JDK API中List接口的实现类

下图仅列出List接口的部分实现类，因为太多了：

2.List接口常用方法

以下方法来自List接口源码：

public interface List<E> extends Collection<E> {

      int size();//集合大小
      
      boolean isEmpty();//判断集合是否为空
      
      boolean contains(Object o);//判断集合是否包含元素o
      
      Iterator<E> iterator();//迭代器方法，用于遍历集合元素
      
      Object[] toArray();//集合转换为数组
      
      <T> T[] toArray(T[] a);//泛型方法，集合转换为数组
      
      boolean remove(Object o);//删除指定元素
      
      boolean containsAll(Collection<?> c);//当前集合是否包含集合c
      
      boolean addAll(Collection<? extends E> c);//添加集合c到当前集合
      
      boolean addAll(int index, Collection<? extends E> c);//在指定位置添加集合c到当前集合
      
      boolean removeAll(Collection<?> c);//删除当前集合中的所有c(c为集合)
      
      boolean retainAll(Collection<?> c);//保留当前集合中所有的集合c
      
      default void replaceAll(UnaryOperator<E> operator) {//替换操作
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

      default void sort(Comparator<? super E> c) {//排序集合元素，要传入一个比较器
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

     void clear();//清空集合

     boolean equals(Object o);//比较元素是否相等

     int hashCode();//计算集合的hashcode值

     E get(int index);//泛型方法，获得指定索引的集合元素
     
    E set(int index, E element);//设置指定索引的集合元素值
    
    void add(int index, E element);//添加指定索引的元素值
    
    E remove(int index);//删除指定位置的值
    
    int indexOf(Object o);//获取元素的索引



}

重点讲述方法：

   * @param a the array into which the elements of this list are to
     *          be stored, if it is big enough; otherwise, a new array of the
     *          same runtime type is allocated for this purpose.
     * @return an array containing the elements of this list
     * @throws ArrayStoreException if the runtime type of the specified array
     *         is not a supertype of the runtime type of every element in
     *         this list
     * @throws NullPointerException if the specified array is null
     */
    <T> T[] toArray(T[] a);

<T> T[] toArray(T[] a);:实现链表到数组的转换，这里的a指定的存储数组

如果a的长度小于当前列表大小，则不进行转换
如果a的长度大于当前列表大小，多余的位置的一个会用null标记
注意：throws ArrayStoreException 如果指定数组的运行时类型
不是每个元素的运行时类型的超类型，保证指定的数组类型为链表元素的超类型。

List<Integer> list3 = new ArrayList<>();
        list3.add(1);
        list3.add(2);
        list3.add(3);
        //这里使用的数组类型必须为list3中的超类才行，而且
        //要保证数组大小大于等于链表大小。
        Integer[] objects = new Integer[]{8, 8,8};
        list3.toArray(objects);
        System.out.println(Arrays.asList(objects));

3.练习

上述方法测试（部分），剩余内容可以自己去测：

package Collection.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * @author rql
 * @date 2022/4/26 - 16:50
 */
public class ListTest {

    public static void main(String[] args) {
        List list=new ArrayList();
        list.add(1);
        list.add(2);
        list.add("背景");
        list.add(new Cat("小欢",3));

        //        int size();
        System.out.println("当前集合大小:"+list.size());

        //
        //        boolean isEmpty();

        System.out.println("当前集合是否为空："+list.isEmpty());
        //
        //        boolean contains(Object o);
        System.out.println("是否包含2："+list.contains(2));
        //
        //        Iterator<E> iterator();
        System.out.println("迭代器遍历集合：");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
        //
        //        Object[] toArray();
        System.out.println("集合转化为数组：");
        Object[] array = list.toArray();//因为没有指定集合的泛型类型，默认为Object类型
        for (Object o : array) {
            System.out.println(o);
        }
        //
        //      <T> T[] toArray(T[] a);

        //
        //        boolean remove(Object o);
        System.out.println("remove的使用：");
        //Object remove = list.remove(1);//删除索引为1的元素：2
        //boolean remove = list.remove("1");//删除元素为1
        //System.out.println(remove);
        Iterator iterator1 = list.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
        }
        //
        //        boolean containsAll(Collection<?> c);
        System.out.println("containsAll：判断当前集合是否包含指定的集合元素：");
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        System.out.println(list.containsAll(list1));//true
        //
        //        boolean addAll(Collection<? extends E> c);
        System.out.println("addAll(Collection<? extends E> c)添加集合，该集合可以是E或E的子类");
        list.addAll(list1);
        iterator=list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //
        //        boolean addAll(int index, Collection<? extends E> c);在指定位置添加一个集合
        System.out.println("boolean addAll(int index, Collection<? extends E> c)");
        list.addAll(1,list1);
        iterator=list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //
        //        boolean removeAll(Collection<?> c);
        System.out.println("boolean removeAll(Collection<?> c):");
//        list.removeAll(list1);
//        iterator=list.iterator();
//        while (iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
        //
        //        boolean retainAll(Collection<?> c);保留集合list中的c
        System.out.println("boolean retainAll(Collection<?> c)：");
        list.retainAll(list1);
        iterator=list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //
        //        default void replaceAll(UnaryOperator<E> operator) {
        //            Objects.requireNonNull(operator);
        //            final ListIterator<E> li = this.listIterator();
        //            while (li.hasNext()) {
        //                li.set(operator.apply(li.next()));
        //            }
        //        }
        //
        //        default void sort(Comparator<? super E> c) {
        //            Object[] a = this.toArray();
        //            Arrays.sort(a, (Comparator) c);
        //            ListIterator<E> i = this.listIterator();
        //            for (Object e : a) {
        //                i.next();
        //                i.set((E) e);
        //            }
        //        }
        //
        //        void clear();
        System.out.println("clear:清空列表");
        list.clear();
        System.out.println(list);

        //
        //        boolean equals(Object o);
        //
        //        int hashCode();计算集合的hashcode值
        int i = list.hashCode();
        System.out.println(i);
        //
        //        E get(int index);
        //
        //        E set(int index, E element);
        //
        //        void add(int index, E element);
        //
        //        E remove(int index);
        //
        //        int indexOf(Object o);
    }
}

class Cat{
    public String name;
    public int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}