1.离线查询去除重复项怎么加条件？
dc.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
2. http协议及端口,smtp协议及端口
超文本传输协议 端口 80
简单邮件传输协议 端口25
3.编写程序，完成文件复制功能 错误？
InputStream is=new InputStream();
OutputStream os = new FileOutputStream(new File("写入的文件的路径")); byte[] buff=new byte[8192]; int length = 0;
while((length=is.read(buff))!=-1){
os.write(buff,0,length);
} 然后try...catch()..finally{关闭流}
4.Servlet创建过程及生命周期Servlet 在容器中运行时，其实例的创建及销毁等是由容器进行控制。
Servlet 的创建有两种方法。
1、客户端请求对应的 Servlet 时，创建 Servlet 实例;大部分Servlet 都是这种 Servlet 。 2、通过在web.xml 中设置load-on-startup来创建servlet实例，这种实例在Web 应用启动时，立即创建Servlet 实例
Servlet 的运行都遵循如下生命周期：
1、创建 Servlet 实例。
2、Web 容器调用 Servlet 的 init 方法，对Servlet 进行初始化。
3、Servlet 初始化后，将一直存在于容器中，用于响应客户端请求。。如果客户端有get 请求，容器调用Se凹let 的doGet 方法处理并响应请求。对于不同的请求，有不同的处理方法，或者统一使用service 方法处理来响应用户请求。
4、Web 容器角色销毁Servlet 时，调用 Servlet 的 destroy 方法，通常在关闭Web容器之时销毁Servlet。
5.用sql语句分页：list.map.set的存储特点?
List 以特定次序来持有元素,可有重复元素.Set 无法拥有重复元素,内部排序.Map 保存key-value值,value可多值
6.final,finally,finaliz的区别
final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声 明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改 被声明为final的方法也同样只能使用，不能重载。
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常 ，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。
finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 ；finalize() 方法以整理系统资源或者执行其他清理工作 finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。
7.arraylist和vector的区别?
ArrayList 作为一个常规用途的对象容器使用，用于替换原先的Vector。允许我们快速访问元素，但在从列表中部插入和删除元素时，速度却嫌稍慢。
一般只应该用ListIterator对一个ArrayList进行向前和向后遍历，不要用它删除和插入元素；与LinkedList相比，它的效率要低许多
8.Arraylist linkedlist区别？
ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦 LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引 但是缺点就是查找非常麻烦 要丛第一个索引开始
9.haSHMAP,HASHTABLE区别
1.Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类；
2.Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。
3.在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。
10.描述Cookie和Session的作用，区别和各自的应用范围，Session工作原理
Cookie是在客户端开辟的一块可长期存储用户信息的地方；Session是在服务器内存中开辟的一块存储用户信息的地方；当客户第一次访问服务器时，服务器在内存创建对应的Session给访问客户，当客户离开或时间过期时；服务器自动销毁Session； Session是由容器管理的
11.set，map，set接口的区别
list以特定次序来持有元素，可有重复元素，查找效率高 ，插入效率低化，
set 无法拥有重复元素，内部排序，检索元素效率低，删除和插入效率高，因为插入和删除不会引起位置上的变化，
12.String和stringbuffer进行字符串连接时的区别？
String对象内容是不可改变的，StringBuffer是可以改变的，别且高效；
13.什么叫项目？
用有限的资源、有限的时间为特定客户完成特定目标的一次性工作
14.J2EE J是什么意思？ 2是什么意思 EE是什么意思？ Struts的拦截器你是怎么做的，是独立开发的，能够独立开发的到。然后问有哪几种拦截？
Java 2 Platform，Enterprise Edition
继承AbstractInterceptor类，覆盖intercept()方法
有struts自己的拦截器 如timer ,i18n,scop,servletconfig,token
还有自定义拦截器
15.简单介绍下java？Spring的AOP，IOC的讲述 对struts2的了解，1，2的比较 xml的了解 J2ee的webserviced的协议？
Spring AOP:代理机制 Spring提供的自动代理机制
Spring的IoC来实组件之间的依赖关系注入, 使控制层与业务实现分离，即客户通过
调用业务委托接口来调用具体的业务组件的实例，避免控制层与业务层的藕合带来的维护
或升级困难。由Spring为DAO生成代理对象来为DAO添加事务服务，由IoC容器DAO的代理实例注入到业务组件中,业务组件通过DAO的委托接口调用DAO对象，使得上层组件不直接依赖于DAO的实现类，使得持久层更换或修改不影响上层组件。
16.Collections,collection的区别
Collection是个java.util下的接口，它是各种集合结构的父接口。Collections是个java.util下的普通类，它包含有各种有关集合操作的静态方法。Collections是针对集合类的一个帮助类，它提供一系列的静态方法实现对各种集合的搜索，排序，线程安全化等操作
17.如何释放过度使用的undo表空间
释放undo表空间 1. 启动SQLPLUS，并用sys登陆到数据库。 2. 查找数据库的UNDO表空间名3. 确认UNDO表空间；SQL> select name from v$tablespace; NAME
4. 检查数据库UNDO表空间占用空间情况以及数据文件存放位置； 5. 查看回滚段的使用情况，哪个用户正在使用回滚段的资源，如果有用户最好更换时间 6. 检查UNDO Segment状态
18.数据库里面游标，索引是怎么用的？ 在oracle数据库中，用get 和load方法 这2个方法来查没有的数据 那么分别会反馈什么样的结果？
declare cur cursor keyset for
get返回null,load classnotfoundException
19.在Oracle中数据库中的一个表中，这个表没有主键id也没有特定标示来查数据，怎么查？
rowid
20.简述private、proteced、public、internal修饰符的访问权限 2.概述反射和序列化
请裂举session、cookie、viewstatedn的应用范围 4、简述WebService和Remoting的特点和运用场景
同一个类 同一个包 不同包的子类 不同包非子类
private *
default * *
protected * * *
public * * * *
Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。本文借由实例，大面积示范Reflection APIs。
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流
21.ORACLE中not和and和or优先级由高到低？
not and or
22.java 是如何进行异常处理的
调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序
23.struts2 必备包
commons-fileupload-1.2.1.jar
commons-io-1.3.2.jar
commons-logging-api-1.1.jar
freemarker-2.3.13.jar
ognl-2.6.11.jar
struts2-core-2.1.6.jar
xwork-2.1.2.jar
24.dao 是什么及作用
Dao 是数据访问对象 DAO负责管理与数据源的连接来获取和储存其中的数据
ibtis 中的#与$的区别
struts的实现原理
1、客户端初始化一个指向Servlet容器（例如Tomcat）的请求
2、这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）；
3、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action；
4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy；
5、ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类；
6、ActionProxy创建一个ActionInvocation的实例。
7、ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。
8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2框架中继承的标签。在这个过程中需要涉及到ActionMapper
简述spring 的事务传播行为和隔离级别
25.写一段把本地文件formfile拷贝到本地文件tofile的程序
public class ChangeJtdToJava {
public static void main(String[] args) {
File dir = new File("f:/jtd");
// 得到d:/jtd 下的所有文件对象
File[] files = dir.listFiles();
for (File file : files) {
String fileName = file.getName(); // 得到文件名
int index = fileName.indexOf(".");// .的索引位置
String fileName2 = fileName.substring(0, index); // 不带后缀名的文件名
String houZui = fileName.substrinxg(index);
if (houZui.equals(".jtd")) {
// "f:/java/" + fileName2 + ".java"
// 要移到的地方
file.renameTo(new File("f:/java/" + fileName2 + ".java"));
}
}
}
}
26.写出删除表中重复记录的语句 oracle
delete from people
where peopleId in (select peopleId from people group by peopleId having count(peopleId) > 1) and rowid not in (select min(rowid) from people group by
27.用java 实现一种排序，java 类实现序列化的方法（二种）？如在collection框架中，要实现什么样的接口
java.io.Serializable接口 Collection框架中实现比较要实现Comparable 接口和 Comparator 接口
28.Struts2是如何实现拦截器的？
Struts2拦截器是在访问某个Action或Action的某个方法，字段之前或之后实施拦截，并且Struts2拦截器是可插拔的，拦截器是ＡＯＰ的一种实现。实现原理：当请求struts2的action时，Struts 2会查找配置文件，并根据其配置实例化相对的 拦截器对象，然后串成一个列表，最后一个一个地调用列表中的拦截器
29.sleep()和wait()区别
sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。 wait().会释放锁
30.Servlet的生命周期分为5个阶段:? 和CGI的区别？
实例化：Servlet容器创建Servlet类的实例。
初始化：该容器调用init()方法，通常会申请资源。
服务：由容器调用service()方法，（也就是doGet()和doPost()）。
破坏：在释放Servlet实例之前调用destroy()方法，通常会释放资源。
31.foward和redirect区别
redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取。web应用程序会要求客户端浏览器重新发出请求地址，客户端会重新连接至所指定的地址，因此浏览器的地址会出现重新导向的信息，重新导向后的请求由浏览器发出，所以不能访问Web应用程序中的隐
32.多线程、同步实现方法？
实现线程有两种 继承Thread类或者实现Runnable接口... 实现同步也有两种,一种是用同步方法,一种是用同步块.. 同步方法就是在方法返回类型后面加上synchronized, 比如:
public void synchronized add(){...}
同步块就是直接写:synchronized (这里写需要同步的对象){...}
33.集合类有哪些？有哪些方法？
集合类 ArrayList LinkedList HashSet HashMap方法：add(),remove(),put(),addAll(),removeAll()
34.java中实现多态的机制是什么
重写，重载
35. 静态的多态和动态的多态的区别
静态的多态:方法名相同，参数个数或类型不相同。(overloading)
动态的多态:子类覆盖父类的方法，将子类的实例传与父类的引用调用的是子类的方法 实现接口的实例传与接口的引用调用的实现类的方法。
36.作用域Public,private,protected.以及不写时的区别
public整个java程序中都可以访问
protected在其他包中不可以访问
friendly只有当前包或当前内可以访问，其他都不行
private只有当前内可以访问
不写的话默认是protected
37．extends和implement的不同
extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了 比如 class A extends B implements C,D,E
38.常用的设计模式？定义一个变量， Var v =new Object (),用js编写的简便写法是什么？join与leftjoin的区别
DAO设计模式与DELEGATE模式
适配器模式与桥梁模式的区别
工厂模式
inner join :内连接查询操作列出与连接条件匹配的数据行，它使用比较运算符比较被连接列的列值
left join:内连接时，返回查询结果集合中的仅是符合查询条件( WHERE 搜索条件或 HAVING 条件)和连接条件的行。而采用外连接时，它返回到查询结果集合中的不仅包含符合连接条件的行，而且还包括左表(左外连接时)、右表(右外连接时)或两个边接表(全外连接)中的所有数据行
39．Hibernate中离线查询与在线查询的区别
Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样， Criteria 是在线的，所以它是由 Hibernate Session 进行创建的；而 DetachedCriteria 是离线的，创建时无需 Session，DetachedCriteria 提供了 2 个静态方法 forClass(Class) 或 forEntityName(Name) 进行DetachedCriteria 实例的创建。
40.C#数据类型有哪些 ？
int 整型double 双精度型string 字符串型 char 字符型 bool 布尔型
41.抽象类能否被实例化
抽象类通常不是由程序员定义的，而是由项目经理或模块设计人 设计抽象类的原因通常是为了规范方法名 抽象类必须要继承，不然没法用，作为模块设计者，可以把让底层程序员直接用得方法直接调用，而一些需要让程序员覆盖后自己做得方法则定义称抽象方法
42.ASP.NET页面传递值的方式有哪些
1 通过URL链接地址传递 2 通过post方式。
send.aspx 3 通过session 4通过Application
5 通过Server.Transfersend.aspx:
43.如何定义一个窗口为 MDI窗口？
MDI窗口 就是说一个窗体做为容器，里面还可以添加其他窗体
44.WCF是什么？
WCF是微软用以应对SOA解决方案的开发需求而专门推出的 是专门用于服务定制、发布与运行以及消息传递和处理的一组专门类的集合，也就是所谓的“类库
45.常用的包，类，接口，各举5个。
类 String Integer Long File Date 包 java.lang.*;java.io.*;java.util.*;java.swt.*;
java.math.*;接口: Comparable ,Connection,Map,List,Runable,
46.
- 网上购物系统的类图，用例图。
- 给你一个整数类型的数组，按从小到大的顺序进行排列！
public static void fun(int [] a,int c)
{
for(int i=0;i<a.length-1;i++)
{
for(int j=i;j<a.length-1;j++)
{
if(a[i]<a[j])
{
t=a[i];
a[i]=a[j];
a[j]=t;
}
}
System.out.print(a[i]+" ");
}
}
查询出M 页的N行数据 。
Select top N from table where id not in (select top (M-1)*N id from table )
1.linkedlist arraylist内部是如何实现的 new ArrayList(10)含义
47.面向对象主要内容? 有什么作用？
就分析设计层面来说，面向对象技术提供了更高级的抽象能力以及更多的方法和工具，如设计模式； 就实现维护层面来说，面向对象技术使代码重用更容易，且使代码具有可扩展性，便于软件的维护和升级更新。
49.如何移动一个数 是62-63=1成立
62-63=1如何移动 2的6次方等于64 2的6次方-63=1 把2移动到6的左下方
50.Java SQL2005导入import data数据源例如有Oracle中的blob字段是否要用ole驱动、递归实现1,1,2,3,5,8,….第30个数是多少？
public static int Foo(int i)
{
if (i <= 0)
return 0;
else if(i > 0 && i <= 2)
return 1;
else return Foo(i -1) + Foo(i - 2);
}
int i=Foo(30);
System.out.println(i);
51.JAVA实现向数据库添加一列
Connection con = null;
ResultSet rs = null;
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name";
Connection con = DriverManager.getConnection(url,"","");
StateManager sm =con.createStateMent();
String sql = "inser table into values("aa","bb")";
rs = sm.excute(sql);
52.写出删除表中重复记录的语句 oracle
delete from people
where peopleId in (select peopleId from people group by peopleId having count(peopleId) > 1) and rowid not in (select min(rowid) from people group
1： 用什么方法使服务器关闭之后，session所保存的信息不会丢失？
使用cookie
2：如果页面没有<html></html>标签，会出现什么错误代码？
没有什么变化
3：抽象类是否可以没有抽象方法？为什么？
可以 在java中用abstract关键字来修饰一个类时，这个类叫做抽象类。
抽象类中不一定要包含abstract方法，但一个类中包含了abstract方法，则这个类必须声明为abstract类。
4：servlet中的init方法什么时候被调用？
容器首次创建实例的时候
53.用4 个0，用你所知道的数学方法计算出24
0的阶乘等于1 即 0！＝１那么４个0就是４了
又4的阶乘为２４ ４！＝２４
54.linux中进程的查看和调度分别用什么命令？
ps -A 查看 renice top
55.sleep()和wait区别
sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后
56.集合类有哪些？有哪些方法？
集合类 ArrayList LinkedList HashSet HashMap方法：add(),remove(),put(),addAll(),removeAll()
57.OSI七层模型tcp四层模型是什么样的
OSI七层参考模型 ：物理层 、数据链路层 、网络层 、传输层、应用层、会话层、表示层
TCP/IP:第一层网络接口层第二层 第二层??网间层 第三层??传输层 第四层??应用层
58.JAVA测试模式(ZZ)：
模式（一） Main 模式
模式（二） toString 模式
模式（三） Equal 模式
模式（四） Internal Tester Class 模式
模式（五） Extern Tester Class 模式
60.一学生表！有班及id，学号！成绩！一求平均成绩！二求比平均成绩高的学生的所有信息
select id,avg(成绩) from table group by id
select * from table where 成绩 > (select 成绩 from （select id,avg(成绩) 成绩 from table group by id）as a )
61.jdk的新特性
“JDK1.5”的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-each 循环，自动装包/拆包，枚举，可变参数, 静态导入 。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。
62.j2ee的规范？
SUN公司定义的一个开发分布式企业级应用的规范。它提供了一个多层次的分布式应用模型和一系列开发技术规范。多层次分布式应用模型是指根据功能把应用逻辑分成多个层次，每个层次支持相应的服务器和组件，组件在分布式服务器的组件容器中运行（如Servlet组件在Servlet容器上运行，EJB组件在EJB容器上运行），容器间通过相关的协议进行通讯，实现组件间的相互调用 J2EE规范定义了以下四个层次。 1.客户端层(Client Tier) 2.Web层 3.业务层(Business Tier) 4.企业信息系统层
63.ajax的工作原理？
Ajax 基本上就是把 JavaScript 技术和 XMLHttpRequest 对象放在 Web 表单和服务器之间。当用户填写表单时，数据发送给一些 JavaScript 代码而不是 直接发送给服务器。相反，JavaScript 代码捕获表单数据并向服务器发送请求。同时用户屏幕上的表单也不会闪烁、消失或延迟。换句话说，JavaScript 代码在幕后发送请求，用户甚至不知道请求的发出。更好的是，请求是异步发送的，就是说 JavaScript 代码（和用户）不用等待服务器的响应。因此用户可以继续输入数据、滚动屏幕和使用应用程序。
然后，服务器将数据返回 JavaScript 代码（仍然在 Web 表单中），后者决定如何处理这些数据。它可以迅速更新表单数据，让人感觉应用程序是立即完成的，表单没有提交或刷新而用户得到了新数据。JavaScript 代码甚至可以对收到的数据执行某种计算，再发送另一个请求，完全不需要用户干预！这就是 XMLHttpRequest 的强大之处。它可以根据需要自行与服务器进行交互，用户甚至可以完全不知道幕后发生的一切。结果就是类似于桌面应用程序的动态、快速响应、高交互性的体验，但是背后又拥有互联网的全部强大力量。
64.Xml特点？
65.oracle中除了数据库备份，还有什么方法备份？
66.j2ee的常用设计模式
Factory（工厂模式）,Builder（建造模式）fFactory Method（工厂方法模式），Prototype（原始模型模式），Singleton（单例模式），Facade（门面模式），Adapter（适配器模式），Bridge（桥梁模式）
67.由aaa字符串得到1000个a写个程序
StringBuilder sBuilder = new StringBuilder();
for(int i=0;i<333;i++){
sBuilder.Append("aaa");
}
sBuilder.Append("aaa".subString(0,1));
68.servlet与cgi的区别
CGI应用开发比较困难，因为它要求程序员有处理参数传递的知识，这不是一种通用的技能。CGI不可移植，为某一特定平台编写的CGI应用只能运行于这一环境中。每一个CGI应用存在于一个由客户端请求激活的进程中，并且在请求被服务后被卸载。这种模式将引起很高的内存、CPU开销，而且在同一进程中不能服务多个客户。
Servlet提供了Java应用程序的所有优势——可移植、稳健、易开发。使用Servlet Tag技术，Servlet能够生成嵌于静态HTML页面中的动态内容
Servlet对CGI的最主要优势在于一个Servlet被客户端发送的第一个请求激活，然后它将继续运行于后台，等待以后的请求。每个请求将生成一个新的线程，而不是一个完整的进程。多个客户能够在同一个进程中同时得到服务。一般来说，Servlet进程只是在Web Server卸载时被卸载
69.SOCKET中有几中连接方式，区别？
Sockets有两种主要的操作方式:面向连接的和无连接的。无连接的操作使用数据报协议，无连接的操作是快速的和高效的,但是数据安全性不佳. 面向连接的操作使用TCP协议.面向连接的操作比无连接的操作效率更低,但是数据的安全性更高
70.Socket如何获取本地ip地址？
public InetAddress getLocalAddress()
71.truncate与delete的区别？
truncate是DDL語言.delete是DML語言 DDL語言是自動提交的.命令完成就不可回滾.truncate的速度也比delete要快得多.
72.xml有哪些解析技术，及区别？
有DOM,SAX,STAX等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件 ，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问
73.文件和目录(i/o)操作，怎么列出某目录下所有文件？某目录下所有子目录，怎么判断文件或目录是否存在？如何读写文件？
列出某目录下所有文件：调用listFile()，然后判断每个File对象是 isFile还是 isAbstracte()，判断文件或目录是否存在：调用 exist 方法，读写文件使用FileReader和FileWriter两个类即可
74.delete from tablea和truncate table tablea的区别！
这里说的delete是指不带where子句的delete语句
相同点:truncate和不带where子句的delete, 以及drop都会删除表内的数据
不同点:
1. truncate和 delete只删除数据不删除表的结构(定义)
drop语句将删除表的结构被依赖的约束(constrain),触发器(trigger),索引(index); 依赖于该表的存储过程/函数将保留,但是变为invalid状态.
2.delete语句是dml,这个操作会放到rollback segement中,事务提交之后才生效;如果有相应的trigger,执行的时候将被触发.
truncate,drop是ddl, 操作立即生效,原数据不放到rollback segment中,不能回滚. 操作不触发trigger.
3.delete语句不影响表所占用的extent, 高水线(high watermark)保持原位置不动
显然drop语句将表所占用的空间全部释放
truncate 语句缺省情况下见空间释放到 minextents个 extent,除非使用reuse storage; truncate会将高水线复位(回到最开始).
4.速度,一般来说: drop> truncate > delete
5.安全性:小心使用drop 和truncate,尤其没有备份的时候.否则哭都来不及
使用上,想删除部分数据行用delete,注意带上where子句. 回滚段要足够大.
想删除表,当然用drop
想保留表而将所有数据删除. 如果和事务无关,用truncate即可. 如果和事务有关,或者想触发trigger,还是用delete.
75.怎么用java反射得到一个类的私有方法？
PrivateTest t= Class.forName("com.test.PrivateTest").newInstance();
Method method2 = Class.forName("com.test.PrivateTest").getDeclaredMethod("method", new Class[]{});
method2.setAccessible(true);
method2.invoke(t, new Object[] {});
76.写一个单例模式？描述工厂模式和单例优缺点 举例在什么情况下用
- 简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。通过它，外界可以从直接创建具体产品对 象的尴尬局面中摆脱出来。
- 外界与具体类隔离开来，偶合性低。
- 明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
缺点：工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则 虽然简单工厂模式能够适应一定的变化，但是它所能解决的问题是远远有限的。它所能创建的类只能是事先教考虑到的，如果需要添加新的类，则就需要改变工厂类了。（这个问题在工厂方法模式将得到很好的解决）
应用情景 工厂类负责创建的对象比较少 客户只知道传入了工厂类的参数，对于始何创建对象（逻辑）不关心
77.JVM加载class文件原理？
JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类 ClassLoader 其实就是读取文件，按照CLASSPATH配置的顺序。 然后解析后转化为类
78.Tomcat的class加载的优先顺序一览
1.最先是$JAVA_HOME/jre/lib/ext/下的jar文件。2.环境变量CLASSPATH中的jar和class文3.$CATALINA_HOME/common/classes下的class文件。4.$CATALINA_HOME/commons/endorsed下的jar文件。
5.$CATALINA_HOME/commons/i18n下的jar文件。6.$CATALINA_HOME/common/lib 下的jar文件。
（JDBC驱动之类的jar文件可以放在这里，这样就可以避免在server.xml配置好数据源却出现找不到JDBC Driver的情况。）
7.$CATALINA_HOME/server/classes下的class文件。
8.$CATALINA_HOME/server/lib/下的jar文件。
9.$CATALINA_BASE/shared/classes 下的class文件。
10.$CATALINA_BASE/shared/lib下的jar文件。
11.各自具体的webapp /WEB-INF/classes下的class文件。
12.各自具体的webapp /WEB-INF/lib下的jar文件。
79.CS与BS联系区别
java适合开发bs结构，cs不是它的强项 C/S 服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQL Server。客户端需要安装专用的客户端软件。B/S 客户机上只要安装一个浏览器（Browser），如Internet Explorer，服务器安装Oracle、Sybase、Informix或 SQL Server等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现。浏览器通过Web Server 同数据库进行数据交互 1．硬件环境不同: C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务. B/S 建立在广域网之上的
2．对安全要求不同 C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通过B/S发布部分可公开信息. B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户
3．对程序架构不同 C/S 程序可以更加注重流程, 可以对权限多层次校验 B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上
80.Error和 exception的区别与联系
error 表示恢复不是不可能,但很困难的情况下的一种严重问题。比如说内存溢,网络故障等。不可能指望程序能处理的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，就不会发生的情况。程序可以捕获到这些异常，并进行处理。
81.在编写页面的会用到哪些技术？？
手写个程序 在本页面中心弹出一个窗体，里面有学生的成绩，可以修改学生的成绩，并且可以关闭窗口，把每个要用的jsp页面显示出来。（用 JavaScript）
82.用main涵数输出一到一百的和。
#include <stdio.h>
int main() {
printf("sum:%d\n", sum());
return 0;
}
int sum() {
int i;
int sum = 0;
for (i = 1; i <= 100; i++)
sum += i;
return sum;
}
83.查一下每门课程都大于80的学生姓名
学生表student 分数表grade
select s.name from student s where s.id no in(select g.studentid from grade g where g.marks<=80)
select * from student where name in (select name from student
where name like '张%' group by name having avg(score) > 75)
84.LIUNIX如何查看CPU,IP,内存？
lsattr -EI memo 查看内存的
/sbin/ifcong 查看 IP的
85.j2EE系统访问速度慢.从哪些方面可以优化
J2EE性能的优化包括很多方面的，要达到一个性能优良的系统，除了关注代码之外，还应该根据系统实际的运行情况，从服务器软硬件环境、集群技术、系统构架设计、系统部署环境、数据结构、算法设计等方面综合考虑
86.J2EE访问速度慢，怎么样优化
1 使用缓冲标记 对于代码逻辑复杂的页面，利用缓冲标记提高性能的效果比较明显；反之，效果可能略逊一筹。 2 始终通过会话Bean访问实体Bean
一些时候，使用实体Bean会导致程序性能不佳。如果实体Bean的惟一用途就是提取和更新数据，改成在会话Bean之内利用JDBC访问数据库可以得到更好的性能 3 选择合适的引用机制
4 在部署描述器中设置只读属性 实体Bean的部署描述器允许把所有get方法设置成“只读”。当某个事务单元的工作只包含执行读取操作的方法时，设置只读属性有利于提高性能，因为容器不必再执行存储操作 5 缓冲对EJB Home的访问
87.haShtable的原理
原理:通过节点的关键码确定节点的存储位置,即给定节点的关键码k,通过一定的函数关系H(散列函数),得到函数值H(k),将此值解释为该节点的存储地址
88.struts中的prepare怎么用？
prepare是在validate拦截器之前执行
<s:checkboxlist list="users" listKey="id" listValue="name" name="userid"></s:checkboxlist>
在使用struts2 checkboxlist,select绑定list时，有时候会出现 以下异常
The requested list key 'users' could not be resolved as a collection/array/map/enumeration/iterator type. Example: people or people.{name} - [unknown location]这样的错误。是因为list的值为空
3. 解决办法是把初始化list的工作放到prepare拦截器中
public class RoleAction extends ActionSupport implements Preparable{
@Override
public void prepare() throws Exception {
//初始化list
} }
89.C#题目conetextmenu控件如何使用.. listview
ContextMenu 组件提供与选定对象相关的常用命令的菜单。可以通过向 MenuItems 集合中添加 MenuItem 对象来向快捷菜单中添加项。可以从快捷菜单中永久地移除项；但是在运行时隐藏或禁用项可能更为妥当。
90.写一条SQL语句，查询姓张学生中平均成绩大于75的学生信息
select * from student where name in (select name from student
where name like '张%' group by name having avg(score) > 75)
91.从以下方面比较strut1和strut2:线程模式、依赖、可测性、表达式语言、捕获输入、绑钉值到页面、类型转换
线程模式: Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
• Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）
Servlet 依赖:
• Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
• Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。
可测性:
• 测试Struts1 Action的一个主要问题是execute方法暴露了servlet API（这使得测试要依赖于容器）。一个第三方扩展－－Struts TestCase－－提供了一套Struts1的模拟对象（来进行测试）。
• Struts 2 Action可以通过初始化、设置属性、调用方法来测试，“依赖注入”支持也使测试更容易。
捕获输入:
• Struts1 使用ActionForm对象捕获输入。所有的ActionForm必须继承一个基类。因为其他JavaBean不能用作ActionForm，开发者经 常创建多余的类捕获输入。动态Bean（DynaBeans）可以作为创建传统ActionForm的选择，但是，开发者可能是在重新描述(创建)已经存 在的JavaBean（仍然会导致有冗余的javabean）。
• Struts 2直接使用Action属性作为输入属性，消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的rich对象类型。Action属性能够通过 web页面上的taglibs访问。Struts2也支持ActionForm模式。rich对象类型，包括业务对象，能够用作输入/输出对象。这种 ModelDriven 特性简化了taglib对POJO输入对象的引用。
表达式语言：
• Struts1 整合了JSTL，因此使用JSTL EL。这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱。
• Struts2可以使用JSTL，但是也支持一个更强大和灵活的表达式语言－－"Object Graph Notation Language" (OGNL).
绑定值到页面（view）:
• Struts 1使用标准JSP机制把对象绑定到页面中来访问。
• Struts 2 使用 "ValueStack"技术，使taglib能够访问值而不需要把你的页面（view）和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面（view）。
类型转换：
• Struts 1 ActionForm 属性通常都是String类型。Struts1使用Commons-Beanutils进行类型转换。每个类一个转换器，对每一个实例来说是不可配置的。
• Struts2 使用OGNL进行类型转换。提供基本和常用对象的转换器。
92.struts的工作原理可分为如下8步。
1.读取配置（初始化ModuleConfig对象）
Struts框架总控制器（ActionServlet）是一个Servlet，在web.xml中被配置成一个自动启动的Servlet。读取配置文件struts-config.xml的配置信息，为不同的Struts模块初始化相应的ModuleConfig对象。
2.用户请求
用户提交表单或调用URL向WEB应用程序服务器提交一个请求，请求的数据用HTTP协议上传给WEB服务器。
3.填充FormBean
（*.do请求）从ActionConfig中找出对应该请求的Action子类，如有对应的Action且这个Action又一个相应的ActionForm，ActionForm被实例化并用HTTP请求的数据填充其属性，并保存在ServletContext中，这样他们就可以被其它Action对象或JSP调用。如果没有对应的Action，控制器则直接转发给JSP或静态页面。
4.派发请求
控制器根据配置信息ActionConfig将请求派发到具体的Action，相应的FormBean一并传给这个Action的execute()方法。
5.处理业务
Action一般只包含一个execute方法，它负责执行相应的业务逻辑。执行完毕后返回一个ActionFoward对象，控制器通过该ActionFoward对象来进行转发工作。
6.返回响应
Action根据业务处理的不同结果返回一个响应对象给总控制器，该目标响应对相对应一个具体的JSP页面或另一个Action。
7.查找响应
总控制器根据业务功能Action返回的目标响应对象找到对应的资源对象，通常是一个具体的JSP页面。
8.响应用户
JSP将结果展现给用户。
93 Spring工作原理
内部最核心的就是IOC了，动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射,反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置文件来动态的创建对象，和调用对象里的方法的 还有一个核心就是AOP这个就是面向切面编程，可以为某一类对象 进行监督和控制（也就是在调用这类对象的具体方法的前后去调用你指定的 模块）从而达到对一个模块扩充的功能。这些都是通过配置类达到的
Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明 管理的（Spring根据这些配置 内部通过反射去动态的组装对象）要记住：Spring是一个容器，凡是在容器里的对象才会有Spring所提供的这些服务和功能
94.Hibernate 的初始化.
读取Hibernate 的配置信息-〉创建Session Factory
1)创建Configeration类的实例。
它的构造方法：将配置信息(Hibernate config.xml)读入到内存。
一个Configeration 实例代表Hibernate 所有Java类到Sql数据库映射的集合。
2)创建SessionFactory实例
把Configeration 对象中的所有配置信息拷贝到SessionFactory的缓存中。
SessionFactory的实例代表一个数据库存储员源，创建后不再与Configeration 对象关联。
缓存(cache):指Java对象的属性(通常是一些集合类型的属性－－占用内存空间。
95在main方法中将字符串中的。数字排序并输出 STRING A="56.89.5.3.75.98.98.26.15.44"
String s=” 56.89.5.3.75.98.98.26.15.44”;
String s1[]=s.spit(“.”);
Integer ii[]=new Integer[s1.length];
For(int i=0;i<s1.length;i++){
ii[i]=Integer.parseInt(s1[i]);
}
Arrays.sort(ii);
for(Integer o: ii){
System.out.println(o+” s”);
}
96Oracle冷备份的通常步骤
1 正常关闭数据库 2 备份所有重要的文件到备份目录（数据文件、控制文件、重做日志文件等）
3 完成备份后启动数据库用冷备份进行恢复时，只需要将所有文件恢复到原有位置，就可以启动数据库了
- 关闭数据库 SQL>shutdown 5 备份文件到备份的目录 6 然后启动数据库 ＃sqlplus "/as sysdba"SQL>startup 冷备份完毕！！
97．servlet 创建过程以及ruquest，response，session的生命周期？
Servlet的创建过程：
第一步
public class AAA extends HttpServlet{
实现对应的doxxx方法
}
第二步:
在web.xml中配置
<servlet>
<servlet-name></servlet-name>
<servlet-class></servlet-class>
</servlet>
<servlet-mapping>
<servlet-name></servlet-name>
<url-pattern></url-pattern>
</servlet-mapping>
servlet的生命周期：
servlet容器创建servlet的一个实例
容器调用该实例的init()方法
如果容器对该servlet有请求，则调用此实例的service()方法
容器在销毁本实例前调用它的destroy()方法
销毁并标记该实例以供作为垃圾收集
一旦请求了一个servlet，就没有办法阻止容器执行一个完整的生命周期。
容器在servlet首次被调用时创建它的一个实例，并保持该实例在内存中，让它对所有的请求进行处理。容器可以决定在任何时候把这个实例从内存中移走。在典型的模型中，容器为每个servlet创建一个单独的实例，容器并不会每接到一个请求就创建一个新线程，而是使用一个线程池来动态的将线程分配给到来的请求，但是这从servlet的观点来看，效果和为每个请求创建一个新线程的效果相同。
９８。手写个单例模式？每个公司基本都考
public class danli {
private static danli dl;
private danli(){
System.out.println("单例模式");
}
public static danli getconnection()
{
if(dl==null)
{
dl=new danli();
}
return dl;
}
}
map保存key-value 值，value可多值；
９９。解释一下mvc以及熟悉的mvc框架
答:m代表模型层，v 代表视图层，c代表控制层，也就是把一个整体分割成不同的模块，各负责自己的功能，分工明确，提高代码的重用性和交互。如 struts2.0,其中m是action,c是拦截器，v是jsp.
１００。解释一下IOC,以及spring的举例
首先 ioc是Spring的核心组件，它的主要是依赖于注入而不依赖于实现，通过对象实例的注入，解决了各个组件的耦合度，提高代码的重用(举例在项目的应用)
Oracle和Sqlserver的区别？数据库里面的语言符号表示？
１０１。浏览器页面与T0MCat的交互过程！
Tomcat根据第1次和第2次请求中所指定Host头的值，查找Server.xml文件中与之相匹配的<Host>元素的name属性值，并以匹配的<Host>元素所设置的WEB站点来响应；
在第3次和第4次请求中所指定Host头的值，在Server.xml文件中没有与之对应的<Host>元素的name属性值，Tomcat将以默认的WEB站点来响应。
１０２。用C编写将一个100以内的自然数分解质因数
#include<stdio.h>
main()
{
int i,j;
for(i=2;i<100;i++)
{
for(j=2;j<i;j++)
{
if(i%j==0)
break;
}
if(i==j)
{
printf("%d ",i);
}
}
}
１０３。用一个方法查出宜个数值类型数组的最大值，用递归方式实现
方法1
public class Test1 {
public static int a(int[] i,int j){
if(i.length-1>j){
if(i[j]>i[j+1]){
i[j+1]=i[j];
}
return a(i,j+1);
}else{
return i[i.length-1];
}
}
}
方法2
public static int test(int []num) int x=0; int log = num.Length;for(intt=0;t<log;t++){ if(num[t]>x){ x=num[t]; } }return x;}
１０４。JSP与SERVLET区别
1.jsp中的out直接用，而servlet中还要自己声明（如PrintWriter out = response.getWriter();）
2.html中的name的值传给.java或者.jsp中的getParameter("name")
3.servlet的本质为java类，jsp编译的中间产物是servlet
4.在servlet中有doGet与doPost方法，而在jsp中没有这些方法
１０５。xmlhttprequest.open()里面有几个方法?
xmlHttp.open("GET","ProcessServlet",true);当指定GET时
send方法的参数必须是null或者"",如果写成xmlHttp.send("xml="+xmlReqFile);
这样加了参数了，就自动改为调用Post方法，写成xmlHttp.send("sadfgsalg");也会调用Post方法
１０６。java优缺点
优点：功能完善，成熟的API，上手快，容易掌握，开元，众多框架支持，便捷的网络开发特性 缺点：不够底层，安全性不高容易被反编译
优点是可移植性比较高，最初设计时就是本着一次编写到处执行设计的。可以开发各种应用程序和游戏，不过速度没有c++快， java主要分三块，j2se：java的基础核心语言。j2me：java的微型模块，专门针对所以一般是不用java来编写应用程序和电脑游戏。
内存小，没有持续电源等小型设备。j2ee：java的企业模块，专门针对企业数据库服务器的连接维护。 手机用到的是用j2me所编出来的小程序。
java比较简单,没有C++的烦琐,但学习时最好有C++为基础.与JSP和SQL起应用,功能强大. 主要缺点就是:速度比较慢,没有C和C++快
１０７。写一个单例Signleton代码
public void getConn(){ private getConn getconn; private getConn(){} public void getConnection(){ if(getconn==null){ getConn conn=new getConn(); } } }
１０８。Mvc各部分用什么实现？
m用javabean实现 v 用jsp javascript c用action servlet实现
１０９。ejb是基于哪些技术实现的，和javabean的区别？
EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现 EJB是一个关于用JAVA语言开发的可部署的服务器端组件的组件体系结构。它是一个技术协议，能使组件运行于任何应用服务器,专门用来解决商务问题JAVABEANS是JAVA类，是由属性、事件和方法组成的JAVA组件，它们可以用来组成JAVA应用程序
１１０。适配器模式解释： 把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类 能够一起工作。适配类可以根据参数返还一个合适的实例给客户端
１１１。进程和线程的区别：线程是一种操作系统对象，代表着一个进程中要被执行的代码的路径。每一个WIN32应用程序至少有一个线程--通常称为住线程或默认线程--但应用程序可以自由地创建其他线程来执行其他任务！
进程是程序的一次动态执行过程，它对应了从代码加载、执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到消亡的过程 线程是比进程更小的执行单位。一个进程在其执行过程能够中，可以产生 多个线程，形成多条执行线索。每条线索，即每个线程也有它自身的产生、存在和消亡过程，也是一个动态的概念
１１２、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）
short s1 = 1; s1 += 1;（可以正确编译）
１１３。写一个程序,把一个文件的数组按对角线做对称变换,并输出!
一个正方形里面全数字,写一个程序,成对角线转变! 我做的这个是3行3列的对角互换，也许转换规则不一样
public class testMain {
public static void main(String[] args) {
int a[][]=new int[3][3];
int c=1;
//初始化数据
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
a[i][j]=c++;
}
}
System.out.println("转换之前：");
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
System.out.print("a["+i+"]["+j+"]="+a[i][j]+" ");
}
System.out.println("\n");
}
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if((i+1<3&&j+1<3)&&i==j&&i!=0&&i!=3-i){
int temp=a[i-1][j-1];
a[i-1][j-1]=a[i+1][j+1];
a[i+1][j+1]=temp;
temp=a[i-1][j+1];
a[i-1][j+1]=a[i+1][j-1];
a[i+1][j-1]=temp;
}
}
}
System.out.println("转换之后：");
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
System.out
print("a["+i+"]["+j+"]="+a[i][j]+" ");
}
System.out.println("\n");
}
}
}
- 再SSH框架中，用流程表示处理过程。从Request, Response
- 人民币小写转成大写，写个java程序和思路（写10100.00转成汉字壹万零壹百整）
public class Money {
public static void main(String[] args) {
// 金额大小写转换
float money = 2038.0f;
int m1, m2, m3, m4, m5, m6, temp;
temp = (int) (money * 100);
System.out.println(money);
m1 = temp % 1000000 / 100000;
m2 = temp % 100000 / 10000;
m3 = temp % 10000 / 1000;
m4 = temp % 1000 / 100;
m5 = temp % 100 / 10;
m6 = temp % 10;
char c1, c2, c3, c4, c5, c6;
c1 = transe(m1);
c2 = transe(m2);
c3 = transe(m3);
c4 = transe(m4);
c5 = transe(m5);
c6 = transe(m6);
String str = "";
if (m1 != 0) {
str += c1 + "千";
}
if (m2 != 0) {
str += c2 + "百";
}
if (m1 != 0 && m2 == 0 && (m3 != 0 || m4 != 0)) {
str += "零";
}
if (m3 != 0) {
str += c3 + "十";
}
if (m2 != 0 && m3 == 0 && m4 != 0) {
str += "零";
}
if (m4 != 0) {
str += c4;
}
str += "元";
if (m5 == 0 && m6 == 0) {
str += "整";
}
if (m5 != 0) {
str += c5 + "角";
}
if (m5 == 0 && m6 != 0) {
str += "零";
}
if (m6 != 0) {
str += c6 + "分";
}
System.out.print(str + "\n");
System.out.println("..........................");
}
public static char transe(int m) {
char r = ' ';
switch (m) {
case 0:
r = '零';
break;
case 1:
r = '壹';
break;
case 2:
r = '贰';
break;
case 3:
r = '叁';
break;
case 4:
r = '肆';
break;
case 5:
r = '伍';
break;
case 6:
r = '陆';
break;
case 7:
r = '柒';
break;
case 8:
r = '捌';
break;
case 9:
r = '玖';
break;
}
return r;
}
}
针对一个分期付款，总期为1年，给定分期金额，期数和开始还款时间，计算出各期还款日期。
package demo;
import java.util.Calendar;
import java.util.Date;
public class TestDemo {
// 分期付款，总期为1年，给定分期金额，期数和开始还款时间
// 计算出各期还款日期
public void huankuan(double amount,int num,Date start){
int period = 365/num; // 一年中分期间隔天数
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, start.getYear()+1900);
cal.set(Calendar.MONTH, start.getMonth());
cal.set(Calendar.DATE, start.getDate());
for(int i=1;i<=num;i++){
System.out.println(" 第" + i + "期还款日期: " + cal.getTime().toLocaleString());
cal.add(Calendar.DATE, period);
}
}
public static void main(String[] args) {
TestDemo demo = new TestDemo();
demo.huankuan(20000.00, 1, new Date());
}
}
117.用java写从1加到100
sum = (1+i)*i/2 i=100 最简单的方法
public class Hello5050{
public static void main(String[] args){
for (int i=1;i<=100;i=i++)
{
System.out.println(++i);
}
}
}
118．SSH的优点和缺点
优点： ssh把数据库，实体，配置都整合，封装
层次的结构（偏于mvc模式）
而且框架的融合，代码的耦合都很不错
对于编程的持续化，扩展化，维护化都很棒 ，SSH已经把底层实现封装好了，开发人员可以更专注于业务处理，
缺点： 出现错误容易搞的复杂
如果某个框架不是很熟悉的话（特别是spring）那就很麻烦
运行速度比较慢
119．用JDBC来实现访问数据库记录可以采用下面的几个步骤：
1、 通过驱动器管理器获取连接接口。
2、 获得Statement或它的子类。
3、 限制Statement中的参数。
4、 执行Statement。
5、 查看返回的行数是否超出范围。
6、 关闭Statement。
7、 处理其它的Statement
8、 关闭连接接
120．overload和override的区别
override是方法重载，用在同一个类中，是几个方法的名字相同，返回值相同，但是参数列表不同，举例来说就像构造函数，可以后多个构造函数，并且每个的参数列表都不同，这样可以用多种方式构造对象。
overload是方法覆盖，用在父子类中，是方法名字相同，参数列表也相同，声明形式都相同，但是子类方法的权限不允许小于父类，不允许抛出比父类更多的异常
121．最常见的runtime exception运行时异常？
数字转换异常，类异常ClassCastException NumberFormatException ArrayIndexOutOfBoundsException:数组越界 ClassCastException:类型转换错误
ArithmeticException：算术错误，典型的就是0作为除数的时候。IllegalArgumentException：非法参数 IndexOutOfBoundsException NullPointerException
SystemException ArrayStoreException
122．描述工厂模式和单例优缺点 举例在什么情况下用。
单例 保证一个类只有单一的实例，也就是说你无法通过New或CreateInstance来创建这个类的一个新实例 好处：当一个对象在程序内部只能有一个实例的时候，它可以保证我们不会重复创建，而是始终指向同一个对象。 缺点就是 它就是在内存上共享，都可以去访问它，而且多个用户访问的都是同一个实例，会造成线程不安全。
/** *//**
* IOC模式简单实例
*/
/** *//**
* 运行类
*/
public class MainClass {
/** *//**
* 主函数
*/
public static void main(String[] args) {
try {
PrinterFactory.createPrinter().printByString("Hello World~!");
} catch (Exception ex) {
System.out.println(ex.toString());
}
}
}
/** *//**
* Printer接口
*/
interface IF_Printer {
/** *//**
* 接口printByString方法声明
*/
public void printByString(String str);
}
/** *//**
* MyPrinter实现Printer接口
*/
class MyPrinter implements IF_Printer {
public void printByString(String str) {
System.out.println(str);
}
}
/** *//**
* IF_Printer对象工厂,用于创建实现接口的类对象
*/
class PrinterFactory {
/** *//**
* 工厂方法,返回IF_Printer接口实例
*/
public static IF_Printer createPrinter() throws InstantiationException,
ClassNotFoundException, IllegalAccessException {
String str = "MyPrinter";//通过字符串寻找实现接口的类,字符串可从文件中读取获得,从而实现IOC模式
return (IF_Printer) Class.forName(str).newInstance();//返回IF_Printer接口实例
}
}
123．创建一个序列号,从1000开始,每次增加1,最大到999999
create sequence newstudno increment by 1
start with 10001 maxvalue 99999
124．设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
public class ThreadTest1{
private int j;
public static void main(String args[]){
ThreadTest1 tt=new ThreadTest1();
Inc inc=tt.new Inc(); Dec dec=tt.new Dec();
for(int i=0;i <2;i++){
Thread t=new Thread(inc);
t.start();
t=new Thread(dec); //???这个前面不要加Thread吗
t.start();
}
}
private synchronized void inc(){ //???为什么要加锁呢 不加可以吗
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
} //???currentThread()有什么作用呢是什么方法
//???getname呢
private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
}
class Inc implements Runnable{
public void run(){
for(int i=0;i <100;i++){
inc();
}
}
}
class Dec implements Runnable{
public void run(){
for(int i=0;i <100;i++){
dec(); } } } }
125．十六进制的216转换十进制是多少：
216是16进制，转10进制:
＝2*16^2+1*16^1+6*16^0
=512+16+6
=536
126．Java中的XML解析方式： dom和jdom解析
127．、UML几种图及用途？
分析阶段：用例图、活动图。
观察对象的交互：交互图。
设计阶段：类图。
观察一个对象在不同状态下的不同行为：状态图。
配置阶段：配置图
分析阶段： 1、用Use Case图描述用户需求，确定项目范围
2、用Sequence描述每个Case的可能的处理流程（一个case可以对
应多个Sequence图）
3、用Collaboration图检查对象之间的行为负载
设计阶段： 1、设计Class（数据库设计还是用ERWin好）
开发阶段： 1、生成代码框架
128．、列举你接触过的框架，说明特点和原理
struts框架具有组件的模块化，灵活性和重用性的优点，同时简化了基于MVC的web应用程序的开发，缺点：Taglib是Struts的一大优势，但对于初学者而言，却需要一个持续学习的过程，甚至还会打乱你网页编写的习惯 Struts将MVC的Controller一分为三，在获得结构更加清晰的同时，也增加了系统的复杂度
工作原理 ：用一个servlet拦截用户的请求，并分发到具体的action中去处理，再将返回的response进行封装，这是处理页面流程的机制，另外还有一些标签，非常容易在页面进行显示
129．Struts Hibernate Spring 在程序中用到哪些
Struts用到的就是它的标签，Hibernate就是O/R mapping对象关系映射，Spring就是IoC控制反转
130．你对面向对象思想的理解？
面向对象是与面向过程相对应的 一般的编程语言（c语言等）是把程序当作一个不可分割的语言段整体 其中的子函数和主函数是调用关系 子函数或主函数的变化都会引起程序的不稳定
面向对象是将程序分割乘不同的类 子函数可以是类主函数也可以是类 然后再对类进行封装 定义各个类的级别和访问权限以确保程序的稳定性
数组和链表的理解，及优缺点？
数组在内存中开辟连续的一块区域，如果一个数据要两个内存单元，一组5个数据10个单元就够了，无需标记其地址，因为数组定义时候标顶了第一个原许的地址，其他四个都知道了
链表可可以是连续的，也可以是不连续的，但一般都是不连续的，尽管在内存中是连续的，我们也不把他当作是连续的，而是把他当作是不连续的，因为如果把他当作是连续的，不如当作是数组了
数组的优点是速度快，数据操作直接使用偏移地址，链表需要按顺序检索节点，效率低.链表的优点是可以快速插入和删除节点，大小动态分配长度不需要固定 链表不存在越界问题，数组有越界问题
131．写几个java.lang.Object类中的方法名称
equals(); toString(); getClass(); hashCode(); clone() finalize() notify() wait() notify()
132．js中加VAR与不加VAR的区别？
在全局作用域中可以不使用var声明变量，但在声明局部变量时，一定要使用var语句.
加了var:在局部函数中加了var说明是局部变量,只对该函数起作用.
不加var:在局部函数中不加的话,说明是给这个全局变量重新赋值.其结果为重新赋值后的.
Struts 1要求Action类要扩展自一个抽象基类。Struts 1的一个共有的问题是面向抽象类编程而不是面向接口编程。
Struts 2的Action类实现了一个Action接口，连同其他接口一起实现可选择和自定义的服务。
Struts 1 Action类是单例类，因只有一个示例控制所有的请求。
Struts 2 Action对象每一个请求都实例化对象，所以没有程安全的问题。
133．jsp有哪些的动作？分别有什么作用？
答： jsp:include：在页面被请求的时候引入一个文件。
jsp:useBean：寻找或者实例化一个JavaBean。
jsp:setProperty：设置JavaBean的属性。
jsp:getProperty：输出某个JavaBean的属性。
jsp:forward：把请求转到一个新的页面。
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记。
134．用oracle写向mine表中差入miname字段？
ALTER TABLE MINE ADD MINNAME VARCHAR2(10);
135．oracle有哪几个对象？
Oracle数据库对象有表、索引、视图、同义词、序列、存储过程、触发器、PL/SQL块等
136．在oracle中，有4个大对象（lobs）类型可用，分别是blob,clob,bfile,nclob。
137．定义两个变量a和b，不使用第三个变量，使两个值交换
public class testMain {
public void test(int a,int b){
System.out.println("交换前a = "+a);
System.out.println("交换前b = "+b);
a=a+b;
b=a-b;
a=a-b;
System.out.println("交换后a = " +a);
System.out.print("交换后b = "+b);
}
public static void main(String args[]){
new testMain().test(10,13);
}
}
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'scriptTree.jsp' starting page</title>
<script type="text/javascript">
function fun1(){
window.showModalDialog("${pageContext.request.contextPath}/user.do?method=login","700");
window.dialogHeight=800;
}
function fun(isd){
var tabIds=document.getElementById(isd);
if(tabIds.style.display=='none'){
tabIds.style.display='inline';
}else{
tabIds.style.display='none';
}
}
</script>
</head>
<body>
<table border="2" borderColor="green" width="75%">
<tr>
<td onclick="fun('tableId1');">树型菜单</td>
<td>菜单名称</td>
</tr>
<tr>
<td colspan="2">
<table id="tableId1" border="2" borderColor="red">
<tr style="display:inline">
<td> kongjian </td>
</tr>
<tr style="display:inline">
<td><a href=""> xiaoxin </a> </td>
</tr>
</table>
</td>
</tr>
</table>
</body>
</html>
138．办公自动化系统用到的技术，分哪些层，有哪些包
使用技术:DWR + Struts + Hibernate + Spring+Ajax+JavaScript
系统架构分为: View层、WEB层、Serivce层、DAO层、持久层(po层)
139．mvc的流程，客户端的请求被发送到哪? m层(模型层)
使用了哪些数据库事务? BeginTransaction、Commit 和 Rollback
.对数据库的访问是怎么实现的
将对持久层数据库的基本添加，修改，查找等操作提取到BaseDAO中,采用JavaBean对数据进行封装，以便对持久层的数据能够很好的处理，实现BaseDAO设计对数据库访问的便捷。业务组件通过DAO 的委托接口调用DAO对象，使得上层组件不 直接依赖于DAO的实现类.
140．接口与抽象类的区别
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接 口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有 程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。 然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到 接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。
141．数据库优化的方案
建立主键，为数据库创建索引，建立存储过程，触发器，可提高查询速度。
142．.冒泡
public static void Bubble(int a[]){
for(int i=0;i<a.length-1;i++){
for(int j=a.length-1;j>i;j--){
if(a[j]<a[j-1]){
a[j]=a[j]+a[j-1];
a[j-1]=a[j]-a[j-1];
a[j]=a[j]-a[j-1];
}
}
}
}
143．常用的设计模式有哪些？并写出一段程序代码
Factory(工厂模式)，Adapter(适配器模式)，Singleton(单例模式)，State(状态模式)，Observer(观察者模式) 等。
public class Singleton{
private static Singleton instance=null;
public static Singleton getInstance(){
if(instance==null){
instance=new Singleton();
}
return instance;
}
}
144．数据库有哪几种结构？
从数据管理的角度看，数据库通常采用三级模式结构，这是数据库管理系统的内部结构；从数据库最终用户的角度看，数据库的结构可分为集中式结构、分布式结构、客户/服务器结构、并型结构，这是数据库的外部的体系
145．css是什么？ABSTRACT是什么意思？（层叠样式表，抽象）
abstract 修饰符可以用于类、方法、属性、事件和索引指示器（indexer），表示其为抽象成员，abstract 不可以和 static 、virtual 一起使用 声明为 abstract 成员可以不包括实现代码，但只要类中还有未实现的抽象成员（即抽象类），那么它的对象就不能被实例化，通常用于强制继承类必须实现某一成员
146．你对Oracle有哪些了解？ （大型数据库，安全性高，稳定性高，功能强大，效率低，价格贵，操作麻烦）
147． 你大学所学习的哪些课程？（会哪些JAVA技术？学过 C语言，c++,c#,java）
148．BBS论坛运用了那些技术，如果你单独开发需要多久，你能够独立完成整个代码的编写吗？（jsp技术，ajax技术，通信技术，）
149．你对博客网有什么认识（典型的网络新事物，指网上写作的一种特定形式和格式。由按时间倒序排列的文档组成的栏目，两侧通常还可以有补充材料，频繁更新，一般大量使用链接）
1.测试覆盖最强的是__d______,最弱的是____c___
A.条件覆盖 B.条件及判定覆盖 C.语句覆盖 D.条件组合覆盖
2.DFD是面向__c____分析方法的描述工具（DFD数据流程图）
A.数据结构 B.数据流 C.对象 D.构件
3.从终端用户的角度来看,事务是一个__B_____
A.对象 B.原子 C.操作 D.子程序
7.构造器是否可以被重写？ 不能
8.char是否可以装一个汉字？ 可以
9.public class Test {
public static void add(Integer i){
int val=i.intValue();
val+=3;
i=new Integer(val);
}
public static void main(String[] args) {
Integer i=new Integer(0);
add(i);
System.out.println(i.intValue());
}
}
打印的结果是0
150．outmermory是个什么问题？你是怎么解决的？
内存溢出 解决方法：手动设置Heap size修改TOMCAT_HOME/bin/catalina.bat
在“echo "Using CATALINA_BASE: $CATALINA_BASE"”上面加入以下行：
JAVA_OPTS="-server -Xms800m -Xmx800m -XX:MaxNewSize=256m"
- &和&&的区别
&,按位与,是位运算符
&&,与，是逻辑运算符
152．数组有没有length()这个方法，String有没有length()这个方
数组没有length()方法，但有length属性
String有length()方法。
- String s=new String(“xyz”)创建了几个对象
2个string对象,一个是=null的s，一个是=“xyz”的string
154．谈谈struts的整个体系？
Struts的目的是为了减少在运用MVC设计模型来开发Web应用的时间。你仍然需要学习和应用该架构，不过它将可以完成其中一些繁重的工作Struts跟Tomcat、Turbine等诸多Apache项目一样，是开源软件，这是它的一大优点，使开发者能更深入的了解其内部实现机制。
除此之外，Struts的优点主要集中体现在两个方面：Taglib和页面导航。Taglib是Struts的标记库，灵活动用，能大大提高开发效率。另外，就目前国内的JSP开发者而言，除了使用JSP自带的常用标记外，很少开发自己的标记，或许Struts是一个很好的起点。
关于页面导航，我认为那将是今后的一个发展方向，事实上，这样做，使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。
MVC即Model-View-Controller的缩写，是一种常用的设计模式。MVC 减弱了业务逻辑接口和数据接口之间的耦合，以及让视图层更富于变化。Struts 是MVC的一种实现，它将 Servlet和 JSP 标记（属于 J2EE 规范）用作实现的一部分。Struts继承了MVC的各项特性，并根据J2EE的特点，做了相应的变化与扩展
155．域名格式要求
英文26个字母和10个阿拉伯数字以及横杠"－"可以用作域名。字母的大小写没有区别；每个层次最长不能超过26个字母；首字或结尾字不能是"."和"-"；域名不能包括有空格；中文暂时不能用作域名。
156．AjAX有什么好处？
用于需要查询数据库才能做的页面校验,再比如实时刷新,再比如良好的用户界面以及快速的响应等等 无刷新、减少网络流量
157．Webservice 有什么好处?
跨平台的可互操作性 跨防火墙的通信 应用程序集成 软件和数据重用
158．JAVA 的缓冲机制？ BufferdStream
159．如何在javascript中实现继续？首先js是单线程的，现在基本除了XHR的callback可以另开一个线程以外，还无法实现多线程，其次timeout是在本次js代码运行完开始计时timeout的，所以在一个耗时的函数之外timeout或者interval一个函数运行本身就是荒谬的，ie下面alert，js函数执行也会阻塞interval执行
160．XMLHTTP的hibernate的save与saveOrUpdate的区别？get与load的区别？
答案: Transient状态--离线状态，Persient状态--持久状态，Detached状态--脱管状态
1.save（）方法，调用save方法时，首先会在session缓存中查找保存对象如果实体对象已经处于Persient状态，直接返回，否在实行sql操作，并将保存的实体对象加入session缓存（save方法不会把实体加入二级缓存的），最后对存在的级联关系进行递归处理。
2.saveOrUpdate（）方法：和save方法一样首先在session缓存中查找，判断对象是否为为保存状态，如果对象处于Persient，不执行操作，处于Transient执行save操作，处于Detached调用save将对象与session重新关联（简单的说就是该方法会先看该对象是否已经存在，如果已经存在就更新，否则新增保存）。
3.get与load的区别？load会先从缓存中查询，如果不存在再到数据库查询；而get是直接从数据库中查询；load的效率会快点（因为他从缓存中查询）
161．连接池的原理
j2ee 服务器启动时会建立一定数量的池连接，并一直维持不少于此数量的池连接。当客户端程序需要连接时，吃驱动程序会返回一个未使用的池连接并将其标记为忙。如果当前 没有空闲连接，池驱动就建立一定新的 连接
162．,用javascript编写脚本小程序，实现点击全选（）
function selectAll(){
var item = document.getElementsByName("ids");
for( var j=0;j<item.length;j++){
if(!item[j].disabled){
item[j].checked = true
}
}
}
<input type="checkbox" name="ids" value="${N.oid}">
<input type=button value="全选" onclick="selectAll()">
163．说一下垃圾回收的原理，可以直接从内存中回收吗?
垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收
164．java的异常有哪几种，有什么区别。
有两中方式:1.捕获异常,自己处理.
throw出去,让别人处理.
165．通过部署描述文件（web.xml）可以配置哪些功能？
监听器。。过滤器。。也可以用来验证XML文件的正确性
166．说一下mvc原理，（关于mvc）
1、模型（Model）
模型是应用程序的主体部分。模型表示业务数据，或者业务逻辑.
2、视图（View）
视图是应用程序中用户界面相关的部分，是用户看到并与之交互的界面。
3、控制器（controller)
控制器工作就是根据用户的输入，控制用户界面数据显示和更新model对象状态。
MVC 式的出现不仅实现了功能模块和显示模块的分离，同时它还提高了应用系统的可维护性、可扩展性、可移植性和组件的可复用性
167．servlet 在MVC中充当的角色: 中心控制器
168．什么是BS和CS
B/S结构是Browser/Server的简称
即浏览器/服务器结构，程序和数据库放在SERVER端，客户端通过
浏览器来访问数据，进行数据交换。
B其实就是BROWSE即浏览器，S就是SERVER,即服务器
也就是说,用户可以用浏览器就可以享受SERVER提供的服务,也就是我们上网的啦
而CS呢,C就是CLIENT即客户端,S就是SERVER,服务端,
也就是说,用户要使用SERVER的服务,需要装上相应的客户端软件,像QQ就是这样的.
C/S又称Client/Server或客户/服务器模式。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQL Server。客户端需要安装专用的客户端软件。
B/S是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如Netscape Navigator或Internet Explorer，服务器安装。Oracle、Sybase、Informix或 SQL Server等数据库。浏览器通过Ｗeb Server 同数据库进行数据交互。
C/S的优点是能充分发挥客户端ＰＣ的处理能力，很多工作可以在客户端处理后再提交给服务器。对应的优点就是客户端响应速度快。
缺点主要有以下几个：
只适用于局域网。而随着互联网的飞速发展，移动办公和分布式办公越来越普及，这需要我们的系统具有扩展性。这种方式远程访问需要专门的技术，同时要对系统进行专门的设计来处理分布式的数据。客户端需要安装专用的客户端软件。首先涉及到安装的工作量，其次任何一台电脑出问题，如病毒、硬件损坏，都需要进行安装或维护。特别是有很多分部或专卖店的情况，不是工作量的问题，而是路程的问题。还有，系统软件升级时，每一台客户机需要重新安装，其维护和升级成本非常高。
对客户端的操作系统一般也会有限制。可能适应于Win98, 但不能用于win2000或Windows XP。或者不适用于微软新的操作系统等等，更不用说Linux、Ｕnix等。
B/S最大的优点就是可以在任何地方进行操作而不用安装任何专门的软件。只要有一台能上网的电脑就能使用，客户端零维护。系统的扩展非常容易，只要能上网，再由系统管理员分配一个用户名和密码，就可以使用了。甚至可以在线申请，通过公司内部的安全认证（如ＣＡ证书）后，不需要人的参与，系统可以自动分配给用户一个账号进入系统。
169．页面中使用javascript的利与弊？（益端：能减少一些简单的逻辑业务，提高页面的效率，弊端：对于有些不能识别Javascript的浏览器存在一定的安全隐患）
2在Liniux/Uinix下创建一个角色帐号，自己拥有一切权限，系统用户拥有访问权限，其他用户没有任何权限.
170．SQL中有个PrepardStatement对象，用Java实现连接Oracle数据库，运用PrepardStatement对象。ConnDB.java
package demo.bean;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class ConnDB {
public static void main(String[] args) {
try{
String driver = "oracle.jdbc.driver.OracleDriver";
String url="jdbc:oracle:thin:@localhost:1521:yf";
String username = "scott";
String password = "tiger";
DriverManager.registerDriver( new oracle.jdbc.OracleDriver());
Connection con = DriverManager.getConnection(url, username, password);
PreparedStatement stm = con.prepareStatement("select sysdate from dual");
ResultSet rs = stm.executeQuery();
while(rs.next()){
System.out.print(rs.getString(1));
}
}catch(Exception e){
e.printStackTrace();
}
}
}
171．数据库索引的优点和缺点
一、为什么要创建索引呢（优点）？
这是因为，创建索引可以大大提高系统的性能。
第一， 通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
第二， 可以大大加快数据的检索速度，这也是创建索引的最主要的原因。
第三， 可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
第四， 在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
第五， 通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。
二、建立方向索引的不利因素（缺点）但是，为表中的每一个列都增加索引，是非常不明智的缺点：
1 创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
2 索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚 簇索引，那么需要的空间就会更大。
3 当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。
172．struts2.0中几种常用的标签
<s:if test=""></s:if> <s:form action=""></s:form>
<s:checkbox></s:checkbox>-----复选框 <s:url></s:url>-----创建url <s:textarea></s:textarea>-----文本域输入框
<s:autocompleter></s:autocompleter> <s:a href=""></s:a>-----超链接，类似于html里的<a></a>
Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯.Spring的架构基础是基于使用JavaBean属性的Inversion of Control容器是一个解决了许多在J2EE开发中常见的问题的强大框架，还提供了可以和总体的IoC容器集成的强大而灵活的MVC web框.
AJAX全称为“Asynchronous JavaScript and XML”（异步JavaScript和XML），是指一种创建交互式网页应用的网页开发技术
Hibernate是连接 Java 应用程序和关系数据库的中间件。它对 JDBC API 进行了封装，负责Java对象的持久化。在分层的软件架构中它位于持久化层，封装了所有数据访问细节，使业务罗基层可以专注于实现业务逻辑
173．servlet和jsp页面过滤器Filter的作用及配置
过滤器可附加到一个或多个servlet或JSP页面上，并且可以检查进入这些资源的请求信息 过滤器要好处。1它以一种模块化的或可重用的方式封装公共的行为 2 利用它能够将高级访问决策与表现代码相分离
174．学JAVA的都看了什么书？
基础很差的人我建议用那本JavaSE 6.0编程指南 《最新Java2 核心技术 卷1、卷2》了，不要怕代码难懂，这个一定要克服，当然某些代码(比如经常提及的画小球、你又不是搞图象的:))就可以跳过去。这当中可以穿插阅读《Java实效编程百例》，最后建议大家阅读《Java编程思想》 thinking in JAVA第三版中文版 Core Java（java核心技术）
175．函数和过程的区别？
过程和函数都为子程序，但也有区别：
1、标识符不同。函数的标识符为FUNCTION，过程为：PROCEDURE。
2、函数中一般不用变量形参，用函数名直接返回函数值；而过程如有返回值，则必须用变量形参返回。
3、过程无类型，不能给过程名赋值；函数有类型，最终要将函数值传送给函数名。
4、函数在定义时一定要进行函数的类型说明，过程则不进行过程的类型说明。
5、调用方式不同。函数的调用出现在表达式中，过程调用，由独立的过程调用语句来完成。
6、过程一般会被设计成求若干个运算结果，完成一系列的数据处理，或与计算无关的各种
操作；而函数往往只为了求得一个函数值。
176．javascript实现继承？
javascript的继承机制并不是明确规定的,而是通过模仿实现的,意味着继承不是由解释程序处理,开发者有权决定最适合的继承方式. 下面我给出几种常用的方法: 1 .对象冒充 原理: 构造函数使用this关键字给所有属性和方法赋值, 因为构造函数只是一个函数,所以可以使ClassA的构造函数成为classB的方法,然后调用它.这样classB就会收到classA的构造函数中定义的属性和方法.例子:
function classA(name)
{
this.name=name;
this.showName=function(){alert(this.name);}
}
function classB(name)
{
this.newMethod = classA;
this.newMethod(name);
}
obj = new classA("hero");
objB = new classB("dby");
obj.showName(); // print hero
objB.showName(); // print dby 说明classB 继承了classA的方法.
对象冒充可以实现多重继承 例如
function classz(){
this.newMethod = classX;
this.newMethod();
delete this.newMethod;
this.newMethod=classY;
this.newMethod():
delete this.newMethod;
177．将字符串str中的rep部分替换成with字符串(不能用jdk自带的replace方法)
public void replace(String str,String rep,String with){
try{
int i = str.indexOf(rep);
String s1 = str.substring(0, i);
String s2 = str.substring(i, rep.length()+i);
String s3 = str.substring(rep.length()+i, str.length());
s2 = with;
String mes = s1+s2+s3;
System.out.println("替换前："+str);
System.out.println("替换后："+mes);
}catch(Exception e){
System.out.println("字符串"+str+"中不含有"+rep+"字符串！");
}
}
178．Java Reflection？
JAVA反射，Reflection是Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说"自审"，并能直接操作程序的内部属性。例如，使用它能获得 Java 类中各成员的名称并显示出来
179．1到11相加是 （奇数，偶数）
偶数
一个圆上有6个点，可以连多少条直线？
180．冰到水的过程相当于液体到____气体___
质数
写一双向链表，向里面插入一个数字，然后查找里面是否有该数字，若有则删除，并返回1，否则返回0
迷宫程序
181．Stack堆栈，实现进栈，出栈
package t1;
public class mystack {
private Object[] data;
private int top=-1;
private int size;
public mystack()
{
data=new Object[5];
size=5;
}
public mystack(int size)
{
data=new Object[size];
this.size=size;
}
public void push(Object obj)
{
if(this.isfull())
{
return ;
}
top++;
data[top]=obj;
}
public Object pop() {
if(this.isempty())
{
return null;
}
Object obj=data[top];
top--;
return obj ;
}
public boolean isfull()
{
if(top==data.length)
{
return true;
}
else
{
return false;
}
}
public boolean isempty()
{
if(top==-1)
{
return true;
}
else
{
return false;
}
}
}
182．每周的工作效率要提高24％，每周工作6天，那么每天工作效率要提高多少？（6％，4%,24%）
24%
前一天是星期一，又是第二个工作日，那么今天是星期几？
Hibernate 中的HQL和 Certila的区别？
Web service 是什么？它是采用什么通信机制，它的通信协议是什么？
Struts 是怎么实现MVC的？
183．j a v a 对象初始化顺序
1.类的初始化（initialization class & interface）2.对象的创建（creation of new class instances）。
顺序：应为类的加载肯定是第一步的，所以类的初始化在前。大体的初始化顺序是：
类初始化 -> 子类构造函数 -> 父类构造函数 -> 实例化成员变量 -> 继续执行子类构造函数的语句
一个字符串中可能存在A-Z的全角字符，写一个方法把里面的全角字符转变成半角字符？
//建立字典表进行查找转换
public static String translate(String s){
String qj = "ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ";
String bj = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
StringBuffer sb = new StringBuffer();
for(int i=0;i<s.length();i++){
char c = s.charAt(i);
int pos = qj.indexOf(c);
if(pos>=0){
System.out.println(c + "," + pos);
sb.append(bj.charAt(pos));
}else{
sb.append(c);
}
}
return sb.toString();
}
184．写一个方法，传入一个int 型的数字，把它的四个字节码取出来，并且把它按大小顺序通过控制台输出？
public static void main(String[] args) {
int num = -800000000;
String str = Integer.toBinaryString(num); //获得num 的二进制
if(num>=0) { //如果输入的数为正数,位数可能不足32位，要补0；负数肯定是32位
if(str.length()<32) { //二进制不足32位，就在前面补0
int n0 = 32-str.length(); //看差几个0
String temp = "";
for(int i=0;i<n0;i++) {
temp = temp + "0"; //拼0
}
str = temp + str;
}
}
String s1 = str.substring(0, 8);
String s2 = str.substring(8, 16);
String s3 = str.substring(16, 24);
String s4 = str.substring(24, 32);
System.out.println(str);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
int n1=Integer.parseInt(s1,2);//以二进制把字符串解析为 10进制的数
int n2=Integer.parseInt(s2,2);
int n3=Integer.parseInt(s3,2);
int n4=Integer.parseInt(s4,2);
System.out.println(n1);
System.out.println(n2);
System.out.println(n3);
System.out.println(n4); //整数大小自己比较吧
}
185．类的工厂模式怎么实现？
首先确定这些类的父类或共同的接口，担任抽象产品的角色，比如
public interface IServer{
public void calc(int a,int b);
}
然后，这些类的具体实现继承某个父类或实现共同的接口,担任具体产品角色，比如
AddServer类和SubServer类
public class AddServer implements IServer{
public void calc(int a,int b){
System.out.println(a+b);
}
}
public class SubServer implements IServer{
public void calc(int a,int b){
System.out.println(a-b);
}
}
最后，涉及一个类充当工厂的角色，根据客户端的要求，提供具体的产品，比如
public class ServerFactory {
private static ServerFactory factory;
private ServerFactory(){}
public static ServerFactory getInstance(){
if(factory == null)
factory = new ServerFactory();
return factory;
}
//根据客户给出的名字返回对应的产品
public IServer getServer(String name){
if("Add".equals(name)){
return new AddServer();
}else if("Sub".equals(name)){
return new SubServer();
}else{
return null;
}
}
public static void main(String args[]){
IServer addserver = ServerFactory.getInstance().getServer("Add");
addserver.calc(5,3);
}
}
186．Web容器里面的对象存活周期？
Web容器里面的对象的存活周期由JVM控制。
某个对象有容器负责实例化或应用负责实例化，如果某个对象得不到任何引用，
则由JVM的垃圾收集器负责销毁。
187．struts2中action的对象的生命周期？
用spring来控制action的生命周期Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。
annotation的使用方法和用途主要分为几类？
答1、内建Annotation——Java5.0版在java语法中经常用到的内建Annotation： 2。开发者自定义Annotation：由开发者自定义Annotation类型。
3、使用第三方开发的Annotation类型
188．说说你对IOC的理解
控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题。是一种设计模式
控制反转还有一个名字叫做依赖注入（Dependency Injection）。简称DI
应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。所以，控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转。可以把IoC模式看做是工厂模式的升华，可以把IoC看作是一个大工厂，只不过这个大工厂里要生成的对象都是在XML文件中给出定义的，然后利用Java 的“反射”编程，根据XML中给出的类名生成相应的对象。
- 从action类，servlet依赖，action执行的控制、线程模式几个方面谈struts和struts2的区别。
Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。
2. Struts 2 Action类可以实现一个Action接口，也可实现其他接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现常用的接口。Action接口不是必须的，任何有execute标识的POJO对象都可以用作Struts2的Action对象。
线程模式:
3. Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
4. Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）
Servlet 依赖:
5. Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
6. Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。
- 如何理解struts,jsf,struts2的工作原理
JSF和STRUTS工作原理大致相同,有一个中心控制器即一个servlet,JSF:用一个JAVABENA里的属性绑定页面表单值,而struts用ActionFrom对应表单值;JSF在一个JAVABEAN里(ManagedBean)处理从页面送来的个值,而struts则是把actionFrom的值送给对象的ACTION来处理,两者都是MVC模式的.
- 整合spring与struts的方法，那种最好，为什么？（自己比较 ）
1.Struts的Action继承Spring的ActionSupport类，并在Action中获取Spring的ApplicationContext。这是最简单的一种整合方式，但有三个缺点：第一，Struts与Spring紧密耦合，不能改换到其他IoC容器；第二，难以使用Spring AOP特性；第三，对于需要使用DispatchAction的Struts应用无能为力。2.在Struts的配置文件中，以Spring的DelegatingRequestProcessor类代替Struts的RequestProcessor类，并在Spring的配置文件中定义与Struts配置文件中<action-mappings>对应的bean，从而将Struts的Action与Spring分开，并把Struts的动作置于Spring的控制之下。这种整合方式的优点是将不再依赖Spring这个特定的IoC容器，但必须依赖Struts的RequestProcessor类。3.通过Spring的DelegatingActionProxy类代理Struts的动作，即在Struts配置文件中，定义<action-mappings>的type属性全部改为DelegatingActionProxy，而不是具体的类名，并在Spring配置文件中定义与Struts动作映射对应的bean，从而将Struts的Action与Spring分开，并把Struts的动作置于Spring的控制之下。无疑，这是最灵活的一种整合方式。
192．springframework与struts的不同之处
SpringFramework是一个采用了反转控制（InversionofControl,Ioc）策略的基于J2EE的轻量级应用框架。核心是IoC容器，对于其它应用，如数据库访问，日志等，SpringFramework多使用现有的、成熟的框架。它采用了模块化的方式，各模块可以共同使用，也可以单独使用其中的一个模块，SpringFramework的一个模块提供了对动态AOP的支持，SpringFramework中提供的声明式事务管理就是基于动态AOP的。
SpringFramework中AOP的实现基于动态代理（DynamicProxy），动态代理源于代理模式，即通过接口实现对业务对象的访问，但动态代理无需为每一个需代理的业务对象静态的生成代理对象，只需提供需要代理的接口与代理实现，就可以在运行时动态的生成代理对象，代理对上述接口的访问，同样的机制也使用于对类的代理，使用类似于修饰者的模式，通过子类化实现。SpringFramework默认使用JDK提供的动态代理机制，此时，业务对象通过接口编程，若需要代理对类的访问，则需要使用CGLIB，这是一个开源的动态代理实现。 SpringFramework的AOP实现不同于AspectJ与AspectWerkz，它不是完全的AOP实现，而是设计用于在应用服务器环境下实现AOP，与SpringFramework的IoC容器配合使用
193．spring使用了哪些设计模式，这样用有什么好处？
Dao模式 通过实现DAO,我们达到了解耦合的目的,达到了饮场实现的目的,使的程序更加的健壮,虽然复杂性是增加了
194．spring对多种ORM 框架提供了很好的支持，结合事务管理描述spring中使用Hibernate的方法。 答：spring中采用aop模式注入hibernate的sessionfactory和事务管理,在dao中调用. Spring集成hibernate有两种方式,一是dao层只与hibernate有关, 不使用任何spring 的api, 然后把dao注入到ioc容器.二是使用spring的hibernateDaoSupport.事务管理也可以只使用hibernate的事务管理,把hibernate的事务关联到当前的thread
195．struts中action是全局的还是局部的，为什么？ 是全局
196．Hibernate有哪几种查询数据的方法？ HQL SQL QBC
197．http和ftp的默许使用端口是什么？http：80 ftp：20
Ping命令的作用？
Ping命令的主要作用是通过发送数据包并接收应答信息来检测两台计算机之间的网络是否连通。当网络出现故障的时候，可以用这个命令来预测故障和确定故障地点
构造器的名能不能和类的名字相同？ 不
198. 在一个主方法类可不意义调用一个非静态的方法？可以
一个类中可不可以有2个公共的方法？ 可以 Internet的最顶级的商业域名叫什么？ .com
- GC是什么，为什么要使用它？
垃圾回收 (garbage collection, GC) 一个跟踪过程，它传递性地跟踪指向当前使用的对象的所有指针，以便找到可以引用的所有对象，然后重新使用在此跟踪过程中未找到的任何堆内存。公共语言运行库垃圾回收器还压缩使用中的内存，以缩小堆所需要的工作空间 因为你没有足够多内存,并且,你挺懒,不去自己清理内存,所以就有了 GC
编程题:有一个数据文件:123 34 17 651234 345....这些数据都是随机产生的,编写程序读出该文件.并将其以从大到小的顺序输出到另一个文件中.
public void readtext(){
File file = new File("D:\test.txt");
List list= new ArrayList();
try {
BufferedReader br=new BufferedReader(new FileReader(file));
String data = "";
String line = null;
while ( (line = br.readLine()) != null) {
data = data.concat(line);
}
StringTokenizer stoken = new StringTokenizer(data, " ");
while (stoken.hasMoreTokens()) {
int i = Integer.parseInt(stoken.nextToken());
list.add(i);
}
} catch(Exception ex) {}
String[] str = new String[list.size()];
for(int i=0;i<list.size();i++){
str[i]=list.get(i);
}
Object iTemp= null;
for(int i=1;i<list.size();i++) {
for(int j=list.size()-1;j>=i;j--) {
if(str[j]>str[j-1]) {
iTemp = str[j-1];
str[j-1] = str[j];
str[j] = iTemp;
}
}
String result = "";
for(int i=0;i<str.length;i++){
result +=str[i]+" ";
}
//将result写入另外一个文件即可。
}
从一到十九共十九个数,打印出利用这十九个整数任意多个相加等于20所以可能性,每个数字在同一个算式中只出现一次.
public void test(){
Integer[] a = new Integer[19];
for(int i=1;i<20;i++){
a[i-1]=i;
}
for(int i=0;i<18;i++){
for(int j=18-i;j<18;j++)
if(a[i]+a[j]==20)
System.out.println(a[i]+"+"+a[i+1]+"="+20);
}
}
JSP内置对象作用，如何取Cookie的方法
使用request对象的getCookies()方法取cookies
(1) HttpServletRequest类的Request对象
作用：代表请求对象，主要用于接受客户端通过HTTP协议连接传输到服务器端的数据。
(2) HttpServletResponse类的Respone对象
作用：代表响应对象，主要用于向客户端发送数据
(3) JspWriter类的out对象
作用：主要用于向客户端输出数据;
Out的基类是JspWriter
(4) HttpSession类的session对象
作用：主要用于来分别保存每个用户信息，与请求关联的会话；
会话状态维持是Web应用开发者必须面对的问题。
(5) ServletContext类的application对象
作用：主要用于保存用户信息，代码片段的运行环境；
它是一个共享的内置对象，即一个容器中的多个用户共享一个application对象，故其保存的信息被所有用户所共享.
(6) PageContext类的PageContext对象
作用：管理网页属性,为JSP页面包装页面的上下文，管理对属于JSP中特殊可见部分中已命名对象的访问，它的创建和初始化都是由容器来完成的。
(7) ServletConfig类的Config对象
作用：代码片段配置对象，表示Servlet的配置。
(8) Object类的Page（相当于this）对象
作用：处理JSP网页，是Object类的一个实例，指的是JSP实现类的实例，即它也是JSP本身，只有在JSP页面范围之内才是合法的。
(9)Exception
作用：处理JSP文件执行时发生的错误和异常
2，写几个线程安全类，不安全的，支持排序的类名？
线程安全类：Vector 不安全的类：ArrayList 支持排序的类：TreeSet
- 将ISO8859-1字符串转成GB2312编码，语句为？
Text=new String(text.getBytes(“iso8859-1”),”gb2312”).
3,说出你用过的J2EE标准的WEB框架和他们之间的比较？
4,类库有哪些？
Xerces ，JDOM dom4j XOM jConfig XStream
5,
完整代码：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/** *//**
* 数组与Collection之间的转换
*/
public class edwin ...{
public static void main(String[] args) ...{
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
//当List中的数据类型都一致时，可以将list转化成数组
//转化成对象数组时，直接调用toArray方法
Object[] objArray = list.toArray();
System.out.println("从list转化成的对象数组的长度为: " + objArray.length);
//以下将会报不兼容的错误信息
// String[] strArrary=list.toArray();
/**//*在转化成其他类型的数组时，需要强制类型转换，并且，要使用带参数的toArray方法。
*toArray方法的参数为一个对象数组，将list中的内容放入参数数组中
*当参数数组的长度小于list的元素个数时，会自动扩充数组的长度以适应list的长度
*/
String[] strArray1 = (String[])list.toArray(new String[0]);
System.out.println("从list转化成的字符串数组的长度为: " + strArray1.length);
//如果大于LIST的长度将会按照数组的长度计算
//String[] strArray1 = (String[])list.toArray(new String[110]);
//System.out.println("从list转化成的字符串数组的长度为: " + strArray1.length);
//分配一个长度与list的长度相等的字符串数组。
String[] strArray2 = (String[])list.toArray(new String[list.size()]);
System.out.println("从list转化成的字符串数组的长度为: " + strArray2.length);
list.clear();//清空List
Set set = new HashSet();
set.add("aaa");
set.add("bbb");
//Set转化成数组
objArray = set.toArray();
strArray1 = (String[])set.toArray(new String[0]);
strArray2 = (String[])set.toArray(new String[set.size()]);
}
}
7，<jsp:include>与<%@include>的区别
动态INCLUDE用jsp:include动作实现 它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面
卢威 广通信达
怎么样手动启动Oracle数据库？
启动数据库:oradim -startup sid 数据库名，启动监听：lsnrctl start，下面就是连接数据
1·WEB SERVICE 的理解
WebService使原来各孤立的站点之间的信息能够相互通信、共享的接口 使用的是Internet上统一、开放的标准，如HTTP、XML WSDL等，所以Web Service可以在任何支持这些标准的环境（是从远程调用服务器上的Web服务，而且这个调用可以很简单的跨过不同网段和防火墙
3·写一个递归编程
public class Test {
static int multiply(int n){
if(n==1||n==0)
return n;
else
return n*multiply(n-1);
}
public static void main(String[] args){
System.out.println(multiply(10));
}
J2ee包括以下13种技术:
1.JDBC
2.JNDI
3.RMI
4.JAVA IDL
5.JAVA Servlet
6.JSP
7.EJB
8.JTS
9.JTA
10.JAVA MAIL
11.JAF
12.JMS
13.XML
JavE 它一个工具，一个用纯java语言写的跨平台的一个通用的Ascii码图形化的文本编辑器 功能和微软的记事本有些类似，主要是一个字处理，但提供图形化输入；操作像是微软的画图软件，因为该软件主要是通过鼠标进行文本的编辑。操作和功能并不复杂。该软件主要的卖点是授权开发源代码方式，其用百分之百java语言开开发的跨平台特点，多用于网络和手机
AWT和Swing的区别？
一般swing组件是从awt组件继的,swing是轻量组件 而awt是重量组件，每个组件都有一个本地peer.所以swing组件在大多数系统上显示都差不多而awt就反之
AWT是比较依赖操作系统组件少，功能少，Swing不依赖，组件多，功能多 窗口风格更多样化 Swing是由纯JAVA CODE所写的，解决了JAVA因窗口类而无法跨平台的问题，使窗口功能也具有跨平台与延展性的特性，而且SWING不需占有太多系统资源
线程同步的方法
哪几个方法可以实现一个线程？
一种是声明 Thread 的子类,重载 Thread 类的方法 run。 另一种途径是声明一个类，该类实现 Runnable 接口。然后再实现方法 run。
STOP()和SUSPEND()不推荐使用的原因
因为stop本质上就是不安全的。停止线程会导致解锁它已锁定的所有监视程序。suspend 从本质上就是易于死锁的。
JAVA事件有哪些模式？
- 事件直接驱动模式。它的第一个要求就是性能的要求，需要直接而且快，是必须经常使用的，主要适合于迅速处理 前台的命令，往往是系统架构的重要部分，也是流程控制的主要模式。2.监控式事件模式是借助第三者来监控和触发事件，特点是： 有一个观察者置身事外在定期独立运行着。
- 用javascript实现用户登录验证的代码.
<script language=javascript>
function checkSubmit()
{if ((document.form1.name.value)=='')
{
window.alert ('姓名必须填写');
document.form1.name.select();
document.form1.name.focus();
return false;
}
else
return true;
}
</script>
<form name="form1" onsubmit="javascript:return checkSubmit()">
<input type="text" name="name">
</form>
<%
Response.Write "<script language=javascript>"&vbCrlf&_
"<!--"&vbCrlf&_
"//Power by xiaotian 2002"&vbCrlf&_
"function checkSubmit()"&vbCrlf&_
"{"&vbCrlf&_
"if ((document.form1.name.value)=='')"&vbCrlf&_
"{"&vbCrlf&_
"window.alert ('姓名必须填写');"&vbCrlf&_
"document.form1.name.select();"&vbCrlf&_
"document.form1.name.focus();"&vbCrlf&_
"return false;"&vbCrlf&_
"else"&vbCrlf&_
"return true;"&vbCrlf&_
"}"&vbCrlf&_
"//-->"&vbCrlf&_
Lucene索引部分主要分为三大块：索引内容读取器，项在文档中的统计信息，项和域的数据结构
uml三要素.
事物、关系、图
EJB规范规定的EJB禁止的操作有哪些？
1.不能操作线程和线程API(线程API指非线程对象的方法如notify,wait等)，
2.不能操作awt，
3.不能实现服务器功能，
4.不能对静态属生存取，
5.不能使用IO操作直接存取文件系统，
6.不能加载本地库.，
7.不能将this作为变量和返回，
8.不能循环调用。
TRUNCATE和DELETE有以下几点区别？
1、TRUNCATE在各种表上无论是大的还是小的都非常快。如果有ROLLBACK命令DELETE将被撤销，而TRUNCATE则不会被撤销。 2、TRUNCATE是一个DDL语言，向其他所有的DDL语言一样，他将被隐式提交，不能对TRUNCATE使用ROLLBACK命令。 3、TRUNCATE将重新设置高水平
http协议，tcpip协议解释
答：HTTP：超文本传输协议（Hypertext Transfer Protocol）
TCP/IP（Transmission Control Protocol/Internet Protocol)的简写，中文译名为传输控制协
//编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。
//但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6应该输出为“我ABC”而不是“我ABC+汉的半个”。
public class InterceptString {
//方法一
public String split1(String arg0,int arg1){
char [] carr=arg0.toCharArray();
int il=carr.length;
for(int i=0;i<arg1&&i<il;i++){
if(carr[i]>0xFF){//0xFF代表255
arg1--;
}
}
int x=arg1>0?arg1:0;
x=arg1<il?arg1:il;
return arg0.substring(0,x);
}
//方法二
public String split2(String str,int byteLength){
if(str==null){
return null;
}
if(str.length()==0){
throw new IllegalArgumentException("Parameter byteLength must be great than 0");
}
char [] chs=str.toCharArray();
int i=0;
int len=0;
while(len<byteLength&&i<chs.length){
len=(chs[i++]>0xFF)?(len+2):(len+1);
}
if(len>byteLength){
i--;
}
return new String(chs,0,i);
}
public static void main(String [] args){
InterceptString is=new InterceptString();
String str="我ABC汉DEF";
System.out.println(is.split1(str,6));
System.out.println(is.split2(str,6));
}
}
3，java程序每天12点打印”hello”
public static void main(String[] args) {
Date date = new Date();
System.out.println(date.getHours());
while (true) {
while (date.getHours() == 12) {
if (date.getMinutes() == 0) {
if (date.getSeconds() == 0) {
System.out.println("hello world!");
}
}
}
}
}
编程题：读取一个文件在控制台打印出来
public void Read(){
File file=new File("E://1.txt");
FileReader fileread=new FileReader(file);
BufferedReader br=new BufferedReader(fileread);
String str="";
File file1=new File("E://2.txt");
FileWriter filewrite=new FileWriter(file1,true);
while ((str=br.readLine())!=null) {
filewrite.write(str.substring(0,str.indexOf(" "))+"\r\n");
}
filewrite.close();
fileread.close();
public static void main(String[] args) {
new ReadFile().Read();
}
2，解析XML的方法及对它的了解？
答：dom jdom sax .XML是The Extensible Markup Language(可扩展标识语言)的简写。它和HTML一样，XML同样来源于SGML，但XML是一种能定义其他语言的语。XML最初设计的目的是弥补HTML的不足，以强大的扩展性满足网络信息发布的需要，后来逐渐用于网络数据的转换和描述。
3，你所熟悉的开源组件和框架，简单介绍下
答：struts,hibernate,spring,Ajax。
Struts只是一个MVC框架（Framework）,用于快速开发Java Web应用。Struts实现的重点在C(Controller)，包括ActionServlet/RequestProcessor和我们定制的 Action,也为V(View)提供了一系列定制标签（Custom Tag）。但Struts几乎没有涉及M(Model),所以Struts可以采用JAVA实现的任何形式的商业逻辑。
优点：
1.是开源软件，这是它的一大优点。使开发者能更深入的了解其内部实现机制。
2.实现MVC模式，结构清晰，使开发者只关注业务逻辑的实现。
3.有丰富的标记库（Taglib），能大大提高开发效率。
4.页面导航：通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。
缺点:
1.转到展示层时，需要配置forward，每一次转到展示层，需要配置forward.
2.Struts 的Action必需是thread－safe方式，它仅仅允许一个实例去处理所有的请求。所以action用到的所有的资源都必需统一同步，这个就引起了线程安全的问题。
3.测试不方便. Struts的每个Action都同Web层耦合在一起，这样它的测试依赖于Web容器，单元测试也很难实现。
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了轻量级的对象封装，使JAVA程序员可以随心所欲的使用对象编程思维来操作数据库。它不仅提供了从JAVA类到数据表之间的映射，也提供了数据查询和恢复机制。相对于使用JDBC和SQL来手工操作数据库，HIBERNATE可以大大减少操作数据库的工作量，另外Hibernate可以利用代理模式来简化载入类的过程，这将大大减少利用Hibernate从数据库提取数据的代码的编写，从而节省开发时间和开发成本，Hibernate可以和多中WEB服务器或者应用服务器良好集成，如今已经支持几乎所有的流行的数据库服务器。
优点:
1.Hibernate 使用 Java 反射机制而不是字节码增强程序来实现透明性。
2.Hibernate 的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。
3.它支持各种关系数据库，从一对一到多对多的各种复杂关系。
缺点：它限制您所使用的对象模型。
Spring它基于IoC（Inversion of Control，反向控制）和AOP的构架多层j2ee系统的框架，但它不强迫你必须在每一层中必须使用Spring，因为它模块化的很好，允许你根据自己的需要选择使用它的某一个模块；它实现了很优雅的MVC，对不同的数据访问技术提供了统一的接口，采用IoC使得可以很容易的实现bean的装配，提供了简洁的AOP并据此实现Transcation Managment，等等
优点:
1.Spring能有效地组织你的中间层对象.
2.Spring能消除在许多工程中常见的对Singleton的过多使用。
3.通过一种在不同应用程序和项目间一致的方法来处理配置文件，Spring能消除各种各样自定义格式的属性文件的需要。
4.通过把对接口编程而不是对类编程的代价几乎减少到没有.
缺点：
使用人数不多、jsp中要写很多代码、控制器过于灵活，缺少一个公用控制器。
要求WEB2。0是什么东西 webservice和soap的区别 介绍几种WEB服务器，问Tomcat里面的文件组成？
WEB2.0是以人为核心线索的网。提供更方便用户织网的工具，鼓励提供内容。根据用户在互联网上留下的痕迹，组织浏览的线索，提供相关的服务，给用户创造新的价值，给整个互联网产生新的价值，才是WEB2.0商业之道。从内容产生者角度看，WEB1.0是商业公司为主体把内容往网上搬，而WEB2.0则是以用户为主，以简便随意方式，通过blog/podcasting 方式
in:启动,关闭Tomcat的命令.
common/lib:网络编程的jar文件.
conf:配置文件.
logs:日志文件.
server:自带的web应用(三个).
shared:所有web应用都可以访问的内容.
temp:临时.
webapps:默认站点文件夹.
work:jsp生成的类.
Tomcat是一个开放源代码、运行servlet和JSP Web应用软件的基于Java的Web应用软件容器。Tomcat Server是根据servlet和JSP规范进行执行的，因此我们就可以说Tomcat Server也实行了Apache-Jakarta规范且比绝大多数商业应用软件服务器要好。
ThreadLocal在项目中的实际意义？
ThreadLocal和其它同步机制相比从另一个角度来解决多线程的并发访问，它为每一个线程维护一个和该线程绑定的变量的副本，从而隔离了多个线程的数据，每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。还提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的整个变量封装进ThreadLocal
ThreadLocal可以大量减少参数的传递，可以使代码简洁，但一个线程会绑定多个自己定义的局部对象，ThreadLocal是抽象在线程上的对象创建工厂，目前的Tomcat5使用了线程池，一个线程处理一个request，这样ThreadLocal对象可以抽象的绑定在request生命周期，不会存在线程危机，而且线程池也平衡了这些ThreadLo
- 不同的数据库里面有相同的表实现同步更新（从多方面考虑）
--用触发器可以实现两个数据表之间的数据同步更新
For Example:
Create Trigger room_texes_change_id
on room
for update
as if update(room.cstname)
set texes.cstname=room.cstname
where texes.id=room.id 。
ejb是基于哪些技术实现的，和javabean的区别？ EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现 EJB是一个关于用JAVA语言开发的可部署的服务器端组件的组件体系结构。它是一个技术协议，能使组件运行于任何应用服务器,专门用来解决商务问题JAVABEANS是JAVA类，是由属性、事件和方法组成的JAVA组件，它们可以用来组成JAVA应用程序
适配器模式解释： 把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类 能够一起工作。适配类可以根据参数返还一个合适的实例给客户端
11.Gc是什么，为什么要有GC
GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：
System.gc() Runtime.getRuntime().gc()
13.switch可以作用于byte吗？可以作用于long，可以作用于string 吗？
switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。
15. try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
会执行，在return前执行。
17.两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
不对，有相同的hash code。
18.当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。
比较难题目
8． 在Oracle中数据库中的一个表中，这个表没有主键id也没有特定标示来查数据，怎么查？
考虑使用Oracle的伪列rowid来查询
9． 概述反射和序列化
反射Reflection 是Java 程序开发语言的特征之一，它允许运行中的Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。
Java序列化序列化就是把对象转换为流以存储到文件或传输给另一个程序。
10．简述WebService和Remoting的特点和运用场景
Web Service主要是为了使原来各孤立的站点之间的信息能够相互通信、共享而提出的一种接口。 Web Service所使用的是Internet上统一、开放的标准，如HTTP、XML、SOAP（简单对象访问协议）、WSDL等，所以Web Service可以在任何支持这些标准的环境（Windows,Linux）中使用。
Remoting 依赖于特定语言的远程调用机制，比如Java的RMI/IIOP
12．dao 是什么及作用
数据访问对象，用于封装数据持久化操作的组件。
16．Inserted和deleted的含义？
SQLServer的DML触发器中两个临时表
inserted表反映插入或更新操作时插入的记录
deleted表反映删除或更新操作时删除的记录
17．3个框架在项目在项目当中的用，basedao是用来做什么的。
basedao封装基本的数据持久化操作
21．Orace中除了数据库备份，还有什么方法备份？
按用户、表、表空间等进行逻辑备份
22．jsp与servlet中请求转发的区别
jsp通过<jsp:forward>标签
servlet通过RequestDispatcher类实现请求转发
23．分页的优化需考虑哪些
sql语句的优化：ID排除法、三层嵌套等
表的优化：适当使用索引
24．web运用程序的稳定、安全需要考虑哪些
Web服务器的性能考虑，
Web应用程序中对请求进行验证，权限检查等
25．问spring的AOP，mvc到底是怎么优化程序的结构？
Spring的整个MVC配置是基于IoC容器的，直接在Controller里定义AOP也是很容易的。
26．笔试：1.LinkedList和ArrayList内部是如何实现的？new ArrayList（10）意思
ArrayList的内部实现是基于内部数组Object[]，所以从概念上讲，它更像数组，但LinkedList的内部实现是基于一组连接的记录，所以，它更像一个链表结构，所以，它们在性能上有很大的差别。
new ArrayList（10）构造一个初始容量为 10 的空列表
27．定义一个变量，Var v =new Object (),用js编写的简便写法是什么？
var v = {};
30．网上购物系统的类图，用例图。
主要的类有：商品分类 商品 订单 订单项 商品评论
主要用例有：查询商品 查看商品详情 发表评论 登录 注册 购物车管理 订单生成 查询订单等
31．给你一个整数类型的数组，按从小到大的顺序进行排列！
简单的冒泡排序
32．查询出M 页的N行数据 。
select * from a where id in (select top(m*n) id from a where id not in (select top((m-1)*n) id from a ))
34．数组里面有几个数，按它在里面出现的频率排序，如果频率一样多的话就比大小。
现统计每个数字的频率，之后按照频率高低进行排序，对于频率相同的则再按照数字大小比较排序。
35．N的二维数组取中间数，再存到另外一个二维数组里面，然后把另外一个二维数组打出来。？？？
题意不明确
36．从记事本读出一个子表符排序写道另一个文件里面。？？？
题意不明确
37．把二叉树从小到大遍历出来怎么实现？ 用递归。
二叉树的中序遍历即可
38．ajax和jms的区别？mysql分页怎么实现，oracle分页怎么实现，他们之间的区别？
Ajax是一个RIA应用技术，解决富Web客户端问题，提高用户体验的
jms是Java的消息服务系统，解决Java分布式应用消息异步通信
mysql中的limit关键字支持分页
oracle中通过rownum进行分页
45．数据库里面的语言符号表示？
指的是Locale，语言编码
49．描述struts体系结构？对应各个部分的开发工作主要包含哪些？
按MVC设计的Web架构，
其中Model为ActionForm组件的设计
View为Struts标签的使用
Controller为Action组件的设计和ActionServlet的配置
50．组合优于继承。你是否同意这句话，并说明
继承和组合都可以实现代码的重用（Reuse），为什么组合要优于继承呢？
通过继承，子类能够获得与父类相同的功能和属性，父类拥有了某种功能，子类就有了；但是如果子类需 要新的功能，直接在父类里面增加新的功能，那么会导致所有的子类同时拥有这种功能，这实际上是将类的功能与类紧紧的耦合在一起，是一种紧密耦合系统，由于 关系相当密切，导致改动一处而动全身，实际上不利于代码的重用。而组合恰好相反，她把类的各项功能分割开，互不干涉。一个类的功能，实际上是各种子功能的 组合，比如鸭子的功能就是飞行功能和发出叫声功能的组合，无论是何种鸭子，都是这样。同时到底是怎样飞行，怎样叫，又可以通过面向接口的编程实现多态。
51．javascript取浏览器的版本 里面还有哪些对象？
<script type="text/javascript">
function getBrowser(){
var bro = navigator.userAgent.toLowerCase();
if(/msie/.test(bro)) return 'IE' + bro.match(/msie ([\d.]*);/)[1]
else if(/navigator/.test(bro)) return 'NS' + bro.match(/navigator\/([\d.]*)/)[1]
else if(/chrome/.test(bro)) return 'CR' + bro.match(/chrome\/([\d]*)/)[1]
else if(/safari/.test(bro)) return 'SF' + bro.match(/version\/([\d]*)/)[1]
else if(/opera/.test(bro)) return 'OP' + bro.match(/version\/([\d]*)/)[1]
else if(/firefox/.test(bro)) return 'FF' + bro.match(/firefox\/([\d]*)/)[1]
}
</script>
52．如何运行本地的EXE文件？
双击运行呗
53．struts中的prepare怎么用？
首先Action组件实现Preparable接口的prepare()方法，在配置 Action组件时应用PrepareInterceptor拦截器。
54．Hrbernate的二级缓存讲述。
hibernate的session提供了一级缓存，每个session，对同一个id进行两次load，不会发送两条sql给数据库，但是session关闭的时候，一级缓存就失效了。
二级缓存是SessionFactory级别的全局缓存，它底下可以使用不同的缓存类库，比如ehcache、oscache等。hibernate在执行任何一次查询的之后，都会把得到的结果集放到缓存中，缓存结构可以看作是一个hash table，key是数据库记录的id，value是id对应的pojo对象。当用户根据id查询对象的时候（load、iterator方法），会首先在缓存中查找，如果没有找到再发起数据库查询。
59．如果做个招聘网站性别只招男的，年龄20-30，如果不匹配就不能让他投简历，怎么实现？ 填身份证时如何让该人信息全部显示出来？
使用JavaScript做客户端检验，填身份证时使用Ajax获取人员信息；
61．软件的开发过程、以及角色？
软件立项 à 需求分析 à 概要设计 à 详细设计 à 编码测试 à 验收运行
| | | |
|------------ 分析员 ---------|--------------程序员---------------|------------测试员-------|
62．JDBC 怎样开启一个事物？什么叫做事务？
面试题上有
63．Io流 InputStream与Reader的区别 ,怎样将字符流转换成字节流
InputStream 字节输入流、Reader字符输入流
OutputStreamWriter 是字符流通向字节流的桥梁
InputStreamReader 是字节流通向字符流的桥梁
64．启动线程调用那个方法 ？为什么要调用start（）方法？若调用run（）方法会出现什么情况？
面试题上有
65．Struts2.0 若在一个方法中返回的是null，表明什么?struts.xml还需要配置吗？为什么？struts有那些标签？struts.xml中有那些标签？
方法返回null，表示没有视图结果回应，当然自己通过流直接输出响应结果，则struts.xml只需对Action进行映射配置，而无须进行结果配置。
66．Hibernate 运行的流程？优缺点？为什么insert比select快？可以批量insert一些数据吗？
Hibernate应该是建立在JDBC基础上的一个开源的ORM映射框架，很好的封装了实体映射实现，提供友好的实体操作接口，以及基于HQL的查询接口，在开发中可以减少编写SQL相关代码，提高效率和减少出错。
以面向对象的方式操作数据库，进行增删改很方便，但执行复杂的查询时则很费事麻烦。
select查询可能需要执行多条SQL语句，牵涉到加载策略所以执行需要消耗很多时间，相比insert操作要慢些。
hibernate可批量insert一些数据，配置文件中设置hibernate.jdbc.batch_size参数，来指定每次提交SQL的数量。
67．sqlserver查询 怎样取得JAVA虚拟机默认的编码方式？
可通过Charset.defaultCharset()来获取
68．公司正在做类似于访问别人QQ空间的登陆方式，我们学的是普通的cookie,session的方式，人家问还有什么登陆方式，是不需要用户名，帐户验证的。例如访问别人的QQ 空间。
url重写呗，会话跟踪的方式
69．智力题：1、有一辆火车以15公里/小时从洛杉矶开往纽约，一辆火车以20公里/小时从纽约开往洛杉矶，一只鸽子以30公里/小时从洛杉矶开往纽约，鸽子和两辆火车同时出发，鸽子遇到火车转头，向另一辆火车飞，直到两辆火车相遇，问鸽子飞了多少公里？
2、有两根不匀称的香，烧完1小时，问如何知道1 5分钟
3一群人在一黑屋子，有黑白2种帽子，每人可以看其他人的帽子，至少1顶黑帽子。如果知道自己是黑帽子，打自己一巴掌。第一次开灯，无人，关灯。第二开灯，无人，关灯。第3次，听到劈劈啪啪的声音。问有几顶黑帽子。
72. 什么是 联通图的生成树？
什么是哈夫曼树？什么是平衡二叉树？写一个深度优先排序，写一个广度优先排序？写出 C语言对链表HEAD的排序？
连通图的生成树——是连通图的一个极小连通子图，它含有图中全部顶点，但只有足以构成一棵树的n-1条边。
哈夫曼树又称最优树（二叉树），是一类带权路径最短的树。构造这种树的算法最早是由哈夫曼(Huffman)1952年提出，这种树在信息检索中很有用。
如果任意节点的左右子树的深度相差不超过1，那这棵树就是平衡二叉树。
74．哪些不是JAVA关键字：TRUE sizeof native是关键字
sizeof不是 大写的TRUE不是
75．怎样知道给出的两条线段是否相交，用伪码实现。
假设线段AB,A(X1,Y1),B(X2,Y2);线段CD,C(X3,Y3),D(X4,Y4);
1。判断两斜率 相等则不相交
2。若斜率不等
76．ORACLE数据库用到了哪些方面，怎样优化数据库。SQL语句过长时，怎样优化？
(1) 使用分区这种手段。所谓分区就是动态地将表中的记录分离到若干不同的表空间上，使数据在物理上被分割开来，便于维护、备份、恢复、事务及查询性能。
(2) 重建索引，及时回收那些未使用空间，提高空间利用率。
(3) 调整SGA参数
sql语句长：用存储过程！
81．JAVASCRIPT的一些常用东西：如提示框如何实现的 ：MVC
使用jQuery等第三方的插件Dialog即可，无需重复造轮子。
85．两个SQL语句 一个ArrayList里面存了一些Student对象，Student对象有Name和Age两人属性，此类里面有set和get方法，要求以Age来降序排序。
要求Student实现Comparable接口的compareTo()方法来按照age判断对象的大小，并且大于时返回-1，小于时返回1，相等则返回0。
86．有一些奇数和偶数，无序的，要求写一个方法，实现将所有的奇数放在全部的偶数前面
主要代码如下：主要采用快速排序的算法。
int[] n = {1,2,5,6,4,7,10,9,3,8};
int m = n[0];
int j = n.length -1;
int i= 0;
while(i<j){
while(i<j && n[j]%2==0){j--;}
if(j>=i){
n[i++] = n[j];
}
while(i<j && n[i]%2!=0){i++;}
if(i<=j){
n[j--] = n[i];
}
}
n[i] = m;
for(int k=0;k<n.length;k++){
System.out.print(n[k] + " ");
}
87．Rethodlocal对项目来说有什么好处？
88．你对工作流和表单的理解
一个工作流包括一组活动及它们的相互顺序关系，还包括过程及活动的启动和终止条件，以及对每个活动的描述。一个完整的工作流管理系统通常由工作流引擎、可视工作流设计、流程操作、工作流客户端程序、流程监控、表单设计工具、与表单的集成以及与应用程序的集成八个部分组成。工作流引擎作为工作流管理系统的核心部分，主要提供了对于工作流定义的解析以及流程流转的支持。
表单用来显示查询或输入的业务数据。
93．根据ORACLE中字段FILE从A目录中搜索相应编码UTF-8转换GB2312拷贝到B目录，并输出 大家解决下
96．Classpath怎么设置和它的意义是什么？
比如，set CLASSPATH=C:\Java\jdk1.6.0_10\lib\dt.jar;.
设置class文件的搜索路径
97．用java写一个读取盘符的名字
new File("").getAbsolutePath().substring(0, 1);
99．Deprecated API 是什么意思？
deprecated是指已经过时，但是为了向前兼容起见仍然保留的方法，这些方法可能会在以后取消支持。你应当改用较新的方法。一般在API里面会说明你应当用什么方法来代替之。
100．如何去掉JAVA的 内存机制？
是不是垃圾回收机制，使用System.gc()强制回收。
101．缺少IDE如何编译JAVA代码？
使用JDK的javac.exe 直接手工编译
或使用Apache的ANT脚本构建
1,THHP与HTTPS有什么区别？
HTTP为普通WEB协议、HTTPS为加密WEB协议。默认http为tcp80端口。https为tcp443端口
2.Session的具体用法？
Session用来保存每一个用户的专有信息，比如像用户登录验证、购物车。
1.ibatis 中的#与$的区别
1.#是把传入的数据当作字符串，如#field#传入的是id,则sql语句生成是这样，order by "id",这当然会报错．．
2.$传入的数据直接生成在sql里，如#field#传入的是id,则sql语句生成是这样，order by id, 这就对了．
3.#方式能够很大程度防止sql注入．
4.$方式无法方式sql注入．
5.$方式一般用于传入数据库对象．例如传入表名.
6.一般能用#的就别用$.
2.简述spring 的事务传播行为和隔离级别
一、事务传播行为Propagation ：
key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用：
PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
二、Isolation Level(事务隔离等级):
1、Serializable：最严格的级别，事务串行执行，资源消耗最大；
2、REPEATABLE READ：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。
3、READ COMMITTED:大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。该级别适用于大多数系统。
4、Read Uncommitted：保证了读取过程中不会读取到非法数据。
隔离级别在于处理多事务的并发问题。
3.请裂举session、cookie、viewstatedn的应用范围
Session 小量数据， 某个用户活动时间 + 延迟时间（默认20分钟）， 单个用户， 服务器端。
Cookie 小量数据， 程序指定生命周期， 单个用户， 客户端 。
ViewState 小量数据，一个web页面的生命期，单个用户，客户端。
1： 用什么方法使服务器关闭之后，session所保存的信息不会丢失？
将session信息保存到数据库中或文件中
B2C和C2C你们是怎么区别的？
Business（企业）、Customer（消费者）
B2C的B是Business企业，2则是to的谐音，C是Customer消费者，所以B2C是企业对消费者的电子商务模式。这种形式的电子商务一般以网络零售业为主，主要借助于Internet开展在线销售活动。B2C简而言之是就是商家与顾客之间的商务活动，也就是通常所说的“网上购物网站”，企业、商家可充分利用电子商城提供的网络基础设施、支付平台、安全平台、管理平台等共享资源有效地、低成本地开展自己的商业活动。
C2C就是消费者（consumer）与消费者（consumer）之间的电子商务。打个比方，比如一个消费者的有一台旧电脑，通过网上拍卖，把它卖给另外一个消费者，这种交易类型就称为c2c电子商务。主要是指网上拍卖。c2c模式的特点就是大众化交易，因为是个人与个人之间的交易！
公钥密码和私钥密码有什么区别？
在现代密码体制中加密和解密是采用不同的密钥（公开密钥），也就是非对称密钥密码系统，每个通信方均需要两个密钥，即公钥和私钥，这两把密钥可以互为加解密。公钥是公开的，不需要保密，而私钥是由个人自己持有，并且必须妥善保管和注意保密。
公钥私钥的原则：
1. 一个公钥对应一个私钥。
2. 密钥对中，让大家都知道的是公钥，不告诉大家，只有自己知道的，是私钥。
3. 如果用其中一个密钥加密数据，则只有对应的那个密钥才可以解密。
4. 如果用其中一个密钥可以进行解密数据，则该数据必然是对应的那个密钥进行的加密。
用最好效率写一个2*17等于多少？
（2<<4）+ 2
#define MaxVertexNum l00 //最大顶点数，应由用户定义
typedef char VertexType； //顶点类型应由用户定义
typedef int EdgeType； //边上的权值类型应由用户定义
typedef struct{
VextexType vexs[MaxVertexNum] //顶点表
EdeType edges[MaxVertexNum][MaxVertexNum];
//邻接矩阵，可看作边表
int n，e； //图中当前的顶点数和边数
}MGragh；
typedef enum{FALSE，TRUE}Boolean；//FALSE为0，TRUE为1
Boolean visited[MaxVertexNum]； //访问标志向量是全局量
/* 深度优先遍历 */
void DFSTraverse(MGraph *G)
{ //深度优先遍历
int i；
for(i=0;i<G->n;i++)
visited[i]=FALSE； //标志向量初始化
for(i=0;i<G->n；i++)
if(!visited[i]) //vi未访问过
DFSM(G，i)； //以vi为源点开始DFS搜索
}//DFSTraverse
void DFSM(MGraph *G，int i)
{ //以vi为出发点对邻接矩阵表示的图G进行DFS搜索，设邻接矩阵是0,l矩阵
int j；
printf("visit vertex：％c"，G->vexs[i])；//访问顶点vi
visited[i]=TRUE；
for(j=0；j<G->n；j++) //依次搜索vi的邻接点
if(G->edges[i][j]==1&&!visited[j])
DFSM(G，j)//(vi，vj)∈E，且vj未访问过，故vj为新出发点
}//DFSM
/* 广度优先遍历 */
void DFSTraverse(MGraph *G)
{ //广度优先遍历
int i；
for(i=0;i<G->n;i++)
visited[i]=FALSE； //标志向量初始化
for(i=0;i<G->n；i++)
if(!visited[i]) //vi未访问过
BFSM(G，i)； //以vi为源点开始DFS搜索
}//DFSTraverse
void BFSM(MGraph *G，int k)
{以vk为源点对用邻接矩阵表示的图G进行广度优先搜索
int i，j；
CirQueue Q；
InitQueue(&Q)；
printf("visit vertex：％c"，G->vexs[k])； //访问源点vk
visited[k]=TRUE；
EnQueue(&Q，k)；
while(!QueueEmpty(&Q)){
i=DeQueue(&Q)； //vi出队
for(j=0;j<G->n;j++)//依次搜索vi的邻接点vj
if(G->edges[i][j]==1&&!visited[j]){//vi未访问
printf("visit vertex：％c"，G->vexs[j])；//访问vi
visited[j]=TRUE；
EnQueue(&Q，j)；//访问过的vi人队
}
}//endwhile
}//BFSM
用4 个0，用你所知道的数学方法计算出24
0的阶乘等于1 即 0！＝１那么４个0就是４了
又4的阶乘为２４ ４！＝２４
建表：借书证，买书
10怎样计算等于24？ (10×10-4)÷4=24
有一个长方形蛋糕,切掉长方形一块,怎样一刀切下去成大小相等两块
将完整的蛋糕的中心与被切掉的那块蛋糕的中心连成一条线。这个方法也适用于立方体