《Effective Java》 读书笔记

文末有PDF文檔，仅用于学习。
更新中......

第1章引言

第2章创建和销毁对象

第1条:用静态工厂方法代替构造器

• 静态工厂方法与构造器不同的第一大优势在于，它们有名称。 
• 静态工厂方法与构造器不同的第二大优势在于，不必在每次调用它们的时候都创建一个新对象。 它从来不创建对象。 这种方法类似于享元 (Flyweight）模式 。 如果程序经常请求创建相同的对象，并且创建对象的代价 很高，则这项技术可以极大地提升性能。 

public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }

• 静态工厂方法与构造器不同的第三大优势在子，它们可以返回原返回类型的任何子类 型的对象。 
• 静态工厂的第四大优势在于，所返回的对象的类可以随着每次调用而发生变化，这取 决于静态工厂方法的参数值。

EnumSet 没有公有的构造器，只有静态工厂方法。 在 OpenJDK 实现中， 它们返回两种子类之一的一个实例，具体则取决于底层枚举类型的大小：如果它的元素有 64 个或者更少，就像大多数枚举类型一样，静态工厂方法就会返回一个 RegalarEumSet 实例， 用单个 long 进行支持；如果枚举类型有 65 个或者更多元素，工厂就返回 JumboEnumSet 实例，用一个 long 数组进行支持。

  

 /**
     * Creates an empty enum set with the specified element type.
     *
     * @param  The class of the elements in the set
     * @param elementType the class object of the element type for this enum
     *     set
     * @return An empty enum set of the specified type.
     * @throws NullPointerException if elementType is null
     */
    public static > EnumSet noneOf(Class elementType) {
        Enum[] universe = getUniverse(elementType);
        if (universe == null)
            throw new ClassCastException(elementType + " not an enum");

        if (universe.length <= 64)
            return new RegularEnumSet<>(elementType, universe);
        else
            return new JumboEnumSet<>(elementType, universe);
    }

在 Java 8 中仍要求接口的所有静态成员都必须是 公有的。 在 Java 9 中允许接口有私有的静态方法，但是静态域和静态成员类仍然需要是公 有的。 

• 静态工厂的第五大优势在于，方法返回的对象所属的类，在编写包含该静态工厂方 法的类时可以不存在。 
• 静态工厂方法的主要缺点在子，类如果不含公有的或者受保护的构造器，就不能被子 类化。 
• 静态工厂方法的第二个缺点在于，程序员很难发现它们

Type 表示工厂方法所返回的对象类型，例如：

  public static BufferedReader newBufferedReader(Path path, Charset cs)
        throws IOException
    {
        CharsetDecoder decoder = cs.newDecoder();
        Reader reader = new InputStreamReader(newInputStream(path), decoder);
        return new BufferedReader(reader);
    }

 

/**
     * Returns an array list containing the elements returned by the
     * specified enumeration in the order they are returned by the
     * enumeration.  This method provides interoperability between
     * legacy APIs that return enumerations and new APIs that require
     * collections.
     *
     * @param  the class of the objects returned by the enumeration
     * @param e enumeration providing elements for the returned
     *          array list
     * @return an array list containing the elements returned
     *         by the specified enumeration.
     * @since 1.4
     * @see Enumeration
     * @see ArrayList
     */
    public static  ArrayList list(Enumeration e) {
        ArrayList l = new ArrayList<>();
        while (e.hasMoreElements())
            l.add(e.nextElement());
        return l;
    }

 

第2条:遇到多个构造器参数时要考虑使用构建器 

静态工厂和构造器有个共同的局限性：它们都不能很好地扩展到大量的可选参数 ,

1.程序员一向习惯采用重叠构造器（ telescoping constructor）模式，

简而言之，重叠构造器模式可行，但是当有许多参数的时候，客户端代码会很难缩写， 并且仍然较难以阅读。  

2.JavaBeans 模式，先调用一个无参构造器来创建对象，然后再调用 setter 方法来设置每个必要的参 数，以及每个相关的可选参数：

 JavaBeans 模式自身有着很严重的缺点。

因为构造过程被分到了几个调用中,在构造过程中 JavaBean 可能处于不一致的状态。 类无法仅仅通过检验构造器参数的有效性来保证一致性。 试图使用处于不一致状态的对象将会导致失败，这种失败与包含错误的代码 大相径庭，因此调试起来十分困难。 与此相关的另一点不足在于， JavaBeans 模式使得把 类做成不可变的可能性不复存在 .

package com.liruilong.common.demo;

/**
 * @Auther Liruilong
 * @Date 2020/8/4 12:34
 * @Description:
 */
