无标签

发布日期: 2019-11-06

文章字数: 36.9k

阅读时长: 159 分

阅读次数:

Java

Oracle JDK有部分源码是闭源的，如果确实需要可以查看OpenJDK的源码，可以在该网站获取。
http://grepcode.com/snapshot/repository.grepcode.com/java/root/jdk/openjdk/8u40-b25/
http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/73d5bcd0585d/src
上面这个还可以查看native方法。

1.1 JDK&JRE&JVM
JDK（Java Development Kit)是针对Java开发员的产品，是整个Java的核心，包括了Java运行环境JRE、Java工具（编译、开发工具)和Java核心类库。
Java Runtime Environment（JRE)是运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。
JVM是Java Virtual Machine（Java虚拟机)的缩写，是整个java实现跨平台的最核心的部分，能够运行以Java语言写作的软件程序。
JDK包含JRE和Java编译、开发工具；
JRE包含JVM和Java核心类库；
运行Java仅需要JRE；而开发Java需要JDK。

1.2 跨平台
字节码是在虚拟机上运行的，而不是编译器。换而言之，是因为JVM能跨平台安装，所以相应JAVA字节码便可以跟着在任何平台上运行。只要JVM自身的代码能在相应平台上运行，即JVM可行，则JAVA的程序员就可以不用考虑所写的程序要在哪里运行，反正都是在虚拟机上运行，然后变成相应平台的机器语言，而这个转变并不是程序员应该关心的。

1.3 基础数据类型
第一类：整型 byte short int long
第二类：浮点型 float double
第三类：逻辑型 boolean(它只有两个值可取true false)
第四类：字符型 char
- byte(1)的取值范围为-128~127（-2的7次方到2的7次方-1)
- short(2)的取值范围为-32768~32767（-2的15次方到2的15次方-1)
- int(4)的取值范围为（-2147483648~2147483647)（-2的31次方到2的31次方-1)
- long(8)的取值范围为（-9223372036854774808~9223372036854774807)（-2的63次方到2的63次方-1)
- float(4)
- double(8)
- char(2)
- boolean(1/8)
内码是程序内部使用的字符编码，特别是某种语言实现其char或String类型在内存里用的内部编码；外码是程序与外部交互时外部使用的字符编码。“外部”相对“内部”而言；不是char或String在内存里用的内部编码的地方都可以认为是“外部”。例如，外部可以是序列化之后的char或String，或者外部的文件、命令行参数之类的。
Java语言规范规定，Java的char类型是UTF-16的code unit，也就是一定是16位（2字节)，然后字符串是UTF-16 code unit的序列。
Java规定了字符的内码要用UTF-16编码。或者至少要让用户无法感知到String内部采用了非UTF-16的编码。
String.getBytes()是一个用于将String的内码转换为指定的外码的方法。无参数版使用平台的默认编码作为外码，有参数版使用参数指定的编码作为外码；将String的内容用外码编码好，结果放在一个新byte[]返回。调用了String.getBytes()之后得到的byte[]只能表明该外码的性质，而无法碰触到String内码的任何特质。
- Java标准库实现的对char与String的序列化规定使用UTF-8作为外码。Java的Class文件中的字符串常量与符号名字也都规定用UTF-8编码。这大概是当时设计者为了平衡运行时的时间效率（采用定长编码的UTF-16)与外部存储的空间效率（采用变长的UTF-8编码)而做的取舍。

1.4 引用类型

类、接口、数组都是引用类型
四种引用
目的：避免对象长期占用内存，

强引用

StringReference GC时不回收
当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

软引用
SoftReference GC时如果JVM内存不足时会回收
软引用可用来实现内存敏感的高速缓存。软引用可以和一个引用队列（ReferenceQueue)联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

弱引用
WeakReference GC时立即回收
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。
弱引用可以和一个引用队列（ReferenceQueue)联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

虚引用
PhantomReference
如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
在Java集合中有一种特殊的Map类型：WeakHashMap，在这种Map中存放了键对象的弱引用，当一个键对象被垃圾回收，那么相应的值对象的引用会从Map中删除。WeakHashMap能够节约存储空间，可用来缓存那些非必须存在的数据。

基础数据类型包装类
为什么需要
由于基本数据类型不是对象，所以java并不是纯面向对象的语言，好处是效率较高（全部包装为对象效率较低)。
Java是一个面向对象的编程语言，基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，就出现了包装类型（如我们在使用集合类型Collection时就一定要使用包装类型而非基本类型)，它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。

有哪些

基本类型包装器类型
boolean Boolean
char Character
int Integer
byte Byte
short Short
long Long
float Float
double Double

Number是所有数字包装类的父类

自动装箱、自动拆箱（编译器行为)
自动装箱：可以将基础数据类型包装成对应的包装类
Integer i = 10000; // 编译器会改为new Integer(10000)
自动拆箱：可以将包装类转为对应的基础数据类型
int i = new Integer(1000);//编译器会修改为 int i = new Integer(1000).intValue();
自动拆箱时如果包装类是null，那么会抛出NPE

Integer.valueOf

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

调用Integer.valueOf时-128~127的对象被缓存起来。
所以在此访问内的Integer对象使用==和equals结果是一样的。
如果Integer的值一致，且在此范围内，因为是同一个对象，所以==返回true；但此访问之外的对象==比较的是内存地址，值相同，也是返回false。

1.5 Object

== 与 equals的区别

如果两个引用类型变量使用==运算符，那么比较的是地址，它们分别指向的是否是同一地址的对象。结果一定是false，因为两个对象不可能存放在同一地址处。
要求是两个对象都不是能空值，与空值比较返回false。
==不能实现比较对象的值是否相同。
所有对象都有equals方法，默认是Object类的equals，其结果与==一样。
如果希望比较对象的值相同，必须重写equals方法。
hashCode与equals的区别
Object中的equals:

public boolean equals(Object obj) {
    return (this == obj);
}

equals 方法要求满足：
自反性 a.equals(a)
对称性 x.equals(y) y.equals(x)
一致性 x.equals(y) 多次调用结果一致
对于任意非空引用x，x.equals(null) 应该返回false
Object中的hashCode:

public native int hashCode();

