Java语言的26个细节

Love The Way You Lie 2022-08-26 00:54 154阅读 0赞

# java中整数的相等比较 #

如果比较两个数值相等的Integer类型的整数，你可能会发现，用“==”比较（首先你必须明确“==”比较的是地址），有的时候返回true,而有的时候，返回false。

比如：  
Integer i = 128;  
Integer j = 128;  
System.out.println(i == j);//返回false

而  
Integer m = 127;  
Integer n = 127;  
System.out.println(m == n);//返回true

为什么两个相差1的数，比较的结果却不一样呢。看一下源码

public static Integer valueOf(int i) \{  
        assert IntegerCache.high >= 127;  
        if (i >= IntegerCache.low && i <= IntegerCache.high)  
            return IntegerCache.cache\[i + (-IntegerCache.low)\];  
        return new Integer(i);  
    \}  
Integer i = 128;这种方式赋值，会调用valueOf方法。我们发现这里做了一些关于IntegerCache的操作。IntegerCache源码：  
private static class IntegerCache \{  
        static final int low = -128;  
        static final int high;  
        static final Integer cache\[\];  
   
        static \{  
            // high value may be configured by property  
            int h = 127;  
            String integerCacheHighPropValue =  
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");  
            if (integerCacheHighPropValue != null) \{  
                int i = parseInt(integerCacheHighPropValue);  
                i = Math.max(i, 127);  
                // Maximum array size is Integer.MAX\_VALUE  
                h = Math.min(i, Integer.MAX\_VALUE - (-low) -1);  
            \}  
            high = h;  
   
            cache = new Integer\[(high - low) + 1\];  
            int j = low;  
            for(int k = 0; k < cache.length; k++)  
                cache\[k\] = new Integer(j++);  
        \}  
   
        private IntegerCache() \{\}  
    \}  
   
原来Integer把-128到127（可调）的整数都提前实例化了， 所以你不管创建多少个这个范围内的Integer都是同一个对象。

那么，如何比较两个Integer类型是否相等呢，你肯定会想到equals,没错，就是equals，看下equals源码：  
public boolean equals(Object obj) \{  
        if (obj instanceof Integer) \{  
            return value == ((Integer)obj).intValue();  
        \}  
        return false;  
    \}  
value值是int类型：

private final int value;

通过源码得知，是获取Integer的基本类型值来用==比较了。  
所以，我们也可以这样，通过Integer.intValue()获取int值来直接比较。  
其实，一个int类型和Integer直接“==”比较也是没有问题的：  
Integer i = 128;  
int j = 128;  
System.out.println(i == j);//返回true  
原因是Integer类型会自动拆箱变为int类型来进行比较。

综上：  
如果你用两个Integer类型的整数做相等比较

**1.如果Integer类型的两个数相等，如果范围在-128~127（默认），那么用“==”返回true，其余的范会false。  
2.两个基本类型int进行相等比较，直接用==即可。  
3.一个基本类型int和一个包装类型Integer比较，用==也可，比较时候，Integer类型做了拆箱操作。  
4.Integer类型比较大小，要么调用Integer.intValue()转为基本类型用“==”比较，要么直接用equals比较。**

扩展：  
Long和Short类型也做了相同的处理，只不过最大值是不可调的。  
参考Long的源码：

public static Long valueOf(long l) \{  
        final int offset = 128;  
        if (l >= -128 && l <= 127) \{ // will cache  
            return LongCache.cache\[(int)l + offset\];  
        \}  
        return new Long(l);  
    \}

