Java集合框架之List接口详解及ArrayList、LinkedList、Vector对比-CSDN博客

本文链接：https://blog.csdn.net/mofeigege/article/details/109212461

List接口中的常用方法


void add(int index, Object ele)	在index位置插入ele元素
boolean addAll(int index, Collection eles)	从index位置开始将eles中的所有元素添加进来,若不写index,默认添加到最后
Object get(int index)	获取指定index位置的元素
int indexOf(Object obj)	返回obj在集合中首次出现的位置,如果不存在,返回-1
int lastIndexOf(Object obj)	返回obj在集合中末次出现的位置,如果不存在,返回-1
Object remove(int index)	移除指定index位置的元素,并返回此元素
Object set(int index, Object ele)	设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex)	返回从fromIndex到toIndex位置(左闭右开)的子集

import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ListTest {
    @Test
    public void test1() {
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("aa");
        list.add(new Person("mofei", 22));
        list.add(456);
        System.out.println("------add()------");
        System.out.println(list);
        list.add(1,"bb");
        System.out.println(list);


        System.out.println("------addAll()------");
        //boolean addAll(int index, Collection eles) : 从index位置开始将eles中的所有元素添加进来,若不写index,默认添加到最后
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list.size());
        System.out.println(list);


        System.out.println("------get()------");
        System.out.println(list.get(1));


        System.out.println("------indexOf()------");
        int index = list.indexOf(456);
        System.out.println(index);

        System.out.println("------lastIndexOf()------");
        int index2 = list.lastIndexOf(456);
        System.out.println(index2);


        System.out.println("------remove()------");
        Object obj = list.remove(0);
        System.out.println(obj);

        System.out.println("------set()------");
        //Object set(int index, Object ele) : 设置指定index位置的元素为ele
        System.out.println(list);
        list.set(5, "uu");
        System.out.println(list);


        System.out.println("------subList()------");
        //List subList(int formIndex, int toIndex) : 返回从fromIndex到toIndex位置(左闭右开)的子集
        List subList = list.subList(4, 7);
        System.out.println(subList);
        System.out.println(list);
    }
}
/**
------add()------
[123, 456, aa, Person{name=mofei',age=22}, 456]
[123, bb, 456, aa, Person{name=mofei',age=22}, 456]
------addAll()------
9
[123, bb, 456, aa, Person{name=mofei',age=22}, 456, 1, 2, 3]
------get()------
bb
------indexOf()------
2
------lastIndexOf()------
5
------remove()------
123
------set()------
[bb, 456, aa, Person{name=mofei',age=22}, 456, 1, 2, 3]
[bb, 456, aa, Person{name=mofei',age=22}, 456, uu, 2, 3]
------subList()------
[456, uu, 2]
[bb, 456, aa, Person{name=mofei',age=22}, 456, uu, 2, 3]
*/

1，List接口框架:
- Collection接口: 单列集合数据，定义了存储一组对象的方法的集合
  - List: 元素有序,可重复的集合，集合中的每个元素都有其对应的顺序索引(动态数组)
    - List接口的实现类常用的有：ArrayList, LinkedList和Vector

面试题:比较ArrayList,LinkedList,Vector三者的异同？
同: 三个类都实现了List接口，存储数据的特点相同：存储有序的,可重复的数据
不同：ArrayList:作为List接口的主要实现类;线程不安全的，效率高;底层使用Object[] elementData存储;
LinkedList:对于频繁插入,删除操作，使用此类效率给ArrayList高;底层使用双向链表存储;
Vector:作为List接口的古老实现类;线程安全的,效率低;底层使用Object[] elementData存储;

2， ArrayList源码分析：
- 2.1 jdk7情况下
  ArrayList list = new ArrayList();底层创建了长度为10的Object[]数组elementData
  list.add(123);//elementData[0] = new Integer(123);
  …
  list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容；
  默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中
  结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity);
- 2.2 jdk8中ArrayList的变化
  ArrayList list = new ArrayList();底层Object[]elementData初始化为{},并没有创建长度为10的数组
  list.add(123);//第一次调用add()时,底层才创建了长度为10的数组，并将数据123添加到elementData[0]中
  …
  后续的添加和扩容操作与jdk7无异
- 2.3 小结: jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象的创建类似于单例的懒汉式,延迟了数组的创建，节省内存

数据结构： 基于数组实现类型：Object类型
使用get(int index) 方法进行查找值：时间复杂度为 o(1)
时间复杂度：o(1) / o(n) / o(log n)
o(1) ：只需要通过一次查询就能找到元素
比如：get(int index) 基于下标查询
o(n) ：需要从头查到尾部
例如：根据元素值进行查询(链表)
o(log n) ：二叉树红黑树
数组：时间复杂度为o(1),基于下表查询
链表：时间复杂度为o(n)，基于值进行查询

初始扩容流程：
在这里插入图片描述

数组与链表结构的区别：
数组：保证元素的有序性，可以基于下标查询，时间复杂度为：o(1)
链表：单向链表和双向链表，可以基于下标查询(从开头开始索引)，时间复杂度为：o(n)
数组适用于：基于下标查询，数组查询快，增删慢
链表适用于：频繁进行增删操作，只需要该引用的指针关系
HashMap底层使用的是单链表，LinkList底层使用的是双向链表。

3， LinkedList的源码分析:
LinkedList list = new LinkedList();//内部声明了Node类型的first和last属性,默认值为Null
list.add(123);//将123封装到Node中,创建了Node对象

其中,Node定义为:体现了LinkedList的双向双向链表的说法

       private static class Node<E> {
          E item;
          Node<E> next;
          Node<E> prev;
 
          Node(Node<E> prev, E element, Node<E> next) {
              this.item = element;
              this.next = next;
              this.prev = prev;
         }
      }