java面试整理（二）

来源：互联网发布：爱淘宝红包返利编辑：程序博客网时间：2024/06/06 10:01

说明：个人整理而已，仅供参考学习，希望能够帮助到他人。

1.用自己的话简要叙述Struts2的执行流程

该框架大致分为3个部分

核心控制器FilterDispatcher，业务控制器Action和用户实现的企业业务逻辑组件

核心控制器是Struts2框架的基础，包含了框架内部的控制流程和处理机制

业务控制器Action和业务逻辑组件是需要用户来自己实现的。

用户在开发Action和业务逻辑组件的同时，还需要编写相关的配置文件，供核心控制器来使用

2.Lucene全文检索

全文检索是计算机程序通过扫描文章中的每一个词，对每一个词建立一个索引，

指明该词在文章中出现的次数和位置。当用户查询时根据建立的索引查找，

类似于通过字典的检索字表查字的过程

3.Session何时刷出缓存

1）事务提交时----tx.commit();

2）Query查询时---query.list();

3）手动调用session.flush();

* 操作缓存相关方法

1）flush：刷出缓存，使用缓存中的数据更新数据库中的数据

2）clear：清空session中的所有数据

3）evict：清除指定对象在一级缓存中的引用

4）refresh：使用数据库中的数据覆盖缓存中的数据

4.看完了Spring是什么，再来看看Spring有哪些优点

1.使用Spring的IOC容器，将对象之间的依赖关系交给Spring，降低组件之间的耦合性，

让我们更专注于应用逻辑

2.可以提供众多服务，事务管理，WS等。

3.AOP的很好支持，方便面向切面编程。

4.对主流的框架提供了很好的集成支持，如Hibernate,Struts2,JPA等

5.Spring DI机制降低了业务对象替换的复杂性。

6.Spring属于低侵入，代码污染极低。

7.Spring的高度可开放性，并不强制依赖于Spring，开发者可以自由选择Spring部分或完全。

5.连接分为三种：内连接、外连接、交叉。外连接分为左外连接和右外连接。

6.get/load:

当查询对象时，如果没有存在的记录

get方法返回null

load方法抛出异常：ObjectNotFoundException

get不支持延迟加载

7.解决丢失更新问题

1）悲观锁:使用数据库底层锁机制，锁定操作的数据，防止并发发生

2）乐观锁：在持久化类中添加版本字段，当事务提交时，比较提交的版本是否和数据库中的版本字段一致，

如果不一致，抛出异常阻止修改

8.Struts2简要工作流程

Struts2的工作流程相对于Struts1要简单，与webwork框架基本相同，也可以说是它的升级版本，简要流程如下：

客户端浏览器发出HTTP请求

根据WEB.XML配置，该请求被核心控制器FilterDispatcher接收

根据struts.xml配置，找到需要调用的Action类和方法，并通过IOC方式，将值注入给Action

Action调用业务逻辑组件处理业务逻辑，这里包含表单验证等

Action执行完后，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应的页面

返回HTTP并响应到客户端浏览器

用jdbc查询学生成绩单，把主要的代码写出来

Connection con =null;

PreparedStatement psmt =null;

Resultset rs =null;

