Java中list详解_java list详解

一、list

（1）List 是接口，继承至Collection接口（Collection接口下还有个Queue接口，有PriorityQueue类）；

（2）List下有ArrayList，Vector，LinkedList

注意：Queue接口与List同一级别，都是继承了Collection接口。LinkedList既可以实现Queue接口,也可以实现List接口.Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法）。

二、list详解

1）ArrayList

ArrayList的实现原理

/*
ArrayList继承AbstractList类，
实现了List和RandomAccess，Cloneable, Serializable接口，
底层是基于动态的数组。
底层使用数组实现,默认初始容量为10.
当超出后，会自动扩容为原来的1.5倍，即自动扩容机制。
List list = Collections.synchronizedList(new ArrayList(...))
//即可线程安全。

// 利用ArrayList类实例化List集合
List<String> list = new ArrayList<String>();
*/
import java.util.*;

public class ArrayListExamples {

	public static void main(String args[]) {
		// 创建一个空的数组链表对象list，list用来存放String类型的数据
		ArrayList<String> list = new ArrayList<String>();

		// 增加元素到list对象中
		list.add("Item1");
		list.add("Item2");
		list.add(2, "Item3"); // 此条语句将会把“Item3”字符串增加到list的第3个位置。
		list.add("Item4");

		// 显示数组链表中的内容
		System.out.println("The arraylist contains the following elements: " + list);

		// 检查元素的位置
		int pos = list.indexOf("Item2");
		System.out.println("The index of Item2 is: " + pos);

		// 检查数组链表是否为空
		boolean check = list.isEmpty();
		System.out.println("Checking if the arraylist is empty: " + check);

		// 获取链表的大小
		int size = list.size();
		System.out.println("The size of the list is: " + size);

		// 检查数组链表中是否包含某元素
		boolean element = list.contains("Item5");
		System.out.println("Checking if the arraylist contains the object Item5: " + element);

		// 获取指定位置上的元素
		String item = list.get(0);
		System.out.println("The item is the index 0 is: " + item);

		// 遍历arraylist中的元素

		// 第1种方法: 循环使用元素的索引和链表的大小
		System.out.println("Retrieving items with loop using index and size list");
		for (int i = 0; i < list.size(); i++) {
			System.out.println("Index: " + i + " - Item: " + list.get(i));
		}

		// 第2种方法:使用foreach循环
		System.out.println("Retrieving items using foreach loop");
		for (String str : list) {
			System.out.println("Item is: " + str);
		}

		// 第三种方法:使用迭代器
		// hasNext(): 返回true表示链表链表中还有元素
		// next(): 返回下一个元素
		System.out.println("Retrieving items using iterator");
		for (Iterator<String> it = list.iterator(); it.hasNext();) {
			System.out.println("Item is: " + it.next());
		}

		// 替换元素
		list.set(1, "NewItem");
		System.out.println("The arraylist after the replacement is: " + list);

		// 移除元素
		// 移除第0个位置上的元素
		list.remove(0);

		// 移除第一次找到的 "Item3"元素
		list.remove("Item3");

		System.out.println("The final contents of the arraylist are: " + list);

		// 转换 ArrayList 为 Array
		String[] simpleArray = list.toArray(new String[list.size()]);
		System.out
				.println("The array created after the conversion of our arraylist is: " + Arrays.toString(simpleArray));
	}
}
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

ArrayList的优缺点

优点：底层数据结构是数组，查询快，增删慢。

缺点： 线程不安全，效率高

2）LinkedList

LinkedList的实现原理

/*
LinkedList继承AbstractList类，
实现了List，Serializable，Queue接口，
LinkedList是通过双向链表去实现的，
既然是链表实现那么它的随机访问效率比ArrayList要低，
顺序访问的效率要比较的高。
每个节点都有一个前驱（之前前面节点的指针）
一个后继（指向后面节点的指针）。
// 利用LinkedList类实例化List集合
List<String> list = new LinkedList<String>();
*/
import java.util.List;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;
 
