java的list集合new_Java的List集合（三十）

List接口

java.util.List接口继承Collection接口，是集合的一个重要的分支，我们平常所使用最多的就是这个集合，我们用实现类所实现这个接口的时候，习惯把这个接口的对象叫做List集合

List接口

List集合的特点：

1、它是一个元素存取有序的集合。

2、它是一个有索引的集合，可以通过索引精确的操作集合中的元素。

3、集合中允许有重复的元素。

List接口中自带的常用的方法：

public void add(int index, E element)将指定的元素，添加到该集合中的指定位置上。

public E get(int index)返回集合中指定位置的元素。

public E remove(int index)移除列表中指定位置的元素，返回被移除的元素。

public E set(int index, E emelent)用指定元素替换集合中指定位置的元素，返回是更新前的元素。

List接口中的常用方法，可以在它的所有的实现类中使用

List接口中常用的方法的使用

准备数据：

List list = new ArrayList<>();

list.add("a");

list.add("b");

list.add("c");

list.add("d");

list.add("e");

System.out.println(list); //[a, b, c, d, e]

public void add(int index, E element)将指定的元素，添加到该集合中的指定位置

//在bc之间加上一个*

list.add(2, "*");

System.out.println(list); //[a, b, *, c, d, e]

public E get(int index)返回集合中指定位置的元素。

//取出下标为2的元素

String str = list.get(2);

//String n = list.get(5); java.lang.IndexOutOfBoundsException 数组下标越界异常

System.out.println(str); //c java中数组下标是从0开始的

public E remove(int index)移除列表中指定位置的元素，返回被移除的元素。

//移除下标为3的元素

String remove = list.remove(3);

System.out.println(remove); //d

System.out.println(list); //[a, b, c, e]

public E set(int index, E emelent)用指定元素替换集合中指定位置的元素，返回是更

//移除第一个元素，返回值是被移除的元素

String set = list.set(0, "*");

System.out.println(set); //a

System.out.println(list); //[*, b, c, d, e]

ArrayList集合

java.util.ArrayList集合，在之前就使用过，但是一直没有介绍过，一直到现在再介绍，因为这个集合是以后我的在工作中用的最多的集合，并且它的大部分方法，在之前使用的时候已经用过了，所以在这里就不在多说他的使用方法了。

在这里主要说一下，他的数据结构，可以从名子中就可以看出来，他是数组实现的，是List接口的一个重要的实现类。

底层的实现：

List里面的数组：

transient Object[] elementData; // non-private to simplify nested class access

这个数组就是List集合里面的底层操作的数组。

List里面的长义：

private int size;

我们通常获得长度就是获得的这个就量的数据。

Arraylist里面的add方法

public boolean add(E e) {

ensureCapacityInternal(size + 1); // Increments modCount!!(增量)

elementData[size++] = e;

return true;

}

ensureCapacityInternal(size + 1)这个方法的作用，就是查询集合中底层的数组的长度够不够，如果够，就继承执行下面的代码，如果不够，就得数组扩容，数组扩容后面再说。

elementData[size++] = e;这个就是把长度加一之后，存到数组的这个位置。

return true;如果没有发生异常，都是返回的true

ensureCapacityInternal(size + 1)方法：

private void ensureCapacityInternal(int minCapacity) {

ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));

}

这个方法是完成判断的主要的方法，它调用了calculateCapacity()方法来确定数组的长度。

private static int calculateCapacity(Object[] elementData, int minCapacity) {

if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

return Math.max(DEFAULT_CAPACITY, minCapacity);

}

return minCapacity;

}

DEFAULTCAPACITY_EMPTY_ELEMENTDATA 默认容器

DEFAULT_CAPACITY默认容量为10

当数组中没有元素的时候，会取默认长度和传进来的长度之中的最大值，致于为什么会这样，是因为这个方法不光add会调用，addAll也会调用这个方法，如果用的是Arraylist的默认方法创建的数组，那么说不定数组的长度会不够的，所以要判断一下。然后返回新数组的长度。

private void ensureExplicitCapacity(int minCapacity) {

modCount++;

// overflow-conscious code

if (minCapacity - elementData.length > 0)

grow(minCapacity);

}

modCount这个变量的作用就是记录一下集合中元素操作的次数，每一次增加或删除的时候，都会加一。

当新数组长度，大于旧的数组长度的时候，就会通过grow()来拷贝数组。

private void grow(int minCapacity) {

// overflow-conscious code

int oldCapacity = elementData.length;

int newCapacity = oldCapacity + (oldCapacity >> 1);

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);

}

这个方法就是拷贝数组的，这个方法就算到调用的是Arrays.copyOf(elementData, newCapacity)，而这个方法的最底层是调用的System.arraycopy()，就是把创建一个新的数组，然后把原来数组中所有的内容都拷贝到新数组中去！

删除的方法，也是和增加的方法大同小异，所以就不说了。

所以说，ArrayList集合查询快，增删慢，就是因为他的底层都是数组操作，数组操作增加和删除的时候，都会创建新的数组，所以速度就会慢很多。

在我们使用List集合的时候，如果初始化数据过大，那么可以在new的时候，直接把长度传过去，这样可以提升一点效率。

LinkedList集合

java.util.LinkedList集合数据存储的结构是链表结构，方便元素的添加，删除。

链表结构，因为是链表结构，所以数据的存储不是在一个边续的内存里面，所以链表结构添加和删除元素的时候，是效率是非常高的。

简单说一下，LinkedList中的链表实现：

在集合中有一个内部娄：

private static class Node {

E item;

Node next;

Node prev;

Node(Node prev, E element, Node next) {

this.item = element;

this.next = next;

this.prev = prev;

}

}

链表其实就是这个Node表，所有的数组都是存到Node里面，item代表的就是当前元素，next就代表着下一个元素的地址，prev就代表着前一个元素的地址。

所以说，LinkedList集合添加和删除容易，就是因为在添加或删除元素的时候，只用new一个对象，然后修一个或两个对象里面的参数就行了。

具体的实现就不说了，但是很简单的。有兴趣的可以去网上找一下。

LinkedList的简单使用

因为是链表结构，所以第一个数据和最后一个数据是最特殊的，所以集合中有在量操作第一个和最后一个数据的方法，所以在这里，我就不说了，这些方法都可以查看API文档，我在这里说两个特殊一点的方法：

public void push(E e) 在列表的头部插入一个元素。

public E pop(); 移除列表里面的第一个元素。

准备数据：

LinkedList link = new LinkedList<>();

link.add("a");

link.add("b");

link.add("c");

link.add("d");

link.add("e");

System.out.println(link); //[a, b, c, d, e]

public void push(E e) 在列表的头部插入一个元素。

link.push("*");

System.out.println(link); //[*, a, b, c, d, e]

public E pop(); 移除列表里面的第一个元素。

String pop = link.pop();

System.out.println(pop); //a

System.out.println(link); //[b, c, d, e]

上面所说的两个LIst集合的实现类，都是在日常开发中经常使用到的，但是这两个实现类都不是同步，这两个实现类都是线程不安全的，所以涉及多线程的时候，要小心使用。

细节决定成败!

个人愚见，如有不对，恳请扶正!