java面试宝典(综合知识)

心已赠人 2022-08-10 12:44 5阅读 0赞

**Java程序员面试题集**

（对原有面试题集的答案进行了全面修订，参照了JDK最新版本，删除了重复题目以及EJB2.x等无用内容，补充最新面试题、知识点巩固练习题和经典面试编程题，增加了大型网站技术架构、数据结构、操作系统、计算机网络等内容）

**1、面向对象的特征有哪些方面?**

答：面向对象的特征主要有以下几个方面：

1)抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。

2)继承(is-a)：继承是从已有类得到继承信息创建新类(方法和域)的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类、孩子类）。

关键字:extends;super(不是对象的引用,只是指示编译器调用超类的方法的特殊关键字)：(1)：

可以实现对超类构造器的调用,必须是子类构造器中的第一条语句;(2)：调用超类的方法，继承技巧:将通用的方法放在超类,具有特殊用途的方法放在子类，继承层次:由一个公共的超类派生出来的所有类的集合,继承链:从某个特定的类到其祖先的路径，注意:Java不支持多继承,支持单继承，阻止继承(final)： String类和calendar类，置换法原则:程序出现超类对象的任何地方都可以用子类对象置换,反之不成立

3)封装：通常认为封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口（可以想想普通洗衣机和全自动洗衣机的差别，明显全自动洗衣机封装更好因此操作起来更简单）。隐藏可隐藏的实现细节,暴露最简单的编程接口

4)多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说都是透明(不可见的)的。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。

对象方法调用的过程:

①　编译器查看对象声明的类型和方法

②　编译器查看调用方法时提供的参数类型

③　检查是动态绑定还是静态绑定(方法表:JVM预先为每一个类创建一个方法表,列出所有的方法名和实际调用的方法)

④　程序启动时, 采用的动态绑定调用方法

**2、作用域public,private,protected,以及不写时的区别？**

答：区别如下：

作用域     当前类  同包 子类 其他

public       √     √      √    √

protected    √     √      √    ×

default      √     √      ×    ×

private      √     ×      ×    ×

不写时默认为default。默认对于同一个包中的其他类相当于公开（public），对于不是同一个包中的其他类相当于私有（private）。受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。

**3、String 是最基本的数据类型吗?**

答：不是。Java中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean；除了基本类型（primitive type）和枚举类型（enumerationtype），剩下的都是引用类型（reference type）。

**4、float f=3.4;是否正确?(long l =3.4L)**

答:不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换floatf=(float)3.4;或者写成**float f=3.4F**;。

**5、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗?**

答：对于short s1 = 1; s1 = s1 + 1;由于1是int类型，因此s1+1运算结果也是int 型，需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译，因为s1 += 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。

**6、Java 有没有goto?保留字：goto,const**

答：goto 是Java中的保留字，在目前版本的Java中没有使用。（根据JamesGosling（Java之父）编写的《The Java Programming Language》一书的附录中给出了一个Java关键字列表，其中有goto和const，但是这两个是目前无法使用的关键字，因此有些地方将其称之为保留字，其实我个人并不认同这个说法，因为熟悉C语言的程序员都知道，在系统类库中使用过的那些单词才被称为保留字）

**7、int 和Integer 有什么区别?**

答：Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入不是对象的基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的封装类型（wrapperclass），int的封装类就是Integer，从JDK1.5开始引入了自动封箱/解封箱机制，使得二者可以相互转换。

Java 为每个原始类型提供了封装类：

原始类型: boolean，char，byte，short，int，long，float，double

封装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

**8、&和&&的区别？**

答：&运算符有两种用法：(1)按位与；(2)逻辑与。&&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是true整个表达式的值才是true。&&之所以称为短路运算是因为，如果&&左边的表达式的值是false，右边的表达式会被直接短路掉，不会进行运算。很多时候我们可能都需要用&&而不是&，例如在验证用户登录时判定用户名不是null而且不是空字符串，应当写为：username != null && !username.equals(“”)，二者的顺序不能交换，更不能用&运算符，因为第一个条件如果不成立，根本不能进行字符串的equals比较，否则会产生NullPointerException异常。注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。

**9、解释内存中的栈（stack）、堆(heap)和静态存储区(常量池)的用法。**

答：通常我们定义一个基本数据类型的变量，栈:一个对象的引用，还有就是函数调用的现场保存都使用内存中的栈空间；堆:而通过new关键字和构造器创建的对象放在堆空间；静态存储区:程序中的字面量（literal）如直接书写的100、“hello”和常量都是放在静态存储区中。栈空间操作最快但是也很小，通常大量的对象都是放在堆空间，整个内存包括硬盘上的虚拟内存都可以被当成堆空间来使用。

String str = new String(“hello”);

上面的语句中str放在栈上，用new创建出来的字符串对象放在堆上，而“hello”这个字面量放在静态存储区。

最新版本的JDK中使用了一项叫“逃逸分析“的技术，可以将一些局部对象放在栈上以提升对象的操作性能。

**10、Math.round(11.5) 等于多少? Math.round(-11.5)等于多少?**

答：Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加0.5然后进行下取整。

**11、swtich 是否能作用在byte 上，是否能作用在long 上，是否能作用在String上?**

答：早期的JDK中，switch（expr）中，expr可以是byte、short、char、int。从1.5版开始，Java中引入了枚举类型（enum），expr也可以是枚举，从1.7版开始，还可以是字符串（String）。长整型（long）是不可以的。

**12、用最有效率的方法计算2乘以8?**

答： 2 << 3（左移3位相当于乘以2的3次方）。2 << 33 <==> 2 << 1

**13、数组有没有length()方法? String 有没有length()方法？**

答：数组没有length()方法，有length 的属性。String 有length()方法。

**14、在Java 中，如何跳出当前的多重嵌套循环？**

答：带标签的break：在最外层循环前加一个标记如A，然后用breakA;可以跳出多重循环。（Java中支持带标签的break和continue语句，作用有些类似于C和C++中的goto语句，但是就像要避免使用goto一样，应该避免使用带标签的break和continue）

**15、构造器（constructor）是否可被重写（override）?**

答：构造器不能被继承，因此不能被重写，但可以被重载。

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

答：不对，如果两个对象x和y满足x.equals(y) == true，它们的哈希码（hash code）应当相同。Java对于eqauls方法和hashCode方法是这样规定的：(1)如果两个对象相同（equals方法返回true），那么它们的hashCode值一定要相同；(2)如果两个对象的hashCode相同，它们并不一定相同。当然，你未必要按照要求去做，但是如果你违背了上述原则就会发现在使用容器时，相同的对象可以出现在Set集合中，同时增加新元素的效率会大大下降（对于使用哈希存储的系统，如果哈希码频繁的冲突将会造成存取性能急剧下降）。比较两个对象的值和状态是否相同用equals,比较两个对象的内存地址是否相同用==

**17、是否可以继承String 类?**

答：String 类是final 类，不可以被继承。继承String本身就是一个错误的行为，对String类型的重用最好的重用方式是关联而不是继承。（合成聚合复用原则）

**18、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?**

答：是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变(可以使用final关键字锁定对象的内容)，但对象的引用是永远不会改变的。C++和C\#中可以通过传引用来改变传入的参数的值。

**19、String和StringBuilder、StringBuffer的区别?**

答：Java 平台提供了两种类型的字符串：String 和StringBuffer / StringBuilder，它们可以储存和操作字符串。其中String是只读字符串，也就意味着String引用的字符串内容是不能被改变的。而StringBuffer和StringBuilder类表示的字符串对象可以直接进行修改。StringBuilder是JDK1.5中引入的，它和StringBuffer的方法完全相同，区别在于它是在单线程环境下使用的，因为它的所有方面都没有被synchronized修饰，因此它的效率也比StringBuffer略高。

**20、重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分?**

答：方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求。

**21、描述一下JVM 加载class文件的原理机制?**

答：JVM 中类的装载是由类加载器（ClassLoader）和它的子类来实现的,Java中的类加载器是一个重要的Java运行时系统组件，它负责在运行时查找和装入类文件中的类。

补充：字节码（bytecode） java Hello àbyte\[\]

1. 由于Java的跨平台性，经过编译的Java源程序并不是一个可执行程序，而是一个或多个类文件。当Java程序需要使用某个类时:

JVM会确保这个类已经被加载、连接(验证、准备和解析)和初始化。

①　类的加载是指把类的.class文件中的数据读入到内存中，通常是创建一个字节数组读入.class文件，然后产生与所加载类对应的Class对象。

②　加载完成后，Class对象还不完整，所以此时的类还不可用。当类被加载后就进入连接阶段，这一阶段包括验证、准备(为静态变量分配内存并设置默认的初始值)和解析(将符号引用替换为直接引用)三个步骤。

③　最后JVM对类进行初始化，包括：1如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；2如果类中存在初始化语句，就依次执行这些初始化语句（给成员变量（属性）赋值的语句）。构造器调用的顺序:父类中静态的方法-->非静态的成员---->自身的方法

2. 类的加载是由类加载器完成的，类加载器包括：根加载器（BootStrap）、扩展加载器（Extension）、系统加载器（System）和用户自定义类加载器（java.lang.ClassLoader的子类）。从JDK1.2开始，类加载过程采取了父亲委托机制(PDM， Parent Delegation Machanism)。PDM更好的保证了Java平台的安全性，在该机制中，JVM自带的Bootstrap是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM不会向Java程序提供对Bootstrap的引用。下面是关于几个类加载器的说明：

a) Bootstrap：一般用本地代码实现，负责加载JVM基础核心类库（rt.jar）；

b) Extension：从java.ext.dirs系统属性所指定的目录中加载类库，它的父加载器是Bootstrap；

c) System：又叫应用类加载器，其父类是Extension。它是应用最广泛的类加载器。它从环境变量classpath或者系统属性java.class.path所指定的目录中记载类，是用户自定义加载器的默认父加载器。

d) BootStrap--->Extension--->System

**22、char 型变量中能不能存贮一个中文汉字?为什么?**

答：char类型可以存储一个中文汉字，因为Java中使用的编码是Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个char类型占2个字节（16bit），所以放一个中文是没问题的。

补充：使用Unicode意味着字符在JVM内部和外部有不同的表现形式，在JVM内部都是Unicode，当这个字符被从JVM内部转移到外部时（例如存入文件系统中），需要进行编码转换。所以Java中有字节流和字符流，以及在字符流和字节流之间进行转换的转换流，如InputStreamReader和OutputStreamWriter，这两个类是字节流和字符流之间的适配器类，承担了编码转换的任务。

**23、抽象类（abstract class）和接口（interface）有什么异同?**

①　抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。

②　一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。

③　接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法。

④　抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的。

⑤　抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。

⑥　有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。

**24、静态嵌套类(Static Nested Class)和内部类（Inner Class）的不同？**

答：Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。

**25、Java 中会存在内存泄漏吗，请简单描述。**

答：理论上Java因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是Java被广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被GC回收也会发生内存泄露。一个例子就是Hibernate的Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象。

**26、抽象的（abstract）方法是否可同时是静态的（static）,是否可同时是本地方法（native），是否可同时被synchronized修饰?**

答：都不能。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。本地方法是由本地代码（如C代码）实现的方法，而抽象方法是没有实现的，也是矛盾的。synchronized和方法的实现细节有关，抽象方法不涉及实现细节，因此也是相互矛盾的。

**27、静态变量和实例变量的区别？**

答：静态变量也称为类变量，属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个拷贝；实例变量必须依存于某一实例，需要先创建对象然后通过对象才能访问到它。

**28、是否可以从一个静态（static）方法内部发出对非静态（non-static）方法的调用？**

答：不可以，静态方法只能访问静态成员，因为非静态方法的调用要先创建对象，然后在调用静态方法时可能对象并没有被初始化。

**29、如何实现对象克隆？**

答：有两种方式：

1. 实现Cloneable接口并重写Object类中受保护的clone()方法；

2. 实现Serializable接口，通过对象的序列化和反序列化实现克隆。

**30、GC 是什么？为什么要有GC？**

答：GC是垃圾收集的意思，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。Java程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：System.gc() 或Runtime.getRuntime().gc() 。

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

补充：标准的Java进程既有栈又有堆。栈保存了原始型局部变量，堆保存了要创建的对象。Java平台对堆内存回收和再利用的基本算法被称为标记和清除，但是Java对其进行了改进，采用“分代式垃圾收集”。这种方法会跟Java对象的生命周期将堆内存划分为不同的区域，在垃圾收集过程中，可能会将对象移动到不同区域：

²  伊甸园（Eden）：这是对象最初诞生的区域，并且对大多数对象来说，这里是它们唯一存在过的区域。

²  幸存者乐园（Survivor）：从伊甸园幸存下来的对象会被挪到这里。

²  终身颐养园（Tenured）：这是足够老的幸存对象的归宿。年轻代收集（Minor-GC）过程是不会触及这个地方的。当年轻代收集不能把对象放进终身颐养园时，就会触发一次完全收集（Major-GC），这里可能还会牵扯到压缩，以便为大对象腾出足够的空间。

²  PermGen

与垃圾回收相关的JVM参数：

²  -Xms / -Xmx --- 堆的初始大小 / 堆的最大大小

²  -Xmn --- 堆中年轻代的大小

²  -XX:-DisableExplicitGC --- 让System.gc()不产生任何作用

²  -XX:+PrintGCDetail --- 打印GC的细节

²  -XX:+PrintGCDateStamps --- 打印GC操作的时间戳

**31、String s=new String(“xyz”);创建了几个字符串对象？**

答：两个对象，一个是静态存储区（常量池）的"xyx",一个是用new创建在堆上的对象。

**32、接口是否可继承（extends）接口? 抽象类是否可实现（implements）接口? 抽象类是否可继承具体类（concrete class）?**

答：接口可以继承接口。抽象类可以实现(implements)接口，抽象类可继承实体类，但前提是具体类必须有明确的构造函数。

**33、一个“.java”源文件中是否可以包含多个类（不是内部类）？有什么限制？**

答：可以，但一个源文件中最多只能有一个公开类而且文件名必须和公开类的类名完全保持一致。

**34、Anonymous Inner Class(匿名内部类)是否可以继承其它类？是否可以实现接口？**

答：可以继承其他类或实现其他接口，在swing编程中常用此方式。

**35、内部类可以引用他包含类的成员吗？有没有什么限制？**

答：一个内部类对象可以访问创建它的外部类对象的成员包括私有成员。

**36、Java 中的final关键字有哪些用法？**

答：(1)修饰类：表示该类不能被继承；(2)修饰方法：表示方法不能被重写；(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。

**37、指出下面程序的运行结果:**

class A\{

static\{

System.out.print("1");

public A()\{

System.out.print("2");

class B extends A\{

static\{

System.out.print("a");

public B()\{

System.out.print("b");

public class Hello\{

public static void main(String\[\] ars)\{

A ab = new B();

ab = new B();

答：执行结果：1a2b2b。创建对象时构造器的调用顺序是：先初始化静态成员，然后调用父类构造器，再初始化非静态成员，最后调用自身构造器。

**38、数据类型之间的转换:**

1) 如何将字符串转换为基本数据类型？

2) 如何将基本数据类型转换为字符串？

答：

1) 调用基本数据类型对应的包装类中的方法parseXXX(String)；

2) 一种方法是将基本数据类型与空字符串（””）连接（+）即可获得其所对应的字符串；另一种方法是调用String 类中的valueOf(…)方法返回相应字符串

**39、如何实现字符串的反转及替换？**

答：方法很多，可以自己写实现也可以使用String或StringBuffer / StringBuilder中的方法。

**40、怎样将GB2312编码的字符串转换为ISO-8859-1编码的字符串？**

答：代码如下所示:

String s1 = "你好";

String s2 = newString(s1.getBytes("GB2312"), "ISO-8859-1");

**41、日期和时间：**

1) 如何取得年月日、小时分钟秒？

2) 如何取得从1970年1月1日0时0分0秒到现在的毫秒数？

3) 如何取得某月的最后一天？

4) 如何格式化日期？

答：操作方法如下所示：

1) 创建java.util.Calendar实例，调用其get()方法传入不同的参数即可获得参数所对应的值

2) 以下方法均可获得该毫秒数:

Calendar.getInstance().getTimeInMillis();

System.currentTimeMillis();

3) 示例代码如下:

Calendartime = Calendar.getInstance();

time.getActualMaximum(Calendar.DAY\_OF\_MONTH);

