List集合

作者: 江湖非良人 | 来源:发表于2019-08-05 15:52 被阅读8次

List接口简介

List是Collection的子接口，其最大的特点是允许保存有重复元素数据，该接口的定义如下：

public interface List<E> extends Collection<E>

但是需要清楚的是List子接口对于Collection接口进行了方法扩充。

获取指定索引上的数据：E get(int index)
修改指定索引上的数据：E set(int index, E element)
返回ListIterator接口对象：ListIterator<E> listIterator()

但是List本身依然是一个接口，接口要想使用则一定要子类来完成定义，在List子接口中有三个常用子类：ArrayList、Vector、LinkedList。

List子接口

从JDK1.9开始，List接口中追加有一些static方法，以方便用户的处理。
范例：观察List的静态方法

import java.util.Arrays;
import java.util.List;
public class JavaAPIDemo {
    public static void main(String[] args) throws Exception {
        List<String> all = List.of("hello", "world", "你好", "MLDN", "饿了么？");
        Object[] result = all.toArray();
        System.out.println(Arrays.toString(result));//[hello, world, 你好, MLDN, 饿了么？]
    }
}

这些操作方法并不是List的传统用法，是在JDK1.9后添加的新功能。

ArrayList子类

ArrayList是List子接口中使用最多的一个子类，但是这个子类在使用时也是有前提要求的，所以本次来对这个类的相关定义以及源代码组成进行分析，在Java里面ArrayList类的定义如下：

public class ArrayList<E> extends AbstractList<E> mplements List<E>, RandomAccess, Cloneable, Serializable

ArrayList的继承结构

范例：使用ArrayList实例化List父接口

import java.util.ArrayList;
import java.util.List;
public class JavaAPIDemo {
    public static void main(String[] args) throws Exception {
        List<String> all=new ArrayList();//为List父接口进行实例化
        all.add("hello");
        all.add("hello");//重复数据
        all.add("wolrd");
        all.add("MLDN");
        System.out.println(all);//[hello, hello, wolrd, MLDN]
    }
}

通过本程序可以发现List的存储特征：

保存的顺序就是其存储的顺序；

List集合里面允许存在有重复数据；

在以上的程序中虽然实现了集合的输出，但是这种输出的操作时直接利用了每一个类提供的toString()方法实现的，为了方便的进行输出处理，在JDK1.8后Iterable定义有一个forEach方法，方法定义如下：

输出支持：default void forEach(Consumer<? super T> action)

范例：利用forEach()方法进行输出（非标准输出）

import java.util.ArrayList;
import java.util.List;
public class JavaAPIDemo {
    public static void main(String[] args) throws Exception {
        List<String> all = new ArrayList();//为List父接口进行实例化
        all.add("hello");
        all.add("hello");//重复数据
        all.add("wolrd");
        all.add("MLDN");
        all.forEach((s -> {
            System.out.print(s + "、");
        }));
        //hello、hello、wolrd、MLDN、
    }
}

需要注意的是，此种输出并不是正常开发情况下要考虑的操作形式。

范例：观察List集合的其它操作方法

import java.util.ArrayList;
import java.util.List;
public class JavaAPIDemo {
    public static void main(String[] args) throws Exception {
        List<String> all = new ArrayList();//为List父接口进行实例化
        System.out.printf("集合是否为空？%s、集合元素个数：%s\n",all.isEmpty(),all.size());//集合是否为空？true、集合元素个数：0    
        //集合是否为空？true、集合元素个数：0
        all.add("hello");
        all.add("hello");//重复数据
        all.add("wolrd");
        all.add("MLDN");
        all.forEach((s -> {
            System.out.print(s + "、");
        }));
        //hello、hello、wolrd、MLDN、
    }
}

如果以方法的功能为例，那么ArrayList中操作支持与之前编写的链表形式是非常相似的，但是它并不是使用链表来实现的，通过类名称实际上就已经可以清楚的发现了，ArrayList应该封装的是一个数组。
ArrayList构造：public ArrayList()