Try{

Class.forname(driveClassName);

Con=DriverManager.getConnection(url,username,password);

Psmt=con.prepareStatement(“select score.*from score ,student

where score.stu_id=student.stu_id and student.name=?”);

psmt.setString(1,studentName);

Resultset rs =psmt.excuteQuery();

While(rs.next()){

System.out.println(“rs.getInt(“subject”)+” ”+rs.getFloat(“score”)”);

}

}catch(Exception e){

e.printStackTrace();

}finally{

If(rs!=null){

Try{

Rs.close()

}catch(exception e){

}

If(psmt!=null){

Try{

psmt.close()

}catch(exception e){

}

If(con!=null){

Try{

con.close()

}catch(exception e){

}}}}

9.描述JDBC的开发流程。

第1步：创建JDBC的工作框架；

第2步：载入数据库驱动；

第3步：建立一个数据库连接；

第4步：依据数据库连接建立一个查询工具；

第5步：依据一个SQL语句，执行查询，并得到结果集；

第6步：使用结果集；

第7步：关闭结果集。

//1.注册驱动

Class.forName("oracle.jdbc.driver.OracleDriver");

//2.获取连接

Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE","user","password");

//3.获取能够发送sql语句的对象

Statement st = conn.createStatement();

//4.执行sql语句

ResultSet rs = st.executeQuery(sql);

//5.有结果集处理结果集

while(rs.next){

System.out.println(rs.getInt("id"));

}

//6.关闭资源

if(rs!=null){

rs.close();

}

if(st!=null){

st.close();

}

if(conn!=null){

conn.close();

}

10.实现多线程有几种方法？

三种，

1. 继承 Thread 类，重写 run 函数

2. 实现 Runnable 接口，重写 run 函数

3. 实现 Callable 接口，重写 call 函数

Java启动线程的三种方式：

1.继承Thread----调用run()方法

public class java_thread extends Thread{

public static void main(String args[])

{

(new java_thread()).run();

System.out.println("main thread run ");

}

public synchronized void run()

{

System.out.println("sub thread run ");

}

2.实现Runable接口

public class java_thread implements Runnable{

public static void main(String args[])

{

(new Thread(new java_thread())).start();

System.out.println("main thread run ");

}

public void run()

{

System.out.println("sub thread run ");

} }

3.直接在函数体中使用

void java_thread() {

Thread t = new Thread(new Runnable(){

public void run(){

mSoundPoolMap.put(index, mSoundPool.load(filePath, index));

getThis().LoadMediaComplete();

}});

t.start();

}

11.写一段JDBC连接Oracle的程序，并实现数据查询。

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

public class TestDemo

{

//orcl为oracle数据库中的数据库名，localhost表示连接本机的oracle数据库

//1521为连接的端口号

private static String url="jdbc:oracle:thin:@localhost:1521:orcl";

//system为登陆oracle数据库的用户名

private static String user="system";

//manager为用户名system的密码

private static String password="manager";

private static Connection conn;

private Statement statement = null;

private ResultSet rs = null;

/**

* 连接数据库的方法

public void getConnection(){

try {

//初始化驱动包

Class.forName("oracle.jdbc.driver.OracleDriver");

//根据数据库连接字符，名称，密码给conn赋值

conn=DriverManager.getConnection(url, user, password);

statement = conn.createStatement();

} catch (Exception e) {

// TODO: handle exception

e.printStackTrace();

}

/**

* 查询操作

* @param sql SQL语句

* @return 查询结果集

public ResultSet executeQuery(String sql){

try{

rs=statement.executeQuery(sql);

}

catch (SQLException e){

e.printStackTrace();

}

return rs;

}

/**

* 连接关闭，资源释放

public void close(){

try{

rs.close();

statement.close();

conn.close();

}

catch (Exception e){

e.printStackTrace();

}

/**

* 测试main方法

* @param args

public static void main(String[] args){

ResultSet rs;

TestDemo testDemo = new TestDemo();

testDemo.getConnection();

rs=testDemo.executeQuery("select * from test");

try{

while (rs.next()){

//do something

}

}catch(Exception e){

e.printStackTrace();

}

testDemo.close();

}

12.下面的代码运行的结果是：

class B extends Object

{

static

{

System.out.println("Load B");

}

public B()

{

System.out.println("Create B");

}

class A extends B

{

static

{

System.out.println("Load A");

}

public A()

{

System.out.println("Create A");

}

public class Testclass

{

public static void main(String[] args)

{

new A();

}

Load B ->Create B->Load A -> Create A

Load B -> Load A ->Create B ->Create A

Load B -> Create B-> Create A -> Load A

Create B ->Create A ->Load B ->Load A

思路：java类中的静态代码块只在类加载到内存时执行一次

B是A的父类，所以先加载B，再加载A

然后在new A()过程中首先构造父类，再构造子类

初始化块在构造器执行之前执行，类初始化阶段先执行最顶层父类的静态初始化块，依次向下执行，最后执行当前类的静态初始化块；创建对象时，先调用顶层父类的构造方法，依次向下执行，最后调用本类的构造方法。

13.Java实现多线程的两种方式，包括如何定义多线程，如何使用多线程实现Runnable接口

class Thread1 implements Runnable{

public void run( ){

//run里一般写一个while(true)循环

System.out.println(“Runnable“);

}

public class Test{

public static void main(String[] a){

Thread1 r = new Thread1();

Thread t1 = new Thread(r);

Thread t2 = new Thread(r);

t1.start();

t2.start();

}

//继承Thread

class Thread2 extends Thread{

public void run(){

System.out.println(“extends“);

}

public class Test{

public static void main(String[] a){

Thread t = new Thread2();

t.start();

}

14.java如何使用随机文件读写类来读写文件内容?

RW表示文件时可读写的

读：

try{

RandomAccessFile f = new RandomAccessFile(“test.txt”, “rw”);

long len = 0L;

long allLen = f.length();

int i = 0;

while (len < allLen) {

String s = f.readLine();

if (i > 0) {

col.add(s);

}

i++;

//游标

len = f.getFilePointer();

}

}catch(Exception err){

err.printStackTrace();

写：

try{

RandomAccessFile f = new RandomAccessFile(“test.txt”, “rw”);

StringBuffer buffer = new StringBuffer(“\n”);

Iterator it = col.iterator();

while (it.hasNext()) {

buffer.append(it.next() + “\n”);

}

f.writeUTF(buffer.toString());

}catch(Exception err){

err.printStackTrace();

}

15.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 !");

}

16.从一到十九共十九个数,打印出利用这十九个整数任意多个相加等于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);

}}

17.编程题:有一个数据文件: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写入另外一个文件即可。

}

18.写一个方法，传入一个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); //整数大小自己比较吧

}

19.servlet中的init方法什么时候被调用？

容器在创建好servlet对象之后，会调用该对象的init方法，并且该方法只被调用一次。

定义一个一维的int数组，先创建它，并初始化它，给它赋值，然后输出其中的一个值。

public static void main(String args[]){

int N=100；

int array[] = new int[N];

for(int i=0;i<N;i++)

array[i]=i;

System.out.println(a[N/2]);

}

20.请描述什么是强制类型转换？什么是自动类型转换？什么是向上造型？并分别举例说明

强制类型转换：在一个类型前面加( )，来强制转换

long l = 9L;

int i = (int)l;
自动类型转换：
int i = 5;
String str = “”+i;
向上造型：把范围小的造型为范围大的类型： int i = 2;
long l = i;

21.a++和++a的区别？

a++ 与 ++a 都是表达式，他们都有值，第一个表达式（即a++)的值是a的原始值，这个表达式获得值之后，对变量a自增。而第二个表达式则是先对a自增，然后再把a的值作为表达式的值 a++先定义后运算；++a先运算后定义

简述Java代码的运行过程

加载代码通过类装载器装载CLASS文件
（2）校验代码由字节码校验
（3）执行代码由解释器将字节码转换成机器码

22、描述Java垃圾回收机制。

java 编程语言解除了程序员释放内存的责任。它可提供一种系统级线程以跟踪每一次内存的分配情况。在 Java 虚拟机的空闲周期，垃圾收集线程检查并释放那些可被释放的内存。垃圾收集在 Java 技术程序的生命周期中自动进行，它解除了释放内存的要求，这样能够有效避免内存漏洞和内存泄露（内存泄露就是程序运行期间，所占用的内存一直往上涨，很容易造成系统资源耗尽而降低性能或崩溃。
垃圾回收有以下特点：
（1）垃圾回收是一个自动的系统行为，程序员不能控制垃圾回收的功能和行为。
（2）有一些跟垃圾回收相关的方法，比如：System.gc( ) ,调用这些方法，仅仅是在通知垃圾回收程序，至于垃圾回收程序运不运行，什么时候运行，都是无法控制的。
（3）程序员可以通过设置对象为 null，来标示某个对象不再被需要了，这只是表示这个对象可以被回收了，并不是马上被回收。

23、写出正则表达式，从一个字符串中提取链接地址。
比如下面字符串中
“<a title="软件测试面试题" href="http://www.mianwww.com/html/category/it-interview/softwaretest" target="_blank">软件测试面试题</a>”
则需要提取的地址为 “http://www.mianwww.com/html/category/it-interview/softwaretest ”

public class Regex {

static void url() {

String input = “<a title="软件测试面试题" href="http://www.mianwww.com/html/category/it-interview/softwaretest" target="_blank">

软件测试面试题</a> “;

Pattern pattern;

Matcher matcher;

pattern = Pattern.compile(“<a(?: [^>]*)+href=([^ >]*)(?: [^>]*)*>”);

matcher = pattern.matcher(input);

while (matcher.find()) {

System.out.println(matcher.group());

}

24.面试题

import java.util.Random;

import java.util.SortedSet;

import java.util.TreeSet;

public class TestDemo

{

public static void main(String[] args)

{

SortedSet<Integer> set = new TreeSet<Integer>();

System.out.println("随机生成的数列是：");

Random random = new Random();

while(true){

int temp = random.nextInt(100);

if(temp <= 1 || temp >= 100){

continue;

}

System.out.print(temp + "\t");

set.add(temp);

if(set.size() == 10){

break;

}

System.out.println();

System.out.print("此数列的最大值是： ");

System.out.println(set.last());

System.out.print("此数列的最小值是： ");

System.out.println(set.first());

}

25、编写代码删除某文件目录下的所有子目录和文件，并输出目录的名字，路径以及文件的内容。

public class DelFile{

public static void main(String[] args){

String url ="/url/file";//某文件目录

File dir = new File(url);

String[] fileList = dir.list();//得到所有的文件和目录名称

File[] files = dir.listFiles();//得到所有的文件，以方便读取

for(String fl : fileList){

if(fl.isDirectory()){

System.out.println("子目录：" + fl );//输出目录的名字

fl.delete();

}

for(File f : files){

System.out.println("文件：" + f.getName());

readFile(f);

f.delete();

}

public void readFile(Flie f){

FileReader fr = new FileReader(f);

BufferedReader bf = new BufferedReader(fr);

String content = "";//用来显示文件内容

while((content = br.readLine() ) != null){

System.ount.println(content);

//此处省略了异常和关闭文件流的处理

}

26、用java扫描指定文件夹下面所有以.txt, .log结尾的文件，将其绝对路径输出

可以考虑使用文件过滤器(FileFilter)来查找指定的文件。

如例（不考虑子文件夹）：

public class FindFile {

public static void main(String[] args) {

File f = new File("F:/test");

FilterFile ff = new FilterFile(new String[] { ".log", ".Txt" });

File[] fs = f.listFiles(ff);

for (File file : fs) {

System.out.println(file.getAbsolutePath());

}

class FilterFile implements FileFilter {

String[] with;

public FilterFile(String[] with) {

this.with = with;

}

@Override

public boolean accept(File pathname) {

for (String w : with) {

return pathname.getName().toLowerCase().endsWith(w.toLowerCase());

}

return false;

}

27、什么是类的反射机制？

1】通过类的类名，获得类的字段，方法，构造方法，接口，可以实例化类

2】Hibernate，spring中经常用到，充分体现

3】代理模式也是

28、什么是java序列化，如何实现java序列化？

答：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

29、写个单例模式

确保一个类只有一个实例，并提供一个全局的访问点

步骤：

1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象；

2，就在类中创建一个本类的对象；

3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）

第一种方式：装载类的时候就创建类的实例，用空间换时间。
第二种方式：延迟装载，不需每次都创建一个类实例，而只是在第一次使用时创建，有效的利用资源，用时间换资源

代码体现：

1，私有化构造函数；

2，创建私有并静态的本类对象；

3，定义公有并静态的方法，返回该对象。

--------饿汉式

Public class Singleton{

Private static Singleton(){};

Private static Singleton s =new Singleton();

Public static Singleton getInstance(){

Return s;

}

-------懒汉式

Public class Single{

Private static Single(){};

Private stattic Single s =null;

Public static synchronized Single getInstance(){

If(s==null){

S=new Single();

Return s;

}

30、String 和StringBuffer的区别

JAVA平台提供了两个类：String和StringBuffer，

它们可以储存和操作字符串，即包含多个字符的字符数据。

String类表示内容不可改变的字符串。而StringBuffer类表示内容可以被修改的字符串

String覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和 hashCode方法

31、String实现了equals方法，而StringBuffer没有实现equals方法

32、.Error与Exception有什么区别？

Error表示系统级的错误和程序不必处理的异常，

Exception表示需要捕捉或者需要程序进行处理的异常。

33、.游标的作用？如何知道游标已经到了最后？

游标用于定位结果集的行，通过判断全局变量@@FETCH_STATUS可以判断是否到了最后，通常此变量不等于0表示出错或到了最后。 @fetch_status

游标是系统为用户开设的一个数据缓冲区，存放SQL语句的执行结果
每个游标区都有一个名字
用户可以用SQL语句逐一从游标中获取记录，并赋给主变量，交由主语言进一步处理
主语言是面向记录的，一组主变量一次只能存放一条记录
仅使用主变量并不能完全满足SQL语句向应用程序输出数据的要求
嵌入式SQL引入了游标的概念，用来协调这两种不同的处理方式

34、触发器分为事前触发和事后触发，两种触发有和区别。语句级触发和行级触发有何区别。

事前触发器运行于触发事件发生之前，而事后触发器运行于触发事件发生之后。通常事前触发器可以获取事件之前和新的字段值。

语句级触发器可以在语句执行前或后执行，而行级触发在触发器所影响的每一行触发一次。

35、hibernate 中的java 对象有几种状态，其相互关系如何（区别和相互转换）。

1）临时状态：当new 一个实体对象后，这个对象处于临时状态，即这个对象只是一个保存临时数据的内存区域，如果没有变量引用这个对象，则会被jre 垃圾回收机制回收。这个对象所保存的数据与数据库没有任何关系，除非通过Session 的save 或者SaveOrUpdate 把临时对象与数据库关联，并把数据插入或者更新到数据库，这个对象才转换为持久对象；

2）持久状态:持久化对象的实例在数据库中有对应的记录，并拥有一个持久化表示（ID）。对持久化对象进行delete 操作后，数据库中对应的记录将被删除，那么持久化对象与数据库记录不再存在对应关系，持久化对象变成临时状态。持久化对象被修改变更后，不会马上同步到数据库，直到数据库事务提交。在同步之前，持久化对象是脏的（Dirty）。

3）游离状态：当Session 进行了Close、Clear 或者evict 后，持久化对象虽然拥有持久化标识符和与数据库对应记录一致的值，但是因为会话已经消失，对象不在持久化管理之内，所以处于游离状态（也叫：脱管状态）。游离状态的对象与临时状态对象是十分相似的，只是它还含有持久化标识。

36、描述forward 和redirect的区别

forward是服务器请求资源，服务器直接访问目标地址的URL，目标地址可以接收request 请求参数，然后把结果发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。
redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求哪个地址，浏览器会重新进行请求，此时不能用request传值，浏览器的地址栏会变成新的地址

37、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

Overload编译时的多态 Override运行时的多态

方法的重写Overriding和重载Overloading是Java多态性的不同表现。

重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。

子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。

如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。

Overloaded的方法是可以改变返回值的类型。

38、说出Servlet的生命周期，并说出Servlet和CGI的区别

servlet 服务器实例化后，容器运行其init方法，

2）当请求到达时运行其service方法，service方法根据请求的类型调用（doGet,doPost）方法

3）当服务器决定将实例销毁时候调用其destroy方法

4）与CGI区别：servlet处于服务进程中，通过多线程方法运行service方法，

一个实例可以服务多个请求，并且实例一般不会销毁，

而CGI对每个请求都产生新的进程，服务完成后就销毁，其效率低于servlet

39、创建 CUSTOMERS 表，字段为： ID：（非空，主键） bigint， NAME：（非空） varchar， AGE： int 类型；创建 ORDERS 表，字段为： ID：（非空，主键，） bigint， ORDER_NUMBER：（非空） varchar， PRICE： double，CUSTOMER_ID ：（外键） bigint，设置级连删除；

USE tt;

CREATE TABLE customers(

id BIGINT PRIMARY KEY,

NAME VARCHAR(15)NOT NULL,

age INT

);

SELECT*FROM customers

CREATE TABLE orders(

id BIGINT PRIMARY KEY,

order_number VARCHAR(20)NOT NULL,

price DOUBLE PRECISION,

customer_id BIGINT

);

ALTER TABLE orders ADD CONSTRAINT FK_CUSTOMER FOREIGN KEY(customer_id)REFERENCES customers(id)ON DELETE CASCADE;

注意：alter table 本表名 add constraint 外键名称 foreign key(本表字段)references 外表名（字段）On delete cascade;

40、简述数据库事务的生命周期？（可画流程图）

1）数据库初始化状态

2）开始事务

3）执行sql增删改查语句

4）提交事务时到更新后的数据库状态

5）撤销事务时回到数据库的初始化状态

41、初始化了一个没有run()方法的线程类,是否会出错？

答案：不会。

第一种方法：直接继承Thread类。

public class Test

{

public static void main(String[] args)

{

ThreadClass t = new ThreadClass();

t.start();

System.out.println("end");//输出“end”

}

class ThreadClass extends Thread //Thread类已经实现了空的run()方法。

{

}

第二种方法：实现Runnable接口

public class Test

{

public static void main(String[] args)

{

ThreadClass t = new ThreadClass();

Thread thread = new Thread(t);

thread.start();

System.out.println("end");

}

class ThreadClass implements Runnable

{

public void run() //必须有此方法否则编译报错。它是Runnable接口中的抽象方法。

{

System.out.println("Threads");

}

42、

44、说出一些常用的类，包,接口，请各举5个？

常用的类：object;array,date;file;exception;

Object

Array 提供了动态创建和访问Java数组的方法

BufferedReader 从字符输入流中读取文本

BufferedWriter

BufferedInputStream 字节流

Calendar 提供操作日历字段的方法

Date

File

Exception

FileReader、FileWriter

HashSet 、HashMap

InputStream、OutputStream

Integer、Float、String

List、Map、Set

Pattern 正则表达式的编译表示形式

Random , Request、Response , System Thread

常用的包：java.io;java.lang;java.util;javax.swing;java.sql

java.io 流 , java.lang , java.util 框架 , java.sql , javax.swing

java.net

常用的接口：collection;runnable;comparable;session;servlet

Collection、List、Set、Map

Comparable

Runnable

java.io.Serializable

Session、HttpSession

Servlet、HttpServletRequest、HttpServletResponse,

45、用sql语句分页：

取出sql表中第31到40的记录（以自动增长ID为主键）

sql server方案1：

select top 10 * from t where id not in (select top 30 id from t order by id ) orde by id

sql server方案2：

select top 10 * from t where id in (select top 40 id from t order by id) order by id desc

mysql方案：select * from t order by id limit 30,10

oracle方案：select * from (select rownum r,* from t where r<=40) where r>30

--------------------待整理进去的内容-------------------------------------

pageSize=20;

pageNo = 5;

1.分页技术1（直接利用sql语句进行分页，效率最高和最推荐的）

mysql:sql = "select * from articles limit " + (pageNo-1)*pageSize + "," + pageSize;

oracle: sql = "select * from " +

"(select rownum r,* from " +

"(select * from articles order by postime desc)" +

"where rownum<= " + pageNo*pageSize +") tmp " +

"where r>" + (pageNo-1)*pageSize;

注释：第7行保证rownum的顺序是确定的，因为oracle的索引会造成rownum返回不同的值

简洋提示：没有order by时，rownum按顺序输出，一旦有了order by，rownum不按顺序输出了，这说明rownum是排序前的编号。如果对order by从句中的字段建立了索引，那么，rownum也是按顺序输出的，因为这时候生成原始的查询结果集时会参照索引表的顺序来构建。

sqlserver:

Select top 页大小*from table1 where id not in

（select top 页大小*（页数-1）id from table1 order by id）order by id

Mysql:

Select*from tableName limit (pageNum-1)*pageSize , pageSize;

Oracle:

截取id方法

Select*from emp a,

(select empno, rownum as num from emp) b

Where a.empno = b.empno=b.empno and b.num between 5 and 7;

三层嵌套方法

Select*from (select a.*,rownum r from (select*from emp) A where rownum<=7) B where r>5;

46、struts2的实现原理

Struts2的实现原理

客户端初始化一个指向servlet容器的请求，该请求经过一系列的过滤器（filter）

接着filterDispatcher被调用，filterDispatcher询问actionMapper来决定这个请求是否需要调用某个action,若需要的话，filterDispatcher把请求的处理交给actionProxy

actionProxy通过configurationManager询问框架的配置文件，找到需要调用的action类

actionProxy创建一个actionInvocation的实例，该实例使用命名模式来调用，在调用action的过程前后，涉及到相关拦截器（intercepter）的调用

一旦action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果.

返回结果一个被表示的JSP或者freeMarker的模式

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

47、查询出M 页的N行数据(分页的实现，求第M也的记录数)

Select top N from table where id not in (select top (M-1)*N id from table )

递归实现1,1,2,3,5,8,„.第30个数是多少？

public class DiGuiTest {

public static int DiGui(int i) {

if(i<=0){

return 0;

}else if(i>0&&i<=2){

return 1;

}else {

return DiGui(i-1)+DiGui(i-2);

}

public static void main(String[] args) {

DiGuiTest dg =new DiGuiTest();

int j=dg.DiGui(30);

System.out.println(j);

}

48、写出删除表中重复记录的语句 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

49、怎么用java反射得到一个类的私有方法？

package test;

public class TestClass { private String testMethod(String value){ return "test:"+value; } } try { //得到test.TestClass类

Class c=Class.forName("test.TestClass");

//得到testMethod的方法

Method m=c.getDeclaredMethod("testMethod", new Class[]{String.class}); //打印完整的方法表示字符串

System.out.println(m.toGenericString()); //调用这个方法

Object obj=m.invoke(c.newInstance(), new Object[]{"method"});

//打印返回结果

System.out.println(obj); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace();

} catch (IllegalArgumentException e) { // TODO Auto-generated catch block

e.printStackTrace();

} catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace();

} catch (NoSuchMethodException e) { // TODO Auto-generated catch block

e.printStackTrace();

} catch (IllegalAccessException e) { // TODO Auto-generated catch block

e.printStackTrace();

} catch (InvocationTargetException e) { // TODO Auto-generated catch block

e.printStackTrace();

} catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace();}

50、多线程、同步实现方法？

1）实现线程有两种方法：继承Thread类或者实现Runnable接口

2）实现同步也有两种,一种是用同步方法,一种是用同步块..

同步方法就是在方法返回类型后面加上synchronized, 比如: senknst

public void synchronized add(){...} return synchronized

同步块就是直接写:synchronized (这里写需要同步的对象){...}synchonized。

51、java中实现多态的机制是什么

重写，重载

1)方法的重写Override和重载Overloade是Java多态性的不同表现。

2)重写Overriding是父类与子类之间多态性的一种表现，

重载Overloading是一个类中多态性的一种表现。

如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。

4)在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

52、开发中都用到了那些设计模式?用在什么场合?

每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心。通过这种方式，你可以无数次地使用那些已有的解决方案，无需在重复相同的工作。

(1) MVC模式,在J2EE项目开发中主要用在表示层框架中，很好解决视图和流程控制。在项目中采用的Struts、WebWork等框架。

(2) DAO模式,在项目开发中主要用在数据层，封装数据的访问操作，为业务层提供数据服务。

(3) IOC模式,在项目开发中业务层有大量对象，他们之间存在依赖关系，可以使用IoC模式减少他们之间的代码耦合，提高系统的可扩展性。实际项目中使用的Spring框架来实现业务组件的装配。

(4) Observer模式，在Servlet的监听器中应用到了观察者模式。

(5) singleton单例模式和Factory工厂模式结合使用在项目中无需使用者了解过多的细节就可获取有关的对象实例。比如Hibernate项目中通过SessionFactory来获取Session。

(6) bridge模式，在项目中使用JDBC驱动访问数据库。

================================

Linkedlist 和arraylist内部是如何实现的

（思路：更深入的问了LinkedList与ArrayList的区别）

ArrayList的内部实现是基于内部数组Object[]，所以从概念上讲，它更像数组，但LinkedList的内部实现是基于一组连接的记录，所以，它更像一个链表结构，所以，它们在性能上有很大的差别。

在ArrayList的前面或中间插入数据时，必须将其后的所有数据相应的后移，这样必然要花费较多时间，所以，当你的操作是在一列数据的后面添加数据而不是在前面或中间，并且需要随机地访问其中的元素时，使用ArrayList会提供比较好的性能；

而访问链表中的某个元素时，就必须从链表的一端开始沿着连接方向一个一个元素地去查找，直到找到所需的元素为止，所以，当你的操作是在一列数据的前面或中间添加或删除数据，并且按照顺序访问其中的元素时，就应该使用LinkedList了。

如果在编程中，两种情形交替出现，这时，可以考虑使用List这样的通用接口，而不用关心具体的实现，在具体的情形下，它的性能由具体的实现来保证。

53、ajax的工作原理？

Ajax 基本上就是把 JavaScript 技术和 XMLHttpRequest 对象放在 Web 表单和服务器之间。当用户填写表单时，数据发送给一些 JavaScript 代码而不是直接发送给服务器。相反，JavaScript 代码捕获表单数据并向服务器发送请求。同时用户屏幕上的表单也不会闪烁、消失或延迟。换句话说，JavaScript 代码在幕后发送请求，用户甚至不知道请求的发出。更好的是，请求是异步发送的，就是说 JavaScript 代码（和用户）不用等待服务器的响应。因此用户可以继续输入数据、滚动屏幕和使用应用程序。然后，服务器将数据返回 JavaScript 代码（仍然在 Web 表单中），后者决定如何处理这些数据。它可以迅速更新表单数据，让人感觉应用程序是立即完成的，表单没有提交或刷新而用户得到了新数据。JavaScript 代码甚至可以对收到的数据执行某种计算，再发送另一个请求，完全不需要用户干预！这就是 XMLHttpRequest 的强大之处。它可以根据需要自行与服务器进行交互，用户甚至可以完全不知道幕后发生的一切。结果就是类似于桌面应用程序的动态、快速响应、高交互性的体验，但是背后又拥有互联网的全部强大力量。

AjAX有什么好处？

用于需要查询数据库才能做的页面校验,再比如实时刷新,再比如良好的用户界面以及快速的响应等等无刷新、减少网络流量

54、用Java实现二叉树前序遍历、中序遍历和后序遍历。

public class Tree {

private int data; /* 数据节点 */

private Tree left; /* 左子树 */

private Tree right; /* 右子树 */

public Tree( int data )

{

this.data = data;

this.left = null;

this.right = null;

}

/**

* 创建二叉树，返回根结点

public static Tree createTree( int[] input )

{

Tree root = null;

Tree temp = null;

for ( int i = 0; i < input.length; i++ )

{

/* 创建根节点 */

if ( root == null )

{

root = temp = new Tree( input[i] );

} else {

/* 回到根结点 */

temp = root;

/* 添加节点 */

while ( temp.data != input[i] )

{

if ( input[i] <= temp.data )

{

if ( temp.left != null )

{

temp = temp.left;

} else {

temp.left = new Tree( input[i] );

}

} else {

if ( temp.right != null )

{

temp = temp.right;

} else {

temp.right = new Tree( input[i] );

}

return(root);

}

/**

* 前序遍历

public static void preOrder( Tree tree )

{

if ( tree != null )

{

System.out.print( tree.data + “ ” );

preOrder( tree.left );

preOrder( tree.right );

}

/**

* 中序遍历

public static void midOrder( Tree tree )

{

if ( tree != null )

{

midOrder( tree.left );

System.out.print( tree.data + “ ” );

midOrder( tree.right );

}

/**

* 后序遍历

public static void posOrder( Tree tree )

{

if ( tree != null )

{

posOrder( tree.left );

posOrder( tree.right );

System.out.print( tree.data + “ ” );

}

/**

* 求二叉树的深度

public static int length( Tree tree )

{

int depth1;

int depth2;

if ( tree == null )

return(0);

/* 左子树的深度 */

depth1 = length( tree.left );

/* 右子树的深度 */

depth2 = length( tree.right );

if ( depth1 > depth2 )

return(depth1 + 1);

else

return(depth2 + 1);

}

public static void main( String[] args )

{

int[] input = { 4, 2, 6, 1, 3, 5, 7, 8, 10 };

Tree tree = createTree( input );

System.out.print( “ 前序遍历： “ );

preOrder( tree );

System.out.print( “ \ n 中序遍历： “ );

midOrder( tree );

System.out.print( “ \ n 后序遍历： “ );

posOrder( tree );

}

55、由aaa字符串得到1000个a写个程序

StringBuilder sBuilder = new StringBuilder();

for(int i=0;i<333;i++){

sBuilder.Append("aaa");

}

sBuilder.Append("aaa".substring(0,1));

public static void main(String[] args) {

// TODO Auto-generated method stub

StringBuilder sBuilder =new StringBuilder();

for(int i=0;i<333;i++){

sBuilder.append("aaa");

}

sBuilder.append("aaa".substring(0,1));

System.out.println("得到a的数量为："+sBuilder.length()+"个a");

}

------------------------结果：得到a的数量为：1000个a

}

56、Error和 exception的区别与联系

error 表示恢复不是不可能,但很困难的情况下的一种严重问题。比如说内存溢,网络故障等。不可能指望程序能处理的情况。

exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，就不会发生的情况。程序可以捕获到这些异常，并进行处理。

57、在编写页面的会用到哪些技术？

美化页面需要用到CSS、页面交互使用JavaScript、动态页面需要用到JSP、XML等动态网页技术。

58、Spring工作原理

内部最核心的就是IOC了，动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射,反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置文件来动态的创建对象，和调用对象里的方法的还有一个核心就是AOP这个就是面向切面编程，可以为某一类对象进行监督和控制（也就是在调用这类对象的具体方法的前后去调用你指定的模块）从而达到对一个模块扩充的功能。这些都是通过配置类达到的

Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明管理的（Spring根据这些配置内部通过反射去动态的组装对象）要记住：Spring是一个容器，凡是在容器里的对象才会有Spring所提供的这些服务和功能

Hibernate 的初始化

读取Hibernate 的配置信息-〉创建Session Factory 1)创建Configeration类的实例。

它的构造方法：将配置信息(Hibernate config.xml)读入到内存。

一个Configeration 实例代表Hibernate 所有Java类到Sql数据库映射的集合。 2)创建SessionFactory实例

把Configeration 对象中的所有配置信息拷贝到SessionFactory的缓存中。

SessionFactory的实例代表一个数据库存储员源，创建后不再与Configeration 对象关联。缓存(cache):指Java对象的属性(通常是一些集合类型的属性－－占用内存空间。

在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. split (“.”); 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”); }

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>

