JAVA基礎之集合、Iterator迭代器、泛型及加強for循環

我的理解：

　　對於集合，首先要明確的是最頂層的接口是Collection接口類，其包含一些基本的方法以便子類調用，不過在定義的時候最好定義好數據類型，以避免遍歷時還得必須進行向上轉型；特別注意的是其沒有關於下標的方法。同時爲了方便遍歷其元素，創建了一個Iterable類由Collection進行實現其獨有的返回迭代器的方法，以便下面的子類進行迭代的實現。

關於泛型：

　　（泛型，即「參數化類型」。一提到參數，最熟悉的就是定義方法時有形參，而後調用此方法時傳遞實參。那麼參數化類型怎麼理解呢？

顧名思義，就是將類型由原來的具體的類型參數化，相似於方法中的變量參數，此時類型也定義成參數形式（能夠稱之爲類型形參），而後在使用/調用時傳入具體的類型（類型實參）。

　　泛型的本質是爲了參數化類型（在不建立新的類型的狀況下，經過泛型指定的不一樣類型來控制形參具體限制的類型）。也就是說在泛型使用過程當中，操做的數據類型被指定爲一個參數，這種參數類型能夠用在類、接口和方法中，分別被稱爲泛型類、泛型接口、泛型方法。）

　　我的認爲就像個形參同樣的，最好前期定義好，以避免再出現轉換類型。瞭解下通配符？,上限須要extends，下限須要super。不過泛型裏面沒有繼承的概念。

加強for循環極大的減小的for循環的代碼量，當不要進行操做而只是進行遍歷時，建議仍是使用加強版的。

 

1、集合：

一、介紹：

集合是java中提供的一種容器，能夠存儲多個數據；集合的長度是可變的，存儲的必須是引用數據類型（數組長度是固定的）。

二、ArrayList集合存儲元素及遍歷：

public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<Integer>(); list.add(111); list.add(222); list.add(333); list.add(444); list.add(555); for(int i=0; i<list.size(); i++){ System.out.println(list.get(i)); } } public static void main(String[] args) { ArrayList<Person> list = new ArrayList<Person>(); list.add(new Person("小強")); list.add(new Person("老王")); list.add(new Person("小虎")); list.add(new Person("小澤")); list.add(new Person("小紅")); for(int i=0; i<list.size(); i++){ Person p = list.get(i); System.out.println(p); } }

三、集合的繼承實現關係：

其中list容許出現重複的元素，是有序的；而set是不容許的，無序的。

四、Collection類：

其是集合中的頂層接口，建立方法以下：

Collection<元素類型> 變量名 =new ArrayList<元素類型>(); //只能存儲指定的類型（最好採用這種方法）
 Collection 變量名 = new ArrayList(); //默認類型爲Object，即任何類型的元素均可以存儲

五、Collection部分基本方法以下：（沒有關於下標的方法）

import java.util.ArrayList; import java.util.Collection; public class Demo02 { public static void main(String[] args) { Collection<Integer> col=new ArrayList<Integer>(); col.add(10); col.add(20); //清空集合 // col.clear(); //判斷集合中是否包含該元素；
        boolean flag=col.contains(20); System.out.println(flag); //根據值刪除元素
        col.remove(10); //遍歷
        if(col instanceof ArrayList){ ArrayList<Integer> arr=(ArrayList<Integer>)col; for(int i=0;i<arr.size();i++){ System.out.println(arr.get(i)); } } //集合轉數組
        Object[] obj=col.toArray(); for(int i=0;i<obj.length;i++){ System.out.println(obj[i]); } } }

2、Iterator迭代器：

一、概述：

　　Collection集合元素的通用獲取方式：在取元素以前先要判斷集合中有沒有元素，若是有，就把這個元素取出來，繼續在判斷，若是還有就再取出出來。一直把集合中的全部元素所有取出。這種取出方式專業術語稱爲迭代。

二、經常使用方法：

hasNext():   若是仍有元素能夠迭代，則返回true；（返回一個boolean值）

next（）:返回迭代的下一個元素，並把指針向後移動下一位。

三、迭代方式的代碼體現：

(Iterable接口 (java.lang.Iterable) 是Java集合的頂級接口之一。Collection接口繼承Iterable，因此Collection的全部子類也實現了Iterable接口。)

Iterable的方法：

