1、用String的方法将数据类型转换为String。
2、有一个不定长度的String，其中前面是字母，后边是数字,例如：”abcd123.456″,
要求写一个方法得到其中的数字以String的形式返回,数字保留小数点后两位，不四舍五入，截去多余小
数,例如：”abcd123.456″，得到”123.45″
如果数字没有小数点,要得到两位为0的小数，例如：”abcd123″，得到”123.00″.
答案如下:
1、String.valueOf(1.23)
2、 public String getString(String str){
String getNumber;
getNumber = str.replaceAll(“[a-z|A-Z]“, ”");
if(getNumber.indexOf(“.”) == -1){
getNumber = getNumber+”.00″;
} else {
if(getNumber.indexOf(“.”)== getNumber.length()-1){
getNumber = getNumber+”00″;
} else if (getNumber.indexOf(“.”)== getNumber.length()-2){
getNumber = getNumber+”0″;
} else {
getNumber = getNumber.substring(0, getNumber.indexOf(“.”)+3);
}
}
return getNumber;
}
—————————————————————-
1 面向对象的特征？
1）对象
对象是运行期的基本实体，它是一个封装了数据和操作这些数据的代码的逻辑实体。
2）类
类是具有相同类型的对象的抽象。一个对象所包含的所有数据和代码可以通过类来构造。
3）封装
封装是将数据和代码捆绑到一起，避免了外界的干扰和不确定性。对象的某些数据和代码可以是私有的，
不能被外界访问，以此实现对数据和代码不同级别的访问权限。
4）继承
继承是让某个类型的对象获得另一个类型的对象的特征。通过继承可以实现代码的重用：从已存在的类派
生出的一个新类将自动具有原来那个类的特性，同时，它还可以拥有自己的新特性。
5）多态
多态是指不同事物具有不同表现形式的能力。多态机制使具有不同内部结构的对象可以共享相同的外部接
口，通过这种方式减少代码的复杂度。
6）动态绑定
绑定指的是将一个过程调用与相应代码链接起来的行为。动态绑定是指与给定的过程调用相关联的代码只
有在运行期才可知的一种绑定，它是多态实现的具体形式。
7）消息传递
对象之间需要相互沟通，沟通的途径就是对象之间收发信息。消息内容包括接收消息的对象的标识，需要
调用的函数的标识，以及必要的信息。消息传递的概念使得对现实世界的描述更容易。
2 tomcat的内存的配置？
tomcat默认可以使用的内存为128MB，在较大型的应用项目中，这点内存是不够的，需要调大。
Unix下，在文件{tomcat_home}/bin/catalina.sh的前面，增加如下设置：
JAVA_OPTS=’-Xms【初始化内存大小】 -Xmx【可以使用的最大内存】’
需要把这个两个参数值调大。例如：
JAVA_OPTS=’-Xms256m -Xmx512m’
表示初始化内存为256MB，可以使用的最大内存为512MB
3 doGet() 和 doPost() 的区别？
doGet() 和 doPost() 接收两个参数：HttpServletRequest 请求和HttpServletResponse响应。
HTTP 协议要么通过在 URL 中放置参数来向 Web 服务器传递信息，要么独立于 URL 传递信息。第一种称
作 GET 命令，而第二种称作 POST 命令。GET 命令的优点是，URL 包含了检索请求信息所需的所有信息
。因此，可将其加入书签以便将来重新调用。而 POST 命令独立于 URL 发送附加信息，提供了更好的安
全性。当需要发送比较大量的信息时，该方法也更为合适。其缺点就是不能被加入书签。
4 常用的标准的sql语句？
增加: insert into tbl_emp(name,password,id) values(yxx,123,12);
删除:delete from tbl_emp where name= ”yxx”;
查询: select * from tbl_emp where name=”yxx”;
更新: update tbl_emp set name=”xiaoxin” where id = 12;
5 string 和 stringbuffer的区别?
它们都是处理字符串的类,但是它们有一个最大的区别,那就是,String对象是存储你不能改动的文本字符
串,相反,如果你希望改动,则应使用StringBuffer类作为替换.
６在jsp页面中如何传递对象?
request，session，application，cookie等
7 常用的集合类?
java.util 中的集合类包含 Java 中某些最常用的类。 最常用的集合类是 List 和 Map。 List 的具体
实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元
素列表。 List 适用于按数值索引访问元素的情形。
Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作“键”和“值”），其中每
个键映射到一个值。 从概念上而言，您可以将 List 看作是具有数值键的 Map。 而实际上，除了 List
和 Map 都在定义 java.util 中外，两者并没有直接的联系。本文将着重介绍核心 Java 发行套件中附带
的 Map，同时还将介绍如何采用或实现更适用于您应用程序特定数据的专用 Map。
8 常出现的异常?
9 经常使用的包,接口,类 请各举出5个?
10 接口和抽象类的区别?
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行
为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以
创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态
方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，
在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的
接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量
。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即
将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。
由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类
型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。
11 动态include()和静态include()的区别?
12 servlet的生命周期?(介绍过———————————)
13 struts的原理?
14 数据连接池的原理?
连接池允许我们通过一个缓冲池重用现有的连接对象，避免每次使用连接对象时都要新建一个对象。采用
连接池之后，只要少量的连接对象就可以满足大量客户端的需要。
每一个连接池都与一个独立的连接字符串及其事务上下文关联。每次打开一个新的连接，数据提供者
会尝试将指定的连接字符串与连接池的字符串进行匹配。如果匹配失败，数据提供者创建一个新的连接并
将它加入连接池。连接池被创建之后，除非进程结束，否则不会被拆除。有人认为这种处理方式会影响性
能，其实不然，维护一个不活动的或者空的连接池不需要多少开销。
连接池创建之后，系统会创建一些连接对象并将它们加入连接池，直至达到额定的最小连接对象数量
。以后，系统会根据需要新建和加入连接对象，一直到达最大连接对象数量限额为止。如果程序请求一个
连接对象时没有空闲的连接对象可用，且连接池里面的对象数量已达到上限，则请求被放入队列，一旦有
连接被释放回缓冲池就立即取出使用。
避免用编程的方式构造连接字符串。如果通过合并多个输入数据的方式构造出连接字符串，很容易给
注入式攻击以可乘之机。如果必须用到用户输入的数据，务必进行严格的验证。
15 j2ee的设计模式?
Session Facade Pattern：使用SessionBean访问EntityBean
Message Facade Pattern：实现异步调用
EJB Command Pattern：使用Command JavaBeans取代SessionBean，实现轻量级访问
Data Transfer Object Factory：通过DTO Factory简化EntityBean数据提供特性
Generic Attribute Access：通过AttibuteAccess接口简化EntityBean数据提供特性
Business Interface：通过远程（本地）接口和Bean类实现相同接口规范业务逻辑一致性
16 线程的同步方法?(介绍过——————————————–)
17 四种会话跟踪技术?
会话作用域ServletsJSP 页面描述
page否是代表与一个页面相关的对象和属性。一个页面由一个编译好的 Java servlet 类（可以带有任何
的 include 指令，但是没有 include 动作）表示。这既包括 servlet 又包括被编译成 servlet 的 JSP
页面
request是是代表与 Web 客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多
个 Web 组件（由于 forward 指令和 include 动作的关系）
session是是代表与用于某个 Web 客户机的一个用户体验相关的对象和属性。一个 Web 会话可以也经常
会跨越多个客户机请求
application是是代表与整个 Web 应用程序相关的对象和属性。这实质上是跨越整个 Web 应用程序，包
括多个页面、请求和会话的一个全局作用域
18 解释 forward include和redirect的不同?
forward与include共亨Request范围内的对象,而redirect则不行，即：如果一个javabean被声明为
request范围的话，则被forward到的资源也可以访问这个javabean,而redriect则不行。
forward与include基本上都是转发到context内部的资源，而redirect可以重定向到外部的资源,如：
req.sendRedriect(“http://www.mocuai.com“);
19 jsp的内值对象?
request 用户端请求，此请求会包含来自GET/POST请求的参数
response 网页传回用户端的回应
pageContext 网页的属性是在这里管理
session 与请求有关的会话期
application servlet 正在执行的内容
out 用来传送回应的输出
config servlet的构架部件
page JSP网页本身
exception 针对错误网页，未捕捉的例外
20 EJB的角色和三个对象
EJB角色主要包括Bean开发者 应用组装者 部署者 系统管理员 EJB容器提供者 EJB服务器提供者
三个对象是Remote（Local）接口、Home（LocalHome）接口，Bean类
ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException,
CannotRedoException, CannotUndoException, ClassCastException, CMMException,
ConcurrentModificationException, DOMException, EmptyStackException,
IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException,
IllegalStateException,
ImagingOpException, IndexOutOfBoundsException, MissingResourceException,
NegativeArraySizeException, NoSuchElementException, NullPointerException,
ProfileDataException, ProviderException, RasterFORMatException, SecurityException,
SystemException, UndeclaredThrowableException, UnmodifiableSetException,
UnsupportedOperationException
1、jsp有哪些内置对象?作用分别是什么?
答:JSP共有以下9种基本内置组件（可与ASP的6种内部组件相对应）：
request 用户端请求，此请求会包含来自GET/POST请求的参数
response 网页传回用户端的回应
pageContext 网页的属性是在这里管理
session 与请求有关的会话期
application servlet 正在执行的内容
out 用来传送回应的输出
config servlet的构架部件
page JSP网页本身
exception 针对错误网页，未捕捉的例外
2、jsp有哪些动作?作用分别是什么?
答:JSP共有以下6种基本动作
jsp:include：在页面被请求的时候引入一个文件。
jsp:useBean：寻找或者实例化一个JavaBean。
jsp:setProperty：设置JavaBean的属性。
jsp:getProperty：输出某个JavaBean的属性。
jsp:forward：把请求转到一个新的页面。
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记
3、JSP中动态INCLUDE与静态INCLUDE的区别？
答：动态INCLUDE用jsp:include动作实现
<jsp:include page=”included.jsp” flush=”true” />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面
<%@ include file=”included.htm” %>
4、两种跳转方式分别是什么?有什么区别?
答：有两种，分别为：
<jsp:include page=”included.jsp” flush=”true”>
<jsp:forward page= “nextpage.jsp”/>
前者页面不会转向include所指的页面，只是显示该页的结果，主页面还是原来的页面。执行完后还会回来，相当于函数调用。并且可以带参数.后者完全转向新页面，不会再回来。相当于go to 语句。
JAVA部分二
1、作用域public,private,protected,以及不写时的区别
答：区别如下：
作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
不写时默认为friendly
2、ArrayList和Vector的区别,HashMap和Hashtable的区别
答：就ArrayList与Vector主要从二方面来说.
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value
3、char型变量中能不能存贮一个中文汉字?为什么?
答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的
4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify
5、继承时候类的执行顺序问题,一般都是选择题,问你将会打印出什么?
答:父类：
package test;
public class FatherClass
{
public FatherClass()
{
System.out.println(“FatherClass Create”);
}
}
子类:
package test;
import test.FatherClass;
public class ChildClass extends FatherClass
{
public ChildClass()
{
System.out.println(“ChildClass Create”);
}
public static void main(String[] args)
{
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}
输出结果：
C:\>java test.ChildClass
FatherClass Create
FatherClass Create
ChildClass Create
6、内部类的实现方式?
答：示例代码如下：
package test;
public class OuterClass
{
private class InterClass
{
public InterClass()
{
System.out.println(“InterClass Create”);
}
}
public OuterClass()
{
InterClass ic = new InterClass();
System.out.println(“OuterClass Create”);
}
public static void main(String[] args)
{
OuterClass oc = new OuterClass();
}
}
输出结果:
C:\>java test/OuterClass
InterClass Create
OuterClass Create
再一个例题：
public class OuterClass {
private double d1 = 1.0;
//insert code here
}
You need to insert an inner class declaration at line 3. Which two inner class declarations are
valid?(Choose two.)
A. class InnerOne{
public static double methoda() {return d1;}
}
B. public class InnerOne{
static double methoda() {return d1;}
}
C. private class InnerOne{
double methoda() {return d1;}
}
D. static class InnerOne{
protected double methoda() {return d1;}
}
E. abstract class InnerOne{
public abstract double methoda();
}
说明如下：
一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。 故 A、B 错
二.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；return d1 出错。
故 D 错
三.非静态内部类的非静态成员可以访问外部类的非静态变量。 故 C 正确
四.答案为C、E
SELEVLET部分三
Servlet方面
1、说一说Servlet的生命周期?
答:servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由javax.servlet.Servlet接口的init,service和destroy方法表达。
2、Servlet版本间(忘了问的是哪两个版本了)的不同?
希望大家补上，谢谢
3、JAVA SERVLET API中forward() 与redirect()的区别？
答:前者仅是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址；后者则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。
这样，从浏览器的地址栏中可以看到跳转后的链接地址。所以，前者更加高效，在前者可以满足需要时，尽量使用forward()方法，并且，这样也有助于隐
藏实际的链接。在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用sendRedirect()方法。
4、Servlet的基本架构
public class ServletName extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
}
1、作用域public,private,protected,以及不写时的区别
答：区别如下：
作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
不写时默认为friendly
2、ArrayList和Vector的区别,HashMap和Hashtable的区别
答：就ArrayList与Vector主要从二方面来说.
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value
3、char型变量中能不能存贮一个中文汉字?为什么?
答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的
4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify
5、继承时候类的执行顺序问题,一般都是选择题,问你将会打印出什么?
答:父类：
package test;
public class FatherClass
{
public FatherClass()
{
System.out.println(“FatherClass Create”);
}
}
子类:
package test;
import test.FatherClass;
public class ChildClass extends FatherClass
{
public ChildClass()
{
System.out.println(“ChildClass Create”);
}
public static void main(String[] args)
{
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}
输出结果：
C:\>java test.ChildClass
FatherClass Create
FatherClass Create
ChildClass Create
6、内部类的实现方式?
答：示例代码如下：
package test;
public class OuterClass
{
private class InterClass
{
public InterClass()
{
System.out.println(“InterClass Create”);
}
}
public OuterClass()
{
InterClass ic = new InterClass();
System.out.println(“OuterClass Create”);
}
public static void main(String[] args)
{
OuterClass oc = new OuterClass();
}
}
输出结果:
C:\>java test/OuterClass
InterClass Create
OuterClass Create
再一个例题：
public class OuterClass {
private double d1 = 1.0;
//insert code here
}
You need to insert an inner class declaration at line 3. Which two inner class declarations are
valid?(Choose two.)
A. class InnerOne{
public static double methoda() {return d1;}
}
B. public class InnerOne{
static double methoda() {return d1;}
}
C. private class InnerOne{
double methoda() {return d1;}
}
D. static class InnerOne{
protected double methoda() {return d1;}
}
E. abstract class InnerOne{
public abstract double methoda();
}
说明如下：
一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。 故 A、B 错
二.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；return d1 出错。
故 D 错
三.非静态内部类的非静态成员可以访问外部类的非静态变量。 故 C 正确
四.答案为C、E
人事方面的问题：
1 首先自我介绍下自己
2 你认为你大学期间最成功的是什么？
3 你最大的优势是什么？
…….其他的就是一些家庭等情况
这是我前天在中科软的面试题，20分，分值最高的一道，我回答的很简单
题：如何写出高性能的SQL语句？
–转
如何写出性能优良的SQL
（1） 选择最有效率的表名顺序(只在基于规则的优化器中有效)：
ORACLE的解析器按照从右到左的顺序处理FROM子句中的表名，FROM子句中写在最后的表(基础表 driving
table)将被最先处理，在FROM子句中包含多个表的情况下,你必须选择记录条数最少的表作为基础表。如果有3个以上的表连接查询,
那就需要选择交叉表(intersection table)作为基础表, 交叉表是指那个被其他表所引用的表.
（2） WHERE子句中的连接顺序．：
ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前, 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾.
（3） SELECT子句中避免使用 ‘ * ‘：
ORACLE在解析的过程中, 会将’*’ 依次转换成所有的列名, 这个工作是通过查询数据字典完成的, 这意味着将耗费更多的时间
（4） 减少访问数据库的次数：
ORACLE在内部执行了许多工作: 解析SQL语句, 估算索引的利用率, 绑定变量 , 读数据块等；
（5） 在SQL*Plus , SQL*Forms和Pro*C中重新设置ARRAYSIZE参数, 可以增加每次数据库访问的检索数据量 ,建议值为200
（6） 使用DECODE函数来减少处理时间：
使用DECODE函数可以避免重复扫描相同记录或重复连接相同的表.
（7） 整合简单,无关联的数据库访问：
如果你有几个简单的数据库查询语句,你可以把它们整合到一个查询中(即使它们之间没有关系)
（8） 删除重复记录：
最高效的删除重复记录方法 ( 因为使用了ROWID)例子：
DELETE FROM EMP E WHERE E.ROWID > (SELECT MIN(X.ROWID)
FROM EMP X WHERE X.EMP_NO = E.EMP_NO);
（9） 用TRUNCATE替代DELETE：
当删除表中的记录时,在通常情况下, 回滚段(rollback segments ) 用来存放可以被恢复的信息.
如果你没有COMMIT事务,ORACLE会将数据恢复到删除之前的状态(准确地说是恢复到执行删除命令之前的状况) 而当运用TRUNCATE时,
回滚段不再存放任何可被恢复的信息.当命令运行后,数据不能被恢复.因此很少的资源被调用,执行时间也会很短. (译者按:
TRUNCATE只在删除全表适用,TRUNCATE是DDL不是DML)
（10） 尽量多使用COMMIT：
只要有可能,在程序中尽量多使用COMMIT, 这样程序的性能得到提高,需求也会因为COMMIT所释放的资源而减少:
COMMIT所释放的资源:
a. 回滚段上用于恢复数据的信息.
b. 被程序语句获得的锁
c. redo log buffer 中的空间
d. ORACLE为管理上述3种资源中的内部花费
（11） 用Where子句替换HAVING子句：
避免使用HAVING子句, HAVING 只会在检索出所有记录之后才对结果集进行过滤. 这个处理需要排序,总计等操作.
如果能通过WHERE子句限制记录的数目,那就能减少这方面的开销.
(非oracle中)on、where、having这三个都可以加条件的子句中，on是最先执行，where次之，having最后，因为on是先把不
符合条件的记录过滤后才进行统计，它就可以减少中间运算要处理的数据，按理说应该速度是最快的，where也应该比having快点的，因为它过滤数据后
才进行sum，在两个表联接时才用on的，所以在一个表的时候，就剩下where跟having比较了。在这单表查询统计的情况下，如果要过滤的条件没有
涉及到要计算字段，那它们的结果是一样的，只是where可以使用rushmore技术，而having就不能，在速度上后者要慢如果要涉及到计算的字
段，就表示在没计算之前，这个字段的值是不确定的，根据上篇写的工作流程，where的作用时间是在计算之前就完成的，而having就是在计算后才起作
用的，所以在这种情况下，两者的结果会不同。在多表联接查询时，on比where更早起作用。系统首先根据各个表之间的联接条件，把多个表合成一个临时表
后，再由where进行过滤，然后再计算，计算完后再由having进行过滤。由此可见，要想过滤条件起到正确的作用，首先要明白这个条件应该在什么时候
起作用，然后再决定放在那里
（12） 减少对表的查询：
在含有子查询的SQL语句中,要特别注意减少对表的查询.例子：
SELECT TAB_NAME FROM TABLES WHERE (TAB_NAME,DB_VER) = ( SELECT
TAB_NAME,DB_VER FROM TAB_COLUMNS WHERE VERSION = 604)
（13） 通过内部函数提高SQL效率.：
复杂的SQL往往牺牲了执行效率. 能够掌握上面的运用函数解决问题的方法在实际工作中是非常有意义的
（14） 使用表的别名(Alias)：
当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上.这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误.
（15） 用EXISTS替代IN、用NOT EXISTS替代NOT IN：
在许多基于基础表的查询中,为了满足一个条件,往往需要对另一个表进行联接.在这种情况下, 使用EXISTS(或NOT
EXISTS)通常将提高查询的效率. 在子查询中,NOT IN子句将执行一个内部的排序和合并. 无论在哪种情况下,NOT IN都是最低效的
(因为它对子查询中的表执行了一个全表遍历). 为了避免使用NOT IN ,我们可以把它改写成外连接(Outer Joins)或NOT
EXISTS.
例子：
（高效）SELECT * FROM EMP (基础表) WHERE EMPNO > 0 AND EXISTS (SELECT ‘X’ FROM DEPT WHERE DEPT.DEPTNO = EMP.DEPTNO AND LOC = ‘MELB’)
(低效)SELECT * FROM EMP (基础表) WHERE EMPNO > 0 AND DEPTNO IN(SELECT DEPTNO FROM DEPT WHERE LOC = ‘MELB’)
（16） 识别’低效执行’的SQL语句：
虽然目前各种关于SQL优化的图形化工具层出不穷,但是写出自己的SQL工具来解决问题始终是一个最好的方法：
SELECT EXECUTIONS , DISK_READS, BUFFER_GETS,
ROUND((BUFFER_GETS-DISK_READS)/BUFFER_GETS,2) Hit_radio,
ROUND(DISK_READS/EXECUTIONS,2) Reads_per_run,
SQL_TEXT
FROM V$SQLAREA
WHERE EXECUTIONS>0
AND BUFFER_GETS > 0
AND (BUFFER_GETS-DISK_READS)/BUFFER_GETS < 0.8
ORDER BY 4 DESC;
（17） 用索引提高效率：
索引是表的一个概念部分,用来提高检索数据的效率，ORACLE使用了一个复杂的自平衡B-tree结构. 通常,通过索引查询数据比全表扫描要快.
当ORACLE找出执行查询和Update语句的最佳路径时, ORACLE优化器将使用索引. 同样在联结多个表时使用索引也可以提高效率.
另一个使用索引的好处是,它提供了主键(primary key)的唯一性验证.。那些LONG或LONG RAW数据类型, 你可以索引几乎所有的列.
通常, 在大型表中使用索引特别有效. 当然,你也会发现, 在扫描小表时,使用索引同样能提高效率.
虽然使用索引能得到查询效率的提高,但是我们也必须注意到它的代价. 索引需要空间来存储,也需要定期维护, 每当有记录在表中增减或索引列被修改时,
索引本身也会被修改. 这意味着每条记录的INSERT , DELETE , UPDATE将为此多付出4 , 5 次的磁盘I/O .
因为索引需要额外的存储空间和处理,那些不必要的索引反而会使查询反应时间变慢.。定期的重构索引是有必要的.：
ALTER INDEX <INDEXNAME> REBUILD <TABLESPACENAME>
（18） 用EXISTS替换DISTINCT：
当提交一个包含一对多表信息(比如部门表和雇员表)的查询时,避免在SELECT子句中使用DISTINCT. 一般可以考虑用EXIST替换, EXISTS 使查询更为迅速,因为RDBMS核心模块将在子查询的条件一旦满足后,立刻返回结果. 例子：
(低效):
SELECT DISTINCT DEPT_NO,DEPT_NAME FROM DEPT D , EMP E
WHERE D.DEPT_NO = E.DEPT_NO
(高效):
SELECT DEPT_NO,DEPT_NAME FROM DEPT D WHERE EXISTS ( SELECT ‘X’
FROM EMP E WHERE E.DEPT_NO = D.DEPT_NO);
（19） sql语句用大写的；因为oracle总是先解析sql语句，把小写的字母转换成大写的再执行
（20） 在java代码中尽量少用连接符“＋”连接字符串！
（21） 避免在索引列上使用NOT 通常，
我们要避免在索引列上使用NOT, NOT会产生在和在索引列上使用函数相同的影响. 当ORACLE”遇到”NOT,他就会停止使用索引转而执行全表扫描.
1 “你最多能出差多久”
2 “你怎么看待加班”
第一题答一年以下直接刷掉，第二题答要加班费直接pass
更过分的是让我和应届生一起笔试！
工资范围3000-4000……我简直无语了，看现在是金融危机就这么剥削！
真够牛的！它以为自己真是大爷！
今天到中科软科面试了，因为之前投了两份简历，一个是应聘JAVA开发，另一个是BI，因到一个叫金融事业部面试，以为就是面试BI的，没想到一位JJ过来了是面试开发，拿了两份题叫1个半小时做完，然后可以走人。JAVA的题比较简单，内容大概是：
打印乘法口决表：
for(int j=0;j<=i;j++){
System.out.print(j+”X”+i+”=”+j*i +”\t”) ;
if(i=j) System.out.println(“\n”);
}
}
递归遍历某个目录sinosoft下的所有java文件
public static void lisFile(String str){
File file = new File(str);
if(file.isDirectory()) {
File[] files = file.listFiles();
for(int i = 0; i < files.length; i++) {
String filename = files[i].getName();
if(filename.trim().toLowerCase().endsWith(“.java”)) {
System.out.print(“files: “+files[i].getName()+”\t”) ;
}
if(files[i].isDirectory()){
String nn=files[i].getPath() ;
lisFile(nn) ;
}
}
}
}
给出一个JDBC操作的例子，指出不完善的地方，那个例子就不说了，下面列出一个常见的：
public static void main(String args[]){
String url = “jdbc:microsoft:sqlserver://localhost:1433;database=NorthWind” ;
String _uname = “dbtest” ;
PreparedStatement psmt = null ;
String _pwd = “889988″ ;
Connection con=null ;
try{
Class.forName(“com.microsoft.jdbc.sqlserver.SQLServerDriver”) ;
System.out.println( “类实例化成功!” );
con = DriverManager.getConnection(url,_uname,_pwd) ;
psmt = con.prepareStatement(“insert into test values(?,?)”) ;
psmt.setString(1, “Jiang hua”) ;
psmt.setString(2, “[email protected]“) ;
psmt.executeUpdate() ;
psmt.setString(1, “Xu Fen”) ;
psmt.setString(2, “[email protected]“) ;
psmt.executeUpdate() ;
}catch(Exception fnot){
fnot.printStackTrace() ;
}finally{
try{
psmt.close() ;
con.close() ;
}catch(Exception e){
e.printStackTrace() ;
}
}
}
SQL 也不难的，给了两个表，然后对两个表进行查询。问了主键,外键，索引有什么作用
还有 以Struts框架为例，向别人介绍MVC模式
Java基础方面:
1、作用域public,private,protected,以及不写时的区别
答：区别如下：
作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
不写时默认为friendly
2、ArrayList和Vector的区别,HashMap和Hashtable的区别
答：就ArrayList与Vector主要从二方面来说.
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value
3、char型变量中能不能存贮一个中文汉字?为什么?
答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的
4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify
5、继承时候类的执行顺序问题,一般都是选择题,问你将会打印出什么?
答:父类：
package test;
public class FatherClass
{
public FatherClass()
{
System.out.println(“FatherClass Create”);
}
}
子类:
package test;
import test.FatherClass;
public class ChildClass extends FatherClass
{
public ChildClass()
{
System.out.println(“ChildClass Create”);
}
public static void main(String[] args)
{
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}
输出结果：
C:\>java test.ChildClass
FatherClass Create
FatherClass Create
ChildClass Create
6、内部类的实现方式?
答：示例代码如下：
package test;
public class OuterClass
{
private class InterClass
{
public InterClass()
{
System.out.println(“InterClass Create”);
}
}
public OuterClass()
{
InterClass ic = new InterClass();
System.out.println(“OuterClass Create”);
}
public static void main(String[] args)
{
OuterClass oc = new OuterClass();
}
}
输出结果:
C:\>java test/OuterClass
InterClass Create
OuterClass Create
再一个例题：
public class OuterClass {
private double d1 = 1.0;
//insert code here
}
You need to insert an inner class declaration at line 3. Which two inner class declarations are
valid?(Choose two.)
A. class InnerOne{
public static double methoda() {return d1;}
}
B. public class InnerOne{
static double methoda() {return d1;}
}
C. private class InnerOne{
double methoda() {return d1;}
}
D. static class InnerOne{
protected double methoda() {return d1;}
}
E. abstract class InnerOne{
public abstract double methoda();
}
说明如下：
一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。 故 A、B 错
二.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；return d1 出错。
故 D 错
三.非静态内部类的非静态成员可以访问外部类的非静态变量。 故 C 正确
四.答案为C、E
7、垃圾回收机制,如何优化程序?
希望大家补上，谢谢
8、float型float f=3.4是否正确?
答:不正确。精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4
9、介绍JAVA中的Collection FrameWork(包括如何写自己的数据结构)?
答：Collection FrameWork如下：
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）
Map提供key到value的映射
10、Java中异常处理机制，事件机制？
11、JAVA中的多形与继承？
希望大家补上，谢谢
12、抽象类与接口？
答：抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。
13、Java 的通信编程，编程题(或问答)，用JAVA SOCKET编程，读服务器几个字符，再写入本地显示？
答:Server端程序:
package test;
import java.net.*;
import java.io.*;
public class Server
{
private ServerSocket ss;
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public Server()
{
try
{
ss=new ServerSocket(10000);
while(true)
{
socket = ss.accept();
String RemoteIP = socket.getInetAddress().getHostAddress();
String RemotePort = “:”+socket.getLocalPort();
System.out.println(“A client come in!IP:”+RemoteIP+RemotePort);
in = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
String line = in.readLine();
System.out.println(“Cleint send is :” + line);
out = new PrintWriter(socket.getOutputStream(),true);
out.println(“Your Message Received!”);
out.close();
in.close();
socket.close();
}
}catch (IOException e)
{
out.println(“wrong”);
}
}
public static void main(String[] args)
{
new Server();
}
};
Client端程序:
package test;
import java.io.*;
import java.net.*;
public class Client
{
Socket socket;
BufferedReader in;
PrintWriter out;
public Client()
{
try
{
System.out.println(“Try to Connect to 127.0.0.1:10000″);
socket = new Socket(“127.0.0.1″,10000);
System.out.println(“The Server Connected!”);
System.out.println(“Please enter some Character:”);
BufferedReader line = new BufferedReader(new
InputStreamReader(System.in));
out = new PrintWriter(socket.getOutputStream(),true);
out.println(line.readLine());
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(in.readLine());
out.close();
in.close();
socket.close();
}catch(IOException e)
{
out.println(“Wrong”);
}
}
public static void main(String[] args)
{
new Client();
}
};
14、用JAVA实现一种排序，JAVA类实现序列化的方法(二种)？如在COLLECTION框架中，实现比较要实现什么样的接口？
答:用插入法进行排序代码如下
package test;
import java.util.*;
class InsertSort
{
ArrayList al;
public InsertSort(int num,int mod)
{
al = new ArrayList(num);
Random rand = new Random();
System.out.println(“The ArrayList Sort Before:”);
for (int i=0;i<num ;i++ )
{
al.add(new Integer(Math.abs(rand.nextInt()) % mod + 1));
System.out.println(“al["+i+"]=”+al.get(i));
}
}
public void SortIt()
{
Integer tempInt;
int MaxSize=1;
for(int i=1;i<al.size();i++)
{
tempInt = (Integer)al.remove(i);
if(tempInt.intValue()>=((Integer)al.get(MaxSize-1)).intValue())
{
al.add(MaxSize,tempInt);
MaxSize++;
System.out.println(al.toString());
} else {
for (int j=0;j<MaxSize ;j++ )
{
if
(((Integer)al.get(j)).intValue()>=tempInt.intValue())
{
al.add(j,tempInt);
MaxSize++;
System.out.println(al.toString());
break;
}
}
}
}
System.out.println(“The ArrayList Sort After:”);
for(int i=0;i<al.size();i++)
{
System.out.println(“al["+i+"]=”+al.get(i));
}
}
public static void main(String[] args)
{
InsertSort is = new InsertSort(10,100);
is.SortIt();
}
}
JAVA类实现序例化的方法是实现java.io.Serializable接口
Collection框架中实现比较要实现Comparable 接口和 Comparator 接口
15、编程：编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半个”。
答：代码如下：
package test;
class SplitString
{
String SplitStr;
int SplitByte;
public SplitString(String str,int bytes)
{
SplitStr=str;
SplitByte=bytes;
System.out.println(“The String is:’”+SplitStr+”‘;SplitBytes=”+SplitByte);
}
public void SplitIt()
{
int loopCount;
loopCount=(SplitStr.length()%SplitByte==0)?(SplitStr.length()/SplitByte):(SplitStr.length()/Split
Byte+1);
System.out.println(“Will Split into “+loopCount);
for (int i=1;i<=loopCount ;i++ )
{
if (i==loopCount){
System.out.println(SplitStr.substring((i-1)*SplitByte,SplitStr.length()));
} else {
System.out.println(SplitStr.substring((i-1)*SplitByte,(i*SplitByte)));
}
}
}
public static void main(String[] args)
{
SplitString ss = new SplitString(“test中dd文dsaf中男大3443n中国43中国人
0ewldfls=103″,4);
ss.SplitIt();
}
}
16、JAVA多线程编程。用JAVA写一个多线程程序，如写四个线程，二个加1，二个对一个变量减一，输出。
希望大家补上，谢谢
17、STRING与STRINGBUFFER的区别。
答：STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法
Jsp方面
1、jsp有哪些内置对象?作用分别是什么?
答:JSP共有以下9种基本内置组件（可与ASP的6种内部组件相对应）：
request 用户端请求，此请求会包含来自GET/POST请求的参数
response 网页传回用户端的回应
pageContext 网页的属性是在这里管理
session 与请求有关的会话期
application servlet 正在执行的内容
out 用来传送回应的输出
config servlet的构架部件
page JSP网页本身
exception 针对错误网页，未捕捉的例外
2、jsp有哪些动作?作用分别是什么?
答:JSP共有以下6种基本动作
jsp:include：在页面被请求的时候引入一个文件。
jsp:useBean：寻找或者实例化一个JavaBean。
jsp:setProperty：设置JavaBean的属性。
jsp:getProperty：输出某个JavaBean的属性。
jsp:forward：把请求转到一个新的页面。
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记
3、JSP中动态INCLUDE与静态INCLUDE的区别？
答：动态INCLUDE用jsp:include动作实现
<jsp:include page=”included.jsp” flush=”true” />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面
<%@ include file=”included.htm” %>
4、两种跳转方式分别是什么?有什么区别?
答：有两种，分别为：
<jsp:include page=”included.jsp” flush=”true”>
<jsp:forward page= “nextpage.jsp”/>
前者页面不会转向include所指的页面，只是显示该页的结果，主页面还是原来的页面。执行完后还会回来，相当于函数调用。并且可以带参数.后者完全转向新页面，不会再回来。相当于go to 语句。
Servlet方面
1、说一说Servlet的生命周期?
答:servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由javax.servlet.Servlet接口的init,service和destroy方法表达。
2、Servlet版本间(忘了问的是哪两个版本了)的不同?
希望大家补上，谢谢
3、JAVA SERVLET API中forward() 与redirect()的区别？
答:前者仅是容器中控制权的转向，在客户端浏览器地址栏中不会
显示出转向后的地址；后者则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。所以，前
者更加高效，在前者可以满足需要时，尽量使用forward()方法，并且，这样也有助于隐藏实际的链接。在有些情况下，比如，需要跳转到一个其它服务器
上的资源，则必须使用sendRedirect()方法。
4、Servlet的基本架构
public class ServletName extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
}
Jdbc、Jdo方面
1、可能会让你写一段Jdbc连Oracle的程序,并实现数据查询.
答:程序如下：
package hello.ant;
import java.sql.*;
public class jdbc
{
String dbUrl=”jdbc:oracle:thin:@127.0.0.1:1521:orcl”;
String theUser=”admin”;
String thePw=”manager”;
Connection c=null;
Statement conn;
ResultSet rs=null;
public jdbc()
{
try{
Class.forName(“oracle.jdbc.driver.OracleDriver”).newInstance();
c = DriverManager.getConnection(dbUrl,theUser,thePw);
conn=c.createStatement();
}catch(Exception e){
e.printStackTrace();
}
}
public boolean executeUpdate(String sql)
{
try
{
conn.executeUpdate(sql);
return true;
}
catch (SQLException e)
{
e.printStackTrace();
return false;
}
}
public ResultSet executeQuery(String sql)
{
rs=null;
try
{
rs=conn.executeQuery(sql);
}
catch (SQLException e)
{
e.printStackTrace();
}
return rs;
}
public void close()
{
try
{
conn.close();
c.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
ResultSet rs;
jdbc conn = new jdbc();
rs=conn.executeQuery(“select * from test”);
try{
while (rs.next())
{
System.out.println(rs.getString(“id”));
System.out.println(rs.getString(“name”));
}
}catch(Exception e)
{
e.printStackTrace();
}
}
}
2、Class.forName的作用?为什么要用?
答：调用该访问返回一个以字符串指定类名的类的对象。
3、Jdo是什么?
答:JDO是Java对象持久化的新的规范，为java
data
object的简称,也是一个用于存取某种数据仓库中的对象的标准化API。JDO提供了透明的对象存储，因此对开发人员来说，存储数据对象完全不需要额
外的代码（如JDBC
API的使用）。这些繁琐的例行工作已经转移到JDO产品提供商身上，使开发人员解脱出来，从而集中时间和精力在业务逻辑上。另外，JDO很灵活，因为它
可以在任何数据底层上运行。JDBC只是面向关系数据库（RDBMS)JDO更通用，提供到任何数据底层的存储功能，比如关系数据库、文件、XML以及对
象数据库（ODBMS）等等，使得应用可移植性更强。
4、在ORACLE大数据量下的分页解决方法。一般用截取ID方法，还有是三层嵌套方法。
答:一种分页方法
<%
int i=1;
int numPages=14;
String pages = request.getParameter(“page”) ;
int currentPage = 1;
currentPage=(pages==null)?(1):{Integer.parseInt(pages)}
sql = “select count(*) from tables”;
ResultSet rs = DBLink.executeQuery(sql) ;
while(rs.next()) i = rs.getInt(1) ;
int intPageCount=1;
intPageCount=(i%numPages==0)?(i/numPages):(i/numPages+1);
int nextPage ;
int upPage;
nextPage = currentPage+1;
if (nextPage>=intPageCount) nextPage=intPageCount;
upPage = currentPage-1;
if (upPage<=1) upPage=1;
rs.close();
sql=”select * from tables”;
rs=DBLink.executeQuery(sql);
i=0;
while((i<numPages*(currentPage-1))&&rs.next()){i++;}
%>
//输出内容
//输出翻页连接
合计:<%=currentPage%>/<%=intPageCount%><a href=”List.jsp?page=1″>第一页</a><a
href=”List.jsp?page=<%=upPage%>”>上一页</a>
<%
for(int j=1;j<=intPageCount;j++){
if(currentPage!=j){
%>
<a href=”list.jsp?page=<%=j%>”>[<%=j%>]</a>
<%
}else{
out.println(j);
}
}
%>
<a href=”List.jsp?page=<%=nextPage%>”>下一页</a><a href=”List.jsp?page=<%=intPageCount%>”>最后页
</a>
Xml方面
1、xml有哪些解析技术?区别是什么?
答:有DOM,SAX,STAX等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装
入内存,适合对XML的随机访问SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到
像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问
STAX:Streaming API for XML (StAX)
2、你在项目中用到了xml技术的哪些方面?如何实现的?
答:用到了数据存贮，信息配置两方面。在做数据交换平台时，将
不能数据源的数据组装成XML文件，然后将XML文件压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再同XML文件中还原相关信息进行处理。在
做软件配置时，利用XML可以很方便的进行，软件的各种配置参数都存贮在XML文件中。
3、用jdom解析xml文件时如何解决中文问题?如何解析?
答:看如下代码,用编码方式加以解决
package test;
import java.io.*;
public class DOMTest
{
private String inFile = “c:\\people.xml”;
private String outFile = “c:\\people.xml”;
public static void main(String args[])
{
new DOMTest();
}
public DOMTest()
{
try
{
javax.xml.parsers.DocumentBuilder builder =
javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder();
org.w3c.dom.Document doc = builder.newDocument();
org.w3c.dom.Element root = doc.createElement(“老师”);
org.w3c.dom.Element wang = doc.createElement(“王”);
org.w3c.dom.Element liu = doc.createElement(“刘”);
wang.appendChild(doc.createTextNode(“我是王老师”));
root.appendChild(wang);
doc.appendChild(root);
javax.xml.transform.Transformer transformer =
javax.xml.transform.TransformerFactory.newInstance().newTransformer();
transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, “gb2312″);
transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, “yes”);
transformer.transform(new javax.xml.transform.dom.DOMSource(doc),
new
javax.xml.transform.stream.StreamResult(outFile));
}
catch (Exception e)
{
System.out.println (e.getMessage());
}
}
}
4、编程用JAVA解析XML的方式.
答:用SAX方式解析XML，XML文件如下：
<?xml version=”1.0″ encoding=”gb2312″?>
<person>
<name>王小明</name>
<college>信息学院</college>
<telephone>6258113</telephone>
<notes>男,1955年生,博士，95年调入海南大学</notes>
</person>
事件回调类SAXHandler.java
import java.io.*;
import java.util.Hashtable;
import org.xml.sax.*;
public class SAXHandler extends HandlerBase
{
private Hashtable table = new Hashtable();
private String currentElement = null;
private String currentValue = null;
public void setTable(Hashtable table)
{
this.table = table;
}
public Hashtable getTable()
{
return table;
}
public void startElement(String tag, AttributeList attrs)
throws SAXException
{
currentElement = tag;
}
public void characters(char[] ch, int start, int length)
throws SAXException
{
currentValue = new String(ch, start, length);
}
public void endElement(String name) throws SAXException
{
if (currentElement.equals(name))
table.put(currentElement, currentValue);
}
}
JSP内容显示源码,SaxXml.jsp:
<HTML>
<HEAD>
<TITLE>剖析XML文件people.xml</TITLE>
</HEAD>
<BODY>
<%@ page errorPage=”ErrPage.jsp”
contentType=”text/html;charset=GB2312″ %>
<%@ page import=”java.io.*” %>
<%@ page import=”java.util.Hashtable” %>
<%@ page import=”org.w3c.dom.*” %>
<%@ page import=”org.xml.sax.*” %>
<%@ page import=”javax.xml.parsers.SAXParserFactory” %>
<%@ page import=”javax.xml.parsers.SAXParser” %>
<%@ page import=”SAXHandler” %>
<%
File file = new File(“c:\\people.xml”);
FileReader reader = new FileReader(file);
Parser parser;
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser sp = spf.newSAXParser();
SAXHandler handler = new SAXHandler();
sp.parse(new InputSource(reader), handler);
Hashtable hashTable = handler.getTable();
out.println(“<TABLE BORDER=2><CAPTION>教师信息表</CAPTION>”);
out.println(“<TR><TD>姓名</TD>” + “<TD>” +
(String)hashTable.get(new String(“name”)) + “</TD></TR>”);
out.println(“<TR><TD>学院</TD>” + “<TD>” +
(String)hashTable.get(new String(“college”))+”</TD></TR>”);
out.println(“<TR><TD>电话</TD>” + “<TD>” +
(String)hashTable.get(new String(“telephone”)) + “</TD></TR>”);
out.println(“<TR><TD>备注</TD>” + “<TD>” +
(String)hashTable.get(new String(“notes”)) + “</TD></TR>”);
out.println(“</TABLE>”);
%>
</BODY>
</HTML>
EJB方面
1、EJB2.0有哪些内容?分别用在什么场合? EJB2.0和EJB1.1的区别?
答：规范内容包括Bean提供者，应用程序装配者，EJB容器，EJB配置工具，EJB服务提供
者，系统管理员。这里面，EJB容器是EJB之所以能够运行的核心。EJB容器管理着EJB的创建，撤消，激活，去活，与数据库的连接等等重要的核心工
作。JSP,Servlet,EJB,JNDI,JDBC,JMS…..
2、EJB与JAVA BEAN的区别？
答:Java Bean 是可复用的组件，对Java
Bean并没有严格的规范，理论上讲，任何一个Java类都可以是一个Bean。但通常情况下，由于Java
Bean是被容器所创建（如Tomcat)的，所以Java Bean应具有一个无参的构造器，另外，通常Java
Bean还要实现Serializable接口用于实现Bean的持久性。Java
Bean实际上相当于微软COM模型中的本地进程内COM组件，它是不能被跨进程访问的。Enterprise Java Bean
相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问（跨进程、跨计算机）。但EJB必须被布署在
诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代
理，EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。
3、EJB的基本架构
答:一个EJB包括三个部分:
Remote Interface 接口的代码
package Beans;
import javax.ejb.EJBObject;
import java.rmi.RemoteException;
public interface Add extends EJBObject
{
//some method declare
}
Home Interface 接口的代码
package Beans;
import java.rmi.RemoteException;
import jaax.ejb.CreateException;
import javax.ejb.EJBHome;
public interface AddHome extends EJBHome
{
//some method declare
}
EJB类的代码
package Beans;
import java.rmi.RemoteException;
import javax.ejb.SessionBean;
import javx.ejb.SessionContext;
public class AddBean Implements SessionBean
{
//some method declare
}
J2EE,MVC方面
1、MVC的各个部分都有那些技术来实现?如何实现?
答:MVC是Model－View－Controller的简
写。”Model” 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现）， “View”
是应用的表示面（由JSP页面产生），”Controller”
是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重
用。
2、应用服务器与WEB SERVER的区别？
希望大家补上，谢谢
3、J2EE是什么？
答:Je22是Sun公司提出的多层(multi-
diered),分布式(distributed),基于组件(component-base)的企业级应用模型(enterpriese
application
model).在这样的一个应用系统中，可按照功能划分为不同的组件，这些组件又可在不同计算机上，并且处于相应的层次(tier)中。所属层次包括客户
层(clietn tier)组件,web层和组件,Business层和组件,企业信息系统(EIS)层。
4、WEB SERVICE名词解释。JSWDL开发包的介绍。JAXP、JAXM的解释。SOAP、UDDI,WSDL解释。
答：Web Service描述语言WSDL
SOAP即简单对象访问协议(Simple Object Access Protocol)，它是用于交换XML编码信息的轻量级协议。
UDDI 的目的是为电子商务建立标准；UDDI是一套基于Web的、分布式的、为Web Service提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service注册，以使别的企业能够发现的访问协议的实现标准。
5、BS与CS的联系与区别。
希望大家补上，谢谢
6、STRUTS的应用(如STRUTS架构)
答：Struts是采用Java Servlet/JavaServer
Pages技术，开发Web应用程序的开放源码的framework。
采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架。 Struts有如下的主要功能：
一.包含一个controller servlet，能将用户的请求发送到相应的Action对象。
二.JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用。
三.提供了一系列实用对象：XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。
设计模式方面
1、开发中都用到了那些设计模式?用在什么场合?
答：每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心。通过这种方式，你可以无数次地使用那些已有的解决方案，无需在重复相同的工作。主要用到了MVC的设计模式。用来开发JSP/Servlet或者J2EE的相关应用。简单工厂模式等。
2、UML方面
答：标准建模语言UML。用例图,静态图(包括类图、对象图和包图),行为图,交互图(顺序图,合作图),实现图,
JavaScript方面
1、如何校验数字型?
var re=/^\d{1,8}$|\.\d{1,2}$/;
var str=document.form1.all(i).value;
var r=str.match(re);
if (r==null)
{
sign=-4;
break;
}
else{
document.form1.all(i).value=parseFloat(str);
}
CORBA方面
1、CORBA是什么?用途是什么?
答：CORBA 标准是公共对象请求代理结构(Common Object Request
Broker Architecture)，由对象管理组织 (Object Management Group，缩写为
OMG)标准化。它的组成是接口定义语言(IDL), 语言绑定(binding:也译为联编)和允许应用程序间互操作的协议。 其目的为：
用不同的程序设计语言书写
在不同的进程中运行
为不同的操作系统开发
LINUX方面
1、LINUX下线程，GDI类的解释。
答：LINUX实现的就是基于核心轻量级进程的”一对一”线程模型，一个线程实体对应一个核心轻量级进程，而线程之间的管理在核外函数库中实现。
GDI类为图像设备编程接口类库。
1、简述你对DAO的理解？
答：DAO是DATA ACCESS OBJECT
的简写，中文译为数据访问对象，主要负责将数据保存到数据源中，从数据源中获取数据，以便能够使用BO透明的访问数据源，降低了BO与数据源之间的耦合，
使BO更专著于业务逻辑的控制，我们通常说的DAO模式，实质上指的是DAO的工厂策略。
BO：
business object业务对象主要作用是把业务逻辑封装为一个对象。这个对象可以包括一个或多个其它的对象。
比如一个简历，有教育经历、工作经历、社会关系等等。
我们可以把教育经历对应一个PO，工作经历对应一个PO，社会关系对应一个PO。
建立一个对应简历的BO对象处理简历，每个BO包含这些PO。
这样处理业务逻辑时，我们就可以针对BO去处理。
2、工厂模式
工厂模式定义：提供创建对象的接口
优点：降低了调用者与被调用者之间的耦合;
缺点：代码增加了复杂度，同时造成了，被调用者与工厂之间的耦合。
3、数据连接池的理解.
1、数据库连接池的产生及基本原理。它的产生是由于在大型系统中，系统往往频繁的建立、关闭与数据库之间的链接，而建立一个数据库链接对于数据库以
及服务器是十分消耗资源的，往往成为系统的瓶颈。由此能不能把产生的链接保留一段时间（保留期间放入一个特定缓冲区就是“池中”），如果有别的链接需要就
重新拿出链接使用，而不需要开启新的链接。这就是数据库连接池的基本原理。
注意不仅在j2ee中有连接池，在其他系统开发框架如.net中也有连接池。
2、数据库连接池的优缺点。最大的有点就是节省资源提高效率，如大型系统中，据说采用连接池后性能提高难以置信。而且tomcat项目由5.0到
5.5到6.0的主要提高之一就是数据库连接池的性能提升！还有以往数据库链接如果时间太长容易发生数据溢出，使用连接池可以控制链接时间自动回收。
缺点主要是如果数据库关闭，连接池失效，所有链接都失效，可能造成无法链接。（其实tomcat一直在改进，这个缺点似乎在具体实现中，已经不存在了）。
4、AJAX的理解
jax 基本上就是把 JavaScript 技术和 XMLHttpRequest
对象放在 Web 表单和服务器 之间 。当用户填写表单时，数据发送给一些 JavaScript 代码而不是
直接发送给服务器。相反，JavaScript
代码捕获表单数据并向服务器发送请求。同时用户屏幕上的表单也不会闪烁、消失或延迟。换句话说，JavaScript
代码在幕后发送请求，用户甚至不知道请求的发出。更好的是，请求是异步发送的，就是说 JavaScript
代码（和用户）不用等待服务器的响应。因此用户可以继续输入数据、滚动屏幕和使用应用程序。
AJAX的全称是Asynchronous JavaScript And XML.
AJAX是2005年由Google发起并流行起来的编程方法， AJAX不是一个新的编程语言，但是它是一个使用已有标准的新的编程技术。
使用AJAX可以创建更好，更快，更用户界面友好的Web应用。
AJAX技术基于Javascript和HTTP Request.
5、Struts2工作机制？优缺点
工作机制：
Struts的工作流程:
在web应用启动时就会加载初始化ActionServlet,ActionServlet从
struts-config.xml文件中读取配置信息,把它们存放到各种配置对象
当ActionServlet接收到一个客户请求时,将执行如下流程.
-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;
-(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
-(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;
-(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象,就表示表单验证成功;
-(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;
-(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给ActionForward对象指向的JSP组件;
-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;
Struts优点:
1. 实现MVC模式，结构清晰使开发者只关注业务逻辑的实现.
2. 有丰富的tag可以用 Struts的标记库(Taglib)，如能灵活动用，则能大大提高开发效率。另外，就目前国内的JSP开发者而言，除了使用JSP自带的常用标记外，很少开发自己的标记，或许Struts是一个很好的起点。
3. 页面导航.页面导航将是今后的一个发展方向，事实上，这样做，使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。
4. 提供Exception处理机制 .
5. 数据库链接池治理
6. 支持I18N
缺点:
1、转到展示层时，需要配置forward，每一次转到展示层，相信大多数都是直接转到jsp，而涉及到转向，需要配置
forward，假如有十个展示层的jsp，需要配置十次struts，而且还不包括有时候目录、文件变更，需要重新修改forward，注重，每次修改
配置之后，要求重新部署整个项目，而tomcate这样的服务器，还必须重新启动服务器，如果业务变更复杂频繁的系统，这样的操作简单不可想象。现在就是
这样，几十上百个人同时在线使用我们的系统，大家可以想象一下，我的烦恼有多大。
2、Struts 的Action必需是thread－safe方式，它仅仅答应一个实例去处理所有的哀求。所以action用到的所有的资源都必需统一同步，这个就引起了线程安全的问题。
3、测试不方便. Struts的每个Action都同Web层耦合在一起，这样它的测试依靠于Web容器，单元测试也很难实现。不过有一个Junit的扩展工具Struts TestCase可以实现它的单元测试。
4、类型的转换. Struts的FormBean把所有的数据都作为String类型，它可以使用工具Commons-Beanutils进行类型转化。但它的转化都是在Class级别，而且转化的类型是不可配置的。类型转化时的错误信息返回给用户也是非常困难的。
5、对Servlet的依赖性过强. Struts处理Action时必需要依赖ServletRequest 和ServletResponse，所有它挣脱不了Servlet容器。
6、前端表达式语言方面.Struts集成了JSTL，所以它主要使用JSTL的表达式语言来获取数据。可是JSTL的表达式语言在Collection和索引属性方面处理显得很弱。
7、对Action执行的控制困难. Struts创建一个Action，如果想控制它的执行顺序将会非常困难。甚至你要重新去写Servlet来实现你的这个功能需求。
8、对Action 执行前和后的处理. Struts处理Action的时候是基于class的hierarchies，很难在action处理前和后进行操作。
9、对事件支持不够.
在struts中，实际是一个表单Form对应一个Action类(或DispatchAction)，换一句话说：在Struts中实际是一个表单只能
对应一个事件，struts这种事件方式称为application event，application event和component
event相比是一种粗粒度的事件。
6、Hibernate工作机制？Hibernate优缺点
1.读取并解析配置文件
2.读取并解析映射信息，创建SessionFactory
3.打开Sesssion
4.创建事务Transation
5.持久化操作
6.提交事务
7.关闭Session
8.关闭SesstionFactory
优点:
1.Hibernate 使用 Java 反射机制 而不是字节码增强程序来实现透明性。
2.Hibernate 的性能非常好，因为它是个轻量级框架。 映射的灵活性很精彩。
3.它支持各种关系数据库，从一对一到多对多的各种复杂关系。
缺点：它限制您所使用的对象模型。(例如，一个持久性类不能映射到多个表)其独有的界面和可怜的市场份额也让人不安，尽
管如此，Hibernate 还是以其强盛的发展动力减轻了这些风险。其他的开源持久性框架也有一些，不过都没有 Hibernate
这样有市场冲击力。
7、HQL和SQL区别
sql是关系数据库查询语言,面对的数据库;而hql是Hibernate这样的数据库持久化框架提供的内置查询语言,虽然他们的目的都是为了
从数据库查询需要的数据,但sql操作的是数据库表和字段,而作为面向对象的hql操作的则是持久化类及其属性
sql 面向数据库表查询
hql 面向对象查询
8、如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态
7. 表字段要少，表关联不要怕多，有二级缓存撑腰
9、AOP和IOC的概念以及在spring中是如何应用的
Spring中AOP的实现就是通过动态代理来实现的。动态代理的实现在上篇blog中已经涉及。Spring中目前最
为实用的AOP应用，非用其实现的事务管理机制莫属。也正是这一点，使得Spring
AOP大方异彩。那么我们继续围绕上节的例子来探讨一下Spring中AOP机制的应用与开发。首先，看看AOP中几个基本的概念对应在AOP中的实
现：?
切点(PointCut)一系列连接点的集合，它指明处理方式（Advice）将在何时被触发。对于我们开发而言，“何时触发”的条件大多是面向Bean
的方法进行制定。像Spring的配置化事务管理时针对方法名称可进行PointCut设置，从而指定对所有以声明字符开头的方法进行基于AOP的事务管
理。那么同样，对于我们自己实现的AOP组件而言，我们也可以以方法名作为触发判定条件。
10、Hibernate的查询方式
1. get() and load()
session.get(Clazz, id);
session.load(Clazz, id);
说明: load()与get()的区别
请注意如果没有匹配的数据库记录，load()方法可能抛出无法恢复的异常(unrecoverable
exception)。
如果类的映射使用了代理(proxy)，load()方法会返回一个未初始化的代理，直到你调用该代理的某方法时才会去访问数据库。
若你希望在某对象中创建一个指向另一个对象的关联，又不想在从数据库中装载该对象时同时装载相关联的那个对象，那么这种操作方式就用得上的了。
如果为相应类映射关系设置了batch-size，
那么使用这种操作方式允许多个对象被一批装载（因为返回的是代理，无需从数据库中抓取所有对象的数据）。
如果你不确定是否有匹配的行存在，应该使用get()方法，它会立刻访问数据库，如果没有对应的行，会返回null。
11、简述在 struts2 中，如何验证框架？
在Action-validation.xml文件中增加如下配置：
<field name=”要验证的属性名称”>
<field-validator type=”要依赖的验证器”>
<message>错误信息</message>
</field-validator>
</field>
11、Struts框架如何取得消息资源文件中的信息？
消息资源文件是一些简单的.properties文件，这些文件包含有可以被struts项目使用的消息信息，消息资源
文件可以以<message-resource/>标签的形式添加到struts-config.xml文件，例如<message-
resource parameter=MessageResource/>
12、如何实现struts的validator框架？
手动:
? public class myForm extends ActionForm
? {
? public ActionErrors validate()
? {
actionErrors.add(ActionErrors.GLOBAL_MESSAGE,new ActionMessage(”properties中的键名”));
? }
? }
? struts-config.xml中修改action的标签validate=true
? input=”错误页面”
? 如果validate方法中的ActionErrors不为空且size>0时
? 会回到input页面。
? 自动
? public class myForm extends ValidateForm
? {
? 不能覆盖validate方法。
? //public void validate()
? //{
?
? //}
? }
? 在struts-config.xml文件中加入插件
? <plug-in className=”org.apache.struts.validator.ValidatorPlugIn”>
? <set-property property=”pathnames” value=”/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml” />
? </plug-in>
? 修改validation.xml中的内容
? errors.required={0} is required.
? errors.minlength={0} can not be less than {1} characters.
? <formset>
? <form name=”loginForm”>
? <field property=”userName” depends=”required”>
? <arg0 key=”userName” />
? </field>
? <field property=”pwd” depends=”required,minlength”>
? <arg0 key=”pwd” />
? <arg1 key=”${var:minlength}” resource=”false”/>
? <var>
? <var-name>minlength</var-name>
? <var-value>6</var-value>
? </var>
? </field>
? </form>
? </formset>
? struts-config.xml中修改action的标签validate=true
? input=”/错误页面”
13、如何用Struts实现国际化?
国际化:不用修改代码，就适用于不同的语言国家
本地化:如果要适应一个国家，要修改源代码
实现过程:
在struts-config.xml中用如下标签说明资源文件名，注意其只是文件名，没有语言_国家
<message-resources parameter=”struts.ApplicationResources” />
在资源文件对应的目录struts中加入适应不同语言、国家的properties文件
ApplicationResources_zh_CN.properties 中国
ApplicationResources_en_US.properties us
如果不是英语要转码
native2ascii -encoding gb2312 源 ApplicationResources_zh_CN.properties
在jsp页面中用
<bean:message key=””/>取出信息
14、Hibernate中怎样实现类之间的关系
类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、