图片 2

java list用法示例详解

一、List回顾

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

1.集合 Collection

Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements)。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java
SDK不提供直接继承自Collection的类,Java
SDK提供的类都是继承自Collection的“子接口”如List和Set。(这段话是抄来的)
咳咳,大体的意思的就是Collection是所有List的国际标准了,那我们可以看一下Collection接口需要记一下的方法。

|–List:元素是有序的(怎么存的就怎么取出来,顺序不会乱),元素可以重复(角标1上有个3,角标2上也可以有个3)因为该集合体系有索引,

二、ArrayList vs. Vector

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

注意,此实现不是同步的。如果多个线程同时访问一个 ArrayList 实例,而其中至少一个线程从结构上修改了列表,那么它必须 保持外部同步。(结构上的修改是指任何添加或删除一个或多个元素的操作,或者显式调整底层数组的大小;仅仅设置元素的值不是结构上的修改。)这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象,则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成,以防止意外对列表进行不同步的访问:

List list =
Collections.synchronizedList(new ArrayList(…)); 

下面演示下相关ArrayList例子。

ArrayList基本方法代码:

@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()+",");
        }
    }

可以从控制台可以看出:

原来集合:
    [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”);
    }

运行,我们可以在控制台看到:

图片 1

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

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

@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");
    }

运行下,我们可以看到:

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

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

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

@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 接口。

iterator()

这个方法是用来遍历Collection中所有的元素的,用法如下:

Iterator it = collection.iterator();
while(it.hasNext()){
           Object ob = it.next();
}

这个可以遍历出一个Collection中所有的元素。

  • Iterator
    迭代器的作用就是遍历Collection,Iterator接口里面规定了三个方法,hasNext()、next()、remove()。看方法名就知道他们的功能了。
  • 在Iterator出现之前,也就是Java1.0版本的时候,遍历还是用的Enumeration这个枚举类,后来Iterator出来之后就取代了Enumeration。
  • Iterator支持fail-fast机制,直白的理解就是快速错误,就是相当于一种报错机制,当遍历的集合发生了结构性的修改的时候就会发生fail-fast.而真正实现检测结构性修改的原因就是在集合中增加一个modcount成员变量,当每次对集合进行add或者remove的时候我们就进行modcount++操作。

|–
ArrayList:底层的数据结构使用的是数组结构(数组长度是可变的百分之五十延长)(特点是查询很快,但增删较慢)线程不同步

三、LinkedList及其与ArrayList性能比

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

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

图片 2

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

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

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);
    }

控制台输出如下:

ArrayList add:  16904776
LinkedList add: 12015418
ArrayList get:  1304593
LinkedList get: 108950741
ArrayList remove:  787388127
LinkedList remove: 128145950

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

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

2、添加/删除操作

自然我下面用LinedList实现一个数据结构–栈。泥瓦匠留给大家LinkedList的一些方法自己消化下。

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());
    }
}
List接口

