think in java interview-高级开发人员面试宝典(四)

￡神魔★判官ぃ 2022-10-01 13:46 120阅读 0赞

# java实现shallow clone(浅克隆）与深克隆(deep clone) #

克隆就是复制一个对象的复本.但一个对象中可能有基本数据类型,如:int,long,float 等,也同时含有非基本数据类型如(数组,集合等)被克隆得到的对象基本类型的值修改了,原对象的值不会改变.这种适合shadow clone(浅克隆).  
但如果你要改变一个非基本类型的值时,原对象的值却改变了,.比如一个数组,内存中只copy他的地址,而这个地址指向的值并没有 copy,当clone时,两个地址指向了一个值,这样一旦这个值改变了,原来的值当然也变了,因为他们共用一个值.,这就必须得用深克隆(deep clone)  
以下举个例子,说明以上情况.  
被克隆类:ShadowClone.java

**\[java\]** [view plain][] [copy][view plain]

1. **public****class** ShadowClone **implements** Cloneable 
2. \{ 
3. // 基本类型
4. **private****int** a; 
5. // 非基本类型
6. **private** String b; 
7. // 非基本类型
8. **private****int**\[\] c; 
9. // 重写Object.clone()方法,并把protected改为public
10. @Override
11. **public** Object clone() 
12. \{ 
13. ShadowClone sc = **null**; 
14. **try**
15. \{ 
16. sc = (ShadowClone) **super**.clone(); 
17. \} **catch** (CloneNotSupportedException e) 
18. \{ 
19. e.printStackTrace(); 
20. \} 
21. **return** sc; 
22. \} 
23. **public****int** getA() 
24. \{ 
25. **return** a; 
26. \} 
27. **public****void** setA(**int** a) 
28. \{ 
29. **this**.a = a; 
30. \} 
31. **public** String getB() 
32. \{ 
33. **return** b; 
34. \} 
35. **public****void** setB(String b) 
36. \{ 
37. **this**.b = b; 
38. \} 
39. **public****int**\[\] getC() 
40. \{ 
41. **return** c; 
42. \} 
43. **public****void** setC(**int**\[\] c) 
44. \{ 
45. **this**.c = c; 
46. \} 
47. \}

测试类Test.java

**\[java\]** [view plain][] [copy][view plain]

1. **public****class** Test 
2. \{ 
3. **public****static****void** main(String\[\] args) **throws** CloneNotSupportedException 
4. \{ 
5. ShadowClone c1 = **new** ShadowClone(); 
6. //对c1赋值
7. c1.setA(100) ; 
8. c1.setB("clone1") ; 
9. c1.setC(**new****int**\[\]\{ 1000\}) ; 
10. 
11. System.out.println("克隆前: c1.a="\+c1.getA() ); 
12. System.out.println("克隆前: c1.b="\+c1.getB() ); 
13. System.out.println("克隆前: c1.c\[0\]="\+c1.getC()\[0\]); 
14. System.out.println("-----------") ; 
15. 
16. //克隆出对象c2,并对c2的属性A,B,C进行修改
17. 
18. ShadowClone c2 = (ShadowClone) c1.clone(); 
19. 
20. //对c2进行修改
21. c2.setA(50) ; 
22. c2.setB("clone2"); 
23. **int** \[\]a = c2.getC() ; 
24. a\[0\]=500 ; 
25. c2.setC(a); 
26. 
27. System.out.println("克隆后: c1.a="\+c1.getA() ); 
28. System.out.println("克隆后: c1.b="\+c1.getB() ); 
29. System.out.println("克隆后: c1.c\[0\]="\+c1.getC()\[0\]); 
30. System.out.println("---------------") ; 
31. 
32. System.out.println("克隆后: c2.a=" \+ c2.getA()); 
33. System.out.println("克隆后: c2.b=" \+ c2.getB()); 
34. System.out.println("克隆后: c2.c\[0\]=" \+ c2.getC()\[0\]); 
35. \} 
36. \}

