今天的面试题目

第一题，创建了2个对象，由于编译器会吧等号右边的进行合并，所以他在常量区会建立一个 "12’的字符串，然后，在堆上创建一个对象叫a .
第二题：日志类触发器吧，其他我不太清楚，表和视图的区别。表是在数据库的存储，视图是某些数据库语句，它不会对应数据库的存储。。表是内模式，视图是外模式。
第三题:hibernate中导入大量对象，可以采用VO模式来优化网络交通
第4题：struts的作用是更好的反应出MVC模式，具体你看书吧，这东西不太好回答，太开放了。
第5题目：SPRING 的IOC,控制反转，好处是通过配置来维持对象之间的关系，而不是让这些关系写死在代码中。这样对象之间的耦合程度被降低到最低
第6题：事务的操作步骤。。不明白。威为什么要有事务。。可以吧多个步骤方在一起，让他们整体作为一个原子，要么一起成功，要么一起失败。

触发器有几种不太清楚，不过好像有前触发器后触发器，以及instead of 触发器，oracle 里好像是这样，记不太清了

第三题:hibernate中导入大量对象 ,应该每导入一定的数据量(比如一百条)刷新一次，flush(); 不要将所有的对象都生成后再保存，分批进行

但是面试的时候说2个对象是错误的我自己也不清楚是3个还是4个我现在也感觉2个对象是不正确的
String a = new String（“12”）；这个语句是创建了2个

第一题，我觉得应该是5个：1.栈上的 a;2,堆上的String对象；3，常量区的1；4，常量区的2；，5，还有一个临时变量 1+ 2；

额，小弟觉得
第一题，是4个对象，“1”，“2”，“12”，还有a所指向的对象
String a= new String("a");是创建了2个对象
+符号貌似是一个重用
愚见

"12",new String(),再+上引用a~~这道题好像很多公司都出吖~~~求牛人确认= =|

string a = new String("1"+"2")共建了几个对象“1”一个对象，“2”一个对象
编译器将“1”，“2”合并为“12” 一个对象
再new一下，一个对象
我觉得是4个对象
a只是引用，算不上对象

http://blog.csdn.net/ZangXT/archive/2009/05/19/4201979.aspx

1.String a = new String("1"+"2")共建了几个对象我相信，绝对是个经典兼考倒一堆人的题目。经典，Java的面、笔试上都会有，可又总是有人会犯晕。呵呵！看构造器里面（"1"+"2"）,这个是在编译期就已经做了处理，即代表一个字符串："12"。当使用new的方法创建字符串时，注意这个”new“，就表示直接开辟了内存空间，VM在对其对象的值”12“；然后再把值放到VM的常量池中，并引用其本身。所以就创建了两个对象，看反编译后的代码：
Java代码 1. String a = new String("1"+"2");
 2. System.out.println(a);
 3. 反编译后的：
 4. Code:
 5. 0: new #2; //class java/lang/String 在堆上创建了一个对象
 6. 3: dup
 7. 4: ldc #3; //String 12最终的字符串值 String a = new String("1"+"2");
System.out.println(a);
反编译后的：
Code:
 0: new #2; //class java/lang/String 在堆上创建了一个对象
 3: dup
 4: ldc #3; //String 12最终的字符串值 在API中对使用new创建String的建议：初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。既然写到这了，就扩展开来，说说其他的情况，先说一个与题目中类似的，唯一区别是，不使用new创建看代码：
Java代码 1. String str1 = "ABC" + "CD";
 2. String str2 = new String("ABC" + "CD"); String str1 = "ABC" + "CD";
String str2 = new String("ABC" + "CD"); 再看其反编译后的：
Java代码 1. Code:
 2. 0: ldc #2; //String ABCCD
 3. 2: astore_1
 4. 3: new #3; //class java/lang/String
 5. 6: dup
 6. 7: ldc #2; //String ABCCD
 7. Code:
0: ldc #2; //String ABCCD
2: astore_1
3: new #3; //class java/lang/String
6: dup
7: ldc #2; //String ABCCD 对比一下，我想大伙都能看出了两者的区别，首先是，直接定义字符串常量，VM不会自动调用new创建，而是在VM维护的常量池中先查找，如果发现，直接返回一个对其的引用，若不存在，把其加入，再返回一个对其的引用。
此外，再总结一下与String 有关的三种加法： * String tmp = "a" + "b" + "c";
 * String tmp = null;tmp+= "a";tmp+= "b";tmp+= "c";
 * 使用Stringbuffer或StringBuilder(注意，其在多线程环境下是不安全的)的append方法看看：
