JAVA -- List ArrayList LinkedList

List接口

1.概述

• 有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
• 与 set 不同，列表通常允许重复的元素。更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。

2.特点

• List中的元素都是有下标的，并且是有序的
• 允许存放重复数据

3.主要方法

方法摘要
返回值	方法	方法描述
boolean	add(E e)	向列表的尾部添加指定的元素
void	add(int index, E element)	在列表的指定位置插入指定元素
boolean	addAll(Collection<? extends E> c)	添加指定 collection 中的所有元素到此列表的结尾
boolean	addAll(int index, Collection<? extends E> c)	将指定 collection 中的所有元素都插入到列表中的指定位置
void	clear()	从列表中移除所有元素
boolean	contains(Object o)	如果列表包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)	如果列表包含指定 collection 的所有元素，则返回 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)	从列表中移除指定 collection 中包含的其所有元素（可选操作）。
boolean	retainAll(Collection<?> c)	仅在列表中保留指定 collection 中所包含的元素（可选操作）。(求交集)
E	set(int index, E element)	用指定元素替换列表中指定位置的元素（可选操作）。
int	size()	返回列表中的元素数。
List<E>	subList(int fromIndex, int toIndex)	返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。（截取）
Object[]	toArray()	返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。（转数组）

4.List 接口测试

	package cn.tedu.collection;
	
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;
	
	//本类用于测试List接口
	public class TestList {
	    public static void main(String[] args) {
	        //1.创建List的多态对象，注意List是接口，不可实例化
	        List<String> list = new ArrayList<>();
	        //2.向list集合中存入数据
	        list.add("大娃");
	        list.add("二娃");
	        list.add("三娃");
	        list.add("四娃");
	        list.add("五娃");
	        list.add("六娃");
	        list.add("七娃");
	        System.out.println(list); //查看集合中的元素
	
	        /*list.clear(); //清空集合
	        System.out.println(list);*/
	        System.out.println(list.contains("三娃")); //true，判断集合是否包含指定元素
	        System.out.println(list.equals("五娃")); //false，集合对象与String不相等
	        System.out.println(list.isEmpty()); //false，判断集合是否为空
	        System.out.println(list.remove("七娃")); //移除集合中指定的元素
	        System.out.println(list.size()); //6，获取集合中元素的个数
	        System.out.println(Arrays.toString(list.toArray())); //将集合转成数组
	
	        //3.测试List接口自己的方法 -- List有序，可以根据索引来操作集合中的元素
	        list.add("小蝴蝶"); //追加在最后
	        list.add(1,"蛇精"); //在指定的索引处添加元素
	        list.add(3,"小蝴蝶");
	        System.out.println(list);
	
	        System.out.println(list.indexOf("小蝴蝶")); //3,获取指定元素第一次出现的索引
	        System.out.println(list.lastIndexOf("小蝴蝶")); //8,获取指定元素第最后一次出现的索引
	
	        //System.out.println(list.remove("小蝴蝶")); //根据元素名删除元素，一次删一个，从前到后删
	        System.out.println(list.remove(5)); //根据索引删除元素，并将被删除的元素返回
	        System.out.println(list);
	        System.out.println(list.get(3)); //根据索引获取元素，并返回
	        System.out.println(list.set(7,"蝎子精")); //修改指定索引处元素的值为蝎子精,并返回被替代的元素
	        System.out.println(list);
	
	        //4.测试集合间的操作
	        List<String> list2 = new ArrayList<>();
	        list2.add("1");
	        list2.add("2");
	        list2.add("3");
	        list2.add("4");
	        System.out.println(list2);
	
	        System.out.println(list.addAll(list2)); //将list2集合的所有内容追加到list末尾
	        System.out.println(list);
	        System.out.println(list.addAll(1,list2)); //将list2集合的所有内容追加到list集合的指定位置
	        System.out.println(list);
	
	        System.out.println(list.containsAll(list2)); //true
	        System.out.println(list.removeAll(list2)); //移除list集合中属于list2的所有元素
	        System.out.println(list);
	    }
	}

