Old zizhu Java tutorial (6)-Understanding list

Address: http://www.java2000.net/p11848
 
List is a frequently-used data structure, which is more frequently used than map and set, because I often use it to return the database operation result set.

1. Package collection. lession6;
3. Import java. util. arraylist;
4. Import java. util. iterator;
5. Import java. util. Collections list;
6. Import java. util. List;
7. Import java. util. listiterator;
8. Import java. util. Stack;
9. Import java. util. vector;
11. /**
12. * Old zizhu Java tutorial (6)-list <br>
13. * List can precisely control the sequence in the set. <Br>
14. * Data can be accessed directly through the data location. <Br>
15. * Repeated data is generally allowed <br>
16. * Generally, null is allowed and multiple null values are allowed.
17. *
18. * @ Author old zizhu Java century network (java2000.net)
19. *
20. */
21. Public class lession6 {
23. Public static void main (string [] ARGs ){
24. // The following are commonly used implementation classes in list
26. // Implement a variable-size list, allowing any data to be added
27. Arraylist = new arraylist ();
29. // It is also the implementation of a variable-size list.
30. // The biggest difference from arraylist is that the method of this class is synchronous (synchronized ).
31. // For detailed differences, see
32. // Check the source code to understand the real difference between arraylist and vector.
33. // Http://www.java2000.net/p9750
34. Vector vector = new vector ();
36. // Implements bidirectional queue control, including operations at the beginning and end
37. // Can be used for Stack and FIFO operations.
38. Listparts list = new parts list ();
40. // Integrate the self-Vector
41. // Provides the LIFO stack operation method.
42. Stack stack = new stack ();
44. //-----------------
45. // The following uses arraylist as an example to check the methods in the list.
46. List list = new arraylist ();
47. // Construct the second list
48. List list2 = new arraylist ();
50. // Add the specified data to the end of the list
51. List. Add (1, 123 );
53. // Insert the specified data at the specified position in the list
54. // Insert data at the beginning
55. // The index at the position of the list starts from 0.
56. List. Add (1, 0,456 );
58. // Put all the data in list2 to the end of list1.
59. // Note that this can be any collection class, not limited to list
60. List. addall (list2 );
62. // Put all the data in list2 to the end of the specified position in list1.
63. // Insert a piece of data
64. List. addall (2, list2 );
66. // Clear the list and delete all the data in it
67. List. Clear ();
69. // Determine whether the list contains data
70. Boolean found = List. Contains (123 );
72. // Determine whether the list contains all the data of another set
73. // Note that this can be any collection class, not limited to list
74. Boolean OK = List. containsall (list2 );
76. // Obtain data at the specified position
77. // If the position exceeds the range of list 0 to list. Size ()-1
78. // Throw an exception: indexoutofboundsexception
79. Object OBJ = list. Get (3 );
81. // Obtain the position of the data in the list
82. // If not found,-1 is returned.
83. // The Position Index starts from 0.
84. Int Index = List. indexof (456 );
86. // Check whether the list is empty
87. Boolean empty = List. isempty ();
89. // List iterator operation
90. // The Order is strictly in the order of list Storage
91. Iterator it = List. iterator ();
93. // Obtain the position where the data is last displayed in the list
94. // Suitable for the list with duplicate data
95. Index = List. lastindexof (456 );
97. // Another iterator in the list
98. Listiterator listit = List. listiterator ();
100. // Another iterator In the list. You can specify the start position.
101. Listiterator listit2 = List. listiterator (3 );
103. // Delete data at a certain position
104. List. Remove (3 );
106. // Delete the first location where the specified object appears
107. // Note: if it is an integer, you must distinguish it from remove (INT ).
108. // We recommend that you use remove (New INTEGER (123); to delete data objects.
109. List. Remove (New INTEGER (123 ));
111. // Delete the data in another set in the list
112. List. removeall (list2 );
114. // Only the data in another set is retained, equal to the intersection
115. List. retainall (list2 );
117. // Replace the data at the specified position
118. List. Set (3,999 );
120. // Number of List Data
121. Int size = List. Size ();
123. // Obtain a subarray
124. List sublist = List. sublist (2, 10 );
126. // Convert the set into an array
127. Object [] objs = List. toarray ();
129. // Convert the set to an array in the specified format
130. // For example, strings are saved in the set.
131. String [] objs2 = (string []) List. toarray (New String [0]);
132. }
133. }

Summary:

In fact, we usually use arraylist. Because vector is a synchronous method, it is used only when multiple threads and global data are involved.