Writer:BYSocket(泥沙砖瓦浆木匠)

微博:BYSocket

豆瓣:BYSocket

继续上一篇的容器文章认识容器,泥瓦匠慢慢带你们走进List的容器解说。今天泥瓦匠想说说 ArrayList 、LinkedList和Vector比较。

一、List回顾

序列(List),有序的Collection,正如它的名字一样,是一个有序的元素列表。确切的讲,列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2,并且如果列表本身允许 null 元素的话,通常它们允许多个 null 元素。实现List的有:ArrayList、LinkedList、Vector、Stack等。值得一提的是,Vector在JDK1.1的时候就有了,而List在JDK1.2的时候出现,待会我们会聊到ArrayList和Vector的区别。

二、ArrayList vs. Vector

ArrayList是一个可调整大小的数组实现的序列。随着元素增加,其大小会动态的增加。此类在Iterator或ListIterator迭代中,调用容器自身的remove和add方法进行修改,会抛出ConcurrentModificationException并发修改异常。下面演示下相关ArrayList例子。

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
@SuppressWarnings({ "rawtypes", "unchecked" })
    public static void listMethods()
    {
         
        List a1 = new ArrayList<String>();
         
        a1.add("List01");
        a1.add("List03");
        a1.add("List04");
        System.out.print("原来集合:\n\t"+a1+"\n");
         
        a1.add(1,"List02");
        System.out.print("指定角标1插入:\n\t"+a1+"\n");
         
        a1.remove(2);
        System.out.print("指定角标2删除:\n\t"+a1+"\n");
         
        System.out.print("指定角标2查询:\n\t"+a1.get(2)+"\n");
         
        Iterator i1 = a1.iterator();
        System.out.println("用迭代器查询全部元素:");
        while (i1.hasNext())
        {
            System.out.print(i1.next()+",");
        }
    }

可以从控制台可以看出:

1
2
3
4
5
6
7
8
9
10
原来集合:
    [List01, List03, List04]
指定角标1插入:
    [List01, List02, List03, List04]
指定角标2删除:
    [List01, List02, List04]
指定角标2查询:
    List04
用迭代器查询全部元素:
List01,List02,List04

在上面我们可以根据角标来增加(add)、删除(remove)、获取(get)列表里面元素。ArrayList提供了Iterator迭代器来遍历序列。值得注意的是,迭代器的就相当于一个指针指向角标,next()方法就相当于指针往后移一位。所以切记,用迭代器中一次循环用一次next()。

下面演示下在ConcurrentModificationException的出现,及处理方案。泥瓦匠用Iterator演示这个异常的出现:

@SuppressWarnings({ “unchecked”, “rawtypes” })
    public static void iteratorTest()
    {
        List a1 = new ArrayList<String>();
        
        a1.add(“List01″);
        a1.add(“List02″);
        a1.add(“List04″);
        a1.add(“List05″);
        
        Iterator i1 = a1.iterator();
        while (i1.hasNext())
        {
            Object obj = i1.next();
            if (obj.equals(“List02″))
                a1.add(“List03″);
        }
        
        System.out.print(“集合:\n\t”+a1+”\n”);
    }
运行,我们可以在控制台看到:

怎么解决的,先看清楚这个问题。问题描述很清楚,在创建迭代器之后,除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改,否则在任何时间以任何方式对列表进行修改,迭代器都会抛出ConcurrentModificationException

因此我们应该这样修改代码,用ListIterator迭代器提供方法,:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@SuppressWarnings({ "unchecked", "rawtypes" })
    public static void listIterator()
    {
         
        List a1 = new ArrayList<String>();
         
        a1.add("List01");
        a1.add("List");
        a1.add("List03");
        a1.add("List04");
         
        ListIterator l1 = a1.listIterator();
        while (l1.hasNext())
        {
            Object obj = l1.next();
            if (obj.equals("List"))
            {
                l1.remove();
                l1.add("List02");
            }
        }
        System.out.print("集合:\n\t"+a1+"\n");
    }

