Effective Java 读书笔记

1、当有多个参数时，使用构建器模式

常用的场景是，查询时，有多个参数。因此构建查询参数对象时，考虑使用Builder模式。

public class QueryBuilder {
    //查询的每个参数，不需要set方法
    private  String userName;
    private String mobile;
    private int cityId;
    private int pageNum;
    private int pageSize;

    //提供一个Builder实例
    public static Builder newBuilder(){
        return new Builder();
    }

    //共有的public 静态static内部类
    public static class Builder{
        private  String userName;
        private String mobile;
        private int cityId;
        private int pageNum;
        private int pageSize;

        //每个方法都是公有的 
        public Builder withUserName(String userName){
            this.userName = userName;
            return this;
        }
        public Builder withMobile(String mobile){
            this.mobile = mobile;
            return this;
        }
        public Builder withCityId(int cityId){
            this.cityId = cityId;
            return this;
        }
        public Builder withPageNum(int pageNum){
            this.pageNum = pageNum;
            return this;
        }
        public Builder withPageSize(int pageSize){
            this.pageSize = pageSize;
            return this;
        }
        //最后提供一个build方法，返回查询类
        public QueryBuilder build(){
            return new QueryBuilder(this);
        }
    }
    //查询类构造方法私有，接收一个Builder参数
    private QueryBuilder(Builder builder){
        userName = builder.userName;
        mobile = builder.mobile;
        cityId = builder.cityId;
        pageNum = builder.pageNum;
        pageSize = builder.pageSize;
        //可以根据需要提供一个boolean hasQuery字段，用于判断是否有查询条件
        //没有查询条件时，返回所有值
        /*hasQuery = StringUtils.isNotEmpty(userName)
                || StringUtils.isNotEmpty(mobile)
                || cityId > 0;
       */
    }
}


    public String getUserName() {
        return userName;
    }

    public String getMobile() {
        return mobile;
    }

    public int getCityId() {
        return cityId;
    }

    public int getPageNum() {
        return pageNum;
    }

    public int getPageSize() {
        return pageSize;
    }

    public boolean isHasQuery() {
        return hasQuery;
    }

//使用
QueryBuilder.Builder builder = QueryBuilder.newBuilder();
QueryBuilder query = builder.withUserName("name1").withMobile("13456463216")
                            .withCityId(1).withPageNum(0).withPageSize(10)
                            .build();

2、使用私有构造器或者枚举类型强化Singleton属性

这里主要写一下Java的Sigleton模式吧，下文讨论的内容引入了其他博文
http://blog.csdn.net/cnyyx/article/details/7482735
http://my.oschina.net/alexgaoyh/blog/261106?fromerr=FT8qyEHA

方法1、静态成员直接初始化

public class Singleton {

    //私有化构造器，防止外部new Singleton()
    private Singleton(){}

    private static final Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }

}

这种方法在类加载的时候就会创建一个Singleton对象，不管该资源是否被请求，占用Jvm内存。

方法2根据lazy initialization思想，使用到时才初始化

public class Singleton {
    private Singleton(){}

    private static Singleton instance;
    public static synchronized Singleton getInstance(){
        if(null == instance){  //@1
            instance = new Singleton(); //@2
        }
        return instance;
    }
}

该方法加载了同步锁，可以防止多线程在执行getInstance方法得到2个对象，如果不加synchronized关键字，考虑线程A、B
A执行 @1 还未执行 @2
B执行 @1 还未执行 @2
将会得到2个对象
缺点：只有在第一次调用的时候才需要同步，一旦instance部位null了，系统依旧花费同步锁开销，有点得不偿失

方法3：在2的基础上，改进标注：尽量减少锁资源

    private Singleton(){}

    private static Singleton instance;
    public static Singleton getInstance(){
        if(null == instance){  //@1
            synchronized (Singleton.class){ //@2
                instance = new Singleton(); //@3
            }
        }
        return instance;
    }

这种写法减少了锁开销，但是在如下情况，却创建了2个对象：
a:线程1执行到1挂起，线程1认为singleton为null
b:线程2执行到1挂起，线程2认为singleton为null
c:线程1被唤醒执行synchronized块代码，走完创建了一个对象
d:线程2被唤醒执行synchronized块代码，走完创建了另一个对象
所以看出这种写法，并不完美。

方法4：为了解决上述3的问题，引入双重检查锁定

    private Singleton(){}

    private static Singleton instance;
    public static Singleton getInstance(){
        if(null == instance){  //@1
            synchronized (Singleton.class){//@2
                if(null == instance){//@3
                    instance = new Singleton();//@4
                }
            }
        }
        return instance;
    }

在同步锁代码块内部，再判断一次对象是否为null，为null才创建对象。这种写法已经接近完美：
a:线程1执行到1，已经进入synchronized的时候，线程挂起，线程1占有Singleton.class资源锁；
b:线程2执行到1，当它准备synchronized块时，因为Singleton.class被占用，线程2阻塞；
c:线程1被唤醒，判断出对象为null，执行完创建一个对象
d:线程2被唤醒，判断出对象不为null，不执行创建语句
如此分析，发现似乎没问题。
但是实际上并不能保证它在单处理器或多处理器上正确运行；
问题就出现在singleton = new Singleton()这一行代码。它可以简单的分成如下三个步骤：
mem= singleton();//1
instance = mem;//2
ctorSingleton(instance);//3
这行代码先在内存开辟空间，赋给singleton的引用，然后执行new 初始化数据，但是注意初始化是要消耗时间。如果此时线程3在执行步骤1的时候，发现singleton 为非null，就直接返回，那么线程3返回的其实是一个没构造完成的对象。
我们期望1,2,3 按照反序执行，但是实际jvm内存模型，并没有明确的有序指定。
这归咎于java的平台的内存模型允许“无序写入”。

