注册 登录
> Java

java解惑你知多少（七）

系统 1278 0

应用

47. 不可变的引用类型

Java代码   收藏代码
  1. BigInteger total = BigInteger.ZERO;  
  2. total.add( new  BigInteger( "1" ));  
  3. total.add( new  BigInteger( "10" ));  
  4. System.out.println(total); //0   

上面程序的结果为11吗？答案是0。

 

BigInteger实例是不可变的。String、BigDecimal以及包装类型：Integer、Long、Short、Byte、Character、Boolean、Float和Double也是如此。对这些类型的操作将返回新的实例。

 

不可变类型更容易设计、实现与作用；它们出错的可能性更小，并且更加安全。

 

本程序修改如下：

Java代码   收藏代码
  1. BigInteger total = BigInteger.ZERO;  
  2. total=total.add( new  BigInteger( "1" ));  
  3. total=total.add( new  BigInteger( "10" ));  
  4. System.out.println(total); //11   

 

48. 请同时重写equals()与hashCode()

Java代码   收藏代码
  1. class  T {  
  2.   private  String str;  
  3.   
  4.  T(String str) {  
  5.    this .str = str;  
  6.  }  
  7.   
  8.   public   boolean  equals(Object obj) {  
  9.    if (!(obj  instanceof  T)){  
  10.     return   false ;  
  11.   }  
  12.   T t = (T)obj;  
  13.    return  t.equals( this .str);  
  14.  }  
  15.   
  16.   public   static   void  main(String[] args) {  
  17.   Set set =  new  HashSet();  
  18.   set.add( new  T( "str" ));  
  19.   System.out.println(set.contains( new  T( "str" ))); //false   
  20.  }  
  21. }  

上面的程序不会打印true，而是false，为什么？

 

hashCode约定要求相等的对象要具有相同的散列码。

 

无论何时，只要你重写了equals方法，你就必须同时重写hashCode方法。

 

如果将自定的类型对象放入HashSet、HashMap、Hashtable、LinkedHashSet、LinkedHashMap这此散列集合时，一定需要重写equals与hashCode方法，这样在放入进去之后还能查找出来。如果放入其他非散列类型的集合时，其实只需要

重写equals就可以了。

 

本程序解决办法重写hashCode()方法：

Java代码   收藏代码
  1. public   int  hashCode() {  
  2.   return   37  *  this .str.hashCode();  
  3. }  

 
49. 日期设置

Java代码   收藏代码
  1. Calendar c = Calendar.getInstance();  
  2. c.set( 2010 ,  12 ,  31 ); // 月是从0开始的，11其实表示12月   
  3. System.out.println(c.get(Calendar.YEAR) +  " "  + c.get(Calendar.MONTH));  
  4. c = Calendar.getInstance();  
  5. c.set( 2010 ,  11 ,  31 );  
  6. System.out.println(c.get(Calendar.YEAR) +  " "  + c.get(Calendar.MONTH));  

本程序较简单，只需注意月是从0开始的就可以了，如果你设置月为12，则会自动转换为下一年。


50. IdentityHashMap


 

Java代码   收藏代码
  1. class  T {  
  2.   private  String str;  
  3.   
  4.  T(String str) {  
  5.    this .str = str;  
  6.  }  
  7.   
  8.   public   int  hashCode() {  
  9.    return   37  *  this .str.hashCode();  
  10.  }  
  11.   
  12.   public   boolean  equals(Object obj) {  
  13.    return   this .str.equals(((T) obj).str);  
  14.  }  
  15.   
  16.   public   static   void  put(Map m) {  
  17.   m.put( "str" ,  "1" );  
  18.    /*  
  19.    * 由于上面程序将 "str" 放入了字符串常量池，  
  20.    * 所以str是同一个对象，不管是什么样类型的  
  21.    * Map，即使使用IdentityHashMap都只放入一次  
  22.    */   
  23.   m.put( "str" ,  "2" );  
  24.   m.put( new  T( "str" ),  "3" );  
  25.   m.put( new  T( "str" ),  "4" );  
  26.  }  
  27.   
  28.   public   static   void  main(String[] args) {  
  29.   Map m =  new  HashMap();  
  30.   put(m);  
  31.   System.out.println(m.size()); // 2   
  32.    //IdentityHashMap比较时使用==替换equals()方法   
  33.   m =  new  IdentityHashMap();  
  34.   put(m);  
  35.   System.out.println(m.size()); // 3   
  36.  }  
  37. }  

 

51. 静态导入的优先权