它是一个本地方法，它的实现与本地机器有关，这里我们暂且认为他返回的是对象存储的物理位置。
当equals方法被重写时，通常有必要重写hashCode方法，以维护hashCode方法的常规约定：值相同的对象必须有相同的hashCode。
- object1.equals(object2)为true，hashCode也相同；
- hashCode不同时，object1.equals(object2)为false；
- hashCode相同时，object1.equals(object2)不一定为true；
当我们向一个Hash结构的集合中添加某个元素，集合会首先调用hashCode方法，这样就可以直接定位它所存储的位置，若该处没有其他元素，则直接保存。若该处已经有元素存在，就调用equals方法来匹配这两个元素是否相同，相同则不存，不同则链到后面（如果是链地址法)。
先调用hashCode，唯一则存储，不唯一则再调用equals，结果相同则不再存储，结果不同则散列到其他位置。因为hashCode效率更高（仅为一个int值)，比较起来更快。
HashMap#put源码
hash是key的hash值，当该hash对应的位置已有元素时会执行以下代码（hashCode相同)
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
如果equals返回结果相同，则值一定相同，不再存入。

如果重写equals不重写hashCode会怎样
两个值不同的对象的hashCode一定不一样，那么执行equals，结果为true，HashSet或HashMap的键会放入值相同的对象。

1.6 String&StringBuffer&StringBuilder
都是final类，不允许继承；
String长度不可变，StringBuffer、StringBuilder长度可变；

String

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {}

equals&hashCode

String重写了Object的hashCode和equals。

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

添加功能

String是final类，不可被继承，也不可重写一个java.lang.String（类加载机制)。
一般是使用StringUtils来增强String的功能。
为什么只加载系统通过的java.lang.String类而不加载用户自定义的java.lang.String类呢？
双亲委派机制
因加载某个类时，优先使用父类加载器加载需要使用的类。如果我们自定义了java.lang.String这个类，
加载该自定义的String类，该自定义String类使用的加载器是AppClassLoader，根据优先使用父类加载器原理，
AppClassLoader加载器的父类为ExtClassLoader，所以这时加载String使用的类加载器是ExtClassLoader，
但是类加载器ExtClassLoader在jre/lib/ext目录下没有找到String.class类。然后使用ExtClassLoader父类的加载器BootStrap，
父类加载器BootStrap在JRE/lib目录的rt.jar找到了String.class，将其加载到内存中。这就是类加载器的委托机制。
所以，用户自定义的java.lang.String不被加载，也就是不会被使用。

+ substring
会创建一个新的字符串；
编译时会将+转为StringBuilder的append方法。
注意新的字符串是在运行时在堆里创建的。
String str1 = “ABC”;可能创建一个或者不创建对象，如果”ABC”这个字符串在java String池里不存在，会在java String池里创建一个创建一个String对象(“ABC”)，然后str1指向这个内存地址，无论以后用这种方式创建多少个值为”ABC”的字符串对象，始终只有一个内存地址被分配，之后的都是String的拷贝，Java中称为“字符串驻留”，所有的字符串常量都会在编译之后自动地驻留。
注意只有字符串常量是共享的，+和substring等操作的结果不是共享的，substring也会在堆中重新创建字符串。

public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > value.length) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    int subLen = endIndex - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
            : new String(value, beginIndex, subLen);
}

public String(char value[], int offset, int count) {
    if (offset < 0) {
        throw new StringIndexOutOfBoundsException(offset);
    }
    if (count <= 0) {
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        if (offset <= value.length) {
            this.value = "".value;
            return;
        }
    }
    // Note: offset or count might be near -1>>>1.
    if (offset > value.length - count) {
        throw new StringIndexOutOfBoundsException(offset + count);
    }
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}

常量池

String str = new String(“ABC”);
至少创建一个对象，也可能两个。因为用到new关键字，肯定会在heap中创建一个str2的String对象，它的value是“ABC”。同时如果这个字符串在字符串常量池里不存在，会在池里创建这个String对象“ABC”。
String s1= “a”;
String s2 = “a”;
此时s1 == s2 返回true
String s1= new String(“a”);
String s2 = new String(“a”);
此时s1 == s2 返回false
“”创建的字符串在字符串池中。
如果引号中字符串存在在常量池中，则仅在堆中拷贝一份(new String);
如果不在，那么会先在常量池中创建一份(“abc”)，然后在堆中创建一份(new String)，共创建两个对象。

编译优化

字面量，final 都会在编译期被优化，并且会被直接运算好。
- 1)注意c和d中，final变量b已经被替换为其字符串常量了。
- 2)注意f、g中，b被替换为其字符串常量，并且在编译时字符串常量的+运算会被执行，返回拼接后的字符串常量
- 3)注意j，a1作为final变量，在编译时被替换为其字符串常量
解释 c == h / d == h/ e== h为false：c是运行时使用+拼接，创建了一个新的堆中的字符串ab，与ab字符串常量不是同一个对象；
解释f == h/ g == h为true：f编译时进行优化，其值即为字符串常量ab，h也是，指向字符串常量池中的同一个对象；

String#intern（JDK1.7之后)
JDK1.7之后JVM里字符串常量池放入了堆中，之前是放在方法区。
intern()方法设计的初衷，就是重用String对象，以节省内存消耗。
一定是new得到的字符串才会调用intern，字符串常量没有必要去intern。
当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（该对象由 equals(Object) 方法确定)，则返回池中的字符串。否则，常量池中直接存储堆中该字符串的引用（1.7之前是常量池中再保存一份该字符串)。
源码

public native String intern();

实例一：
- String s = new String(“1”);
  s.intern();
  String s2 = “1”;
  System.out.println(s == s2);// false

String s3 = new String(“1”) + new String(“1”);
s3.intern();
String s4 = “11”;
System.out.println(s3 == s4);// true

