知其然,知其所以然之Java基础系列(一)

相信大家在最初接触Java基础学习的时候,也只是跟着课本上的描述学习,知其然,不知所以然,要想成为一个Java老鸟,不仅要学会怎么用,也要知道为何这么用。在Java基础系列的博客中,我会列举一系列大家日常开发中只知道会用的,却不知道为何如此这么用的那些常用知识点。

1.1 一个简单的String例子,看看个人功底如何?

下面看一段代码片段:

public static void main(String[] args){
         String a = "a" + "b" + 1;
         String b = "ab1";
         System.out.println(a == b);
}

我们在日常开发中,对于字符串的比较是通过equals()方法进行比较,而在上面这段代码中却使用了==比较两个字符串,我们知道,在我们刚接触Java程序设计的时候,老师教我们比较两个字符串用等号是匹配不了的,那这段代码运行结果是TRUE还是FALSE呢?

运行结果:

 

true

 

这肯定会让大家很迷茫,难道我们老师的真理是错的吗?其实也不能怪老师,老师带进门,修行靠个人。

分析:

分析之前你需要知道==和equals的区别?==用于比较内存单元格上的内容,比较对象时就是比较两个对象的内存地址是否一样,对于基本类型:byte,short,int,float,long等,其实是比较它们的值是否相等;在默认情况下,不重写equals方法也是比较内存地址,String类之所以能够用equals来比较两个字符串的值,是因为它重写了equals方法。为何 a == b运行结果true,答案是编译时优化,a = "a" + "b" + 1,等号右侧全是常量,当编译器编译代码时,无需运行时知道右侧是什么值,直接将其编译成,a = "ab1",所以,a和b指向了同一个引用。为何要做如此优化呢?提高整体效率呗,能提前做的事就提前做,为何要等到要做的时候在做呢,各位,是不是呢?

补充例子,看看大家掌握的如何了?

 

private static String getA(){
       return "a";
}

public static void main(String[] args){
      String a = "a";
      final String c = "a";
      String b = a + "b";
      String d = c + "b";
      String e = getA() + "b";
      String compare = "ab";
      System.out.println(b == compare);
      System.out.println(d == compare);
      System.out.println(e == compare);
}
      

 

1.2 使用“+”拼接字符串的误区

 

其实“+”在拼接少量的字符串的时候,效率比append()方法效率更高,String通过“+”拼接字符串的时候,如果拼接的是对象是常量,则会在编译时合并优化,在编译阶段就完成了,无需运行时;append()更适合去拼接大量的字符串。下面我们来看一段代码片段以及编译后的代码:

编译前:

 

public void sample(){
        String a = "a";
        String b = "b";
        String c = a + b + "f";
}


编译后:

 

 

public void sample(){
        String a = "a";
        String b = "b";
        StringBuilder temp = new StringBuilder();
        temp.append(a).append(b).append("f");
        String c = temp.toString();
}

我们接着看下使用“+”来拼接大量字符串会带来什么结果?

 

 

String a = "";
for(int i=0; i<10000; i++){
     a += i;
}


看下编译后,会怎样?

 

 

String a = "";
for(int i=0; i<10000; i++){
     StringBuilder temp = new StringBuilder();
     temp.append(a).append(i);
     a = temp.toString();
}


在这个循环的过程中,导致a引用的值越来越来,每次拼接都会产生一个临时变量,这个就会导致产生大量的临时垃圾,随着数量的增加,垃圾空间也会越来越大,可能会导致OOM,直接导致系统宕机或者僵死,大量的垃圾也会导致新生代堆内存不足频繁进行minor GC,当新生代中的对象转移至老年代,随着老年代内存空间被占满,会直接导致full GC,依次full GC时间持续之长,运行的系统性能极速下降。

 

总结:在开发过程知道拼接的全是常量或者少量拼接就可以使用"+",对于大量拼接请使用append()方法。

 

1.3 覆盖Object的equals方法

有的时候,我们重写了equals方法,却忘了重写hashCode()方法,可能导致我们找了好久才想起我们忘了重写这个方法了,白白浪费了时间。在每个覆盖了equals方法的类中,也必须覆盖其hashCode方法。如果不这么做的话,就违反了Object.hashCode通用约定,从而导致该类无法结合所有基于散列的集合一起正常运作,这样的集合包括:HashMap,HashSet和Hashtable。

