ForCleanCode 为笔者读书总结，出于自身理解目的总结！
JoshBloch.jpg
一丶用私有构造期或者枚举强化Singleton属性。
1丶单列：仅仅被实例化一次的类。
在JAVA 1.5之前 实现单列 有两种常见方式:
1.第一种方式:公有域。
/**
* Created by zhaoyuanchao on 2018/5/11.
* 1丶私有化构造器
* 2丶唯一得静态成员INSTANCE 确保访问了唯一实例
*/
public class Elvis {
public static final Elvis INSTANCE = new Elvis();
private Elvis() {
}
}
问题：
享有特权得客户端可以借助 AccessibleObject.setAccessible方法，通过反射机制，调用私有构造器。 （可以同过 让他被要求创造第二个实例的时候抛出异常 来抵御这种攻击）
2.第二种方式：（看来J神对静态工厂方法情有独钟）
/**
* Created by zhaoyuanchao on 2018/5/11.
* 1丶共有的静态工厂方法，调用唯一实例
*/
public class Elvis {
private static final Elvis INSTANCE = new Elvis();
private Elvis() {
}
public static Elvis getInstance(){
return INSTANCE;
}
}
两种方式的比较：
1丶公有域方式：
组成类的成员变量很清楚的声明了类是一个Singleton.
共有静态域是final的，所以总是包含单个相同的引用。
2丶静态工厂方式:
灵活性：在不改变其API的前提下，我们可以改变该类是否应该是一个SIngleton的想法。
这两种方式在序列化后，为了保证Singleton，必须声明所有的实例都是transient,并提供一个readResolve方法：
public class Elvis implements Serializable {
private static final Elvis INSTANCE = new Elvis();
private Elvis() {
}
public static Elvis getInstance(){
return INSTANCE;
}
/**
* 保证反序列化后唯一实例
* @return
*/
private Object readResolve(){
return INSTANCE;
}
}
3丶第三种方式实现单列：
public enum Elvise {
INSTANCE
}
优点：
(1) 简洁.
(2) 无偿提供了序列化机制
(3) 单元素的枚举 已经成为实现单列的最佳方式！
二丶避免创建不必要的对象
1丶一般对象的创建
/**
* 每次执行的时候都会创造新的实例，会创建很多不必要的实例，
* 因为每调用一次构造器 就会创造一个新的实例。
*/
String mString = new String("string"); //不要这样创建
/**
* 至创建一个String的实例
*/
String mStrings = "string";
2丶静态工厂方法优先于构造器方法。
/**
* 每次都会创建出新对象
*/
Boolean s = new Boolean("ss");
/**
* 重用传入对象
*/
Boolean getS = Boolean.valueOf("ss");
/**
* Returns a {@code Boolean} with a value represented by the
* specified string. The {@code Boolean} returned represents a
* true value if the string argument is not {@code null}
* and is equal, ignoring case, to the string {@code "true"}.
*
* @param s a string.
* @return the {@code Boolean} value represented by the string.
*/
public static Boolean valueOf(String s) {
return parseBoolean(s) ? TRUE : FALSE;
}
3.重用那些 已知不被修改的量。
（1）未被重用的列子：
public class Person {
private final Date bitrhDate;
public Person(Date bitrhDate) {
this.bitrhDate = bitrhDate;
}
/**
* 每次查询的时候 都会创建 一个Calender 一个TimeZone 两个Date,
* 这些都是固定值，没有必要每次查询都创建对应实例
* @return
*/
public boolean isBabyBoomer(){
Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
calendar.set(1946,Calendar.JANUARY,1,0,0,0);
Date dateStart = calendar.getTime();
calendar.set(1965,Calendar.JANUARY,1,0,0,0);
Date dateEnd = calendar.getTime();
return bitrhDate.compareTo(dateStart) >= 0 &&
bitrhDate.compareTo(dateEnd) < 0;
}
}
(2) 静态初始化器 复用常量(改进版本)
public class Person {
private final Date bitrhDate;
private static final Date DATE_START;
private static final Date DATE_END;
public Person(Date bitrhDate) {
this.bitrhDate = bitrhDate;
}
/**
* 只在第一次运行的时候，创建实例一次
*/
static {
Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
calendar.set(1946,Calendar.JANUARY,1,0,0,0);
DATE_START = calendar.getTime();
calendar.set(1965,Calendar.JANUARY,1,0,0,0);
DATE_END = calendar.getTime();
}
public boolean isBabyBoomer(){
return bitrhDate.compareTo(DATE_START) >= 0 &&
bitrhDate.compareTo(DATE_END) < 0;
}
}
比较：
两种代码 在J神的电脑上 调用一千万次：
第一种：32000ms 第二种：130ms
快了将近 250倍。
4丶自动装箱和 拆箱造成的问题：
（1）自动装箱 和 拆箱 实际上就是 ，基本类型和 装箱基本类型 可以自动转换得一种功能；
Long sum = 0L;
for(long i = 0;i < Integer.MAX_VALUE; i++){
sum += i;
}
这段程序因为打错了一个字符，导致效率会降低。
变量sum被声明成Long而不是long，意味着程序构造了很多多余得Long实例。将Long 改成long ，在我的机器上运行 时间从43S减少到了6.8S。
结论：
优先使用基本类型,而不是装箱基本类型,当心无意识得 自动装箱。
三丶消除过期得对象引用：
public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INIYITAL_CAPACITY = 16;
public Stack(Object[] elements) {
this.elements = new Object[DEFAULT_INIYITAL_CAPACITY];
}
public void push(Object object){
ensureCapacity();
elements[size++] = object;
}
public Object pop(){
if (size == 0)
throw new EmptyStackException();
return elements[--size];
}
private void ensureCapacity() {
if (elements.length == size){
elements = Arrays.copyOf(elements,2*size+1);
}
}
}
观察：
这段程序 会随着内存得增加 效率会不断的降低！
原因是 总栈中被pop出去的对象，将不会被当作垃圾回收，即使使用栈的程序不在引用这些对象。他们也不会被回收了！
栈内维护着这些对象的过期引用(永远也不会被解除的引用)。
修复方法：
public Object pop(){
if (size == 0)
throw new EmptyStackException();
Object result = elements[--size];
elements[size] = null;
return result;
}
清空过期引用。
清空对象引用应该是一种列外，而不是一种规范行为！
2：内存泄漏的第二个常见来源：缓存！
3：内存泄漏的第三个常见来源：回调！
可以只保存他们的弱引用方式来规避此类问题（weak reference）
四: 避免使用终结方法：
1.finalizer:通常是不可预测，也很危险的！
缺点：
1：不能保证会被及时的执行：
注重时间的任务 不能用终结方法。
2：Java语言的规范不仅不保证 终结方法会被及时执行，而且根本就保证不了它们会被执行。
3：会造成严重的性能损失
网友评论