String s = newString(“1”)，生成了常量池中的“1” 和堆空间中的字符串对象。
s.intern()，这一行的作用是s对象去常量池中寻找后发现”1”已经存在于常量池中了。
String s2 = “1”，这行代码是生成一个s2的引用指向常量池中的“1”对象。
结果就是 s 和 s2 的引用地址明显不同。因此返回了false。
String s3 = new String(“1”) + newString(“1”)，这行代码在字符串常量池中生成“1” ，并在堆空间中生成s3引用指向的对象（内容为”11”)。注意此时常量池中是没有 “11”对象的。
s3.intern()，这一行代码，是将 s3中的“11”字符串放入 String 常量池中，此时常量池中不存在“11”字符串，JDK1.6的做法是直接在常量池中生成一个 “11” 的对象。
但是在JDK1.7中，常量池中不需要再存储一份对象了，可以直接存储堆中的引用。这份引用直接指向 s3 引用的对象，也就是说s3.intern() ==s3会返回true。
String s4 = “11”，这一行代码会直接去常量池中创建，但是发现已经有这个对象了，此时也就是指向 s3 引用对象的一个引用。因此s3 == s4返回了true。
实例二：
- String s3 = new String(“1”) + new String(“1”);
  String s4 = “11”;
  s3.intern();
  System.out.println(s3 == s4);// false
String s3 = new String(“1”) + newString(“1”)，这行代码在字符串常量池中生成“1” ，并在堆空间中生成s3引用指向的对象（内容为”11”)。注意此时常量池中是没有 “11”对象的。
String s4 = “11”，这一行代码会直接去生成常量池中的”11”。
s3.intern()，这一行在这里就没什么实际作用了。因为”11”已经存在了。
结果就是 s3 和 s4 的引用地址明显不同。因此返回了false。
实例三：
- String str1 = new String(“SEU”) + new String(“Calvin”);
  System.out.println(str1.intern() == str1);// true
  System.out.println(str1 == “SEUCalvin”);// true
str1.intern() == str1就是上面例子中的情况，str1.intern()发现常量池中不存在“SEUCalvin”，因此指向了str1。 “SEUCalvin”在常量池中创建时，也就直接指向了str1了。两个都返回true就理所当然啦。

实例四：
- String str2 = “SEUCalvin”;//新加的一行代码，其余不变
  String str1 = new String(“SEU”) + new String(“Calvin”);
  System.out.println(str1.intern() == str1);// false
  System.out.println(str1 == “SEUCalvin”);// false
在实例三的基础上加了第一行
str2先在常量池中创建了“SEUCalvin”，那么str1.intern()当然就直接指向了str2，你可以去验证它们两个是返回的true。后面的”SEUCalvin”也一样指向str2。所以谁都不搭理在堆空间中的str1了，所以都返回了false。

StringBuffer&StringBuilder
StringBuffer是线程安全的，StringBuilder不是线程安全的，但它们两个中的所有方法都是相同的。StringBuffer在StringBuilder的方法之上添加了synchronized，保证线程安全。
StringBuilder比StringBuffer性能更好。

1.7 面向对象

抽象类与接口

区别：
- 1)抽象类中方法可以不是抽象的；接口中的方法必须是抽象方法；
- 2)抽象类中可以有普通的成员变量；接口中的变量必须是 static final 类型的，必须被初始化 , 接口中只有常量，没有变量。
- 3)抽象类只能单继承，接口可以继承多个父接口；
- 4)Java8 中接口中会有 default 方法，即方法可以被实现。
使用场景：
如果要创建不带任何方法定义和成员变量的基类，那么就应该选择接口而不是抽象类。
如果知道某个类应该是基类，那么第一个选择的应该是让它成为一个接口，只有在必须要有方法定义和成员变量的时候，才应该选择抽象类。因为抽象类中允许存在一个或多个被具体实现的方法，只要方法没有被全部实现该类就仍是抽象类。

三大特性
面向对象的三个特性：封装；继承；多态
封装：将数据与操作数据的方法绑定起来，隐藏实现细节，对外提供接口。
继承：代码重用；可扩展性
多态：允许不同子类对象对同一消息做出不同响应
多态的三个必要条件：继承、方法的重写、父类引用指向子类对象

重写和重载
根据对象对方法进行选择，称为分派
编译期的静态多分派：overloading重载根据调用引用类型和方法参数决定调用哪个方法（编译器)
运行期的动态单分派：overriding 重写根据指向对象的类型决定调用哪个方法（JVM)

1.8 关键类

ThreadLocal（线程局部变量)

在线程之间共享变量是存在风险的，有时可能要避免共享变量，使用ThreadLocal辅助类为各个线程提供各自的实例。
例如有一个静态变量

public static final SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd”);

如果两个线程同时调用sdf.format(…)
那么可能会很混乱，因为sdf使用的内部数据结构可能会被并发的访问所破坏。当然可以使用线程同步，但是开销很大；或者也可以在需要时构造一个局部SImpleDateFormat对象。但这很浪费。
希望为每一个线程构造一个对象，即使该线程调用多次方法，也只需要构造一次，不必在局部每次都构造。

public static final ThreadLocal<SimpleDateFormat> sdf = new ThreadLocal<SimpleDateFormat>() {
    @Override
    protected SimpleDateFormat initialValue() {
        return new SimpleDateFormat("yyyy-MM-dd");
    }
};

实现原理：
1)每个线程的变量副本是存储在哪里的
ThreadLocal的get方法就是从当前线程的ThreadLocalMap中取出当前线程对应的变量的副本。该Map的key是ThreadLocal对象，value是当前线程对应的变量。

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
【注意，变量是保存在线程中的，而不是保存在ThreadLocal变量中】。当前线程中，有一个变量引用名字是threadLocals，这个引用是在ThreadLocal类中createmap函数内初始化的。
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
每个线程都有一个这样的名为threadLocals 的ThreadLocalMap，以ThreadLocal和ThreadLocal对象声明的变量类型作为key和value。
Thread
ThreadLocal.ThreadLocalMap threadLocals = null;
这样，我们所使用的ThreadLocal变量的实际数据，通过get方法取值的时候，就是通过取出Thread中threadLocals引用的map，然后从这个map中根据当前threadLocal作为参数，取出数据。现在，变量的副本从哪里取出来的（本文章提出的第一个问题)已经确认解决了。
每个线程内部都会维护一个类似 HashMap 的对象，称为 ThreadLocalMap，里边会包含若干了 Entry（K-V 键值对)，相应的线程被称为这些 Entry 的属主线程；
Entry 的 Key 是一个 ThreadLocal 实例，Value 是一个线程特有对象。Entry 的作用即是：为其属主线程建立起一个 ThreadLocal 实例与一个线程特有对象之间的对应关系；
Entry 对 Key 的引用是弱引用；Entry 对 Value 的引用是强引用。