5.List 接口迭代方式

	package cn.tedu.collection;
	
	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;
	import java.util.ListIterator;
	
	//本类用于进一步测试List接口
	public class TestList2 {
	    public static void main(String[] args) {
	        //1.创建List接口的多态对象
	        List<String> list = new ArrayList<>();
	        //2.向创建好的list集合添加元素
	        list.add("喜羊羊");
	        list.add("懒羊羊");
	        list.add("美羊羊");
	        list.add("暖羊羊");
	        list.add("沸羊羊");
	        list.add("慢羊羊");
	        System.out.println(list);
	
	        /**
	         * 测试集合的迭代方式
	         * 1.for循环
	         * 2.高效for循环
	         * 3.iterator
	         * 4.listIterator
	         */
	        //方式一：因为List集合是有序的，元素有下标，所以可以根据下标进行遍历
	        //从哪开始：0   到哪结束：list.size()-1   如何变化++
	        //1.普通for循环
	        System.out.println("********方式一:普通for循环********");
	        for (int i = 0; i < list.size() ; i++){
	            //根据本轮循环遍历到的索引值获取对应的集合元素
	            System.out.println(list.get(i));
	        }
	
	        //方式二：因为普通for循环遍历效率低，语法复杂，所以使用foreach循环遍历
	        //格式： for(本轮遍历到的元素类型  元素名 : 要遍历的内容名){循环体}
	        //2.增强for循环
	        System.out.println("********方式二:增强for循环********");
	        for(String s : list){
	            System.out.println(s);
	        }
	
	        //方式三：从父接口中继承过来的迭代器iterator
	        //3.iterator
	        System.out.println("********方式三:iterator********");
	        //   1.获取对应的迭代器对象
	        Iterator<String> it = list.iterator();
	        //  2.通过刚刚获取到的迭代器循环迭代集合中的所有元素
	        while (it.hasNext()){ //判断是否仍有下一个元素可以迭代
	            System.out.println(it.next()); //打印当前获取到的元素
	        }
	
	        //方式四：listIterator属于list接口特有的迭代器
	        /**
	         * Iterator<E> -- 父接口 -- hasNext()  next()
	         * ListIterator<E> -- 子接口 -- 除了父接口的功能外，
	         * 还有自己的特有功能，比如逆序遍历，添加元素等等，但是不常用
	         * public interface ListIterator<E> extends Iterator<E>
	         */
	        //4.listIterator
	        System.out.println("********方式四:listIterator********");
	        ListIterator<String> it2 = list.listIterator();
	        while (it2.hasNext()){
	            System.out.println(it2.next());
	        }
	    }
	}

ArrayList

6.概述

• List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

7.特点

• 底层结构是数组，查询快，增删慢，适合查询较多的情况
• 底层数组的默认初始容量大小是10，如果不够会以1.5倍扩容

  	// 源码摘抄
  	
  	/**
       * Default initial capacity.(默认初始容量)
       */
      private static final int DEFAULT_CAPACITY = 10;
  
  	/**
       * Increases the capacity to ensure that it can hold at least the
       * number of elements specified by the minimum capacity argument.
       *
       * @param minCapacity the desired minimum capacity
       */
      private void grow(int minCapacity) {
          // overflow-conscious code
          int oldCapacity = elementData.length;
          int newCapacity = oldCapacity + (oldCapacity >> 1); //此处使用 >>1 右移一位，相当于除以2
          if (newCapacity - minCapacity < 0)
              newCapacity = minCapacity;
          if (newCapacity - MAX_ARRAY_SIZE > 0)
              newCapacity = hugeCapacity(minCapacity);
          // minCapacity is usually close to size, so this is a win:
          elementData = Arrays.copyOf(elementData, newCapacity);
      }
  

