java集合之List

時間 2019-12-01

標籤 java 集合 list 欄目 Java 简体版

原文原文鏈接

1. List的四個基本增刪改查方法的使用以下：java

 1 public class Demo1_List {
 2 
 3     /*
 4      * void add(int index, E element)
 5      * E remove(int index)     返回值爲刪除的元素
 6      * boolean remove(E element)
 7      * E get(int index)
 8      * E set(int index, E element)
 9      */
10     public static void main(String[] args) {
11 
12         //demo1();
13         //demo2();
14         //demo3();
15         List l = new ArrayList();
16         l.add("a");
17         l.add("b");
18         l.add("c");
19         l.set(1, "dd");         //將指定位置的元素修改
20         System.out.println(l);  //[a, dd, c]
21     }
22 
23     public static void demo3() {
24         List l = new ArrayList();
25         l.add("a");
26         l.add("b");
27         l.add("c");
28         //Object o = l.get(0);
29         //System.out.println(o);
30         //經過索引遍歷list集合
31         for (int i = 0; i < l.size(); i++) {
32             System.out.println(l.get(i));
33         }
34     }
35 
36     public static void demo2() {
37         List l = new ArrayList();
38         l.add("a");
39         l.add("b");
40         l.add("c");
41         l.add(555);
42         Object obj = l.remove(1);
43         System.out.println(obj);  //b    
44         System.out.println(l);    //[a, c]
45         System.out.println(l.remove("a"));   //true
46         //Object o = l.remove(555);    //java.lang.IndexOutOfBoundsException: Index: 555, Size: 2   這裏刪除時不會自動裝箱
47     }
48 
49     public static void demo1() {
50         List l = new ArrayList();
51         l.add("a");
52         l.add("b");
53         l.add("c");
54         System.out.println(l);    //[a, b, c]
55         l.add(3, "d");          //0 <= index <= size  時不會報異常
56         //l.add(4, "d");        java.lang.IndexOutOfBoundsException: Index: 4, Size: 3
57     }
58 
59 }

2. 使用get() 和 size()方法結合遍歷存有自定義對象的集合數組

 1 public class Demo2_List {
 2 
 3     /*
 4      * 向List集合中存儲學生對象，使用size()和get()結合的方法遍歷集合
 5      */
 6     public static void main(String[] args) {
 7         List l = new ArrayList();
 8         l.add(new Student("張三",18));
 9         l.add(new Student("李四",19));
10         l.add(new Student("王五",10));
11         for (int i = 0; i < l.size(); i++) {
12 //            System.out.println(l.get(i));
13             Student s = (Student) l.get(i);
14             System.out.println(s.getName() + " " + s.getAge());
15         }
16     }
17 
18 }

3. 須要注意：遍歷的同時修改集合會報java.util.ConcurrentModificationException併發修改異常，要想避免這個異常，則可使用迭代器特有的添加方法安全

 1 public class Demo3_ConcurrentModificationException {
 2 
 3     public static void main(String[] args) {
 4 
 5         List l = new ArrayList();
 6         l.add("a");
 7         l.add("world");
 8         l.add("b");
 9         l.add("c");
10         
11         /*Iterator it = l.iterator();
12         while (it.hasNext()) {
13             String s = (String) it.next();
14             if (s.equals("world")) {
15                 l.add("javaee");      //遍歷的同時修改集合會報java.util.ConcurrentModificationException併發修改異常
16             }                         //要想避免這個異常，則可使用迭代器特有的添加方法
17         }
18         */
19         
20         ListIterator lit = l.listIterator();    //獲取list集合特有的迭代器
21         while (lit.hasNext()) {
22             String s = (String)lit.next();
23             if (s.equals("world")) {
24                 lit.add("javaee");              //使用list特有的迭代器添加方法在遍歷的同時添加元素不會出現併發修改異常
25             }
26         }
27         System.out.println(l);    //[a, world, javaee, b, c]
28         
29     }
30 
31 }

4. Vector數據結構

 1 public class demo4_Vector {
 2 
 3     /*
 4      * 如今Vector已經基本上廢棄，由list代替
 5      * 
 6      * 數組：查詢修改快，增刪慢
 7      * 
 8      * 鏈表：查詢修改慢，增刪改快
 9      * 
10      * list的三個子類比較：
11      *    ArrayList：
12      *        底層數據結構是數組，查詢快，增刪慢
13      *        線程不安全，效率高
14      *        
15      *    Vector：
16      *        底層數據結構是數組，查詢快，增刪慢
17      *        線程安全，，效率低
18      *    
19      *    Vector相對ArrayList查詢慢（線程安全），相對LinkList增刪慢（數據結構）
20      *    
21      *    LinkList：
22      *        底層數據結構是鏈表，查詢慢，增刪快
23      *        線程不安全，效率高
24      *        
25      *    Vector和ArrayList的區別：
26      *        Vector是線程安全的，效率低
27      *        ArrayList是線程不安全的，效率高
28      *        
29      *    ArrayList和LinkList的區別：
30      *        ArrayList底層是數組結構，查詢和修改快
31      *        LinkList底層是鏈表結構，增刪快，查詢修改慢
32      *        
33      *    NB:
34      *        查詢多時用ArrayList
35      *        增刪多時用LinkList
36      *        若是都多的話，用ArrayList
37      *  
38      */
39     public static void main(String[] args) {
40 
41         Vector v = new Vector();
42         v.addElement("a");
43         v.addElement("b");
44         v.addElement("c");
45         
46         Enumeration en = v.elements();
47         while(en.hasMoreElements()) {
48             System.out.println(en.nextElement());
49         }
50     }
51 
52 }

