《Java集合類3》Iterator 與 比較器

標題 ：Iterator(迭代器)

可迭代是Java集合框架下的所有集合類的一種共性，也就是把集合中的所有元素遍歷一遍。迭代的過程需要依賴一個迭代器對象。

Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            String string = iterator.next();
        }

概述
迭代—簡單地理解爲遍歷，是一個標準化遍歷各類容器裏面的所有對象的方法類，它是一個很典型的設計模式。迭代器(Iterator)模式是用於提供一種方法訪問一個容器對象中各個元素，而又不需暴露該對象的內部細節。
在沒有迭代器時我們是這麼進行處理的。如下：
【數組】

int[] arrays = new int[10];
   for(int i = 0 ; i  arrays.length ; i++){
       int a = arrays[i];
   }

【ArrayList】

ListString list = new ArrayListString();
   for(int i = 0 ; i  list.size() ;  i++){
      String string = list.get(i);
   }

上面兩種方式的弊端：對於這兩種方式，我們都事先知道集合的內部結構，訪問代碼和集合本身是緊密耦合的，無法將訪問邏輯從集合類和客戶端代碼中分離出來。同時每一種集合對應一種遍歷方法，客戶端代碼無法複用。
在實際應用中需要如何將上面將兩個集合進行整合是相當麻煩的。所以爲了解決以上問題，Iterator模式出現，它總是用同一種邏輯來遍歷集合。

使得客戶端自身不需要來維護集合的內部結構，所有的內部狀態都由Iterator來維護。客戶端從不直接和集合類打交道，它總是控制Iterator，向它發送向前，向後，取當前元素的命令，就可以間接遍歷整個集合。

java.util.Iterator
在Java中Iterator是一個接口，Java所有集合類都是進行迭代的。
1、接口定義

public interface Iterator{
    boolean hasNext();
    Object next();
    void remove();
}

2、其中：
boolean hasNext()：該方法用於判斷集合對象是否還有下一個元素，如果已經是最後一個元素，則返回false。
Object next()：獲取出下一個元素。
void remove()：從迭代器指向的Collection中移除迭代器返回的最後一個元素。

【注意】：Iterator只有上面接口中的三個方法，再沒有其他的方法了。
所以對於迭代器中的元素只能刪，不能加。
而且這裏的移除只是針對於迭代器中的元素，而非Iterator所操作的集合的元素，即就是集合對象不能動。

3、迭代方法：
iterator()方法——是所操作的集合類的方法
——是集合類的引用 . iterator()—>返回的是一個Iterator對象

    for(Iterator  it = list.iterator(); it.hasNext();){
           //假如要輸出的是String類型
        String s = (String) it.next();//一條一條的將迭代器對象中的元素讀出來
    }
———————————————————————————————————————————————————————————————————————
    Iterator  it = 集合引用 . iterator();
             while(it.hasNext()){
                 Object o=it.next();
             }

4、使用示例
注意： Object next() 返回的是一個Object對象，必須強制轉換爲需要的類型。

【ArrayList遍歷】：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        Iterator<String> it=list.iterator();//得到一個list的迭代器
        while (it.hasNext()){
            //將迭代的下標移動一位，並得到當前位置的元素
            String s=it.next();
            System.out.println(s);
        }
    }
}

首先創建了一個List 的集合對象，並放入兩個字符串對象元素；
然後通過iterator()方法得到迭代器。Iterator()方法正是由Iterable接口所規定的，ArrayList 對該方法提供了具體的實現。

【LinkedList遍歷】：

List<String> link=new LinkedList<String>();
link.add("AAA");
link.add("BBB");
Iterator it=link.iterator();
while(it.hasNext()){
    String s=(String)it.next(); //it.next()返回的是Object對象
    System.out.println(s);
}

【HashSet遍歷】：

Set<String> set=new HashSet<String>();
set.add("AAA");
set.add("BBB");
Iterator it=set.iterator();
while(it.hasNext()){
    String s=(String)it.next(); //it.next()返回的是Object對象
    System.out.println(s);
}

比較器 Comparable 和 Comparator

Comparable ——自然順序的比較

Comparable 在 java.lang包下，是一個接口，內部只有一個方法 compareTo()：

public interface Comparable<T> {
     public int compareTo(T o);
}

Comparable 可以讓實現它的類的對象進行比較，具體的比較規則是按照compareTo 方法中的規則進行。這種順序稱爲 自然順序。
compareTo 方法的返回值有三種情況：

/*
* @param   o the object to be compared.
* @return  a negative integer, zero, or a positive integer as this object
*          is less than, equal to, or greater than the specified object.
*/
e1.compareTo(e2) < 0 即 e1 < e2
e1.compareTo(e2) = 0 即 e1 = e2
e1.compareTo(e2) >0  即 e1 > e2

【自然順序代碼實現】

 //自然順序是——>必須實現一個Comparable接口
 
 //該類可以和另一個Person類進行比較
public class Person implements Comparable<Person>{
    public String name;
    public int age;
    public int height;
    public int weight;
    public int level;
    public int gender;

    @Override
    public int compareTo(Person o) {
        return age-o.age;
        /*
        if(age<o.age){
            return -1;
        }else if(age==o.age){
            return 0;
        }else {
            return 1;
        }
        */
    }

    public static void main(String[] args) {
        Person p=new Person();
        p.name="James";
        p.age=18;
        Person q=new Person();
        q.name="Tom";
        q.age=20;

        int r=p.compareTo(q);
        if(r<0){
            System.out.println("p小於q");
        }else if(r==0){
            System.out.println("p等於q");
        }else {
            System.out.println("p大於q");
        }
    }
}

像String、Integer這些類已經天生就實現了Comparable接口
===》所以字符串、數字本身就是具有自然順序。
後面重寫 compareTo 時，要判斷某個相同時對比下一個屬性，把所有屬性都比較一次。

Comparator ——對象的非自然順序的比較

Comparator 是java中的接口，位於java.util包下，該接口抽象度極高，有必要掌握該接口的使用，排序其實只是Comparator能實現的功能之一，它不僅限於排序。

1、接口定義

public interface Comparator<T> {
    //主要方法
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

在List或數組中的對象如果沒有實現Comparable接口時，那麼就需要調用者爲需要排序的數組或List設置一個Compartor，Compartor的compare方法用來告訴代碼應該怎麼去比較兩個實例， 然後根據比較結果進行排序。

2、非自然順序代碼實現
對於非自然順序的比較，必須要實現一個Comparator接口，並且要自己手動構造一個比較器，例如：

import java.util.Comparator;

// 利用Comparator接口的實現類去執行排序功能
class PersonNameComparator  implements Comparator<Person> {
    public String name;
    public int age;
    public int height;
    public int weight;
    public int level;
    public int gender;

    @Override
    public int compare(Person o1, Person o2) {
        return o1.name.compareTo(o2.name);
    }

    public static void main(String[] args) {
        Person p=new Person();
        p.name="James";
        p.age=18;
        Person q=new Person();
        q.name="Tom";
        q.age=20;

        //構造一個比較器
        Comparator<Person> comparator=new PersonNameComparator();
        System.out.println("按照姓名比較");
        int s=comparator.compare(p,q);
        if(s<0){
            System.out.println("p小於q");
        }else if(s==0){
            System.out.println("p等於q");
        }else {
            System.out.println("p大於q");
        }
    }
}