一、ArrayList和linkedList的区别

  1. Array
    Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。
    Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大，因为这需要重排数组中的所有数据, (因为删除数据以后, 需要把后面所有的数据前移)
    缺点: 数组初始化必须指定初始化的长度, 否则报错

例如:

int[] a = new int[4];//推介使用int[] 这种方式初始化
	
	int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]
  1. List
    List—是一个有序的集合，可以包含重复的元素，提供了按索引访问的方式，它继承Collection。
    List有两个重要的实现类：ArrayList和LinkedList
    List是一个接口，不可以实例化, 不能写成如下：
List<Integer> list = new List<Integer>();//错误

类继承关系:

arraylist拿索引 java arraylist索引_ci

  1. ArrayList
    ArrayList: 可以看作是能够自动增长容量的数组
    ArrayList的toArray方法返回一个数组
    ArrayList的asList方法返回一个列表
    ArrayList底层的实现是Array, 数组扩容实现
  2. LinkList
    LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.
    但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。

arraylist拿索引 java arraylist索引_链表_02

链表不需要连续的空间, 大小不确定

  1. 对比

小结

同样查找, 时间复杂度都是O(N), 但是数组要比链表快

因为数组的连续内存, 会有一部分或者全部数据一起进入到CPU缓存, 而链表还需要在去内存中根据上下游标查找, CPU缓存比内存块太多

数据大小固定, 不适合动态存储, 动态添加, 内存为一连续的地址, 可随机访问, 查询速度快

链表代销可变, 扩展性强, 只能顺着指针的方向查询, 速度较慢。

  1. ArrayList的源码分析
    7.1 ArrayList的主要成员变量
private static final int DEFAULT_CAPACITY = 10;
 	// ArrayList的默认长度是多少
 private static final Object[] EMPTY_ELEMENTDATA = {};
 	// ArrayList的默认空元素链表
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 	// ArrayList存放的数据
 transient Object[] elementData; // non-private to simplify nested class access
 	// ArrayList的长度
 private int size;

7.2 ArrayList的构造函数

// 构造一个初始化容量为10的空列表
 public ArrayList() {
         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
 }
 // 初始化一个指定大小容量的列表
 public ArrayList(int initialCapacity) {
         if (initialCapacity > 0) {
             this.elementData = new Object[initialCapacity];
         } else if (initialCapacity == 0) {
             this.elementData = EMPTY_ELEMENTDATA;
         } else {
             throw new IllegalArgumentException("Illegal Capacity: "+
                                                initialCapacity);
         }
     }
 // 构造一个包含指定集合的元素列表, 按照它们由集合迭代器返回的顺序
 public ArrayList(Collection<? extends E> c) {
         elementData = c.toArray();
         if ((size = elementData.length) != 0) {
             // c.toArray might (incorrectly) not return Object[] (see 6260652)
             if (elementData.getClass() != Object[].class)
                 elementData = Arrays.copyOf(elementData, size, Object[].class);
         } else {
             // replace with empty array.
             this.elementData = EMPTY_ELEMENTDATA;
         }
 }

7.3 扩容机制

ArrayList扩容的核心从ensureCapacityInternal方法说起。可以看到前面介绍成员变量的提到的ArrayList有两个默认的空数组：

DEFAULTCAPACITY_EMPTY_ELEMENTDATA：是用来使用默认构造方法时候返回的空数组。如果第一次添加数据的话那么数组扩容长度为DEFAULT_CAPACITY=10。

EMPTY_ELEMENTDATA：出现在需要用到空数组的地方，其中一处就是使用自定义初始容量构造方法时候如果你指定初始容量为0的时候就会返回。

// 增加元素的方法
public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

 //判断当前数组是否是默认构造方法生成的空数组，如果是的话minCapacity=10反之则根据原来的值传入下一个方法去完成下一步的扩容判断
private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
        }

//minCapacitt表示修改后的数组容量，minCapacity = size + 1
 private void ensureCapacityInternal(int minCapacity) {
        //判断看看是否需要扩容
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

下面谈谈ensureExplicitCapacity方法（modCount设计到Java的快速报错机制后面会谈到），可以看到如果修改后的数组容量大于当前的数组长度那么就需要调用grow进行扩容，反之则不需要。

/判断当前ArrayList是否需要进行扩容
private void ensureExplicitCapacity(int minCapacity) {
  modCount++;

  // overflow-conscious code
  // int[] a = new int[5]; 数组创建的时候是多大, a.length就等于5
  if (minCapacity - elementData.length > 0)
    grow(minCapacity);
}

总结:

一、ArrayList原理

1、底层是由数组实现的,所以有数组的特性:

<1>、因为有下标,所以随机访问和遍历快,插入和删除慢,因为插入和删除后需要重新维护下标(移动元素)

<2>、浪费内存,因为数组长度不可变,达到上限后,会自动扩容(新创建一个数组,长度是原数组的
   1.5倍)。

<3>、默认大小是10。

<4>、线程不安全,有序,可重复。

2、删除元素和插入元素的原理:

<1>、删除:

把指定元素后面位置的所有元素，利用System.arraycopy方法整体向前移动一个位置
最后一个位置的元素指定为null，这样让gc可以去回收它
实际上就是移动这些元素,向前移动一位。

<2>、插入

看到插入的时候，按照指定位置，把从指定位置开始的所有元素利用
System.arraycopy方法做一个整体的复制，向后移动一个位置。

二、LinkedList原理

1、LinkedList是基于链表实现的

2、具体实现:

<1>、new LinkedList的时候,堆里面会产生一个对象,这个对象有几个属性:size和first和last。
   初始化的时候first和last等于null,size=0

<2>、当第一次add的时候,会产生一个node对象,node对象的next属性为null,还有一个e属性,就是添加的值。然后将node属性的内存地址赋给LinkedList对象的first。

<3>、第二次添加add,又将第一个node的内存地址存入新node的perv属性,第一个node的next属性赋值:新node的内存地址

这样就实现了链表结果

3、特性

<1>、真正的动态结构,添加或者插入新节点,改变上一个或者上下节点的next和perv属性就行
  内存空间不连续,也不会有扩容的情况。

<2>、由于没有下标,get方法实际上是先找头元素,然后循环next获取的,所以这种情况用for循环
遍历,每次都会从头开始循环,所以linkedlist最好是用迭代器遍历

<3>、遍历慢,删除插入快,因为内存不连续,并且不用维护下标。