4) 利用java.text.DataFormat的子类（如SimpleDateFormat类）中的format(Date)方法可将日期格式化。

**42、打印昨天的当前时刻。**

答：

public class YesterdayCurrent \{

public static void main(String\[\] args)\{

Calendar cal = Calendar.getInstance();

cal.add(Calendar.DATE, -1);

System.out.println(cal.getTime());

**43、比较一下Java 和JavaScript。**

答：JavaScript 与Java 是两个公司开发的不同的两个产品。Java 是原SUN 公司推出的面向对象的程序设计语言，特别适合于Internet应用程序开发；而JavaScript是原Netscape公司的产品，为了扩展Netscape浏览器的功能而开发的一种可以嵌入Web页面中运行的基于对象和事件驱动的解释性语言，它的前身是LiveScript；而Java 的前身是Oak语言。

下面对两种语言间的异同作如下比较：

1）基于对象和面向对象：Java 是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象；JavaScript 是种脚本语言，它可以用来制作与网络无关的，与用户交互作用的复杂软件。它是一种基于对象（Object-Based）和事件驱动（Event-Driven）的编程语言。因而它本身提供了非常丰富的内部对象供设计人员使用；

2）解释和编译：Java的源代码在执行之前，必须经过编译；JavaScript是一种解释性编程语言，其源代码不需经过编译，由浏览器解释执行；

3）强类型变量和类型弱变量：Java采用强类型变量检查，即所有变量在编译之前必须作声明；JavaScript中变量声明，采用其弱类型。即变量在使用前不需作声明，而是解释器在运行时检查其数据类型；

4）代码格式不一样。

补充：个人认为Java和JavaScript最重要的区别是一个是静态语言，一个是动态语言。目前的编程语言的发展趋势是函数式语言和动态语言。在Java中类（class）是一等公民，而JavaScript中函数（function）是一等公民。

**44、什么时候用assert？**

答：assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后， assertion检查通常是关闭的。在实现中，断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为true；如果表达式计算为false，那么系统会报告一个AssertionError。

断言用于调试目的：

assert(a > 0); // throws an AssertionError ifa <= 0

断言可以有两种形式：

assert Expression1;

assert Expression1 : Expression2 ;

Expression1 应该总是产生一个布尔值。

Expression2 可以是得出一个值的任意表达式；这个值用于生成显示更多调试信息的字符串消息。

断言在默认情况下是禁用的，要在编译时启用断言，需使用source 1.4 标记：

javac -source 1.4 Test.java

要在运行时启用断言，可使用-enableassertions 或者-ea 标记。

要在运行时选择禁用断言，可使用-da 或者-disableassertions 标记。

要在系统类中启用断言，可使用-esa 或者-dsa 标记。还可以在包的基础上启用或者禁用断言。可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

**45、Error 和Exception 有什么区别?**

答：Error 表示系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的一种严重问题；比如内存溢出，不可能指望程序能处理这样的情况；Exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况。

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

答：会执行，在return 前执行。

**47、Java 语言如何进行异常处理，关键字：throws、throw、try、catch、finally分别如何使用？**

答：Java 通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java 中，每个异常都是一个对象，它是Throwable类或其子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java 的异常处理是通过5 个关键词来实现的：try、catch、throw、throws 和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throw）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理；try用来指定一块预防所有“异常”的程序；catch子句紧跟在try块后面，用来指定你想要捕捉的“异常”的类型；throw 语句用来明确地抛出一个“异常”；throws用来标明一个成员函数可能抛出的各种“异常”；finally 为确保一段代码不管发生什么“异常”都被执行一段代码；可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try 语句，“异常”的框架就放到栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种“异常”进行处理，栈就会展开，直到遇到有处理这种“异常”的try 语句。

**48、运行时异常与受检异常有何异同？**

答：异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误，只要程序设计得没有问题通常就不会发生。受检异常跟程序运行的上下文环境有关，即使程序设计无误，仍然可能因使用的问题而引发。Java编译器要求方法必须声明抛出可能发生的受检异常，但是并不要求必须声明抛出未被捕获的运行时异常。

**49、列出一些你常见的运行时异常？**

答：

ArithmeticException

ClassCastException

IllegalArgumentException

IndexOutOfBoundsException

NullPointerException

SecurityException

**50、final, finally, finalize的区别?**

答：final：修饰符（关键字）有三种用法：如果一个类被声明为final，意味着它不能再派生出新的子类，即不能被继承，因此它和abstract是反义词。将变量声明为final，可以保证它们在使用中不被改变，被声明为final 的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改。被声明为final 的方法也同样只能使用，不能在子类中被重写。finally：通常放在try…catch的后面构造总是执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码只要JVM不关闭都能执行，可以将释放外部资源的代码写在finally块中。finalize：Object类中定义的方法，Java中允许使用finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的，通过重写finalize() 方法可以整理系统资源或者执行其他清理工作。

**51、类ExampleA 继承Exception，类ExampleB 继承ExampleA。**

有如下代码片断：

try\{

thrownew ExampleB(“b”)；

\}catch（ExampleA e）\{

System.out.printfln（“ExampleA”）；

\}catch（Exception e）\{

System.out.printfln（“Exception”）；

输出的内容应该是：

A．ExampleA B.Exception C.无输出

答：输出为A。（根据里氏代换原则\[能使用父类型的地方一定能使用子类型\]，抓取ExampleA类型异常的catch块能够抓住try块中抛出的ExampleB类型的异常）

**52、List、Set、Map 是否继承自Collection 接口？**

答：List、Set 是，Map 不是。Map是键值对映射容器，与List和Set有明显的区别，而Set存储的零散的元素且不允许有重复元素（数学中的集合也是如此），List是线性结构的容器，适用于按数值索引访问元素的情形。Collections定义一系列算法的工具类

**53、说出ArrayList、Vector、LinkedList 的存储性能和特性？**

答：ArrayList 和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList 使用双向链表实现存储（将内存中零散的内存单元通过附加的引用关联起来，形成一个可以按序号索引的线性结构，这种链式存储方式与数组的连续存储方式相比，其实对内存的利用率更高），按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。Vector属于遗留容器（早期的JDK中使用的容器，除此之外Hashtable、Dictionary、BitSet、Stack、Properties都是遗留容器），现在已经不推荐使用，但是由于ArrayList和LinkedListed都是非线程安全的，如果需要多个线程操作同一个容器，那么可以通过工具类Collections中的synchronizedList方法将其转换成线程安全的容器后再使用（这其实是装潢模式最好的例子，将已有对象传入另一个类的构造器中创建新的对象来增加新功能）。

**54、Collection 和Collections 的区别？**

答：Collection 是一个接口，它是Set、List等容器的父接口；Collections是个一个工具类，提供了一系列的静态方法来辅助容器操作，这些方法包括对容器的搜索、排序、线程安全化等等。

**55、List、Map、Set 三个接口，存取元素时，各有什么特点？**

答：List以特定索引来存取元素，可有重复元素。Set不能存放重复元素（用对象的equals()方法来区分元素是否重复）。Map保存键值对（key-value pair）映射，映射关系可以是一对一或多对一。Set和Map容器都有基于哈希码和排序树的两种实现版本，基于哈希码的版本存取时间复杂度为O(1)，而基于排序树版本的实现在插入或删除元素时会按照元素或元素的键（key）构成排序树从而达到排序和去重的效果。

** **

**56、TreeMap和TreeSet在排序时如何比较元素？Collections工具类中的sort()方法如何比较元素？**

答：TreeSet要求存放的对象所属的类必须实现Comparable接口，该接口提供了比较元素的compareTo()方法，当插入元素时会回调该方法比较元素的大小。TreeMap要求存放的键值对映射的键必须实现Comparable接口从而根据键对元素进行排序。Collections工具类的sort方法有两种重载的形式，第一种要求传入的待排序容器中存放的对象比较实现Comparable接口以实现元素的比较；第二种不强制性的要求容器中的元素必须可比较，但是要求传入第二个参数，参数是Comparator接口的子类型（需要重写compare方法实现元素的比较），相当于一个临时定义的排序规则。

**57、sleep()和wait()有什么区别?**

①　答：sleep()方法是线程类（Thread）的静态方法，导致此线程暂停执行指定时间，将执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复（线程回到就绪（ready）状态），以为调用sleep不会释放对象锁。

②　wait()是Object 类的方法，对此对象调用wait()方法导致本线程放弃对象锁(线程暂停执行)，进入等待此对象的等待锁定池，只有针对此对象发出notify 方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入就绪状态。

**58、sleep()和yield()有什么区别?**

答：

① sleep()方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会；yield()方法只会给相同优先级或更高优先级的线程以运行的机会；

② 线程执行sleep()方法后转入阻塞（blocked）状态，而执行yield()方法后转入就绪（ready）状态；

③ sleep()方法声明抛出InterruptedException，而yield()方法没有声明任何异常；

④ sleep()方法比yield()方法（跟操作系统相关）具有更好的可移植性。

**59、当一个线程进入一个对象的synchronized方法后，其它线程是否可进入此对象的其它方法？**

答：不能。其它线程只能访问该对象的非同步方法，同步方法则不能进入。

**60、请说出与线程调度相关的方法。**

答：

1) wait():使一个线程处于等待状态，并且释放所持有的对象的锁；

2)  sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常；

3) notify():唤醒一个处于等待状态的线程，当然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且与优先级无关；

4) notityAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争；

5) JDK 1.5通过Lock接口提供了显式(explicit)的锁机制，增强了灵活性以及对线程的协调。Lock接口中定义了加锁（lock()）和解锁(unlock())的方法，同时还提供了newCondition()方法来产生用于线程之间通信的Condition对象；

6) JDK 1.5还提供了信号量(semaphore)机制，信号量可以用来限制对某个共享资源进行访问的线程的数量。在对资源进行访问之前，线程必须从得到信号量的许可（调用Semaphore对象的acquire()方法）；在完成对资源的访问后，线程必须向信号量归还许可（调用Semaphore对象的release()方法）。

**61、编写多线程程序有几种实现方式？**

答：多线程有三种实现方法：一种是继承Thread类；第二种是实现Runnable接口。两种方式都要通过重写run()方法来定义线程的行为。第三种实现Callable 接口,可通过frute接受返回值

**62、synchronized关键字的用法？**

答：synchronized关键字可以将对象或者方法标记为同步，以实现对对象和方法的互斥访问，可以用synchronized(对象) \{ … \}定义同步代码块，或者在声明方法时将synchronized作为方法的修饰符。

**63、举例说明同步和异步。**

答：如果系统中存在临界资源（每次只允许一个线程访问的资源），例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就必须进行同步存取（数据库操作中的悲观锁就是最好的例子）。当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。事实上，所谓的同步就是指阻塞式操作，而异步就是非阻塞式操作。

**64、启动一个线程是用run()还是start()方法?**

答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM 调度并执行，这并不意味着线程就会立即运行。run()方法是线程启动后要进行回调（callback）的方法。

**65、什么是线程池（thread pool）？**

答：在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁，这就是"池化资源"技术产生的原因。线程池顾名思义就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。

Java中的Executor接口定义一个执行线程的工具。它的子类型即线程池接口是ExecutorService。要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，因此在工具类Executors面提供了一些静态工厂方法，生成一些常用的线程池，如下所示：

ü  newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

ü  newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

ü  newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

ü  newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

ü  newSingleThreadExecutor：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

**66、线程的基本状态以及状态之间的关系？**

答：

** **

**67、简述synchronized 和java.util.concurrent.locks.Lock的异同？**

答：主要相同点：Lock 能完成synchronized 所实现的所有功能；主要不同点：Lock 有比synchronized  更精确的线程语义和更好的性能。synchronized 会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally块中释放（这是释放外部资源的最好的地方）。

**68、Java中如何实现序列化（串行化），有什么意义？**

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

要实现序列化，需要让一个类实现Serializable接口，该接口是一个标识性接口(没有任何的方法，但继承了该接口就具备了一种能力)，标注该类对象是可被序列化的，然后使用一个输出流来构造一个对象输出流并通过writeObject(Object obj)方法就可以将实现对象写出(即保存其状态)；如果需要反序列化则可以用一个输入流建立对象输入流，然后通过readObject()方法从流中读取对象。

**69、Java 中有几种类型的流？**

答：字节流，字符流。字节流继承于InputStream、OutputStream，字符流继承于Reader、Writer。在java.io 包中还有许多其他的流，主要是为了提高性能和使用方便。

补充：关于Java的IO需要注意的有两点：一是两种对称性（输入和输出的对称性，字节和字符的对称性）；二是两种设计模式（适配器模式和装潢模式）。另外Java中的流不同于C\#的是它只有一个维度一个方向。

70、写一个方法，输入一个文件名和一个字符串，统计这个字符串在这个文件中出现的次数。

答：代码如下：

public int countWords(String file, String find)throws Exception