59、servlet的生命周期：

servlet容器创建servlet的一个实例

容器调用该实例的init()方法

如果容器对该servlet有请求，则调用此实例的service()方法容器在销毁本实例前调用它的destroy()方法销毁并标记该实例以供作为垃圾收集

一旦请求了一个servlet，就没有办法阻止容器执行一个完整的生命周期。

容器在servlet首次被调用时创建它的一个实例，并保持该实例在内存中，让它对所有的请求进行处理。容器可以决定在任何时候把这个实例从内存中移走。在典型的模型中，容器为每个servlet创建一个单独的实例，容器并不会每接到一个请求就创建一个新线程，而是使用一个线程池来动态的将线程分配给到来的请求，但是这从servlet的观点来看，效果和为每个请求创建一个新线程的效果相同。

一旦请求提交给容器，容器会自动创建相应的request、response，一旦回应完毕则request、response自动销毁。客户端第一次请求时，容器会建立相应的会话，直到会话超时，会话随即销毁。

60、解释一下mvc以及熟悉的mvc框架

答:m代表模型层，v 代表视图层，c代表控制层，也就是把一个整体分割成不同的模块，各负责自己的功能，分工明确，提高代码的重用性和方便维护。

在jsp设计模式二中，jsp用来做视图层，servlet是控制器，dao则处理相关业务成为模型层。在struts2.0,其中m是action,c是拦截器，v是jsp.