List接口是有序的Collection接口的实现。此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,类似于Java的数组。
顺序是 List 重要的特性;它可保证元素按照规定的顺序排列。
List 为 Collection 添加了大量方法,以便我们在 List
中部插入和删除元素(只推荐对 LinkedList 这样做)。List 也会生成一个
ListIterator(列表反复器),利用它可在一个列表里朝两个方向遍历,同时插入和删除位于列表中部的元素(同样地,只建议对
LinkedList 这样做)
ArrayList 由一个数组后推得到的
List。作为一个常规用途的对象容器使用,用于替换原先的
Vector。允许我们快速访问元素,但在从列表中部插入和删除元素时,速度却嫌稍慢。一般只应该用
ListIterator 对一个 ArrayList
进行向前和向后遍历,不要用它删除和插入元素;与 LinkedList
相比,它的效率要低许多
LinkedList
提供优化的顺序访问性能,同时可以高效率地在列表中部进行插入和删除操作。但在进行随机访问时,速度却相当慢,此时应换用
ArrayList。也提供了
addFirst(),addLast(),getFirst(),getLast(),removeFirst()以及
removeLast()
(未在任何接口或基础类中定义),以便将其作为一个规格、队列以及一个双向队列使用

  • LinkedList
    LinkedList实现了List接口,允许null元素。此外LinkedList提供额外的get,remove,insert方法在
    LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈(stack),队列(queue)或双向队列(deque)。
      注意LinkedList没有同步方法。如果多个线程同时访问一个List,则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List:
    List list = Collections.synchronizedList(newLinkedList(…));

  • ArrayList
    ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。  每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法并没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。  和LinkedList一样,ArrayList也是非同步的(unsynchronized)。

  • Vector
    Vector非常类似ArrayList,但是Vector是同步的。由Vector创建的Iterator,虽然和
    ArrayList创建的Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了
    Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出
    ConcurrentModificationException,因此必须捕获该异常。
    Stack
    Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop
    方法,还有peek方法得到栈顶的元素,empty方法堆栈是否为空,search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

  • Tips
    需要快速插入,删除元素,应该使用LinkedList,如果需要快速随机访问元素,应该使用ArrayList。
    如果程序在单线程环境中,或者访问仅仅在一个线程中进行,考虑非同步的类,其效率较高,如果多个线程可能同时操作一个类,应该使用同步的类。尽量返回接口而非实际的类型,如返回List而非ArrayList,这样如果以后需要将ArrayList换成LinkedList时,代码不用改变。
    arraylist和linkedlist

  1. ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。
  2. 对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针
  3. 对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据。
    这一点要看实际情况的。若只对单条数据插入或删除,ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据,LinkedList的速度大大优于ArrayList.
    因为ArrayList每插入一条数据,要移动插入点及之后的所有数据。

Vector和ArrayList

  • vector是线程同步的,所以它也是线程安全的,而arraylist是线程异步的,是不安全的。如果不考虑到线程的安全因素,一般用arraylist效率比较高。
  1. 如果集合中的元素的数目大于目前集合数组的长度时,vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度的50%.如过在集合中使用数据量比较大的数据,用vector有一定的优势。
  2. 如果查找一个指定位置的数据,vector和arraylist使用的时间是相同的,都是0(1),这个时候使用vector和arraylist都可以。而如果移动一个指定位置的数据花费的时间为0(n-i)n为总长度,这个时候就应该考虑到使用linklist,因为它移动一个指定位置的数据
    所花费的时间为0(1),而查询一个指定位置的数据时花费的时间为0(i)。
  • ArrayList
    和Vector是采用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,都允许直接序号索引元素,但是插入数据要设计到数组元素移动等内存操作,所以索引数据快插入数据慢,Vector由于使用了synchronized方法(线程安全)所以性能上比ArrayList要差,LinkedList使用双向链表实现存储,按序号索引数据需要进行向前或向后遍历,但是插入数据时只需要记录本项的前后项即可,所以插入数度较快!

|– LinkedList:底层的数据结构是链表结构(特点是查询较慢,增删较快)

四、总结

泥瓦匠总结如下:

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每插入一条数据,要移动插入点及之后的所有数据。

|– Vector:底层是数组数据结构
线程同步(数组长度是可变的百分之百延长)(无论查询还是增删都很慢,被ArrayList替代了)

List:特有的方法,凡是可以操作角标的方法都是该体系特有的方法

复制代码代码如下:

boolean add(int index, E element)

boolean addAll(index,Collection)

复制代码代码如下:

public static void List_add(){

ArrayList a1 = new ArrayList();

a1.add(“java”);

a1.add(“php”);//List集合中的元素可以重复

a1.add(“.net”);

System.out.println(“原集合:”+a1);

a1.add(1, “Flash”);

a1.add(0, “ps”);

System.out.println(a1);

ArrayList a2 = new ArrayList();

a2.add(“javascript”);

a2.add(“3dMax”);

a2.add(“IBM”);

a1.addAll(0, a2);

System.out.println(a1);

}

删除指定位置的元素

复制代码代码如下:

boolean remove(int index)

复制代码代码如下:

public static void List_remove(){

ArrayList a1 = new ArrayList();

a1.add(“javascript”);

a1.add(“php”);

a1.add(“flash”);

System.out.println(“原集合:”+a1);

a1.remove(0);

System.out.println(a1);

}

修改指定角标的元素  set(int index, E element)  返回的是修改的那个元素

复制代码代码如下:

public static void List_set() {

ArrayList a1 = new ArrayList();

a1.add(“javascript”);

a1.add(“php”);

a1.add(“.net”);

System.out.println(“原集合:”+a1);

a1.set(1, “falsh”);

System.out.println(a1);

}

复制代码代码如下:

get(int index)   返回列表中指定位置的元素

subList(int fromIndex, int toIndex)    返回列表中指定的 fromIndex(包括
)和 toIndex(不包括)之间的部分元素。

复制代码代码如下:

public static void List_get() {

ArrayList a1 = new ArrayList();

a1.add(“java”);

a1.add(“php”);

a1.add(“flash”);

System.out.println(a1.get(0));//获取指定角标的元素,有了该方法就可以遍历该集合中的所有元素

System.out.println(a1.subList(1,
3));//获取集合中某一部分的元素,包含头不包含尾

}

List集合特有的迭代器:ListIterator(是Iterator的子接口)

注意:

在迭代时,是不可以通过集合对象的方法操作集合中的元素

因为会发生ConcurrentModificationException异常(并发异常)

所以,在迭代器时,只能用迭代器的方法造作元素

因为Iterator方法是有限的所以只能对元素进行判断,取出,删除的操作

如果想要其他的操作如添加,修改等,就需要使用其子接口,ListIterator

该接口只能通过List集合的listIterator方法获取

复制代码代码如下:

public class ListIteratorDemo {

public static void main(String[] args) {

ArrayList a1 = new ArrayList();

a1.add(“java01”);

a1.add(“java02”);

a1.add(“java03”);

a1.add(“java04”);

System.out.println(“原集合是:”+a1);

/*在迭代过程中准备添加或者删除元素

Iterator it = al.iterator();

while (it.hasNext()){

Object obj = it.next();

if (obj.equals(“java02”))

//al.add(“java008”);//会出现并发异常,因为迭代器正在操作集合,不能再用集合的方法操作集合了

it.remove();//将java02的引用从集合中删除了

System.out.println(“obj:”+obj);

}

*/

//只有List的listIterator有增,删,改,查这些功能,因为只有List有索引

ListIterator li = a1.listIterator();

while (li.hasNext()){

if(li.next().equals(“java02”))

//li.add(“java009”);

li.set(“java006”);

}

}

}

Vector:枚举就是Vector特有的取出方式,跟迭代器很像(其实枚举和迭代是一样的)
已经被迭代器取代

复制代码代码如下:

public class VectorDemo {

public static void main(String[] args) {

Vector v = new Vector();

v.add(“java01”);

v.add(“java02”);

v.add(“java03”);

v.add(“java04”);

for(Enumeration en = v.elements();en.hasMoreElements();){

System.out.println(en.nextElement());

}

}

}

LinkedList:

特有方法:

addFirst();在头部添加元素      addLast();在尾部添加元素

getFirst(); getLast();
获取元素但不删除元素。如果集合中没有元素,会出现NoSuchElementException

removeFirst();   removeLast();
获取元素但是删除元素。如果集合中没有元素,会出现NoSuchElementException

在JDK1.6出现了替代方法

offerFirst(); offerLast();

peekFirst(); peekLast();
获取元素,但是元素不被删除。如果集合中没有元素,会返回null

pollFirst(); pollLast();
获取元素,但是元素被删除。如果集合中没有元素,会返回null

复制代码代码如下:

public class LinkedListDemo {

public static void main(String[] args) {

LinkedList link = new LinkedList();

link.add(“java01”);

link.add(“java02”);

link.add(“java03”);

link.add(“java04”);

while(!link.isEmpty()){

System.out.println((link.removeLast()));

}

}

}

发表评论

电子邮件地址不会被公开。 必填项已用*标注