Java代码 1. Code:
 2. START-第一种情况String str1 = "ABC" + "CD"：
 3. 0: ldc #2; //String ABCCD
 4. 2: astore_1
 5. END-第一种情况
 6.
 7. START-第二种情况：String str2 = null;str2 += "ABC";str2 += "CDS";str2 += "DSS";
 8. 3: aconst_null
 9. 4: astore_2
 10. 5: new #3; //class java/lang/StringBuilder: 创建了一个StringBuilder对象
 11. 8: dup
 12. 9: invokespecial #4;
 13. 12: aload_2
 14. 13: invokevirtual #5;
 15. 16: ldc #6; //String ABC ：追加第一个字符串"ABC",调用了append方法，下看
 16. 18: invokevirtual #5; //Method append:
 17. 21: invokevirtual #7; //Method toString:
 18.
 19. 24: astore_2
 20. 25: new #3; //class java/lang/StringBuilder：再创建了一个StringBuilder对象
 21. 28: dup
 22. 29: invokespecial #4;
 23. 32: aload_2
 24. 33: invokevirtual #5; 先追加前面的字符串 "ABC"
 25. 36: ldc #8; //String CDS ：追加第二个字符串"CDS",调用了append方法，下看
 26. 38: invokevirtual #5; //Method java/lang/StringBuilder.append:
 27. 41: invokevirtual #7; //Method java/lang/StringBuilder.toString:
 28. 44: astore_2
 29.
 30. 45: new #3; //class java/lang/StringBuilder：再创建了一个StringBuilder对象
 31. 48: dup
 32. 49: invokespecial #4;
 33. 52: aload_2
 34. 53: invokevirtual #5; //Method java/lang/StringBuilder.append: 先追加前面的字符串"ABC CDS"
 35. 56: ldc #9; //String DSS：追加第三个字符串"CDS",调用了append方法，下看
 36. 58: invokevirtual #5; //Method java/lang/StringBuilder.append:
 37. 61: invokevirtual #7; //Method java/lang/StringBuilder.toString:
 38. END-第二种情况
 39.
 40. START-第三种情况
 41. 64: astore_2
 42. 65: new #10; //class java/lang/StringBuffer：创建StringBuffer对象
 43. 68: dup
 44. 69: invokespecial #11; //Method java/lang/StringBuffer."<init>":()V
 45. 72: astore_3
 46. 73: aload_3
 47. 74: ldc #6; //String ABC ：调用append方法
 48. 76: invokevirtual #12; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
 49. 79: pop
 50. 80: aload_3
 51. 81: ldc #13; //String DDD：调用append方法
 52. 83: invokevirtual #12; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
 53. 86: pop
 54. END-第三种情况 Code:
START-第一种情况String str1 = "ABC" + "CD"：
 0: ldc #2; //String ABCCD
 2: astore_1
 END-第一种情况

 START-第二种情况：String str2 = null;str2 += "ABC";str2 += "CDS";str2 += "DSS";
 3: aconst_null
 4: astore_2
 5: new #3; //class java/lang/StringBuilder: 创建了一个StringBuilder对象
 8: dup
 9: invokespecial #4;
 12: aload_2
 13: invokevirtual #5;
 16: ldc #6; //String ABC ：追加第一个字符串"ABC",调用了append方法，下看
 18: invokevirtual #5; //Method append:
 21: invokevirtual #7; //Method toString:

 24: astore_2
 25: new #3; //class java/lang/StringBuilder：再创建了一个StringBuilder对象
 28: dup
 29: invokespecial #4;
 32: aload_2
 33: invokevirtual #5; 先追加前面的字符串 "ABC"
 36: ldc #8; //String CDS ：追加第二个字符串"CDS",调用了append方法，下看
 38: invokevirtual #5; //Method java/lang/StringBuilder.append:
 41: invokevirtual #7; //Method java/lang/StringBuilder.toString:
 44: astore_2

 45: new #3; //class java/lang/StringBuilder：再创建了一个StringBuilder对象
 48: dup
 49: invokespecial #4;
 52: aload_2
 53: invokevirtual #5; //Method java/lang/StringBuilder.append: 先追加前面的字符串"ABC CDS"
 56: ldc #9; //String DSS：追加第三个字符串"CDS",调用了append方法，下看
 58: invokevirtual #5; //Method java/lang/StringBuilder.append:
 61: invokevirtual #7; //Method java/lang/StringBuilder.toString:
 END-第二种情况

 START-第三种情况
 64: astore_2
 65: new #10; //class java/lang/StringBuffer：创建StringBuffer对象
 68: dup
 69: invokespecial #11; //Method java/lang/StringBuffer."<init>":()V
 72: astore_3
 73: aload_3
 74: ldc #6; //String ABC ：调用append方法
 76: invokevirtual #12; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
 79: pop
 80: aload_3
 81: ldc #13; //String DDD：调用append方法
 83: invokevirtual #12; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
 86: pop
 END-第三种情况小结一把：在JVM中，出现了第二种情况的，会默认创建一个StringBuilder对象来对字符串进行追加，注意，每一个"+="操作符，就会创建一个新的StringBuilder对象。这里就会造成挺大的内存浪费。而用StringBuffer/StringBuilder这个对象来实现追加，在没调用其toString方法时，其对象还是可变的，一旦调用了toString的方法，就变成了不可变的String。2. 触发器有几种？表和视图的区别
3.hibernate中导入（导出？忘记是导入还是导出了）大量数据时，会产生大量的对象，为了避免这一现象应该怎么做？
4.struts的作用，被用做c层的原理
5.Spring的ioc的好处
6.事务的操作步骤（不大明白这个题目的意思），为什么会有事务
这里有某位仁兄（ charles_wang8888）的解答，个人感觉其答得好：第一题，创建了2个对象，由于编译器会吧等号右边的进行合并，所以他在常量区会建立一个 "12’的字符串，然后，在堆上创建一个对象叫a .
第二题：日志类触发器吧，其他我不太清楚，表和视图的区别。表是在数据库的存储，视图是某些数据库语句，它不会对应数据库的存储。。表是内模式，视图是外模式。
第三题:hibernate中导入大量对象，可以采用VO模式来优化网络交通
第4题：struts的作用是更好的反应出MVC模式，具体你看书吧，这东西不太好回答，太开放了。
第5题目：SPRING 的IOC,控制反转，好处是通过配置来维持对象之间的关系，而不是让这些关系写死在代码中。这样对象之间的耦合程度被降低到最低
第6题：事务的操作步骤。。不明白。威为什么要有事务。。可以吧多个步骤方在一起，让他们整体作为一个原子，要么一起成功，要么一起失败。

31楼的我也看蒙了一大片个人认为是四个 1 2 12 new

调试易

今天的面试题目

解决方案 »