Java代码   收藏代码
  1. import   static  java.util.Arrays.toString;  
  2. import  java.util.Arrays;  
  3. public   class  T {  
  4.   public   static   void  main(String[] args) {  
  5.   prt( 1 ,  2 ,  3 );  
  6.  }  
  7.   static   void  prt(Object... args) {  
  8.    // 自身继承至Object类的toString的优先级高于静态导入的方法   
  9.    //!! System.out.println(toString(args));//不能编译   
  10.   System.out.println(Arrays.toString(args));  
  11.  }  
  12. }  

本身就属于某个范围的成员在该范围内与静态导入相比具有优先权。


52. PrintStream对输出结果的缓冲

Java代码   收藏代码
  1. public   static   void  main(String[] args) {  
  2.  String str =  "Hello World" ;  
  3.   for  ( int  i =  0 ; i < str.length(); i++) {  
  4.   System.out.write(str.charAt(i));  
  5.  }  
  6. }  

上面的程序没有输出结果。

 

这里的问题在于System.out是带有缓冲的。输出的结果被写入了System.out的缓冲区，但是缓冲区从来都没有被刷新。大多数人认为，当有输出产生的时候System.out和System.err会自动地进制刷新，但这并不完全正确，这两个流都属于PrintStream类型，请看API DOC描述：一个PrintStream被创建为自动刷新，这意味着当一个字节数组（byte[]）被写入、或者某个println方法被调用、或者一个换行字符或字节（'\n'）被写入之后，PrintStream类型的flush方法就会被自动调用。

 

令人奇怪的是，如果这个程序用print(char)去替代write(int)，它就会刷新System.out并输出结果，这种行为与print(char)的文档是矛盾的，因为其文档叙述道：“打印一个字符，这个字符将根据平台缺省的字符编码方式翻译成一个或多个字节，并且这些字节将完全按照write(int)方法的方式输出。”，但这里没有换行符却也自动的刷新了。

 

类似的，如果程序改用print(String)，它也会对流进行刷新。所以调用print方法也是会自动刷新的。

 

53. 调用操作系统命令时被阻塞问题

Java代码   收藏代码
  1. public   static   void  main(String[] args)  throws  IOException,  
  2.   InterruptedException {  
  3.  String command =  "java ProcessTest exc" ;  
  4.   if  (args.length !=  0 ) {  
  5.    for  ( int  i =  0 ; i <  200 ; i++) {  
  6.    System.out.println(command);  
  7.    System.err.println(command);  
  8.   }  
  9.  }  else  {  
  10.   Process process = Runtime.getRuntime().exec(command);    
  11.    int  exitValue = process.waitFor();  
  12.   System.out.println( "exit value = "  + exitValue);  
  13.  }  
  14. }  

执行java ProcessTest发现程序阻塞。

 

Process文档描述：由于某些本地平台只提供有限大小的缓冲，所以如果不能迅速地读取子进程的输出流，就有可能会导致子进程的阻塞，甚至是死锁。这恰好就是这里所发生的事情：没有足够的缓冲空间来保存这些输出结果。为了结子进程（Process线程），父进程（Main线程）必须排空它的输出流（标准流与错误流都需要排空），即要去缓存中读取结果：

Java代码   收藏代码
  1. static   void  readResult( final  InputStream is) {  
  2.   new  Thread( new  Runnable() {  
  3.    public   void  run() {  
  4.     try  {  
  5.      // 排空缓存内容   
  6.      while  (is.read() >=  0 );  
  7.    }  catch  (IOException e) {  
  8.     e.printStackTrace();  
  9.    }  
  10.   }  
  11.  }).start();  
  12. }  

 

然后在process.waitFor()之前加上

Java代码   收藏代码
  1. readResult(process.getErrorStream());  
  2. readResult(process.getInputStream());  

即可输出exit value = 0。

 

另外，只能根据process.waitFor返回的结果来判断操作系统命令执行是否成功（成功：0，失败：1），我们不能根据

错误流中是否有内容来判断是否执行成功。


54. 实现Serializable的单例问题

Java代码   收藏代码
  1. class  Dog  implements  Serializable{  
  2.   public   static   final  Dog INSTANCE =  new  Dog();  
  3.   private  Dog(){}  
  4. }  

 上面能控制只生成一个单实例吗？

 

如果对实现了Serializable的对象进行序列化后，再反序列化，内中会不只一个实例了，因为反序列化时会重新生成一个对象。

 

