java细节(一)

1，位移运算越界怎么处理 y
   考察下面的代码输出结果是多少? HX
   int a=5; "isO<
   System.out.println(a<<33); &FA{1g
按 照常理推测,把a左移33位应该将a的所有有效位都移出去了，那剩下的都是零啊，所以输出结果应该是0才对啊，可是执行后发现输出结果是10，为什么呢？ 因为Java语言对位移运算作了优化处理，Java语言对a<<b转化为a<<(b%32)来处理，所以当要移位的位数b超过 32时，实际上移位的位数是b%32的值，那么上面的代码中a<<33相当于a<<1，所以输出结果是10。 cs!AG
©http://www.java125.cn为java提供源动力　　tp%
2，可以让i!=i吗？ :C(pKj
当你看到这个命题的时候一定会以为我疯了，或者Java语言疯了。这看起来是绝对不可能的，一个数怎么可能不等于它自己呢？或许就真的是Java语言疯了，不信看下面的代码输出什么？ 7Tdc
 double i=0.0/0.0; Dm
 if(i==i){ d"
     System.out.println("Yes i==i"); 8&%
 }else{ o/l!S+
     System.out.println("No i!=i"); *aK9
 } u
上 面的代码输出"No i!=i"，为什么会这样呢？关键在0.0/0.0这个值，在IEEE 754浮点算术规则里保留了一个特殊的值用来表示一个不是数字的数量。这个值就是NaN("Not a Number"的缩写)，对于所有没有良好定义的浮点计算都将得到这个值，比如：0.0/0.0；其实我们还可以直接使用Double.NaN来得到这个 值。在IEEE 754规范里面规定NaN不等于任何值，包括它自己。所以就有了i！=i的代码。 -/!yJB
©http://www.java125.cn为java提供源动力　　t
3，怎样的equals才安全？ DI|
   我们都知道在Java规范里定义了equals方法覆盖的5大原则：reflexive（反身性），symmetric（对称性），transitive（传递性），consistent（一致性），non-null（非空性）。那么考察下面的代码： 3%aP
public class Student{ D$#6
   private String name; n(
   private int age; l7
   public Student(String name,int age){ (y+n
       this.name=name; t
       this.age=age; /
   } v]*7
   public boolean equals(Object obj){ N
       if(obj instanceof Student){ o/G4
           Student s=(Student)obj; b:G0QZ
           if(s.name.equals(this.name) && s.age==this.age){ 0o6E
               return true; ]Jstr
           } >2[a
       } #
       return super.equals(obj); S.
   } Vlj~
} ©http://www.java125.cn为java提供源动力　　0^w+`M
你 认为上面的代码equals方法的覆盖安全吗？表面看起来好像没什么问题，这样写也确实满足了以上的五大原则。但其实这样的覆盖并不很安全，假如 Student类还有一个子类CollegeStudent,如果我拿一个Student对象和一个CollegeStudent对象equals,只要 这两个对象有相同的name和age，它们就会被认为相等，但实际上它们是两个不同类型的对象啊。问题就出在instanceof这个运算符上，因为这个 运算符是向下兼容的，也就是说一个CollegeStudent对象也被认为是一个Student的实例。怎样去解决这个问题呢？那就只有不用 instanceof运算符，而使用对象的getClass()方法来判断两个对象是否属于同一种类型，例如，将上面的equals()方法修改为： }$
  public boolean equals(Object obj){ @c
       if(obj.getClass()==Student.class){ 2
           Student s=(Student)obj; N-fUs=
           if(s.name.equals(this.name) && s.age==this.age){ n
               return true; +f
           } cTCg
       } 7PJIE.
       return super.equals(obj); 7|
   } l.(
 这样才能保证obj对象一定是Student的实例，而不会是Student的任何子类的实例。 F$
©http://www.java125.cn为java提供源动力　　/
4，浅复制与深复制 Xy
1）浅复制与深复制概念 $umh
⑴浅复制（浅克隆） 2O`BP[
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 ^$:6D
©http://www.java125.cn为java提供源动力　　z<2
⑵深复制（深克隆） )l
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。 ^UuB
©http://www.java125.cn为java提供源动力　　0IWqw]
2）Java的clone（）方法 H_xE
⑴clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足： .
①对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象 @l
②对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样 {*{XIE
③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。 ]S.
©http://www.java125.cn为java提供源动力　　
⑵Java中对象的克隆 EW
①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。 JbT@p
②在派生类中覆盖基类的clone()方法，并声明为public。 )5
③在派生类的clone()方法中，调用super.clone()。 qr9l3p
④在派生类中实现Cloneable接口。 'K;
©http://www.java125.cn为java提供源动力　　9
请看如下代码： gM
©http://www.java125.cn为java提供源动力　　N5i
class Student implements Cloneable{ H,/1%
   String name; as
   int age; 2Ng-}
©http://www.java125.cn为java提供源动力　　>
   Student(String name,int age){ YGslNQ
       this.name=name; C/
       this.age=age; },:
   } KPbna
©http://www.java125.cn为java提供源动力　　r08w|
   public Object clone(){ I&5Kak
       Object obj=null; 81wJ;
       try{ M
        obj=(Student)super.clone(); c
             //Object中的clone()识别出你要复制的是哪一个对象。 (S
       } 'Z]VV
       catch(CloneNotSupportedException e){ 8c
           e.printStackTrace(); ){27
       } 2eqM?2
       return obj; !q_
   } $;
} ©http://www.java125.cn为java提供源动力　　 j
©http://www.java125.cn为java提供源动力　　~[V7xR
public static void main(String[] args){ q?r~&%
     Student s1=new Student("zhangsan",18); :
     Student s2=(Student)s1.clone(); m
     s2.name="lisi"; Ta
     s2.age=20; `/
     System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2 9R]s
                                                 //后，不影响学生1的值。 $I
  } `
©http://www.java125.cn为java提供源动力　　FE
说明： kBl
① 为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？在运行时刻，Object中的clone()识 别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。 W/
②继承自java.lang.Object类的clone()方法是浅复制。以下代码可以证明之。 ;s/-
©http://www.java125.cn为java提供源动力　　5|@?
class Teacher{ XMu7Fd
   String name; )Fl_
   int age; >a7
   Teacher(String name,int age){ SIySp
       this.name=name; qV6F
       this.age=age; `
   } wO+
} ©http://www.java125.cn为java提供源动力　　[h
class Student implements Cloneable{ +WH
   String name; 8OPH
   int age; |([H8
   Teacher t;//学生1和学生2的引用值都是一样的。 z
   Student(String name,int age,Teacher t){ Z8$kw
       this.name=name; Y#B8
       this.age=age; d
       this.t=t; V9V<AT
   } z
   public Object clone(){ wU92m
       Student stu=null; KHuc|
       try{ SnF
           stu=(Student)super.clone(); z
       }catch(CloneNotSupportedException e){ fY
           e.printStackTrace(); l`
       } j
       stu.t=(Teacher)t.clone(); s`Ine)
       return stu; _e
   } <qr
   public static void main(String[] args){ F%7#d
       Teacher t=new Teacher("tangliang",30); 4UYP
       Student s1=new Student("zhangsan",18,t); (s
       Student s2=(Student)s1.clone(); 7|y?K
       s2.t.name="tony"; )-
       s2.t.age=40; +
       System.out.println("name="+s1.t.name+","+"age="+s1.t.age); H^rE,}
         //学生1的老师成为tony,age为40。 C9."
   } 8DE<
} ©http://www.java125.cn为java提供源动力　　F
  8kC+Z
那应该如何实现深层次的克隆，即修改s2的老师不会影响s1的老师？代码改进如下。 A6lO
class Teacher implements Cloneable{ PkFRU
   String name; Ty,/+X
   int age; e
   Teacher(String name,int age){ Ybet
       this.name=name; 9hiT
       this.age=age; Vg
   } ^
   public Object clone(){ -6
       Object obj=null; :P|mmz
       try{ {ubX
           obj=super.clone(); v
       }catch(CloneNotSupportedException e){ 5b
           e.printStackTrace(); ``b
       } Hu
       return obj; Oo)
   } G)q8>s
} ©http://www.java125.cn为java提供源动力　　Rnw:"
©http://www.java125.cn为java提供源动力　　@B(I]
class Student implements Cloneable{ ^}
   String name; Fe
   int age; 63B}D?
   Teacher t; s0A,q
   Student(String name,int age,Teacher t){ s,qo44
       this.name=name; a7!~}9
       this.age=age; bIoVWM
       this.t=t; P1`mN
   } 4FfICV
   public Object clone(){ p/
       Student stu=null; ^]g
       try{ `8`W
          stu=(Student)super.clone(); p-y-2-
       }catch(CloneNotSupportedException e){ M;
           e.printStackTrace(); T
       } WudAPC
       stu.t=(Teacher)t.clone(); wRhDG
       return stu; 4|3E
   } f"
} ©http://www.java125.cn为java提供源动力　　)-5Z
public static void main(String[] args){ 2#
     Teacher t=new Teacher("tangliang",30); qg
     Student s1=new Student("zhangsan",18,t); 8MI{bR
     Student s2=(Student)s1.clone(); gF(@
     s2.t.name="tony"; MRk
     s2.t.age=40; &/F
     System.out.println("name="+s1.t.name+","+"age="+s1.t.age); poK0hu
                //学生1的老师不改变。 "}F35`
} ©http://www.java125.cn为java提供源动力　　M
©http://www.java125.cn为java提供源动力　　OZHqRL
3）利用串行化来做深复制 UOuJ+
   把对象写到流里的过程是串行化（Serilization）过程，Java程序员又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把 对象从流中读出来的并行化（Deserialization）过程则叫做“解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对 象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。 jr`CMB
   在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。 ]6/
如下为深复制源代码。 17
public Object deepClone(){ C{R
//将对象写到流里 n]
ByteArrayOutoutStream bo=new ByteArrayOutputStream(); 'Q<{T
ObjectOutputStream oo=new ObjectOutputStream(bo); f//P!
oo.writeObject(this); &p#r
//从流里读出来 3 AO
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray()); NL>v
ObjectInputStream oi=new ObjectInputStream(bi); s8$ I!
return(oi.readObject()); i_p>P
} ©http://www.java125.cn为java提供源动力　　OInxm
©http://www.java125.cn为java提供源动力　　k
这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。上例代码改进如下。 ,F3
©http://www.java125.cn为java提供源动力　　Evi
class Teacher implements Serializable{ 4(n(_
   String name; Yy$T]b
   int age; t7H
   Teacher(String name,int age){ V/Gq
       this.name=name; f}Xl
       this.age=age; F.
   } %3p}u
} ©http://www.java125.cn为java提供源动力　　b'
class Student implements Serializable uCF<
{ ©http://www.java125.cn为java提供源动力　　6A
   String name;//常量对象。 hfC@
   int age; oa.&
   Teacher t;//学生1和学生2的引用值都是一样的。 uz/Q%Q
   Student(String name,int age,Teacher t){ AHn4
       this.name=name; SNS
       this.age=age; ggGm
       this.p=p; 3aE%Qx
   } pK
   public Object deepClone() throws IOException, 7~S:
OptionalDataException,ClassNotFoundException 8
{ ©http://www.java125.cn为java提供源动力　　,:#
//将对象写到流里 wT
ByteArrayOutoutStream bo=new ByteArrayOutputStream(); Xgl`
ObjectOutputStream oo=new ObjectOutputStream(bo); np)
oo.writeObject(this); 8/D*a
//从流里读出来 6
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray()); L1
ObjectInputStream oi=new ObjectInputStream(bi); S
return(oi.readObject()); vPVU
} ©http://www.java125.cn为java提供源动力　　KH
©http://www.java125.cn为java提供源动力　　/
} ©http://www.java125.cn为java提供源动力　　?9RF
public static void main(String[] args){ g%=pO
     Teacher t=new Teacher("tangliang",30); lgDE5g
     Student s1=new Student("zhangsan",18,t); =2b=
     Student s2=(Student)s1.deepClone(); 16V.vs
     s2.t.name="tony"; XNV{
     s2.t.age=40; x>#O'
     System.out.println("name="+s1.t.name+","+"age="+s1.t.age); ^I=N[
      //学生1的老师不改变。 5，String类和对象池 ?y
   我们知道得到String对象有两种办法： m
   String str1="hello"; j6R#/
   String str2=new String("hello"); i
   这两种创建String对象的方法有什么差异吗？当然有差异，差异就在于第一种方法在对象池中拿对象，第二种方法直接生成新的对象。在JDK5.0里 面，Java虚拟机在启动的时候会实例化9个对象池，这9个对象池分别用来存储8种基本类型的包装类对象和String对象。当我们在程序中直接用双引号 括起来一个字符串时，JVM就到String的对象池里面去找看是否有一个值相同的对象，如果有，就拿现成的对象，如果没有就在对象池里面创建一个对象， 并返回。所以我们发现下面的代码输出true： _}Ji;b
 String str1="hello"; ($Yl
 String str2="hello"; lOi.
 System.out.println(str1==str2); yXv%3x
这说明str1和str2指向同一个对象，因为它们都是在对象池中拿到的，而下面的代码输出为false: @cnJG9
 String str3="hello" [
 String str4=new String("hello"); n
 System.out.println(str3==str4); z=!
因为在任何情况下，只要你去new一个String对象那都是创建了新的对象。 |+E
与此类似的，在JDK5.0里面8种基本类型的包装类也有这样的差异： -!If
 Integer i1=5;//在对象池中拿 />O$
 Integer i2 =5;//所以i1==i2 V$$
 Integer i3=new Integer(5);//重新创建新对象，所以i2!=i3 O+~;V
©http://www.java125.cn为java提供源动力　　%vaH<u
对象池的存在是为了避免频繁的创建和销毁对象而影响系统性能，那我们自己写的类是否也可以使用对象池呢？当然可以，考察以下代码： 'MM
 class Student{ &Jdwvq
    private String name; r} W
    private int age; J
    private static HashSet<Student> pool=new HashSet<Student>();//对象池 J#A,
    Kr
    public Student(String name,int age){ WZK`e
       this.name=name; "gv6l~
       this.age=age; *&q;
    } ?6D=
©http://www.java125.cn为java提供源动力　　MU
    //使用对象池来得到对象的方法 gIXj
    public static Student newInstance(String name,int age){ .STz)
         //循环遍历对象池 ?
         for(Student stu:pool){ X5~_J
             if(stu.name.equals(name) && stu.age==age){ Vg4'F)
                   return stu; @q
             } @M
         } l`Mn
         //如果找不到值相同的Student对象，则创建一个Student对象 "
         //并把它加到对象池中然后返回该对象。 B[
         Student stu=new Student(name,age); WReN:
         pool.add(stu); k/L;<1
         return stu; '+~
    } ~8M
} ©http://www.java125.cn为java提供源动力　　,<gD
©http://www.java125.cn为java提供源动力　　m
public class Test{ j
 public static void main(String[] args){ r/y
     Student stu1=Student.newInstance("tangliang",30);//对象池中拿 Ty^ZT
     Student stu2=Student.newInstance("tangliang",30);//所以stu1==stu2 [m_
     Student stu3=new Student("tangliang",30);//重新创建，所以stu1!=stu3 A
     System.out.println(stu1==stu2); 0>>
     System.out.println(stu1==stu3); p50<
  } A,2>p
}

6，2.0-1.1==0.9吗?ylM
考察下面的代码：;`e
double a=2.0，b=1.1，c=0.9；+
if(a-b==c){#5E$
  System.out.println("YES!");o
}else{}fK
  System.out.println("NO!");C`Y
}©http://www.java125.cn为java提供源动力　　kz
以 上代码输出的结果是多少呢？你认为是“YES！”吗？那么，很遗憾的告诉你，不对，Java语言再一次cheat了你，以上代码会输出“NO！”。为什么 会这样呢？其实这是由实型数据的存储方式决定的。我们知道实型数据在内存空间中是近似存储的，所以2.0-1.1的结果不是0.9，而是 0.88888888889。所以在做实型数据是否相等的判断时要非常的谨慎。一般来说，我们不建议在代码中直接判断两个实型数据是否相等，如果一定要比 较是否相等的话我们也采用以下方式来判断：#ZW#l
 if(Math.abs(a-b)<1e-5){=Yq-;$
    //相等uF
 }else{"_
   //不相等W]#w
 }'
上面的代码判断a与b之差的绝对值是否小于一个足够小的数字，如果是，则认为a与b相等，否则，不相等。RR
©http://www.java125.cn为java提供源动力　　9UW/
©http://www.java125.cn为java提供源动力　　~
7，判断奇数uLJ _
 以下的方法判断某个整数是否是奇数，考察是否正确：%3!_
  public boolean isOdd(int n){q=
      return (n%2==1);s3TS
  }EI[7rr
  很多人认为上面的代码没问题，但实际上这段代码隐藏着一个非常大的BUG，当n的值是正整数时，以上的代码能够得到正确结果，但当n的值是负整数时，以上 方法不能做出正确判断。例如，当n=-3时，以上方法返回false。因为根据Java语言规范的定义，Java语言里的求余运算符（%）得到的结果与运 算符左边的值符号相同，所以，-3%2的结果是-1，而不是1。那么上面的方法正确的写法应该是：0[eTeU
  public boolean isOdd(int n){O!GM
      return (n%2!=0);IZgWr^
  }

 8,拓宽数值类型会造成精度丢失吗？ CGzA
   Java语言的8种基本数据类型中7种都可以看作是数值类型，我们知道对于数值类型的转换有一个规律：从窄范围转化成宽范围能够自动类型转换，反之则必须强制转换。请看下图： K{ C^
byte-->short-->int-->long-->float-->double )dIF
char-->int U
我 们把顺箭头方向的转化叫做拓宽类型，逆箭头方向的转化叫做窄化类型。一般我们认为因为顺箭头方向的转化不会有数据和精度的丢失，所以Java语言允许自动 转化，而逆箭头方向的转化可能会造成数据和精度的丢失，所以Java语言要求程序员在程序中明确这种转化，也就是强制转换。那么拓宽类型就一定不会造成数 据和精度丢失吗？请看下面代码： c|
int i=2000000000; 0:
int num=0; x1s9
for(float f=i;f<i+50;f++){ JH0^.
   num++; U
} ©http://www.java125.cn为java提供动力　　(9qF
System.out.println(num); H@%
请考察以上代码输出多少？ Q
如果你回答50 ，那么请运行一下，结果会让你大吃一惊！没错，输出结果是0，难道这个循环根本就没有执行哪怕一次？确实如此，如果你还不死心，我带你你看一个更诧异的现象，运行以下代码，看输出什么？ _
int i=2000000000; +.|#"
float f1=i; 6W2F~
float f2=i+50; _
System.out.println(f1==f2); p
   哈哈，你快要不相信你的眼睛了，结果竟然是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，所以在使用的时候一定要小心。