try(Reader in = new FileReader(file)) \{

int count = 0;//统计字符的变量

intc;//临时变量

while ((c = in.read()) != -1) \{

while (c == find.charAt(0)) \{

for (int i = 1; i < find.length(); i++) \{

c = in.read();

if (c != find.charAt(i)) break;

if (i == find.length() - 1) count++;

return count;

注意：这里用到了JDK 1.7的TWR（Try-With-Resources），这种写法让代码更加紧凑精炼。

**71、UML是什么？UML中有哪些图？**

答：UML是统一建模语言，它发表于1997年，综合了当时已经存在的面向对象的建模语言、方法和过程。UML包括了用例图（use case diagram）、类图（class diagram）、时序图（sequence diagram）、协作图（collaboration diagram）、状态图（statechart diagram）、活动图（activity diagram）、构件图（component diagram）、部署图（deployment diagram）等图形符号用来描述软件系统部分或全部的静态结构和动态结构。

**72、写一个单例类。**

答：单例模式主要作用是保证在Java应用程序中，一个类只有一个实例存在。下面给出两种不同形式的单例：

第一种形式：饿汉式单例

public class Singleton \{

private Singleton()\{\}

private static Singleton instance = new Singleton();

public static Singleton getInstance()\{

return instance;

第二种形式：懒汉式单例

public class Singleton \{

private static Singleton instance = null;

public static synchronizedSingleton getInstance()\{

if (instance==null)

instance＝new Singleton();

return instance;

第三种:静态内部类

**public class Singleton \{**

**    private static classSingletonHolder \{**

**      private static finalSingleton INSTANCE = new Singleton();**

**    \}**

**    private Singleton ()\{\}**

**    public static final SingletongetInstance() \{**

**      returnSingletonHolder.INSTANCE;**

**    \}**

**\}**

第四种:双重检锁

**public class Singleton \{**

**    private volatile staticSingleton singleton;**

**    private Singleton ()\{\}**

**    public static Singleton getSingleton()\{**

**      if (singleton == null) \{**

**          synchronized (Singleton.class) \{**

**            if (singleton == null) \{**

**                singleton = newSingleton();**

**            \}**

**          \}**

**      \}**

**      return singleton;**

**    \}**

**\}**

单例的特点：外界无法通过构造器来创建对象，该类必须提供一个静态方法向外界提供该类的唯一实例。

Spring中所涉及的设计模式:

应该说设计模式是我们在写代码时候的一种被承认的较好的模式。好的设计模式就像是给代码造了一个很好的骨架，在这个骨架里，你可以知道心在哪里，肺在哪里，因为大多数人都认识这样的骨架，就有了很好的传播性。这是从易读和易传播来感知设计模式的好处。当然设计模式本身更重要的是设计原则的一种实现，比如开闭原则，依赖倒置原则，这些是在代码的修改和扩展上说事。说到底就是人类和代码发生关系的四种场合：阅读，修改，增加，删除。让每一种场合都比较舒服的话，就需要用设计模式。

下面来简单列举Spring中的设计模式：

1. 简单工厂

又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。

Spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得Bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。

2. 工厂方法（FactoryMethod）

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

Spring中的FactoryBean就是典型的工厂方法模式。如下图：

3. 单例（Singleton）

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

Spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是因为Spring管理的是是任意的Java对象。

4. 适配器（Adapter）

将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

Spring中在对于AOP的处理中有Adapter模式的例子，见如下图：

由于Advisor链需要的是MethodInterceptor对象，所以每一个Advisor中的Advice都要适配成对应的MethodInterceptor对象。

5.包装器（Decorator）

动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

Spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。

6. 代理（Proxy）

为其他对象提供一种代理以控制对这个对象的访问。

从结构上来看和Decorator模式类似，但Proxy是控制，更像是一种对功能的限制，而Decorator是增加职责。

Spring的Proxy模式在aop中有体现，比如JdkDynamicAopProxy和Cglib2AopProxy。

7.观察者（Observer）

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

Spring中Observer模式常用的地方是listener的实现。如ApplicationListener。

8. 策略（Strategy）

定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

Spring中在实例化对象的时候用到Strategy模式，见如下图：

在SimpleInstantiationStrategy中有如下代码说明了策略模式的使用情况：

9.模板方法（TemplateMethod）

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

Template Method模式一般是需要继承的。这里想要探讨另一种对Template Method的理解。Spring中的JdbcTemplate，在用这个类时并不想去继承这个类，因为这个类的方法太多，但是我们还是想用到JdbcTemplate已有的稳定的、公用的数据库连接，那么我们怎么办呢？我们可以把变化的东西抽出来作为一个参数传入JdbcTemplate的方法中。但是变化的东西是一段代码，而且这段代码会用到JdbcTemplate中的变量。怎么办？那我们就用回调对象吧。在这个回调对象中定义一个操纵JdbcTemplate中变量的方法，我们去实现这个方法，就把变化的东西集中到这里了。然后我们再传入这个回调对象到JdbcTemplate，从而完成了调用。这可能是Template Method不需要继承的另一种实现方式吧。

以下是一个具体的例子：

JdbcTemplate中的execute方法：

JdbcTemplate执行execute方法：

**73、说说你所熟悉或听说过的设计模式以及你对设计模式的看法。**

### 答：在GoF的《[Design Patterns: Elements of Reusable Object-Oriented Software][Design Patterns_ Elements of Reusable Object-Oriented Software]》中给出了三类（创建型\[对类的实例化过程的抽象化\]、结构型\[描述如何将类或对象结合在一起形成更大的结构\]、行为型\[对在不同的对象之间划分责任和算法的抽象化\]）共23种设计模式（AbstractFactory（抽象工厂模式），Builder（建造者模式），Factory Method（工厂方法模式），Prototype（原始模型模式），Singleton（单例模式）；Facade（门面模式），Adapter（适配器模式），Bridge（桥梁模式），Composite（合成模式），Decorator（装饰模式），Flyweight（享元模式），Proxy（代理模式）；Command（命令模式），Interpreter（解释器模式），Visitor（访问者模式），Iterator（迭代子模式），Mediator（调停者模式），Memento（备忘录模式），Observer（观察者模式），State（状态模式），Strategy（策略模式），TemplateMethod（模板方法模式）， Chain Of Responsibleity（责任链模式））。 ###

所谓设计模式，就是一套被反复使用的代码设计经验的总结（情境中一个问题经过证实的一个解决方案）。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式使人们可以更加简单方便的复用成功的设计和体系结构。将已证实的技术表述成设计模式也会使新系统开发者更加容易理解其设计思路。

** **

**74、Java企业级开发中常用的设计模式有哪些？**

答： 按照分层开发的观点，可以将应用划分为：表示层、业务逻辑层和持久层，每一层都有属于自己类别的设计模式。

表示层设计模式：

1) Interceptor Filter：拦截过滤器，提供请求预处理和后处理的方案，可以对请求和响应进行过滤。

2)  Front Controller：通过中央控制器提供请求管理和处理，管理内容读取、安全性、视图管理和导航等功能。

3) View Helper：视图帮助器，负责将显示逻辑和业务逻辑分开。显示的部分放在视图组件中，业务逻辑代码放在帮助器中，典型的功能是内容读取、验证与适配。

4)  Composite View：复合视图

业务逻辑层设计模式：

1) Business Delegate：业务委托，减少表示层和业务逻辑层之间的耦合。

2) Value Object：值对象，解决层之间交换数据的开销问题。VO

3) Session Façade：会话门面，隐藏业务逻辑组件的细节，集中工作流程。

4) Value Object Assembler：灵活的组装不同的值对象VOA

5) Value List Handler：提供执行查询和处理结果的解决方案，还可以缓存查询结果，从而达到提升性能的目的。

6) Service Locator：服务定位器，可以查找、创建和定位服务工厂，封装其实现细节，减少复杂性，提供单个控制点，通过缓存提高性能。

持久层设计模式：

1) Data Access Object：数据访问对象，以面向对象的方式完成对数据的增删改查。

**75、你在开发中都用到了那些设计模式？用在什么场合？**

答：面试被问到关于设计模式的知识时，可以拣最常用的作答，例如：

1) 工厂模式：工厂类可以根据条件生成不同的子类实例，这些子类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作（多态方法）。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

2) 代理模式：给一个对象提供一个代理对象，并由代理对象控制原对象的引用。实际开发中，按照使用目的的不同，代理可以分为：远程代理、虚拟代理、保护代理、Cache代理、防火墙代理、同步化代理、智能引用代理。

3) 适配器模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起使用的类能够一起工作。

4) 模板方法模式：提供一个抽象类，将部分逻辑以具体方法或构造器的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法（多态实现），从而实现不同的业务逻辑。

**76、XML 文档定义有几种形式？它们之间有何本质区别？解析XML 文档有哪几种方式？**

答：XML文档定义分为DTD和Schema两种形式；其本质区别在于Schema本身也是一个XML文件，可以被XML解析器解析。对XML的解析主要有DOM（文档对象模型）、SAX、StAX（JDK1.6中引入的新的解析XML的方式，Streaming API for XML） 等，其中DOM处理大型文件时其性能下降的非常厉害，这个问题是由DOM 的树结构所造成的，这种结构占用的内存较多，而且DOM 必须在解析文件之前把整个文档装入内存,适合对XML 的随机访问（典型的用空间换取时间的策略）；SAX是事件驱动型的XML解析方式，它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML 的顺序访问；如其名称所暗示的那样，StAX把重点放在流上。实际上，StAX与其他方法的区别就在于应用程序能够把XML作为一个事件流来处理。将XML作为一组事件来处理的想法并不新颖（事实上 SAX 已经提出来了），但不同之处在于StAX允许应用程序代码把这些事件逐个拉出来，而不用提供在解析器方便时从解析器中接收事件的处理程序。

补充：自己的项目中需要解析XML，建议使用Dom4j

**77、你在项目中哪些地方用到了XML？**

答:XML的主要作用有两个方面：数据交换（曾经被称为业界数据交换的事实标准，现在此项功能在很多时候都被JSON取代）和信息配置。在做数据交换平台时，将数据用标签组装成XML文件，然后将XML文件压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再从XML文件中还原相关信息进行处理。目前很多软件都使用XML来存储器配置文件，项目开始时通常也会将作为配置的硬代码（hard code）写在XML文件中。

**78、在进行数据库编程时，连接池有什么作用？**

答：由于创建连接和释放连接都有很大的开销（尤其是数据库服务器不在本地时，每次建立连接都需要进行TCP的三次握手，再加上网络延迟，造成的开销是不可忽视的），为了提升系统访问数据库的性能，可以事先创建若干连接置于连接池中，需要时直接从连接池获取，使用结束时归还连接池，从而避免频繁创建和释放连接所造成的开销，这是典型的用空间换取时间的策略（浪费了空间存储连接，但节省了创建和释放连接的时间）。池化技术在Java开发中是很常见的，在使用线程时创建线程池的道理与此相同。

**79、什么是DAO模式？**

答：DAO（Data Access Object）顾名思义是一个为数据库或其他持久化机制提供了抽象接口的对象，在不暴露数据库实现细节的前提下提供了各种数据操作。为了建立一个健壮的Java EE应用，应该将所有对数据源的访问操作进行抽象化后封装在一个公共API中。用程序设计语言来说，就是建立一个接口，接口中定义了此应用程序中将会用到的所有事务方法。在这个应用程序中，当需要和数据源进行交互的时候则使用这个接口，并且编写一个单独的类来实现这个接口，在逻辑上该类对应一个特定的数据存储。

**80、什么是ORM？数据库访问技术有那些?**

答：对象关系映射（Object—Relational Mapping，简称ORM）是一种为了解决程序的面向对象模型与数据库的关系模型互不匹配问题的技术；简单的说，ORM 是通过使用描述对象和数据库之间映射的元数据，将Java程序中的对象自动持久化到关系数据库中，其本质上就是将数据从一种形式转换到另外一种形式。

ORM(Hibernate、JPA、JDO)

JDBC(SpringJdbc、MyBatis)

数据库访问技术的比较:

Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R Mapping实现了POJO 和数据库表之间的映射，以及SQL 的自动生成和执行。程序员往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握， Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。

MyBatis则在于POJO 与SQL之间的映射关系。然后通过映射配置文件，将SQL所需的参数，以及返回的结果字段映射到指定POJO。 相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mapping”的ORM实现。

JDBC自由度高、运行效率高,但是代码繁复,比如：完全依赖于数据配置产生的查询方案的综合查询系统

## Hibernate的调优方案 ##

1.  制定合理的缓存策略；
2.  尽量使用延迟加载特性；
3.  采用合理的Session管理机制；
4.  使用批量抓取，设定合理的批处理参数（batch\_size）;
5.  进行合理的O/R映射设计

MyBatis 在 Session 方面和 Hibernate 的 Session 生命周期是一致的，同样需要合理的 Session 管理机制。 MyBatis 同样具有二级缓存机制。  MyBatis 可以进行详细的 SQL 优化设计

具体选择那一种数据访问技术,需要根据特定的场景,在一般的应用场景中，可以采用多种数据访问技术，一般选择两种结合使用

**81、JDBC中如何进行事务处理？ **

答：Connection提供了事务处理的方法，通过调用setAutoCommit(false)可以设置手动提交事务；当事务完成后用commit()显式提交事务；如果在事务处理过程中发生异常则通过rollback()进行事务回滚。除此之外，较新的JDBC标准还引入了Savepoint（保存点）的概念，允许事务回滚到指定的保存点。

**82、  事务的ACID是指什么？**

答：

1) 原子性(Atomic)：事务中各项操作，要么全做要么全不做，任何一项操作的失败都会导致整个事务的失败；

2) 一致性(Consistent)：事务结束后系统状态是一致的；

3) 隔离性(Isolated)：并发执行的事务彼此无法看到对方的中间状态；

4) 持久性(Durable)：事务完成后所做的改动都会被持久化，即使发生灾难性的失败。通过日志和同步备份可以在故障发生后重建数据。

**83、Statement和PreparedStatement有什么区别？哪个性能更好？**

答： 与Statement相比，

1PreparedStatement接口代表预编译的语句，它主要的优势在于可以减少SQL的编译错误并增加SQL的安全性（减少SQL注射攻击的可能性）；

2PreparedStatement中的SQL语句是可以带参数的；

3当批量处理SQL时或频繁执行相同的查询时，PreparedStatement有明显的性能上的优势，由于数据库可以将编译优化后的SQL语句缓存起来，下次执行相同语句时就会很快。

补充：为了提供对存储过程的调用，JDBC API中还提供了CallableStatement接口。存储过程（Stored Procedure）是数据库系统中，一组为了完成特定功能的SQL语句的集合，经编译后存储在数据库中，用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。但是调用存储过程可能会影响数据库的移植，因为每种数据库的存储过程在书写上存在许多差别。

尽量在数据访问层使用类级别的静态变量定义SQL,不应在方法的内部声明SQL字符串变量,提高JVM的内存使用率

**84、使用JDBC操作数据库时，如何提升读取数据的性能？如何提升更新数据的性能？**

答：要提升读取数据的性能，可以指定通过结果集（ResultSet）对象指定每次抓取数据的大小（fetch size）；要提升更新数据的性能可以使用PreparedStatement语句构建批处理（batch）。

**85、JDBC能否处理Blob和Clob？**

答： Blob是指二进制大对象（Binary Large Object），而Clob是指大字符对象（Character Large Objec），因此其中Blob是为存储大的二进制数据而设计的，而Clob是为存储大的文本数据而设计的。JDBC的PreparedStatement和ResultSet都提供了相应的方法来支持Blob和Clob操作。

**86、Struts 2中，Action通过什么方式获得用户从页面输入的数据，又是通过什么方式把其自身的数据传给视图的？**

答：Action从页面获取数据有三种方式：

1)  通过Action属性接受参数

2) 通过域模型获取参数(贫血模型)

3) 通过模型驱动获取参数（ModelDriven<T>）

Action将数据存入值栈(Value Stack)中，视图可以通过表达式语言（EL）从值栈中获取数据。

**87、简述Struts 2是如何实现MVC架构模式的。**

答：MVC架构模式要求应用程序的输入、处理和输出三者分离，将系统分成模型（Model）、视图（View）、控制器（Controller）三个部分，通过控制器实现模型和视图的解耦合，使得应用程序的开发和维护变得容易，如下图所示。Web开发中的MVC架构模式有的地方也称为MVC2。

图 MVC架构模式图

其中，模型代表了应用程序的数据和处理这些数据的规则，同时还可以为视图提供的查询保存相关的状态，通常由JavaBean来实现，模型的代码写一次就可以被多个视图重用；视图用来组织模型的内容，它从模型中获得数据，并将数据展现给用户，在Struts 2中通常由JSP页面、Freemarker模板等来实现；控制器负责从客户端接受请求并将其转换为某种行为，行为完成后再选择一个视图来呈现给用户，控制器本身不需要输出任何内容，它只是接收请求并决定调用哪个模型组件去处理请求，StrutsPrepareAndExecuteFilter过滤器是Struts 2中的核心，它和一系列的Action构成了Struts 2中的控制器。

**88、阐述Struts 2如何实现用户输入验证。在你做过的项目中使用的是那种验证方式，为什么选择这种方式？**

答：Struts 2可以使用手动验证和自动验证框架实现用户输入验证。自动验证框架是将对输入的验证规则放在XML文件中，这种方式比较灵活，可以在不修改代码的情况下修改验证的规则。

**89、阐述Struts 2中的Action如何编写？Action是否采用了单例？**

答：Struts2的Action有三种写法：

1)  POJO

2)  实现Action接口重写execute()方法

3)  继承ActionSupport类

Action没有像Servlet一样使用单实例多线程的工作方式，很明显，每个Action要接收不同用户的请求参数，这就意味着Action是有状态的(多实例)，因此在设计上使用了每个请求对应一个Action的处理方式。

**90、Struts 2中的Action并没有直接收到用户的请求，那它为什么可以处理用户的请求，又凭什么知道一个请求到底交给哪个Action来处理？**

答：Struts2的核心过滤器接收到用户请求后，会对用户的请求进行简单的预处理(例如解析、封装参数)，然后通过反射来创建Action实例，并调用Action中指定的方法来处理用户请求。

要决定请求交给哪一个Action来处理有两种方式：1利用配置文件：可以在配置文件中通过<action>标签配置和请求对应的Action类以及要调用的方法；2利用约定：Struts2中可以使用约定(convention)插件，例如约定xxx总是对应XxxAction，这是对约定优于配置理念的践行。

**91、你经常用到的Struts 2常量配置有哪些？**

答：

1) struts.i18n.encoding– 指定默认编码

2) struts.objectFactory/ struts.objectFactory.spring.autoWire – 对象工厂 /Spring的自动装配方式(名字、类型)

3) struts.devMode– 是否使用开发模式

4) struts.locale– 指定默认区域，默认值是en\_US

5) struts.i18n.resources– 国际化使用的资源文件

6) struts.enable.DynamicMethodInvocation– 是否允许动态方法调用

**92、简述Struts2的异常处理机制。**

答：Struts 2提供了声明式的异常处理机制，可以在配置文件中加入如下代码：

<global-exception-mappings>

<exception-mapping exception=”…” result=”…”/>

</global-exception-mappings>

**93、说一下你对约定优于配置（CoC）的理解。**

答：约定优于配置(convention over configuration)，也称作按约定编程，是一种软件[设计范式][Link 1]，旨在减少[软件开发人员][Link 2]需做决定的数量。本质是说，开发人员仅需规定应用中不符约定的部分。例如，如果模型中有个名为Sale的类，那么数据库中对应的表就会默认命名为sales。只有在偏离这一约定时，例如将该表命名为products\_sold，才需写有关这个名字的配置。如果您所用工具的约定与你的期待相符，便可省去配置；反之，你可以配置来达到你所期待的方式。遵循约定虽然损失了一定的灵活性，不能随意安排目录结构，不能随意进行函数命名，但是却能减少配置。更重要的是，遵循约定可以帮助开发人员遵守构建标准，包括各种命名的规范。