运行下,我们可以看到:

1
2
集合:
    [List01, List02, List03, List04]

这样,我们成功解决了这个并发修改异常。把其中‘List’元素删除,新增了一个‘List02’的元素。

Vector非常类似ArrayList。早在JDK1.1的时候就出现了,以前没有所谓的List接口,现在此类被改进为实现List接口。但与新的Collection不同的是,Vector是同步的。泥瓦匠想说的是Vector,在像查询的性能上会比ArrayList开销大。下面演示下Vector的基本例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@SuppressWarnings({ "unchecked", "rawtypes" })
    public static void vectorMethods()
    {
        Vector v1 = new Vector<String>();
         
        v1.add("Vector001");
        v1.add("Vector002");
        v1.add("Vector003");
        v1.add("Vector004");
        v1.add("Vector005");
         
        Enumeration e1 =v1.elements();
        while (e1.hasMoreElements())
        {
            Object object = e1.nextElement();
            System.out.println(object);
        }
    }

从方法上看几乎没差别,同样注意的是:此接口的功能与 Iterator 接口的功能是重复的。此外,Iterator 接口添加了一个可选的移除操作,并使用较短的方法名。新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。

三、LinkedList及其与ArrayList性能比

LinkedList与ArrayList一样实现List接口,LinkedList是List接口链表的实现。基于链表实现的方式使得LinkedList在插入和删除时更优于ArrayList,而随机访问则比ArrayList逊色些。LinkedList实现所有可选的列表操作,并允许所有的元素包括null。除了实现 List 接口外,LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列

LinkedList和ArrayList的方法时间复杂度总结如下图所示。

表中,添加add()指添加元素的方法,remove()是指除去(int index)角标。ArrayList具有O(N)的任意指数时间复杂度的添加/删除,但O(1)的操作列表的末尾。链表的O(n)的任意指数时间复杂度的添加/删除,但O(1)操作端/列表的开始。

泥瓦匠用代码验证下这个结论:

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public static void testPerBtwnArlAndLkl()
    {
        ArrayList<Integer> arrayList   = new ArrayList<Integer>();
        LinkedList<Integer> linkedList = new LinkedList<Integer>();
                 
        // ArrayList add
        long startTime  = System.nanoTime();
        long endTime;
        long duration;
          
        for (int i = 0; i < 100000; i++) {
            arrayList.add(i);
        }
        endTime System.nanoTime();
        duration endTime - startTime;
        System.out.println("ArrayList add:  " + duration);
          
        // LinkedList add
        startTime System.nanoTime();
          
        for (int i 0; i < 100000; i++) {
            linkedList.add(i);
        }
        endTime System.nanoTime();
        duration endTime - startTime;
        System.out.println("LinkedList add: " + duration);
          
        // ArrayList get
        startTime System.nanoTime();
          
        for (int i 0; i < 10000; i++) {
            arrayList.get(i);
        }
        endTime System.nanoTime();
        duration endTime - startTime;
        System.out.println("ArrayList get:  " + duration);
          
        // LinkedList get
        startTime System.nanoTime();
          
        for (int i 0; i < 10000; i++) {
            linkedList.get(i);
        }
        endTime System.nanoTime();
        duration endTime - startTime;
        System.out.println("LinkedList get: " + duration);
          
        // ArrayList remove
        startTime System.nanoTime();
          
        for (int i 9999; i >=0; i--) {
            arrayList.remove(i);
        }
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("ArrayList remove:  " + duration);
          
        // LinkedList remove
        startTime = System.nanoTime();
          
        for (int i = 9999; i >=0; i--) {
            linkedList.remove(i);
        }
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("LinkedList remove: " + duration);
    }

控制台输出如下:

1
2
3
4
5
6
ArrayList add:  16904776
LinkedList add: 12015418
ArrayList get:  1304593
LinkedList get: 108950741
ArrayList remove:  787388127
LinkedList remove: 128145950

对比下的话,其性能差距很明显。LinkedList在添加和删除中性能快,但在获取中性能差。从复杂度和测试结果,我们应该懂得平时在添加或者删除操作频繁的地方,选择LinkedList时考虑:

1、没有大量的元素的随机访问

2、添加/删除操作

自然我下面用LinedList实现一个数据结构–栈。泥瓦匠留给大家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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package com.sedion.bysocket.collection;
import java.util.LinkedList;
 
/**
 * 用LinkedList实现栈
 * 队列和栈区别:队列先进先出,栈先进后出。
 */
public class Stack<T>
{
    private LinkedList<T> storage = new LinkedList<T>();
 
    /** 入栈 */
    public void push(T v)
    {
        storage.addFirst(v);
    }
 
    /** 出栈,但不删除 */
    public T peek()
    {
        return storage.getFirst();
    }
 
    /** 出栈,删除 */
    public T pop()
    {
        return storage.removeFirst();
    }
 
    /** 栈是否为空 */
    public boolean empty()
    {
        return storage.isEmpty();
    }
 
    /** 输出栈元素 */
    public String toString()
    {
        return storage.toString();
    }
     
    public static void main(String[] args)
    {
        Stack stack=new Stack<String>();
        stack.push("a");
        stack.push("b");
        stack.push("c");
        System.out.println(stack.toString());
        Object obj=stack.peek();
        System.out.println(obj+"--"+stack.toString());
        obj=stack.pop();
        System.out.println(obj+"--"+stack.toString());
        System.out.println(stack.empty());
    }
}

四、总结

泥瓦匠总结如下:

Vector和ArrayList

1、vector是线程同步的,所以它也是线程安全的,而arraylist是线程异步的,是不安全的。

2、记住并发修改异常 java.util.ConcurrentModificationException ,优先考虑ArrayList,除非你在使用多线程所需。

Aarraylist和Linkedlist
1、对于随机访问get和set,ArrayList觉得优于LinkedList,LinkedList要移动指针。
2、于新增和删除操作add和remove,LinedList比较占优势,ArrayList要移动数据。
3、单条数据插入或删除,ArrayList的速度反而优于LinkedList.若是批量随机的插入删除数据,LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据,要移动插入点及之后的所有数据。