2)为什么ThreadLocalMap的Key是弱引用
如果是强引用，ThreadLocal将无法被释放内存。
因为如果这里使用普通的key-value形式来定义存储结构，实质上就会造成节点的生命周期与线程强绑定，只要线程没有销毁，那么节点在GC分析中一直处于可达状态，没办法被回收，而程序本身也无法判断是否可以清理节点。弱引用是Java中四档引用的第三档，比软引用更加弱一些，如果一个对象没有强引用链可达，那么一般活不过下一次GC。当某个ThreadLocal已经没有强引用可达，则随着它被垃圾回收，在ThreadLocalMap里对应的Entry的键值会失效，这为ThreadLocalMap本身的垃圾清理提供了便利。

3)ThreadLocalMap是何时初始化的（setInitialValue)
在get时最后一行调用了setInitialValue，它又调用了我们自己重写的initialValue方法获得要线程局部变量对象。ThreadLocalMap没有被初始化的话，便初始化，并设置firstKey和firstValue；如果已经被初始化，那么将key和value放入map。

private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

4)ThreadLocalMap 原理

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

它也是一个类似HashMap的数据结构，但是并没实现Map接口。
也是初始化一个大小16的Entry数组，Entry对象用来保存每一个key-value键值对，只不过这里的key永远都是ThreadLocal对象，通过ThreadLocal对象的set方法，结果把ThreadLocal对象自己当做key，放进了ThreadLoalMap中。
ThreadLoalMap的Entry是继承WeakReference，和HashMap很大的区别是，Entry中没有next字段，所以就不存在链表的情况了。
构造方法
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
- // 表的大小始终为2的幂次
  table = new Entry[INITIAL_CAPACITY];
  int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
  table[i] = new Entry(firstKey, firstValue);
  size = 1;
// 设定扩容阈值
setThreshold(INITIAL_CAPACITY);
}
- 在ThreadLocalMap中，形如key.threadLocalHashCode & (table.length - 1)（其中key为一个ThreadLocal实例)这样的代码片段实质上就是在求一个ThreadLocal实例的哈希值，只是在源码实现中没有将其抽为一个公用函数。
- 对于& (INITIAL_CAPACITY - 1)，相对于2的幂作为模数取模，可以用&(2^n-1)来替代%2^n，位运算比取模效率高很多。至于为什么，因为对2^n取模，只要不是低n位对结果的贡献显然都是0，会影响结果的只能是低n位。

private void setThreshold(int len) {
    threshold = len * 2 / 3;
}

getEntry（由ThreadLocal#get调用)

private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else

// 因为用的是线性探测，所以往后找还是有可能能够找到目标Entry的。
```
  return getEntryAfterMiss(key, i, e);
```
}

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;

    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)

// 该entry对应的ThreadLocal已经被回收，调用expungeStaleEntry来清理无效的entry

expungeStaleEntry(i);

  else
      i = nextIndex(i, len);
  e = tab[i];

}
return null;
}

i是位置
从staleSlot开始遍历，将无效key（弱引用指向对象被回收)清理，即对应entry中的value置为null，将指向这个entry的table[i]置为null，直到扫到空entry。
另外，在过程中还会对非空的entry作rehash。
可以说这个函数的作用就是从staleSlot开始清理连续段中的slot（断开强引用，rehash slot等)

private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // expunge entry at staleSlot
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {

// 对于还没有被回收的情况，需要做一次rehash。
如果对应的ThreadLocal的ID对len取模出来的索引h不为当前位置i，
- 则从h向后线性探测到第一个空的slot，把当前的entry给挪过去。
  int h = k.threadLocalHashCode & (len - 1);
  if (h != i) {
  tab[i] = null;
  
  // Unlike Knuth 6.4 Algorithm R, we must scan until
  // null because multiple entries could have been stale.
  while (tab[h] != null)
  h = nextIndex(h, len);
  tab[h] = e;
  }
  }
  }
  return i;
  }

set（线性探测法解决hash冲突)

private void set(ThreadLocal<?> key, Object value) {

    // We don't use a fast path as with get() because it is at
    // least as common to use set() to create new entries as
    // it is to replace existing ones, in which case, a fast
    // path would fail more often than not.

    Entry[] tab = table;
    int len = tab.length;
    // 计算key的hash值

- int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
     e != null;
     e = tab[i = nextIndex(i, len)]) {
    ThreadLocal<?> k = e.get();

    if (k == key) {

// 同一个ThreadLocal赋了新值，则替换原值为新值

      e.value = value;
      return;
  }

  if (k == null) {

// 该位置的TheadLocal已经被回收，那么会清理slot并在此位置放入当前key和value（stale：陈旧的)
```
      replaceStaleEntry(key, value, i);
      return;
  }
```
}
// 下一个位置为空，那么就放到该位置上
tab[i] = new Entry(key, value);
int sz = ++size;
// 启发式地清理一些slot,并判断是否是否需要扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
```
  rehash();
```
}
每个ThreadLocal对象都有一个hash值 threadLocalHashCode，每初始化一个ThreadLocal对象，hash值就增加一个固定的大小 0x61c88647。

private final int threadLocalHashCode = nextHashCode();

private static final int HASH_INCREMENT = 0x61c88647;

private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

由于ThreadLocalMap使用线性探测法来解决散列冲突，所以实际上Entry[]数组在程序逻辑上是作为一个环形存在的。

private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

在插入过程中，根据ThreadLocal对象的hash值，定位到table中的位置i，过程如下：
1、如果当前位置是空的，那么正好，就初始化一个Entry对象放在位置i上；
2、不巧，位置i已经有Entry对象了，如果这个Entry对象的key正好是即将设置的key，那么重新设置Entry中的value；
3、很不巧，位置i的Entry对象，和即将设置的key没关系，那么只能找下一个空位置；
这样的话，在get的时候，也会根据ThreadLocal对象的hash值，定位到table中的位置，然后判断该位置Entry对象中的key是否和get的key一致，如果不一致，就判断下一个位置
可以发现，set和get如果冲突严重的话，效率很低，因为ThreadLoalMap是Thread的一个属性，所以即使在自己的代码中控制了设置的元素个数，但还是不能控制其它代码的行为。

