1) Java中的4种引用
在JDK 1.2以前的版本中，若一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及（reachable）状态，程序才能使用它。从JDK 1.2版本开始，把对象的引用分为4种级别，从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为：强引用、软引用、弱引用和虚引用。
- 强引用
我们平日里面的用到的new了一个对象就是强引用，例如 Object obj = new Object();当JVM的内存空间不足时，宁愿抛出OutOfMemoryError使得程序异常终止也不愿意回收具有强引用的存活着的对象！
记住是存活着，不可能是你new一个对象就永远不会被GC回收。当一个普通对象没有其他引用关系，只要超过了引用的作用域或者显示的将引用赋值为null时，你的对象就表明不是存活着，这样就会可以被GC回收了。当然回收的时间是不一定的具体得看GC回收策略。
- 软引用
软引用的生命周期比强引用短一些。软引用是通过SoftReference类实现的。
Object obj = new Object();
SoftReference softObj = new SoftReference(obj);
obj = null； //去除强引用
这样就是一个简单的软引用使用方法。通过get()方法获取对象。当JVM认为内存空间不足时，就回去试图回收软引用指向的对象，也就是说在JVM抛出OutOfMemoryError之前，会去清理软引用对象。软引用可以与引用队列(ReferenceQueue)联合使用。
Object obj = new Object();
ReferenceQueue queue = new ReferenceQueue();
SoftReference softObj = new SoftReference(obj,queue);
obj = null； //去除强引用
当softObj软引用的obj被GC回收之后，softObj 对象就会被塞到queue中，之后我们可以通过这个队列的poll()来检查你关心的对象是否被回收了，如果队列为空，就返回一个null。反之就返回软引用对象也就是softObj。
软引用一般用来实现内存敏感的缓存，如果有空闲内存就可以保留缓存，当内存不足时就清理掉，这样就保证使用缓存的同时不会耗尽内存。例如图片缓存框架中缓存图片就是通过软引用的。
- 弱引用
弱引用是通过WeakReference类实现的，它的生命周期比软引用还要短,也是通过get()方法获取对象。
在GC的时候，不管内存空间足不足都会回收这个对象，同样也可以配合ReferenceQueue 使用，也同样适用于内存敏感的缓存。ThreadLocal中的key就用到了弱引用。
Object obj = new Object();
WeakReference<Object> weakObj = new WeakReference<Object>(obj);
obj = null； //去除强引用
- 幻像引用
也称虚引用，是通过PhantomReference类实现的。任何时候可能被GC回收,就像没有引用一样。
Object obj = new Object();
ReferenceQueue queue = new ReferenceQueue();
PhantomReference<Object> phantomObj = new PhantomReference<Object>(obj , queue);
obj = null； //去除强引用
无法通过虚引用访问对象的任何属性或者函数。那就要问了要它有什么用？虚引用仅仅只是提供了一种确保对象被finalize以后来做某些事情的机制。比如说这个对象被回收之后发一个系统通知啊啥的。虚引用是必须配合ReferenceQueue 使用的，具体使用方法和上面提到软引用的一样。主要用来跟踪对象被垃圾回收的活动。
2) 基本类型和包装类
- 基本数据类型与包装类的对应关系
| 基本类型 | 类型 | 包装类 | 大小 | 取值范围 | 包装类缓存范围 |
|---|---|---|---|---|---|
| byte | 数值型 | Byte | 8bit | [-2^7, 2^7-1] 默认值是0 | 全部缓存 |
| short | 数值型 | Short | 16bit | [-2^15, 2^15-1] 默认值是0 | -128~127 缓存 |
| int | 数值型 | Integer | 32bit | [-2^31, 2^31-1] 默认值是0 | -128~127 缓存 |
| long | 数值型 | Long | 64bit | [-2^63, 2^63-1] 默认值是0L | -128~127 缓存 |
| float | 数值型 | Float | 32bit | 默认值是0F | 全部缓存 |
| double | 数值型 | Double | 64bit | 0.0 | 全部缓存 |
| char | 字符型 | Character | 16bit | 默认值是\u00000 | <=127 缓存 |
| boolean | 布尔型 | Boolean | / | 只要true和false两个字面量值 默认是 false | 无缓存 |
- 类型转换
Java中每一种基本类型都会对应一个唯一的包装类，基本类型与其包装类都可以通过包装类中的静态或者成员方法进行转换。每种基本类型及其包装类的对应关系如下，值得注意的是，所有的包装类都是final修饰的，也就是它们都是无法被继承和重写的。
Java中除了boolean类型之外，其他7中类型相互之间可以进行转换。转换分为自动转换和强制转换。对于自动转换（隐式），无需任何操作，而强制类型转换需要显式转换，即使用转换操作符（type）。7种类型按照其占用空间大小进行排序：byte <（short=char）< int < long < float < double
类型转换的总则是：小可直接转大、大转小会失去精度。这句话的意思是较小的类型直接转换成较大的类型，没有任何印象；而较大的类型也可以转换为较小的类型，但是会失去精度。他们之间的转换都不会抛出任何运行时异常。小转大是Java帮我们自动进行转换的，与正常的赋值操作完全一样；大转小需要进行强制转换操作，其语法是target-type var =（target-type） value。
// 自动转换
long l = 10;
double d = 10;
float = 10;
// 强制转换
int a = (int) 1.0;
char c = (char) a;
- 常见考题：
Integer int1 = 59;
Integer int2 = Integer.valueOf(59);
System.out.println(int1 == int2); //true
Integer int3 = 200;
Integer int4 = Integer.valueOf(200);
System.out.println(int3 == int4); //false
当使用直接赋值如”Integer int1= 59“的时候，会调用Integer的valueOf()方法，这个方法就是返回一个Integer对象，但是在返回前，作了一个判断，判断要赋给对象的值i是否在[-128,127]区间中，且IntegerCache（是Integer类的内部类，里面有一个Integer对象数组，用于存放已经存在的且范围在[-128,127]中的对象）中是否存在此对象，如果存在，则直接返回引用，否则，创建一个新对象返回。那么我们就可以知道，200这个数字不在[-128，127]中，所以会直接创建一个新对象返回，int3和int4就是两个不同的对象。而59属于[-128，127]中，当创建int2时，会直接返回引用，此时int2和int1都指向同一个地址。下面是Integer.valueOf的源码：
/**
* Returns an {@code Integer} instance representing the specified
* {@code int} value. If a new {@code Integer} instance is not
* required, this method should generally be used in preference to
* the constructor {@link #Integer(int)}, as this method is likely
* to yield significantly better space and time performance by
* caching frequently requested values.
*
* This method will always cache values in the range -128 to 127,
* inclusive, and may cache other values outside of this range.
*
* @param i an {@code int} value.
* @return an {@code Integer} instance representing {@code i}.
* @since 1.5
*/
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
所以如果不需要新的 Integer 实例，则通常应优先使用该方法，而不是构造方法 Integer(int)，因为该方法有可能通过缓存经常请求的值而显著提高空间和时间性能 。
为什么需要包装类
很多人会有疑问，既然Java中为了提高效率，提供了八种基本数据类型，为什么还要提供包装类呢？
这个问题，其实前面已经有了答案，因为Java是一种面向对象语言，很多地方都需要使用对象而不是基本数据类型。比如，在集合类中，我们是无法将int 、double等类型放进去的。因为集合的容器要求元素是Object类型。为了让基本类型也具有对象的特征，就出现了包装类型，它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。
拆箱与装箱
那么，有了基本数据类型和包装类，肯定有些时候要在他们之间进行转换。比如把一个基本数据类型的int转换成一个包装类型的Integer对象。我们认为包装类是对基本类型的包装，所以，把基本数据类型转换成包装类的过程就是打包装，英文对应于boxing，中文翻译为装箱。反之，把包装类转换成基本数据类型的过程就是拆包装，英文对应于unboxing，中文翻译为拆箱。
在Java SE5之前，要进行装箱，可以通过以下代码：
Integer i = new Integer(10);
自动拆箱与自动装箱
在Java SE5中，为了减少开发人员的工作，Java提供了自动拆箱与自动装箱功能。
自动装箱: 就是将基本数据类型自动转换成对应的包装类。
自动拆箱：就是将包装类自动转换成对应的基本数据类型。
自动装箱与自动拆箱的实现原理
既然Java提供了自动拆装箱的能力，那么，我们就来看一下，到底是什么原理，Java是如何实现的自动拆装箱功能。
我们有以下自动拆装箱的代码：
public static void main(String[]args){
Integer integer=1; //装箱
int i=integer; //拆箱
}
对以上代码进行反编译后可以得到以下代码：
public static void main(String[]args){
Integer integer=Integer.valueOf(1);
int i=integer.intValue();
}
从上面反编译后的代码可以看出，int的自动装箱都是通过Integer.valueOf()方法来实现的，Integer的自动拆箱都是通过integer.intValue来实现的。如果读者感兴趣，可以试着将八种类型都反编译一遍 ，你会发现以下规律：
自动装箱都是通过包装类的
valueOf()方法来实现的.自动拆箱都是通过包装类对象的xxxValue()来实现的。
哪些地方会自动拆装箱
我们了解过原理之后，在来看一下，什么情况下，Java会帮我们进行自动拆装箱。前面提到的变量的初始化和赋值的场景就不介绍了，那是最简单的也最容易理解的。我们主要来看一下，那些可能被忽略的场景。
- 将基本数据类型放入集合类
我们知道，Java中的集合类只能接收对象类型，那么以下代码为什么会不报错呢？
List<Integer> li = new ArrayList<>();
for (int i = 1; i < 50; i ++){
li.add(i);
}
将上面代码进行反编译，可以得到以下代码：
List<Integer> li = new ArrayList<>();
for (int i = 1; i < 50; i += 2){
li.add(Integer.valueOf(i));
}
以上，我们可以得出结论，当我们把基本数据类型放入集合类中的时候，会进行自动装箱。
-
包装类型和基本类型的大小比较
包装类与基本数据类型进行比较运算，是先将包装类进行拆箱成基本数据类型，然后进行比较的。 -
包装类型的运算
两个包装类型之间的运算，会被自动拆箱成基本类型进行。 -
三目运算符的使用
这是很多人不知道的一个场景，作者也是一次线上的血淋淋的Bug发生后才了解到的一种案例。看一个简单的三目运算符的代码：
boolean flag = true;
Integer i = 0;
int j = 1;
int k = flag ? i : j;
很多人不知道，其实在int k = flag ? i : j;这一行，会发生自动拆箱。反编译后代码如下：
boolean flag = true;
Integer i = Integer.valueOf(0);
int j = 1;
int k = flag ? i.intValue() : j;
System.out.println(k);
这其实是三目运算符的语法规范。当第二，第三位操作数分别为基本类型和对象时，其中的对象就会拆箱为基本类型进行操作。因为例子中，flag ? i : j;片段中，第二段的i是一个包装类型的对象，而第三段的j是一个基本类型，所以会对包装类进行自动拆箱。如果这个时候i的值为null，那么久会发生NPE。（自动拆箱导致空指针异常）
- 函数参数与返回值
这个比较容易理解，直接上代码了：
//自动拆箱
public int getNum1(Integer num) {
return num;
}
//自动装箱
public Integer getNum2(int num) {
return num;
}
自动拆装箱带来的问题
当然，自动拆装箱是一个很好的功能，大大节省了开发人员的精力，不再需要关心到底什么时候需要拆装箱。但是，它也会引入一些问题。
包装对象的数值比较，不能简单的使用==，虽然-128到127之间的数字可以，但是这个范围之外还是需要使用equals比较。
前面提到，有些场景会进行自动拆装箱，同时也说过，由于自动拆箱，如果包装类对象为null，那么自动拆箱时就有可能抛出NPE。如果一个for循环中有大量拆装箱操作，会浪费很多资源。
上面有关自动拆箱与装箱得内容引用下面的文章：
链接：https://juejin.im/post/5b8de48951882542d63b4662
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
网友评论