下面我们来看一下,关于Object规范对equals和hashCode的约定吧

  • 在应用程序的执行期间,只要对象的equals方法的比较操作所用到的信息没有被修改,那么对这同一个对象调用多次,hashCode方法都必须始终如一地返回同一个数字。
  • 如果两个对象根据equals(Object)方法比较是相等的,那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。

下面看一段代码:

 

public class Student{
       private String id;
       private String name;
       private int age;

       public Student(String id, String name,  int age){
       this.id = id;
       this.name = name;
       this.age = age;
       
       //setter和getter方法省略

       @Override
       public boolean equals(Object o){
           if(o == this){
               return this;
           }
           if(o instanceof Student)
           Student stu = (Student) o;
           return o.getId().equals(id) && o.getName().equals(name)
                  && o.getAge() == age;
       }

 }


假设你企图将这个类与HashMap一起用:

 

 

Map<Student, String> stuMap = new HashMap<Student, String>;
stuMap.put("2010214139", "wangf", 26);

这时候,你可能期望stuMap.get(new Student("2010214139", "wangf", 26))会返回wangf,但它实际返回的是null。由于Student类没有覆盖HashCode方法,从而导致两个相等的实例具有不相等的散列码,违反了约定。只需为Student重写hashCode方法即可。

 

比如下面这种:

 

@Override
pulic int hashCode(){
      return 31;
}

虽然这种hashCode是合法的,但每次调用都返回相同的散列码,因此,每个对象都被映射到同一个散列桶中,使散列表退化为链表。一个好的散列函数通常倾向于"为相等的对象产生不相等的散列码"。如何写一个合法的hashCode呢?

 

  • 把某个非零的常数值,比如17,保存在名为result的int类型的变量中
  • 对于对象中每个关键域f,完成以下步骤:

              1)如果该域是boolean,则计算f ? 1:0;

              2)如果该域是byte、char、short或者int类型,则计算(int)f;

              3)如果该域是long类型,则计算(int)(f^(f>>>32));

              4)如果该域是float类型,则计算Float.floatToIntBits(f);

              5)如果该域是double类型,则计算Double.doubleToLongBits(),然后按照步骤3)操作

              6)如果该域是一个对象引用,并且该类的equals方法地跪地equals的方式来比较域,则同样为这个域递归的调用hashCode。如果这个域为null,则返回0。

              7)如果该域是一个数组,则把每一个元素当做单独的域处理。

  • 按照下面的公式,把步骤2中计算得到的散列码合并到result,result = 31 * result + x;
  • 返回result

下面写出Student的hashCode方法:

 

@Override
public int hashCode(){
   int result = 17;
   result = 31 * result + id.hashCode();
   result = 31 * result + name.hashCode();
   result = 31 * result + age;
   return result;
}

 

1.4 自动装箱和自动拆箱

Java1.5发行版中增加了自动装箱和自动拆箱,基本类型和装箱类型有三个主要区别:

  1. 基本类型只有值,两个装箱基本类型可以具有相等的值和不同的同一性。
  2. 基本类型只有功能完备的值,而每个装箱基本类型除了它对应基本类型的所有功能之外,还有个非功能值null。
  3. 基本类型通常比装箱类型节省空间。

如果不小心这三点都会让你陷入麻烦中。

下面我们看下这个小程序:

 

public class Test{
      private static Integer i;
      
      public static void main(String[] args){
           if(i == 32){
               System.out.println("hello");
           }
      }
}

事实上它并没输出hello,而是抛出了NPE,问题在于i是Integer类型,而不是int基本类型,就像所有的对象引用域一样,它的初始值都是null。

 

最后,看下这段代码片段:

 

public static void main(String[] args){
      Long sum = 0;
      for(long i=0; i<Integer.MAX_VALUE;i++){
           sum +=i ;
      }
      System.out.println(sum);

}

这个程序比预计的要慢一些,为什么呢?因为它把基本类型设计成了装箱类型,变量被反复的装箱和拆箱,导致性能明显下降。

 

核实使用装箱类型呢?答案有三点:

       第一点:作为集合中的元素、键和值

       第二点:在参数化类型中,必须使用装箱基本类型作为类型参数,比如ThradLocal<Integer>

       第三点:在进行反射的方法调用时,必须使用装箱基本类型

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值