61、解释一下IOC,以及spring的举例

IOC称为控制反转，也叫依赖注入，ioc是Spring的核心组件，它通过配置文件，将需要创建的对象以池的方式管理，将实例注入到需要的对象中区，是对象依赖于注入而不依赖于实现，解决了各个组件的耦合度，使得项目在后期的维护和扩展上非常方便。如在ssh框架整合中，我们将datasource对象注入给sessionFactory，再将sessionFactory注入给dao组件，再将dao组件注入给struts的Action组件，在将action对象注入给struts的拦截器。

62、JSP与SERVLET区别

JSP在本质上就是SERVLET,但是两者的创建方式不一样.Servlet完全是JAVA程序代码构成，擅长于流程控制和事务处理，通过Servlet来生成动态网页很不直观.JSP由HTML代码和JSP标签构成，可以方便地编写动态网页.因此在实际应用中采用Servlet来控制业务流程，而采用JSP来生成动态网页.在struts框架中，JSP位于MVC设计模式的视图层，而Servlet位于控制层.JSP是Servlet技术的扩展，本质上就是Servlet的简易方式。JSP编译后是“类servlet”。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP是Java和HTML组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。

-----------------------------------------------

SSH框架中，用流程表示处理过程。

从Request, Response

---------------------------------------------