**94、Struts2中如何实现I18N？**

答：首先，为不同语言地区编写不同的资源文件；然后在Struts2配置文件中配置struts.i18n.custom.resources常量；在Action中可以通过调用getText()方法读取资源文件获取国际化资源。

**95、简述拦截器的工作原理以及你在项目中使用过哪些自定义拦截器。**

答：Struts 2中定义了拦截器的接口以及默认实现，实现了Interceptor接口或继承了AbstractInterceptor的类可以作为拦截器。接口中的init()方法在拦截器被创建后立即被调用，它在拦截器的生命周期内只被调用一次，可以在该方法中对相关资源进行必要的初始化。每拦截一个请求，intercept()方法就会被调用一次。destory()方法将在拦截器被销毁之前被调用, 它在拦截器的生命周期内也只被调用一次。

项目中使用过的有权限拦截器、执行时间拦截器、令牌拦截器等。

**96、如何在Struts2中使用Ajax功能？**

答：以下是Struts2中实现Ajax的可选方式：

1) JSON plugin+ jQuery

2) DOJO plugin

3) DWR (DirectWeb Remoting)

**97、谈一下拦截器和过滤器的区别。**

答：拦截器和过滤器都可以用来实现横切关注功能，其区别主要在于：

1) 拦截器是基于Java反射机制的，而过滤器是基于接口回调的。

2) 过滤器依赖于Servlet容器，而拦截器不依赖于Servlet容器。

3) 拦截器只能对Action请求起作用，而过滤器可以对所有请求起作用。

4) 拦截器可以访问Action上下文、值栈里的对象，而过滤器不能。

** **

**98、谈一下Struts 1和Struts 2的区别。**

答：

<table> 
 <tbody> 
 <tr> 
 <td> 不同点 </td> 
 <td> Struts 1 </td> 
 <td> Struts 2 </td> 
 </tr> 
 <tr> 
 <td> Action 类 </td> 
 <td> 要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。 </td> 
 <td> Action类可以实现一个Action接口，也可实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport类去作为Action的父类，但不是必须的，任何有execute方法的POJO对象都可以用作Struts 2的Action对象。 </td> 
 </tr> 
 <tr> 
 <td> 线程模式 </td> 
 <td> Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。 </td> 
 <td> Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，Servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题） </td> 
 </tr> 
 <tr> 
 <td> Servlet依赖 </td> 
 <td> Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和HttpServletResponse 被传递给execute方法。 </td> 
 <td> Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。 </td> 
 </tr> 
 <tr> 
 <td> 可测性 </td> 
 <td> Action的一个主要问题是execute方法暴露了servlet API（这使得测试要依赖于容器）。 </td> 
 <td> Action可以通过初始化、设置属性、调用方法来测试，“依赖注入”支持也使测试更容易。 </td> 
 </tr> 
 <tr> 
 <td> 捕获输入 </td> 
 <td> 使用ActionForm对象捕获输入。所有的ActionForm必须继承一个基类。因为其他JavaBean不能用作ActionForm，开发者经常创建多余的类捕获输入。 </td> 
 <td> Struts2可以通过Action的属性、域模型或模型驱动等方式实现输入捕获，而且还自带了默认的类型转换机制。 </td> 
 </tr> 
 <tr> 
 <td> 表达式语言 </td> 
 <td> 整合了JSTL，因此使用JSTL EL。这种EL有基本对象图遍历，但是对集合和索引属性的支持较弱。 </td> 
 <td> 可以使用JSTL，但是也支持一个更强大和灵活的表达式语言 – OGNL（坦白的说这是一个很垃圾又没有效率的表达式语言，前不久曝出的Struts 2高危漏洞就是由OGNL引起的） </td> 
 </tr> 
 <tr> 
 <td> 类型转换 </td> 
 <td> ActionForm 属性通常都是String类型。Struts1使用Commons-Beanutils进行类型转换。每个类一个转换器，对每一个实例来说是不可配置的。 </td> 
 <td> 使用OGNL进行类型转换。提供基本和常用对象的转换器。 </td> 
 </tr> 
 </tbody> 
</table>

** **

**99、谈一下你的项目选择Struts 2的理由**

答：

1.Action是POJO，没有依赖ServletAPI，具有良好的可测试性；

2.强大的拦截器简化了开发的复杂度；

3.支持多种表现层技术：JSP、Freemarker等等；

4.灵活的验证方式；

5.国际化(I18N)支持；

6.声明式异常管理；

7.通过JSON插件简化Ajax；

8.通过Spring插件跟Spring整合。

补充：有人为选择和评判Web框架提出了20条标准，包括：开发人员的工作效率（能用1-5天搭建一个CRUD页面吗）、开发人员的看法（用起来有意思吗）、学习曲线（学了一个星期或一个月后能干活吗）、项目健康状况（项目陷入绝境了吗）、开发人员的充足性（能找到经验丰富的开发人员吗）、就业趋势（将来能招到人吗）、模板化（遵循DRY（Don’t Repeat Yourself）原则吗）、组件（自带日期选择器之类的控件吗）、Ajax（是否支持异步调用和局部刷新）、插件或附加项（能加入Facebook集成之类的功能吗）、扩展性（默认的控制处理的并发用户数能到500+吗）、测试支持（能够做测试驱动的开发吗）、I18N和L10N（有多国语言、地域支持吗）、校验（能轻松校验用户输入并迅速反馈吗）、多编程语言支持（能够同时使用多种语言开发吗）、文档的质量（常见的用例和问题都在文档中有体现吗）、出版的图书（有没有行业专家使用了它并分享了自己的使用经验）、REST支持（能按HTTP协议的设计宗旨使用该协议吗）、移动支持（是否很容易就能支持Android、iOS和其他移动智能终端）、风险程度（能不能做大型项目）。很明显，Java其实算不上最优化的Web开发语言，但是它却满足了这20条中的很多，尤其是充足的开发人员、成熟的解决方案这两点。

**100、Struts 2中如何访问HttpServletRequest、HttpSession和ServletContext三个域对象**

答：有两种方式：

1) 通过ServletActionContext的方法获得；

2) 通过ServletRequestAware、SessionAware和ServletContextAware接口注入。

** **

**101、Struts 2中的默认包struts-default有什么作用？**

答：它定义了Struts 2内部的众多拦截器和Result类型，而Struts 2很多核心的功能都是通过这些内置的拦截器实现，如：从请求中把请求参数封装到action、文件上传和数据验证等等都是通过拦截器实现的。在Struts 2的配置文件中，自定义的包继承了struts-default包就可以使用Struts 2为我们提供的这些功能。

** **

**102、简述值栈(Value-Stack)的原理和生命周期**

答：Value-Stack贯穿整个 Action 的生命周期，保存在request作用域中，所以它和request的生命周期一样。当Struts 2接受一个请求时，会创建ActionContext、Value-Stack和Action对象，然后把Action存放进Value-Stack，所以Action的实例变量可以通过OGNL访问。由于Action是多实例的，和使用单例的Servlet不同，每个Action都有一个对应的Value-Stack，Value-Stack存放的数据类型是该Action的实例，以及该Action中的实例变量，Action对象默认保存在栈顶。

**103、SessionFactory是线程安全的吗？Session是线程安全的吗，两个线程能够共享同一个Session吗？**

答：SessionFactory对应Hibernate的一个数据存储的概念，它是线程安全的，可以被多个线程并发访问。SessionFactory一般只会在启动的时候构建。对于应用程序，最好将SessionFactory通过单例的模式进行封装以便于访问。Session是一个轻量级非线程安全的对象（线程间不能共享session），它表示与数据库进行交互的一个工作单元。Session是由SessionFactory创建的，在任务完成之后它会被关闭。Session是持久层服务对外提供的主要接口。Session会延迟获取数据库连接（也就是在需要的时候才会获取）。为了避免创建太多的session，可以使用ThreadLocal来取得当前的session，无论你调用多少次getCurrentSession()方法，返回的都是同一个session。

**104、Session的load和get方法的区别是什么？**

答：主要有以下三项区别：

1)  如果没有找到符合条件的记录,get方法返回null, load方法抛出异常

2)  get方法直接返回实体类对象, load方法返回实体类对象的代理(虚拟代理)

3)  get方法只在一级缓存(内部缓存)中进行数据查找,如果没有找到对应的数据则越过二级缓存, 直接发出SQL语句完成数据读取;load方法则可以充分利用二级缓存中的现有数据

简单的说，对于load()方法Hibernate认为该数据在数据库中一定存在可以放心的使用代理来实现延迟加载，如果没有数据就抛出异常，而通过get()方法去取的数据可以不存在。

**105、Session的save()、update()、merge()、lock()、saveOrUpdate()和persist()方法有什么区别？**

答：Hibernate的对象有三种状态：瞬态、持久态和游离态。游离状态的实例可以通过调用save()、persist()或者saveOrUpdate()方法进行持久化；脱管状态的实例可以通过调用 update()、saveOrUpdate()、lock()或者replicate()进行持久化。save()和persist()将会引发SQL的INSERT语句，而update()或merge()会引发UPDATE语句。save()和update()的区别在于一个是将瞬态对象变成持久态，一个是将游离态对象变为持久态。merge方法可以完成save()和update()方法的功能，它的意图是将新的状态合并到已有的持久化对象上或创建新的持久化对象。按照官方文档的说明：(1)persist()方法把一个瞬态的实例持久化，但是并"不保证"标识符被立刻填入到持久化实例中，标识符的填入可能被推迟到flush的时间；(2) persist"保证"，当它在一个事务外部被调用的时候并不触发一个Insert语句，当需要封装一个长会话流程的时候，一个persist这样的函数是需要的。(3)save"不保证"第2条,它要返回标识符，所以它会立即执行Insert语句，不管是不是在事务内部还是外部。update()方法是把一个已经更改过的脱管状态的对象变成持久状态；lock()方法是把一个没有更改过的脱管状态的对象变成持久状态。

**106、阐述Session加载实体对象的过程。**

答：Session加载实体对象的步骤是：

1)  Session在调用数据库查询功能之前,首先会在缓存中进行查询, 在一级缓存中, 通过实体类型和主键进行查找, 如果一级缓存查找命中且数据状态合法, 则直接返回

2)  如果一级缓存没有命中,接下来Session会在当前NonExists记录(相当于一个查询黑名单, 如果出现重复的无效查询可以迅速判断, 从而提升性能)中进行查找, 如果NonExists中存在同样的查询条件,则返回null

3)  对于load方法, 如果一级缓存查询失败则查询二级缓存, 如果二级缓存命中则直接返回

4)  如果之前的查询都未命中,则发出SQL语句, 如果查询未发现对应记录则将此次查询添加到Session的NonExists中加以记录, 并返回null

5) 根据映射配置和SQL语句得到ResultSet,并创建对应的实体对象

6)  将对象纳入Session(一级缓存)管理

7)  执行拦截器的onLoad方法(如果有对应的拦截器)

8)  将数据对象纳入二级缓存

9)  返回数据对象

**107、 Query接口的list方法和iterate方法有什么区别？**

答：Iterate迭代器 (时间换空间)

1) list方法无法利用缓存,它对缓存只写不读; iterate方法可以充分利用缓存,如果目标数据只读或者读取频繁, iterate可以减少内存性能开销

2)  list方法不会引起N+1查询问题,而iterate方法会引起N+1查询问题

**108、Hibernate如何实现分页查询？**

答：通过Hibernate实现分页查询，开发人员只需要提供HQL语句、查询起始行数(setFirstresult()方法)和最大查询行数(setMaxResult()方法)，并调用Query接口的list()方法，Hibernate会自动生成分页查询的SQL语句。

**109、锁机制有什么用？简述Hibernate的悲观锁和乐观锁机制。**

答：有些业务逻辑在执行过程中往往需要保证数据访问的排他性，于是需要通过一些机制保证在此过程中数据被锁住不会被外界修改，这就是所谓的锁机制。

Hibernate支持悲观锁和乐观锁两种锁机制。悲观锁，顾名思义，它悲观的认为在数据处理过程中一定存在修改数据的并发事务(包括本系统的其他事务或来自外部系统的事务)，于是将处理的数据设置为锁定状态。悲观锁必须依赖数据库本身的锁机制才能真正保证数据访问的排他性。乐观锁，顾名思义，对并发事务持乐观态度(认为对数据的并发操作很少发生)，通过更加宽松的锁机制解决悲观锁排他的数据访问对系统性能造成的严重影响。最常见的乐观锁是通过数据版本标识来实现的，读取数据时获得数据的版本号，更新数据时将此版本号加1，然后和数据库表对应记录的当前版本号进行比较，如果提交的数据版本号大于数据库中此记录的当前版本号则更新数据，否则认为是过期数据。

**110、阐述实体对象的三种状态以及转换关系。**

答：Hibernate中对象有三种状态：临时态（transient）、持久态（persistent）和游状态（detached），如下图所示。

图 Hibernate实体状态转换图

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

ü 持久状态：持久化对象的实例在数据库中有对应的记录，并拥有一个持久化标识。对持久化对象进行delete操作后，数据库中对应的记录将被删除，那么持久化对象与数据库记录不再存在对应关系，持久化对象变成临时状态。持久化对象被修改变更后，不会马上同步到数据库，直到数据库事务提交。

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

**111、如何理解Hibernate的延迟加载机制。在实际应用中，延迟加载与session关闭的矛盾是如何处理的？**

答：延迟加载就是并不是在读取的时候就把数据加载进来，而是等到使用时再加载。Hibernate使用了虚拟代理机制实现延迟加载。返回给用户的并不是实体本身，而是实体对象的代理。代理对象在用户调用getter方法时就会去数据库加载数据。但加载数据就需要数据库连接。而当我们把会话关闭时，数据库连接就同时关闭了。

延迟加载与session关闭的矛盾一般可以这样处理：

1) 关闭延迟加载特性。这种方式操作起来比较简单，因为hibernate的延迟加载特性是可以通过映射文件或者注解进行配置的，但这种解决方案存在明显的缺陷。首先，出现no session or session was closed就证明了系统中已经存在主外键关联，如果去掉延迟加载的话，则每次查询的开销都会变得很大。

2) 在session关闭之前先获取需要查询的数据(Hibernate.initialize()方法)。

3) 使用拦截器(Interceptor)或过滤器(Filter)控制Session。

**112、举一个多对多关联的例子，并说明如何实现多对多关联映射。**

答：例如：商品和订单、学生和课程都是典型的多对多关系。可以在实体类上通过@ManyToMany注解配置多对多关联或者通过映射文件中的<set>和<many-to-many>标签配置多对多关联，但是通常情况下，可以将多对多关联转换成两个多对一关联来实现多对多关联映射。

**113、谈一下你对继承映射的理解。**

答：继承关系的映射策略有三种：

1)  每个继承结构一张表(tableper class hierarchy)

2)  每个子类一张表(tableper subclass)

3)  每个具体类一张表(tableper concrete class)

第一种方式属于单表策略，其优点在于查询子类对象的时候无需表连接，查询速度快，适合多态查询；缺点是可能导致表很大。后两种方式属于多表策略，其优点在于数据存储紧凑，其缺点是需要进行连接查询，不适合多态查询。

**114、简述Hibernate常见优化策略。**

答：

1)  制定合理的缓存策略

2)  采用合理的Session管理机制

3)  尽量使用延迟加载特性

4)  设定合理的批处理参数

5)  如果可以, 选用UUID作为主键生成器

6)  如果可以, 选用基于version的乐观锁替代悲观锁

7)  在开发过程中, 开启hibernate.show\_sql选项查看生成的SQL, 从而了解底层的状况;开发完成后关闭此选项

8)  数据库本身的优化(合理的索引, 缓存, 数据分区策略等)也会对持久层的性能带来可观的提升, 这些需要专业的DBA提供支持

**115、谈一谈Hibernate的一级缓存、二级缓存和查询缓存。**

答：Hibernate的Session提供了一级缓存的功能，默认总是有效的，当应用程序保存持久化实体、修改持久化实体时，Session并不会立即把这种改变提交到数据库，而是缓存在当前的Session中，除非显示调用了Session的flush()方法或通过close()方法关闭Session。通过一级缓存，可以减少程序与数据库的交互，从而提高数据库访问性能。

