「 深刻浅出 」集合List

时间  2019-12-07
标签 深刻 集合 list 栏目 快乐工作 繁體版
原文   原文链接

第一篇文章 「 深刻浅出 」java集合Collection和Map 主要讲了对集合的总体介绍,本篇文章主要讲List相对于Collection新增的一些重要功能以及其重要子类ArrayList、LinkedList、Vectorjava

1、List集合

关于List集合的介绍与方法,可参考第一篇文章 「 深刻浅出 」java集合Collection和Mapnode

迭代方法ListIterator

相对于其它集合,List集合添加了一种新的迭代方法ListIterator
ListIterator的方法以下:面试

image

ListIterator接口在Iterator接口基础上增长了以下方法：
boolean hasPrevious(): 若是以逆向遍历列表。若是迭代器有上一个元素，则返回 true。
E previous():返回迭代器的前一个元素。
void add(Object o):将指定的元素插入列表。
int nextIndex():下一个索引号
int previousIndex():上一个索引号
void set(E e):修改迭代器当前元素的值
void add(E e):在迭代器当前位置插入一个元素数组

ListIterator接口比Iterator接口多了两个功能:
1.ListIterator可在遍历过程当中新增和修改
2.ListIterator可逆向遍历安全

使用示例以下:数据结构

public class ListIteratorDemo {
    public static void main(String[] args) {
        // 建立列表
        List<Integer> list = new ArrayList<Integer>();
        // 向列表中增长10个元素
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        // 得到ListIterator对象
        ListIterator<Integer> it = list.listIterator();
        // 正序遍历修改与新增
        while (it.hasNext()) {
            Integer i = it.next();
            //修改元素值
            it.set(i+1);

            if(i == 5 ){
                //新增元素值
                it.add(55);
            }

            //! it.set(i+1);
            // 注意:若是修改的代码在这个位置会报错
            //set操做不能放在add操做以后
            // 这里不作解析,欲知详情,请看源码
        }

        System.out.println("正向遍历");
        //正向遍历
        for(Integer i:list){
            System.out.println(i+" ");
        }

        System.out.println("逆向遍历");
        //逆向遍历
        //通过上面迭代器it遍历后,迭代器it已到达最后一个节点
        while (it.hasPrevious()) {
            System.out.println(it.previous() + " ");
        }
    }
}

2、ArrayList和Vector

ArrayList和Vector很类似,因此就一块儿介绍了框架

ArrayList和Vector类都是基于数组实现的List类，因此ArrayList和Vector类封装了一个动态的、容许再分配的Object[]数组。ArrayList和Vector对象使用initalCapacity参数来设置该数组的长度，当向ArrayList和Vector中添加元素超过了该数组的长度时，它们的initalCapacity会自动增长。函数

下面咱们经过阅读JDK 1.8 ArrayList源码来了解ArrayList性能

无参构造函数