参考Short的源码：  
public static Short valueOf(short s) \{  
        final int offset = 128;  
        int sAsInt = s;  
        if (sAsInt >= -128 && sAsInt <= 127) \{ // must cache  
            return ShortCache.cache\[sAsInt + offset\];  
        \}  
        return new Short(s);

# 其他 #

Java作为一门优秀的面向对象的程序设计语言,正在被越来越多的人使用。本文试图列出作者在实际开发中碰到的一些Java语言的容易被人忽视的细节,希望能给正在学习Java语言的人有所帮助。  
1，位移运算越界怎么处理  
    考察下面的代码输出结果是多少?  
    int a=5;  
    System.out.println(a<<33);

按照常理推测,把a左移33位应该将a的所有有效位都移出去了，那剩下的都是零啊，所以输出结果应该是0才对啊，可是执行后发现输出结果是10，为什么呢？因为Java语言对位移运算作了优化处理，Java语言对a<<b转化为a<<(b%32)来处理，所以当要移位的位数b超过32时，实际上移位的位数是b%32的值，那么上面的代码中a<<33相当于a<<1，所以输出结果是10。

补充：在java语言中，位移操作共分三种，左位移（<<），右位移（>>）和无符号右位移（>>>）。如果将位移运算表示为公式的话，即n operator s。其中，operator表示上述的三种位移操作之一；n和s表示操作数，必须是可以转化成int类型的，否则出现运行时错误。n是原始数值，s表示位移距离。该公式的含义是n按照operator运算符含义位移s位。位移的距离使用掩码32（类似于子网掩码），即位移距离总是在0~31之间，超出这个范围的位移距离（包括负数）会被转化在这个范围里。也就是说真正的位移距离是n%32，所以上面的位移距离33实际上是1。n<<s的结果（无论是否溢出）总是等价于n与2的n%32次幂的乘积。在上面的例子里面，位移距离是33%32即1，2的1次幂是2，5与2的乘积是10.所以最终结果是10。对于右位移操作n<<s的结果（无论是否溢出）总是等价于n与2的n%32次幂的商。（以上内容参考java规范15.9）

2，可以让i!=i吗？  
当你看到这个命题的时候一定会以为我疯了，或者Java语言疯了。这看起来是绝对不可能的，一个数怎么可能不等于它自己呢？或许就真的是Java语言疯了，不信看下面的代码输出什么？  
  double i=0.0/0.0;  
  if(i==i)\{   
      System.out.println("Yes i==i");  
  \}else\{   
      System.out.println("No i!=i");  
  \}  
上面的代码输出"No i!=i"，为什么会这样呢？关键在0.0/0.0这个值，在IEEE 754浮点算术规则里保留了一个特殊的值用来表示一个不是数字的数量。这个值就是NaN("Not a Number"的缩写)，对于所有没有良好定义的浮点计算都将得到这个值，比如：0.0/0.0；其实我们还可以直接使用Double.NaN来得到这个值。在IEEE 754规范里面规定NaN不等于任何值，包括它自己。所以就有了i！=i的代码。  
3，怎样的equals才安全？  
    我们都知道在Java规范里定义了equals方法覆盖的5大原则：reflexive（反身性），symmetric（对称性），transitive（传递性），consistent（一致性），non-null（非空性）。那么考察下面的代码：  
public class Student\{   
    private String name;  
    private int age;  
    public Student(String name,int age)\{   
        this.name=name;  
        this.age=age;  
    \}  
    public boolean equals(Object obj)\{   
        if(obj instanceof Student)\{   
            Student s=(Student)obj;  
            if(s.name.equals(this.name) && s.age==this.age)\{   
                return true;  
            \}  
        \}  
        return super.equals(obj);  
    \}  
\}

你认为上面的代码equals方法的覆盖安全吗？表面看起来好像没什么问题，这样写也确实满足了以上的五大原则。但其实这样的覆盖并不很安全，假如Student类还有一个子类CollegeStudent,如果我拿一个Student对象和一个CollegeStudent对象equals,只要这两个对象有相同的name和age，它们就会被认为相等，但实际上它们是两个不同类型的对象啊。问题就出在instanceof这个运算符上，因为这个运算符是向下兼容的，也就是说一个CollegeStudent对象也被认为是一个Student的实例。怎样去解决这个问题呢？那就只有不用instanceof运算符，而使用对象的getClass()方法来判断两个对象是否属于同一种类型，例如，将上面的equals()方法修改为：  
   public boolean equals(Object obj)\{   
        if(obj.getClass()==Student.class)\{   
            Student s=(Student)obj;  
            if(s.name.equals(this.name) && s.age==this.age)\{   
                return true;  
            \}  
        \}  
        return super.equals(obj);  
    \}  
  这样才能保证obj对象一定是Student的实例，而不会是Student的任何子类的实例。

4，浅复制与深复制  
1）浅复制与深复制概念  
⑴浅复制（浅克隆）  
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。  
  
⑵深复制（深克隆）  
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。  
  
2）Java的clone（）方法  
⑴clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：  
①对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象  
②对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样  
③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。  
  
⑵Java中对象的克隆  
①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。  
②在派生类中覆盖基类的clone()方法，并声明为public。  
③在派生类的clone()方法中，调用super.clone()。  
④在派生类中实现Cloneable接口。  
  
请看如下代码：  
  
class Student implements Cloneable\{   
    String name;  
    int age;  
    Student(String name,int age)\{   
        this.name=name;  
        this.age=age;  
    \}  
    public Object clone()\{   
        Object obj=null;  
        try\{   
         obj=(Student)super.clone();  
              //Object中的clone()识别出你要复制的是哪一个对象。  
        \}  
        catch(CloneNotSupportedException e)\{   
            e.printStackTrace();  
        \}  
        return obj;  
    \}  
\}  
  
public static void main(String\[\] args)\{   
      Student s1=new Student("zhangsan",18);  
      Student s2=(Student)s1.clone();  
      s2.name="lisi";  
      s2.age=20;  
      System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2  
                                                  //后，不影响学生1的值。  
   \}  
  
说明：  
①为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。  
②继承自java.lang.Object类的clone()方法是浅复制。以下代码可以证明之。  
  
class Teacher\{   
    String name;  
    int age;  
    Teacher(String name,int age)\{   
        this.name=name;  
        this.age=age;  
    \}  
\}  
class Student implements Cloneable\{   
    String name;  
    int age;  
    Teacher t;//学生1和学生2的引用值都是一样的。  
    Student(String name,int age,Teacher t)\{   
        this.name=name;  
        this.age=age;  
        this.t=t;  
    \}  
    public Object clone()\{   
        Student stu=null;  
        try\{   
            stu=(Student)super.clone();  
        \}catch(CloneNotSupportedException e)\{   
            e.printStackTrace();  
        \}  
        stu.t=(Teacher)t.clone();  
        return stu;  
    \}  
    public static void main(String\[\] args)\{   
        Teacher t=new Teacher("tangliang",30);  
        Student s1=new Student("zhangsan",18,t);  
        Student s2=(Student)s1.clone();  
        s2.t.name="tony";  
        s2.t.age=40;  
        System.out.println("name="+s1.t.name+","+"age="+s1.t.age);  
          //学生1的老师成为tony,age为40。  
    \}  
\}  
    
那应该如何实现深层次的克隆，即修改s2的老师不会影响s1的老师？代码改进如下。  
class Teacher implements Cloneable\{   
    String name;  
    int age;  
    Teacher(String name,int age)\{   
        this.name=name;  
        this.age=age;  
    \}  
    public Object clone()\{   
        Object obj=null;  
        try\{   
            obj=super.clone();  
        \}catch(CloneNotSupportedException e)\{   
            e.printStackTrace();  
        \}  
        return obj;  
    \}  
\}  
class Student implements Cloneable\{   
    String name;  
    int age;  
    Teacher t;  
    Student(String name,int age,Teacher t)\{   
        this.name=name;  
        this.age=age;  
        this.t=t;  
    \}  
    public Object clone()\{   
        Student stu=null;  
        try\{   
           stu=(Student)super.clone();  
        \}catch(CloneNotSupportedException e)\{   
            e.printStackTrace();  
        \}  
        stu.t=(Teacher)t.clone();  
        return stu;  
    \}  
\}  
public static void main(String\[\] args)\{   
      Teacher t=new Teacher("tangliang",30);  
      Student s1=new Student("zhangsan",18,t);  
      Student s2=(Student)s1.clone();  
      s2.t.name="tony";  
      s2.t.age=40;  
      System.out.println("name="+s1.t.name+","+"age="+s1.t.age);  
                 //学生1的老师不改变。  
\}  
  
3）利用串行化来做深复制  
    把对象写到流里的过程是串行化（Serilization）过程，Java程序员又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做“解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。  
    在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。

如下为深复制源代码。  
public Object deepClone()\{   
//将对象写到流里  
ByteArrayOutoutStream bo=new ByteArrayOutputStream();  
ObjectOutputStream oo=new ObjectOutputStream(bo);  
oo.writeObject(this);  
//从流里读出来  
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());  
ObjectInputStream oi=new ObjectInputStream(bi);  
return(oi.readObject());  
\}  
  