SessionFactory级别的二级缓存是全局性的，所有的Session可以共享这个二级缓存。不过二级缓存默认是关闭的，需要显示开启并指定需要使用哪种二级缓存实现类(可以使用第三方提供的实现)。一旦开启了二级缓存并设置了需要使用二级缓存的实体类，SessionFactory就会缓存访问过的该实体类的每个对象，除非缓存的数据超出了指定的缓存空间。

一级缓存和二级缓存都是对整个实体进行缓存，不会缓存普通属性，如果希望对普通属性进行缓存，可以使用查询缓存。查询缓存是将HQL或SQL语句以及它们的查询结果作为键值对进行缓存，对于同样的查询可以直接从缓存中获取数据。查询缓存默认也是关闭的，需要显示开启。

**116、说出Servlet的生命周期，并说出Servlet和CGI的区别?**

答：Web容器加载Servlet并将其实例化后，Servlet生命周期开始，容器运行其init()方法进行Servlet的初始化，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet、doPost等），当服务器决定将实例销毁的时候调用其destroy方法。Servlet与CGI的区别在于Servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于Servlet。

补充：目前使用的Fast CGI已经解决了CGI效率上的问题，所以面试的时候大可不必诟病CGI，腾讯的网站就使用了CGI技术，也没感觉它哪里不好。

**117、转发（forward）和重定向（redirect）的区别?**

答：forward是容器中控制权的转向，是服务器请求资源，服务器直接访问目标地址的URL，把那个URL 的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。redirect就是服务器端根据逻辑，发送一个状态码，告诉浏览器重新去请求那个地址，因此从浏览器的地址栏中可以看到跳转后的链接地址。前者更加高效，在前者可以满足需要时，尽量使用forward()方法，并且，这样也有助于隐藏实际的链接；在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用sendRedirect()方法。(定义、访问的方式)

**118、JSP有哪些内置对象？作用分别是什么？**

答：JSP有9个内置对象：

request：封装客户端的请求，其中包含来自GET或POST请求的参数；HttpServletRequest

response：封装服务器对客户端的响应；HttpServletResponse

pageContext：通过该对象可以获取其他对象；PageContext

session：封装用户会话的对象；HttpSession

application：封装服务器运行环境的对象；ServletContext

out：输出服务器响应的输出流对象；JspWriter–> Writer(字符流)

config：Web应用的配置对象；ServletConfig

page：JSP页面本身（相当于Java程序中的this）；Object

exception：封装页面抛出异常的对象。Exception

**119、get和post请求的区别？**

答：

1) get请求用来从服务器上获得资源，而post是用来向服务器提交数据；

2) get将表单中数据按照name=value的形式，添加到action所指向的URL后面，并且两者使用“?”连接，而各个变量之间使用“&”连接；post是将表单中的数据放在HTML头部（header），传递到action所指向URL；

3)  get传输的数据要受到URL长度限制（1024字节）；而post可以传输大量的数据，上传文件只能使用post方式；

4)  使用get时参数会显示在地址栏上，如果这些数据不是敏感数据，那么可以使用get；对于敏感数据还是应用使用post；

5) get使用MIME类型application/x-www-form-urlencoded的URL 编码（URLencoding，也叫百分号编码）文本的格式传递参数，保证被传送的参数由遵循规范的文本组成，例如一个空格的编码是"%20"。

**120、常用的Web容器**

答：Unix和Linux平台下使用最广泛的免费HTTP服务器是Apache服务器，而Windows平台的服务器通常使用IIS作为Web服务器。选择Web服务器应考虑的因素有：性能、安全性、日志和统计、[虚拟主机][Link 3]、[代理服务器][Link 4]、缓冲服务和集成[应用程序][Link 5]等。下面是对常用服务器的简介：

IIS：Microsoft的Web服务器产品为Internet Information Services。IIS 是允许在公共Intranet或Internet上发布信息的Web服务器。IIS是目前最流行的Web服务器产品之一，很多著名的网站都是建立在IIS的平台上。IIS提供了一个图形界面的[管理工具][Link 6]，称为[Internet服务][Internet]管理器，可用于监视配置和控制Internet服务。IIS是一种Web服务组件，其中包括Web服务器、[FTP服务器][FTP]、NNTP服务器和SMTP服务器，分别用于网页浏览、[文件传输][Link 7]、新闻服务和邮件发送等方面，它使得在网络（包括互联网和局域网）上发布信息成了一件很容易的事。它提供ISAPI(Intranet Server API）作为扩展Web服务器功能的[编程接口][Link 8]；同时，它还提供一个Internet数据库连接器，可以实现对数据库的查询和更新。

Kangle：Kangle [Web服务器][Web]是一款跨平台、功能强大、安全稳定、易操作的高性能[Web服务器][Web]和[反向代理][Link 9][服务器软件][Link 10]。此外，Kangle也是一款专为做[虚拟主机][Link 3]研发的[Web服务器][Web]。实现[虚拟主机][Link 3]独立进程、独立身份运行。用户之间安全隔离，一个用户出问题不影响其他用户。支持PHP、ASP、ASP.NET、Java、Ruby等多种动态开发语言。

WebSphere：WebSphere Application Server是功能完善、开放的Web[应用程序][Link 5]服务器，是IBM电子商务计划的核心部分，它是基于Java的应用环境，用于建立、部署和管理Internet和Intranet Web应用程序，适应各种Web[应用程序][Link 5]服务器的需要，范围从简单到高级直到企业级。

WebLogic：BEA WebLogic Server是一种多功能、基于标准的Web[应用服务器][Link 11]，为企业构建自己的应用提供了坚实的基础。各种应用开发、部署所有关键性的任务，无论是集成各种系统和数据库，还是提交服务、跨Internet协作，Weblogic都提供了相应的支持。由于它具有全面的功能、对开放标准的遵从性、多层架构、支持基于组件的开发，基于Internet的企业都选择它来开发、部署最佳的应用。BEA WebLogic Server在使[应用服务器][Link 11]成为企业应用架构的基础方面一直处于领先地位，为构建[集成化][Link 12]的企业级应用提供了稳固的基础，它们以 Internet的容量和速度，在连网的企业之间共享信息、提交服务，实现协作自动化。

Apache：目前[Apache][]仍然是世界上用得最多的Web服务器，市场占有率约为60%左右。世界上很多著名的网站都是Apache的产物，它的成功之处主要在于它的[源代码][Link 13]开放、有一支强大的开发团队、支持跨平台的应用（可以运行在几乎所有的[Unix][]、Windows、[Linux][]系统平台上）以及它的可移植性等方面。

Tomcat：Tomcat是一个开放[源代码][Link 13]、运行Servlet和JSP的容器。Tomcat Server实现了Servlet和JSP规范。此外，Tomcat还实现了Apache-Jakarta规范而且比绝大多数商业[应用软件][Link 14]服务器要好，因此目前也有不少的Web服务器都选择了Tomcat。

补充：JBoss（Servlet、EJB、Ngix）

**121、JSP 和Servlet有什么关系？**

答：Servlet是一个特殊的Java程序，它运行于服务器的JVM中，能够依靠服务器的支持向浏览器提供显示内容。JSP本质上是Servlet的一种简易形式， JSP会被服务器处理成一个类似于Servlet的Java程序，可以简化页面内容的生成。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java 文件中，并且完全从表示层中的HTML分离开来。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp 的文件（有人说，Servlet就是在Java中写HTML，而JSP就是在HTML中写Java代码，当然，这个说法还是很片面的）。JSP侧重于视图，Servlet更侧重于控制逻辑，在MVC架构模式中，JSP适合充当视图（view）而Servlet适合充当控制器（controller）。

**122、JSP中的四种作用范围？**

答：page、request、session和application，具体如下：

1) page 代表与一个页面相关的对象和属性；

2) request 代表与Web客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个Web 组件；

3) session代表与某个用户与服务器建立的一次会话相关的对象和属性；

4) application代表与整个Web应用程序相关的对象和属性，它实质上是跨越整个Web应用程序，包括多个页面、请求和会话的一个全局作用域。

**123、如何实现JSP或Servlet的单线程模式？**

答：<%@pageisThreadSafe=”false”%>

补充：Servlet默认的工作模式是单实例多线程，如果Servlet实现了标识接口SingleThreadModel又或是JSP页面通过page指令设置isThreadSafe属性为false，那么它们生成的Java代码会以单线程多实例方式工作。显然，这样做会导致每个请求创建一个Servlet实例，这种实践将导致严重的性能问题。

**124、实现用户跟踪的技术有哪些？**

答：由于HTTP协议本身是无状态的，服务器为了区分不同的用户，就需要对用户会话进行跟踪，简单的说就是为用户进行登记，为用户分配唯一的ID，下一次用户在请求中包含此ID，服务器据此判断到底是哪一个用户。

cookie：cookie有两种，一种是基于窗口的，浏览器窗口关闭后，cookie就没有了；另一种是将信息存储在一个临时文件中，并设置存在的时间。当用户通过浏览器和服务器建立一次会话后，会话ID就会随响应信息返回存储在基于窗口的cookie中，那就意味着只要浏览器没有关闭，会话没有超时，下一次请求时这个会话ID又会提交给服务器让服务器识别用户身份。会话中可以为用户保存信息。会话对象是在服务器内存中的，而基于窗口的cookie是在客户端内存中的。如果浏览器禁用了cookie，那么就需要通过下面两种方式进行会话跟踪。当然，在使用cookie时要注意几点：首先不要在cookie中存放敏感信息；其次cookie存储的数据量有限（4k），不能将过多的内容存储cookie中。

URL 重写：将唯一的会话ID添加到URL结尾以标识一个会话。

设置表单隐藏域：将和会话跟踪相关的字段添加到隐式表单域中，这些信息不会在浏览器中显示但是提交表单时会提交给服务器。

<input type=”text” name= “jsessionid” value=”<%session.getId()%>”

**126、过滤器有哪些作用和用法？**

答：Java Web开发中的过滤器（filter）是从Servlet2.3规范开始增加的功能，并在Servlet 2.4规范中得到增强。对Web应用来说，过滤器是一个驻留在服务器端的Web组件，它可以截取客户端和服务器之间的请求与响应信息，并对这些信息进行过滤。当Web容器接受到一个对资源的请求时，它将判断是否有过滤器与这个资源相关联。如果有，那么容器将把请求交给过滤器进行处理。在过滤器中，你可以改变请求的内容，或者重新设置请求的报头信息，然后再将请求发送给目标资源。当目标资源对请求作出响应时候，容器同样会将响应先转发给过滤器，再过滤器中，你可以对响应的内容进行转换，然后再将响应发送到客户端。

常见的过滤器用途主要包括：对用户请求进行统一认证、对用户的访问请求进行记录和审核、对用户发送的数据进行过滤或替换、转换图象格式、对响应内容进行压缩以减少传输量、对请求或响应进行加解密处理、触发资源访问事件、对XML的输出应用XSLT等。

和过滤器相关的接口主要有：Filter、FilterConfig、FilterChain

下面是编码过滤器的例子：

package com.accp.filter;

import java.io.IOException;

import javax.servlet.Filter;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

public class CodingFilter implements Filter \{

privateString defaultEncoding = "utf-8";

@Override

publicvoid destroy() \{

@Override

publicvoid doFilter(ServletRequest req, ServletResponse resp,

FilterChainchain) throws IOException, ServletException \{

req.setCharacterEncoding(defaultEncoding);

resp.setCharacterEncoding(defaultEncoding);

chain.doFilter(req, resp);

@Override

publicvoid init(FilterConfig config) throws ServletException \{

String encoding =config.getInitParameter("encoding");

if(encoding != null) \{

defaultEncoding= encoding;

**127、监听器有哪些作用和用法？**

答：Java Web开发中的监听器（listener）就是application、session、request三个对象创建、销毁或者往其中添加修改删除属性时自动执行代码的功能组件，如下所示：

1) ServletContextListener：对Servlet上下文的创建和销毁进行监听。

2) ServletContextAttributeListener：监听Servlet上下文属性的添加、删除和替换。

3) HttpSessionListener：对Session的创建和销毁进行监听。

补充：session的销毁有两种情况：1session超时（可以在web.xml中通过<session-config>/<session-timeout>标签配置超时时间）；2通过调用session对象的invalidate()方法使session失效。

4) HttpSessionAttributeListener：对Session对象中属性的添加、删除和替换进行监听。

5) ServletRequestListener：对请求对象的初始化和销毁进行监听。

6) ServletRequestAttributeListener：对请求对象属性的添加、删除和替换进行监听。

下面是一个统计网站最多在线人数及时间的监听器：

package com.jackfrued.listener;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import java.util.Date;

import javax.servlet.ServletContext;

import javax.servlet.http.HttpSessionEvent;

import javax.servlet.http.HttpSessionListener;

public class MaxCountListener implementsHttpSessionListener \{

@Override

publicvoid sessionCreated(HttpSessionEvent event) \{

ServletContext app =event.getSession().getServletContext();

int count =Integer.parseInt(app.getAttribute("onLineCount").toString());

count++;

app.setAttribute("onLineCount",count);

int maxOnLineCount =Integer.parseInt(app.getAttribute("maxOnLineCount").toString());

if (count > maxOnLineCount) \{

app.setAttribute("maxOnLineCount",count);

DateFormatdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

app.setAttribute("date",df.format(new Date()));

@Override

publicvoid sessionDestroyed(HttpSessionEvent event) \{

ServletContext app =event.getSession().getServletContext();

int count =Integer.parseInt(app.getAttribute("onLineCount").toString());

count--;

app.setAttribute("onLineCount",count);

** **

**128、web.xml 的作用？**

答：用于配置Web应用的相关信息，如：监听器（listener）、过滤器（filter）、 Servlet、相关参数、会话超时时间、安全验证方式、错误页面等。例如：

1) 配置Spring上下文加载监听器加载Spring配置文件：

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:applicationContext.xml</param-value>

</context-param>

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

2) 配置Spring的OpenSessionInView过滤器来解决延迟加载和Hibernate会话关闭的矛盾：

<filter-name>openSessionInView</filter-name>

<filter-class>

org.springframework.orm.hibernate3.support.OpenSessionInViewFilter

</filter-class>

</filter>

<filter-mapping>

<filter-name>openSessionInView</filter-name>

<url-pattern>/\*</url-pattern>

</filter-mapping>

3) 配置会话超时时间为10分钟：

<session-config>

<session-timeout>10</session-timeout>

</session-config>

4) 配置404和Exception的错误页面：

<error-page>

<error-code>404</error-code>

<location>/error.jsp</location>

</error-page>

<error-page>

<exception-type>java.lang.Exception</exception-type>

<location>/error.jsp</location>

</error-page>

5) 配置安全认证方式：在Tomact的conf文件夹中的user.xml编写角色

<security-constraint>

<web-resource-collection>

<web-resource-name>Protected Area</web-resource-name>

<url-pattern>/admin/\*</url-pattern>

<http-method>GET</http-method>

<http-method>POST</http-method>

</web-resource-collection>

<auth-constraint>

<role-name>admin</role-name>

</auth-constraint>

</security-constraint>

<login-config>

<auth-method>BASIC</auth-method>

</login-config>

<security-role>

<role-name>admin</role-name>

</security-role>

补充：如果Web提供了有价值的商业信息或者是敏感数据，那么站点的安全性就是必须考虑的问题。安全认证是实现安全性的重要手段，认证就是要解决“Are you who you say you are?”的问题。认证的方式非常多，简单说来可以分为三类：

A. What you know? --- 口令

B. What you have? --- 数字证书（U盾、密保卡）

C. Who you are? ---  指纹、虹膜

在Tomcat中可以通过建立安全套接字层（Secure Socket Layer, SSL）以及通过基本验证或表单验证来实现对安全性的支持。

**129、你的项目中使用过哪些JSTL标签？**

答：项目中主要使用了JSTL的核心标签库，包括<c:if>、<c:choose>、<c: when>、<c: otherwise>、<c:forEach>等，主要用于构造循环和分支结构以控制显示逻辑。

说明：虽然JSTL标签库提供了core(推荐使用)、sql、fmt、xml（不推荐使用违背了视图与逻辑的分离)等标签库，但是实际开发中建议只使用核心标签库（core），而且最好只使用分支和循环标签并辅以表达式语言（EL），这样才能真正做到数据显示和业务逻辑的分离，这才是最佳实践。

