List集合

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高。

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 202,529评论 5赞 475
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,015评论 2赞 379
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 149,409评论 0赞 335
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,385评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,387评论 5赞 364
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,466评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,880评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,528评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,727评论 1赞 295
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,528评论 2赞 319
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,602评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,302评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,873评论 3赞 306
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,890评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,132评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,777评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,310评论 2赞 342

推荐阅读更多精彩内容