用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); } } }

----------------------------------------------

62、SSH的优点和缺点

优点： ssh把数据库，实体，配置都整合，封装层次的结构（偏于mvc模式）

而且框架的融合，代码的耦合都很不错

对于编程的持续化，扩展化，维护化都很棒，SSH已经把底层实现封装好了，开发人员可以更专注于业务处理，缺点：出现错误容易搞的复杂

如果某个框架不是很熟悉的话（特别是spring）那就很麻烦运行速度比较慢

63、用JDBC来实现访问数据库记录步骤：

1、通过驱动器管理器获取连接接口。 2、获得Statement或它的子类。 3、限制Statement中的参数。 4、执行Statement。

查看返回的行数是否超出范围。 6、关闭Statement。 7、处理其它的Statement 8、关闭连接接

64、列举你接触过的框架，说明特点和原理

1）struts框架具有组件的模块化，灵活性和重用性的优点，同时简化了基于MVC的web应用程序的开发，缺点：Taglib是Struts的一大优势，但对于初学者而言，却需要一个持续学习的过程，甚至还会打乱你网页编写的习惯 Struts将MVC的Controller一分为三，在获得结构更加清晰的同时，也增加了系统的复杂度，工作原理：用一个servlet拦截用户的请求，并分发到具体的action中去处理，再将返回的response进行封装，这是处理页面流程的机制，另外还有一些标签，非常容易在页面进行显示。

