程序博客网 > 谷歌退出中国 知乎

ArrayList与LinkedList的简单比较

来源：互联网 发布：谷歌退出中国 知乎 编辑：程序博客网 时间：2024/06/08 03:08

在Java的List类型集合中，ArrayList和LinkedList大概是最常用到的2个了，细看了一下它们的实现，发现区别还是很大的，这里简单的列一下个人比较关心的区别。

类声明

ArrayList

1
2
3
4
public class ArrayList<E>
        extendsAbstractList<E>
        implementsList<E>, RandomAccess,
              Cloneable, java.io.Serializable

LinkedList

1
2
3
public class LinkedList<E>
    extendsAbstractSequentialList<E>
    implementsList<E>, Deque<E>, Cloneable, java.io.Serializable

二者的定义有些相近，除了都实现List、Cloneable和Serializable以外，继承的类不一样，以及接口有细微的区别。

1
public abstract class AbstractSequentialList<E> extends AbstractList<E>

AbstractSequentialList也继承自AbstractList，它只是多了一些实现的方法，参照API的doc，这个类用于按顺序访问的List的实现，所谓顺序访问（sequential access），可以与随即访问（random access）的ArrayList对比去理解。

Deque是一个双向（double ended queue）的Queue的接口，因为这个接口的区别，LinkedList里实现的方法要比ArrayList多一些。

元素存储方式

ArrayList：采用数组方式

1
private transient Object[] elementData;

LinedList：采用链表

1
2
3
4
5
6
7
8
9
10
11
12
13
private transient Entry<E> header = newEntry<E>(null,null, null);
 
private static class Entry<E> {
    E element;
    Entry<E> next;
    Entry<E> previous;
 
    Entry(E element, Entry<E> next, Entry<E> previous) {
        this.element = element;
        this.next = next;
        this.previous = previous;
    }
}

很好理解，从字面都可以理解出来，一个是数组实现，一个是链表实现。

元素添加

二者都有几个add()方法，

void add(E item)  向滚动列表的末尾添加指定的项。
void add(E item, int index)  向滚动列表中索引指示的位置添加指定的项。

先看看ArrayList的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void add(intindex, E element) {
    if(index > size || index < 0)
        thrownew IndexOutOfBoundsException(
        "Index: "+index+", Size: "+size);
 
    ensureCapacity(size+1); // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index +1,
             size - index);
    elementData[index] = element;
    size++;
    }
 
    publicboolean add(E e) {
    ensureCapacity(size +1);  // Increments modCount!!
    elementData[size++] = e;
    returntrue;
    }

对于add(E e)方法，非常简单，首先确保数组容量，然后直接赋值。在不需要扩充数组容量的情况下，效率非常高，而一旦需要数组扩容，代价就会上升：

1
2
3
4
5
6
7
8
9
10
11
12
public void ensureCapacity(intminCapacity) {
modCount++;
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
    Object oldData[] = elementData;
    intnewCapacity = (oldCapacity * 3)/2+ 1;
        if(newCapacity < minCapacity)
    newCapacity = minCapacity;
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
}
}

 因为它需要将已有的数组复制到新的数组里去。由此便可以想到一个提高add()效率的方法，在一开始尽量设定一个合理的数组容量，那么可以有效地减少数组的扩容和大量的复制。

对于add(int index, E e)，比起add(E e)，多一个可能的复制操作，这样才能保证在合理的位置插入新的元素。

LinkedList的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public boolean add(E e) {
addBefore(e, header);
    returntrue;
}
 
private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry =new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
modCount++;
return newEntry;
}
 
public void add(intindex, E element) {
    addBefore(element, (index==size ? header : entry(index)));
}
 
/**
 * Returns the indexed entry.
 */
privateEntry<E> entry(intindex) {
    if(index < 0 || index >= size)
        thrownew IndexOutOfBoundsException("Index: "+index+
                                            ", Size: "+size);
    Entry<E> e = header;
    if(index < (size >> 1)) {
        for(int i = 0; i <= index; i++)
            e = e.next;
    }else {
        for(int i = size; i > index; i--)
            e = e.previous;
    }
    returne;
}

