Compare ArrayList, LinkedList, vectors

Translators: Anchor
Translation time: December 2, 2013
Original link: ArrayList vs. LinkedList vs. Vector

1. List overview

List, as shown in the name, is an ordered list of elements. When we talk about lists, it's a good idea to compare them to set, and the elements in the set set are unordered and unique.
is the collection class succession diagram, you can have a general understanding of the knowledge discussed in this article.

Figure 1

2. Comparison of ArrayList, LinkedList and vectors
As you can see, all three have implemented the List interface. All use is similar, the main difference is because the implementation of different ways, so the different operations have different efficiency.
ArrayList is a resizable array. When more elements are added to the ArrayList, their size will grow dynamically. Internal elements can be accessed directly through get and set methods, because ArrayList is essentially an array.
LinkedList is a doubly linked list that has better performance than ArrayList when adding and deleting elements. However, the get and set aspects are weaker than ArrayList.
Of course, these comparisons refer to the comparison of large data volumes or very frequent operations, and if the data and calculations are small, then the contrast will lose meaning.
vectors are similar to ArrayList, but they belong to the strong synchronization class. If your program itself is thread-safe (thread-safe, not sharing the same collection/object across multiple threads), then using ArrayList is a better choice.
Vectors and ArrayList request greater space when more elements are added. Each time the vector requests a double space for its size, ArrayList increases by 50% for size each time.
The LinkedList also implements the Queue interface, which provides more methods than list, including offer (), Peek (), poll (), and so on.
Note: The initial capacity of ArrayList is very small by default, so if you can estimate the amount of data, assigning a large initial value is a best practice, which reduces the cost of resizing.
3. ArrayList example

[Java]View Plaincopy

2. Public static void Testarraylist () {
4. Arraylist<integer> al = new arraylist<integer> ();
6. Al.add (3);
8. Al.add (2);
10. Al.add (1);
12. Al.add (4);
14. Al.add (5);
16. Al.add (6);
18. Al.add (6);
24. iterator<integer> iter1 = Al.iterator ();
26. While (Iter1.hasnext ()) {
28. System.out.println (Iter1.next ());
30. }
32. }

4. LinkedList Example

[Java]View Plaincopy

2. Public static void Testlinkedlist () {
4. linkedlist<integer> ll = new linkedlist<integer> ();
6. Ll.add (3);
8. Ll.add (2);
10. Ll.add (1);
12. Ll.add (4);
14. Ll.add (5);
16. Ll.add (6);
18. Ll.add (6);
24. Iterator<integer> iter2 = Ll.iterator ();
26. While (Iter2.hasnext ()) {
28. System.out.println (Iter2.next ());
30. }
32. }

As the example above shows, its usage is similar, the actual difference is that the underlying implementation and the complexity of the operation are different.
5. Vector
Vectors and ArrayList are almost identical, the only difference being that the vector is a synchronous class (synchronized). Therefore, the cost is greater than the ArrayList. Under normal circumstances, Most Java programmers use ArrayList instead of vectors, because synchronization can be controlled entirely by the programmer itself.
6. ArrayList and LinkedList performance comparison
The complexity of time is compared as follows:

	ArrayList	linkedlist
Get ()	O (1)	O (N)
Add ()	O (1)	O (1) amortized
Remove ()	O (N)	O (N)

* Add () in the table represents add (e e), and remove () represents remove (int index) '

• ArrayList for random position add/remove, the time complexity is O (n), but for Add/delete operations at the end of the list, the time complexity is O (1).
• LinkedList for random position add/remove, the time complexity is O (n), but for Add/delete operations at the end/beginning of the list, the time complexity is O (1).

I use the following code to test their performance:

[Java]View Plaincopy