**130、使用标签库有什么好处？如何自定义JSP标签？**

答：使用标签库的好处包括以下几个方面：

1)  分离JSP页面的内容和逻辑，简化了Web开发；

2)  开发者可以创建自定义标签来封装业务逻辑和显示逻辑；

3)  标签具有很好的可移植性、可维护性和可重用性；

4)  避免了对Scriptlet（小脚本）的使用（很多公司的项目开发都不允许在JSP中书写小脚本）

自定义JSP标签包括以下几个步骤：

A. 编写一个Java类实现Tag/BodyTag/IterationTag接口(通常不直接实现这些接口而是继承TagSupport/BodyTagSupport/SimpleTagSupport类，这是对适配器模式中缺省适配模式的应用)

B. 重写doStartTag()、doEndTag()等方法，定义标签要完成的功能

C.  编写扩展名为tld的标签描述文件对自定义标签进行部署，tld文件通常放在WEB-INF文件夹或其子目录

D. 如果要将标签库做成JAR文件，可以使用打包命令jar cvf filename.jar . \[最后的点是必要的，还要注意路径问题\]；tld文件放在JAR文件的META-INF目录，然后将JAR文件放到项目的WEB-INF/lib目录下

E. 在web.xml文件中使用<jsp-config>标签配置自定义标签库

F. 在JSP页面中使用taglib指令引用该标签库

下面是一个例子：

标签类源代码

package com.jackfrued.tag;

import java.io.IOException;

import java.text.SimpleDateFormat;

import java.util.Date;

import javax.servlet.jsp.JspException;

import javax.servlet.jsp.JspWriter;

import javax.servlet.jsp.tagext.TagSupport;

@SuppressWarnings("serial")