粗略看起来要复杂一些，因为LinkedList同时还是一个Deque（JDK 1.6新添加的），所以它的实现也要兼顾双向队列。

下面从一个空的LinkedList开始，看看新的元素是如何添加进来的：

1
2
3
4
5
6
7
List<Integer> ints =new LinkedList<Integer>();
 
ints.add(1);
ints.add(2);
ints.add(3);
 
System.out.println(ints);//[1, 2, 3]

下面一步一步看List内部header和元素之间的关系：

  • 初始化： header.element = null; header.next=header.previous=header这里是一个环状的结构，自己的p和n指针都指向自己

  • 添加第一个元素“1”:header.element=null;header.next=1;header.previous=1;2个元素相互连接
  • 添加第二个元素“2” 这里很明显看来了，是一个环状结构
  • 添加第三个元素“3” 既然是一个环状，干脆用圆形显示好了，貌似画的不太圆。。。

这里总结一下两种的差别：

  • 对于元素的add()来说，LinkedList要比ArrayList要快一些，因为ArrayList可能需要额外的扩容操作，当然如果没有扩容，二者没有很大的差别
  • 对于元素的add(int, element),对于LinkedList来说，代价主要在遍历获取插入的位置的元素，而ArrayList的主要代价在于可能有额外的扩容和大量元素的移动
  • 小结：对于简单的元素添加，如果事先知道元素的个数，采用预置大小的ArrayList要更好，反之可以考虑LinkedList

元素移除

 ArrayList的元素移除：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public E remove(int index) {
RangeCheck(index);
 
modCount++;
E oldValue = (E) elementData[index];
 
int numMoved = size - index - 1;
if (numMoved > 0)
    System.arraycopy(elementData, index+1, elementData, index,
             numMoved);
elementData[--size] =null; // Let gc do its work
 
return oldValue;
}
 
public boolean remove(Object o) {
if (o == null) {
        for(int index = 0; index < size; index++)
    if(elementData[index] == null) {
        fastRemove(index);
        returntrue;
    }
} else{
    for(int index = 0; index < size; index++)
    if(o.equals(elementData[index])) {
        fastRemove(index);
        returntrue;
    }
    }
return false;
}
 
/*
 * Private remove method that skips bounds checking and does not
 * return the value removed.
 */
privatevoid fastRemove(intindex) {
    modCount++;
    intnumMoved = size - index - 1;
    if(numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] =null; // Let gc do its work
}

remove(int)和remove(Object)两种方式的返回值是有区别的哦

对于ArrayList来说，主要是的仍然会有元素的移动（这里就是数组的复制），虽然采用的是System的arrayCopy，但是本质上还是复制的思路。还有一点需要注意的是，remove(Object)对null值进行单独处理，这里也说明ArrayList是可以存取null的。

LinkedList元素移除：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public E remove(int index) {
     returnremove(entry(index));
 }
 
 /**
  * Returns the indexed entry.
  */
 privateEntry<E> entry(intindex) {
     if(index < 0 || index >= size)
         thrownew IndexOutOfBoundsException("Index: "+index+
                                             ", Size: "+size);
     Entry<E> e = header;
     if(index < (size >> 1)) {
         for(int i = 0; i <= index; i++)
             e = e.next;
     }else {
         for(int i = size; i > index; i--)
             e = e.previous;
     }
     returne;
 }
 
public boolean remove(Object o) {
     if(o==null) {
         for(Entry<E> e = header.next; e != header; e = e.next) {
             if(e.element==null) {
                 remove(e);
                 returntrue;
             }
         }
     }else {
         for(Entry<E> e = header.next; e != header; e = e.next) {
             if(o.equals(e.element)) {
                 remove(e);
                 returntrue;
             }
         }
     }
     returnfalse;
 }

