Java容器学习之List

List接口继承了Collcetion接口，Collection接口又继承了超级接口Iterable，List是有序列表，实现类有ArrayList、LinkedList、Vector、Stack等。

• ArrayList是基于数组实现的，是一个数组队列，可以动态扩容
• LinkedList是基于链表实现的，是一个双向循环列表，可以当做堆栈使用
• Vector是基于数组实现的，是一个矢量队列，是线程安全的
• Stack是基于数组实现的，继承了Vector，是先进后出

现在从List的常用方法做一个梳理。

一、常用方法

1.1 List中添加元素

boolean add(E e) //添加元素， add()方法用于向容器中添加元素，返回值是布尔型

void add(int index, Object obj) //在指定位置添加元素，index是添加元素的位置， index范围是（0，list.size())

boolean addAll(Collection<? extends E> c) //将一个List中的元素全部添加到另一个list的尾部

 1     public static void testAdd() {
 2         List<Integer> arrayList = new ArrayList<Integer>();
 3         arrayList.add(1);
 4         arrayList.add(2);
 5         arrayList.add(3);
 6         for(Integer number : arrayList) {
 7             System.out.print(number + " ");
 8         }
 9         List<Integer> arrayList1 = new ArrayList<>();
10         arrayList1.add(22);
11         arrayList1.add(15);
12         arrayList.addAll(arrayList1);
13         System.out.print("合并后：");
14         for(Integer number : arrayList) {
15             System.out.print(number + " ");
16         }
17     }

1.2 List中删除元素

void clear() //删除List中所有元素

Object remove(int index) //删除指定位置的元素，并把删除元素返回

boolean remove(Object obj) //从集合中删除一个元素，返回布尔值

boolean removeAll(Collection<?> c) //从List删除另一个集合c中的值

boolean retainAll(Collection<?>  c) //只保留集合c中的值

void replaceAll(UnaryOperator operator) //根据operator指定的计算规则来重新设置List集合中的所有元素，与Collections中的replaceAll方法有区别

    public static void testDelete() {
         List<String> pirates = new ArrayList<>();
         pirates.add("路飞");
         pirates.add("索隆");
         pirates.add("娜美");
         pirates.add("乌索普");
         for (String name : pirates) {
             System.out.println("删除前成员有：" + name);
         }
         pirates.remove("乌索普");
         for (String name : pirates) {
             System.out.println("删除后成员有：" + name);
         }
         List<String> retainList = new ArrayList<>();
         retainList.add("路飞");
         pirates.retainAll(retainList);
         for (String name : pirates) {
             System.out.println("保留的成员有：" + name);
         }

         pirates.replaceAll(x -> "草帽海贼团：" + x);
         for (String name : pirates) {
             System.out.println(name);
         }
     }

1.3 List中的其它方法

boolean contains(Object obj) //判断是否包含指定元素

boolean contains(Collection c) //判断是否包含另一个集合的元素

boolean isEmpty() //判断是否为空

int size() //返回集合中元素个数

E get(int index) //获取指定位置元素

E set(int index, E element) //对指定位置赋值

int indexof(Object o) //返回指定元素第一次出现的位置索引

List<E> subList(int fromIndex, int toIndex) //返回从fromIndex到toIndex之间的元素

     public static void testOtherFunction() {
         List<String> pirates = new ArrayList<>();
         pirates.add("路飞");
         pirates.add("索隆");
         pirates.add("娜美");
         pirates.add("乌索普");
         if (pirates.contains("路飞")) {
             System.out.println("包含路飞");
         }
         System.out.println(pirates.indexOf("娜美"));
         System.out.println("pirates长度是：" + pirates.size());
         pirates.set(2, "小贼猫娜美");
         for (String name : pirates) {
             System.out.println("草帽海贼团：" + name);
         }
         List<String> subPirates = pirates.subList(1, 2);
         for (String name : subPirates) {
             System.out.println("草帽海贼团001：" + name);
         }
     }

因为List中方法太多，对其它方法不再进行介绍。

1.4 List的三种遍历方式

     public static void testTraverse() {
         List<String> pirates = new ArrayList<>();
         pirates.add("路飞");
         pirates.add("索隆");
         pirates.add("娜美");
         // for循环遍历
         for (int i = 0; i < pirates.size(); i++) {
             System.out.println(pirates.get(i));
         }
         // 增强for循环
         for (String str : pirates) {
             System.out.println(str);
         }
         // 迭代器遍历
         Iterator iterator = pirates.iterator();
         while (iterator.hasNext()) {
             System.out.println(iterator.next());
         }
         ListIterator listIterator = pirates.listIterator();
         while (listIterator.hasNext()) {
             System.out.println(listIterator.next());
         }
     }

前两种遍历方式比较常见，不再介绍，这里主要说一下第三种遍历方式。使用Iterator和ListIterator迭代器都可以对List进行遍历，ListIterator继承于Iterator，并扩充了自己的方法。

下面介绍一下两种迭代器的不同点：

• Iterator可以应用于所有的集合，Set、List和Map和这些集合的子类型。而ListIterator只能用于List及其子类型
• ListIterator有add方法，可以向List中添加对象，而Iterator不能
• ListIterator有hasPrevious()和previous()方法，可以实现双向遍历，而Iterator只能向后遍历
• ListIterator可以定位当前索引的位置，nextIndex()和previousIndex()可以实现，Iterator不能。