2）Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

3）Spring 也表示是一个开源框架，是为了解决企业应用程序开发复杂性由Rod Johnson创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

65、Struts Hibernate Spring 在程序中用到哪些

典型的J2EE三层结构，分为表现层、中间层（业务逻辑层）和数据服务层。三层体系将业务规则、数据访问及合法性校验等工作放在中间层处理。客户端不直接与数据库交互，而是通过组件与中间层建立连接，再由中间层与数据库交互。

表现层是传统的JSP技术，自1999年问世以来，经过多年的发展，其广泛的应用和稳定的表现，为其作为表现层技术打下了坚实的基础。

中间层采用的是流行的Spring+Hibernate，为了将控制层与业务逻辑层分离，又细分为以下几种。

Web层，就是MVC模式里面的“C”（controller），负责控制业务逻辑层与表现层的交互，调用业务逻辑层，并将业务数据返回给表现层作组织表现，该系统的MVC框架采用Struts。

Service层（就是业务逻辑层），负责实现业务逻辑。业务逻辑层以DAO层为基础，通过对DAO组件的正面模式包装，完成系统所要求的业务逻辑。

DAO层，负责与持久化对象交互。该层封装了数据的增、删、查、改的操作。

PO，持久化对象。通过实体关系映射工具将关系型数据库的数据映射成对象，很方便地实现以面向对象方式操作数据库，该系统采用Hibernate作为ORM框架。

Spring的作用贯穿了整个中间层，将Web层、Service层、DAO层及PO无缝整合，其数据服务层用来存放数据。

一个良好的框架可以让开发人员减轻重新建立解决复杂问题方案的负担和精力；它可以被扩展以进行内部的定制化；并且有强大的用户社区来支持它。框架通常能很好的解决一个问题。然而，你的应用是分层的，可能每一个层都需要各自的框架。仅仅解决UI问题并不意味着你能够很好的将业务逻辑和持久性逻辑和UI 组件很好的耦合。

65、Webservice 有什么好处?

跨平台的可互操作性跨防火墙的通信应用程序集成软件和数据重用

连接池的原理

j2ee 服务器启动时会建立一定数量的池连接，并一直维持不少于此数量的池连接。当客户端程序需要连接时，吃驱动程序会返回一个未使用的池连接并将其标记为忙。如果当前没有空闲连接，池驱动就建立一定新的连接

66、说一下垃圾回收的原理，可以直接从内存中回收吗?

垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象和进行清楚回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收

67、java的异常有哪几种，有什么区别。

第一种方式：直接在函数头中throws SomeException，函数体中不需要try/catch

第二种方式：使用try/catch，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常

第三种方法：使用try/catch/finally，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常

通过部署描述文件（web.xml）可以配置哪些功能？

监听器。。过滤器。。也可以用来验证XML文件的正确性

68、说一下mvc原理

1、模型（Model）

模型是应用程序的主体部分。模型表示业务数据，或者业务逻辑.

2、视图（View）

视图是应用程序中用户界面相关的部分，是用户看到并与之交互的界面。

3、控制器（controller)

控制器工作就是根据用户的输入，控制用户界面数据显示和更新model对象状态。

MVC 式的出现不仅实现了功能模块和显示模块的分离，同时它还提高了应用系统的可维护性、可扩展性、可移植性和组件的可复用性

69、在Liniux/Uinix下创建一个角色帐号，自己拥有一切权限，系统用户拥有访问权限，其他用户没有任何权限

70、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();

}

71、介绍下spring ,ajax ,hibernate

1)Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯.Spring的架构基础是基于使用JavaBean属性的Inversion of Control容器是一个解决了许多在J2EE开发中常见的问题的强大框架，还提供了可以和总体的IoC容器集成的强大而灵活的MVC web框.

2)AJAX全称为“Asynchronous JavaScript and XML”（异步JavaScript和XML），是指一种创建交互式网页应用的网页开发技术

3)Hibernate是连接 Java 应用程序和关系数据库的中间件。它对 JDBC API 进行了封装，负责Java对象的持久化。在分层的软件架构中它位于持久化层，封装了所有数据访问细节，使业务罗基层可以专注于实现业务逻辑

72、函数和过程的区别？

过程和函数区别如下：

1、标识符不同:函数的标识符为FUNCTION，过程为：PROCEDURE。

2、话法不同：函数中一般不用变量形参，用函数名直接返回函数值；而过程如有返回值，则必须用变量形参返

回。

3、函数在定义时一定要进行函数的类型说明，过程则不进行过程的类型说明。

4、调用方式不同:函数的调用出现在表达式中，过程调用，由独立的过程调用语句来完成。 5、过程一般会被设计成求若干个运算结果，完成一系列的数据处理，或与计算无关的各种

操作；而函数往往只为了求得一个函数值。

73、 Struts 是怎么实现MVC的？

Struts提供MVC三层模式:

MVC就是 model view controller.

1】view视图层一般运用jsp或者html进行实现，展现给用户看；

2】controller控制层struts有个文件叫struts-config.xml，该文件里面定义个处理后的跳转页面；

3】model模型层理解不深，可能是逻辑模型

74、Web service 是什么？它是采用什么通信机制，它的通信协议是什么？

答： Webservice是跨平台，跨语言的远程调用技术;

1. 它的通信机制实质就是xml数据交换;

2. 它采用了soap协议（简单对象协议）进行通信

75、j a v a 对象初始化顺序

1.类的初始化（initialization class & interface）

2.对象的创建（creation of new class instances）

顺序：应为类的加载肯定是第一步的，所以类的初始化在前。大体的初始化顺序是：

类初始化 -> 子类构造函数 -> 父类构造函数 -> 实例化成员变量 -> 继续执行子类构造函数的语句

76、类的工厂模式怎么实现？

首先确定这些类的父类或共同的接口，担任抽象产品的角色，比如 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); } }

77、Web容器里面的对象存活周期？

Web容器里面的对象的存活周期由JVM控制。某个对象有容器负责实例化或应用负责实例化，如果某个对象得不到任何引用，

则由JVM的垃圾收集器负责销毁。

struts2中action的对象的生命周期？

用spring来控制action的生命周期Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。

78、说说你对IOC的理解

答：1.控制反转（Inversion of Control，英文缩写为IoC）是一种设计模式；

2.控制反转还有一个名字叫做依赖注入（Dependency Injection）。简称DI；

应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。

79、整合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的控制之下。无疑，这是最灵活的一种整合方式。

80、哪几个方法可以实现一个线程？

一种是声明 Thread 的子类,重载 Thread 类的方法 run。另一种途径是声明一个类，该类实现 Runnable 接口。然后再实现方法 run。

