Java List操作

 

一、List：、有顺序以线性方式存储,可以存放重复对象

线程安全方法：List list = Collections.synchronizedList(new LinkedList(...));

LinkedList：双向链表实现存储　　索引数据慢插入数度较快　　线程不安全（比安全性能好）

ArrayList:数组方式存储数据　　索引数据快插入数据慢　　线程不安全

Vector:数组方式存储数据　　索引数据快插入数据慢　　线程安全

Stack：继承自Vector，实现一个后进先出的堆栈

ArrayList:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List books = new ArrayList();
        //向books集合中添加三个元素
        books.add(new String("11111111111"));
        books.add(new String("22222222222"));
        books.add(new String("33333333333"));
        System.out.println(books);

        //将新字符串对象插入在第二个位置
        books.add(1 , new String("44444444444"));
        for (int i = 0 ; i < books.size() ; i++ )
        {
            System.out.println(books.get(i));
        }

        //删除第三个元素
        books.remove(2);
        System.out.println(books);

        //判断指定元素在List集合中位置：输出1，表明位于第二位
        System.out.println(books.indexOf(new String("44444444444")));  //①
        //将第二个元素替换成新的字符串对象
        books.set(1, new String("LittleHann"));
        System.out.println(books);

        //将books集合的第二个元素（包括）
        //到第三个元素（不包括）截取成子集合
        System.out.println(books.subList(1 , 2));
    }
}

Result:

[11111111111, 22222222222, 33333333333]
11111111111
44444444444
22222222222
33333333333
[11111111111, 44444444444, 33333333333]
1
[11111111111, LittleHann, 33333333333]
[LittleHann]

Stack:

import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Stack v = new Stack();
        //依次将三个元素push入"栈"
        v.push("11");
        v.push("22");
        v.push("33");

        System.out.println(v);
        //访问第一个元素，但并不将其pop出"栈"
        System.out.println(v.peek());
        System.out.println(v);
        //pop出第一个元素
        System.out.println(v.pop());
        System.out.println(v);
    }
}

Result:

[11, 22, 33]
33
[11, 22, 33]
33
[11, 22]

LinkedList:

import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        LinkedList books = new LinkedList();
        
        //将字符串元素加入队列的尾部(双端队列)
        books.offer("11");
        //将一个字符串元素加入栈的顶部(双端队列)
        books.push("22");
        //将字符串元素添加到队列的头(相当于栈的顶部)
        books.offerFirst("33");
        System.out.println(books);
        //访问、并不删除栈顶的元素
        System.out.println(books.peekFirst());
        //访问、并不删除队列的最后一个元素
        System.out.println(books.peekLast());
        //将栈顶的元素弹出"栈"
        System.out.println(books.pop());
        //下面输出将看到队列中第一个元素被删除
        System.out.println(books);
        //访问、并删除队列的最后一个元素
        System.out.println(books.pollLast());
        //下面输出将看到队列中只剩下中间一个元素：
        System.out.println(books);
    }
}

Result:

[33, 22, 11]
33
11
33
[22, 11]
11
[22]

PriorityQueue:

PriorityQueue pq = new PriorityQueue();
        //下面代码依次向pq中加入四个元素
        pq.offer(6);
        pq.offer(-3);
        pq.offer(9);
        pq.offer(0);

        //输出pq队列，并不是按元素的加入顺序排列，
        //而是按元素的大小顺序排列，输出[-3, 0, 9, 6]
        System.out.println(pq);
        //访问队列第一个元素，其实就是队列中最小的元素：-3
        System.out.println(pq.poll());

Result:

[-3, 0, 9, 6]
-3

PriorityQueue不允许插入null元素，它还需要对队列元素进行排序

ArrayDeque:

import java.util.ArrayDeque;

public class Main {

    public static void main(String[] args) {
        ArrayDeque stack = new ArrayDeque();
        //依次将三个元素push入"栈"
        stack.push("11");
        stack.push("22");
        stack.push("33");
        System.out.println(stack);
        //访问第一个元素，但并不将其pop出"栈"
        System.out.println(stack.peek());
        System.out.println(stack);
        //pop出第一个元素
        System.out.println(stack.pop());
        System.out.println(stack);
    }
}

结果：

[33, 22, 11]
33
[33, 22, 11]
33
[22, 11]

List集合类应用场景：

1. java提供的List就是一个"线性表接口"，ArrayList(基于数组的线性表)、LinkedList(基于链的线性表)是线性表的两种典型实现
2. Queue代表了队列，Deque代表了双端队列(既可以作为队列使用、也可以作为栈使用)
3. 因为数组以一块连续内存来保存所有的数组元素，所以数组在随机访问时性能最好。所以的内部以数组作为底层实现的集合在随机访问时性能最好。
4. 内部以链表作为底层实现的集合在执行插入、删除操作时有很好的性能
5. 进行迭代操作时，以链表作为底层实现的集合比以数组作为底层实现的集合性能好

http://www.cnblogs.com/LittleHann/p/3690187.html

http://blog.csdn.net/speedme/article/details/22398395