《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");
        }
    }
}