Java核心类库——集合的迭代（遍历） Iterator接口

集合的迭代（遍历）
 使用于：List,Set
 集合的迭代，是一种遍历算法
 1） 迭代操作举例：播放列表的“逐个播放”；将扑克牌“逐一发放“
 2） java使用Iterator接口描述了迭代模式操作
  Itertator中的方法，专门为while循环设计
 3）Iterator的实例可以从集合对象获得，是这个集合的一个元素序列视图，默认包含一个操作游标（在第一个元素之前）
 ＊ hasNext()方法，可以检查游标是否有下一个元素
 ＊ next()方法，移动游标到下一个元素，并且返回这个元素引用
 使用while循环配合这两个方法，可以迭代处理集合所有的元素
 4）迭代时可以使用迭代起remove()方法删除刚刚迭代的元素在迭代过程中

 ＊迭代时不能用使用集合方法（add,remove,set）更改集合元素

例子

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.List;
 4 
 5 public class IteratorDemo {
 6  public static void main(String[] args) {
 7   List<String> eggs = new ArrayList<String>();
 8   eggs.add("鸡蛋");
 9   eggs.add("坏蛋");
10   eggs.add("鸭蛋");
11   eggs.add("鹅蛋");
12   eggs.add("傻蛋");
13   Iterator ite = eggs.iterator();
14   while(ite.hasNext()){//hasNext()方法返回一个bollean类型的值，判断是否有下一个
15    String str = ite.next();//ite.next()访问下一个元素
16    System.out.println(str);
17    ite.remove();//删除已经访问过的元素
18   }
19  }

Map的迭代(遍历)
三种遍历方式
A 对Key：value 进行迭代
 map.entrySet();
 ＊利用key:value对（Entry）的迭代输出结果
 ＊Entry 接口在Map接口中定义,代表Map集合中的条目
 ＊Map集合可以看作是Entry组成的集合
 ＊使用map.entrySet()方法返回所有Entry组成的Set集合
 ＊每个元素的类型是Entry

  Set<Entry<Character,Integer>> entrySet = map.entrySet();
  
  for(Iterator<Entry<Character,Integer>> i=entrySet.iterator();i.hasNext();){
   Entry<Character,Integer> entry = i.next();
   Character ch = entry.getKey();
   Integer n = entry.getValue();
  }

B 对Key进行迭代
 map.keySet();
 ＊map中的Key是不重复，无序的集合，所以map.keySet()
 ＊返回了Set类型的集合

  Set<Character> keys = map.keySet();//全部Key
  Iterator<Character> its = keys.iterator()
  while(its.hasNext()){
   char ch = its.next() ;
   System.out.println(ch);//打印出所有的Key
  }

C 对Value进行迭代
 map.values();
 ＊map.values() 返回map中所有Value,组成一个集合
 ＊这个集合的值可能有重复，并且无序，所以是Collection类型

 Collection<Integer> values = map.values();
 for(Iterator<Integer> its = values.iterator(); its.hasNext();){
   int n = its.next();
   System.out.println(n);//打印出所有的value
  }

案例：统计每个字符出现的次数
String s = "aabcbca";
统计结果
a:3 k:v
b:2
c:2

例子：

  1 import java.util.ArrayList;
  2 import java.util.Collection;
  3 import java.util.Collections;
  4 import java.util.Comparator;
  5 import java.util.HashMap;
  6 import java.util.Iterator;
  7 import java.util.List;
  8 import java.util.Map;
  9 import java.util.Map.Entry;
 10 import java.util.Set;
 11 
 12 public class CharConuterDemo {
 13  public static void main(String[] args) {
 14   Map<Character,Integer> map = countAll("abccacedbba");
 15   System.out.println(map);
 16   
 17   System.out.println("迭代Map的Values 实现统计字符总数:");
 18   //map.values() 返回map中所有Value,组成一个集合
 19   //这个集合的值可能有重复，并且无序，所以是Collection类型
 20   Collection<Integer> values = map.values();
 21   int all = 0;
 22   for(Iterator<Integer> its = values.iterator(); its.hasNext();){
 23    int n = its.next();
 24    all+=n;
 25   }
 26   System.out.println("总字符数:"+all);
 27   
 28   Set<Character> keys = map.keySet();//全部Key
 29   //map中的Key是不重复，无序的集合，所以map.keySet()
 30   //返回了Set类型的集合，
 31   for(Iterator<Character> its = keys.iterator();its.hasNext();){
 32    char ch = its.next() ;
 33    int n = map.get(ch);
 34    System.out.println(ch + ":" + n
 35      + "占总数的" + ((double)n/all)*100);
 36   }
 37   //利用key:value对（Entry）的迭代输出结果
 38   //在迭代之前，要先排序，再迭代输出
 39   System.out.println("利用key:value对(Entry)迭代输出");
 40   //Entry 接口在Map接口中定义,代表Map集合中的条目
 41   //Map集合可以看作是Entry组成的集合
 42   //使用map.entrySet()方法返回所有Entry组成的Set集合
 43   //每个元素的类型是Entry
 44   Set<Entry<Character,Integer>> entrySet = map.entrySet();
 45   List<Entry<Character,Integer>> list = 
 46    new ArrayList<Entry<Character,Integer>>(entrySet);
 47   Collections.sort(list,new ByValue());
 48   for(Iterator<Entry<Character,Integer>> i=list.iterator();i.hasNext();){
 49    Entry<Character,Integer> entry = i.next();
 50    Character ch = entry.getKey();
 51    Integer n = entry.getValue();
 52   }
 53  }
 54  /**
 55   * 统计字符串中每个字符的数量
 56   * @param str一个被统计的字符串
 57   * @return 一个统计的结果Map集合，其中Key是字符，value是出现次数
 58   * str = "aabccbea";
 59   * 
 60   */
 61  public static Map<Character,Integer> countAll(String str){
 62   //创建一个空map统计结果
 63   HashMap<Character,Integer> map = 
 64    new HashMap<Character,Integer>();
 65   //迭代字符串的每个字符，
 66   for(int i=0;i<str.length();i++){
 67    char ch = str.charAt(i);
 68    //检查map中是否包含这个字符
 69    if(map.containsKey(ch)){
 70     //如果包含(统计过),取出原统计值并对其+1，保存回map
 71     Integer n = map.get(ch);
 72     map.put(ch, n+1);
 73    }else{
 74     //如果没有包含，就添加新的统计结果为 1
 75     map.put(ch, 1);
 76    }
 77   }
 78   return map;
 79  }
 80 
 81 }
 82 class ByValue implements Comparator<Entry<Character,Integer>>{
 83  public int compare(Entry<Character,Integer> o1,Entry<Character,Integer> o2){
 84   return -(o1.getValue() - o2.getValue());
 85  }
 86 }
 87 
 88  
 89 
 90 sort()和Comparator之间不可告人的排序秘密
 91 
 92 例子:按照字符串数组长度排序
 93 常用写法(使用匿名类)
 94 import java.util.ArrayList;
 95 import java.util.Collections;
 96 import java.util.Comparator;
 97 import java.util.List;
 98 
 99 public class ComparatorDemo {
100  public static void main(String[] args) {
101   List<String> list= new ArrayList<String>();
102   list.add("Tom");
103   list.add("Jerry");
104   list.add("Andy");
105   Collections.sort(list, new Comparator<String>(){
106    public int compare(String o1,String o2){
107     return o1.length()-o2.length();  //按照字符串长度排序
108    }
109   });
110   System.out.println(list);
111  }
112 
113 }

例子2部分代码,按Value的大小排序

 1 List<Entry<Character,Integer>> list = 
 2    new ArrayList<Entry<Character,Integer>>();
 3   Collections.sort(list,new ByValue());
 4 //普通写法(未使用匿名类)
 5 class ByValue implements Comparator<Entry<Character,Integer>>{
 6  public int compare(Entry<Character,Integer> o1,Entry<Character,Integer> o2){
 7   //return (o1.getValue() - o2.getValue());//从小到大
 8   return -(o1.getValue() - o2.getValue());//从大到小
 9  }
10 }