结果:  
克隆前: c1.a=100  
克隆前: c1.b=clone1  
克隆前: c1.c\[0\]=1000  
\-----------  
克隆后: c1.a=100  
克隆后: c1.b=clone1  
克隆后: c1.c\[0\]=500  
\---------------  
克隆后: c2.a=50  
克隆后: c2.b=clone2  
克隆后: c2.c\[0\]=500  
问题出现了,我指修改了克隆后的对象c2.c的值,但c1.c的值也改变了,与c2的值相等.  
以下针对浅克隆得出结论:基本类型是可以被克隆的,但引用类型只是copy地址,并没有copy这个地址指向的对象的值,这使得两个地址指向同一值,修改其中一个,当然另一个也就变了.  
由此可见,浅克隆只适合克隆基本类型,对于引用类型就不能实现克隆了.  
  
那如何实现克隆引用对象呢,以下提供一种方法. 用序列化与反序列化实现深克隆(deep copy)  
  
被克隆对象.DeepClone.java

**\[java\]** [view plain][] [copy][view plain]

1. **import** java.io.Serializable; 
2. //要实现深克隆必须实现Serializable接口
3. **public****class** DeepClone **implements** Serializable 
4. \{ 
5. **private****int** a; 
6. **private** String b; 
7. **private****int**\[\] c; 
8. **public****int** getA() 
9. \{ 
10. **return** a; 
11. \} 
12. **public****void** setA(**int** a) 
13. \{ 
14. **this**.a = a; 
15. \} 
16. **public** String getB() 
17. \{ 
18. **return** b; 
19. \} 
20. **public****void** setB(String b) 
21. \{ 
22. **this**.b = b; 
23. \} 
24. **public****int**\[\] getC() 
25. \{ 
26. **return** c; 
27. \} 
28. **public****void** setC(**int**\[\] c) 
29. \{ 
30. **this**.c = c; 
31. \} 
32. \}

测试类Test.java

**\[java\]** [view plain][] [copy][view plain]

1. **import** java.io.ByteArrayInputStream; 
2. **import** java.io.ByteArrayOutputStream; 
3. **import** java.io.IOException; 
4. **import** java.io.ObjectInputStream; 
5. **import** java.io.ObjectOutputStream; 
6. **public****class** Test 
7. \{ 
8. **public****static****void** main(String\[\] args) **throws** CloneNotSupportedException 
9. \{ 
10. Test t = **new** Test(); 
11. DeepClone dc1 = **new** DeepClone(); 
12. // 对dc1赋值
13. dc1.setA(100); 
14. dc1.setB("clone1"); 
15. dc1.setC(**new****int**\[\] \{ 1000 \}); 
16. System.out.println("克隆前: dc1.a=" \+ dc1.getA()); 
17. System.out.println("克隆前: dc1.b=" \+ dc1.getB()); 
18. System.out.println("克隆前: dc1.c\[0\]=" \+ dc1.getC()\[0\]); 
19. System.out.println("-----------"); 
20. DeepClone dc2 = (DeepClone) t.deepClone(dc1); 
21. // 对c2进行修改
22. dc2.setA(50); 
23. dc2.setB("clone2"); 
24. **int**\[\] a = dc2.getC(); 
25. a\[0\] = 500; 
26. dc2.setC(a); 
27. System.out.println("克隆前: dc1.a=" \+ dc1.getA()); 
28. System.out.println("克隆前: dc1.b=" \+ dc1.getB()); 
29. System.out.println("克隆前: dc1.c\[0\]=" \+ dc1.getC()\[0\]); 
30. System.out.println("-----------"); 
31. System.out.println("克隆后: dc2.a=" \+ dc2.getA()); 
32. System.out.println("克隆后: dc2.b=" \+ dc2.getB()); 
33. System.out.println("克隆后: dc2.c\[0\]=" \+ dc2.getC()\[0\]); 
34. \} 
35. // 用序列化与反序列化实现深克隆
36. **public** Object deepClone(Object src) 
37. \{ 
38. Object o = **null**; 
39. **try**
40. \{ 
41. **if** (src != **null**) 
42. \{ 
43. ByteArrayOutputStream baos = **new** ByteArrayOutputStream(); 
44. ObjectOutputStream oos = **new** ObjectOutputStream(baos); 
45. oos.writeObject(src); 
46. oos.close(); 
47. ByteArrayInputStream bais = **new** ByteArrayInputStream(baos 
48. .toByteArray()); 
49. ObjectInputStream ois = **new** ObjectInputStream(bais); 
50. o = ois.readObject(); 
51. ois.close(); 
52. \} 
53. \} **catch** (IOException e) 
54. \{ 
55. e.printStackTrace(); 
56. \} **catch** (ClassNotFoundException e) 
57. \{ 
58. e.printStackTrace(); 
59. \} 
60. **return** o; 
61. \} 
62. \}

