迭代器的扩展

1. map迭代器
   MapIterator 很方便，以后将不再使用map.keyset来用Iterator访问了。
   要使用这个map必须要实现IterableMap接口，而commons提供了很好的实现类HashedMap。

public static void hashedMap(){
        HashedMap<String,String> map=new HashedMap<>();
        map.put("a", "handsome");
        map.put("b", "littleugly");
        map.put("c", "coll");
        
        MapIterator<String,String> it=map.mapIterator();
        while(it.hasNext()){
            /**
             * it.next();
             * String key=it.getKey();
             * 使用这种迭代有可能会忘记掉it.next造成错误，所以推荐用下面的
             */
            String key=it.next();
            String value=map.get(key);
            System.out.println(key+"----->"+value);
        }
    }

2. 去重迭代器，相当于去除重复的过滤器
   用 new UniqueFilterIterator（迭代器）；来包装某容器的迭代器
   再遍历时，即可去重

public static void uniqueFilterIterator(){
        List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("a");
        list.add("c");
        //返回一个Iterator
        Iterator<String> it=new UniqueFilterIterator<String>(list.iterator());
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
输出结果：
a
b
c

3. 自定义规则的迭代器
   FilterIterator自定义过滤+Predicate
   使用new FilterIterator(迭代器，断言);返回一个迭代器

    public static void filterIterator(){
        List<String> list=new ArrayList<>();
        list.add("Viking");
        list.add("and");
        list.add("handsome");
        list.add("Apple");
        list.add("hello");
        
        //字符串带有a则返回false
        Predicate<String> predicate=new Predicate<String>() {

            public boolean evaluate(String str) {
                char c;
                for(int i=0;i<str.length();i++)
                    {
                        c=str.charAt(i);
                        if(c=='a')
                            return false;//带a返回false
                    }
                return true;
            }
        };
        
        Iterator<String> it=new FilterIterator<String>(list.iterator(),predicate);
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
输出结果：
Viking
Apple
hello

4. 循环迭代器
   LoopingIterator
   使用new LoopingIterator(容器)；返回一个迭代器

public static void loopingIterator(){
        List<String> list=new ArrayList<>();
        list.add("Viking");
        list.add("and");
        list.add("handsome");
        
        Iterator<String> it=new LoopingIterator<String>(list);
        //限定输出的元素个数
        for(int i=0;i<5;i++){
            System.out.println(it.next());
        }
    }
输出结果：
Viking
and
handsome
Viking
and

5. 数组迭代器
   new ArrayListIterator<T>(数组，索引起始，索引终止)；
   也可以不指定索引

public static void arrayIterator(){
        int[] a={1,2,3,4,5,6,7,8,9};
        //全部迭代
        Iterator<Integer> it=new ArrayListIterator<Integer>(a);
        while(it.hasNext())
            System.out.print(it.next()+"\t");
        System.out.println();
        //限定索引
        Iterator<Integer> it2=new ArrayListIterator<Integer>(a,3,8);
        while(it2.hasNext())
            System.out.print(it2.next()+"\t");
    }
输出结果：
1   2   3   4   5   6   7   8   9   
4   5   6   7   8   

双向Map

跟guava里的biMap类似。
要求键跟值都不能重复，所以可以反转。使用inverseBidiMap();方法

1. DualTreeBidiMap(); 有序的
2. DualHashBidiMap(); 无序的

有序的，元素放进去的时候就排序了

    public static void main(String[] args) {
        BidiMap<String,String> bidimap=new DualTreeBidiMap<>();
        bidimap.put("mom", "mom@qq.com");
        bidimap.put("dad", "dad@hotmail.com");
        bidimap.put("yang", "yang@hotmail.com");
        bidimap.put("viking", "viking@qq.com");
        
        MapIterator<String,String> it=bidimap.mapIterator();
        
        while(it.hasNext()){
            String key=it.next();
            String value=it.getValue();
            System.out.println(key+"------>"+value);
        }
        //反转后通过值来获得键
        System.out.println(bidimap.inverseBidiMap().get("dad@hotmail.com"));
    }
输出结果：
dad------>dad@hotmail.com
mom------>mom@qq.com
viking------>viking@qq.com
yang------>yang@hotmail.com
dad

无序的就是没排序的，没啥特别的

Bag 包，可以重复

1. HashBag 无序
2. TreeBag 有序
   添加和删除时可以选择次数
   add(内容，次数)
   remove一样

public static void main(String[] args) {
        Bag<String> bag=new HashBag<>();
        bag.add("a");
        bag.add("a",3);
        bag.remove("a",2);
        bag.add("b",3);
        Iterator<String> it=bag.iterator();
        while(it.hasNext())
            System.out.print(it.next()+"\t");
    }
结果：
a   a   b   b   b   

利用bag来解决之前的统计字符串数量的问题

public static void main(String[] args) {
        String str="this is a cat and that is a mice where is the food";
        String[] strs=str.split(" ");
        Bag<String> bag=new HashBag<>();
        for(int i=0;i<strs.length;i++){
            bag.add(strs[i]);
        }
        //获取其中所有不重复元素的set
        Set<String> set=bag.uniqueSet();
        //遍历
        for(String temp:set){
            System.out.println(temp+"------->"+bag.getCount(temp));//bag.getCount()可以获得该元素的数量
        }
    }```