Java复制粘贴变成乱码 java复制的代码运行错误

五、常见错误5#：拷贝错误的数据

有时候程序员知道必须返回一个拷贝，但是却不小心拷贝了错误的数据。由于仅仅做了部分的数据拷贝工作，下面的代码与程序员的意图有偏差：

 

1. import
2. /*** Example class. The height and width values should never * be 
3. negative. */
4. public class
5. static final public int TOTAL_VALUES = 10; 
6. private Dimension[] d = new
7. public
8. /*** Set height and width. Both height and width must be nonnegative * or
9.  an exception will be thrown. */
10. public synchronized void setValues (int index, int height, int
11. throws
12. if (height < 0 || width < 0) 
13. throw new
14. if (d[index] == null) 
15. d[index] = new
16. d[index].height = height; 
17. d[index].width = width; 
18. } 
19. public synchronized
20. throws
21. return
22. } 
23. }

 

这儿的问题在于getValues()方法仅仅克隆了数组，而没有克隆数组中包含的Dimension对象，因此，虽然调用者无法改变内部的数组使其元素指向不同的Dimension对象，但是调用者却可以改变内部的数组元素(也就是Dimension对象)的内容。方法getValues()的更好版本为：

 

1. public synchronized Dimension[] getValues() throws
2. Dimension[] copy = (Dimension[])d.clone(); 
3. for (int i = 0; i < copy.length; ++i){ 
4. // NOTE: Dimension isn’t cloneable. 
5. if (d != null) 
6. copy[i] = new
7. } 
8. return
9. }

在克隆原子类型数据的多维数组的时候，也会犯类似的错误。原子类型包括int,float等。简单的克隆int型的一维数组是正确的，如下所示：

 

1. public void store (int[] data) throws
2. this.data = (int[])data.clone(); 
3. // OK 
4. }

拷贝int型的二维数组更复杂些。Java没有int型的二维数组，因此一个int型的二维数组实际上是一个这样的一维数组：它的类型为int[]。简单的克隆int[][]型的数组会犯与上面例子中getValues()方法第一版本同样的错误，因此应该避免这么做。下面的例子演示了在克隆int型二维数组时错误的和正确的做法：

 

1. public void wrongStore (int[][] data) throws
2. this.data = (int[][])data.clone(); // Not OK! 
3. } 
4. public void rightStore (int[][] data){ 
5. // OK! 
6. this.data = (int[][])data.clone(); 
7. for (int i = 0; i < data.length; ++i){ 
8. if (data != null) 
9. this.data[i] = (int[])data[i].clone(); 
10. 　 } 
11. }

 

六、常见错误6#：检查new 操作的结果是否为null

Java编程新手有时候会检查new操作的结果是否为null。可能的检查代码为：

 

1. Integer i = new Integer (400); 
2. if (i == null) 
3. throw new

检查当然没什么错误，但却不必要，if和throw这两行代码完全是浪费，他们的唯一功用是让整个程序更臃肿，运行更慢。

C/C++程序员在开始写java程序的时候常常会这么做，这是由于检查C中malloc()的返回结果是必要的，不这样做就可能产生错误。检查C++中new操作的结果可能是一个好的编程行为，这依赖于异常是否被使能(许多编译器允许异常被禁止，在这种情况下new操作失败就会返回null)。在java 中，new 操作不允许返回null，如果真的返回null，很可能是虚拟机崩溃了，这时候即便检查返回结果也无济于事。

七、常见错误7#：用== 替代.equals

在Java中，有两种方式检查两个数据是否相等：通过使用==操作符，或者使用所有对象都实现的.equals方法。原子类型(int, flosat, char 等)不是对象，因此他们只能使用==操作符，如下所示：

 

1. int x = 4; 
2. int y = 5; 
3. if
4. System.out.println ("Hi"); 
5. // This ’if’ test won’t compile. 
6. if
7. System.out.println ("Hi");

 

对象更复杂些，==操作符检查两个引用是否指向同一个对象，而equals方法则实现更专门的相等性检查。