cleanSomeSlots（启发式地清理slot)
i是当前位置，n是元素个数
i对应entry是非无效（指向的ThreadLocal没被回收，或者entry本身为空)
n是用于控制控制扫描次数的
正常情况下如果log n次扫描没有发现无效slot，函数就结束了
但是如果发现了无效的slot，将n置为table的长度len，做一次连续段的清理
再从下一个空的slot开始继续扫描
这个函数有两处地方会被调用，一处是插入的时候可能会被调用，另外个是在替换无效slot的时候可能会被调用，
区别是前者传入的n为元素个数，后者为table的容量

private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        i = nextIndex(i, len);
        Entry e = tab[i];
        if (e != null && e.get() == null) {
            n = len;
            removed = true;
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

rehash

先全量清理，如果清理后现有元素个数超过负载，那么扩容

private void rehash() {

- // 进行一次全量清理
expungeStaleEntries();

// Use lower threshold for doubling to avoid hysteresis
if (size >= threshold - threshold / 4)
    resize();

}

全量清理

private void expungeStaleEntries() {
    Entry[] tab = table;
    int len = tab.length;
    for (int j = 0; j < len; j++) {
        Entry e = tab[j];
        if (e != null && e.get() == null)
            expungeStaleEntry(j);
    }
}

扩容，因为需要保证table的容量len为2的幂，所以扩容即扩大2倍

private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;

    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }

    setThreshold(newLen);
    size = count;
    table = newTab;
}

remove

private void remove(ThreadLocal<?> key) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {

// 显式断开弱引用
```
      e.clear();
```

// 进行段清理

      expungeStaleEntry(i);
      return;
  }

}
}

Reference#clear

public void clear() {
    this.referent = null;
}

内存泄露

只有调用TheadLocal的remove或者get、set时才会采取措施去清理被回收的ThreadLocal对应的value（但也未必会清理所有的需要被回收的value)。假如一个局部的ThreadLocal不再需要，如果没有去调用remove方法清除，那么有可能会发生内存泄露。
既然已经发现有内存泄露的隐患，自然有应对的策略，在调用ThreadLocal的get()、set()可能会清除ThreadLocalMap中key为null的Entry对象，这样对应的value就没有GC Roots可达了，下次GC的时候就可以被回收，当然如果调用remove方法，肯定会删除对应的Entry对象。
如果使用ThreadLocal的set方法之后，没有显式的调用remove方法，就有可能发生内存泄露，所以养成良好的编程习惯十分重要，使用完ThreadLocal之后，记得调用remove方法。

JDK建议将ThreadLocal变量定义成private static的，这样的话ThreadLocal的生命周期就更长，由于一直存在ThreadLocal的强引用，所以ThreadLocal也就不会被回收，也就能保证任何时候都能根据ThreadLocal的弱引用访问到Entry的value值，然后remove它，防止内存泄露。

Iterator / ListIterator / Iterable
普通for循环时不能删除元素，否则会抛出异常；Iterator可以

public interface Collection<E> extends Iterable<E> {}

Collection接口继承了Iterable，Iterable接口定义了iterator抽象方法和forEach default方法。所以ArrayList、LinkedList都可以使用迭代器和forEach，包括增强for循环（编译时转为迭代器)。

public interface Iterable<T> {
    Iterator<T> iterator();
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

default Spliterator spliterator() {

  return Spliterators.spliteratorUnknownSize(iterator(), 0);

}

}
注意这些具体的容器类返回的迭代器对象是各不相同的，主要是因为不同的容器遍历方式不同，但是这些迭代器对象都实现Iterator接口，都可以使用一个Iterator对象来统一指向这些不同的子类对象。
ArrayList#iterator

public Iterator<E> iterator() {
    return new Itr();
}

ArrayList#Itr

private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    @Override
    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
        Objects.requireNonNull(consumer);
        final int size = ArrayList.this.size;
        int i = cursor;
        if (i >= size) {
            return;
        }
        final Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        // update once at end of iteration to reduce heap write traffic
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

ArrayList#listIterator

public ListIterator<E> listIterator() {
    return new ListItr(0);
}

ArrayList#ListItr

private class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {
        super();
        cursor = index;
    }

    public boolean hasPrevious() {
        return cursor != 0;
    }

    public int nextIndex() {
        return cursor;
    }

    public int previousIndex() {
        return cursor - 1;
    }

    @SuppressWarnings("unchecked")
    public E previous() {
        checkForComodification();
        int i = cursor - 1;
        if (i < 0)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i;
        return (E) elementData[lastRet = i];
    }

    public void set(E e) {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.set(lastRet, e);
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    public void add(E e) {
        checkForComodification();

        try {
            int i = cursor;
            ArrayList.this.add(i, e);
            cursor = i + 1;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
}

for /增强for/ forEach

For-each loop Equivalent for loop
for (type var : arr) {
body-of-loop
} for (int i = 0; i < arr.length; i++) {
type var = arr[i];
body-of-loop
}
for (type var : coll) {
body-of-loop
} for (Iterator iter = coll.iterator(); iter.hasNext(); ) {
type var = iter.next();
body-of-loop
}

增强for循环在编译时被修改为for循环：数组会被修改为下标式的循环；集合会被修改为Iterator循环。
增强for循环不适合以下情况：（过滤、转换、平行迭代)
对collection或数组中的元素不能做赋值操作；
只能正向遍历，不能反向遍历；
遍历过程中，collection或数组中同时只有一个元素可见，即只有“当前遍历到的元素”可见，而前一个或后一个元素是不可见的；
forEach
ArrayList#forEach继承自
Iterable接口的default方法
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
```
  action.accept(t);
```
}
}

Comparable与Comparator

基本数据类型包装类和String类均已实现了Comparable接口。
实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序，默认为升序。

可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort)，从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构（如TreeSet,TreeMap)的顺序。

1.9 继承