public class Demo {
    private final int a;
    private final int d;
    private Demo(Bulider bulider) {
        a = bulider.a;
        d = bulider.d;
    }
    public static class Bulider {
        private int a;
        private int d;
        public Bulider(int a) {
            this.a = a;
        }
        public Demo build() {
            return new Demo(this);
        }
        public Bulider setA(int a) {
            this.a = a;
            return this;
        }
        public Bulider setD(int d) {
            this.d = d;
            return this;
        }
    }

    public static void main(String[] args) {
        Demo build = new Demo.Bulider(3).setD(4).build();
    }


}

注意Demo是不可变的，所有的默认参数值都单独放在个地方。builder的设值方法返回builder本身，以便把调用链接起来，得到一个流式的API。 BuiIde模式模拟了具名的可选参数。

为了简洁起见，示例中省略了有效性检查。要想尽快侦测到无效的参数，可以在builder的构造器和方法中检查参数的有效性。查看不可变量，包括build方法调用的构造器中的多个参数。为了确保这些不变量免受攻击，从builder复制完参数之后，要检查对象域（详见第50条）。如果检查失败，就抛出Il leg a lArgumen tExcept ion （详见第72条），其中的详细信息会说明哪些参数是无效的（详见第75条）

package com.liruilong.common;

import java.util.EnumSet;
import java.util.Objects;
import java.util.Set;

/**
 * @Auther Liruilong
 * @Date 2020/8/4 20:04
 * @Description:
 */
public abstract class Pizza {
    public enum Topping { HAM, MUSHROOM, ONION, PEPPER, SAUSAGE }
    final Set toppings;
    abstract static class Builder>{
        // TODO: 2020/8/4  noneOf(class  elementType)  :  使用指定的元素类型创建一个空的枚举集
        EnumSet toppings= EnumSet.noneOf(Topping.class);
        public T addTopping(Topping topping) {
            // TODO: 2020/8/4 检查指定的对象引用不是 null : 检查指定的对象引用不是 null (抛异常)     
            toppings.add(Objects.requireNonNull(topping));
            return self();
        }
        protected abstract T self();
    }
    Pizza (Builder builder){
     toppings = builder.toppings.clone();
    }
}
    

Builder模式也适用于类层次结构 

package com.liruilong.common;

import java.util.EnumSet;
import java.util.Objects;
import java.util.Set;

/**
 * @Auther Liruilong
 * @Date 2020/8/4 20:04
 * @Description: 通过内部抽象类来构建成员。
 */
public abstract class Pizza {
    public enum Topping {HAM, MUSHROOM, ONION, PEPPER, SAUSAGE}

    final Set toppings;

    abstract static class Builder> {
        // TODO: 2020/8/4  noneOf(class  elementType)  :  使用指定的元素类型创建一个空的枚举集
        EnumSet toppings = EnumSet.noneOf(Topping.class);

        public T addTopping(Topping topping) {
            // TODO: 2020/8/4 检查指定的对象引用不是 null : 检查指定的对象引用不是 null (抛异常)
            toppings.add(Objects.requireNonNull(topping));
            return self();
        }

        protected abstract T self();

        abstract Pizza build();
    }

    Pizza(Builder builder) {
        toppings = builder.toppings.clone();
    }
}
    

 Pizza.Builder的类型是泛型（generictype），带有一个递归类型参数（recursivetype parameter），详见第30条。它和抽象的self方法一样，允许在子类中适当地进行方法链接，不需要转换类型。这个针对Java缺乏self类型的解决方案，被称作模拟的self类型（simulatedself-type）。

package com.liruilong.common;

/**
 * @Auther Liruilong
 * @Date 2020/8/5 19:58
 * @Description:
 */
public class Calzone extends Pizza {

    private final boolean sauceInside;

    public static class Builder extends Pizza.Builder {
        private boolean sauceInside = false; //default

        public Builder sauceInside() {
            sauceInside = true;
            return this;
        }
        // TODO 方法重写 return 可以是子类型
        @Override
        public Calzone build() {
            return new Calzone(this);
        }
        @Override
        protected Builder self() {
            return this;
        }
    }
    private  Calzone(Builder builder){
        super(builder);
        sauceInside = builder.sauceInside;
    }

}

-------------------------------------
package com.liruilong.common;

import java.util.Objects;


/**
 * @Auther Liruilong
 * @Date 2020/8/5 19:47
 * @Description:
 */
public class NyPizza extends Pizza {

    public enum Size {SMALL, LARGE}

    private final Size size;

    public static class Builder extends Pizza.Builder {
        private final Size size;

        public Builder(Size size) {
            this.size = Objects.requireNonNull(size);
        }

        @Override
        protected Builder self() {
            return this;
        }

        @Override
        NyPizza build() {
            return new NyPizza(this);
        }
    }

    private NyPizza(Builder builder) {
        super(builder);
        size = builder.size;
    }