iterator()：

 　　　　返回在此Collection的元素上進行迭代的迭代器。

import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class Demo05 { public static void main(String[] args) { Collection col=new ArrayList(); col.add("abc"); col.add("add"); col.add("edf"); //獲取迭代器對象
        Iterator it=col.iterator(); //判斷是否有元素
        while(it.hasNext()){ //獲取每一個元素
            Object s=it.next(); //判斷是不是String類型
            if(s instanceof String){ //向下轉型
                String str=(String)s; //調用子類獨有的方法
 System.out.println(str.length()); } } } }

（因爲元素被存進集合後所有都被提高爲Object類型，因此須要向下轉型）

3、泛型：

　　泛型，用來靈活地將數據類型應用到不一樣的類、方法、接口當中。將數據類型做爲參數進行傳遞。

一、含有泛型的類：

定義格式：

　　修飾符 class 類名<表明泛型的變量>{   }

使用格式：

　　建立對象時，肯定泛型的類型。

二、含有泛型的接口：

　　　　修飾符 interface 接口名<表明泛型的變量>{   }

使用格式：

　　定義時肯定泛型的類型（實現接口的時候明確）；

　　或者：

　　知道建立對象時，肯定泛型的類型；

三、使用泛型的好處：

 

　　將運行時期的ClassCastException，轉移到了編譯時期變成了編譯失敗。避免了類型強轉的麻煩。

import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.Iterator; public class Demo01 { public static void main(String[] args) { ArrayList<String> arr=new ArrayList<String>(); arr.add("a"); arr.add("b"); HashSet<Integer> set=new HashSet<Integer>(); set.add(123); set.add(456); get(arr); get(set); } //寫一個方法遍歷兩個集合
    public static void get(Collection<?> col){ //獲取迭代器對象
        Iterator<?> it=col.iterator(); //判斷是否存在
        while(it.hasNext()){ System.out.println(it.next()); } } }

四、泛型通配符：

　　爲了解決這個"沒法肯定具體集合中的元素類型"問題，java中，爲咱們提供了泛型的通配符<?>。當使用泛型類或者接口時，傳遞的數據中，泛型類型不肯定，能夠經過通配符<?>表示。可是一旦使用泛型的通配符後，只能使用Object類中的共性方法，集合中元素自身方法沒法使用。

五、泛型限定：

限定泛型的上限：

　　格式：? extends E

? 表明接收E類型或者E的子類型的元素

 

限定泛型的下限：

格式：? super E

? 表明接收E類型或者E的父類型的元素

import java.util.ArrayList; import java.util.Iterator; public class Demo02 { public static void main(String[] args) { ArrayList<Cooker> arr1=new ArrayList<Cooker>(); arr1.add(new Cooker()); arr1.add(new Cooker()); ArrayList<Waiter> arr2=new ArrayList<Waiter>(); arr2.add(new Waiter()); arr2.add(new Waiter()); get(arr1); get(arr2); } //寫一個方法來遍歷容器
    public static void get(ArrayList<? extends Emp> arr){ Iterator<? extends Emp> it=arr.iterator(); while(it.hasNext()){ /*Object obj=it.next(); if(obj instanceof Cooker){ Cooker c=(Cooker)obj; c.work(); } if(obj instanceof Waiter){ Waiter c=(Waiter)obj; c.work(); }*/ it.next().work(); } } }

4、加強for循環：

　　加強for循環是JDK1.5之後出來的一個高級for循環，專門用來遍歷數組和集合的。它的內部原理實際上是個Iterator迭代器，因此在遍歷的過程當中，不能對集合中的元素進行增刪操做。（也沒有下標的概念）

格式：

for(元素的數據類型 變量 : Collection集合or數組){

}

import java.util.ArrayList; import java.util.Collection; public class Demo06 { public static void main(String[] args) { /*for（你容器中存放的數據類型 變量名：你要遍歷的容器的名字）{ System.out.println(變量名); }*/ Collection<String> col=new ArrayList<String>(); col.add("abc"); col.add("bcd"); col.add("edg"); for(String s:col){ System.out.println(s); } } }

加強for循環和老式的for循環有什麼區別？

注意：新for循環必須有被遍歷的目標。目標只能是Collection或者是數組。

建議：遍歷數組時，若是僅爲遍歷，可使用加強for若是要對數組的元素進行 操做，使用老式for循環能夠經過角標操做。