子类继承父类所有的成员变量（即使是private变量，有所有权，但是没有使用权，不能访问父类的private的成员变量)。

子类中可以直接调用父类非private方法，也可以用super.父类方法的形式调用。

子类构造方法中如果没有显式使用super(父类构造方法参数)去构造父类对象的话（如果有必须是方法的第一行)，编译器会在第一行添加super()。
子类的构造函数可否不使用super(父类构造方法参数)调用超类的构造方法？
可以不用显式的写出super，但前提是“父类中有多个构造方法，且有一个是显式写出的无参的构造方法”。

1.10 内部类

在另一个类的里面定义的类就是内部类
内部类是编译器现象，与虚拟机无关。
编译器会将内部类编译成用$分割外部类名和内部类名的常规类文件，而虚拟机对此一无所知。

内部类可以是static的，也可用public，default，protected和private修饰。（而外部类即类名和文件名相同的只能使用public和default)。

优点

每个内部类都能独立地继承一个（接口的)实现，所以无论外部类是否已经继承了某个（接口的)实现，对于内部类都没有影响。
接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。
用内部类还能够为我们带来如下特性：
1、内部类可以有多个实例，每个实例都有自己的状态信息，并且与其他外部对象的信息相互独立。
2、在单个外部类中，可以让多个内部类实现不同的接口，或者继承不同的类。外部类想要多继承的类可以分别由内部类继承，并进行Override或者直接复用。然后外部类通过创建内部类的对象来使用该内部对象的方法和成员，从而达到复用的目的，这样外部内就具有多个父类的所有特征。
3、创建内部类对象的时刻并不依赖于外部类对象的创建。
4、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
5、内部类提供了更好的封装，除了该外部类，其他类都不能访问
只有静态内部类可以同时拥有静态成员和非静态成员，其他内部类只有拥有非静态成员。

成员内部类：就像外部类的一个成员变量

注意内部类的对象总有一个外部类的引用
当创建内部类对象时，会自动将外部类的this引用传递给当前的内部类的构造方法。

静态内部类：就像外部类的一个静态成员变量

public class OuterClass {

    private static class StaticInnerClass {
        int id;
        static int increment = 1;
    }
}
//调用方式：
//外部类.内部类 instanceName = new 外部类.内部类();

局部内部类：定义在一个方法或者一个块作用域里面的类

想创建一个类来辅助我们的解决方案，又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。
JDK1.8之前不能访问非final的局部变量！
生命周期不一致：
方法在栈中，对象在堆中；方法执行完，对象并没有死亡
如果可以使用方法的局部变量，如果方法执行完毕，就会访问一个不存在的内存区域。
而final是常量，就可以将该常量的值复制一份，即使不存在也不影响。

public Destination destination(String str) {
    class PDestination implements Destination {
        private String label;

        private PDestination(String whereTo) {
            label = whereTo;
        }
        public String readLabel() {
            return label;
        }
    }
    return new PDestination(str);
}

匿名内部类：必须继承一个父类或实现一个接口

匿名内部类和局部内部类在JDK1.8 之前都不能访问一个非final的局部变量，只能访问final的局部变量，原因是生命周期不同，可能栈中的局部变量已经被销毁，而堆中的对象仍存活，此时会访问一个不存在的内存区域。假如是final的变量，那么编译时会将其拷贝一份，延长其生命周期。
拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变。
但在JDK1.8之后可以访问一个非final的局部变量了，前提是非final的局部变量没有修改，表现得和final变量一样才可以！

interface AnonymousInner {
    int add();
}
public class AnonymousOuter {
    public AnonymousInner getAnonymousInner(){
        int x = 100;
        return new AnonymousInner() {
            int y = 100;
            @Override
            public int add() {
                return x + y;
            }
        };
    }
}

1.11 关键字

final

try-finally-return

1、不管有没有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；无论try里执行了return语句、break语句、还是continue语句，finally语句块还会继续执行；如果执行try和catch时JVM退出（比如System.exit(0))，那么finally不会被执行；
finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，仍然是之前保存的值)，所以函数返回值是在finally执行前确定的；
【
如果try语句里有return，那么代码的行为如下：

1.如果有返回值，就把返回值保存到局部变量中
2.执行jsr指令跳到finally语句里执行
3.执行完finally语句后，返回之前保存在局部变量表里的值

】
3、当try和finally里都有return时，会忽略try的return，而使用finally的return。
4、如果try块中抛出异常，执行finally块时又抛出异常，此时原始异常信息会丢失，只抛出在finally代码块中的异常。
实例一：

public static int test() {
    int x = 1;
    try {
        x++;
        return x; // 2
    } finally {
        x++;
    }
}

实例二：

private static int test2() {
    try {
        System.out.println("try...");
        return 80;
    } finally {
        System.out.println("finally...");
        return 100; // 100
    }
}

static

static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。
1)修饰成员方法：静态成员方法
在静态方法中不能访问类的非静态成员变量和非静态成员方法；
在非静态成员方法中是可以访问静态成员方法/变量的；
即使没有显式地声明为static，类的构造器实际上也是静态方法

2)修饰成员变量：静态成员变量

静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
静态成员变量并发下不是线程安全的，并且对象是单例的情况下，非静态成员变量也不是线程安全的。
怎么保证变量的线程安全?
只有一个线程写，其他线程都是读的时候，加volatile；线程既读又写，可以考虑Atomic原子类和线程安全的集合类；或者考虑ThreadLocal

3)修饰代码块：静态代码块
用来构造静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

4)修饰内部类：静态内部类

成员内部类和静态内部类的区别：
- 1)前者只能拥有非静态成员；后者既可拥有静态成员，又可拥有非静态成员
- 2)前者持有外部类的的引用，可以访问外部类的静态成员和非静态成员；后者不持有外部类的引用，只能访问外部类的静态成员
- 3)前者不能脱离外部类而存在；后者可以
  5)修饰import：静态导包

switch

switch字符串实现原理

对比反编译之后的结果：
编译后switch还是基于整数，该整数来自于String的hashCode。
先比较字符串的hashCode，因为hashCode相同未必值相同，又再次检查了equals是否相同。

字节码实现原理（tableswitch / lookupswitch)