Java 容器 & 泛型:二、ArrayList 、LinkedList和Vector比较的更多相关文章

  1. Java 容器 & 泛型:五、HashMap 和 TreeMap的自白

    Writer:BYSocket(泥沙砖瓦浆木匠) 微博:BYSocket 豆瓣:BYSocket Java 容器的文章这次应该是最后一篇了:Java 容器 系列. 今天泥瓦匠聊下 Maps. 一.Ma ...

  2. Javase之集合体系(2)之List及其子类ArrayList,LinkedList与Vector及其迭代器知识

    集合体系之List及其子类ArrayList,LinkedList与Vector及其迭代器知识 List(接口) 特点:有序(存储与取出顺序相同),可重复 List子类特点: ​ ArrayList: ...

  3. Java 容器 & 泛型:一、认识容器

    Writer:BYSocket(泥沙砖瓦浆木匠) 微博:BYSocket 豆瓣:BYSocket 容器是Java语言学习中重要的一部分.泥瓦匠我的感觉是刚开始挺难学的,但等你熟悉它,接触多了,也就“顺 ...

  4. Java 容器 & 泛型:三、HashSet,TreeSet 和 LinkedHashSet比较

    Writer:BYSocket(泥沙砖瓦浆木匠) 微博:BYSocket 豆瓣:BYSocket 上一篇总结了下ArrayList .LinkedList和Vector比较,今天泥瓦匠总结下Hash ...

  5. 安卓 ArrayList,LinkedList,HashSet,Vector,TreeSet的区别和使用

    java的集合就那么几种 总体为:List,Set,Map (都是接口由其子类去实现具体的方法) ArrayList,LinkedList,Vector都属于List List:元素是有顺序的,元素可 ...

  6. Java——集合框架之ArrayList,LinkedList,迭代器Iterator

    概述--集合框架 Java语言的设计者对常用的数据结构和算法做了一些规范(接口)和实现(具体实现接口的类).所有抽象出来的数据结构和操作(算法)统称为Java集合框架(Java Collection ...

  7. java类集框架(ArrayList,LinkedList,Vector区别)

    主要分两个接口:collection和Map 主要分三类:集合(set).列表(List).映射(Map)1.集合:没有重复对象,没有特定排序方式2.列表:对象按索引位置排序,可以有重复对象3.映射: ...

  8. Java 容器 & 泛型:六、容器讲到为什么要使用泛型

    Writer:BYSocket(泥沙砖瓦浆木匠) 微博:BYSocket 豆瓣:BYSocket ArrayList是集合类中无处不在的,泛型也是,泛型对集合类尤其有用.但是为啥要使用泛型?理解好了这 ...

  9. 【Java集合系列二】LinkedList解析

    一.简介 1.LinkedList继承关系 2.LinkedList底层实现 LinkedList使用双向链表存储数据,所以没有默认的容量,也不会有扩容一说.只有两个指针,永远指向链表的两端:firs ...

随机推荐

  1. jmeter本身的一个bug记录

    1.使用jmeter测http接口 2.断言接口返回的内容是否包含某串文本 3.结果:总是返回断言失败,即使接口返回的内容包含了该文本 接口返回的值为: {"code":" ...

  2. 受限filterbanks

    2.Related works to filterbank learning 虽然DNN-HMM模型的性能比GMM-HMM模型相比,具有很大的优势,但是训练集和测试集之间的失配问题,也使得DNN-HM ...

  3. 1003 Emergency Dijkstra

    这题做的心很累,我用的还是 1018的思路做的,但是 使用dfs 求最大人数对于某些有问题(现在也不知道错哪了), 看了别人的代码后才发现,其实完全不用这么麻烦,只需设置一个点的权重,一遍DJ(自创简 ...

  4. python之路(九)-函数装饰器

    装饰器 某公司的基础业务平台如下: def f1(): print('这是f1业务平台') def f2(): print('这是f2业务平台') def f3(): print('这是f3业务平台' ...

  5. 【收藏】JS获取鼠标的X,Y坐标位置

    JS的方法: <html> <head> <meta http-equiv="Content-Type" content="text/htm ...

  6. python opencv 处理文件、摄像头、图形化界面

    转换成RGB import cv2 import numpy as ny img = ny.zeros( ( 3 , 3 ),ny.float32) img=cv2.cvtColor(img,cv2. ...

  7. IOS 模拟器多开集成测试和那些坑

    #### 前言公司一直没有IOS自动化,搞得很尴尬,个人感觉搞自动测试的,不搞IOS自动化,就像金X,少了重要一点啊.也向领导申请过不止一次,总只都各种原因没有分配机器,不了了之.某天线上IOS出bu ...

  8. CSS中清除浮动的作用以及如何清除浮动

    1.什么是浮动,浮动的作用 “浮动”从字面上来理解就是“悬浮移动.非固定”的意思.块级元素(div.table.span…)是以垂直方向排列,而在前端界面中往往要使用水平布局块级元素使界面更美观.这就 ...

  9. JS canvas 画板 撤销

    <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content ...

  10. 在已有数据的表中添加id字段并且自增

    各位大牛,小弟在开发过程中,遇到了这样一个问题,由于新功能的增加需要使原有的一张表的结构作出调整,需要添加一个id主键字段,但是因为表里有很多数据了,所以,怎样才能添加这个字段,并且使原有的数据也能够 ...