更显得混乱的是由java.lang.Object 所提供的缺省的equals方法的实现使用==来简单的判断被比较的两个对象是否为同一个。

许多类覆盖了缺省的equals方法以便更有用些，比如String类，它的equals方法检查两个String对象是否包含同样的字符串，而Integer的equals方法检查所包含的int值是否相等。

大部分时候，在检查两个对象是否相等的时候你应该使用equals方法，而对于原子类型的数据，你用该使用==操作符。

八、常见错误8#： 混淆原子操作和非原子操作

Java保证读和写32位数或者更小的值是原子操作，也就是说可以在一步完成，因而不可能被打断，因此这样的读和写不需要同步。以下的代码是线程安全(thread safe)的：

 

1. public class
2. private int value; // More code here... 
3. public void set (int
4. // NOTE: No synchronized keyword 
5. this.value = x; 
6. 　 } 
7. }

 

不过，这个保证仅限于读和写，下面的代码不是线程安全的：

 

1. public void
2. // This is effectively two or three instructions: 
3. // 1) Read current setting of ’value’. 
4. // 2) Increment that setting. 
5. // 3) Write the new setting back. 
6. this.value; 
7. }

 

在测试的时候，你可能不会捕获到这个错误。首先，测试与线程有关的错误是很难的，而且很耗时间。其次，在有些机器上，这些代码可能会被翻译成一条指令，因此工作正常，只有当在其它的虚拟机上测试的时候这个错误才可能显现。因此最好在开始的时候就正确地同步代码：

 

1. public synchronized void
2. this.value; 
3. }

九、常见错误9#：在catch 块中作清除工作

一段在catch块中作清除工作的代码如下所示：

 

1. OutputStream os = null; 
2. try{ 
3. new
4. // Do something with os here. 
5. 　 os.close(); 
6. }catch
7. if (os != null) 
8. 　 os.close(); 
9. }

 

尽管这段代码在几个方面都是有问题的，但是在测试中很容易漏掉这个错误。下面列出了这段代码所存在的三个问题：

1．语句os.close()在两处出现，多此一举，而且会带来维护方面的麻烦。

2．上面的代码仅仅处理了Exception，而没有涉及到Error。但是当try块运行出现了Error，流也应该被关闭。

3．close()可能会抛出异常。

上面代码的一个更优版本为：

 

1. OutputStream os = null; 
2. try{ 
3. new
4. // Do something with os here. 
5. }finally{ 
6. if (os != null) 
7. os.close(); 
8. }

 

这个版本消除了上面所提到的两个问题：代码不再重复，Error也可以被正确处理了。但是没有好的方法来处理第三个问题，也许最好的方法是把close()语句单独放在一个try/catch块中。

十、常见错误10#： 增加不必要的catch 块

一些开发者听到try/catch块这个名字后，就会想当然的以为所有的try块必须要有与之匹配的catch块。

C++程序员尤其是会这样想，因为在C++中不存在finally块的概念，而且try块存在的唯一理由只不过是为了与catch块相配对。

增加不必要的catch块的代码就象下面的样子，捕获到的异常又立即被抛出：

 

1. try{ 
2. // Nifty code here 
3. }catch(Exception e){ 
4. throw
5. }finally{ 
6. // Cleanup code here 
7. }

不必要的catch块被删除后，上面的代码就缩短为：

 

1. try{ 
2. // Nifty code here 
3. }finally{ 
4. // Cleanup code here 
5. }

常见错误11#；没有正确实现equals，hashCode，或者clone 等方法

方法equals，hashCode，和clone 由java.lang.Object提供的缺省实现是正确的。不幸地是，这些缺省实现在大部分时候毫无用处，因此许多类覆盖其中的若干个方法以提供更有用的功能。但是，问题又来了，当继承一个覆盖了若干个这些方法的父类的时候，子类通常也需要覆盖这些方法。在进行代码审查时，应该确保如果父类实现了equals，hashCode，或者clone等方法，那么子类也必须正确。正确的实现equals，hashCode，和clone需要一些技巧。

转自51CTO开发频道

转载于:https://blog.51cto.com/liangruijun/636265