既然INSTANCE为静态域，那序列化时返回的对象如果也是INSTANCE就可以解决问题了，而打开API我们发现Serializable接口确实有这样两个特殊的方法描述：
 将对象写入流时需要指定要使用的替代对象的可序列化类，应使用准确的签名来实现此特殊方法：
ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
此 writeReplace 方法将由序列化调用，前提是如果此方法存在，而且它可以通过被序列化对象的类中定义的一个方法访问。因此，该方法可以拥有私有 (private)、受保护的 (protected) 和包私有 (package-private) 访问。子类对此方法的访问遵循 java 访问规则。 
 在从流中读取类的一个实例时需要指定替代的类应使用的准确签名来实现此特殊方法：
ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;
此 readResolve 方法遵循与 writeReplace 相同的调用规则和访问规则。

 

上述两个方法的只要出现，就会履盖以下两个方法（这两个方法本质的意义就是用来替换序列与反序列的对象），虽然会执行它们，但最后得到的结果却是writeReplace、readResolve两个方法写入或读出的对象：
 private void writeObject(java.io.ObjectOutputStream out) throws IOException
 private void readObject(java.io.ObjectInputStream in)throws IOException, ClassNotFoundException;

 

另外，writeObject与readObject需成对实现，而writeReplace与readResolve则不需要成对出现，一般单独使用。如果同时出现这四个方法，最后写入与读出的结果以writeReplace和readResolve方法的结果为准。

 

所以下要解决真真单实例问题，我们如下修正：

Java代码   收藏代码
  1. class  Dog  implements  Serializable {  
  2.   public   static   final  Dog INSTANCE =  new  Dog();  
  3.   private  Dog() {}  
  4.   private  Object readResolve() {  
  5.    return  INSTANCE;  
  6.  }  
  7. }  
  8.   
  9. public   class  SerialDog {  
  10.   public   static   void  main(String[] args)  throws  IOException,  
  11.    ClassNotFoundException {  
  12.   ByteArrayOutputStream bos =  new  ByteArrayOutputStream();  
  13.    new  ObjectOutputStream(bos).writeObject(Dog.INSTANCE);  
  14.   ByteArrayInputStream bin =  new  ByteArrayInputStream(bos.toByteArray());  
  15.   Dog dog = (Dog)  new  ObjectInputStream(bin).readObject();  
  16.   System.out.println(dog == Dog.INSTANCE); //true   
  17.  }  
  18. }  

一个实现了Serializable的单例类，必须有一个readResolve方法，用以返回它的唯一实例。


55. thread. isInterrupted()与Thread.interrupted()

Java代码   收藏代码
  1. public   class  SelfInerruption {  
  2.   public   static   void  main(String[] args) {  
  3.   Thread.currentThread().interrupt();  
  4.    if  (Thread.interrupted()) {  
  5.     // Interruped:false   
  6.    System.out.println( "Interruped:"  + Thread.interrupted());  
  7.   }  else  {  
  8.    System.out.println( "Not interruped:"  + Thread.interrupted());  
  9.   }  
  10.  }  
  11. }  

上面结果走的是第一个分支，但结果却不是Interruped:true？

 

Thread.interrupted()为Thread的静态方法，调用它首先会返回当前线程的中断状态（如果当前线程上调用了interrupt()方法，则返回true，否则为false），然后再清除当前线程的中断状态，即将中断状态设置为false。换句话说，如果连续两次调用该方法，则第二次调用将返回 false。

 

而isInterrupted()方法为实例方法，测试线程是否已经中断，并不会清除当前线程中断状态。

 

所以这里应该使用isInterrupted()实例方法，就可以修复该问题。

 

java解惑你知多少（七）


更多文章、技术交流、商务合作、联系博主

微信扫码或搜索：z360901061

微信扫一扫加我为好友

QQ号联系： 360901061

您的支持是博主写作最大的动力，如果您喜欢我的文章，感觉我的文章对您有帮助，请用微信扫描下面二维码支持博主2元、5元、10元、20元等您想捐的金额吧，狠狠点击下面给点支持吧，站长非常感激您！手机微信长按不能支付解决办法：请将微信支付二维码保存到相册，切换到微信，然后点击微信右上角扫一扫功能，选择支付二维码完成支付。

【本文对您有帮助就好】元

您的支持是博主写作最大的动力，如果您喜欢我的文章，感觉我的文章对您有帮助，请用微信扫描上面二维码支持博主2元、5元、10元、自定义金额等您想捐的金额吧，站长会非常 感谢您的哦！！！

发表我的评论
最新评论 总共0条评论