(LinkedList与链表) 和 （ArrayList与顺序表）的区别

1. ArrayList简介

MyArrayList

常量（define）public static final int

    public static final int DEFAULT_CAPACITY = 10;

在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：

【说明】

1. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
2. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
3. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
4. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者
   CopyOnWriteArrayList
5. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

2. LinkedList的使用

5.1 什么是LinkedList

LinkedList 的官方文档

LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
在集合框架中，LinkedList也实现了List接口，具体如下：
【说明】

1. LinkedList实现了List接口
2. LinkedList的底层使用了双向链表
3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问
4. LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)

5.2 LinkedList的使用

1. LinkedList的构造

public static void main(String[] args) {
     
	// 构造一个空的
	LinkedList List<Integer> list1 = new LinkedList<>(); 
	List<String> list2 = new java.util.ArrayList<>(); 
	list2.add("JavaSE"); 
	list2.add("JavaWeb"); 
	list2.add("JavaEE"); 
	// 使用ArrayList构造LinkedList 
	List<String> list3 = new LinkedList<>(list2); 
}

2. LinkedList的其他常用方法介绍

    public static void main(String[] args) {
    
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);  //add(elem): 表示尾插
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        System.out.println(list.size());
        System.out.println(list);

        //在起始位置插入0
        list.add(0, 0);  add(index, elem): 在index位置插入元素elem
        System.out.println(list);

        list.remove();  //remove(): 删除第一个元素，内部调用的是removeFirst()
        list.removeFirst();  //removeFirst(): 删除第一个元素
        list.removeLast();  //removeLast(): 删除最后元素
        list.remove(1);  //remove(index): 删除index位置的元素
        System.out.println(list);

        // contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
        if(!list.contains(1)){
    
            list.add(0, 1);
        }
        list.add(1);
        System.out.println(list);
        System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
        System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
        int elem = list.get(0); // get(index): 获取指定位置元素
        list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
        System.out.println(list);

        // subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
        List<Integer> copy = list.subList(0, 3);
        System.out.println(list);
        System.out.println(copy);
        list.clear(); // 将list中元素清空
        System.out.println(list.size());
    }

3. LinkedList的遍历

    public static void main(String[] args) {
    
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);  //add(elem): 表示尾插
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        System.out.println(list.size());
        // foreach遍历
        for (int e:list) {
    
            System.out.print(e + " ");
        }
        System.out.println();

        // 使用迭代器遍历---正向遍历
        ListIterator<Integer> it = list.listIterator();
        while(it.hasNext()){
    
            System.out.print(it.next()+ " ");
        }
        System.out.println();
        // 使用反向迭代器---反向遍历
        ListIterator<Integer> rit = list.listIterator(list.size());
        while (rit.hasPrevious()){
    
            System.out.print(rit.previous() +" ");
        }
        System.out.println();
    }

3. ArrayList和LinkedList的区别