5. 對List集合中的元素去重併發

 1 /**
 2  * @author Administrator
 3  * 對存儲有重複字符串的集合去重
 4  */
 5 @SuppressWarnings({ "rawtypes", "unchecked" })
 6 public class Demo5_ArrayList_quchong {
 7 
 8     /**
 9      * @param args
10      */
11     public static void main(String[] args) {
12 
13         ArrayList list = new ArrayList();
14         list.add("a");
15         list.add("a");
16         list.add("b");
17         list.add("b");
18         list.add("b");
19         list.add("c");
20         list.add("c");
21         ArrayList li = getSingle(list);
22         System.out.println(li);
23     }
24     
25     
26     /**
27      * @param list
28      * @return ArrayList
29      * 思路：經過建立一個新的集合對老集合遍歷，將須要留下的元素插入新集合中
30      * 
31      * 1. 建立一個新空集合
32      * 2.對老集合進行遍歷，判斷新集合中是否存在該元素，若是不存在則插入，若是存在則繼續遍歷
33      * 3.將新集合返回
34      */
35     public static ArrayList getSingle(ArrayList list) {
36         ArrayList newList = new ArrayList();
37         Iterator it = list.iterator();
38         while(it.hasNext()) {
39             Object o = it.next();
40             if (!newList.contains(o)) {
41                 newList.add(o);
42             }
43         }
44         return newList;
45     }
46 
47 }
48 
49 ***************************************************************
50 
51 /**
52  * @author Administrator
53  * 對自定義類集合去重處理
54  *
55  */
56 @SuppressWarnings({ "rawtypes", "unchecked" })
57 public class Demo6_ArrayList_zdyquchong {
58 
59     /**
60      * @param args
61      */
62     public static void main(String[] args) {
63 
64         ArrayList list = new ArrayList();
65         list.add(new Person("張三", 23));
66         list.add(new Person("張三", 23));
67         list.add(new Person("李四", 24));
68         list.add(new Person("李四", 24));
69         list.add(new Person("李四", 24));
70         
71         ArrayList li = getSingle(list);
72         System.out.println(li);
73     }
74 
75     /**
76      * @param list
77      * @return ArrayList
78      * 思路：經過建立一個新的集合對老集合遍歷，將須要留下的元素插入新集合中
79      * 
80      * 1. 建立一個新空集合
81      * 2.對老集合進行遍歷，判斷新集合中是否存在該元素，若是不存在則插入，若是存在則繼續遍歷
82      * 3.將新集合返回
83      */
84     public static ArrayList getSingle(ArrayList list) {
85         ArrayList newList = new ArrayList();
86         Iterator it = list.iterator();
87         while(it.hasNext()) {
88             Object o = it.next();
89             if (!newList.contains(o)) {
90                 newList.add(o);
91             }
92         }
93         return newList;
94     }
95 }

6.LinkListspa

 1 /*
 2      * public void addFirst(E e)    
 3      * public void addLast(E e)
 4      * public E removeFirst()   返回被刪除的元素
 5      * public E removeLast()    返回被刪除的元素
 6      * public E getFirst()      返回查找的元素
 7      * public E getLast()       返回查找的元素
 8      * public E get(int index)  返回查找的元素
 9      */
10     public static void main(String[] args) {
11         LinkedList list = new LinkedList();
12         list.addFirst("a");
13         list.addFirst("b");
14         list.addFirst("c");
15         list.addFirst("d");
16         list.addLast("e");
17         System.out.println(list);
18         System.out.println(list.removeFirst());
19         System.out.println(list.removeLast());
20         System.out.println(list.getFirst());
21         System.out.println(list.getLast());
22         System.out.println(list.get(1));
23         
24     }

7. 使用LinkList模擬棧的進出線程

 1 /**
 2  * @author Administrator
 3  *  使用LinkedList模擬棧的進、出以及是否爲空
 4  */
 5 public class Demo8_LinkList {
 6 
 7     public static void main(String[] args) {
 8         Stack s = new Stack();
 9         s.in("a");
10         s.in("b");
11         s.in("c");
12         s.in("d");
13         
14         System.out.println(s);
15         while(!s.isEmpty()) {
16             System.out.println(s.out());
17         }
18     }