2. Public static void Testperformance () {
4. arraylist<integer> ArrayList = new arraylist<integer> ();
6. linkedlist<integer> LinkedList = new linkedlist<integer> ();
10. int
12. Times = Ten * 1000;
14. //times = 100 * 1000;
16. //times = 1000 * 1000;
18. System.out.println ("Test times =" + times);
20. System.out.println ("-------------------------");
22. //ArrayList Add
24. Long startTime = System.nanotime ();
28. For (int i = 0; i < times; i++) {
30. Arraylist.add (i);
32. }
34. Long endTime = System.nanotime ();
36. long duration = Endtime-starttime;
38. System.out.println (Duration + "<--arraylist add");
42. //LinkedList add
44. StartTime = System.nanotime ();
48. For (int i = 0; i < times; i++) {
50. Linkedlist.add (i);
52. }
54. EndTime = System.nanotime ();
56. Duration = Endtime-starttime;
58. System.out.println (Duration + "<--linkedlist add");
60. System.out.println ("-------------------------");
62. //ArrayList get
64. StartTime = System.nanotime ();
68. For (int i = 0; i < times; i++) {
70. Arraylist.get (i);
72. }
74. EndTime = System.nanotime ();
76. Duration = Endtime-starttime;
78. System.out.println (Duration + "<--arraylist get");
82. //LinkedList get
84. StartTime = System.nanotime ();
88. For (int i = 0; i < times; i++) {
90. Linkedlist.get (i);
92. }
94. EndTime = System.nanotime ();
96. Duration = Endtime-starttime;
98. System.out.println (Duration + "<--linkedlist get");
100. System.out.println ("-------------------------");
104. //ArrayList Remove
106. StartTime = System.nanotime ();
110. For (int i = times- 1; I >= 0; i--) {
112. Arraylist.remove (i);
114. }
116. EndTime = System.nanotime ();
118. Duration = Endtime-starttime;
120. System.out.println (Duration + "<--arraylist remove");
124. //LinkedList Remove
126. StartTime = System.nanotime ();
130. For (int i = times- 1; I >= 0; i--) {
132. Linkedlist.remove (i);
134. }
136. EndTime = System.nanotime ();
138. Duration = Endtime-starttime;
140. System.out.println (Duration + "<--linkedlist remove");
142. }

The output results are as follows:

[Plain]View Plaincopy

1. Test times = 10000
2. -------------------------
3. 1469985 <--arraylist Add
4. 3530491 <--linkedlist Add
5. -------------------------
6. 593678 <--arraylist Get
7. 86914251 <--linkedlist Get
8. -------------------------
9. 625651 <--arraylist Remove
10. 2164320 <--linkedlist Remove

[Java]View Plaincopy

1. Test times = 100000
2. -------------------------
3. 11480805 <--arraylist Add
4. 26384338 <--linkedlist Add
5. -------------------------
6. 714072 <--arraylist Get
7. 10040809061 <--linkedlist Get
8. -------------------------
9. 1203935 <--arraylist Remove
10. 1595905 <--linkedlist Remove

[Plain]View Plaincopy

1. In the 1000*1000 run, a long time later, the LinkedList get log has not been printed out, about 15 minutes or so, the result is still not out.

[Java]View Plaincopy

1. test times = 1000000   
2. -------------------------  
3. 132632998  <--arraylist add  
4. 322885939 <--linkedlist  add  
5. -------------------------  
6. 3690752&NBSP;<--ARRAYLIST&NBSP;GET&NBSP;&NBSP;
7. 1520315361147&NBSP;<--LINKEDLIST&NBSP;GET&NBSP;&NBSP;
8. -------------------------  
9. 8750043&NBSP;<--ARRAYLIST&NBSP;REMOVE&NBSP;&NBSP;
10. 13872885&NBSP;<--LINKEDLIST&NBSP;REMOVE&NBSP;&NBSP;

The difference in performance is quite noticeable,LinkedList is faster on add and remove, and slower on get ( This is the original).

Translator Note : The Translator's compilation and execution environment is myeclipse JDK6, regardless of how to see, are ArrayList better, so, how to choose, please according to their actual situation to decide, it is best to do their own test, because the data type is different, Different versions of JDK, different optimizations, may have different results.

Based on the time complexity table and the test results, we can determine when to use ArrayList and when to use LinkedList.

In simple terms, LinkedList is more suitable for:

• No random reads of large scale
• Large number of Add/delete operations

Compare ArrayList, LinkedList, vectors