结果:  
克隆前: dc1.a=100  
克隆前: dc1.b=clone1  
克隆前: dc1.c\[0\]=1000  
\-----------  
克隆前: dc1.a=100  
克隆前: dc1.b=clone1  
克隆前: dc1.c\[0\]=1000  
\-----------  
克隆后: dc2.a=50  
克隆后: dc2.b=clone2  
克隆后: dc2.c\[0\]=500  
深克隆后:修改dc1或者dc2,无论是基本类型还是引用类型,他们的值都不会随着一方改变另一方也改变.

**总结:**

当克隆的对象只有基本类型,不含引用类型时,可以用浅克隆实现.

当克隆的对象含有引用类型时,必须使用深克隆实现.

# 谈谈final， finally， finalize的区别 #

final修饰符（关键字）

如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载finally？再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

finalize方法名

Java 技术允许使用 finalize（）方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize（） 方法以整理系统资源或者执行其他清理工作。finalize（）方法是在垃圾收集器删除对象之前对这个对象调用的。

# Java对象的强、软、弱和虚引用 #

##  ##

## **强引用** ##

**\[java\]** [view plain][] [copy][view plain]

1. Object o=**new** Object(); 
2. Object o1=o;

上面代码中第一句是在heap堆中创建新的Object对象通过o引用这个对象，第二句是通过o建立o1到new Object()这个heap堆中的对象的引用，这两个引用都是强引用.只要存在对heap中对象的引用，gc就不会收集该对象.如果通过如下代码：

**\[java\]** [view plain][] [copy][view plain]

1. o=**null**; 
2. o1=**null**;

如果显式地设置o和o1为null，或超出范围，则gc认为该对象不存在引用，这时就可以收集它了。可以收集并不等于就一会被收集，什么时候收集这要取 决于gc的算法，这要就带来很多不确定性。例如你就想指定一个对象，希望下次gc运行时把它收集了，那就没办法了，有了其他的三种引用就可以做到了。其他 三种引用在不妨碍gc收集的情况下，可以做简单的交互。  
  
heap中对象有强可及对象、软可及对象、弱可及对象、虚可及对象和不可到达对象。应用的强弱顺序是强、软、弱、和虚。对于对象是属于哪种可及的对象，由他的最强的引用决定。如下：

**\[java\]** [view plain][] [copy][view plain]

1. String abc=**new** String("abc"); //1 
2. SoftReference<String> abcSoftRef=**new** SoftReference<String>(abc); //2 
3. WeakReference<String> abcWeakRef = **new** WeakReference<String>(abc); //3 
4. abc=**null**; //4 
5. abcSoftRef.clear();//5

第一行在heap对中创建内容为“abc”的对象，并建立abc到该对象的强引用,该对象是强可及的。  
  
第二行和第三行分别建立对heap中对象的软引用和弱引用，此时heap中的对象仍是强可及的。  
  
第四行之后heap中对象不再是强可及的，变成软可及的。同样第五行执行之后变成弱可及的。

## SoftReference（软引用） ##

