1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？7
2、Java有没有goto7
3、说说&和&&的区别。7
4、在JAVA中如何跳出当前的多重嵌套循环？7
5、switch语句能否作用在byte上，能否作用在long上，能否作用在String上8
6、shorts1=1;s1=s1+1;有什么错shorts1=1;s1+=1;有什么错8
7、char型变量中能不能存贮一个中文汉字为什么8
8、用最有效率的方法算出2乘以8等於几8
9、请设计一个一百亿的计算器8
10、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？8
11、"=="和equals方法究竟有什么区别？9
12、静态变量和实例变量的区别？9
13、是否可以从一个static方法内部发出对非static方法的调用？9
14、Integer与int的区别9
15、Math.round(11.5)等于多少Math.round(-11.5)等于多少10
16、下面的代码有什么不妥之处10
17、请说出作用域public，private，protected，以及不写时的区别10
18、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型10
19、构造器Constructor是否可被override10
20、接口是否可继承接口抽象类是否可实现(implements)接口抽象类是否可继承具体类(concreteclass)抽象类中是否可以有静态的main方法？抽象类是否可有以内部类？接口是否可以有内部类？10
21、写clone()方法时，通常都有一行代码(不是必须有)，是什么？11
22、面向对象的特征有哪些方面11
23、java中实现多态的机制是什么？11
24、abstractclass和interface有什么区别11
25、abstract的method是否可同时是static，是否可同时是native，是否可同时是synchronized，是否可同时是final12
26、什么是内部类？StaticNestedClass和InnerClass的不同。12
27、内部类可以引用它的包含类的成员吗？有没有什么限制？12
28、AnonymousInnerClass(匿名内部类)是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)12
29、super.getClass()方法和this.getClass()方法返回对象是否相同？12
30、String是最基本的数据类型吗12
31、Strings="Hello";s=s+"world!";这两行代码执行后，原始的String对象中的内容到底变了没有？12
32、是否可以继承String类12
33、Strings=newString("xyz");创建了几个StringObject二者之间有什么区别？13
34、String和StringBuffer的区别13
34.1、StringBuffer和StringBuilder的区别13
35、如何把一段逗号分割的字符串转换成一个数组13
36、数组有没有length()这个方法String有没有length()这个方法？JS的数组有没有length()方法？JS的字符串有没有length()方法？14
37、下面这条语句一共创建了多少个对象：Strings="a"+"b"+"c"+"d";14
38、try{}里有一个return语句，那么紧跟在这个try后的finally{}里的code会不会被执行，什么时候被执行，在return前还是后14
39、下面的程序代码输出的结果是多少？15
40、final,finally,finalize的区别。16
41、运行时异常(Runtime)与检查异常(Checked)有何异同？16
42、error和exception有什么区别16
43、Java中的异常处理机制的简单原理和应用。17
44、请写出你最常见到的5个RuntimeException。17
45、Java语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？17
46、Java中有几种方法可以实现一个线程？用什么关键字修饰同步方法stop()和suspend()方法为何不推荐使用？18
47、sleep()和wait()有什么区别19
48、同步和异步有何异同，在什么情况下分别使用他们？举例说明。19
49.下面两个方法同步吗？（自己发明）19
50、多线程有几种实现方法同步有几种实现方法20
51、启动一个线程是用run()还是start()20
52、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法20
53、线程的基本概念、线程的基本状态以及状态之间的关系20
54、简述synchronized和java.util.concurrent.locks.Lock的异同？20
55、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。21
56、子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序。22
57、介绍Collection框架的结构23
58、Collection框架中实现比较要实现什么接口24
59、ArrayList和Vector的区别24
60、HashMap和Hashtable的区别24
61、List和Map区别24
62、List,Set,Map是否继承自Collection接口24
63、List、Map、Set三个接口，存取元素时，各有什么特点？24
64、说出ArrayList,Vector,LinkedList的存储性能和特性25
65、去掉一个Vector集合中重复的元素25
66、Collection和Collections的区别。25
67、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢是用==还是equals()它们有何区别25
68、你所知道的集合类都有哪些？主要方法？25
69、两个对象值相同(x.equals(y)==true)，但却可有不同的hashcode，这句话对不对26
70、TreeSet里面放对象，如果同时放入了父类和子类的实例对象，那比较时使用的是父类的compareTo方法，还是使用的子类的compareTo方法，还是抛异常！26
71、说出一些常用的类，包，接口，请各举5个26
72、Java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？26
73、字节流与字符流的区别26
74、什么是java序列化，如何实现java序列化？或者请解释Serializable接口的作用。26
75、描述一下JVM加载class文件的原理机制27
76、heap和stack有什么区别。27
77、GC是什么为什么要有GC27
78、垃圾回收的优点和原理。并考虑2种回收机制。27
79、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？27
80、什么时候用assert。28
81、java中会存在内存泄漏吗，请简单描述。28
82、能不能自己写个类，也叫java.lang.String？28
83.Java代码查错29
84、SSH集成方式33
二.算法与编程33
1、编写一个程序，将a.txt文件中的单词与b.txt文件中的单词交替合并到c.txt文件中，a.txt文件中的单词用回车符分隔，b.txt文件中用回车或空格进行分隔。33
2、编写一个程序，将d:\java目录下的所有.java文件复制到d:\jad目录下，并将原来文件的扩展名从.java改为.jad。34
3、编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串，但要保证汉字不被截取半个，如“我ABC”，4，应该截取“我AB”，输入“我ABC汉DEF”，6，应该输出“我ABC”，而不是“我ABC+汉的半个”。35
4、有一个字符串，其中包含中文字符、英文字符和数字字符，请统计和打印出各个字符的个数。35
5、说明生活中遇到的二叉树，用java实现二叉树36
6、从类似如下的文本文件中读取出所有的姓名，并打印出重复的姓名和重复的次数，并按重复次数排序：37
7、写一个Singleton出来。39
8、递归算法题140
9、递归算法题241
10、排序都有哪几种方法？请列举。用JAVA实现一个快速排序。41
11、有数组a[n]，用java代码将数组元素顺序颠倒42
12、金额转换，阿拉伯数字的金额转换成中国传统的形式如：（￥1011）－>（一千零一拾一元整）输出。43
13、不使用递归遍历二叉树43
14、以最快的效率找出一个数组中第二大的数45
三.html&JavaScript&ajax部分46
1.判断第二个日期比第一个日期大46
2.用table显示n条记录，每3行换一次颜色，即1，2，3用红色字体，4，5，6用绿色字体，7，8，9用红颜色字体。47
3、HTML的form提交之前如何验证数值文本框的内容全部为数字否则的话提示用户并终止提交47
4、请写出用于校验HTML文本框中输入的内容全部为数字的javascript代码48
5、说说你用过那些ajax技术和框架，说说它们的区别48
四.Javaweb部分48
1、Tomcat的优化经验48
2、HTTP请求的GET与POST方式的区别48
3、解释一下什么是servlet;49
4、说一说Servlet的生命周期49
5、Servlet的基本架构49
6、ServletAPI中forward()与redirect()的区别？49
7、什么情况下调用doGet()和doPost()？49
8、Request对象的主要方法：49
9、request.getAttribute()和request.getParameter()有何区别50
10.jsp有哪些内置对象作用分别是什么分别有什么方法？50
12.jsp生命周期51
12.jsp有哪些动作作用分别是什么51
13、JSP的常用指令51
14.JSP中动态INCLUDE与静态INCLUDE的区别？51
15、两种跳转方式分别是什么有什么区别51
16、页面间对象传递的方法51
17、JSP和Servlet有哪些相同点和不同点，他们之间的联系是什么？51
18、MVC的各个部分都有那些技术来实现如何实现52
19、我们在web应用开发过程中经常遇到输出某种编码的字符，如iso-8859-1等，如何输出一个某种编码的字符串？52
20、现在输入n个数字，以逗号分开；然后可选择升或者降序排序；按提交键就在另一页面显示按什么排序，结果为，提供reset52
五.数据库部分52
1、根据部门号从高到低，工资从低到高列出每个员工的信息。52
2、列出各个部门中工资高于本部门的平均工资的员工数和部门号，并按部门号排序52
3、存储过程、函数与触发器必须讲，经常被面试到53
4、数据库三范式是什么54
5、说出一些数据库优化方面的经验55
6、union和unionall有什么不同56
6.1、表test中有两个字段a、b，都为数值型，如果a大于b，取a列的值，如果a不大于b，取b列的值，写出你认为最有效率的SQL，兼容所有数据库。56
7、分页语句56
8.用一条SQL语句查询出每门课都大于80分的学生姓名56
9.所有部门之间的比赛组合56
10.每个月份的发生额都比101科目多的科目57
11.统计每年每月的信息58
13.删除除了id号不同,其他都相同的学生冗余信息60
14.航空网的几个航班查询题：60
15.查出比经理薪水还高的员工信息：61
16、求出小于45岁的各个老师所带的大于12岁的学生人数61
17.求出发帖最多的人：61
18、一个用户表中有一个积分字段，假如数据库中有100多万个用户，若要在每年第一天凌晨将积分清零，你将考虑什么，你将想什么办法解决61
19、一个用户具有多个角色，请查询出该表中具有该用户的所有角色的其他用户。(跟第42条SQL语句同)62
20.xxx公司的sql面试62
21、注册Jdbc驱动程序的三种方式63
22、用JDBC如何调用存储过程64
23、JDBC中的PreparedStatement相比Statement的好处64
24、Class.forName的作用为什么要用64
25、大数据量下的分页解决方法。64
26、用JDBC查询学生成绩单,把主要代码写出来（考试概率极大）.65
27、这段代码有什么不足之处65
28、说出数据连接池的工作机制是什么65
29、为什么要用ORM和JDBC有何不一样66
30.数据库大数据处理66
31.存储过程和函数具体的区别：66
六.XML部分66
1、xml有哪些解析技术区别是什么66
2、你在项目中用到了xml技术的哪些方面如何实现的67
3、用jdom解析xml文件时如何解决中文问题如何解析67
4、编程用JAVA解析XML的方式.68
5、XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？69
七.流行的框架与新技术70
1、谈谈你对Struts的理解。70
2、谈谈你对Hibernate的理解。70
3、AOP的作用。70
4、你对Spring的理解。71
5、谈谈Struts中的ActionServlet。71
6、Struts优缺点71
7、STRUTS的应用(如STRUTS架构)72
8、说说struts1与struts2的区别。72
9、hibernate中的update()和saveOrUpdate()的区别，session的load()和get()的区别。72
10、简述Hibernate和JDBC的优缺点如何书写一个onetomany配置文件.72
11、iBatis与Hibernate有什么不同72
12、写Hibernate的一对多和多对一双向关联的orm配置hibernate的inverse属性的作用73
13、在DAO中如何体现DAO设计模式73
14、Spring+Hibernate中委托方案怎么配置73
15.hibernate进行多表查询每个表中各取几个字段，也就是说查询出来的结果集没有一个实体类与之对应如何解决；73
16.介绍一下Hibernate的二级缓存74
17、Spring的依赖注入是什么意思给一个Bean的message属性,字符串类型,注入值为"Hello"的XML配置文件该怎么写74
18、JDO是什么74
19、什么是spring的AOP75
20、Struts的工作流程！75
21、Spring与EJB的区别75
八.软件工程与设计模式75
1、UML方面75
2、j2ee常用的设计模式？说明工厂模式。75
3、开发中都用到了那些设计模式用在什么场合75
九.j2ee部分76
1、BS与CS的联系与区别。76
2、应用服务器与WEBSERVER的区别？77
3、应用服务器有那些？77
4、J2EE是什么？77
5、J2EE是技术还是平台还是框架？什么是J2EE77
6、请对以下在J2EE中常用的名词进行解释(或简单描述)77
7、如何给weblogic指定大小的内存78
8、如何设定的weblogic的热启动模式(开发模式)与产品发布模式78
9、如何启动时不需输入用户名与密码78
12、在weblogic中发布ejb需涉及到哪些配置文件78
13、如何在weblogic中进行ssl配置与客户端的认证配置或说说j2ee(标准)进行ssl的配置78
14、如何查看在weblogic中已经发布的EJB78
可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。
一个文件中可以只有非public类，如果只有一个非public类，此类可以跟文件名不同
java中的保留字，现在没有在java中使用。
&和&&都可以用作逻辑与的运算符，&&为短路与，&不是短路与。
另外&可以做为整数的位运算符
例1：对于if(str!=null&&!str.equals(“”))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException如果将&&改为&，则会抛出NullPointerException异常。
&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，
例2：If(x==33&++y>0)y会增长，if(x==33&&++y>0)不会增长
备注：这道题先说两者的共同点，再说出&&和&的特殊之处，并列举一些经典的例子来表明自己理解透彻深入、实际经验丰富。
1.Break+标签
2.直接使用Break
3.使用方法的return
在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break语句，即可跳出外层循环。例如，
ok:for(inti=0;i<10;i++){
for(intj=0;j<10;j++){
System.out.println("i="+i+",j="+j);
if(j==5)
breakok;
}
另外，我个人通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体代码的控制，例如，要在二维数组中查找到某个数字。
intarr[][]={{1,2,3},{4,5,6,7},{9}};
booleanfound=false;
for(inti=0;i for(intj=0;j if(arr[i][j]==5){ found=true; break; 第三种，使用方法的return privatestaticinttest(){ intcount=0; for(inti=0;i<10;i++){ count++; if(j==5){ returncount; return0; 作用在byte,short,char,int,enum 封装类对象和枚举，其它基本数据类型及引用数据类型都不能做为case的条件 对于shorts1=1;s1=s1+1;由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。 对于shorts1=1;s1+=1;由于+=是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。 char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字 补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。 2<<3 因为将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，所以，2乘以8等於几的最效率的方法是2<<3。 如果只是大整数运算，使用BigInteger就可以 如果有浮点数据参与去处，需要使用BigDecimal进行运算 Java中基本类型的浮点数运算是不精确的，需要使用BigDecimal运算，尤其是金融、会计方向的软件 引用变量不能重新赋值，但是引用指向的对象的内容可以变化 例1：finalStringBuffera=newStringBuffer("immutable"); a=newStringBuffer(""); 有编译错 例2： finalStringBuffera=newStringBuffer("immutable"); a.append(“123”); 正确 他们的区别主要存在在引用数据类型上 ==为比较两侧的对象是否同一对象，是用内存地址来比较的 equals是方法，默认是用内存地址比较，重写后，主要是用来比较两侧的对象的值是否相同，和equals方法中的实现有关 ==可以两侧都为null，但equals左侧的引用指向的对象不能空，不然有NullPointerException 除非需要比较两个引用指向的对象是同一对象，一般都使用equals方法进行比较。尤其是String之类的值对象，另外，常量尽量放在比较的左侧 在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。 在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。 总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。 不可以。因为非static方法（实例方法）是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部发出对非static方法的调用。 int是java提供的8种原始数据类型之一，意思整型，占用4字节。 Integer是java为int提供的封装类，是引用数据类型。 int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况。 例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer 在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，所以用el表达式在文本框中显示时，结果为0，所以，int不适合作为web层的表单数据的类型。 在Hibernate中，如果将OID定义为Integer类型，那么Hibernate就可以根据其值是否为null而判断一个对象是否是临时的，如果将OID定义为了int类型，还需要在hbm映射文件中设置其unsaved-value属性为0。 Math类中提供了三个与取整有关的方法：ceil、floor、round，这些方法的作用与它们的英文名称的含义相对应，例如，ceil的英文意义是天花板，该方法就表示向上取整，Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11；floor的英文意义是地板，该方法就表示向下取整，Math.ceil(11.6)的结果为11,Math.ceil(-11.6)的结果是-12；最难掌握的是round方法，它表示“四舍五入”，算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。 1.if(username.equals(“zxx”){} username可能为null,会报空指针错误；改为"zxx".equals(username) 2.intx=1; returnx==1true:false;这个改成returnx==1;就可以! 这四个作用域的可见范围如下表所示。 说明：如果在修饰的元素上面没有写任何访问修饰符，则表示friendly/default。 作用域 当前类 同package 子孙类 其他package public √ protected × friendly/default private 备注：只要记住了有4种访问权限，4个访问范围，然后将全选和范围在水平和垂直方向上分别按排从小到大或从大到小的顺序排列，就很容易画出上面的图了。 Overload是重载的意思，Override是覆盖的意思，也就是重写。 Overload和Override有共同之处，两个方法的方法名都必须相同，如果不同，既不构成Overload，也不构成Override。 a)参数列表完全相同：个数相同、类型相同、顺序相同 b)子类的返回值不能比父类的返回值范围大 c)子类方法抛出的异常不能比父类方法抛出的异常范围大 d)修饰符只能为public、protected、friendly，不能为private e)父子类方法不能使用static修饰 构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。 接口可以继承接口；抽象类可以实现(implements)接口；抽象类可以继承具体类；抽象类中可以有静态的main方法；抽象类可有以内部类；接口可以有内部类，但必须是static内部类，但不一定是final的。 只有记住抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法。 clone有缺省行为，super.clone();因为首先要把类中的成员复制到位，然后才是复制自己的成员。 1.封装，隐藏内部实现，只暴露公共行为 2.继承，提高代码的重用性 3.多态，体现现实生活中相似对象的差异性 4.抽象，抽取现实世界中相似对象的共同点 通过继承父类或实现接口。 继承指子类继承父类的所有属性、方法、内部类。对于属性而言，如果子类的属性名和父类的属性名相同，则子类会把父类的属性隐藏。属性根据引用来调用，方法根据对象来调用；Java中只有单继承，一个子类只能直接继承一个父类。 实现指某类可以实现接口中的部分或所有方法，并能继承接口中的所有的属性和内部类。接口中的属性都为publicstaticfinal类型，方法都为public类型，内部类都为publicstatic类型。接口可以继承多个接口，实现类可以实现多个接口。 含有abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstractclass，abstractclass类中的方法不必是抽象的。abstractclass类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。 接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为publicabstract类型，接口中的成员变量类型默认为publicstaticfinal。 下面比较一下两者的语法区别： 1.抽象类可以有构造方法，接口中不能有构造方法。 2.抽象类中可以有普通成员变量，接口中没有普通成员变量 3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。 4.抽象类中的抽象方法的访问类型可以是public，protected和默认类型，但接口中的抽象方法只能是public类型的，并且默认即为publicabstract类型。 5.抽象类中可以包含静态方法，接口中不能包含静态方法 6.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是publicstaticfinal类型，并且默认即为publicstaticfinal类型。 7.一个类可以实现多个接口，但只能继承一个抽象类。 下面接着再说说两者在应用上的区别： 接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约； 而抽象类在代码实现方面发挥作用，可以实现代码的重用。 abstract的method不可以是static的，因为抽象的方法是要被子类实现的，而static与子类扯不上关系！ native方法表示该方法要用另外一种依赖平台的编程语言实现的，不存在着被子类实现的问题，所以，它也不能是抽象的，不能与abstract混用。 synchronized和abstract合用的问题不能共用，abstract方法只能存在于抽象类或接口中，它不能直接产生对象，而默认synchronized方法对当前对象加锁，没有对象是不能加锁。 另外synchronized不能被继承，子类继承时，需要另加修改符。 final方法和abstract不能共用，因为final是不能被子类重写的，而抽象方法必须被某级子类重写。 内部类就是在一个类的内部定义的类。内部可以定义在除参数位置上的任意位置。 1.静态内部类需要使用static修饰，而普通内部类不能使用static修饰 2.静态内部类只能定义在和属性同级，普通内部类可以定义在除参数位置以外的任意位置 3.静态内部类必需有名称，而普通内部类可以是匿名的 4.静态内部类没有this引用，只此只能访问外部类的静态成员，而普通内部类可以访问外部类的全部成员 5.静态内部类访问外部类的同名函数时，使用“外部类名.方法名”即可，而普通内部类需要使用“外部类名.this.外部方法” 6.静态内部类可以定义静态方法，而普通内部类不能定义静态方法，但能定义简单数据类型的静态属性，不能定义引用类型的静态属性。 1.如果内部类为静态内部类，只能调用外部类的静态成员；如果有重名成员，需要用“外部类名.成员名”访问；不能调用外部类的对象成员。 2.如果内部类为非静态内部类，则可以调用外部类的所有成员；如果有重名成员，需要使用“外部类名.this.成员名” 可以继承其他类或实现其他接口。不仅是可以，而是必须! 返回的Class对象是同一对象，都是子类的对象。final方法，不允许重写 基本数据类型包括byte、int、char、long、float、double、boolean和short。 String是引用数据类型。 java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer/StringBuilder类 没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。 s=s+"world!";相当于:(JDK1.5以上版本) s=newStringBuilder(String.valueOf(s)).append("world!").toString(); String类是final类故不可以继承。 两个对象。一个是"xyz"，为缓冲区对象。另一个是new出来的String对象。 这两个对象的值相同，但不是同一个对象。 补充，新建对象有几种方式？ 1.使用new关键字 2.使用反射，调用newInstance 3.使用clone方法 4.使用序列化与反序列化 5.动态代理(Proxy类和CGLIB) 这两个类都实现了CharSequence接口。 1.类型不同，因为不是一个类，也没有继承关系，做参数时不能共用 2.String对象是不可变对象，不能修改值。而StringBuffer是可变对象，能修改值。 3.拼接字符串时，String会产生新对象，而StringBuffer只是增加新字符，不产生新对象，因此效率高。 4.String覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和hashCode方法，所以，将StringBuffer对象存储进Java集合类中时会出现问题。 相同之处，这两类都是可变长的字符串存储类，都实现了CharSequence接口 2.StringBuffer为线程安全类，StringBuilder为线程非安全类 3.StringBuffer性能低，StringBuilder性能高，如果在局部优先使用StringBuilder 4.JDK在1.5之前，字符串相加使用StringBuffer对象，在1.5之后使用StringBuilder对象 StringTokenizertokener=newStringTokenizer(s,","); String[]result=newString[tokener.countTokens()]; Integeri=0; while(tokener.hasMoreTokens()){ result[i++]=tokener.nextToken(); intindex=-1; intoldIndex=0; List while((index=s.indexOf(',',index+1))!=-1){ ss.add(s.substring(oldIndex,index)); oldIndex=index+1; if(s.charAt(s.length()-1)==','){ ss.add(""); String[]array=ss.toArray(newString[ss.size()]); System.out.println(Arrays.toString(array)); 数组没有length()这个方法，有length的属性。String有有length()这个方法。JS中只有length属性，没有length方法。 答：产生了一个对象，即"abcd" 对于如下代码： Strings1="a"; Strings2=s1+"b"; Strings3="a"+"b"; System.out.println(s2=="ab");//false System.out.println(s3=="ab");//true Strings="a"+"b"+"c"+"d"; System.out.println(s=="abcd");//trues被优化为”abcd” 也许你的答案是在return之前，但往更细地说，我的答案是在return中间执行，请看下面程序代码的运行结果： publicclassTest{ publicstaticvoidmain(String[]args){ System.out.println(test()); staticinttest(){ intx=1; try{ returnx; finally{ ++x; ---------执行结果--------- 1 运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。 publicclassSmallT{ publicstaticvoidmain(Stringargs[]){ SmallTt=newSmallT(); intb=t.get(); System.out.println(b); publicintget(){ return1; }finally{ return2; 返回的结果是2。 我可以通过下面一个例子程序来帮助我解释这个答案，从下面例子的运行结果中可以发现，try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行，所以，返回的结果是2。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。 在讲解答案时可以用下面的程序来帮助分析： System.out.println(newTest().test()); inttest(){ returnfunc1(); returnfunc2(); intfunc1(){ System.out.println("func1"); intfunc2(){ System.out.println("func2"); -----------执行结果----------------- func1 func2 2 结论：finally中的代码比return和break语句后执行 内部类要访问局部变量，局部变量必须定义成final类型 finalint[]number={20}; newThread(){ @Override publicvoidrun(){ for(intk=0;k<20;k++){ number[0]++; }.start(); Thread.sleep(10); System.out.println(number[0]); finally是异常处理语句结构的一部分，表示总是执行，用来释放资源。 finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用 运行时异常为编程时的异常，应该在生产环境正常运行状态下不会发生的异常 检查异常通常为一种设计模式，表示某处执行时可能因为条件不足而出现异常，程序必须对此进行处理，JVM会提示编程人员捕获或重新抛出异常 error表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出，不可能指望程序能处理这样的情况。exception表示一种设计或实现问题，也就是说，它表示如果程序运行正常，正常情况下从不会发生的情况。 异常是指java程序运行时（非编译）所发生的非正常情况或错误。 Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象中，该对象中包含有异常的信息。 Java可以自定义异常类，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception。 提示答题者：就按照三个级别去思考：虚拟机必须宕机的错误，程序可以死掉也可以不死掉的错误，程序不应该死掉的错误 NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException、IllegelArgumentException、SecurityException。 throw程序出错时，手工抛出异常，最好能把异常进行堆栈式抛出 try尝试执行，里面的语句可能出现异常，如出现异常需要处理 catch处理try中出现的异常 finally在try后执行清理操作，用于释放资源 java5以前，有如下两种： 第一种： newThread(){}.start();这表示调用Thread子类对象的run方法，newThread(){}表示一个Thread的匿名子类的实例对象，子类加上run方法后的代码如下： 第二种： newThread(newRunnable(){}).start();这表示调用Thread对象接受的Runnable对象的run方法，newRunnable(){}表示一个Runnable的匿名子类的实例对象,runnable的子类加上run方法后的代码如下： newThread(newRunnable(){ }).start(); 从Java5开始，还有如下一些线程池创建多线程的方式： ExecutorServicepool=Executors.newFixedThreadPool(3); pool.execute(newRunable(){ }); Executors.newCachedThreadPool().execute(newRunable(){ Executors.newSingleThreadExecutor().execute(newRunable(){ 有两种实现方法，分别使用newThread()和newThread(runnable)形式，第一种直接调用thread的run方法，所以，我们往往使用Thread子类，即newSubThread()。第二种调用runnable的run方法。 1.sleep是在Thread类定义的，wait是在Object类定义的 2.sleep有两个重载方法，wait有三个重载方法 3.sleep能自动唤醒，wait有参数的方法能自动唤醒，但无参数的重载方法不能自动唤醒，需要使用notify/notifyAll进行手动唤醒 4.sleep挂起时，不释放锁资源，wait挂起时，会释放锁资源 5.sleep调用时，不需要放在synchronized内，wait需要放在synchronized内 6.sleep一般不会产生死锁，但是wait可能会产生死锁 同步是指所有操作串行化执行，顺序不能改变，前一操作未完成，后个操作不执行。 异步是指所有操作可以并行执行，顺序无关。 例如寄信 同步：如果没有寄完，不能吃饭，邮递员10天后送到，发送人被饿死 异步：寄出后可以立即吃饭，邮递员送完后，通知发送人送信结果。 如果强调执行顺序的话，用同步。如果顺序无关，则可以用异步。 异步执行效率比同步高。该用同步时，如果用了异步，结果可能会出现不一致。 classTest{ synchronizedstaticvoidsayHello3(){ synchronizedvoidgetX(){ 多线程有两种实现方法，分别是继承Thread类与实现Runnable接口 同步的实现方面有五种，分别是synchronized、wait与notify、sleep、suspend、join synchronized:一直持有锁，直至执行结束 wait():使一个线程处于等待状态，并且释放所持有的对象的lock，需捕获异常。 sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，需捕获异常，不释放锁。 notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。 notityAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。 启动一个线程是调用start()方法，使线程就绪状态，以后可以被调度为运行状态，一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。 如果其它方法中使用当前对象作为锁对象，则不能； 如果其它方法中没有使用当前对象作为锁对象，则能。 在多任务操作系统中，为了提高CPU的利用率，可以使用多进程编程。但对进程通信比较困难，进程间数据不能共享，因此可以使用多线程编程。一个进程至少包含一个主入口线程。 主要相同点：Lock能完成synchronized所实现的所有功能 主要不同点： 举例说明（对下面的题用lock进行了改写）： packagecom.huawei.interview; importjava.util.concurrent.locks.Lock; importjava.util.concurrent.locks.ReentrantLock; publicclassThreadTest{ privateintj; privateLocklock=newReentrantLock(); ThreadTesttt=newThreadTest(); for(inti=0;i<2;i++){ newThread(tt.newAdder()).start(); newThread(tt.newSubtractor()).start(); privateclassSubtractorimplementsRunnable{ while(true){ lock.lock(); System.out.println("j--="+j--); lock.unlock(); privateclassAdderimplementsRunnable{ System.out.println("j++="+j++); 以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。 publicclassThreadTest1{ ThreadTest1tt=newThreadTest1(); Incinc=tt.newInc(); Decdec=tt.newDec(); Threadt=newThread(inc); t.start(); t=newThread(dec); privatesynchronizedvoidinc(){ j++; System.out.println(Thread.currentThread().getName()+"-inc:"+j); privatesynchronizedvoiddec(){ j--; System.out.println(Thread.currentThread().getName()+"-dec:"+j); classIncimplementsRunnable{ for(inti=0;i<100;i++){ inc(); classDecimplementsRunnable{ dec(); publicstaticvoidmain(String[]args)throwsException{ for(inti=0;i<50;i++){ MainThreadmain=newMainThread(); main.start(); main.join(); classMainThreadextendsThread{ SubThreadsub=newSubThread(); sub.start(); sub.join(); }catch(InterruptedExceptione){ //LOG System.out.println("main:"+i); classSubThreadextendsThread{ System.out.println("sub:"+i); Iterable（顺序表） àCollection（他下面可以装东西） àList（是collection下面的接口）可以重 àArrayList（局部变量用这个合适） àLinkedList（是一个链表，按顺序连接） àVector（它是一个类，叫做向量，也算一种list，唯一区别是跟线程同步） àStack（栈（）） àSet（是collection下面的接口）不可以重（无序的， àHashSet àSortedSet（它是一个接口） àTreeSet（是用treeMap实现的）（value不重要Key重要） Map（无序的，放进去取出来不同）（在数学上是集合，是一个元素元素不能又重的） àSortedMap（ àTreeMap àHashtable（跟它的区别）（它是旧实现因为跟线程同步，另外它用的旧接口便利用invtion便利） àProperties àHashMap àLinkedHashMap Collections，不属于集合，是集合类的工具类 Arrays，不属于集合类，是数据对象的工具类 Comparable/Comparator 1.线程同步，Vector线程安全，ArrayList线程不安全 2.效率问题，Vector效率低，ArrayList效率高 3.增长数量，Vector以1.5倍增长，ArrayList以2倍增长 1.线程同步，Hashtable线程安全，HashMap线程不安全 2.效率问题，Hashtable效率低，HashMap效率高 3.HashMap可以使用null作为key，Hashtable不可以使用null为key 4.HashMap使用的是新实现，继承AbstractMap，而Hashtable是继承Dictionary类，实现比较老 5.Hash算法不同，HashMap的hash算法比Hashtable的hash算法效率高 6.HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey。因为contains方法容易让人引起误解。 7.取值不同，HashMap用的是Iterator接口，而Hashtable中还有使用Enumeration接口 一个是存储单列数据的集合，另一个是存储键和值的双列数据的集合，List中存储的数据是有顺序，并且允许重复；Map中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的。 List、Set是，Map不是 List使用get(index)取值，也可以使用Iterator、toArray取值 Set只能通过Iterator、toArray取值 Map取值使用get(key)取值，也可以使用keySet取键值集合，也可使用values取值集合，entrySet取全部键值对映射。 1.ArrayList和Vector使用数组存储元素；LinkedList使用链表存储元素 2.ArrayList和Vector插入删除数据时，需要搬运数据，效率较差；LinkedList使用链表，不需要搬运数据，效率高 3.ArrayList和Vectory查询时，按数组下标查询，不需要遍历，效率高；LinkedList需要遍历，查询效率底 4.ArrayList和Vector的区别见59条 1.自行遍历，用另外一个Vector来判断是否有重复 2.用Set(TreeSet或HashSet)来去重 3.用Apache的CollectionUtil工具类去重 VectornewVector=newVector(); for(inti=0;i Objectobj=vector.get(i); if(!newVector.contains(obj)) newVector.add(obj); 还有一种简单的方式，HashSetset=newHashSet(vector); Collection是集合类的上级接口，继承与他的接口主要有Set和List. Collections是针对集合类的一个工具类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。 Set里的元素是不能重复的，元素重复与否视具体情况而定： 1.HashSet使用equals比较 2.TreeSet使用compareTo进行比较 最常用的集合类接口是List和Map。 List的具体实现包括ArrayList、Vector、LinkedList，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。List适用于按数值索引访问元素的情形。 Set的具体实现包括HashSet和TreeSet，它们也是可变大小集合，但不适合用索引取值。 Map提供了一个更通用的元素存储方法。Map集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。 ArrayList/Vector、LinkedList HashSet/TreeSet Properties/HashTable/TreeMap/HashMap List的主要方法有： add、get、remove、set、iterator、contains、addAll、removeAll、indexOf、toArray、clear、isEmpty Set的主要方法有： add、remove、iterator、contains、addAll、removeAll、toArray、clear、isEmpty Map的主要方法有： put、get、keySet、values、entrySet、clear、remove、isEmpty 1.equals等，hashCode同，因此重写equals方法必须重写hashCode 2.hashCode等，equals不一定同，但hashCode最好散列化 3.任何对象equalsnull都得false 4.没有继承关系的两个类，equals都得false 5.重写equals方法的类最好是值类，即不可变 6.如果A对象equalsB对象，B对象equalsC对象，则A对象equalsC对象 1.如果子类重新实现了Comparable，且比较时全部使用父类的引用和属性，则不会出错 2.如果子类重新实现了Comparable，且比较时使用了子类的引用和属性，出异常 3.子类没有重新实现Comparable，则不会了出错。 用哪个对象比较，则调用哪个对象的comparaTo方法 要让人家感觉你对JavaEE开发很熟，所以，不能仅仅只列corejava中的那些东西，要多列你在做ssh项目中涉及的那些东西。就写你最近写的那些程序中涉及的那些类。 常用的类：BufferedReader，BufferedWriter，FileReader，FileWirter，String，Integer， java.util.Date，System，Class，List，HashMap 常用的包：java.lang，java.io，java.util，java.sql，javax.servlet，org.apache.strtuts.action，org.hibernate,org.springframework 常用的接口：List，Map，Document，NodeList，Servlet，HttpServletRequest，HttpServletResponse，HttpSession，Action(Struts)，Transaction(Hibernate)，Session(Hibernate)，ApplicationContext(Spring)，FactoryBean(Spring) 字节流，字符流。字节流继承于InputStream、OutputStream，字符流继承于Reader、Writer。在java.io包中还有许多其他的流，主要是为了提高性能和使用方便。 FileInputStream、FileReader、ByteArrayInputStream、CharArrayReader、BufferedInputStream、BufferedReader、ZipInputStream、PrintStream、StringReader、ObjectInputStream、RandomAccessFile(不属于流，但像流) 字节流是按字节读取或写入设备，但字符流是以字符为单位读取或写入设备。 如果是二进制文件，需要用字节流读取。一般来说，字符流只处理文本文件。在设备中，大多数情况是以字节形式存储数据的，因此字符流通过需要传入字节流当参数。 序列化是把内存Java对象保存到存储介质中，反序列化就是把存储介质中的数据转化为Java对象。Java通过ObjectInputStream和ObjectOutputStream实现序列化和反序列化。需要进行序列化的对象的类必须实现Serializable接口，通常情况下需要满足以下条件： 1.强烈建议手动生成serialVersionUID常量 2.如果需要加解密的话，需要实现两个方法readObject和writeObject方法 3.如果使用Hibernate二级缓存或其它缓存服务器的话，对象必须是可序列化的 4.如果需要远程调用对象或传值的话，则对像需要序列化 5.序列化类的可序列化成员必须也是可序列化的，不需要序列化的属性用transient修饰 1.查找当前ClassLoader中是否有此class的类对象，有则返回 2.若没有的话，向上递归所有的父ClassLoader中有无此class类对象，有则返回 3.若还没有，查找BootstrapClassLoader中有无此class类对象，有则返回 4.若还没有的话，使用findClass或resolveClass加载类对象 a.读取class二进制文件 b.根据字节数组生成Class对象 c.缓存到当前ClassLoader中 JVM加载class对象是懒加载，按需加载 Java的内存分为两类，一类是栈内存，一类是堆内存。 栈中存储的是当前线程的方法调用、基本数据类型和对象的引用，栈是有序的。 堆中存储的是对象，堆是无序的。 方法中的局部变量使用final修饰后，放在堆中，而不是栈中。 GC是垃圾回收的意思(GabageCollection)，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。线程对象在没有终止前，即使没有任何引用，也不会被垃圾回收。 只能建议JVM回收内存，不能强制，可以使用System.gc()建议执行。 GC有三种方式，串行回收、并行回收、混合回收。 对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。 assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，assert将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。 会，原因： 如果对象被集合类引用时，如果只是添加，而不删除，会引起内存泄漏，严重时会发出内存溢出。 Java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露 内存泄露的另外一种情况：当一个对象被存储进HashSet或HashMap中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，造成内存泄露。 可以，如果非要实现java.lang.String，需要自已写ClassLoader，不然JVM优先加载默认rt.jar中的java.lang.String。 可以，但在应用的时候，需要用自己的类加载器去加载，否则，系统的类加载器永远只是去加载rt.jar包中的那个java.lang.String。由于在tomcat的web应用程序中，都是由webapp自己的类加载器先自己加载WEB-INF/classess目录中的类，然后才委托上级的类加载器加载，如果我们在tomcat的web应用程序中写一个java.lang.String，这时候Servlet程序加载的就是我们自己写的java.lang.String，但是这么干就会出很多潜在的问题，原来所有用了java.lang.String类的都将出现问题。 虽然java提供了endorsed技术，可以覆盖jdk中的某些类，但是，能够被覆盖的类是有限制范围，反正不包括java.lang这样的包中的类。 （下面的例如主要是便于大家学习理解只用，不要作为答案的一部分，否则，人家怀疑是题目泄露了）例如，运行下面的程序： packagejava.lang; publicclassString{ System.out.println("string"); 报告的错误如下： java.lang.NoSuchMethodError:main Exceptioninthread"main" 这是因为加载了jre自带的java.lang.String，而该类中没有main方法。 1. abstractclassName{ privateStringname; publicabstractbooleanisStupidName(Stringname){} 大侠们，这有何错误 答案:错。abstractmethod必须以分号结尾，且不带花括号。 2. publicclassSomething{ voiddoSomething(){ privateStrings=""; intl=s.length(); 有错吗 答案:错。局部变量前不能放置任何访问修饰符(private，public，和protected)。final可以用来修饰局部变量 (final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。 3. abstractclassSomething{ privateabstractStringdoSomething(); 这好像没什么错吧 答案:错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract method封锁起来呢(同理，abstractmethod前不能加final)。 4. publicintaddOne(finalintx){ return++x; 这个比较明显。 答案:错。intx被修饰成final，意味着x不能在addOnemethod中被修改。 5. Othero=newOther(); newSomething().addOne(o); publicvoidaddOne(finalOthero){ o.i++; classOther{ publicinti; 和上面的很相似，都是关于final的问题，这有错吗 答案:正确。在addOnemethod中，参数o被修饰成final。如果在addOnemethod里我们修改了o的reference (比如:o=newOther();)，那么如同上例这题也是错的。但这里修改的是o的membervairable (成员变量)，而o的reference并没有改变。 6. classSomething{ inti; publicvoiddoSomething(){ System.out.println("i="+i); 有什么错呢看不出来啊。 答案:正确。输出的是"i=0"。inti属於instantvariable(实例变量，或叫成员变量)。instantvariable有defaultvalue。int的defaultvalue是0。 7. finalinti; 和上面一题只有一个地方不同，就是多了一个final。这难道就错了吗 答案:错。finalinti是个final的instantvariable(实例变量，或叫成员变量)。final的instantvariable没有defaultvalue，必须在constructor(构造器)结束之前被赋予一个明确的值。可以修改为"finalinti=0;"。 8. Somethings=newSomething(); System.out.println("s.doSomething()returns"+doSomething()); publicStringdoSomething(){ return"Dosomething..."; 看上去很完美。 答案:错。看上去在main里calldoSomething没有什么问题，毕竟两个methods都在同一个class里。但仔细看，main是static的。staticmethod不能直接callnon-staticmethods。可改成"System.out.println("s.doSomething()returns"+s.doSomething());"。同理，staticmethod不能访问non-staticinstantvariable。 9. 此处，Something类的文件名叫OtherThing.java privatestaticvoidmain(String[]something_to_do){ System.out.println("Dosomething..."); 这个好像很明显。 答案:正确。从来没有人说过Java的Class名字必须和其文件名相同。但publicclass的名字必须和文件名相同，如果main方法是public，则为程序的入口方法，而为private只是普通的静态方法而已。 10． interfaceA{ intx=0; classD{ intx=2; classBextendsD{ classCextendsBimplementsA{ publicvoidpX(){ System.out.println(super.x); newC().pX(); 11. interfacePlayable{ voidplay(); interfaceBounceable{ interfaceRollableextendsPlayable,Bounceable{ Ballball=newBall("PingPang"); classBallimplementsRollable{ publicStringgetName(){ returnname; publicBall(Stringname){ this.name=name; publicvoidplay(){ ball=newBall("Football"); System.out.println(ball.getName()); 这个错误不容易发现。 Spring是一个容器，可以把Struts的Action对象和Hibernate的SessionFactory对象、事务管理器管理起来，负责这些对象的生命周期，包括对象的创建、装载、销毁，从而使开发人员只去实现具体的业务逻辑。具体集成方式如下： 1.在web.xml中配置struts的servlet或filter入口类，同时在web.xml中配置spring的listener和配置文件路径 2.引用SSH所需的jar包放在WEB-INF/lib下，需要有struts-spring-plugin.jar 3.在struts.xml配置中，把Struts的Action类交由Spring托管 4.把Hibernate所需的DataSource、SessionFactory、TranscationManager、HibernateTemplate配置在Spring的配置文件中 5.Dao层的类有时需要继承HiberateDaoSupport类，如果有HibernateTemplate时，可以不继承 6.把Action、Service、Dao等对象注册到Spring中管理 packagecom.bwie.interview; importjava.io.IOException; importjava.io.InputStreamReader; importjava.io.PrintStream; importjava.util.StringTokenizer; publicclassAnswerB01{ publicstaticvoidmain(String[]args)throwsIOException{ StringTokenizertokenizer1=getTokenzer("/a.txt"); StringTokenizertokenizer2=getTokenzer("/b.txt"); PrintStreamout=newPrintStream("C:/c.txt"); while(tokenizer1.hasMoreTokens()&&tokenizer2.hasMoreTokens()){ out.println(tokenizer1.nextToken()); out.println(tokenizer2.nextToken()); out.close(); privatestaticStringTokenizergetTokenzer(StringfileName)throwsIOException{ InputStreamReaderreader=newInputStreamReader(AnswerB01.class.getResourceAsStream(fileName)); StringBuilderbuilder=newStringBuilder(1000); intlength=-1; char[]cs=newchar[1024]; while((length=reader.read(cs))!=-1){ builder.append(cs,0,length); reader.close(); returnnewStringTokenizer(builder.toString()); 答：listFiles方法接受一个FileFilter对象，这个FileFilter对象就是过虑的策略对象，不同的人提供不同的FileFilter实现，即提供了不同的过滤策略。 importjava.io.File; importjava.io.FileInputStream; importjava.io.FileOutputStream; importjava.io.FilenameFilter; publicclassAnswerB02{ FilesourceFolder=newFile("D:/java"); File[]files=sourceFolder.listFiles(newJavaFileFilter()); for(Filefile:files){ StringabsolutePath=file.getName(); StringtargetFile="D:/jad/"+absolutePath.substring(0,absolutePath.length()-5)+".jad"; copy(file,newFile(targetFile)); privatestaticvoidcopy(Filesource,Filetarget)throwsIOException{ FileInputStreaminput=newFileInputStream(source); FileOutputStreamout=newFileOutputStream(target); byte[]bs=newbyte[1024]; while((length=input.read(bs))!=-1){ out.write(bs,0,length); input.close(); privatestaticfinalclassJavaFileFilterimplementsFilenameFilter{ publicbooleanaccept(Filedir,Stringname){ returnname.endsWith(".java"); publicclassAnswerB03{ Strings="我ABC汉DEF"; System.out.println(substring(s,6)); publicstaticStringsubstring(Strings,intlength){ char[]cs=s.toCharArray(); StringBuilderbuilder=newStringBuilder(); for(charc:cs){ if(isAsc(c)){ }else{ count+=2; if(count>length){ builder.append(c); returnbuilder.toString(); publicstaticbooleanisAsc(charc){ returnc<128; 答：哈哈，其实包含中文字符、英文字符、数字字符原来是出题者放的烟雾弹。 Stringcontent="中国aadf的111萨bbb菲的zz萨菲"; HashMap for(inti=0;i charc=content.charAt(i); Integercount=map.get(c); if(count==null){ count=0; count=count+1; map.put(c,count); Set for(Entryentry:entries){ system.out.println(entry.getkey()+":"+entry.getValue()); 如果一串字符如"aaaabbc中国1512"要分别统计英文字符的数量，中文字符的数量，和数字字符的数量，假设字符中没有中文字符、英文字符、数字字符之外的其他特殊字符。 intengishCount; intchineseCount; intdigitCount; for(inti=0;i charch=str.charAt(i); if(ch>='0'&&ch<='9'||ch=='.'){ digitCount++; }elseif((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')){ engishCount++; chineseCount++; 这是组合设计模式。 我有很多个(假设10万个)数据要保存起来，以后还需要从保存的这些数据中检索是否存在某个数据，（我想说出二叉树的好处，该怎么说呢？那就是说别人的缺点），假如存在数组中，那么，碰巧要找的数字位于99999那个地方，那查找的速度将很慢，因为要从第1个依次往后取，取出来后进行比较。平衡二叉树（构建平衡二叉树需要先排序，我们这里就不作考虑了）可以很好地解决这个问题，但二叉树的遍历（前序，中序，后序）效率要比数组低很多，原理如下图： 代码如下： publicclassAnswerB04{ Noderoot=makeupTree(); traverse(root); privatestaticvoidtraverse(Nodenode){ if(node==null){ return; traverse(node.left); System.out.println(node.value); traverse(node.right); }//11112021222 privatestaticNodemakeupTree(){ Noderoot=newNode(0); Nodenode1=newNode(1); Nodenode2=newNode(2); Nodenode11=newNode(11); Nodenode12=newNode(12); Nodenode21=newNode(21); Nodenode22=newNode(22); root.left=node1; root.right=node2; node1.left=node11; node1.right=node12; node2.left=node21; node2.right=node22; returnroot; publicstaticclassNode{ publicNodeleft; publicNoderight; publicintvalue; publicNode(intvalue){ this.value=value; 1,张三,28 2,李四,35 3,张三,28 4,王五,35 5,张三,28 6,李四,35 7,赵六,28 8,田七,35 importjava.io.BufferedReader; importjava.util.ArrayList; importjava.util.Collections; importjava.util.HashMap; importjava.util.List; importjava.util.Map; importjava.util.Set; publicclassAnswerB06{ BufferedReaderreader=newBufferedReader(newInputStreamReader(newFileInputStream("/person.txt"))); Map Stringline=null; while((line=reader.readLine())!=null){ String[]segments=line.split(",",-1); Stringname=segments[1]; Integercount=nameMap.get(name); nameMap.put(name,count); List Set for(Stringname:names){ PersonCountpersonCount=newPersonCount(); personCount.name=name; personCount.count=nameMap.get(name); personCounts.add(personCount); Collections.sort(personCounts); for(PersonCountpersonCount:personCounts){ System.out.println(personCount.name+"="+personCount.count); staticclassPersonCountimplementsComparable publicStringname; publicintcount; publicintcompareTo(PersonCounto){ returncount-o.count; 第一种：饱汉模式 publicclassSingleTon{ privateSingleTon(){ //实例化放在静态代码块里可提高程序的执行效率，但也可能更占用空间 privatefinalstaticSingleToninstance=newSingleTon(); publicstaticSingleTongetInstance(){ returninstance; 第二种：饥汉模式 privatestaticSingleToninstance; publicstaticsynchronizedSingleTongetInstance(){ if(instance==null){ instance=newSingleTon(); 第三种：用枚举 publicenumSingleTon{ ONE; 第四种，双重校验： synchronized(SingleTon.class){ 其他形式: 定义一个类，它的构造函数为private的，所有方法为static的。 一般认为第一种形式要更加安全些 一个整数，大于0，不用循环和本地变量，按照n，2n，4n，8n的顺序递增，当值大于5000时，把值按照指定顺序输出来。 例：n=1237 则输出为： 9896， 4948， 2474， 1237， 提示：写程序时，先致谢按递增方式的代码，写好递增的以后，再增加考虑递减部分。 publicstaticvoiddoubleNum(intn){ if(n<=5000) doubleNum(n*2); System.out.println(n); 第1个人10，第2个比第1个人大2岁，依次递推，请用递归方式计算出第8个人多大？ packagecn.itcast; importjava.util.Date; publicclassA1{ System.out.println(computeAge(8)); publicstaticintcomputeAge(intn){ if(n==1) return10; returncomputeAge(n-1)+2; publicstaticvoidtoBinary(intn,StringBufferresult){ if(n/2!=0) toBinary(n/2,result); result.append(n%2); 排序算法有： 冒泡排序、插值排序、选择排序、HASH排序、快速排序 冒泡排序： publicstaticvoidbubbleSort(int[]array){ for(inti=1;i for(intj=0;j if(array[i] inttemp=array[i]; array[i]=array[j]; array[j]=temp; 快速排序： publicclassQuickSort{ publicvoidquickSort(String[]strDate,intleft,intright){ Stringmiddle,tempDate; inti,j; i=left; j=right; middle=strDate[(i+j)/2]; do{ while(strDate[i].compareTo(middle)<0&&i i++;//找出左边比中间值大的数 while(strDate[j].compareTo(middle)>0&&j>left) j--;//找出右边比中间值小的数 if(i<=j){//将左边大的数和右边小的数进行替换 tempDate=strDate[i]; strDate[i]=strDate[j]; strDate[j]=tempDate; i++; }while(i<=j);//当两者交错时停止 if(i quickSort(strDate,i,right); if(j>left){ quickSort(strDate,left,j); String[]strVoid=newString[]{"11","66","22","0","55","22","0","32"}; QuickSortsort=newQuickSort(); sort.quickSort(strVoid,0,strVoid.length-1); for(inti=0;i System.out.println(strVoid[i]+""); publicclassAnswerB11{ int[]array={2,25,21,63,234,83}; reverse(array); privatestaticvoidreverse(int[]array){ for(inti=0;i array[i]=array[array.length-1-i]; array[array.length-1-i]=temp; publicclassAnswerB12{ privatestaticfinalchar[]data=newchar[]{'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'}; privatestaticfinalchar[]units=newchar[]{'元','拾','佰','仟','万','拾','佰','仟','亿'}; System.out.println(toUpcaseMoney(convert(100215))); privatestaticStringtoUpcaseMoney(Stringmoney){ returnnewStringBuilder(money).toString().replaceAll("零[拾佰仟]","零").replaceAll("零+万","万").replaceAll("零+元","元").replaceAll("零+","零"); publicstaticStringconvert(intmoney){ StringBuffersbf=newStringBuffer(); intunit=0; while(money!=0){ sbf.insert(0,units[unit++]); intnumber=money%10; sbf.insert(0,data[number]); money/=10; returnsbf.toString(); importjava.util.Stack; publicclassAnswerB13{ //两次pop Nodetree=makeupTree(); Stack NodecurrentNode=tree; while(currentNode!=null){ System.out.println(currentNode.value); stack.push(currentNode); currentNode=currentNode.left; Nodeparent=stack.pop(); currentNode=parent.right; if(currentNode==null){ if(stack.isEmpty()){ NodeparentParent=stack.pop(); currentNode=parentParent.right; //一次pop Stack Nodecurrent=tree; while(current!=null){ System.out.println(current.value); Nodeparent=current; current=current.left; if(current==null){ if(!nodeStack.isEmpty()){ NodeparentNode=nodeStack.pop(); current=parentNode.right; nodeStack.push(parent); publicclassQuestionB14{ int[]nums={1,2,7,4,6,9,5,3,65,23,87}; intmax1=Integer.MIN_VALUE; intmax2=Integer.MIN_VALUE; for(inti=0;i intcurrent=nums[i]; if(current continue; if(current>max1){ max2=max1; max1=current; max2=current; System.out.println(max2); window.onload=function(){ //这么写是为了实现js代码与html代码的分离，当我修改js时，不能影响html代码。 document.getElementById("frm1").onsubmit=function(){ vard1=this.d1.value; vard2=this.d2.value; if(!verifyDate(d1)){ alert("第一个日期格式不对"); returnfalse; if(!verifyDate(d2)){ alert("第二个日期格式不对"); if(!compareDate(d1,d2)){ alert("第二个日期比第一日期小"); }; functioncompareDate(d1,d2){ vararrayD1=d1.split("-"); vardate1=newDate(arrayD1[0],arrayD1[1],arrayD1[2]); vararrayD2=d2.split("-"); vardate2=newDate(arrayD2[0],arrayD2[1],arrayD2[2]); returndate1>date2; functionverifyDate(d){ vardatePattern=/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2]\d|3[0-1])$/; returndatePattern.test(d);1 2 3 4 5 6 7 8 9 10