【152天】尚学堂高淇Java300集视频精华笔记（119-120）

一点小心得（2017.7.7）

1. 裴新老师讲课好快啊！内容密度好高啊！消化好困难啊！

2. 我发现以讲求质量，不骗自己为标准，完全不可能做到339的量，慢慢来吧，先调整为333，之后每3天加1课。

3. 我发现：面对一个不知道怎么下手的题目，最好的办法就是最朴素的办法，以终为始，不断拆分，最近这七个周期，就训练这个简单的思维模型了。

第119集：自定义实现迭代器、深入迭代器、迭代器原理、面向对象实现

迭代器为什么是内部类？

答：节约内存，提高效率。如下例所示，若不使用内部类，每一次迭代都需要重新创建一个容器对象，而使用内部类则不一样，可以只是重新调用迭代器的方法新建一个内部类对象，大大节约了内存。

例1：不用内部类的情形

package test119;

import java.util.Iterator;

public class MyArrayList2 {
    
    private String[] elem = {"a","b","c"};
    private int cursor = -1;
    private int size = elem.length;
    
    
    public boolean hasNext(){
        return cursor!=size-1;
    }
    
    public String next(){
        cursor++;
        return elem[cursor];
    }
    
    public void remove(){
        //这里写实现
    }

    
    public static void main(String[] args){
        //遍历第一遍 创建一个容器对象
        MyArrayList2 list = new MyArrayList2();
        while(list.hasNext()){
            String str = list.next();
            System.out.println(str);
        }
        //遍历第二遍 再创建一个容器对象
        MyArrayList2 list2 = new MyArrayList2();
        while(list2.hasNext()){
            String str = list2.next();
            System.out.println(str);
        }
        
    }
}

例2：用了内部类的情形

package test119;

import java.util.Iterator;

public class MyArrayList2 {
    
    private String[] elem = {"a","b","c"};
    

    private class M implements Iterator<String>{
        private int cursor = -1;
        private int size = elem.length;
        
        public boolean hasNext(){
            return cursor!=size-1;
        }
        
        public String next(){
            cursor++;
            return elem[cursor];
        }
        
        public void remove(){
            //这里写实现
        }
    }
    
    public Iterator<String> iterator(){
        return new M();
    }
    
    public static void main(String[] args){
        //遍历第一遍 创建一个迭代器
        MyArrayList2 list = new MyArrayList2();
        Iterator<String> itr = list.iterator();
        while(itr.hasNext()){
            String str = itr.next();
            System.out.println(str);
        }
        //遍历第二遍 再创建一个迭代器，
        Iterator<String> itr2 = list.iterator();
        while(itr2.hasNext()){
            String str = itr2.next();
            System.out.println(str);
        }
        
    }
}

例3：进一步改良：改写为匿名内部类

package test119;

import java.util.Iterator;

public class MyArrayList3 {
    
    private String[] elem = {"a","b","c"};
        
    public Iterator<String> iterator(){
        return new Iterator<String>(){ //因为上例M只使用了一次，所以这里直接使用匿名内部类了
            private int cursor = -1;
            private int size = elem.length;
            
            public boolean hasNext(){
                return cursor!=size-1;
            }
            
            public String next(){
                cursor++;
                return elem[cursor];
            }
            
            public void remove(){
                //这里写实现
            }
        };
    }
    
    public static void main(String[] args){
        MyArrayList3 list = new MyArrayList3();
        Iterator<String> itr = list.iterator();
        while(itr.hasNext()){
            String str = itr.next();
            System.out.println(str);
        }    
    }
}

此处补充匿名内部类相关知识：看第一部分即可

例4：进一步改良：使用增强for循环

1. 使用增强for循环必须实现java.lang.Iterable<T>接口,重写iterator方法。

2. 注意区分Iterable<T>接口和Iterator<T>接口

3. Iterable<T>接口里面的重要方法：Iterator<T> iterator();

4. Iterator<E>接口里面的重要方法：

   1. boolean hasNext（）;

   2. E next();

   3. default void remove();

package test119;

import java.util.Iterator;

public class MyArrayList4 implements Iterable<String>{
    
    private String[] elem = {"a","b","c"};
        
    public Iterator<String> iterator(){
        return new Iterator<String>(){ //因为上例M只使用了一次，所以这里直接使用匿名内部类了
            private int cursor = -1;
            private int size = elem.length;
            
            public boolean hasNext(){
                return cursor!=size-1;
            }
            
            public String next(){
                cursor++;
                return elem[cursor];
            }
            
            public void remove(){
                //这里写实现
            }
        };
    }
    
    public static void main(String[] args){
        MyArrayList4 list = new MyArrayList4();
        Iterator<String> itr = list.iterator();
        for(String temp:list){
            System.out.println(temp);
        }
    }
}

第120集：HashMap、经典存储分拣思路

package test120;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @author wangtao
 * 往Map里面存数据的两种分拣思路
 */
public class Test {
    public static void main(String[] args){
        String test = "this is a cat and this is a dog";
        String[] arr = test.split(" ");
        
        Map<String,Letter> letters = new HashMap<String,Letter>();
        //思路一：先为每一个key创建容器，再装数据
//        for(String temp:arr){
//            if(!letters.containsKey(temp)){
//                letters.put(temp, new Letter());
//            }
//            Letter col = letters.get(temp);
//            col.setCount(col.getCount()+1);
//        }
        
        //思路二：遇见一个key，进行一次检查（有无容器），若有，直接装数据；若无，创建一个容器再装数据。
//        for(String temp:arr){
//            if(!letters.containsKey(temp)){
//                Letter col = new Letter();
//                col.setCount(1);
//                letters.put(temp,col);
//            } else {
//                Letter col = letters.get(temp);
//                col.setCount(col.getCount()+1);
//            }
//        }
        
        //思路二的另一种写法
        Letter col = null;
        for(String temp:arr){
            if(null==(col = letters.get(temp))){
                col = new Letter();
                col.setCount(1);
                letters.put(temp, col);
            }else{
                col.setCount(col.getCount()+1);
            }
        }
        
        
        
        //遍历已经存了数据的Map
        Set<String> a = new HashSet<String>();
        a = letters.keySet();
        for(Iterator<String> itr = a.iterator();itr.hasNext();){
            String key = (String)itr.next();
            System.out.println("单词:"+key+"  次数:"+letters.get(key).getCount());
        }
        
    }
}