这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。上例代码改进如下。  
  
class Teacher implements Serializable\{   
    String name;  
    int age;  
    Teacher(String name,int age)\{   
        this.name=name;  
        this.age=age;  
    \}  
\}  
class Student implements Serializable  
\{   
    String name;//常量对象。  
    int age;  
    Teacher t;//学生1和学生2的引用值都是一样的。  
    Student(String name,int age,Teacher t)\{   
        this.name=name;  
        this.age=age;  
        this.p=p;  
    \}  
    public Object deepClone() throws IOException,  
OptionalDataException,ClassNotFoundException  
\{   
//将对象写到流里  
ByteArrayOutoutStream bo=new ByteArrayOutputStream();  
ObjectOutputStream oo=new ObjectOutputStream(bo);  
oo.writeObject(this);  
//从流里读出来  
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());  
ObjectInputStream oi=new ObjectInputStream(bi);  
return(oi.readObject());  
\}  
  
\}  
public static void main(String\[\] args)\{   
      Teacher t=new Teacher("tangliang",30);  
      Student s1=new Student("zhangsan",18,t);  
      Student s2=(Student)s1.deepClone();  
      s2.t.name="tony";  
      s2.t.age=40;  
      System.out.println("name="+s1.t.name+","+"age="+s1.t.age);  
       //学生1的老师不改变。  
\}  
5，String类和对象池

