顶级学习方法，希望值得你借鉴

前言：

这是不熟悉的一些技术点，如果你对某一部分知识感到陌生或者感觉不熟练就将它写进来，逐步学习完再将其从中去掉；还有一些让我读不懂的代码或者不叫读不懂，让我很难受，就是每一句干啥都知道，但是完全理解不了，需要你下来慢慢研究底层慢慢啃，甚至是背。

我觉得针对以下的问题要分策略解决：

技术点：学习一个技术点先学会怎么去使用，反反复复的使用，直至得心应手，然后开始去研究它为什么这么用，一步一步地由浅入深地看底层，先看懂了解清楚底层，再手写底层源码。

不熟悉的代码：反反复复地看，反反复复地研究，直至最后手写底层源码。

不熟悉的技术点（反复揣摩，反复思考）

1.策略枚举

2.迭代器

3.HashMap

4.线程局部变量共享

5.枚举

6.volatile – 防止指令重排

7.内部类

8.线程池

9.I/O流

不熟悉的代码(不断看流程，自写底层，追求优化)

1.这是HashMap的value排序，我看不懂

public class Test03 {
	/**
	 * 知识点：HashMap的面试题
	 * 
	 * 需求：给HashMap的value排序
	 * 思路：
	 * 		HashMap 获取映射关系对象的Set集合 -> ArrayList对象 -> list.sort(外置比较器) 
	 */
	public static void main(String[] args) {
		
		HashMap<String,Integer> map = new HashMap<>();
		
		map.put("麻生希", 28);
		map.put("椎名空", 23);
		map.put("水菜丽", 29);
		map.put("朝桐光", 21);
		map.put("侯小康", 21);
		map.put("北岛玲", 28);
		
		//获取映射关系对象的集合
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		
		//将Set集合转换为ArraryList集合
		ArrayList<Entry<String,Integer>> list = new ArrayList<>(entrySet);
		
		//排序
		list.sort(new Comparator<Entry<String,Integer>>() {
			@Override
			public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
				return o1.getValue() - o2.getValue();
			}
		});
		
		for (Entry<String, Integer> entry : list) {
			System.out.println(entry);
		}
		
		
	}
}

2.这是ThreadLocal实现多线程局部变量共享的代码，我看不懂

public class Test01 {
    /**
     * 知识点：线程局部变量共享
     *
     * 需求：共享多个数据 - 使用ThreadLocal
     * @param args
     */
    public static ThreadLocal<Date> local = new ThreadLocal<>();

    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 10;
                String str = "用良心作教育";
                Date date = Date.getIntance(i,str);

                local.set(date);

                A a = new A();
                B b = new B();
                a.println();
                b.println();
            }
        },"线程1").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 20;
                String str = "做真实的自己";
                Date date = Date.getIntance(i, str);

                local.set(date);

                A a = new A();
                B b = new B();
                a.println();//20
                b.println();//20
            }
        }, "线程2").start();

    }
}



public class Date {
    private int i;
    private String str;

    public Date(int i,String str) {
        this.i = i;
        this.str = str;
    }

    //该方法保证了当前线程只能有一个Data对象
    public static Date getIntance(int i,String str){
        //获取当前线程的Data对象
        Date date = Test01.local.get();
        //判断data对象是否存在
        if(date == null){
            date = new Date(i, str);
        }else {
            date.setI(i);
            date.setStr(str);
        }

        return date;
    }

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return i + "--" + str;
    }
}

public class A {
    public void println(){
        Thread thread = new Thread();
        Date value = Test01.local.get();
        System.out.println(thread.getName() + "里的A类对象获取了数据：" + value);
    }
}

public class B {
    public void println(){
        Thread thread = new Thread();
        Date value = Test01.local.get();
        System.out.println(thread.getName() + "里的B类对象获取了数据：" + value);
    }
}