默认初始化为容量为10学习

   /**
     * Constructs an empty list with an initial capacity of ten。
       意思是：构造一个空数组，默认的容量为10
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

有参构造函数

建立指定容量的ArrayList

//动态Object数组，用来保存加入到ArrayList的元素
Object[] elementData;

//ArrayList的构造函数，传入参数为数组大小
public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
             //建立一个对应大小的数组对象
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            //传入数字为0，将elementData 指定为一个静态类型的空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

add方法

执行add方法时,先确保容量足够大,若容量不够,则会进行扩容；
扩容大小为原来的1.5倍(这个须要注意一下,面试常常考)

//添加元素e
public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    //将对应索引下的元素赋值为e：
    elementData[size++] = e;
    return true;
}
//获得最小扩容量
private void ensureCapacityInternal(int minCapacity) {
    //若是此时ArrayList是空数组,则将最小扩容大小设置为10：
    if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //判断是否须要扩容：
    ensureExplicitCapacity(minCapacity);
}
//判断是否须要扩容
private void ensureExplicitCapacity(int minCapacity) {
    //操做数+1
    modCount++;
    //判断最小扩容容量-数组大小是否大于0：
    if (minCapacity - elementData.length > 0)
        //扩容：
        grow(minCapacity);
}
//ArrayList动态扩容的核心方法:
private void grow(int minCapacity) {
    //获取现有数组大小：
    int oldCapacity = elementData.length;
    //位运算，获得新的数组容量大小，为原有的1.5倍：
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //若是新扩容的大小依旧小于传入的容量值，那么将传入的值设为新容器大小：
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;

    //若是新容器大小，大于ArrayList最大长度：
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        //计算出最大容量值：
        newCapacity = hugeCapacity(minCapacity);
    //数组复制：
    elementData = Arrays.copyOf(elementData, newCapacity);
}
//计算ArrayList最大容量：
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0)
        throw new OutOfMemoryError();
    //若是新的容量大于MAX_ARRAY_SIZE
    //将会调用hugeCapacity将int的最大值赋给newCapacity
    return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
}

remove方法

有如下两种删除方法:

  • remove(int index)是针对于索引来进行删除，不须要去遍历整个集合，效率更高；
  • remove(Object o)是针对于对象来进行删除，须要遍历整个集合进行equals()方法比对，因此效率较低；

不过，不管是哪一种形式的删除，最终都会调用System.arraycopy()方法进行数组复制操做，等同于移动数组位置,因此效率都会受到影响

//在ArrayList的移除index位置的元素
public E remove(int index) {
    //检查索引是否合法：不合法抛异常
    rangeCheck(index);
    //操做数+1：
    modCount++;
    //获取当前索引的value:
    E oldValue = elementData(index);
    //获取须要删除元素 到最后一个元素的长度，也就是删除元素后，后续元素移动的个数；
    int numMoved = size - index - 1;
    //若是移动元素个数大于0 ，也就是说删除的不是最后一个元素：
    if (numMoved > 0)
        // 将elementData数组index+1位置开始拷贝到elementData从index开始的空间
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    //size减1，并将最后一个元素置为null
    elementData[--size] = null;
    //返回被删除的元素：
    return oldValue;
}

//在ArrayList的移除对象为O的元素，不返回被删除的元素：
public boolean remove(Object o) {
    //若是o==null，则遍历集合，判断哪一个元素为null：
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                //快速删除，和前面的remove（index）同样的逻辑
                fastRemove(index);
                return true;
            }
    } else {
        //同理：
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

//快速删除：
private void fastRemove(int index) {
    //操做数+1
    modCount++;
    //获取须要删除元素 到最后一个元素的长度，也就是删除元素后，后续元素移动的个数；
    int numMoved = size - index - 1;
    //若是移动元素个数大于0 ，也就是说删除的不是最后一个元素：
    if (numMoved > 0)
        // 将elementData数组index+1位置开始拷贝到elementData从index开始的空间
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    //size减1，并将最后一个元素置为null
    elementData[--size] = null;
}

get方法

经过elementData()方法获取对应索引元素，在返回时候进行类型转换

//获取index位置的元素
public E get(int index) {
    //检查index是否合法：
    rangeCheck(index);
    //获取元素：
    return elementData(index);
}
//获取数组index位置的元素：返回时类型转换
E elementData(int index) {
    return (E) elementData[index];
}

set方法

经过elementData获取旧元素,再设置新元素值相应index位置,最后返回旧元素

//设置index位置的元素值了element，返回该位置的以前的值
public E set(int index, E element) {
    //检查index是否合法：判断index是否大于size
    rangeCheck(index);
    //获取该index原来的元素：
    E oldValue = elementData(index);
    //替换成新的元素：
    elementData[index] = element;
    //返回旧的元素：
    return oldValue;
}

调整容量大小

ArrayList还提供了两个额外的方法来调整其容量大小

  • void ensureCapacity(int minCapacity): 增长容量，以确保它至少可以容纳最小容量参数所指定的元素数。
  • void trimToSize():将容量调整为列表的当前大小。

Vector实现原理与ArrayList基本相同,可参考上述内容

ArrayList和Vector的主要区别

  • ArrayList是线程不安全的，Vector是线程安全的。
  • Vector的性能比ArrayList差。

LinkedList

LinkedList是基于双向链表实现的,内部存储主要是Node对象,该对象存储着元素值外,还指向上一节点和下一节点。
注意，由于LinkedList是基于链表实现的，没有容量的说法，因此更没有扩容之说

集合基础框架

public class LinkedList<E>
        extends AbstractSequentialList<E>
        implements List<E>, Deque<E>, Cloneable, java.io.Serializable {

    //LinkedList的元素个数：
    transient int size = 0;

    //LinkedList的头结点：Node内部类
    transient java.util.LinkedList.Node<E> first;

    //LinkedList尾结点：Node内部类
    transient java.util.LinkedList.Node<E> last;

    //空实现：头尾结点均为null，链表不存在
    public LinkedList() {
    }

    //调用添加方法：
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

    //节点的数据结构，包含先后节点的引用和当前节点
    private static class Node<E> {
        //结点元素：
        E item;
        //结点后指针
        java.util.LinkedList.Node<E> next;
        //结点前指针
        java.util.LinkedList.Node<E> prev;

        Node(java.util.LinkedList.Node<E> prev, E element, java.util.LinkedList.Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
}
LinkedList的经常使用方法只作简单介绍不贴源码,具体可自行看源码

add方法

LinkedList有两种添加方法

  • add(E e)链表最后添加一个元素
  • add(int index, E element)指定位置下添加一个元素；

LinedList添加元素主要分为如下步骤:
1.将添加的元素转换为LinkedList的Node对象节点；
2.增长该Node节点的先后引用，即该Node节点的prev、next属性，让其分别指上、下节点；
3.修改该Node节点的先后Node节点中pre/next属性，使其指向该节点。

image

remove方法

LinkedList的删除也提供了2种形式

  • remove(int index)直接经过索引删除元素
  • remove(Object o)经过对象删除元素,须要逐个遍历LinkedList的元素，重复元素只删除第一个：

删除后,须要修改上节点的next指向当前下一节点,下节点的prev指向当前上一节点

set方法

set(int index, E element)方法经过node(index)获取到相应的Node,再修改元素的值

get方法

这是咱们最经常使用的方法,其中核心方法node(int index),须要从头遍历或从后遍历找到相应Node节点
在经过node(int index)获取到对应节点后，返回节点中的item属性,该属性就是咱们所保存的元素。

//获取相应角标的元素：
public E get(int index) {
    //检查索引是否正确：
    checkElementIndex(index);
    //获取索引所属结点的 元素值：
    return node(index).item;
}
//获取对应角标所属于的结点：
java.util.LinkedList.Node<E> node(int index) {
    //位运算：若是位置索引小于列表长度的一半，则从头开始遍历；不然，从后开始遍历；
    if (index < (size >> 1)) {
        java.util.LinkedList.Node<E> x = first;
        //从头结点开始遍历：遍历的长度就是index的长度，获取对应的index的元素
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        //从集合尾结点遍历：
        java.util.LinkedList.Node<E> x = last;
        //一样道理：
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

ArrayList和LinkedList的主要区别

  • ArrayList基于数组实现的,LinkedList是基于双向链表实现的
  • ArrayList随机访问效率高，随机插入、随机删除效率低,须要移动元素位置
    LinkedList随机插入、随机删除效率高,随机访问效率低,因须要遍历链表

好叻,搞完,溜了溜了
下一期为<集合Set>,敬请期待

近期推荐:

好人？坏人？作真实的人
「 优质资源 」收藏!最新精选优质资源!
java当心机(5)| 浅谈类成员初始化顺序

更多精彩内容,可阅读原文

您的点赞、转发是对我最大的支持！

image

image

 THANDKS

  • End -

一个立志成大腿而天天努力奋斗的年轻人

伴学习伴成长，成长之路你并不孤单!

扫描二维码,关注公众号

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程