public class TimeTag extends TagSupport \{

privateString format = "yyyy-MM-dd hh:mm:ss";

privateString foreColor = "black";

privateString backColor = "white";

publicint doStartTag() throws JspException \{

SimpleDateFormat sdf = newSimpleDateFormat(format);

JspWriter writer = pageContext.getOut();

StringBuilder sb = new StringBuilder();

sb.append(String.format("<spanstyle='color:%s;background-color:%s'>%s",

foreColor, backColor, sdf.format(newDate())));

try \{

writer.print(sb.toString());

\} catch (IOException e) \{

e.printStackTrace();

return SKIP\_BODY;

publicvoid setFormat(String format) \{

this.format = format;

publicvoid setForeColor(String foreColor) \{

this.foreColor = foreColor;

publicvoid setBackColor(String backColor) \{

this.backColor = backColor;

标签描述文件

<?xml version="1.0"encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/j2ee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee

http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary\_2\_0.xsd"

version="2.0">

<tlib-version>1.0</tlib-version>

<short-name>JTag</short-name>

<tag>

<tag-class>com.jackfrued.tag.TimeTag</tag-class>

<body-content>empty</body-content>

<name>format</name>

<required>false</required>

</attribute>

<name>foreColor</name>

</attribute>

<name>backColor</name>

</attribute>

</tag>

</taglib>

Web.xml配置

<jsp-config>

<taglib-uri>http://blog.csdn.net/jackfrued/mytaglib</taglib-uri>

<taglib-location>/WEB-INF/tld/mytag.tld</taglib-location>

</taglib>

</jsp-config>

JSP页面

<%@taglib prefix="j"uri="http://blog.csdn.net/jackfrued/mytaglib" %>

<j:timeformat="yyyy-MM-dd hh:mm" foreColor="yellow"backColor="blue"/>

**131、请对以下Java EE中的名词进行解释**

答：

A. 容器：容器为Java EE应用程序组件提供了运行时支持。容器提供了一份从底层Java EE API到应用程序组件的联合视图。Java EE应用程序组件不能直接地与其它Java EE应用程序组件交互。它们通过容器的协议和方法来达成它们之间以及它们与平台服务之间的交互。在应用程序组件和Java EE服务之间插入一个容器，这允许该容器透明地为组件注入必须的服务，例如声明式事务管理，安全检查，资源池和状态管理。

B. 资源适配器：资源适配器是一个系统级的组件，它通常实现了对外部资源管理器的网络连接。资源适配器能够扩展Java EE平台的功能。这只需要实现一个Java EE标准服务API(例如JDBCTM驱动程序)，或者定义并实现一个能连接到外部应用程序系统的资源适配器就可以达到。资源适配器也可以提供完整的本地或本地资源的服务。资源适配器接口通过Java EE服务供应商接口(Java EE SPI)来连接Java EE平台。使用Java EE SPI连接到Java EE平台的资源适配器可以和所有的Java EE产品协同工作。

C. JNDI（Java Naming & Directory Interface）：JAVA命名目录接口，主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。

D. JMS（Java Message Service）：Java消息服务是用于消息发送的标准API，它支持可靠的“点对点”消息发送和“发布\-订阅”模型。Java EE规范要求JMS供应商同时实现“点对点”消息发送和”发布/订阅”型消息发送。

E. JTA（Java Transaction API）：Java事务接口。Java事务API由两部分组成：1)一个应用程序级的边界划分接口，容器和应用程序组件用它来划分事务边界；2)一个介于事务管理器和资源管理器之间的Java EE SPI( 事务管理器)级接口。

F. JPA（Java Persistence API）：Java持久化API是用于持久化和对象/关系映射管理的标准API。通过使用一个Java域模型来管理关系型数据库，JavaEE规范为应用程序开发者提供了一种对象/关系映射功能。Java EE必须对Java持久化API提供支持。它也可以用在Java SE环境中。

G. JAF（JavaBean Activation FrameWork）：JAF API提供了一个框架来处理不同MIME类型的数据，它们源于不同的格式和位置。JavaMail API使用了JAF API。JAF API包含在Java SE中，因此它可以被Java EE应用程序使用。

H. JAAS（Java Authentication and Authorization Service）：使服务能够基于用户进行验证和实施访问控制。它实现了一个Java版的标准的的Plugable Authentication Module (PAM)框架，并支持基于用户的授权。Java Authorization Service Provider Contract for Containers (JACC) 定义了JavaEE应用程序服务器和授权服务提供方之间的协议，允许将自定义的授权服务提供方插入任何Java EE产品中。

I. JMX（Java Management Extension）：Java平台企业版管理规范中定义了一种API，通过一种特殊的管理型EJB来管理Java EE服务器。JMX API也提供了一些管理上的支持。

J. NAT(网络地址转换):将一个IP地址域映射到另一个IP地址域的技术,从而为终端主机提供透明路由。NAT包括:静态网络地址转换、动态网络地址转换、网络地址及端口转换、动态网络地址及端口转换、端口映射等。NAT常用于私有地址与共有地址域的转换，以解决IP地址匮乏的问题。

**132、Java EE 是什么？**

答：Java EE是[Sun][]公司为企业级应用推出的标准[平台][Link 15]，该平台是由一系列技术标准所组成的，包括：EJB、JAAS、JAF、JAX-WS、JDBC、JNDI、JSTL、JSF、JSP、Servlet、RMI等。

**133、你是如何理解控制反转（IoC）和依赖注入（DI）的？**

答：控制反转 (Inversion ofControl， IoC)是把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。所谓的“控制反转”就是对组件对象控制权的转移，从程序代码本身转移到了外部容器，由容器来创建对象并管理对象之间的依赖关系。IoC体现了好莱坞原则：“Don’t call me, we will call you”。依赖注入（Dependency Injection，DI）的基本原则是：应用组件不应该负责查找资源或者其他依赖的协作对象。配置对象的工作应该由容器负责，查找资源的逻辑应该从应用组件的代码中抽取出来，交给容器来完成。DI是对IoC更准确的描述，即组件之间的依赖关系由容器在运行期决定，形象的来说，即由容器动态的将某种依赖关系注入到组件之中。

举个例子：一个类A需要用到接口B中的方法，那么就需要为类A和接口B建立关联或依赖关系，最原始的方法是在类A中创建一个接口B的实现类C的实例，但这种方法需要开发人员自行维护二者的依赖关系，也就是说当依赖关系发生变动的时候需要修改代码并重新构建整个系统。如果通过一个容器来管理这些对象以及对象的依赖关系，则只需要在类A中定义好用于关联接口B的方法(构造器或setter方法)，将类A和接口B的实现类C放入容器中，通过对容器的配置来实现二者的关联。

**134、请写出Spring 中IoC的实现机制。**

答：Spring中可以通过setter方法注入(推荐使用)和构造方法注入(注入的对象有顺序)实现IoC。

**135、你的项目选择使用Spring框架的原因是什么？**

答：

A. Spring提供了企业级开发的一站式选择，有大量的功能模块可供选择，并且可以根据项目的需要自由取舍。Spring通过POJO简化了Java EE开发，低侵入式的编程提供了代码的持续集成能力和易测试性。

B. Spring框架的核心功能是依赖注入（DI）。DI使得代码的单元测试更加方便、系统更好维护、代码也更加灵活。DI代码自身很容易测试，通过构建实现了应用所需的接口的“模拟”对象就可以进行功能的黑盒测试。DI代码也更容易复用，因为其“被依赖的”功能封装在在定义良好的接口中，允许其他对象根据需要将其插入到所需的对象中，这些对象是在其他应用平台中进行配置的。DI使代码更加灵活，由于其天生的松耦合性，它允许程序员仅需考虑自己所需的接口和其他模块暴露出来的接口来就可以决定对象之间如何关联。

C. Spring支持面向切面编程（AOP），允许通过分离应用业务逻辑和系统服务从而进行内聚性的开发。AOP通常用来支持日志、审计、性能和内存监控等功能。

D.Spring还提供了许多实现基本功能的模板类，使得Java EE应用的开发更加容易。例如，JdbcTemplate类和JDBC、JpaTemplate类和JPA，JmsTemplate类和JMS都可以很好地结合起来使用。RestTemplate类非常简洁，使用这个模板的代码的可读性和可维护性也都很好。

E. Spring提供了声明式事务处理，工作调度，身份认证，成熟的Web MVC框架以及和其他框架的集成，例如Hibernate、MyBatis、JasperReports、JSF、Struts、Tapestry、Seam和Quartz等等。

F. Spring Bean对象可以通过Terracotta在不同的JVM之间共享。这就允许使用已有的Bean并在集群中共享 ，将Spring应用上下文事件变为分布式事件，还可以通过SpringJMX导出集群Bean，使得Spring应用高可用、集群化。

G. Spring倾向于使用非受检异常（unchecked exceptions）和减少不当try、catch和finally代码块，例如JpaTemplate这样的Spring模板类会负责关闭或释放数据库连接，这避免了潜在的外部资源泄露问题并提高了代码的可读性。

** **

**136、Spring的AOP是什么？**

答:AOP是Aspect OrientedPrograming的简称,被翻译成”面向切面编程”,适用于那些具有横切逻辑的应用场合(性能监测、访问控制、事物管理、日志记录),

专业术语:

Cross-cutting concern：横切性关注点

Aspect(切面)：由切点和增强(引介)组成,提供与业务逻辑无关的额外服务的对象

Advice(增强)：aspect中对cross-cutting concern的具体实现称为advice,增强接口:BeforeAfvice,AfterRetuningAdvice,ThrowsAdvice等

Joinpoint(连接点)：advice在应用程序执行时加入业务流程的点或时机称为joinpoint，即advice在应用程序中被执行的时机。Spring只支持方法的joinpoint，执行时机可能是某个方法被执行前或执行后，或两者都有，或方法中发生某个异常的时候

Target(目标对象)

Introduction(引介):特殊的增强,为类添加一些属性和方法,动态地为业务类添加接口 实现逻辑，让业务类成为这个接口的实现类

Weaving(织入):将增强添加对目标类具体连接点上的过程,三种织入方式:

编译期织入:要求使用特殊的Java编译器

类装载期织入:要求特殊的类加载器

动态代理织入:在运行期为目标类添加增强生成子类的方式

Proxy(代理)

PointCut(切点)

AOP如何将增强应用于目标对象的连接点上:

第一:如何通过切点和增强定位到连接点上

第二:如何在增强中编写切面代码

项目中的架构之分层步鄹(“为变而设计”):

l  软件的生命周期

l  软件中变和不变的因素

在查询数据很多的时候,怎么提高查询效率（数据库或Java代码方面作答）:

数据库设计方面：

l  建立索引

l  分区(MySQL,比如按时间分区)

l  尽量使用固定长度的字段

l  限制字段长度

数据库I/O方面:

l  增加缓冲区

l  如果涉及表的级联,不同的表存储在不同的硬盘上,一增加I/O读取的速度

SQL语句方面:

l  优化SQL语句,减少比较次数

l  限制返回的条目数(MySQL中用的是limit)

Java方面:

l  如果反复使用的查询,使用preparedStament减少查询的次数

l  使用批处理查询

**137、给出下面的二叉树先序、中序、后序遍历的序列？**

答：先序序列：ABDEGHCF；中序序列：DBGEHACF；后序序列：DGHEBFCA。

补充：二叉树也称为二分树，它是树形结构的一种，其特点是每个结点至多有二棵子树，并且二叉树的子树有左右之分，其次序不能任意颠倒。二叉树的遍历序列按照访问根节点的顺序分为先序（先访问根节点，接下来先序访问左子树，再先序访问右子树）、中序（先中序访问左子树，然后访问根节点，最后中序访问右子树）和后序（先后序访问左子树，再后序访问右子树，最后访问根节点）。如果知道一棵二叉树的先序和中序序列或者中序和后序序列，那么也可以还原出该二叉树。

例如，已知二叉树的先序序列为：xefdzmhqsk，中序序列为：fezdmxqhks，那么还原出该二叉树应该如下图所示：

**137、你知道的排序算法都哪些？用Java写一个排序系统。**

答：稳定的排序算法有：插入排序、选择排序、冒泡排序、鸡尾酒排序、归并排序、二叉树排序、基数排序等；不稳定排序算法包括：希尔排序、堆排序、快速排序等。

下面是按排序原理对排序算法进行划分的一个列表：

下面按照策略模式给出一个排序系统，实现了冒泡、归并和快速排序。

鸡尾酒排序:两端冒泡

Sorter.java

**package** com.jackfrued.util;

**import** java.util.Comparator;

/\*\*

\* 排序器接口(策略模式:将算法封装到具有共同接口的独立的类中使得它们可以相互替换)

\* **@author**骆昊

\*/

**public  interface**Sorter \{

/\*\*

\* 排序

\* **@param** list待排序的数组

\*/

**public** <T **extends** Comparable<T>>**void**sort(T\[\] list);

/\*\*

\* 排序

\* **@param** list待排序的数组

\* **@param** comp比较两个对象的比较器

\*/

**public** <T>**void** sort(T\[\] list,Comparator<T> comp);

BubbleSorter.java

**package** com.jackfrued.util;

**import** java.util.Comparator;

/\*\*

\* 冒泡排序

\* **@author**骆昊

\*/

**public  class**BubbleSorter **implements** Sorter \{

@Override

**public** <T **extends** Comparable<T>>**void**sort(T\[\] list) \{

**boolean** swapped =**true**;

**for**(**int**i = 1; i < list.length&& swapped; i++) \{

swapped= **false**;

**for**(**int** j = 0; j < list.length \- i; j++) \{

**if**(list\[j\].compareTo(list\[j + 1\]) > 0 ) \{

Ttemp = list\[j\];

list\[j\]= list\[j + 1\];

list\[j+ 1\] = temp;

swapped= **true**;

鸡尾酒排序：**public** <T**extends** Comparable<T>> **void** PickMeUpsort(T\[\] list)\{

**boolean** swapped =**true**;

**for**(**int**i = 1; i < list.length&& swapped; i++) \{

swapped= **false**;

**for**(**int** j = 0; j < list.length \- i; j++) \{

**if**(list\[j\].compareTo(list\[j + 1\]) > 0 ) \{

Ttemp = list\[j\];

list\[j\]= list\[j + 1\];

list\[j+ 1\] = temp;

swapped= **true**;

if(swapped)\{

for(intj=list.length-i-1;j>0;j--)\{

swapped  = flase;

If(list\[j\].compareTo(list\[j -1\]) <0 )

T temp = list\[j\];

List\[j\] =list\[j-1\];

List\[j-1\] = temp;

Swaaped = true;

@Override

**public** <T>**void** sort(T\[\] list,Comparator<T> comp) \{

**boolean** swapped =**true**;

**for**(**int**i = 1; i < list.length&& swapped; i++) \{

swapped= **false**;

**for**(**int** j = 0; j < list.length \- i; j++) \{

**if**(comp.compare(list\[j\], list\[j + 1\]) > 0 ) \{

Ttemp = list\[j\];

list\[j\]= list\[j + 1\];

list\[j+ 1\] = temp;

swapped= **true**;

MergeSorter.java

**package** com.jackfrued.util;

**import** java.util.Comparator;

/\*\*

\* 归并排序

\* 归并排序是建立在归并操作上的一种有效的排序算法。

\* 该算法是采用分治法（divide\-and\-conquer）的一个非常典型的应用，

\* 先将待排序的序列划分成一个一个的元素，再进行两两归并，

\* 在归并的过程中保持归并之后的序列仍然有序。

\* **@author**骆昊

\*/

**public  class**MergeSorter **implements** Sorter \{

@Override

**public** <T **extends** Comparable<T>>**void**sort(T\[\] list) \{

T\[\] temp = (T\[\]) **new** Comparable\[list.length\];

mSort(list, temp, 0, list.length \- 1);

**private** <T**extends** Comparable<T>>**void**mSort(T\[\] list, T\[\] temp,**int** low, **int**high) \{

**if**(low == high) \{

**return** ;

**else** \{

**int** mid = low + ((high -low) >> 1);

mSort(list,temp, low, mid);

mSort(list,temp, mid + 1, high);

merge(list,temp, low, mid + 1, high);

**private** <T**extends** Comparable<T>>**void**merge(T\[\] list, T\[\] temp,**int** left, **int**right,**int**last) \{

**int** j = 0;

**int** lowIndex = left;

**int** mid = right - 1;

**int** n = last - lowIndex + 1;

**while** (left <= mid && right <= last)\{

**if** (list\[left\].compareTo(list\[right\]) < 0)\{

temp\[j++\] = list\[left++\];

\} **else** \{

temp\[j++\] = list\[right++\];

**while** (left <= mid) \{

temp\[j++\] = list\[left++\];

**while** (right <= last) \{

temp\[j++\] = list\[right++\];

**for** (j = 0; j < n; j++) \{

list\[lowIndex + j\] = temp\[j\];

@Override

**public** <T>**void** sort(T\[\] list,Comparator<T> comp) \{

T\[\] temp = (T\[\]) **new** Comparable\[list.length\];

mSort(list, temp, 0, list.length \- 1, comp);

**private** <T>**void** mSort(T\[\] list, T\[\]temp,**int**low, **int**high, Comparator<T> comp) \{

**if**(low == high) \{

**return** ;

**else** \{

**int** mid = low + ((high -low) >> 1);

mSort(list,temp, low, mid, comp);

mSort(list,temp, mid + 1, high, comp);

merge(list,temp, low, mid + 1, high, comp);

**private** <T>**void** merge(T\[\] list, T\[\]temp,**int**left, **int**right,**int**last, Comparator<T> comp) \{

**int** j = 0;

**int** lowIndex = left;

**int** mid = right - 1;

**int** n = last - lowIndex + 1;

**while** (left <= mid && right <= last)\{

**if** (comp.compare(list\[left\], list\[right\]) <0) \{

temp\[j++\] = list\[left++\];

\} **else** \{

temp\[j++\] = list\[right++\];

**while** (left <= mid) \{

temp\[j++\] = list\[left++\];

**while** (right <= last) \{

temp\[j++\] = list\[right++\];

**for** (j = 0; j < n; j++) \{

list\[lowIndex + j\] =temp\[j\];

package com.accp.sort;

/\*\*

\* 归并数组排序

\* @authorAdministrator

\*/

public class AchieveComparator \{

publicstatic void main(String\[\] args) \{

Integer\[\] x = \{ 12, 34, 56, 77, 89, 90, 92 \};

Integer\[\] y = \{ 11, 30, 32,44,67, \};

Object\[\] z = merge(x, y);

for (Object elem : z) \{

System.out.println(elem+ "\\t");

publicstatic <T extends Comparable<T>> Object\[\] merge(T\[\] a, T\[\] b) \{

Object\[\] z = new Object\[a.length+b.length\];

int xIndex, yIndex, zIndex;

xIndex = yIndex = zIndex = 0;

for (; xIndex < a.length && yIndex< b.length; zIndex++) \{

if(a\[xIndex\].compareTo(b\[yIndex\]) < 0) \{

z\[zIndex\] = a\[xIndex++\];

\}else \{

z\[zIndex\] = b\[yIndex++\];

while (xIndex < a.length) \{

z\[zIndex++\]= a\[xIndex++\];

while (yIndex < b.length) \{

z\[zIndex++\]= a\[yIndex++\];

return z;

QuickSorter.java

**package** com.jackfrued.util;

**import** java.util.Comparator;

/\*\*

\* 快速排序

\* 快速排序是使用分治法（divide\-and\-conquer）依选定的枢轴

\* 将待排序序列划分成两个子序列，其中一个子序列的元素都小于枢轴，

\* 另一个子序列的元素都大于或等于枢轴，然后对子序列重复上面的方法，

\* 直到子序列中只有一个元素为止

\* **@author** Hao

\*/

**public  class**QuickSorter **implements** Sorter \{

@Override

**public** <T **extends** Comparable<T>>**void**sort(T\[\] list) \{

quickSort(list, 0, list.length \- 1);

@Override

**public** <T>**void** sort(T\[\] list,Comparator<T> comp) \{

quickSort(list, 0, list.length \- 1, comp);

**private** <T**extends** Comparable<T>>**void**quickSort(T\[\] list,**int** first, **int**last) \{

**if** (last > first) \{

**int** pivotIndex =partition(list, first, last);

quickSort(list,first, pivotIndex - 1);

quickSort(list,pivotIndex, last);

**private** <T>**void** quickSort(T\[\] list, **int** first, **int** last,Comparator<T> comp) \{

**if** (last > first) \{

**int** pivotIndex = partition(list,first, last, comp);

quickSort(list,first, pivotIndex - 1, comp);

quickSort(list,pivotIndex, last, comp);

**private** <T**extends** Comparable<T>>**int**partition(T\[\] list,**int** first, **int**last) \{

T pivot = list\[first\];

**int** low = first + 1;

**int** high = last;

**while** (high > low) \{

**while** (low <= high&& list\[low\].compareTo(pivot) <= 0) \{

low++;

**while** (low <= high&& list\[high\].compareTo(pivot) >= 0) \{

high--;

**if** (high > low) \{

T temp = list\[high\];

list\[high\] = list\[low\];

list\[low\] = temp;

**while** (high > first && list\[high\].compareTo(pivot) >= 0) \{

high--;

**if** (pivot.compareTo(list\[high\]) > 0) \{

list\[first\]= list\[high\];

list\[high\]= pivot;

**return** high;

**else** \{

**return** low;

**private** <T>**int** partition(T\[\] list, **int** first, **int** last,Comparator<T> comp) \{

T pivot = list\[first\];

**int** low = first + 1;

**int** high = last;

**while** (high > low) \{

**while** (low <= high&& comp.compare(list\[low\], pivot) <= 0) \{

low++;

**while** (low <= high&& comp.compare(list\[high\], pivot) >= 0) \{

high--;

**if** (high > low) \{

T temp = list\[high\];

list\[high\] = list\[low\];

list\[low\] = temp;

**while** (high > first && comp.compare(list\[high\], pivot) >= 0) \{

high--;

**if** (comp.compare(pivot, list\[high\]) > 0) \{

list\[first\]= list\[high\];

list\[high\]= pivot;

**return** high;

**else** \{

**return** low;

**138、写一个二分查找（折半搜索）的算法。**

答：折半搜索，也称二分查找算法、二分搜索，是一种在有序数组中查找某一特定元素的[搜索算法][Link 16]。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

**package** com.jackfrued.util;

**import** java.util.Comparator;

**public  class**MyUtil \{

**public static** <T **extends** Comparable<T>>**int**binarySearch(T\[\] x, T key) \{

**return**  *binarySearch*(x, 0, x.length \- 1, key);

**public static** <T> **int** binarySearch(T\[\] x, T key, Comparator<T> comp) \{

**int** low = 0;

**int** high = x.length\- 1;

**while** (low <= high) \{

**int** mid = (low + high)>>> 1;

**int** cmp =comp.compare(x\[mid\], key);

**if** (cmp < 0) \{

low = mid + 1;

**else  if** (cmp > 0) \{

high = mid - 1;

**else** \{

**return** mid;

**return** \-1;

**private static**<T **extends** Comparable<T>>**int**binarySearch(T\[\] x,**int** low, **int**high, T key) \{

**if**(low <= high) \{

**int** mid = low + ((high -low) >> 1);

**if**(key.compareTo(x\[mid\])== 0) \{

**return** mid;

**else if**(key.compareTo(x\[mid\])< 0) \{

**return***binarySearch*(x, low, mid - 1, key);

**else** \{

**return***binarySearch*(x, mid + 1, high, key);

**return** \-1;

public static <T extendsComparable<T>> void binarySearchsort(T\[\] list) \{

/\*\*

\* @param x 被查找的数组(有序)

\* @param key 查找特定的元素

\* @return 找到元素返回元素在数组中的位置,没有找到就返回-1

\*/

publicstatic <T extends Comparable<T>> int binarySearchsort(T\[\] x, T key)\{

int low = 0;//起点元素

int hight = x.length - 1;//终点元素

while (low <= hight) \{

//中间元素

intmid = low + ((hight - low) >> 1);

//如果要查找的元素等于中间元素

if(key.compareTo(x\[mid\]) == 0) \{

return mid;

//如果要查找的元素大于中间元素 ,low=mid+1

\}else if (key.compareTo(x\[mid\]) > 0) \{

low = mid + 1;

//如果要查找的元素小于中间元素 ,hight = mid-1

\}else if (key.compareTo(x\[mid\]) < 0) \{

hight = mid -1;

return -1;

说明：两个版本一个用递归实现，一个用循环实现。需要注意的是计算中间位置时不应该使用(high + low) / 2的方式，因为加法运算可能导致整数越界，这里应该使用一下三种方式之一：low + (high – low) / 2或low + (high – low) >> 1或（low + high） >>> 1（注：>>>是逻辑右移，不带符号位的右移）

**139、统计一篇英文文章中单词个数。**

答：

import java.io.FileReader;

public class WordCounting \{

publicstatic void main(String\[\] args) \{

try (FileReader fr = newFileReader("a.txt")) \{

intcounter = 0;//记录单词数

booleanstate = false;//状态标识

intcurrentChar;//当前的字符

//一次读取一个单词

while((currentChar= fr.read()) != -1) \{

//一个单词的标识:空格、换行、回车

if(currentChar == ' ' || currentChar == '\\n'

||currentChar == '\\t' || currentChar == '\\r') \{

state= false;

else if(!state) \{

state= true;

counter++;

System.out.println(counter);

catch(Exception e) \{

e.printStackTrace();

补充：这个程序可能有很多种写法，这里选择的是Dennis M. Ritchie和Brian W. Kernighan老师在他们不朽的著作《The C Programming Language》中给出的代码，向两位老师致敬。下面的代码也是如此。

**140、输入年月日，计算该日期是这一年的第几天。**

答：

**import** java.util.Scanner;

**public  class**DayCounting \{

**public  static void** main(String\[\] args) \{

**int**\[\]\[\] data = \{

\{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31\},

\{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30,31\}

\};

Scanner sc = **new** Scanner(System.*in*);

System.*out*.print("请输入年月日(1980 11 28): ");

**int** year = sc.nextInt();

**int** month = sc.nextInt();

**int** date = sc.nextInt();

**int**\[\] daysOfMonth =

data\[(year % 4 == 0 && year % 100 != 0 || year % 400 == 0)?1 : 0\];

**int** sum = 0;

**for**(**int**i = 0; i < month - 1; i++) \{

sum+= daysOfMonth\[i\];

sum += date;

System.*out*.println(sum);

sc.close();

**141、约瑟夫环：15个基督教徒和15个非教徒在海上遇险，必须将其中一半的人投入海中，其余的人才能幸免于难，于是30个人围成一圈，从某一个人开始从1报数，报到9的人就扔进大海，他后面的人继续从1开始报数，重复上面的规则，直到剩下15个人为止。结果由于上帝的保佑，15个基督教徒最后都幸免于难，问原来这些人是怎么排列的，哪些位置是基督教徒，哪些位置是非教徒。**

答：

**public  class**Josephu \{

**private  static final  int** *DEAD\_NUM* = 9;

**public  static void** main(String\[\] args) \{

**boolean**\[\] persons =**new boolean**\[30\];

**for**(**int**i = 0; i < persons.length; i++) \{

persons\[i\]= **true**;

**int** counter = 0;

**int** claimNumber = 0;

**int** index = 0;

**while**(counter < 15) \{

**if**(persons\[index\]) \{

claimNumber++;

**if**(claimNumber ==*DEAD\_NUM*) \{

counter++;

claimNumber= 0;

persons\[index\]= **false**;

index++;

**if**(index >= persons.length) \{

index = 0;

**for**(**boolean**p : persons) \{

**if**(p) \{

System.*out*.print("基");

**else** \{

System.*out*.print("非");

**142、回文素数：所谓回文数就是顺着读和倒着读一样的数(例如：11，121，1991…)，回文素数就是既是回文数又是素数(只能被1和自身整除的数)的数。编程找出11～9999之间的回文素数。**

答：

**public  class**PalindromicPrimeNumber \{

**public  static void** main(String\[\] args) \{

**for**(**int**i = 11; i <= 9999; i++) \{

**if**(*isPrime*(i)&&*isPalindromic*(i)) \{

System.*out*.println(i);

//判断素数

**public  static boolean** isPrime(**int** n) \{

**for**(**int**i = 2; i <= Math.*sqrt*(n); i++) \{

**if**(n % i == 0) \{

**return  false**;

**return  true**;

//判断回文数

**public  static boolean** isPalindromic(**int** n) \{

**int** temp = n;//临时变量

**int** sum = 0;//记录回文数

**while**(temp > 0) \{

sum =sum \* 10 + temp % 10;

temp/= 10;

**return** sum == n;

**143、全排列：给出五个数字12345的所有排列。**

答：

**public  class**FullPermutation \{

**public  static void** perm(**int**\[\] list) \{

*perm*(list, 0);

**private  static void** perm(**int**\[\] list,**int** k) \{

**if** (k == list.length)\{

**for** (**int** i = 0; i < list.length; i++) \{

System.*out*.print(list\[i\]);

System.*out*.println();

\} **else** \{

**for** (**int** i = k; i < list.length; i++) \{

*swap*(list, k, i);

*perm*(list, k + 1);

*swap*(list, k, i);

**private  static void** swap(**int**\[\] list,**int** pos1, **int** pos2) \{

**int** temp = list\[pos1\];

list\[pos1\] = list\[pos2\];

list\[pos2\] = temp;

**public  static void** main(String\[\] args) \{

**int**\[\] x = \{1, 2, 3, 4, 5\};

*perm*(x);

**144、对于一个有N个整数元素的一维数组，找出它的子数组（数组中下标连续的元素组成的数组）之和的最大值。**

答：下面给出几个例子（最大子数组用粗体表示）：

1) 数组：\{ 1, -2, **3**,**5**, -3, 2 \}，结果是：8

2) 数组：\{ 0, -2, **3**, **5**, **-1**,  **2** \}，结果是：9

3) 数组：\{ -9, **-2**,-3, -5, -3 \}，结果是：-2

可以使用动态规划的思想求解：

**public  class**MaxSum \{

**private  static int** max(**int** x,**int** y) \{

**return** x > y? x: y;

**public  static int** maxSum(**int**\[\] array) \{

**int** n = array.length;

**int**\[\] start =**newint**\[n\];

**int**\[\] all =**newint**\[n\];

all\[n - 1\] = start\[n - 1\] = array\[n - 1\];

**for**(**int**i = n - 2; i >= 0; i--) \{

start\[i\]= *max*(array\[i\], array\[i\] + start\[i + 1\]);

all\[i\]= *max*(start\[i\], all\[i + 1\]);

**return** all\[0\];

**public  static void** main(String\[\] args) \{

**int**\[\] x1 = \{ 1, -2, 3, 5, -3, 2 \};

**int**\[\] x2 = \{ 0, -2, 3, 5, -1, 2 \};

**int**\[\] x3 = \{ -9, -2, -3, -5, -3 \};

System.*out*.println(*maxSum*(x1));  // 8

System.*out*.println(*maxSum*(x2));  // 9

System.*out*.println(*maxSum*(x3));  //-2

**145、用递归实现字符串倒转**

答：

**public  class**StringReverse \{

**public  static** String reverse(StringoriginStr) \{

//递归临界:字符串为、空长度为1

**if**(originStr ==**null** || originStr.length() == 1) \{

**return** originStr;

//递归:截取substring(1)、charAt(0)

**return**  *reverse*(originStr.substring(1)) + originStr.charAt(0);

**public  static void** main(String\[\] args) \{

System.*out*.println(*reverse*("hello"));

**146、输入一个正整数，将其分解为素数的乘积。**

答：

**public  class**DecomposeInteger \{

**private static** List<Integer> *list* =**new**ArrayList<Integer>();

**public  static void** main(String\[\] args) \{

System.*out*.print("请输入一个数: ");

Scanner sc = **new** Scanner(System.*in*);

**int** n = sc.nextInt();

*decomposeNumber*(n);

System.*out*.print(n +" = ");

**for**(**int**i = 0; i <*list*.size()- 1; i++) \{

System.*out*.print(*list*.get(i) +" \* ");

System.*out*.println(*list*.get(*list*.size() - 1));

**public  static void** decomposeNumber(**int** n) \{

**if**(*isPrime*(n)) \{

*list*.add(n);

*list*.add(1);

**else** \{

*doIt*(n,(**int**)Math.*sqrt*(n));

**public  static void** doIt(**int** n,**int** div) \{

**if**(*isPrime*(div) && n % div == 0) \{

*list*.add(div);

*decomposeNumber*(n/ div);

**else** \{

*doIt*(n,div - 1);

**public  static boolean** isPrime(**int** n) \{

**for**(**int**i = 2; i <= Math.*sqrt*(n); i++) \{

**if**(n % i == 0) \{

**return  false**;

**return  true**;

**147、一个有n级的台阶，一次可以走1级、2级或级，问走完n级台阶有多少种走法。**

答：可以通过递归求解。

**public  class**GoSteps \{

**public  static int**  countWays(**int** n) \{

**if**(n < 0) \{

**return** 0;

\} *countWays*

**else  if**(n == 0) \{

**return** 1;

**else** \{

**return***countWays*(n - 1) + (n - 2) + *countWays*(n -3);

**publicstaticvoid**main(String\[\] args) \{

System.*out*.println(*countWays*(5));  // 13

**148、写一个算法判断一个英文单词的所有字母是否全都不同（不区分大小写）。**

答：用空间换时间

**public  class**AllNotTheSame \{

**public  static boolean** judge(String str) \{

String temp = str.toLowerCase();

**int**\[\] letterCounter =**new int**\[26\];

**for**(**int**i = 0; i < temp.length(); i++) \{

**int** index = temp.charAt(i)-'a';

letterCounter\[index\]++;

**if**(letterCounter\[index\]> 1) \{

**returnfalse**;

**returntrue**;

**public  static void** main(String\[\] args) \{

System.*out*.println(*judge*("hello"));

System.*out*.print(*judge*("smile"));

**149、有一个已经排好序的整数数组，其中存在重复元素，请将重复元素删除掉，例如，A= \[1, 1, 2, 2, 3\]，处理之后的数组应当为A= \[1, 2, 3\]。**

答：

**import** java.util.Arrays;

**public  class**RemoveDuplication \{

**public  static int**\[\] removeDuplicates(**int** a\[\]) \{

**if**(a.length <= 1) \{

**return** a;

**int** index = 0;

**for**(**int** i = 1; i < a.length; i++) \{

**if**(a\[index\] != a\[i\]) \{

a\[++index\] = a\[i\];

**int**\[\] b =**new int**\[index + 1\];

System.*arraycopy*(a, 0, b, 0, b.length);

**return** b;

**publicstaticvoid**main(String\[\] args) \{

**int**\[\] a = \{1, 1, 2, 2, 3\};

a = *removeDuplicates*(a);

System.*out*.println(Arrays.*toString*(a));

**150、给一个数组，其中有一个重复元素占半数或半数以上，找出这个元素。**

答：

**public  class**FindMost \{

**public static** <T> T find(T\[\] x)\{

T temp = **null**;

**for**(**int**i = 0, nTimes = 0; i < x.length; i++) \{

**if**(nTimes == 0) \{

temp = x\[i\];

nTimes = 1;

**else** \{

**if**(x\[i\].equals(temp)) \{

nTimes++;

**else** \{

nTimes--;

**return** temp;

**public  static void** main(String\[\] args) \{

String\[\] strs = \{ "hello","kiss", "hello","hello","maybe"\};

System.*out*.println(*find*(strs));

BeanFactory在初始化容器时,并未实例化Bean,直到第一访问牟恩Bean时才实例目标；

ApplicationContext在初始化应用上下文时就实例化所有单实例的Bean;ApplicationContext比BeanFactory初始化时间稍长

富文本框

UI控件

EasyUI

MiniUI

zTree

jQuery-treeView

150.Ajax的工作原理和XmlHttpRequest对象

Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，然后用javascript来操作DOM而更新页面。这其中最关键的一步就是从服务器获得请求数据。要清楚这个过程和原理，我们必须对 XMLHttpRequest有所了解。

XMLHttpRequest是ajax的核心机制，它是在IE5中首先引入的，是一种支持异步请求的技术。简单的说，也就是javascript可以及时向服务器提出请求和处理响应，而不阻塞用户。达到无刷新的效果。

所以我们先从XMLHttpRequest讲起，来看看它的工作原理。

首先，我们先来看看XMLHttpRequest这个对象的属性。

它的属性有：

onreadystatechange  每次状态改变所触发事件的事件处理程序。

responseText     从服务器进程返回数据的字符串形式。

responseXML    从服务器进程返回的DOM兼容的文档数据对象。

status           从服务器返回的数字代码，比如常见的404（未找到）和200（已就绪）

status Text       伴随状态码的字符串信息

readyState       对象状态值

0 (未初始化) 对象已建立，但是尚未初始化（尚未调用open方法）

1 (初始化) 对象已建立，尚未调用send方法

2 (发送数据) send方法已调用，但是当前的状态及http头未知

3 (数据传送中) 已接收部分数据，因为响应及http头不全，这时通过responseBody和responseText获取部分数据会出现错误，

4 (完成) 数据接收完毕,此时可以通过通过responseXml和responseText获取完整的回应数据

151.创建Ajax的XmlHttpRequest

function CreateXmlHttp() \{

//非IE浏览器创建XmlHttpRequest对象

if(window.XmlHttpRequest) \{

xmlhttp = new XmlHttpRequest();

//IE浏览器创建XmlHttpRequest对象

if (window.ActiveXObject)\{

try\{

xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");

catch (e) \{

try \{

xmlhttp = new ActiveXObject("msxml2.XMLHTTP");

catch (ex) \{ \}

function Ustbwuyi() \{

vardata = document.getElementById("username").value;

CreateXmlHttp();

if(!xmlhttp) \{

alert("创建xmlhttp对象异常！");

return false;

xmlhttp.open("POST", url, false);

xmlhttp.onreadystatechange = function () \{

if(xmlhttp.readyState == 4) \{

document.getElementById("user1").innerHTML = "数据正在加载...";

if (xmlhttp.status == 200) \{

document.write(xmlhttp.responseText);

xmlhttp.send();

152.Ajax的优缺点:

优点:

1、最大的一点是页面无刷新，在页面内与服务器通信，给用户的体验非常好。

2、使用异步方式与服务器通信，不需要打断用户的操作，具有更加迅速的响应能力。

3、可以把以前一些服务器负担的工作转嫁到客户端，利用客户端闲置的能力来处理，减轻服务器和带宽的负担，节约空间和宽带租用成本。并且减轻服务器的负担，ajax的原则是“按需取数据”，可以最大程度的减少冗余请求，和响应对服务器造成的负担。

4、基于标准化的并被广泛支持的技术，不需要下载插件或者小程序。

**缺点:**

1、ajax干掉了back按钮，即对浏览器后退机制的破坏。后退按钮是一个标准的web站点的重要功能，但是它没法和js进行很好的合作。这是ajax所带来的一个比较严重的问题，因为用户往往是希望能够通过后退来取消前一次操作的。那么对于这个问题有没有办法？答案是肯定的，用过Gmail的知道，Gmail下面采用的ajax技术解决了这个问题，在Gmail下面是可以后退的，但是，它也并不能改变ajax的机制，它只是采用的一个比较笨但是有效的办法，即用户单击后退按钮访问历史记录时，通过创建或使用一个隐藏的IFRAME来重现页面上的变更。（例如，当用户在Google Maps中单击后退时，它在一个隐藏的IFRAME中进行搜索，然后将搜索结果反映到Ajax元素上，以便将应用程序状态恢复到当时的状态。）

但是，虽然说这个问题是可以解决的，但是它所带来的开发成本是非常高的，和ajax框架所要求的快速开发是相背离的。这是ajax所带来的一个非常严重的问题。

2、安全问题

技术同时也对IT企业带来了新的安全威胁，ajax技术就如同对企业数据建立了一个直接通道。这使得开发者在不经意间会暴露比以前更多的数据和服务器逻辑。ajax的逻辑可以对客户端的安全扫描技术隐藏起来，允许黑客从远端服务器上建立新的攻击。还有ajax也难以避免一些已知的安全弱点，诸如跨站点脚步攻击、SQL注入攻击和基于credentials的安全漏洞等。

3、对搜索引擎的支持比较弱。

4、破坏了程序的异常机制。至少从目前看来，像ajax.dll，ajaxpro.dll这些ajax框架是会破坏程序的异常机制的。关于这个问题，我曾经在开发过程中遇到过，但是查了一下网上几乎没有相关的介绍。后来我自己做了一次试验，分别采用ajax和传统的form提交的模式来删除一条数据……给我们的调试带来了很大的困难。

5、另外，像其他方面的一些问题，比如说违背了url和资源定位的初衷。例如，我给你一个url地址，如果采用了ajax技术，也许你在该url地址下面看到的和我在这个url地址下看到的内容是不同的。这个和资源定位的初衷是相背离的。

6、一些手持设备（如手机、PDA等）现在还不能很好的支持ajax，比如说我们在手机的浏览器上打开采用ajax技术的网站时，它目前是不支持的，当然，这个问题和我们没太多关系。

**Oracle语句练习**

0. 查询最高工资及其对应员工

解法一: select ename from (select ename from emp orderby sal desc) where rownum=1;

解法二: select ename from emp where sal=(selectmax(sal) from emp);

解法三: select ename, sal from emp where sal not in(select distinct t1.sal from emp t1 inner join emp t2 on t1.sal < t2.sal);

1. 计算每位员工的年薪

select ename, sal\*12+nvl(comm, 0) annualSalaryfrom emp;

2. 统计有员工的部门的人数

select count(distinct deptno) from emp;

3. 求挣最高薪水的员工(boss除外)的姓名

select ename from emp where sal = (select max(sal)from emp where job<>upper('president'));

4. 查询薪水超过平均薪水的员工的姓名和工资

select ename, sal from emp where sal > (selectavg(sal) from emp);

5. 查询薪水超过其所在部门平均薪水的员工的姓名、部门编号和工资

select ename, t1.deptno, to\_char(sal, '$9,999.9')sal, to\_char(round(t2.avgsal, 1), '$9,999.9') avg from emp t1,(select deptno,avg(sal) avgsal from emp group by deptno) t2 where t1.sal > t2.avgsal andt1.deptno = t2.deptno;

6. 查询部门中薪水最高的人姓名、工资和所在部门名称

select ename, sal, dname from emp t1

inner join

(select deptno, max(sal) maxsal from emp group bydeptno) t2

on t1.deptno = t2.deptno and t1.sal = t2.maxsal

inner join

dept t3 on t3.deptno = t1.deptno;

7. 查询部门平均薪水的等级

select deptno, avg, grade from (select deptno,avg(sal) avg from emp group by deptno) t1 inner join salgrade t2 on t1.avg betweent2.losal and t2.hisal;

8. 哪些人是主管

select ename from emp

where empno in (select distinct mgr from emp);

9. 求平均薪水最高的部门的名称和平均工资

select dname, to\_char(avg, '$9,999.9') avg fromdept t1

inner join (select deptno, avg from (selectdeptno, avg(sal) avg from emp group by deptno) where avg =  (select max(avg) from(select deptno, avg(sal) avg from emp group by deptno))) t2 on t1.deptno =t2.deptno;

10. 求薪水最高的前3名雇员

select \* from (select ename, sal from emp orderby sal desc) t where rownum <= 3;

11. 求薪水最高的第4-6名雇员

select ename, sal from (select rownum as rn, t.\*from (select ename, sal from emp order by sal desc) t) where rn >= 4 and rn<= 6;

12. 求薪水最低的部门经理所在部门的名称

时间转换:

1.Calendar 转化String

//获取当前时间的具体情况,如年,月,日,week,date,分,秒等

Calendar calendat = Calendar.getInstance();

SimpleDateFormat sdf = newSimpleDateFormat("yyyy-MM-dd");

String dateStr = sdf.format(calendar.getTime());

2.String 转化Calendar

String str="2010-5-27";

SimpleDateFormat sdf= newSimpleDateFormat("yyyy-MM-dd");

Date date =sdf.parse(str);

Calendar calendar = Calendar.getInstance();

calendar.setTime(date);

3.Date 转化String

SimpleDateFormat sdf= newSimpleDateFormat("yyyy-MM-dd");

String dateStr=sdf.format(new Date());

4.String 转化Date

String str="2010-5-27";

SimpleDateFormat sdf= newSimpleDateFormat("yyyy-MM-dd");

Date birthday = sdf.parse(str);

5.Date 转化Calendar

Calendar calendar = Calendar.getInstance();

calendar.setTime(new java.util.Date());

6.Calendar转化Date

Calendar calendar = Calendar.getInstance();

java.util.Date date =calendar.getTime();

[Design Patterns_ Elements of Reusable Object-Oriented Software]: http://www.amazon.cn/Design-Patterns-Elements-of-Reusable-Object-Oriented-Software-Gamma-Erich/dp/0201633612/ref=sr_1_3?ie=UTF8&qid=1387704600&sr=8-3&keywords=design+patterns
[Link 1]: http://zh.wikipedia.org/w/index.php?title=%E8%AE%BE%E8%AE%A1%E8%8C%83%E5%BC%8F&action=edit&redlink=1
[Link 2]: http://zh.wikipedia.org/wiki/%E8%BD%AF%E4%BB%B6%E8%AE%BE%E8%AE%A1%E5%B8%88
[Link 3]: http://baike.baidu.com/view/7383.htm
[Link 4]: http://baike.baidu.com/view/751.htm
[Link 5]: http://baike.baidu.com/view/330120.htm
[Link 6]: http://baike.baidu.com/view/1251417.htm
[Internet]: http://baike.baidu.com/view/1326829.htm
[FTP]: http://baike.baidu.com/view/106754.htm
[Link 7]: http://baike.baidu.com/view/543341.htm
[Link 8]: http://baike.baidu.com/view/897136.htm
[Web]: http://baike.baidu.com/view/460250.htm
[Link 9]: http://baike.baidu.com/view/1165595.htm
[Link 10]: http://baike.baidu.com/view/4438667.htm
[Link 11]: http://baike.baidu.com/view/995472.htm
[Link 12]: http://baike.baidu.com/view/2236379.htm
[Apache]: http://baike.baidu.com/view/28283.htm
[Link 13]: http://baike.baidu.com/view/60376.htm
[Unix]: http://baike.baidu.com/view/8095.htm
[Linux]: http://baike.baidu.com/view/1634.htm
[Link 14]: http://baike.baidu.com/view/7886.htm
[Sun]: http://zh.wikipedia.org/wiki/Sun
[Link 15]: http://zh.wikipedia.org/wiki/%E7%B3%BB%E7%B5%B1%E5%B9%B3%E5%8F%B0
[Link 16]: http://zh.wikipedia.org/w/index.php?title=%E6%90%9C%E7%B4%A2%E7%AE%97%E6%B3%95&action=edit&redlink=1