一 泛型

標識著集合中儲存的元素

<泛型(型別)> eg: ArrayList<String>

好處:

1.操作資料更加安全(規範集合中能儲存的資料)

2.可以避免向下轉型(強轉型別)的麻煩

3.將執行時的出錯 轉到編譯時報錯

二 正向遍歷與逆向遍歷

public static void main(String[] args){
   ArrayList<String> list = new ArrayList<>();
   list.add("a");
   list.add("b");
   list.add("c");
   list.add("d");
   ListIterator<String> lisIterator = list.listIterator();
   while(lisIterator.hasNext()){
      String string = lisIterator.next();
      System.out.println(string);
   }
}
 

public static void main(String[] args){
   ArrayList<String> list = new ArrayList<>();
   list.add("a");
   list.add("b");
   list.add("c");
   list.add("d");
   ListIterator<String> lisIterator = list.listIterator();
   while(lisIterator.hasNext()){
      String string = lisIterator.next();
      System.out.println(string);
   }
   while (listIterator.hasPrevious()) {
      //獲取前一個元素
      string previous = listIterator.previous();
      System.out.println(previous);
   }
}
 

需要注意的是:在使用迭代器遍歷時,其內部的指標在第一個元素的上面,所以正向遍歷時,判斷指標下一個位置有元素執行遍歷.

執行完畢後,內部指標在最後一個元素位置上,此時逆向遍歷,判斷指標上一個位置有元素執行遍歷.因此,如若未執行正向遍歷而直接進行逆向遍歷,是無法執行的.

三 強轉型時泛型的編譯報錯

public static void fun2() {
	//不加泛型 集合中儲存三個學生
	ArrayList list = new ArrayList();
	list.add(new Student("恐龍",18));
	list.add(new Student("大海",18));
	list.add(new Student("地獄",18));
	//從集合中取出一個元素
	Object object = list.get(0);
	Student student = (Student)object;
	System.out.println(student.getName());
	//從集合中取出一個元素 強轉型工人型別
	//呼叫工人的工作方法
	//不加泛型 獲取到集合中的元素
	//元素的型別你可以隨便強轉,編譯不報錯
	Object object2 = list.get(1);
	Worker worker = (Worker)object2;
	worker.work();
	//加上泛型 可以在編譯時 有錯誤提示
	//讓集合中儲存的元素 更加安全
//	Worker worker2 = (Worker)list.get(0);
}
 

四 基本資料型別陣列轉集合時

public static void fun6() {
	//陣列轉集合
	int[] array = {1,2,3,4,5};
	//根據泛型 這個集合中 每一個元素 都是一個數組
	List<int[]> list = Arrays.asList(array);
	System.out.println(list);
	//直接傳入 int[] 系統不會幫你進行 自動裝箱
	Integer[] newArray = {1,2,3,4,5};
	//直接把陣列中的元素 放入到集合中
	List<Integer> asList = Arrays.asList(newArray);
	System.out.println(asList);
}

五 陣列轉集合 需注意的地方

轉成集合後,可以呼叫集合中的其他方法

public static void main(String[] args) {
	String[] strings = {"wanglong","pengqian","xiaofeng"};
	//陣列轉集合
	List<String> list = Arrays.asList(strings);
	//新增一個元素
	//UnsupportedOperationException
	//不支援的操作異常
//	list.add("kuner");
//	System.out.println(list);
	boolean b = list.contains("wanglong");
	System.out.println(b);
}

六 ? extends E

? 子類   ,    E 父類

public static void fun1() {
	//addAll(Collection<? extends E> c)
	//建立一個person集合 儲存兩個person
	ArrayList<Person> list1 = new ArrayList<>();
	list1.add(new Person("wang1",11));
	list1.add(new Person("wang2",11));
	//建立一個student集合 儲存兩個person
	ArrayList<Student> list2 = new ArrayList<>();
	list2.add(new Student("peng1",11));
	list2.add(new Student("peng2",11));
	//addAll(Collection<? extends Person> c)
	list1.addAll(list2);
	System.out.println(list1);
//	list2.addAll(list1); //報錯
}

七 刪除元素需注意的

public static void fun2() {
	//迴圈刪除
	//建立一個集合儲存 abcd
	//如果有b 就把b刪了(使用迴圈)
	ArrayList<String> list = new ArrayList<>();
	list.add("a");
	list.add("b");
	list.add("b");
	list.add("c");
	list.add("d");
	for (int i =    0; i < list.size(); i++) {
		if (list.get(i).equals("b")) {				
		//刪除之後,要退回角標,因為刪除之後,陣列中的元素會向前移動一位
		list.remove(i);
		}
	}
	System.out.println(list);
}

在其刪除元素後,陣列中後面的元素會向前移動一位,所以會出現上述情況

可在刪除的同時,將i減一即可

或者用迭代器刪除

public static void fun3() {
	//迭代器刪除
	ArrayList<String> list = new ArrayList<>();
	list.add("a");
	list.add("b");
	list.add("b");
	list.add("c");
	list.add("d");
	Iterator iterator = list.iterator();
	while (iterator.hasNext()) {
		String next = (String)iterator.next(); 
		if (next.equals("b")) {
			iterator.remove();
		}
	}
	System.out.println(list);
}