/*
 * @desc LinkedList测试程序。
 *
 * @author skywang
 * @email  kuiwu-wang@163.com
 */
public class LinkedListTest {
    public static void main(String[] args) {
        // 测试LinkedList的API
        testLinkedListAPIs() ;
 
        // 将LinkedList当作 LIFO(后进先出)的堆栈
        useLinkedListAsLIFO();
 
        // 将LinkedList当作 FIFO(先进先出)的队列
        useLinkedListAsFIFO();
    }
     
    /*
     * 测试LinkedList中部分API
     */
    private static void testLinkedListAPIs() {
        String val = null;
        //LinkedList llist;
        //llist.offer("10");
        // 新建一个LinkedList
        LinkedList llist = new LinkedList();
        //---- 添加操作 ----
        // 依次添加1,2,3
        llist.add("1");
        llist.add("2");
        llist.add("3");
 
        // 将“4”添加到第一个位置
        llist.add(1, "4");
         
 
        System.out.println("\nTest \"addFirst(), removeFirst(), getFirst()\"");
        // (01) 将“10”添加到第一个位置。  失败的话，抛出异常！
        llist.addFirst("10");
        System.out.println("llist:"+llist);
        // (02) 将第一个元素删除。        失败的话，抛出异常！
        System.out.println("llist.removeFirst():"+llist.removeFirst());
        System.out.println("llist:"+llist);
        // (03) 获取第一个元素。          失败的话，抛出异常！
        System.out.println("llist.getFirst():"+llist.getFirst());
 
 
        System.out.println("\nTest \"offerFirst(), pollFirst(), peekFirst()\"");
        // (01) 将“10”添加到第一个位置。  返回true。
        llist.offerFirst("10");
        System.out.println("llist:"+llist);
        // (02) 将第一个元素删除。        失败的话，返回null。
        System.out.println("llist.pollFirst():"+llist.pollFirst());
        System.out.println("llist:"+llist);
        // (03) 获取第一个元素。          失败的话，返回null。
        System.out.println("llist.peekFirst():"+llist.peekFirst());
     
 
        System.out.println("\nTest \"addLast(), removeLast(), getLast()\"");
        // (01) 将“20”添加到最后一个位置。  失败的话，抛出异常！
        llist.addLast("20");
        System.out.println("llist:"+llist);
        // (02) 将最后一个元素删除。        失败的话，抛出异常！
        System.out.println("llist.removeLast():"+llist.removeLast());
        System.out.println("llist:"+llist);
        // (03) 获取最后一个元素。          失败的话，抛出异常！
        System.out.println("llist.getLast():"+llist.getLast());
 
 
        System.out.println("\nTest \"offerLast(), pollLast(), peekLast()\"");
        // (01) 将“20”添加到第一个位置。  返回true。
        llist.offerLast("20");
        System.out.println("llist:"+llist);
        // (02) 将第一个元素删除。        失败的话，返回null。
        System.out.println("llist.pollLast():"+llist.pollLast());
        System.out.println("llist:"+llist);
        // (03) 获取第一个元素。          失败的话，返回null。
        System.out.println("llist.peekLast():"+llist.peekLast());
 
          
 
        // 将第3个元素设置300。不建议在LinkedList中使用此操作，因为效率低！
        llist.set(2, "300");
        // 获取第3个元素。不建议在LinkedList中使用此操作，因为效率低！
        System.out.println("\nget(3):"+llist.get(2));
 
 
        // ---- toArray(T[] a) ----
        // 将LinkedList转行为数组
        String[] arr = (String[])llist.toArray(new String[0]);
        for (String str:arr)
            System.out.println("str:"+str);
 
        // 输出大小
        System.out.println("size:"+llist.size());
        // 清空LinkedList
        llist.clear();
        // 判断LinkedList是否为空
        System.out.println("isEmpty():"+llist.isEmpty()+"\n");
 
    }
 