方法5：在4的基础上引入volatile

    private Singleton(){}

    private static volatile Singleton instance;
    public static Singleton getInstance(){
        if(null == instance){  //@1
            synchronized (Singleton.class){//@2
                if(null == instance){//@3
                    instance = new Singleton();//@4
                }
            }
        }
        return instance;
    }

Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新值。
但是5的写法，虽然理论上似乎可以解决无序写入问题。实际上并非如此。

方法6： 为了实现慢加载，并且不希望每次调用getInstance时都必须互斥执行，最好并且最方便的解决办法如下：（通过内部类实现多线程环境中的单例模式）

        private Singleton(){}

    private static class InstanceHolder{
        private static final Singleton instance = new Singleton();
    }
    public static Singleton getInstance(){
        return InstanceHolder.instance;
    }

JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，
并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上面的问题(方法4)。此外该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低效问题(方法2)。
最后instance是在第一次加载InstanceHolder类时被创建的，而InstanceHolder类则在调用getInstance方法的时候才会被加载，因此也实现了惰性加载。

方法7：另一种写法是采用枚举(因为枚举类型的构造函数天生是私有的, 而且外部也不能new一个枚举值)

public enum A{
        INSTANCE;
        public void invoke(){...}
}

3、通过私有构造器强化不可实例化的能力

有时候可能需要编写只包含静态方法和静态域的类，如工具类。最好给其提供一个私有构造器，否则编译器会为其生成一个默认的无参构造函数。

public class MobileUtils {

    private MobileUtils(){}

    /**
     * 隐藏手机号中间4位
     * @param mobile
     * @return String 隐藏手机号中间4位之后的手机号
     */
    public static String hideMobile(String mobile) {
        if (StringUtils.isEmpty(mobile)) {
            return StringUtils.EMPTY;
        }
        if (mobile.length() < 8) {
            return StringUtils.EMPTY;
        }
        return mobile.substring(0, 3) + "****" + mobile.substring(7);
    }
}

4、避免创建不必要的对象

 对于同时提供了构造器和静态工厂方法，通常使用静态工程方法而不是构造器，以避免
 创建不必要的对象，比如Boolean.valueOf(String)比new Boolean(String)要好，构造器每次
 被调用时都要创建一个新的对象，静态工厂方法则没有这种要求，也不会这样做
 下面是Boolean的部分源码，查看其valueOf方法

     public static final Boolean TRUE = new Boolean(true);
     public static final Boolean FALSE = new Boolean(false);

     public static Boolean valueOf(String s) {
        return toBoolean(s) ? TRUE : FALSE;
     }
     private static boolean toBoolean(String name) {
        return ((name != null) && name.equalsIgnoreCase("true"));
     }

5、消除过期对象

这里只能说学习，主要看的是ArrayList吧，对不用的对象是如何处理的。

protected void removeRange(int fromIndex, int toIndex) {
         modCount++;
         int numMoved = size - toIndex;
         System.arraycopy(elementData, toIndex, elementData, fromIndex,
         numMoved);

         // clear to let GC do its work 就是这里！
         int newSize = size - (toIndex-fromIndex);
         for (int i = newSize; i < size; i++) {
         elementData[i] = null;
         }
         size = newSize;
     }

     public static native void arraycopy(Object src,  int  srcPos,
        Object dest, int destPos,int length);

6、覆盖equal时请遵守通用约定

简单总结一下:
1、是否是同一个对象的引用
2、类型转换
3、域的比较，在比较时，优先比较区分度大的域
注意：这里有个坑：equals方法的参数是Object，而不是自己定义的类。否则直接变成代码重载，而不是重写了！！
@Override的作用也可以看到了 书中36条：坚持使用Override注解

@Override
public boolean equals(Object anObject) {
        if (this == anObject) {//是否是同一个对象的引用
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String) anObject;//转换为该对象类型
            int n = value.length;  //管家field的值比较，先比较区分度比较大的！
            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;
    }

7、clone方法

主要考虑Java 深拷贝和浅拷贝

浅拷贝（浅复制、浅克隆）：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。
换言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

深拷贝（深复制、深克隆）：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，
而不再是原有的那些被引用的对象。
换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

clone基本类型 深拷贝
clone对象类型 浅拷贝，重写clone方法，将对象引入一一clone，即可实现深拷贝

    // 改为深复制：
    Student2 student = (Student2) super.clone();
    // 本来是浅复制，现在将Teacher对象复制一份并重新set进来
    student.setTeacher((Teacher) student.getTeacher().clone());

serialization序列化 深拷贝

8、Comparable的理解

类的比较，主要有两种方法，一种是类实现Comparable接口，重写compareTo方法；另外一种是在集合比较的时候，新建一个Comparator，重写compare方法。与书中hashCode讲解有点关系的部分是：hashCode影响：HashSet、HashMap、HashTable
compareTo影响：TreeSet、TreeMap、Collections、Arrays。

自我感觉关于整数比较时，尽量直接<>直接比较，通过减法有可能溢出！
另外，有点不太相关的内容，在比较时，返回-1、0、1表示大小关系，其实只要返回一个符号（正负）就行，看到了Long的signum方法

public static int signum(long i) {
        return (int) ((i >> 63) | (-i >>> 63));
    }

直接通过移位，不需要比较操作符，一句话搞定！吊吊的！Long的rotate和reverse也很吊！