Java教程

Effective Java笔记

本文主要是介绍Effective Java笔记,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

使用Build模式

  • 不是直接生成想要的对象,而是让客户端利用所有必要的参数调用构造器,得到一个builder对象
  • 然后客户端在builder对象上调用类似于setter的方法,来设置每个相关的可选参数
  • 最后,客户端调用无参的build方法来生成不可变的对象
//   在这当中 FF是不可变的,所有的默认参数都单独放到一个地方
public class FF {
    private final int a;
    private final int b;
    private final int c;

    // Build 模式模拟了含有具体名字的可选参数
    public static class Builder{
        private final int a;
        private final int b;
        private int c;

        public Builder(int a, int b) {     //两个参数 
            this.a = a;
            this.b = b;
            System.out.println(a);
            System.out.println(b);
        }

        public Builder c(int val){   //单独一个参数
            c = val;
            System.out.println(c);
            return this;
        }

        public FF build(){
            return new FF(this);
        }
    }
    private FF(Builder builder){
        a = builder.a;
        b = builder.b;
        c = builder.c;
    }
    public static void main(String []args){
        FF f = new Builder(1,2).c(100).build();
    }

}

  • build模式十分灵活,可以利用耽搁builder构建多个对象
  • builder的参数可以在创建对象期间进行调整,也可随着不同的对象而改变

优先使用基本类型而不是装箱基本类型

测试

public static void main(String []args){
        long startTime = System.currentTimeMillis(); //获取开始时间

        long sum = 0L;
        for(long i = 0; i < Integer.MAX_VALUE; i++){
            sum += i;
        }
        System.out.println(sum);
        long endTime = System.currentTimeMillis(); //获取结束时间
        System.out.println("程序运行时间:" + (endTime - startTime) + "ms"); //输出程序运行时间
    }

  • 只因为打错一个字符,变量sum被声明成Long而不是long,运行时间9254ms
  • sum改为long类型,运行时间为964ms

重写equals必须重写hashcode

反例

public class PhoneNum {
    private final short code;
    private final short prefix;


    public PhoneNum(int code, int prefix) {

        this.code = (short) code;
        this.prefix = (short) prefix;
        rangeCheck(code, 999, "code");
        rangeCheck(prefix, 9999, "prefix");
    }

    private static void rangeCheck(int arg,int max,String name){
        if(arg < 0 || arg > max){
            throw new IllegalArgumentException();
        }
    }
    @Override
    public boolean equals(Object o){
        if (o == this){
            return true;
        }
        if(!(o instanceof PhoneNum)){
            return false;
        }
        PhoneNum pn = (PhoneNum)o;
        return pn.prefix == prefix
                && pn.code == code;
    }
    public static void main(String []args){
        Map<PhoneNum,String> map = new HashMap<>();
        map.put(new PhoneNum(1,2),"jenny");
        System.out.println(map.get(new PhoneNum(1,2)));
    }
}

  • 这时候输出是null,这里涉及两个PhoneNum的实例;
  • 第一个被用于插入HashMap中,第二个实例与第一个实例相等,被用于获取;
  • 由于PhoneNum类没有覆盖hashcode方法,从而导致两个相等的实例具有不想等的散列码,违反了hashCode规约
  • 因此,put方法把电话号码对象存放在一个散列桶中
  • get方法却在另一个散列桶中查找这个电话号码,及时这两个实例正好被放到同一个散列桶中
  • get方法也必定会返回null,因为HashMap有一项优化,可将与每个项相关的散列码缓存起来
  • 如果散列码不匹配,也不必检验对象的等同性
这篇关于Effective Java笔记的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!