/**
 * JDK1.8：Constructs an empty list with an initial capacity of ten.
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

ArrayList构造：public ArrayList(int initialCapacity)

transient Object[] 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);
        }
    }

通过有参构造方法可以发现，在ArrayList中所包含的数据实际上就是一个对象数组。在进行数据追加时发现ArrayList集合中保存的对象数组长度不够时，那么会将会开辟新的数组，同时将原始的旧数组内容拷贝到新数组中。
而后数组的开辟操作：

private int newCapacity(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity <= 0) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return minCapacity;
    }
    return (newCapacity - MAX_ARRAY_SIZE <= 0) ? newCapacity  : hugeCapacity(minCapacity);
}

如果在实例化ArrayList类对象时没有传递初始化额长度，则默认情况下会使用空数组，但是如果在进行数据增加时，发现数组容量不够，则会判断当前的增长容量与默认的容量的大小，使用较大的一个数值进行新的数组开辟，所以可以得出结论：
JDK1.7+：ArrayList默认的构造只会使用默认的空数组，使用时才会开辟数组，默认的开辟长度为10，自动增长倍数为1.5倍：oldCapacity + (oldCapacity >> 1)

//JDK1.7
public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
}
public ArrayList() {
    super();
    this.elementData = EMPTY_ELEMENTDATA;
}
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);
}

JDK1.6及以前：ArrayList默认的构造实际上就会默认开辟大小为10的数组，自动增长倍数为（1.5倍+1）：(oldCapacity * 3)/2 + 1

// ArrayList带容量大小的构造函数。
public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
    // 新建一个数组
    this.elementData = new Object[initialCapacity];
}
// ArrayList构造函数。默认容量是10。
public ArrayList() {
    this(10);
}
public void ensureCapacity(int minCapacity) {
    //对于modCount变量，我们后面会给出解释
    modCount++;
    // 当前数组的长度
    int oldCapacity = elementData.length;
    // 最小需要的容量大于当前数组的长度则进行扩容
    if (minCapacity > oldCapacity) {
        Object oldData[] = elementData;
        // 新扩容的数组长度为旧容量的1.5倍+1
        int newCapacity = (oldCapacity * 3) / 2 + 1;
        // 如果新扩容的数组长度还是比最小需要的容量小，则以最小需要的容量为长度进行扩容
        if (newCapacity < minCapacity)
            newCapacity = minCapacity;
        // minCapacity is usually close to size, so this is a win:
        // 进行数据拷贝，Arrays.copyOf底层实现是System.arrayCopy()
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
}

在JDK1.7+中，当ArrayList之中保存的容量不足时会采用1.5倍的方式进行增长，原始长度为0，扩容：（0->10->15->22->33->49->73->……）。

ArrayList扩容采用的是将原数组的内容拷贝到扩容后的新数组中，所以在使用ArrayList类或其子类时一定要估算实际存储的数据量大小，一般采用有参构造进行创建，以避免ArrayList重复扩容影响性能和产生过多的垃圾数组空间。

ArrayList保存自定义类

通过之前的分析已经清楚了ArrayList子类的实现原理以及List核心操作，但是在测试的时候使用的是系统提供的String类，这是一个设计比较完善的类，而对于类集而言也可以实现自定义类对象的保存。
范例：实现自定义类对象保存

import java.util.ArrayList;
import java.util.List;
@lombok.Data//会自动生成getter、setter、equals、hashCode、toString
@lombok.NoArgsConstructor//会自动生成无参构造
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return String.format("姓名：%s、年龄：%s", name, age);
    }
}
public class JavaAPIDemo {
    public static void main(String[] args) throws Exception {
        List<Person> all = new ArrayList();
        all.add(new Person("张三", 30));
        all.add(new Person("李四", 28));
        all.add(new Person("王五", 32));
        System.out.println(all.contains(new Person("王五", 32)));
        all.remove(new Person("王五", 32));
        all.forEach(System.out::println);//方法引用代替了消费型的接口
        /**
         * true
         * 姓名：张三、年龄：30
         * 姓名：李四、年龄：28
         */
    }
}

在使用List保存自定义对象时，如果需要使用到contains()、remove()方法进行查询或删除处理时一定要保证类中已经覆写了equals()方法。

LinkedLIst子类

在List接口中还有一个比较常用的子类：LinkedList，这个类通过名称就可以发现其特点：基于链表的实现。那么首先观察一下LinkedList的定义：

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable

LinkedLIst类的继承关系如下

范例：使用LinkedList实现集合操作

import java.util.LinkedList;
import java.util.List;
public class JavaAPIDemo {
    public static void main(String[] args) throws Exception {
        List<String> all = new LinkedList<>();
        System.out.printf("集合是否为空？%s、集合元素个数：%s\n",all.isEmpty(),all.size());
        all.add("hello");
        all.add("hello");
        all.add("wolrd");
        all.add("MLDN");
        all.forEach(System.out::println);
    }
}

如果现在只是观察程序的功能会发现和ArrayList使用时完全一样的，但是其内部实现机制是完全不同的，首先观察LinkedList构造方法中并没有提供像ArrayList那样的初始化大小的方法，而只是提供了无参构造处理：“public LinkedList()”。随后观察add()方法的具体实现。

public boolean add(E e) {
    linkLast(e);
    return true;
}

在之前编写自定义链表时，是判断了传入数据是否为null，如果为null则不进行保存，但在LinkedList中并没有做这样的处理，而是所有的数据都可以保存,而后此方法调用了linkLast()方法（再最后一个节点后追加）。

void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

在LinkedList类中保存的数据都是利用Node节点进行的封装处理，同时为了提高程序执行性能，每一次都会保存上一个追加的节点（最后一个节点），就可以在增加数据的时候避免递归处理，在增加数据时要进行数据保存个数的追加。

通过上面的分析，可以发现LinkedList封装的就是一个链表实现。

Vector子类

Vector是一个原始古老的程序类，这个类是在JDK1.0时提供的。到了JDk1.2时由于许多开发者已经习惯于使用Vector，并且许多系统类也是Vector实现的，考虑到请使用的广泛性，所以类集框架将其保留了下来，并让其多实现了一个List接口，观察Vector的结构定义：

public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

继承结构与ArrayList是相同的，所以来讲这个类继承结构如下。

Vector

范例：Vector类使用

import java.util.List;
import java.util.Vector;
public class JavaAPIDemo {
    public static void main(String[] args) throws Exception {
        List<String> all = new Vector();
        System.out.printf("集合是否为空？%s、集合元素个数：%s\n",all.isEmpty(),all.size());
        all.add("hello");
        all.add("hello");
        all.add("wolrd");
        all.add("MLDN");
        all.remove("hello");
        all.add(null);
        all.forEach(System.out::println);
    }
}

下面可以进一步的观察Vector类实现：

public Vector() {
    this(10);
}
public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}
public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

Vector类如果使用的是无参构造方法，则一定会默认开辟一个10个长度的数组，而后其余的实现操作与ArrayList是相同的。通过源代码分析可以发现，Vector类中的操作方法采用的都是synchronized同步处理，而ArrayList并没有进行同步处理，所以Vector类中的方法在多线程访问的时候属于线程安全的，但是性能不如ArrayList高。

List集合

List接口简介

ArrayList子类

ArrayList保存自定义类

LinkedLIst子类

Vector子类

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java高级编程

java基础知识