    public static void main(String[] args) {
        NyPizza pizza = new NyPizza.Builder(Size.SMALL).addTopping(Topping.ONION)
                        .addTopping(Topping.ONION).build();
        Calzone calzone = new Calzone.Builder()
                        .addTopping(Topping.ONION).sauceInside().build();
    }


}

 在该方法中，子类方法声明返回超级类中声明的返回类型的子类型，这被称作协变返回类型(covariant return type）。它允许客户端无须转换类型就能使用这些构建器

• 与构造器相比，builder的微略优势在于，它可以有多个可变（varargs）参数。因为builder是利用单独的方法来设置每一个参数。
• 此外，构造器还可以将多次调用某一个方法而传人的参数集中到一个域中，如前面的调用了两次addToppiq方法的代码所示。
• Builder模式十分灵活，可以利用单个builder构建多个对象。build的参数可以在调用build方法来创建对象期间进行调整，也可以随着不同的对象而改变。
• builder可以自动填充某些域，例如每次创建对象时自动增加序列号。因此它只在有很多参数的时候才使用，比如4个或者更多个参数。

如果类的构造器或者静态工厂中具有多个参数，设计这种类时，Builde模式就是一种不错的选择，特别是当大多数参数都是可选或者类型相同的时候。与使用重叠构造器模式相比，使用Builder模式的客户端代码将更易于阅读和编写，构建器也比JavaBeans更加安全。

第3条:用私有构造器或者枚举类型强化Singleton属性

Singleton是指仅仅被实例化一次的类。Singleton通常被用来代表一个无状态的对象，如函数（详见第24条），或者那些本质上唯一的系统组件。使类成为Singleton会使它的害户端测试变得十分困难

package com.liruilong.common;

/**
 * @Auther Liruilong
 * @Date 2020/8/6 19:48
 * @Description:
 */
public class Singleton {
    public static  final  Singleton sin = new Singleton();

    // todo 私有状态,保证全局唯一性。
    /***
     
AccessibleObject.setAccessible方法，通过反射机制（详见第65条）调用私有构造器

     * @Description
     * @author Liruilong
     * @Date 2020年08月06日  20:08:39
     **/
    private Singleton(){}

    public static Singleton getSin() {
        return sin;
    }


}

使用静态工厂的一个优势是，可以通过方法引用（method reference）作为提供者

序列化状态 添加 transient 是实例域为，并提供一个readResolve 方法 

package com.liruilong.common;

import java.io.Serializable;

/**
 * @Auther Liruilong
 * @Date 2020/8/6 19:48
 * @Description:
 */
public class Singleton  implements Serializable {
    //todo  序列化状态 添加 transient 是实例域为，并提供一个readResolve 方法
    public transient static  final  Singleton sin = new Singleton();

    // todo 私有状态,保证全局唯一性。
    /***
     
AccessibleObject.setAccessible方法，通过反射机制（详见第65条）调用私有构造器

     * @Description
     * @author Liruilong
     * @Date 2020年08月06日  20:08:39
     **/
    private Singleton(){}

    public static Singleton getSin() {
        return sin;
    }
    public Singleton readResolve(){
        return sin;
    }


}

实现Singleton的第三种方法是声明一个包含单个元素的枚举类型：单元素的枚举类型经常成为实现Singleton的最佳方法。

package com.liruilong.singleton;
 
/**
 * @Author: Liruilong
 * @Date: 2019/7/20 17:55
 */
 
// final 不允许被继承
public final class Singleton {
    // 实例变量
    private byte[] bate = new byte[1024];
    // 私有的构造函数，即不允许外部 new
    private Singleton(){ }
/**
     * @Author Liruilong
     * @Description 基于枚举类线程安全
     * 枚举类型不允许被继承，同样线程安全的，且只能被实例化一次。
     * @Date 17:33 2019/7/26
     * @Param []
     * @return com.liruilong.singleton.Singleton
     **/
    private enum Singtetonss {
        SINGTETONSS; //实例必须第一行，默认 public final static修饰
        private Singleton singleton;
 
        Singtetonss() { //构造器。默认私有
            this.singleton = new Singleton();
        }
        public static Singleton getInstance() {
            return SINGTETONSS.singleton;
        }
    }
    public static  Singleton getInstance3(){
        return Singtetonss.getInstance();
    }

第4条 通过私有构造器强化不可实例化的能力

企图通过将类做成抽象类来强制该类不可被实例化是行不通的。该类可以被子类化，并且该子类也可以被实例化。

因此只要让这个类包含一个私有构造器，它就不能被实例化：

package com.liruilong.common;

/**
 * @Auther Liruilong
 * @Date 2020/8/6 20:31
 * @Description:
 */
public class NoNewClass {
    private NoNewClass(){
        //
        throw new AssertionError();
    }
}

第5条:优先考虑依赖注入来引用资源

有许多类会依赖一个或多个底层的资源。例如，拼写检查器需要依赖词典。

不要用Singleton和静态工具类来实现依赖一个或多个底层资源的类，且该资源的行为会影响到该类的行为；也不要直接用这个类来创建这些资源。而应该将这些资源或者工厂传给构造器（或者静态工厂，或者构建器），通过它们来创建类。这个实践就被称作依赖注入，它极大地提升了类的灵活性、可重用性和可测试性

第6条:避免创建不必要的对象

一般来说，最好能重用单个对象，而不是在每次需要的时候就创建一个相同功能的新对象。重用方式既快速，又流行。

如果对象是不可变的（immutable)它就始终可以被重用。

对于同时提供了静态工厂方法（staticfactory method) 和构造器的不可变类，通常优先使用静态工厂方法而不是构造器