8.ArrayList测试

	package cn.tedu.list;
	
	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.ListIterator;
	
	//本类用于ArrayList相关测试
	public class TestArrayList {
	    public static void main(String[] args) {
	        //1.创建对应的集合对象
	        /**
	         * 底层会自动帮我们创建数组来存放对象，并且初始容量为10
	         */
	        ArrayList<Integer> list = new ArrayList<>();
	        //2.向集合中添加元素进行测试
	        list.add(100);
	        list.add(200);
	        list.add(300);
	        list.add(400);
	        list.add(400);
	        list.add(300);
	        System.out.println(list); //[100, 200, 300, 400, 400, 300]
	
	        //3.测试常用数据
	/*        list.clear(); //清空集合
	        System.out.println(list); //[]      */
	        System.out.println(list.contains("100")); //false,这个100是String类型
	        System.out.println(list.contains(100)); //true，是否包含指定元素
	        System.out.println(list.isEmpty()); //false,判断集合是否为空
	        System.out.println(list.get(0)); //100，根据索引获取元素
	        System.out.println(list.indexOf(400)); //3,判断指定元素第一次出现的位置
	        System.out.println(list.lastIndexOf(400)); //4,判断指定元素最后一次出现的位置
	        System.out.println(list.remove(1)); //200,移除指定位置处的元素，并将该元素返回
	
	        /* 根据元素名移除元素 */
	        //System.out.println(list.remove(300)); //IndexOutOfBoundsException,数组下标越界
	        //System.out.println(list.remove("300")); //false, "300"是String类型
	        System.out.println(list.remove(Integer.valueOf(300))); //使用Integer.valueOf()把int类型的300转成Integer类型
	        System.out.println(list);
	
	        System.out.println(list.set(2,777)); //修改指定索引处的元素的值为777
	        System.out.println(list);
	        System.out.println(list.size()); //4,获取列表中元素的个数
	
	        //进行集合的迭代
	        //1. for循环
	        System.out.println("********for循环********");
	        for(int i = 0; i < list.size() ; i++){
	            System.out.println(list.get(i));
	        }
	        //2. foreach循环
	        System.out.println("********foreach循环********");
	        for(Integer i : list){
	            System.out.println(i);
	        }
	        //3. iterator
	        System.out.println("********iterator********");
	        Iterator<Integer> it = list.iterator();
	        while (it.hasNext()){
	            System.out.println(it.next());
	        }
	        //4. listIterator
	        System.out.println("********listIterator********");
	        ListIterator<Integer> it2 = list.listIterator();
	        while (it2.hasNext()){
	            System.out.println(it2.next());
	        }
	
	        System.out.println("********listIterator逆序遍历方式一********");
	        while (it2.hasNext()){
	            it2.next();
	        }
	        while (it2.hasPrevious()){
	            System.out.println(it2.previous());
	        }
	
	        System.out.println("********listIterator逆序遍历方式二********");
	        for(it2 = list.listIterator() ; it2.hasNext() ;){
	            it2.next();
	        }
	        for(;it2.hasPrevious();){
	            System.out.println(it2.previous());
	        }
	
	
	    }
	}

LinkedList

9.概述及特点

• LinkedList 底层结构是链表，不连续的内存空间，查询慢，增删快，适合增删场景较多的情况
• 链表结构针对查询而言，首尾操作比较快，中间操作比较慢

10.LinkedList测试

	package cn.tedu.list;
	
	import java.util.LinkedList;
	
	//本类用于LinkedList的相关测试
	public class TestLinkedList {
	    public static void main(String[] args) {
	        //1.创建集合对象
	        LinkedList<String> list = new LinkedList<>();
	        //2.向集合中添加元素进行测试
	        list.add("孙悟空");
	        list.add("猪八戒");
	        list.add("沙和尚");
	        list.add("唐三藏");
	        list.add("白龙马");
	        System.out.println(list);
	
	        //3.2测试LinkedList自己的方法
	        list.addFirst("玉兔精"); //添加首元素
	        list.addLast("孔雀精"); //添加尾元素
	        System.out.println(list);
	
	        System.out.println(list.getFirst()); //获取首元素
	        System.out.println(list.getLast()); //获取尾元素
	
	        System.out.println(list.removeFirst()); //移除首元素，并返回对应元素
	        System.out.println(list.removeLast()); //移除尾元素，并返回对应元素
	        System.out.println(list);
	
	        //4.其他测试
	        //4.1创建集合对象并存入数据
	        LinkedList<String> list2 = new LinkedList<>();
	        list2.add("水浒传");
	        list2.add("西游记");
	        list2.add("三国演义");
	        list2.add("红楼梦");
	        System.out.println(list2);
	
	        //获取但不移除集合中的首元素（第一个元素）
	        System.out.println(list2.element()); //水浒传
	        System.out.println(list2);
	
	        /* 查询 peek  */
	        //获取但不移除集合中的首元素（第一个元素）
	        System.out.println(list2.peek()); //水浒传
	        System.out.println(list2.peekFirst()); //水浒传
	        System.out.println(list2);
	        //获取但不移除集合中的尾元素（最后一个元素）
	        System.out.println(list2.peekLast()); //红楼梦
	        System.out.println(list2);
	
	        /* 新增 offer  */
	        System.out.println(list2.offer("聊斋志异")); //true，新增元素，默认增加在尾部
	        System.out.println(list2.offerFirst("斗罗大陆")); //true，在首部增加元素
	        System.out.println(list2.offerLast("斗破苍穹")); //true，在尾部增加元素
	        System.out.println(list2);
	
	        /* 移除  poll */
	        System.out.println(list2.poll()); //斗罗大陆，移除首元素并返回该元素
	        System.out.println(list2);
	        System.out.println(list2.pollFirst()); //水浒传，移除首元素并返回该元素
	        System.out.println(list2.pollLast()); //斗破苍穹，移除尾元素并返回该元素
	        System.out.println(list2);
	    }
	}