软引用是主要用于内存敏感的高速缓存。在jvm报告内存不足之前会清除所有的软引用，这样以来gc就有可能收集软可及的对象，可能解决内存吃紧问题，避 免内存溢出。什么时候会被收集取决于gc的算法和gc运行时可用内存的大小。当gc决定要收集软引用是执行以下过程,以上面的abc SoftRef为例：  
  
1、首先将abcSoftRef的referent设置为null，不再引用heap中的new String("abc")对象。  
  
2、将heap中的new String("abc")对象设置为可结束的(finalizable)。  
  
3、当heap中的new String("abc")对象的finalize()方法被运行而且该对象占用的内存被释放， abcSoftRef被添加到它的ReferenceQueue中。  
  
**注:对ReferenceQueue软引用和弱引用可以有可无，但是虚引用必须有，参见：**

**\[java\]** [view plain][] [copy][view plain]

1. Reference(T paramT, ReferenceQueue<? **super** T>paramReferenceQueue)

被 Soft Reference 指到的对象，即使没有任何 Direct Reference，也不会被清除。

一直要到 JVM 内存不足且 没有 Direct Reference 时才会清除，SoftReference 是用来设计 object-cache 之用的。

如此一来 SoftReference 不但可以把对象 cache 起来，也不会造成内存不足的错误 （OutOfMemoryError）。我觉得 Soft Reference 也适合拿来实作 pooling 的技巧。

**\[java\]** [view plain][] [copy][view plain]

1. A obj = **new** A(); 
2. SoftRefenrence sr = **new** SoftReference(obj); 
3. 
4. //引用时
5. **if**(sr!=**null**)\{ 
6. obj = sr.get(); 
7. \}**else**\{ 
8. obj = **new** A(); 
9. sr = **new** SoftReference(obj); 
10. \}

## 弱引用 ##

当gc碰到弱可及对象，并释放abcWeakRef的引用，收集该对象。但是gc可能需要对此运用才能找到该弱可及对象。通过如下代码可以了明了的看出它的作用：

**\[java\]** [view plain][] [copy][view plain]

1. String abc=**new** String("abc"); 
2. WeakReference<String> abcWeakRef = **new** WeakReference<String>(abc); 
3. abc=**null**; 
4. System.out.println("before gc: "\+abcWeakRef.get()); 
5. System.gc(); 
6. System.out.println("after gc: "\+abcWeakRef.get());

运行结果：  
  
　　before gc: abc  
　　after gc: null  
  
gc收集弱可及对象的执行过程和软可及一样，只是gc不会根据内存情况来决定是不是收集该对象。  
  
如果你希望能随时取得某对象的信息，但又不想影响此对象的垃圾收集，那么你应该用 Weak Reference 来记住此对象，而不是用一般的 reference。

**\[java\]** [view plain][] [copy][view plain]

1. A obj = **new** A(); 
2. 
3. WeakReference wr = **new** WeakReference(obj); 
4. 
5. obj = **null**; 
6. 
7. //等待一段时间，obj对象就会被垃圾回收
8. ... 
9. 
10. **if** (wr.get()==**null**) \{ 
11. System.out.println("obj 已经被清除了 "); 
12. \} **else** \{ 
13. 　System.out.println("obj 尚未被清除，其信息是 "\+obj.toString()); 
14. \} 
15. ...

在此例中，透过 get() 可以取得此 Reference 的所指到的对象，如果返回值为 null 的话，代表此对象已经被清除。  
  
这类的技巧，在设计 Optimizer 或 Debugger 这类的程序时常会用到，因为这类程序需要取得某对象的信息，但是不可以 影响此对象的垃圾收集。

## PhantomRefrence（虚引用） ##

虚顾名思义就是没有的意思，建立虚引用之后通过get方法返回结果始终为null，通过源代码你会发现，虚引用通向会把引用的对象写进referent，只是get方法返回结果为null。先看一下和gc交互的过程在说一下他的作用。  
  
  
1 不把referent设置为null，直接把heap中的new String("abc")对象设置为可结束的(finalizable).  
  