注意构造器Boolean(String）在Java9中已经被废弃了。

构造器在每次被调用的时候都会创建一个新的对象，而静态工厂方法则从来不要求这样做，实际上也不会这样做。除了重用不可变的对象之外，也可以重用那些已知不会被修改的可变对象。

 public static void main(String[] args) {
        // Boolean.valueOf(""); 优于  new Boolean("");   
        Boolean.valueOf("");
        new Boolean("");
    }

 对于字符串的正则匹配。虽然String.matches方法最易于查看一个字符串是否与正则表达式相匹配，但并不适合在注重性能的情形中重复使用

它在内部为正则表达式创建了一个Pattern实例，却只用了一次，之后就可以进行垃圾回收了。创建Patter口实例的戚本很高，因为需要将正则表达式编译成一个有限状态机（finitestate machine）。

 private static final Pattern ROMAN = Pattern.compile("^(?=.)M*(C[MD]D?C{0,3})" +
            "(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");

 
static boolean isRomanNumeral(String s){
        // 正确的写法：
        ROMAN.matcher(s).matches();
        
        return s.matches("^(?=.)M*(C[MD]D?C{0,3})" +
                "(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");
    }

自动装箱（autoboxing），它允许程序员将基本类型和装箱基本类型（BoxedPrimitive Type）混用，按需要自动装箱和拆箱。自动装箱使得基本类型和装箱基本类型之间的差别变得模糊起来，但是并没有完全消除 。

 public static long sum(){
        // long sum = 0; 比 Long 快很多
        // 要优先使用基本类型，而不是封装类型，要当心无意识的使用自动装箱
        Long sum = 0L;
        for (long i = 0; i < Integer.MAX_VALUE; i++) {
            sum += i;
        }
        return sum;
    }

第7条:消除过期的对象引用·

清空对象引用应该是一种例外，而不是一种规范行为。消除过期引用最好的方法是让包含该引用的变量结束其生命周期。如果你是在最紧凑的作用域范围内定义每一个变量（详见第57条），这种情形就会自然而然地发生

package com.liruilong.common;

import java.util.Arrays;
import java.util.EmptyStackException;
import java.util.Objects;

/**
 * @Auther Liruilong
 * @Date 2020/8/6 20:54
 * @Description:
 */
public class Stack {
    private Object[] element;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;


    public Stack() {
        this.element = new Object[DEFAULT_INITIAL_CAPACITY];
    }
    public void push(Object object){
        ensureCapactity();
        element[size++] = object;
    }
    public Object pop(){
        if (size == 0){
            throw new EmptyStackException();
        }
        return element[--size];
    }
    // TODO 程序中哪里发生了内存泄漏呢？如果一个战先是增长，然后再收缩，
    //  那么，从校中弹出来的对象将不会被当作垃圾回收，
    //  即使使用校的程序不再引用这些对象，它们也不会被回收。
    //  这是因为校内部维护着对这些对象的过期引用（obsolete reference）。
    //  所谓的过期引用，是指永远也不会再被解除的引用。
    //  在本例中，凡是在elements数组的“活动部分”(active portion）之外的任何引用都是过期的。
    //  活动部分是指elements中下标小于size的那些元素

    private void ensureCapactity() {
        if(element.length == size){
            element = Arrays.copyOf(element, 2 * size + 1);
        }
    }
}

在支持垃圾回收的语言中，内存泄漏是很隐蔽的（称这类内存泄漏为“无意识的对象保持”（unintentionalobject retention）更为恰当）。如果一个对象引用被无意识地保留起来了，那么垃圾回收机制不仅不会处理这个对象.

public Object pop(){
        if (size == 0){
            throw new EmptyStackException();
        }
        Object result = element[--size];
        element[size] = null;
        return result;
    }

• 只要类是自己管理内存，程序员就应该警惕内存泄漏问题。
• 内存泄漏的另一个常见来源是缓存。
  • 如果你正好要实现这样的缓存：只要在缓存之外存在对某个项的键的引用，该项就有意义，那么就可以用WeakHashMap代表缓存；当缓存中的项过期之后，它们就会自动被删除。记住只有当所要的缓存项的生命周期是由该键的外部引用而不是由值决定时，WeakHashMap才有用。

WeakHashMap：

public class WeakHashMapextends AbstractMapimplements Map

 

以弱键 实现的基于哈希表的 Map。在 WeakHashMap 中，当某个键不再正常使用时，将自动移除其条目。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃，这就使该键成为可终止的，被终止，然后被回收。丢弃某个键时，其条目从映射中有效地移除，因此，该类的行为与其他的 Map 实现有所不同。

null 值和 null 键都被支持。该类具有与 HashMap 类相似的性能特征,并具有相同的效能参数初始容量 和加载因子。

像大多数 collection 类一样，该类是不同步的。可以使用 Collections.synchronizedMap 方法来构造同步的 WeakHashMap。

该类主要与这样的键对象一起使用，其 equals 方法使用 == 运算符来测试对象标识。一旦这种键被丢弃，就永远无法再创建了，所以，过段时间后在 WeakHashMap 中查找此键是不可能的，不必对其项已移除而感到惊讶。该类十分适合与 equals 方法不是基于对象标识的键对象一起使用，比如，String 实例。然而，对于这种可重新创建的键对象，键若丢弃，就自动移除 WeakHashMap 条目，这种表现令人疑惑。

WeakHashMap 类的行为部分取决于垃圾回收器的动作，所以，几个常见的（虽然不是必需的）Map 常量不支持此类。因为垃圾回收器在任何时候都可能丢弃键，WeakHashMap 就像是一个被悄悄移除条目的未知线程。特别地，即使对 WeakHashMap 实例进行同步，并且没有调用任何赋值方法，在一段时间后 size 方法也可能返回较小的值，对于 isEmpty 方法，返回 false，然后返回 true，对于给定的键，containsKey 方法返回 true 然后返回 false，对于给定的键，get 方法返回一个值，但接着返回 null，对于以前出现在映射中的键，put 方法返回 null，而 remove 方法返回 false，对于键 set、值 collection 和条目 set 进行的检查，生成的元素数量越来越少。

WeakHashMap 中的每个键对象间接地存储为一个弱引用的指示对象。因此，不管是在映射内还是在映射之外，只有在垃圾回收器清除某个键的弱引用之后，该键才会自动移除。

实现注意事项：WeakHashMap 中的值对象由普通的强引用保持。因此应该小心谨慎，确保值对象不会直接或间接地强引用其自身的键，因为这会阻止键的丢弃。注意，值对象可以通过 WeakHashMap 本身间接引用其对应的键；这就是说，某个值对象可能强引用某个其他的键对象，而与该键对象相关联的值对象转而强引用第一个值对象的键。处理此问题的一种方法是，在插入前将值自身包装在 WeakReferences 中，如：m.put(key, new WeakReference(value))，然后，分别用 get 进行解包。

collection 的 iterator 方法所返回的迭代器（由该类所有“collection 视图方法”返回）均是快速失败的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器自身的 remove 或 add 方法,其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就完全失败，而不是冒着在将来不确定的时间任意发生不确定行为的风险。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测 bug。

此类是 Java Collections Framework 的成员。

    public static void main(String[] args) {
        System.out.println(isRomanNumeral("IV"));
        WeakHashMap weakHashMap = new WeakHashMap(){
            {
                for (int i = 0; i < 0 ; i++) {
                    put(i+"","==========="+i);
                }
            }
        };
        weakHashMap.forEach((o1,o2) -> System.out.println("原来的数据："+o1+":"+o2));
        //调用垃圾回收后没有数据
        Runtime.getRuntime().gc();
        System.out.println("额 ，数据呢："+weakHashMap.get("1"));
        weakHashMap.forEach((o1,o2) -> System.out.println("现在的数据："+o1+":"+o2));
    }

 

缓存应该时不时地清除掉没用的项。这项清除工作可以由一个后台线程（可能是ScheduledThreadPoolExecutor）[在给定延时后执行异步任务或者周期性执行任务]来完成，或者也可以在给缓存添加新条目的时候顺便进行清理。LinkedHashMap类利用它的removeEldestEntry方法可以很容易地实现后一种方案。对于更加复杂的缓存，必须直接使用java.lang.ref

• 内存泄漏的第三个常见来源是监昕器和其他回调。

如果你实现了一个API，客户端在这个API中注册回调，却没有显式地取消注册，那么除非你采取某些动作，否则它们就会不断地堆积起来。确保回调立即被当作垃圾回收的最佳方法是只保存它们的弱引用（weakreference），例如，只将它们保存成WeakHashMap中的键.

package com.liruilong.common.util;

import java.util.Map;
import java.util.Objects;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Author Liruilong
 * @Date 2020/8/11 09:37
 * @Description: 基于 WeakHashMap 的缓存实现
 */
public class WeakHashMapCache {
    private final int size;

    private final Map eden;

    private final Map longterm;

    private WeakHashMapCache(Builder builder){
       this.size = builder.size;
       this.eden = builder.eden;
       this.longterm = builder.longterm;
    }

    public  static class Builder{
        private volatile int size;

        private volatile  Map eden;

        private volatile Map longterm;

        public  Builder(int size){
            this.size = rangeCheck(size,Integer.MAX_VALUE,"缓存容器初始化容量异常");
            this.eden = new ConcurrentHashMap<>(size);
            this.longterm = new WeakHashMap<>(size);
        }

        private static int rangeCheck(int val, int i, String arg) {
            if (val < 0 || val > i) {
                throw new IllegalArgumentException(arg + ":" + val);
            }
            return  val;
        }
        public WeakHashMapCache build(){
            return new WeakHashMapCache(this);
        }

    }
    public V get(K k){
        V v = this.eden.get(k);
        if (Objects.isNull(v)){
            v = this.longterm.get(k);
            if (Objects.nonNull(v)){
                this.eden.put(k,v);
            }
        }
        return v;
    }
    public void put(K k,V v){
        if (this.eden.size() >= size){
            this.longterm.putAll(this.eden);
            this.eden.clear();
        }
        this.eden.put(k,v);
    }

    public static void main(String[] args) {

        WeakHashMapCache cache = new WeakHashMapCache.Builder(3).build();

        for (int i = 0; i < 5; i++) {
            cache.put(i+"",i+"");
        }
        System.gc();
        for (int i = 0; i < 5; i++) {
            System.out.println(cache.get(i + ""));
        }

    }

}

https://github.com/apache/tomcat/blob/3e5ce3108e2684bc25013d9a84a7966a6dcd6e14/java/org/apache/tomcat/util/collections/ConcurrentCache.java 

 --- Ajax请求之后的数据会一直保存在内存中，等待下一次请求覆盖掉，还是会直接被js回收掉？？

借助于Heap剖析工具（HeapProfiler）才能发现内存泄漏问题

第8条:避免使用终结方法和清除方法

终结方法（finalize「）通常是不可预测的，也是很危险的，一般情况下是不必要的，

在Java9 中用清除方法（cleaner）代替了终结方法。清除方法没有终结方法那么危险，但仍然是不可预测、运行缓慢，一般情况下也是不必要的

终结方法和清除方法的缺点在于不能保证会被及时执行。从一个对象变得不可到达开始，到它的终结方法被执行，所花费的这段时间是任意长的。这意味着，注重时间的任务不应该由终结方法或者清除方法来完成

终结方法线程的优先级比该应用程序的其他线程的优先级要低得多。

永远不应该依赖终结方法或者清除方法来更新重要的持久状态，不要被System.gc和System.runFinalization这两个方法所诱惑。

第9条: try-with-resources优先于try-finally

当Java7引人try-with刊sources语句。要使用这个构造的资源，必须先实现AutoCloseable接口，其中包含了单个返回void的close方法。Java类库与第三方类库中的许多类和接口，现在都实现或扩展了AutoCloseable接口。如果编写了一个类，它代表的是必须被关闭的资源，那么这个类也应该实现AutoCloseable。

public class Stack extends Exception implements AutoCloseable {

  @Override
    public void close() throws Exception {
        System.out.println("资源关闭");
    }
 public static void main(String[] args) {

  try(Stack stack = new Stack()){
            stack.push("嘻嘻，加油");
            System.out.println(stack.pop());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

嘻嘻，加油
资源关闭

 第3章对于所有对象都通用的方法

Object所有的非final方法（equals、hashCode、toString、clone和finalize）都有明确的通用约定（general contract), 因为它们设计成是要被覆盖（override）的。任何一个类，它在覆盖这些方法的时·候，都有责任遵守这些通用约定；如果不能做到这一点，其他依赖于这些约定的类（例如HashMap和HashSet）就无法结合该类一起正常运作。

第10条:覆盖equals时请遵守通用约定

• 类的每个实例本质上都是唯一的。
• 类没有必要提供“逻辑相等”（logical equality）的测试功能
• 超类已经覆盖了equals，超类的行为对于这个类也是合适的
• 类是私有的，或者是包级私有的，可以确定它的equals方法永远不会被调用

什么时候应该覆盖equals方法呢？

有一种“值类”不需要覆盖equals方法，即用实例受控确保“每个值至多只存在一个对象”的类。枚举类型（详见第34条）就属于这种类。对于这样的类而言，逻辑相同与对象等同是一回事，因此Object的equals方法等同于逻辑意义上的equals方法

如果类具有自己特有的“逻辑相等”（logicalequality）概念（不同于对象等同的概念），而且超类还没有覆盖equals。这通常属于“值类”（value class）的情形。值类仅仅是一个表示值的类。

五个要求：

• 自反性（Reflexivity）
• 对称性（Symmetry）
• 传递性（Transitivity）平行性
• 一致性（Consistency）
• 非空性（Non-nullity）

在equals方法中用getClass测试代替instanceof测试，可以扩展可实例化的类和增加新的值组件，同时保留equals约定的不可行性。

我们无法在扩展可实例化的类的同时，既增加新的值组件，同时又保留equals约定

方法：

1. 使用＝＝操作符检查“参数是否为这个对象的引用”
2. 使用instanceof操作符检查“参数是否为正确的类型”为空。
3. 把参数转换成正确的类型
4. 对于该类中的每个“关键”（significant ）域，检查参数中的域是否与该对象中对应的域相匹配。
5. 在编写完equals方法之后，应该问自己三个问题：它是否是对称的、传递的、一致的？

注意：

• 覆盖equals时总要覆盖hashCode
• 不要企图让equals方法过于智能
• 不要将equals声明中的Object对象替换为其他的类型：这个方法并没有覆盖（override)Object. equals，因为它的参数应该是Object类型，相反，它重载（overload）了Object.equals 。
• 里氏替换原则（Liskov substitution principle）认为，一个类型的任何重要属性也将适用于它的子类型，

package com.liruilong.common;

import java.util.Objects;

/**
 * @Author Liruilong
 * @Date 2020/8/8 17:25
 * @Description:
 */
public class PhoneNumber {
    private final short areaCode, prefix, lineNum;

    public PhoneNumber(int areaCode, int prefix, int lineNum) {
        this.areaCode = rangeChek(areaCode, 999, "area code");
        this.prefix = rangeChek(prefix,999,"pre fix");
        this.lineNum = rangeChek(lineNum,999,"lineNum");
    }

    private static short rangeChek(int val, int i, String arg) {
        if (val < 0 || val > i) {
            throw new IllegalArgumentException(arg + ":" + val);
        }
        return (short) val;
    }
    /**
     * @param o
     * @return boolean
     * @Description
     * 使用＝＝操作符检查“参数是否为这个对象的引用”
     * 使用instanceof操作符检查“参数是否为正确的类型”为空。
     * 把参数转换成正确的类型
     * 对于该类中的每个“关键”（significant ）域，检查参数中的域是否与该对象中对应的域相匹配。
     * @author Liruilong
     * @Date 2020年08月08日  17:08:46
     **/
    @Override
    public boolean equals(Object o) {
        // 使用＝＝操作符检查“参数是否为这个对象的引用”
        if (this == o) {
            return true;
        }

        // 使用instanceof操作符检查“参数是否为正确的类型”为空。测试等同性的同时，测试非空性。
        if (!(o instanceof PhoneNumber)) {
            return false;
        }
        // 把参数转换成正确的类型
        PhoneNumber that = (PhoneNumber) o;
        // 对于该类中的每个“关键”（significant ）域，检查参数中的域是否与该对象中对应的域相匹配。
        return areaCode == that.areaCode &&
                prefix == that.prefix &&
                lineNum == that.lineNum;
    }

    @Override
    public int hashCode() {
        return Objects.hash(areaCode, prefix, lineNum);
    }
}

第11条:覆盖equals时总要覆盖hashCode

在每个覆盖了equals方法的类中，都必须覆盖hashCode方法。如果不这样做的话，就会违反hashCode的通用约定，从而导致该类无法结合所有基于散列的集合一起正常运作，这类集合包括HashMap和HashSet。

因没有覆盖hashCode而违反的关键约定是第二条：相等的对象必须具有相等的散到码（hashcode ）。

@Override
    public int hashCode() {
        return Objects.hash(areaCode, prefix, lineNum);
    }

//---------------------------
 public static int hash(Object... values) {
        return Arrays.hashCode(values);
    }
//---------------------------
public static int hashCode(Object a[]) {
        if (a == null)
            return 0;

        int result = 1;

        for (Object element : a)
            result = 31 * result + (element == null ? 0 : element.hashCode());

        return result;
    }

第12条:始终要覆盖toString

提供好的t。String实现可以便类用起来更加舒适，使用了这个类的系统也更易于调试。

 @Override
    public String toString() {
        return "PhoneNumber{" +
                "areaCode=" + areaCode +
                ", prefix=" + prefix +
                ", lineNum=" + lineNum +
                '}';
    }

    public static void main(String[] args) {
        PhoneNumber phoneNumber = new PhoneNumber(12,23,34);
        System.out.println(phoneNumber);
    }

com.liruilong.common.PhoneNumber@a456
PhoneNumber{areaCode=12, prefix=23, lineNum=34}

在实际应用中，toString方法应该返回对象中包含的所有值得关注的信息，

 public static void main(String[] args) {
        PhoneNumber phoneNumber = new PhoneNumber(12,212323,34);
        System.out.println(phoneNumber);
    }

要在你编写的每一个可实例化的类中覆盖Object的toString实现，除非已经在超类中这么做了。这样会使类使用起来更加舒适，也更易于调试。toString方法应该以美观的格式返回一个关于对象的简洁、有用的描述。

Exception in thread "main" java.lang.IllegalArgumentException: pre fix:212323
	at com.liruilong.common.PhoneNumber.rangeChek(PhoneNumber.java:21)
	at com.liruilong.common.PhoneNumber.(PhoneNumber.java:15)
	at com.liruilong.common.PhoneNumber.main(PhoneNumber.java:70)

制定格式：

  // 无论是否决定指定格式，都应该在文档中明确地表明你的意图
    @Override
    public String toString() {
        return String.format("%03d-%03d-%04d",areaCode,prefix,lineNum);
    }

 

012-045-0034

 第13条:谨慎地覆盖clone

Cloneable接口的目的是作为一个标注接口。表明该类的实例允许克隆。

事实上，实现Cloneable接口的类是为了提供一个功能适当的公有的clone方法。

package com.liruilong.common;

import java.util.Objects;

/**
 * @Author Liruilong
 * @Date 2020/8/8 17:25
 * @Description:
 */
public class PhoneNumber  implements  Cloneable{

    @Override
    protected PhoneNumber clone() throws CloneNotSupportedException {
       try {
           return ((PhoneNumber) super.clone());
        }catch (CloneNotSupportedException e){
           throw  new AssertionError();
       }
    }

}

  因为Java支持协变返回类型（covariant return type）。换句话说，目前覆盖方法的返回类型可以是被覆盖方法的返回类型的子类了.

 /* @return     a clone of this instance.
     * @throws  CloneNotSupportedException  if the object's class does not
     *               support the {@code Cloneable} interface. Subclasses
     *               that override the {@code clone} method can also
     *               throw this exception to indicate that an instance cannot
     *               be cloned.
     * @see java.lang.Cloneable
     */
    protected native Object clone() throws CloneNotSupportedException;

对super.clone方法的调用应当包含在一个try-catch块中。这是因为Object声明其clone方法抛出CloneNotSupportedException，这是一个受检异常（checkedexception）。由于PhoneNumber实现了Cloneable接口

对于域中包含引用类的对象。

实际上，clone方法就是另一个构造器；必须确保它不会伤害到原始的对象，并确保正确地创建被克隆对象中的约束条件

Cloneable架构与引用可变对象的final域的正常用法是不相兼容的，

对象拷贝的更好的办法是提供一个拷贝构造器（copyconstructo「）或拷贝工厂（copy factory ）。

总之，复制功能最好由构造器或者工厂提供。这条规则最绝对的例外是数组，最好利用clone方法复制数组。

第14条:考虑实现Comparable接口

compareTo方法并没有在Object类中声明。相反，它是Comparable接口中唯一的方法。将这个对象与指定的对象进行比较。当该对象小于、等于或大于指定对象的时候，分别返回一个负整数、零或者正整数。如果由于指定对象的类型而无法与该对象进行比较，则抛出ClassCastException异常

public interface Comparable {
     /* @param   o the object to be compared.
     * @return  a negative integer, zero, or a positive integer as this object
     *          is less than, equal to, or greater than the specified object.
     *
     * @throws NullPointerException if the specified object is null
     * @throws ClassCastException if the specified object's type prevents it
     *         from being compared to this object.
     */
    public int compareTo(T o);
}

compareTo方法不但允许进行简单的等同性比较，而且允许执行顺序比较，除此之外，它与Object的equals方法具有相似的特征，它还是个泛型（generic）。

类实现了Comparable接口，就表明它的实例具有内在的排序关系( natural ordering）。为实现Comparable接口的对象数组进行排序就这么简单。

 Arrays.sort(new PhoneNumber[]{new PhoneNumber(12,23,34)});

在compareTo方法中使用关系操作符〈和〉是非常烦琐的，并且容易出错，因此不再建议使用。 

public static void main(String[] args) {
        Demo build = new Bulider(3).setD(4).build();
        Set s = new TreeSet();
        Collections.addAll(s,args);
    }

  Java 平台类库中的所有值类（ value classes）， 以及所有的枚 举类型（详见第 34 条）都实现了 Comparable 接口 。 如果你正在编写一个值类，它具有非 常明显的内在排序关系，比如按字母顺序、按数值顺序或者按年代顺序，那你就应该坚决考虑实现 Comparable 接口：
在 Java 8 中， Comparator 接口配置了一组 比较器构造方法 （ comparator construction methods），使得 比较器的构造工作变得非常流畅。 之后，按照 Comparable 接口 的要求， 这些比较器可以用来实现一个 compareTo 方法

static Comparator