我们知道得到String对象有两种办法： String str1="hello"; String str2=new String("hello"); 这两种创建String对象的方法有什么差异吗？当然有差异，差异就在于第一种方法在对象池中拿对象，第二种方法直接生成新的对象。在JDK5.0里面，Java虚拟机在启动的时候会实例化9个对象池，这9个对象池分别用来存储8种基本类型的包装类对象和String对象。当我们在程序中直接用双引号括起来一个字符串时，JVM就到String的对象池里面去找看是否有一个值相同的对象，如果有，就拿现成的对象，如果没有就在对象池里面创建一个对象，并返回。所以我们发现下面的代码输出true：

String str1="hello";

String str2="hello";

System.out.println(str1==str2);

这说明str1和str2指向同一个对象，因为它们都是在对象池中拿到的，而下面的代码输出为false: String str3="hello" ;

String str4=new String("hello");

System.out.println(str3==str4);

因为在任何情况下，只要你去new一个String对象那都是创建了新的对象。与此类似的，在JDK5.0里面8种基本类型的包装类也有这样的差异(

补充：

Java语言在实现Integer的对象池的时候规定只有小于127的Integer对象才可以从对象池中拿，如果大于127的值，不管用什么方式都将生成新对象

1。java在编译的时候 Integer a = 100; 被翻译成-> Integer a = Integer.valueOf(100);  
2。比较的时候仍然是对象的比较  
3。在jdk源码中  
。。。  
public static Integer valueOf(int i) \{   
final int offset = 128;   
if (i >= -128 && i <= 127) \{ // must cache   
return IntegerCache.cache\[i + offset\];   
\}   
return new Integer(i);   
\}   
。。。  
而  
。。。  
private static class IntegerCache \{   
private IntegerCache()\{\}   
static final Integer cache\[\] = new Integer\[-(-128) + 127 + 1\];   
static \{   
for(int i = 0; i < cache.length; i++)   
cache = new Integer(i - 128);   
\}   
\}   
。。。  
这边是java为了提高效率，初始化了-128--127之间的整数对象  
所以在赋值在这个范围内都是同一个对象。  
再加一句  
Integer a = 100;  
a++;  
//这边a++是新创建了一个对象，不是以前的对象。  
    public static void main(String \[\]args) \{  
        Integer a = 100;  
        Integer b = a;  
        a++;  
        System.out.println(a==b);  
    \}  
打印就是false  
对于127--128没有多大关系，但是在这范围之外就影响性能了吧，就像StringBuffer VS String一样了

)：