    /**
     * 将LinkedList当作 LIFO(后进先出)的堆栈
     */
    private static void useLinkedListAsLIFO() {
        System.out.println("\nuseLinkedListAsLIFO");
        // 新建一个LinkedList
        LinkedList stack = new LinkedList();
 
        // 将1,2,3,4添加到堆栈中
        stack.push("1");
        stack.push("2");
        stack.push("3");
        stack.push("4");
        // 打印“栈”
        System.out.println("stack:"+stack);
 
        // 删除“栈顶元素”
        System.out.println("stack.pop():"+stack.pop());
         
        // 取出“栈顶元素”
        System.out.println("stack.peek():"+stack.peek());
 
        // 打印“栈”
        System.out.println("stack:"+stack);
    }
 
    /**
     * 将LinkedList当作 FIFO(先进先出)的队列
     */
    private static void useLinkedListAsFIFO() {
        System.out.println("\nuseLinkedListAsFIFO");
        // 新建一个LinkedList
        LinkedList queue = new LinkedList();
 
        // 将10,20,30,40添加到队列。每次都是插入到末尾
        queue.add("10");
        queue.add("20");
        queue.add("30");
        queue.add("40");
        // 打印“队列”
        System.out.println("queue:"+queue);
 
        // 删除(队列的第一个元素)
        System.out.println("queue.remove():"+queue.remove());
     
        // 读取(队列的第一个元素)
        System.out.println("queue.element():"+queue.element());
 
        // 打印“队列”
        System.out.println("queue:"+queue);
    }
}
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

LinkedList的优缺点

优点：底层数据结构是链表，查询慢，增删快。

缺点： 线程不安全，效率高

3）Vector

Vector的实现原理

在ArrayList中每个方法中添加了synchronized关键字来保证同步。

//例子：
import java.util.Vector;
import java.lang.*;
import java.util.Enumeration;
public class VectorApp
{
public static void main(String args[])
{
Vector v1 = new Vector();
Integer integer1= new Integer(1);
//加入为字符串对象
v1.addElement("one");
//加入的为integer的对象
v1.addElement(integer1);
v1.addElement(integer1);
v1.addElement("two");
v1.addElement(new Integer(2));
v1.addElement(integer1);
v1.addElement(integer1);
//转为字符串并打印
System.out.println("The Vector v1 is:\n\t"+v1);
//向指定位置插入新对象
v1.insertElementAt("three",2);
v1.insertElementAt(new Float(3.9),3);
System.out.println("The Vector v1(used method
insertElementAt()is:\n\t)"+v1);
//将指定位置的对象设置为新的对象
//指定位置后的对象依次往后顺延
v1.setElementAt("four",2);
System.out.println("The vector v1 cused method setElmentAt()is:\n\t"+v1);
v1.removeElement(integer1);
//从向量对象v1中删除对象integer1
//由于存在多个integer1,所以从头开始。
//找删除找到的第一个integer1.
Enumeration enum = v1.elements();
System.out.println("The vector v1 (used method removeElememt()is");
while(enum.hasMoreElements())
System.out.println(enum.nextElement()+"");
System.out.println();
//使用枚举类(Enumeration)的方法取得向量对象的每个元素。
System.out.println("The position of Object1(top-to-botton):"+v1.indexOf(integer1));
System.out.println("The position of Object1(tottom-to-top):"+v1.lastIndexOf(integer1));
//按不同的方向查找对象integer1所处的位置
v1.setSize(4);
System.out.println("The new Vector(resized the vector)is:"+v1);
//重新设置v1的大小，多余的元素被抛弃
}
}
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

Vector的优缺点

优点：底层数据结构是数组，查询快，增删慢。

缺点：线程安全，效率低

4）三种list的使用

对数组查询次数多：ArrayList

对数组修改次数多：LinkedList

数组需要更加安全：Vector

数组不需要更加安全：ArrayList或者LinkedList

当需要使用list时，对使用具体哪个list不确定：ArrayList

总结： ArrayList是基于动态的数组的数据结构 LinkedList是基于链表的数据结构