1.spring对多种ORM 框架提供了很好的支持，结合事务管理描述spring中使用Hibernate的方法。

答：spring中采用aop模式注入hibernate的sessionfactory和事务管理,在dao中调用.Spring集成hibernate有两种

方式,一是dao层只与hibernate有关, 不使用任何spring 的api, 然后把dao注入到ioc容器.二是使用spring的hibernateDaoSupport.事务管理也可以只使用hibernate的事务管理.

2.Hibernate有哪几种查询数据的方法？

答:hibernate在查询方式上有三种方式:HQL SQL QBC

从一到十九共十九个数,打印出利用这十九个整数任意多个相加等于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); }

}

81、写几个线程安全类，不安全的，支持排序的类名？线程安全类：Vector 、Hashtable、

不安全的类：ArrayList、HashMap、Linkedlist

支持排序的类：TreeSet

JDK也提供一个对集合类进行线程安全处理的类Collections类，可以对一些非结程安全的类进行同步处理。

将ISO8859-1字符串转成GB2312编码，语句为？

String s=new String(text.getBytes(“iso8859-1”),”gb2312”).

82、写一个递归编程

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));

}

83、用javascript实现用户登录验证的代码.

function checkSubmit()

{if ((document.form1.name.value)=='') {

window.alert ('姓名必须填写'); document.form1.name.select(); document.form1.name.focus(); return false; } else

return true;

}

</script>

84、编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。

但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6应该输出为“我ABC”而不是“我ABC+汉的半个”。

public static void main(String[] args) throws Exception{

String str = "我a爱中华abc def';

String str = "我ABC汉";

int num = trimGBK(str.getBytes("GBK"),5);

System.out.println(str.substring(0,num) );

}