这里的实现就是典型的链表删除的实现，其中有几个细节需要提一下：

  • modCount的处理，这个变量是用来存储List的修改的次数的，仅仅存储添加和删除的操作此书，用来在Iterator中判断List的状态和行为，防止不同步的修改，抛出ConcurrentModificationException
  • 通过索引访问元素的实现entry(int)，这里有一个小细节，
     if (index < (size >> 1)) {

如果元素的位置在前半段，那么通过next指针查找，否则通过previous指针查找。这一行代码有2个值得学习的地方，第一查找的优化，根据位置判断查找的方向，第二移位操作的运用。不得不佩服Bloch的编程功底。

小结一下：

删除操作中，LinkedList更有优势，一旦找到了删除的节点，它仅仅只是断开链接关系，并没有元素复制移动的行为，而ArrayList不可避免的又要进行元素的移动。

元素索引

indexOf(Object o)  回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

ArrayList的实现：

1
2
3
4
5
6
7
8
9
10
11
12
public int indexOf(Object o) {
if (o == null) {
    for(int i = 0; i < size; i++)
    if(elementData[i]==null)
        returni;
} else{
    for(int i = 0; i < size; i++)
    if(o.equals(elementData[i]))
        returni;
}
return -1;
}

LinkedList的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public int indexOf(Object o) {
    intindex = 0;
    if(o==null) {
        for(Entry e = header.next; e != header; e = e.next) {
            if(e.element==null)
                returnindex;
            index++;
        }
    }else {
        for(Entry e = header.next; e != header; e = e.next) {
            if(o.equals(e.element))
                returnindex;
            index++;
        }
    }
    return-1;
}

ArrayList：基于数组的遍历查找

LinkedList：基于链表的遍历查找

按照对象在内存中存储的顺序去考虑，数组的访问要比链接表快，因为对象都存储在一起。

遍历

基于以上的分析，可以得出，按照索引遍历，ArrayList是更好的选择，按照Iterator遍历，也许LinkedList会好一些。

反过来理解，如果是ArrayList，Iterator和index遍历都可以，如果是LinkedList，优先选择Iterator比较好。

其他

  • 对于ArrayList和LinkedList， size() isEmpty() 这些都是常量计算，代价很低
  • LinkedList实现了更多的方法，包括Queue，所以它也是一种队列
  • 对于少量得元素临时存储，优先考虑ArrayList
  • 频繁的添加和删除操作的时候，优先使用LinkedList
  • 频繁的按索引访问遍历，优先使用ArrayList
0 0
谷歌退出中国 知乎 谷歌退出中国 知乎
原创粉丝点击
热门IT博客
淘宝充值话费多久到账淘宝充值话费多久到账
微信网络出错轻击屏幕微信网络出错轻击屏幕
重庆正大软件职业学院
邀请函制作软件app
淘宝助理上传宝贝慢
互通商城 软件靠谱吗
积分记录软件
淘宝如何免费上传视频
pc网络射击游戏排行榜
艾克里里变脸视频软件
云计算的定义和特点
java中super()的用法
印度教知乎
淘宝买家秀大尺度云盘
fluent软件中文版
淘宝优惠券设置到首页
python爬虫教程pdf版
上海黄金交易所交易软件
linux man pdf
a frame three.js
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 康佳通行证忘了怎么办 九游申诉过多怎么办 oppo账号找回了怎么办 交易猫离线状态怎么办 icloud账号忘了怎么办 id密码忘记了怎么办 如果忘记qq密码怎么办 word工具栏隐藏了怎么办 工行账号被冻结怎么办 公司账号被冻结怎么办 哈罗单车冻结了怎么办 百度云账号违规怎么办 百度外卖被冻结怎么办 公司账户被冻结怎么办 app账号被限制怎么办 微信号限制登录怎么办 微信被永久封了怎么办 储蓄卡被冻结怎么办 百度云qq登录怎么办 微信发红包忘记密码怎么办 电脑wps表格打不开怎么办 电脑wps文字打不开怎么办 电脑的wps打不开怎么办 qq锁异地登录怎么办 手机玩游游戏太热怎么办 运动秀注册不了怎么办 应用卸载不掉怎么办 aweme卸载不掉怎么办 win10系统安装失败怎么办 英雄联盟自动更新失败怎么办 英雄联盟老出错怎么办? lol下载0kb怎么办 手机md5校验失败怎么办 王者荣耀占内存怎么办 信用卡被暂停使用怎么办 宝宝爱涂鸦怎么办呢 大良老板欠薪怎么办 投影仪流明很低怎么办 户外涂鸦没有墙怎么办 word突然未响应怎么办 文档突然未响应怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里