Integer i1=5;//在对象池中拿

Integer i2 =5;//所以i1==i2

Integer i3=new Integer(5);//重新创建新对象，所以i2!=i3 对象池的存在是为了避免频繁的创建和销毁对象而影响系统性能，那我们自己写的类是否也可以使用对象池呢？当然可以，考察以下代码：

class Student\{

private String name;

private int age;

private static HashSet pool=new HashSet();//对象池

public Student(String name,int age)\{

this.name=name; this.age=age; \} //使用对象池来得到对象的方法

public static Student newInstance(String name,int age)\{

//循环遍历对象池

for(Student stu:pool)\{

if(stu.name.equals(name) && stu.age==age)\{

return stu; \}

\} //如果找不到值相同的Student对象，则创建一个Student对象

//并把它加到对象池中然后返回该对象。

Student stu=new Student(name,age);

pool.add(stu);

return stu; \}

public class Test\{

public static void main(String\[\] args)\{

Student stu1=Student.newInstance("tangliang",30);//对象池中拿

Student stu2=Student.newInstance("tangliang",30);//所以stu1==stu2

Student stu3=new Student("tangliang",30);//重新创建，所以stu1!=stu3

System.out.println(stu1==stu2); System.out.println(stu1==stu3); \} \}

6，2.0-1.1==0.9吗?

考察下面的代码：

double a=2.0，b=1.1，c=0.9；

if(a-b==c)\{

System.out.println("YES!"); \}

else\{

System.out.println("NO!"); \}

以上代码输出的结果是多少呢？你认为是“YES！”吗？那么，很遗憾的告诉你，不对，Java语言再一次cheat了你，以上代码会输出“NO！”。为什么会这样呢？其实这是由实型数据的存储方式决定的。我们知道实型数据在内存空间中是近似存储的，所以2.0-1.1的结果不是0.9，而是0.88888888889。所以在做实型数据是否相等的判断时要非常的谨慎。一般来说，我们不建议在代码中直接判断两个实型数据是否相等，如果一定要比较是否相等的话我们也采用以下方式来判断：

if(Math.abs(a-b)<1e-5)

\{ //相等 \}

else\{ //不相等 \}

上面的代码判断a与b之差的绝对值是否小于一个足够小的数字，如果是，则认为a与b相等，否则，不相等。

7，判断奇数

以下的方法判断某个整数是否是奇数，考察是否正确：

public boolean isOdd(int n)\{

return (n%2==1); \}

很多人认为上面的代码没问题，但实际上这段代码隐藏着一个非常大的BUG，当n的值是正整数时，以上的代码能够得到正确结果，但当n的值是负整数时，以上方法不能做出正确判断。例如，当n=-3时，以上方法返回false。因为根据Java语言规范的定义，Java语言里的求余运算符（%）得到的结果与运算符左边的值符号相同，所以，-3%2的结果是-1，而不是1。那么上面的方法正确的写法应该是： public boolean isOdd(int n)\{ return (n%2!=0); \}

8,拓宽数值类型会造成精度丢失吗？

Java语言的8种基本数据类型中7种都可以看作是数值类型，我们知道对于数值类型的转换有一个规律：从窄范围转化成宽范围能够自动类型转换，反之则必须强制转换。请看下图： byte-->short-->int-->long-->float-->double       char-->int 我们把顺箭头方向的转化叫做拓宽类型，逆箭头方向的转化叫做窄化类型。一般我们认为因为顺箭头方向的转化不会有数据和精度的丢失，所以Java语言允许自动转化，而逆箭头方向的转化可能会造成数据和精度的丢失，所以Java语言要求程序员在程序中明确这种转化，也就是强制转换。那么拓宽类型就一定不会造成数据和精度丢失吗？请看下面代码：

int i=2000000000;   
int num=0;   
for(float f=i;f<i+50;f++)\{   
    num++;   
\}   
System.out.println(num);   
请考察以上代码输出多少？   
如果你回答50 ，那么请运行一下，结果会让你大吃一惊！没错，输出结果是0，难道这个循环根本就没有执行哪怕一次？确实如此，如果你还不死心，我带你看一个更诧异的现象，运行以下代码，看输出什么？   
int i=2000000000;   
float f1=i;   
float f2=i+50;   
System.out.println(f1==f2);   
    哈哈，你快要不相信你的眼睛了，结果竟然是true;难道f1和f2是相等的吗？是的，就是这样，这也就能解释为什么上一段代码输出的结果是0，而不是50了。那为什么会这样呢？关键原因在于你将int值自动提升为float时发生了数据精度的丢失，i的初始值是2000000000，这个值非常接近Integer.MAX\_VALUE，因此需要用31位来精确表示，而float只能提供24位数据的精度（另外8位是存储位权，见IEEE745浮点数存储规则）。所以在这种自动转化的过程中，系统会将31位数据的前24位保留下来，而舍弃掉最右边的7位，所以不管是2000000000还是2000000050，舍弃掉最右边7位后得到的值是一样的。这就是为什么f1==f2的原因了。   
    类似的这种数值拓宽类型的过程中会造成精度丢失的还有两种情况，那就是long转化成float和long转化成double，所以在使用的时候一定要小心。

9，i=i+1和i+=1完全等价吗？

可能有很多程序员认为i+=1只是i=i+1的简写方式，其实不然，它们一个使用简单赋值运算，一个使用复合赋值运算，而简单赋值运算和复合赋值运算的最大差别就在于：复合赋值运算符会自动地将运算结果转型为其左操作数的类型。看看以下的两种写法，你就知道它们的差别在哪儿了：  
  (1) byte i=5;  
      i+=1;  
  (2) byte i=5;  
      i=i+1;  
    第一种写法编译没问题，而第二种写法却编译通不过。原因就在于，当使用复合赋值运算符进行操作时，即使右边算出的结果是int类型，系统也会将其值转化为左边的byte类型，而使用简单赋值运算时没有这样的优待，系统会认为将i+1的值赋给i是将int类型赋给byte，所以要求强制转换。理解了这一点后，我们再来看一个例子：  
  byte b=120;  
  b+=20;  
  System.out.println("b="+b);  
  说到这里你应该明白了，上例中输出b的值不是140，而是-116。因为120+20的值已经超出了一个byte表示的范围，而当我们使用复合赋值运算时系统会自动作类型的转化，将140强转成byte，所以得到是-116。由此可见，在使用复合赋值运算符时还得小心，因为这种类型转换是在不知不觉中进行的，所以得到的结果就有可能和你的预想不一样。