public static int trimGBK(byte[] buf,int n){

int num = 0;

boolean bChineseFirstHalf = false;

for(int i=0;i<n;i++) {

if(buf[i]<0 && !bChineseFirstHalf){

bChineseFirstHalf = true;

}else{

num++;

bChineseFirstHalf = false;

}

return num;

}

85、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!"); } } } } }

86、编程题：读取一个文件在控制台打印出来

File file = new File("E:\\课件\\二期课件\\Java\\T09 src\\JRadioButtonDemo.java");

long file_length= file.length();

try { //输入流

FileInputStream input = new FileInputStream(file);

byte b_data [] = new byte[(int)file_length];

input.read(b_data);

System.out.println(new String(b_data)); input.close();

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) { // TODO Auto-generated catch block

e.printStackTrace();

}

87、解析XML的方法及对它的了解？

答：:有DOM,SAX,STAX等

DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问

88、介绍几种WEB服务器，问Tomcat里面的文件组成？

IIS、apache、Tomcat

bin:启动,关闭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规范且比绝大多数商业应用软件服务器要好。

89、适配器模式解释：

把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端

try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

也许你的答案是在return之前，但往更细地说，我的答案是在return中间执行，请看下面程序代码的运行结果：

public class Test { public static void main(String[] args) { // TODO Auto-generated method stub

System.out.println(new Test().test());;

}

static int test()

{ int x = 1;

try { return x;

}

finally { ++x;

} } }

---------执行结果 --------- S1

运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。

90、概述反射和序列化

反射Reflection 是Java 程序开发语言的特征之一，它允许运行中的Java 程序对自身进行检查;能直接操作程序的内部属性和方法。

简单来说序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化，我们可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。而把Java对象转换为字节序列的过程称为对象的序列化。

91、dao 是什么及作用

DAO组件主要提供数据库访问操作，主要是对各自数据表的CRUD方法，在一般设计过程中为了考虑松耦合的问题，业务逻辑层中不应当牵涉到任何持久层实际操作，所以可以将各数据源表的操作特性封装到DAO组件中去，这样增强了系统的可读性、可维护性。92、 Inserted和deleted的含义？

SQLServer的DML触发器中两个临时表

inserted表反映插入或更新操作时插入的记录

deleted表反映删除或更新操作时删除的记录

93、3个框架在项目在项目当中的用，basedao是用来做什么的。

DAO组件主要提供数据库访问操作，针对不同数据源表进行了封装，这样可以提供其它层的访问接口，使得组件之间解耦，而BaseDAO是这些所有不同DAO的公共特性的封装，针对一些可以进一步进行细化的DAO组行的进一步抽象，使组件的移值性更为灵活。

94、sp与servlet中请求转发的区别

forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址，但此转发是连续的转发，在转发过程中请求参数也连续转发到目标地址中。

redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求。前者对请求是连续的，后者是重新发送一个新的请求，所以只能重新发送新的请求参数，原有的请求参数将不再连续到目标页面。

95、分页的优化需考虑哪些

sql语句的优化：ID排除法、三层嵌套等表的优化：适当使用索引

web运用程序的稳定、安全需要考虑哪些

Web服务器的性能考虑主要有：并发用户数、事务安全、负载均衡、时段流量、网络带宽安全性：

关键数据的保护，例如用户数据等 ·

功能服务的正常提供。 ·

网站的防攻击能力

对异常灾害的恢复能力

程序性能：

响应请求并运行得出结果的平均时间

错误的检测和拦截 ·

扩展性

96、把二叉树从小到大遍历出来怎么实现？

public class Node { public int value; public Node left; public Node right;

public void store(int value) { if(value<this.value) { if(left == null) {

left = new Node();

left.value=value; } else { left.store(value);

}

else if(value>this.value) {

if(right == null)

{ right = new Node(); right.value=value;

} else { right.store(value); }

} }

public boolean find(int value)

{

System.out.println("happen " + this.value); if(value == this.value) {

return true; }

else if(value>this.value) { if(right == null) return false;

return right.find(value);

}else { if(left == null) return false; return left.find(value);

}

public void preList() { System.out.print(this.value + ","); if(left!=null) left.preList(); if(right!=null) right.preList();

}

public void middleList() { if(left!=null) left.preList();

System.out.print(this.value + ",");

if(right!=null) right.preList();

}

public void afterList() { if(left!=null) left.preList();

if(right!=null) right.preList();

System.out.print(this.value + ",");

}

public static void main(String [] args)

{

int [] data = new int[20]; for(int i=0;i<data.length;i++) { data[i] = (int)(Math.random()*100) + 1; System.out.print(data[i] + ",");

}

System.out.println();

Node root = new Node(); root.value = data[0];

for(int i=1;i<data.length;i++) { root.store(data[i]);

}

root.find(data[19]);

root.preList();

System.out.println(); root.middleList(); System.out.println();

root.afterList();

}

两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对? 对。

如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode，当然，我们没有理由不实现，通常都会去实现的。

97、Orace中除了数据库[XX]备份，还有什么方法备份？

1.导出／导入（EXP/IMP）。

2.热备份。热备份是在数据库运行的情况下，采用archivelog mode方式备份数据库的方法。所以，如果你有昨天夜里的一个冷备份而且又有今天的热备份文件，在发生问题时，就可以利用这些资料恢复更多的信息。热备份要求数据库在Archivelog方式下操作，并需要大量的档案空间。一旦数据库运行在archivelog状态下，就可以做备份了。

3.冷备份。冷备份发生在数据库已经正常关闭的情况下，当正常关闭时会提供给我们一个完整的数据库。冷备份时将关键性文件拷贝到另外的位置的一种说法。

98、问spring的AOP，mvc到底是怎么优化程序的结构？

SpringAOP主要提供了Pointcut、Aspects等以及它们如何被织入应用程序、代理的方式等等进行优化的控制。而Spring MVC里面前端控制器叫做DispatcherServlet。里面充当Action的组件叫做Controller，返回的视图层对象叫做ModelAndView，提交和返回都可能要经过过滤。从而提高程序可读性和稳定性。

99、笔试：1.LinkedList和ArrayList内部是如何实现的？new ArrayList（10）意思

new ArrayList（10）构造一个初始容量为 10 的空列表

定义一个变量，Var v =new Object (),用js编写的简便写法是什么？

var v = {};

100、网上购物系统的类图，用例图。

主要的类有：商品分类商品订单订单项商品评论

主要用例有：查看商品详情发表评论登录注册购物车管理订单生成查询订单等

101、给你一个整数类型的数组，按从小到大的顺序进行排列！

Array.sort(int a[]);//默认为升序排列

102、mysql分页怎么实现，oracle分页怎么实现，他们之间的区别？

Ajax是一个RIA应用技术，解决富Web客户端问题，提高用户体验的 jms是Java的消息服务系统，解决Java分布式应用消息异步通信

mysql中的limit关键字查询出指定区间的记录进行分页。

oracle中通过rownum来记录结果集记录编号实现分页

103、描述struts体系结构？对应各个部分的开发工作主要包含哪些？

按MVC设计的Web架构，

其中Model为ActionForm组件的设计

View为Struts标签的使用

Controller为Action组件的设计和ActionServlet的配置

104、truts中的prepare怎么用？

首先Action组件实现Preparable接口的prepare()方法，在配置 Action组件时应用PrepareInterceptor拦截器。

Hrbernate的二级缓存讲述。

hibernate的session提供了一级缓存，每个session，对同一个id进行两次load，不会发送两条sql给数据库，但是session关闭的时候，一级缓存就失效了。

二级缓存是SessionFactory级别的全局缓存，它底下可以使用不同的缓存类库，比如ehcache、oscache等。hibernate在执行任何一次查询的之后，都会把得到的结果集放到缓存中，缓存结构可以看作是一个hash table，key是数据库记录的id，value是id对应的pojo对象。当用户根据id查询对象的时候（load、iterator方法），会首先在缓存中查找，如果没有找到再发起数据库查询。

105、如果做个招聘网站性别只招男的，年龄20-30，如果不匹配就不能让他投简历，怎么实现？填身份证时如何让该人信息全部显示出来？

使用JavaScript做客户端检验，填身份证时使用Ajax获取人员信息；

106、软件的开发过程、以及角色？

软件立项 à 需求分析 à 概要设计 à 详细设计 à 编码测试 à 验收运行

| | | |

|------------ 分析员 ---------|--------------程序员---------------|------------测试员-------|

107、Io流 InputStream与Reader的区别 ,怎样将字符流转换成字节流

InputStream 字节输入流、Reader字符输入流

OutputStreamWriter 是字符流通向字节流的桥梁

InputStreamReader 是字节流通向字符流的桥梁

108、Struts2.0 若在一个方法中返回的是null，表明什么?struts.xml还需要配置吗？为什么？struts有那些标签？struts.xml中有那些标签？

方法返回null，表示没有视图结果回应，当然自己通过流直接输出响应结果，则struts.xml只需对Action进行映射配置，而无须进行结果配置.

109、Hibernate 运行的流程？优缺点？为什么insert比select快？可以批量insert一些数据吗？

Hibernate应该是建立在JDBC基础上的一个开源的ORM映射框架，很好的封装了实体映射实现，提供友好的实体操作接口，以及基于HQL的查询接口，在开发中可以减少编写SQL相关代码，提高效率和减少出错。

以面向对象的方式操作数据库，进行增删改很方便，但执行复杂的查询时则很费事麻烦。

select查询可能需要执行多条SQL语句，牵涉到加载策略所以执行需要消耗很多时间，相比insert操作要慢些。

hibernate可批量insert一些数据，配置文件中设置hibernate.jdbc.batch_size参数，来指定每次提交SQL的数量。

110、sqlserver查询怎样取得JAVA虚拟机默认的编码方式？

可通过Charset.defaultCharset()来获取

111、智力题：

1、有一辆火车以15公里/小时从洛杉矶开往纽约，一辆火车以20公里/小时从纽约开往洛杉矶，一只鸽子以30公里/小时从洛杉矶开往纽约，鸽子和两辆火车同时出发，鸽子遇到火车转头，向另一辆火车飞，直到两辆火车相遇，问鸽子飞了多少公里？假设洛杉矶到纽约的距离为s

那小鸟飞行的距离就是(s/(15+20))*30。

有两根不匀称的香，烧完1小时，问如何知道1 5分钟

把香称重，取出总重量的1/4

3,一群人在一黑屋子，有黑白2种帽子，每人可以看其他人的帽子，至少1顶黑帽子。如果知道自己是黑帽子，打自己一巴掌。第一次开灯，无人，关灯。第二开灯，无人，关灯。第3次，听到劈劈啪啪的声音。问有几顶黑帽子。

112、ORACLE数据库用到了哪些方面，怎样优化数据库。SQL语句过长时，怎样优化？

(1) 使用分区这种手段。所谓分区就是动态地将表中的记录分离到若干不同的表空间上，使数据在物理上被分割开来，便于维护、备份、恢复、事务及查询性能。

(2) 重建索引，及时回收那些未使用空间，提高空间利用率。 (3) 调整SGA参数

sql语句长：用存储过程！

113、有一些奇数和偶数，无序的，要求写个方法，实现将所有的奇数放在全部的偶数前面

主要代码如下：主要采用快速排序的算法。

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] + " "); }

114、你对工作流和表单的理解

一个工作流包括一组活动及它们的相互顺序关系，还包括过程及活动的启动和终止条件，以及对每个活动的描述。一个完整的工作流管理系统通常由工作流引擎、可视工作流设计、流程操作、工作流客户端程序、流程监控、表单设计工具、与表单的集成以及与应用程序的集成八个部分组成。工作流引擎作为工作流管理系统的核心部分，主要提供了对于工作流定义的解析以及流程流转的支持。

表单用来显示查询或输入的业务数据。

115、Classpath怎么设置和它的意义是什么？

比如，set CLASSPATH=C:\Java\jdk1.6.0_10\lib\dt.jar;. 设置class文件的搜索路径

用java写一个读取盘符的名字

new File("").getAbsolutePath().substring(0, 1);

116、如何去掉JAVA的内存机制？

是不是垃圾回收机制，使用System.gc()强制回收。

117、 THHP与HTTPS有什么区别？

HTTP为普通WEB协议、HTTPS为加密WEB协议。默认http为tcp80端口。https为tcp443端口

118、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.一般能用#的就别用$.

119、请裂举session、cookie、viewstated的应用范围

Session 服务器端维护，某个用户活动时间 + 延迟时间（默认20分钟）， Cookie 客户端维护，程序可指定生命周期， ViewState 小量数据，一个web页面的生命期

120、用什么方法使服务器关闭之后，session所保存的信息不会丢失？

将session信息保存到数据库中或文件中

121、用最好效率写一个2*17等于多少？

（2<<4）+ 2

0怎样计算等于24？

(10×10-4)÷4=24

122、有一个长方形蛋糕,切掉长方形一块,怎样一刀切下去成大小相等两块

将完整的蛋糕的中心与被切掉的那块蛋糕的中心连成一条线。这个方法也适用于立方体

九个球不知道哪个轻重，让你称？

4个和4个称，若相等则剩下一个是比较重要(2)若不相等，则往那边不相等的那4个球中取两个分为一组，则左2个，右2个，则有左边或右边右一个是比较重的，从任意一边取一个投入另一方，并记住这个球，从其它4个取两个放入另外一边，并记住这两个球，若从一边取走的放到另一边后，那边重，则这球比较重要，若从一边取走的放到另一边后，那边轻，则为另外一边所剩的一个球发

0 0