编译器会使用tableswitch和lookupswitch指令来生成switch语句的编译代码。当switch语句中的case分支的条件值比较稀疏时，tableswitch指令的空间使用率偏低。这种情况下将使用lookupswitch指令来替代。lookupswitch指令的索引表由int类型的键（来源于case语句块后面的数值)与对应的目标语句偏移量所构成。当lookupswitch指令执行时，switch语句的条件值将和索引表中的键进行比较，如果某个键和条件值相符，那么将转移到这个键对应的分支偏移量继续执行，如果没有键值符合，执行将在default分支执行。

abstract

只要含有抽象方法，这个类必须添加abstract关键字，定义为抽象类。
只要父类是抽象类,内含抽象方法，那么继承这个类的子类的相对应的方法必须重写。如果不重写，就需要把父类的声明抽象方法再写一遍，留给这个子类的子类去实现。同时将这个子类也定义为抽象类。
注意抽象类中可以有抽象方法，也可以有具体实现方法（当然也可以没有)。
抽象方法须加abstract关键字，而具体方法不可加
只要是抽象类，就不能存在这个类的对象（不可以new一个这个类的对象)。

this & super
this
自身引用；访问成员变量与方法；调用其他构造方法
1. 通过this调用另一个构造方法，用法是this(参数列表)，这个仅在类的构造方法中可以使用
1. 函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。
1. 需要引用当前对象时候，直接用this（自身引用)
super
父类引用；访问父类成员变量与方法；调用父类构造方法
super可以理解为是指向自己超（父)类对象的一个指针，而这个超类指的是离自己最近的一个父类。
super有三种用法：
1.普通的直接引用
与this类似，super相当于是指向当前对象的父类，这样就可以用super.xxx来引用父类的成员，如果不冲突的话也可以不加super。
2.子类中的成员变量或方法与父类中的成员变量或方法同名时，为了区别，调用父类的成员必须要加super
3.调用父类的构造函数

访问权限

1.12 枚举

JDK实现

实例：

public enum Labels0 {

    ENVIRONMENT("环保"), TRAFFIC("交通"), PHONE("手机");

    private String name;

    private Labels0(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

编译后生成的字节码反编译：
可以清晰地看到枚举被编译后其实就是一个类，该类被声明成 final，说明其不能被继承，同时它继承了 Enum 类。枚举里面的元素被声明成 static final ，另外生成一个静态代码块 static{}，最后还会生成 values 和 valueOf 两个方法。下面以最简单的 Labels 为例，一个一个模块来看。

Enum 类

Enum 类是一个抽象类，主要有 name 和 ordinal 两个属性，分别用于表示枚举元素的名称和枚举元素的位置索引，而构造函数传入的两个变量刚好与之对应。
toString 方法直接返回 name。
equals 方法直接用 == 比较两个对象。
hashCode 方法调用的是父类的 hashCode 方法。
枚举不支持 clone、finalize 和 readObject 方法。
compareTo 方法可以看到就是比较 ordinal 的大小。
valueOf 方法，根据传入的字符串 name 来返回对应的枚举元素。

静态代码块的实现

在静态代码块中创建对象，对象是单例的！
可以看到静态代码块主要完成的工作就是先分别创建 Labels 对象，然后将“ENVIRONMENT”、“TRAFFIC”和“PHONE”字符串作为 name ，按照顺序分别分配位置索引0、1、2作为 ordinal，然后将其值设置给创建的三个 Labels 对象的 name 和 ordinal 属性，此外还会创建一个大小为3的 Labels 数组 ENUM$VALUES，将前面创建出来的 Labels 对象分别赋值给数组。

values的实现
可以看到它是一个静态方法，主要是使用了前面静态代码块中的 Labels 数组 ENUM$VALUES，调用 System.arraycopy 对其进行复制，然后返回该数组。所以通过 Labels.values()[2]就能获取到数组中索引为2的元素。

valueOf 方法
该方法同样是个静态方法，可以看到该方法的实现是间接调用了父类 Enum 类的 valueOf 方法，根据传入的字符串 name 来返回对应的枚举元素，比如可以通过 Labels.valueOf(“ENVIRONMENT”)获取 Labels.ENVIRONMENT。
枚举本质其实也是一个类，而且都会继承java.lang.Enum类，同时还会生成一个静态代码块 static{}，并且还会生成 values 和 valueOf 两个方法。而上述的工作都需要由编译器来完成，然后我们就可以像使用我们熟悉的类那样去使用枚举了。

用enum代替int常量

将int枚举常量翻译成可打印的字符串，没有很便利的方法。
要遍历一个枚举组中的所有int 枚举常量，甚至获得int枚举组的大小。
使用枚举类型的values方法可以获得该枚举类型的数组
枚举类型没有可以访问的构造器，是真正的final；是实例受控的，它们是单例的泛型化；本质上是单元素的枚举；提供了编译时的类型安全。
单元素的枚举是实现单例的最佳方法！
可以在枚举类型中放入这段代码，可以实现String2Enum。
注意Operation是枚举类型名。

用实例域代替序数

这种实现不好，不推荐使用ordinal方法，推荐使用下面这种实现：

用EnumSet代替位域

位域是将几个常量合并到一个集合中，我们推荐用枚举代替常量，用EnumSet代替集合
- EnumSet.of(enum1,enum2) -> Set<枚举>
  用EnumMap代替序数索引

将一个枚举类型的值与一个元素（或一组)对应起来，推荐使用EnumMap数据结构
如果是两个维度的变化，那么可以使用EnumMap<Enum1,Map<Enum1,元素>>

1.13 序列化
JDK序列化（Serizalizable)
定义：将实现了Serializable接口（标记型接口)的对象转换成一个字节数组，并可以将该字节数组转为原来的对象。
ObjectOutputStream 是专门用来输出对象的输出流；
ObjectOutputStream 将 Java 对象写入 OutputStream。可以使用 ObjectInputStream 读取（重构)对象。