2 与软引用和弱引用不同，先把PhantomRefrence对象添加到它的ReferenceQueue中，然后在释放虚可及的对象。  
  
你会发现在收集heap中的new String("abc")对象之前，你就可以做一些其他的事情。通过以下代码可以了解他的作用。

**\[java\]** [view plain][] [copy][view plain]

1. **import** java.lang.ref.PhantomReference; 
2. **import** java.lang.ref.Reference; 
3. **import** java.lang.ref.ReferenceQueue; 
4. **import** java.lang.reflect.Field; 
5. 
6. **public****class** Test \{ 
7. **public****static****boolean** isRun = **true**; 
8. 
9. **public****static****void** main(String\[\] args) **throws** Exception \{ 
10. String abc = **new** String("abc"); 
11. System.out.println(abc.getClass() + "@" \+ abc.hashCode()); 
12. **final** ReferenceQueue referenceQueue = **new** ReferenceQueue<String>(); 
13. **new** Thread() \{ 
14. **public****void** run() \{ 
15. **while** (isRun) \{ 
16. Object o = referenceQueue.poll(); 
17. **if** (o != **null**) \{ 
18. **try** \{ 
19. Field rereferent = Reference.**class**
20. .getDeclaredField("referent"); 
21. rereferent.setAccessible(**true**); 
22. Object result = rereferent.get(o); 
23. System.out.println("gc will collect:"
24. \+ result.getClass() + "@"
25. \+ result.hashCode()); 
26. \} **catch** (Exception e) \{ 
27. 
28. e.printStackTrace(); 
29. \} 
30. \} 
31. \} 
32. \} 
33. \}.start(); 
34. PhantomReference<String> abcWeakRef = **new** PhantomReference<String>(abc, 
35. referenceQueue); 
36. abc = **null**; 
37. Thread.currentThread().sleep(3000); 
38. System.gc(); 
39. Thread.currentThread().sleep(3000); 
40. isRun = **false**; 
41. \} 
42. 
43. \}

结果为：  
  
**class java.lang.String@96354  
gc will collect:class java.lang.String@96354**

## 为什么需要使用软引用 ##

首先，我们看一个雇员信息查询系统的实例。

我们将使用一个Java语言实现的雇员信息查询系统查询存储在磁盘文件或者数据库中的雇员人事档案信息。

作为一个用户，我们完全有可能需要回头去查看几分钟甚至几秒钟前查看过的雇员档案信息(同样，我们在浏览WEB页面的时候也经常会使用“后退”按钮)。

这时我们通常会有两种程序实现方式:

一种是把过去查看过的雇员信息保存在内存中，每一个存储了雇员档案信息的Java对象的生命周期贯穿整个应用程序始终;

另一种是当用户开始查看其他雇员的档案信息的时候，把存储了当前所查看的雇员档案信息的Java对象结束引用，使得垃圾收集线程可以回收其所占用的内存空间，当用户再次需要浏览该雇员的档案信息的时候，重新构建该雇员的信息。

很显然，第一种实现方法将造成大量的内存浪费，而第二种实现的缺陷在于即使垃圾收集线程还没有进行垃圾收集，包含雇员档案信息的对象仍然完好地保存在内存中，应用程序也要重新构建一个对象。

我们知道，访问磁盘文件、访问网络资源、查询数据库等操作都是影响应用程序执行性能的重要因素，如果能重新获取那些尚未被回收的Java对象的引用，必将减少不必要的访问，大大提高程序的运行速度。

# 在J2EE的bean设计时我们对有些bean需要实现Serializable，为什么？ #

实现了Serializable接口的对象，可将它们转换成一系列字节，并可在以后完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。换句话说，可以先在Windows机器上创建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里准确无误地重新“装配”。不必关心数据在不同机器上如何表示，也不必关心字节的顺序或者其他任何细节。

转载于:https://blog.51cto.com/longx/1351869

[view plain]: http://blog.csdn.net/lifetragedy/article/details/9751079#