serialVersionUID

Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类)的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)。
- 1)如果没有添加serialVersionUID，进行了序列化，而在反序列化的时候，修改了类的结构（添加或删除成员变量，修改成员变量的命名)，此时会报错。
- 2)如果添加serialVersionUID，进行了序列化，而在反序列化的时候，修改了类的结构（添加或删除成员变量，修改成员变量的命名)，那么可能会恢复部分数据，或者恢复不了数据。
如果设置了serialVersionUID并且一致，那么可能会反序列化部分数据；如果没有设置，那么只要属性不同，那么无法反序列化。

其他序列化工具

XML/JSON
Thrift/Protobuf

对象深拷贝与浅拷贝

当拷贝一个变量时，原始引用和拷贝的引用指向同一个对象，改变一个引用所指向的对象会对另一个引用产生影响。
如果需要创建一个对象的浅拷贝，那么需要调用clone方法。
Object 类本身不实现接口 Cloneable，直接调用clone会抛出异常。

如果要在自己定义类中调用clone方法，必须实现Cloneable接口（标记型接口)，因为Object类中的clone方法为protected，所以需要自己重写clone方法，设置为public。

protected native Object clone() throws CloneNotSupportedException;

public class Person implements Cloneable {
    private int age;
    private String  name;
    private Company company;
    @Override
    public Person clone() throws CloneNotSupportedException {
        return (Person) super.clone();
    }

}

public class Company implements Cloneable{
    private String name;

    @Override
public Company clone() throws CloneNotSupportedException {
    return (Company) super.clone();
}

}
使用super（即Object)的clone方法只能进行浅拷贝。
如果希望实现深拷贝，需要修改实现，比如修改为：

@Override
public Person clone() throws CloneNotSupportedException {
    Person person = (Person) super.clone();
    person.setCompany(company.clone()); // 一个新的Company
    return person;
}

假如说Company中还有持有其他对象的引用，那么Company中也要像Person这样做。
可以说：想要深拷贝一个子类，那么它的所有父类都必须可以实现深拷贝。
另一种实现对象深拷贝的方式是序列化。
@Override
protected Object clone() {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream os = new ObjectOutputStream(baos);
os.writeObject(this);
os.close();
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream in = new ObjectInputStream(bais);
Object ret = in.readObject();
in.close();
return ret;
}catch(Exception e) {
e.printStackTrace();
}
return null;
}

1.14 异常

Error、Exception

Error是程序无法处理的错误，它是由JVM产生和抛出的，比如OutOfMemoryError、ThreadDeath等。这些异常发生时，Java虚拟机（JVM)一般会选择线程终止。
Exception是程序本身可以处理的异常，这种异常分两大类运行时异常和非运行时异常。程序中应当尽可能去处理这些异常。
常见RuntimeException
IllegalArgumentException - 方法的参数无效
NullPointerException - 试图访问一空对象的变量、方法或空数组的元素
ArrayIndexOutOfBoundsException - 数组越界访问
ClassCastException - 类型转换异常
NumberFormatException 继承IllegalArgumentException，字符串转换为数字时出现。比如int i= Integer.parseInt(“ab3”);

RuntimeException与非Runtime Exception

RuntimeException是运行时异常，也称为未检查异常；
非RuntimeException 也称为CheckedException 受检异常
前者可以不必进行try-catch，后者必须要进行try-catch或者throw。

异常包装
在catch子句中可以抛出一个异常，这样做的目的是改变异常的类型
try{
…
}catch(SQLException e){
throw new ServletException(e.getMessage());
}
这样的话ServletException会取代SQLException。
有一种更好的方法，可以保存原有异常的信息，将原始异常设置为新的异常的原因
try{
…
}catch(SQLException e){
Throwable se = new ServletException(e.getMessage());
se.initCause(e);
throw se;
}
当捕获到异常时，可以使用getCause方法来重新得到原始异常
Throwable e = se.getCause();
建议使用这种包装技术，可以抛出系统的高级异常（自己new的)，又不会丢失原始异常的细节。
早抛出，晚捕获。

1.15 泛型

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参)，然后在使用/调用时传入具体的类型（类型实参)。

泛型接口/类/方法
泛型继承、实现
父类使用泛型，子类要么去指定具体类型参数，要么继续使用泛型

泛型的约束和局限性

- 1)只能使用包装器类型，不能使用基本数据类型；

- 2)运行时类型查询只适用于原始类型，不适用于带类型参数的类型；

if(a instanceof Pair) //error
- 3)不能创建带有类型参数的泛型类的数组
Pair [] pairs = new Pair[10];//error
只能使用反射来创建泛型数组

public static <T extends Comparable> T[] minmax(T… a){

T[] mm = (T[]) Array.newInstance(a.getClass().getComponentType(),个数);
…复制
}

通配符
? 未知类型只可以用于声明时，声明类型或方法参数，不能用于定义时（指定类型参数时)
List<?> unknownList;
List<? extends Number> unknownNumberList;
List<? super Integer> unknownBaseLineIntgerList;
对于参数值是未知类型的容器类，只能读取其中元素，不能向其中添加元素，因为，其类型是未知，所以编译器无法识别添加元素的类型和容器的类型是否兼容，唯一的例外是null。

通配符类型 List 与原始类型 List 和具体类型 List都不相同，List表示这个list内的每个元素的类型都相同，但是这种类型具体是什么我们却不知道。注意，List和List

Java

1.1 JDK&JRE&JVM

1.2 跨平台

1.3 基础数据类型

1.4 引用类型

四种引用

强引用

软引用

弱引用

虚引用

基础数据类型包装类

为什么需要

有哪些

自动装箱、自动拆箱（编译器行为)

Integer.valueOf

1.5 Object

== 与 equals的区别

hashCode与equals的区别

如果重写equals不重写hashCode会怎样

1.6 String&StringBuffer&StringBuilder

String

equals&hashCode

添加功能

+ substring

常量池

编译优化

StringBuffer&StringBuilder

1.7 面向对象

抽象类与接口

三大特性

重写和重载

1.8 关键类

ThreadLocal（线程局部变量)

1)每个线程的变量副本是存储在哪里的

2)为什么ThreadLocalMap的Key是弱引用

3)ThreadLocalMap是何时初始化的（setInitialValue)

4)ThreadLocalMap 原理

构造方法

set（线性探测法解决hash冲突)

cleanSomeSlots（启发式地清理slot)