面试题

1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

可以有多个类，但只能有一个 public的类，并且public 的类名必须与文件名相一致。

2、Java 有没有goto?

java中的保留字，现在没有在 java中使用。

3、说说&和&&的区别。

&和&& 都可以用作逻辑与的运算符，表示逻辑与（ and），当运算符两边的表达式的结果都为 true时，整个运算结果才为true，否则，只要有一方为 false，则结果为false 。

&&还具有短路的功能，即如果第一个表达式为 false，则不再计算第二个表达式，

4、在JAVA 中如何跳出当前的多重嵌套循环？

在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的 break语句，即可跳出外层循环

5 、switch 语句能否作用在 byte 上，能否作用在 long上，能否作用在 String 上?

在 switch（ expr1 ）中，expr1 只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是 int 基本类型或Integer 包装类型，由于， byte,short,char 都可以隐含转换为 int，所以，这些类型以及这些类型的包装类型也是可以的。

6 、short s1 = 1; s1 = s1 + 1; 有什么错 ? short s1 = 1; s1 += 1;有什么错 ?

对于 short s1 = 1; s1 = s1 + 1; 由于s1+1 运算时会自动提升表达式的类型，所以结果是 int 型，再赋值给 short类型 s1 时，编译器将报告需要强制转换类型的错误。

对于 short s1 = 1; s1 += 1; 由于 += 是 java语言规定的运算符， java 编译器会对它进行特殊处理，因此可以正确编译。

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

char 型变量是用来存储 Unicode编码的字符的， unicode 编码字符集中包含了汉字，所以， char 型变量中当然可以存储汉字啦。 unicode编码占用两个字节，所以， char 类型的变量也是占用两个字节。

8 、用最有效率的方法算出 2 乘以8 等于几 ?

2 << 3 ， 

10 、使用 final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的

11、 "=="和 equals方法究竟有什么区别？

== 操作符专门用来 比较两个变量的值是否相等 ，也就是用于比较变量所对应的内存中所存储的数值是否相同， 要比较两个基本类型的数据或两个引用变量是否相等，只能用 == 操作符。

equals 方法是用于比较两个独立对象的内容是否相同 ，如果一个类没有自己定义 equals方法，它默认的 equals方法（从 Object类继承的）就是使用 ==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用 equals和使用 ==会得到同样的结果，

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

在语法定义上的区别 ： 静态变量 前要加 static关键字，而实例变量前则不加。

在程序运行时的区别 ：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。 静态变量 不属于某个实例对象，而是 属于类 ，所以也称为 类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

13、是否可以从一个 static方法内部发出对非 static方法的调用？

不可以 。因为 非static 方法是要与对象关联在一起 的，必须创建一个对象后，才可以在该对象上进行方法调用，而 static方法调用时不需要创建对象，可以直接调用。也就是说， 当一个 static方法被调用时，可能还没有创建任何实例对象 ，如果从一个 static方法中发出对非 static方法的调用，那个非 static方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个 static方法内部发出对非 static方法的调用。

14、 Integer与int 的区别

int 是java 提供的8 种原始数据类型之一。 Java为每个原始类型提供了封装类， Integer是 java为 int提供的封装类。 int的默认值为 0，而 Integer的默认值为 null，即 Integer可以区分出未赋值和值为 0的区别， int则无法表达出未赋值的情况，例如，要想表达出没有参加考试和考试成绩为 0的区别，则只能使用 Integer。在 JSP开发中， Integer的默认为 null，所以用 el表达式在文本框中显示时，值为空白字符串，而 int默认的默认值为 0，所以用 el表达式

在文本框中显示时，结果为

0，所以， int不适合作为 web层的表单数据的类型。

在 Hibernate中，如果将 OID定义为 Integer类型，那么 Hibernate就可以根据其值是否为 null而判断一个对象是否是临时的，如果将 OID定义为了 int类型，还需要在 hbm映射文件中设置其 unsaved-value属性为 0。

另外， Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数， Integer中还定义了表示整数的最大值和最小值的常量。

15、 Math.round(11.5)等於多少 ? Math.round(-11.5)等於多少 ?

Math 类中提供了三个与取整有关的方法： ceil、 floor、 round，这些方法的作用与它们的英文名称的含义相对应，例如， ceil的英文意义是 天花板 ，该方法就表示 向上取整， Math.ceil(11.3)的结果为 12,Math.ceil(-11.3)的结果是 -11； floor 的英文意义是 地板，该方法就表示 向下取整 ，Math.ceil(11.6) 的结果为 11,Math.ceil(-11.6)的结果是 -12；最难掌握的是 round 方法，它表示“四舍五入” ，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5后再向下取整，所以， Math.round(11.5)的结果为 12， Math.round(-11.5)的结果为 -11。

16、下面的代码有什么不妥之处 ?

 if(username.equals( “zxx ”){}

username 可能为NULL, 会报空指针错误；改为 "zxx".equals(username)

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

Overload是重载的意思， Override是覆盖的意思，也就是重写。

重载 Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。

重写 Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。

这是不行的，我们可以用反证法来说明这个问题，因为我们有时候调用一个方法时也可以不定义返回结果变量，即不要关心其返回结果，

19、构造器 Constructor是否可被 override?

构造器 Constructor 不能被继承，因此不能重写 Override ，但可以被重载 Overload。

20、接口是否可继承接口 ?抽象类是否可实现 (implements)接口 ?抽象类是否可继承具体类 (concrete class)?抽象类中是否可以有静态的 main方法？

接口可以继承接口。抽象类可以实现 (implements)接口，抽象类可以继承具体类。抽象类中可以有静态的 main方法。

只有记住抽象类与普通类的唯一区别：就是不能创建实例对象和允许有 abstract 方法。

21、写 clone()方法时，通常都有一行代码，是什么？

super.clone();

22、面向对象的特征有哪些方面

封装：

封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合” 。原则：把对同一事物进行操作的方法和相关的方法放在同一个类中，把方法和它操作的数据放在同一个类中。

抽象：

抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。使用抽象可以避免考虑一些与目标无关的细节。我对抽象的理解就是不要用显微镜去看一个事物的所有方面，这样涉及的内容就太多了，而是要善于划分问题的边界，当前系统需要什么，就只考虑什么。

继承：

继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

多态：

多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。

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

靠的是 父类或接口定义的引用变量 可以 指向子类或具体实现类的实例对象 

24、 abstract class和 interface有什么区别?

含有 abstract修饰符的 class即为抽象类， abstract类不能创建的实例对象。含有 abstract方法的类必须定义为 abstract class， abstract class类中的方法不必是抽象的。不能有抽象构造方法或抽象静态方法。 如果的子类没有实现抽象父类中的 所有抽象方法 ，那么子类也必须定义为 abstract类型。

接口（ interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。 接口 中的方法 定义 默认为public abstract 类型 ，接口中的 成员变量类型 默认为 public static final。

下面比较一下两者的语法 区别：

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有普通成员变量，接口中没有普通成员变量

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以是 public， protected和（默认类型 ,虽然

eclipse 下不报错，但应该也不行），但接口中的 抽象方法只能是 public 类型的，并且默认即为 public abstract类 型。

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是 public static final类型，并且默认即为 public static final类型。

7. 一个类可以实现多个接口，但只能继承一个抽象类。

25、 abstract的method 是否可同时是static, 是否可同时是native ，是否可同时是synchronized?

abstract 的method 不可以是 static的，因为抽象的方法是要被子类实现的，

native 方法表示该方法要用另外一种依赖平台的编程语言实现的，不存在着被子类实现的问题，所以，它也不能是抽象的，不能与 abstract混用。

关于 synchronized与 abstract合用的问题， synchronized应该是作用在一个具体的方法上才有意义。方法上的 synchronized同步所使用的同步锁对象是 this，而抽象方法上无法确定 this是什么。

26、什么是内部类？ Static Nested Class和 Inner Class的不同。

内部类就是在一个类的内部定义的类，内部类中不能定义静态成员 内部类可以直接访问外部类中的成员变量

static Nested Class能访问外部类的非 static成员变量 (不能直接访问，需要创建外部类实例才能访问非静态变量 )

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

完全可以。如果不是静态内部类，那没有什么限制！

如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，

28、 Anonymous Inner Class (匿名内部类 )是否可以 extends(继承)其它类，是否可以 implements(实现 )interface(接口)?

可以继承其他类或实现其他接口。不仅是可以，而是必须 !

29、 super.getClass()方法调用

在 test方法中，直接调用 getClass().getName() 方法，返回的是 Test类名

如果想得到父类的名称，应该用如下代码：

getClass().getSuperClass().getName();

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

基本数据类型包括 byte、 int、 char、 long、 float、 double、 boolean和 short。

31、 String s = "Hello";s = s + " world!";这两行代码执行后，原始的 String对象中的内容到底变了没有？

没有。 因为String 被设计成不可变 (immutable) 类，所以它的所有对象都是不可变对象。

32、是否可以继承 String类?

String 类是final 类故不可以继承。

33、 __________ String s = new String("xyz");创建了几个 String Object?二者之间有什么区别？

两个或一个，” xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量” xyz”不管出现多少遍，都是缓冲区中的那一个。 New String每写一遍，就创建一个新的对象，它一句那个常量” xyz”对象的内容来创建出一个新 String对象。如果以前就用过’ xyz’，这句代表就不会创建” xyz”自己了，直接从缓冲区拿。

34、 String和StringBuffer 的区别

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

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

35、如何把一段逗号分割的字符串转换成一个数组 ?

 用正则表达式，代码大概为： String [] result = orgStr.split( “, ”);

36、数组有没有 length()这个方法 ? String有没有length() 这个方法？

数组没有 length() 这个方法，有 length的属性。 String 有有length() 这个方法。

37、下面这条语句一共创建了多少个对象： String s="a"+"b"+"c"+"d";

javac编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。

 只创建了一个 String 对象。

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

也许你的答案是在 return 之前，

finally中的代码比 return 和break 语句后执行

40、 final, finally, finalize的区别。

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

内部类要访问局部变量，局部变量必须定义成 final类型，例如，一段代码……

finally 是异常处理语句结构的一部分，表示总是执行。

finalize 是Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。 JVM不保证此方法总被调用

41、运行时异常与一般异常有何异同？

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。 java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

42、 error和exception 有什么区别?

error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。 exception表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

43、 Java中的异常处理机制的简单原理和应用。

异常是指 java 程序运行时（非编译）所发生的非正常情况或错误 

Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，

数组脚本越界（ArrayIndexOutOfBoundsException ），空指针异常（ NullPointerException）、类转换异常（ ClassCastException）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，

就按照三个级别去思考：虚拟机必须宕机的错误，程序可以死掉也可以不死掉的错误，程序不应该死掉的错误；

44、请写出你最常见到的 5个runtime exception 。

它们都是 RuntimeException的子类，在 jdk doc中查 RuntimeException类，就可以看到其所有的子类列表，也就是看到了所有的系统异常。我比较有印象的系统异常有： NullPointerException、 ArrayIndexOutOfBoundsException 、ClassCastException 。

45、 JAVA语言如何进行异常处理，关键字： throws,throw,try,catch,finally分别代表什么意义？在 try块中可以抛出异常吗？

throws捕获并向外抛出异常

throw抛出异常

try catch是内部捕获异常并做自定义处理

finally是无论是否有异常都会被处理的语句，除非在 finally前存在被执行的 System.exit(int i)时除外

46、 java中有几种方法可以实现一个线程？用什么关键字修饰同步方法 ? stop()和suspend()方法为何不推荐使用？

有两种实现方法，分别使用 new Thread()和 new Thread(runnable)形式，第一种直接调用 thread的 run方法，所以，我们往往使用 Thread子类，即 new SubThread()。第二种调用

runnable

的 run方法。

有两种实现方法， 分别是继承 Thread 类与实现Runnable 接口

用 synchronized关键字修饰同步方法

反对使用 stop() ，是因为它不安全 。它会解除由线程获取的所有锁定， suspend() 方法容易发生死锁 。

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

 sleep是线程类（ Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用 sleep不会释放对象锁。 wait是 Object类的方法，对此对象调用 wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出 notify方法（或 notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

48、同步和异步有何异同，在什么情况下分别使用他们？举例说明。

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。

当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程， 在很多情况下采用异步途径往往更有效率。

50、多线程有几种实现方法 ?同步有几种实现方法 ?

多线程有两种实现方法，分别是继承 Thread 类与实现Runnable 接口

同步的实现方面有两种，分别是 synchronized,wait 与notify

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

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

notify(): 唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由 JVM确定唤醒哪个线程，而且不是按优先级。

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

51、启动一个线程是用 run()还是 start()? .

启动一个线程是调用 start()方法，使线程就绪状态，以后可以被调度为运行状态，一个线程必须关联一些具体的执行代码， run()方法是该线程所关联的执行代码。

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

1. 其他方法前是否加了 synchronized关键字，如果没加，则能。

2. 如果这个方法内部调用了 wait，则可以进入其他 synchronized方法。

3. 如果其他个方法都加了 synchronized关键字，并且内部没有调用 wait，则不能。

4. 如果其他方法是static ，它用的同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是 this。

53、线程的基本概念、线程的基本状态以及状态之间的关系

一个程序中可以有多条执行线索同时执行，一个线程就是程序中的一条执行线索，每个线程上都关联有要执行的代码，即可以有多段程序代码同时运行，每个程序至少都有一个线程，即 main方法执行的那个线程。

状态：就绪，运行， synchronize阻塞， wait和 sleep挂起，结束。 wait必须在 synchronized内部调用。

调用线程的 start方法后线程进入就绪状态，线程调度系统将就绪状态的线程转为运行状态，遇到 synchronized语句时，由运行状态转为阻塞，当 synchronized获得锁后，由阻塞转为运行，在这种情况可以调用 wait方法转为挂起状态，当线程关联的代码执行完后，线程变为结束状态。

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

主要相同点： Lock能完成 synchronized所实现的所有功能

主要不同点： Lock有比 synchronized更精确的线程语义和更好的性能。 synchronized会自动释放锁，而 Lock一定要求程序员手工释放，并且必须在 finally从句中释放。 Lock还有更强大的功能，

57、介绍 Collection框架的结构

答：随意发挥题，天南海北谁便谈，只要让别觉得你知识渊博，理解透彻即可。

58、 Collection框架中实现比较要实现什么接口

comparable/comparator

59、 ArrayList和Vector 的区别

这两个类都实现了 List接口（ List接口继承了 Collection接口），他们都是有序集合，并且其中的数据是允许重复的 

（1）同步性：Vector 是线程安全的，

2）数据增长： Vector增长原来的一倍， ArrayList增加原来的 0.5倍。

60、 HashMap和Hashtable 的区别

HashMap 是Hashtable 的轻量级实现（非线程安全的实现），他们都完成了 Map接口，

一 .历史原因 :Hashtable是基于陈旧的 Dictionary类的， HashMap是 Java 1.2引进的 Map接口的一个实现 二 .同步性 :Hashtable是线程安全的，也就是说是同步的，而 HashMap是线程序不安全的，不是同步的 三 .值：只有 HashMap可以让你将空值作为一个表的条目的 key或 value

61、 List和 Map 区别?

一个是存储单列数据的集合，另一个是存储键和值这样的双列数据的集合， List中存储的数据是有顺序，并且允许重复； Map中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的。

62、 List, Set, Map是否继承自 Collection接口 ?

List ，Set 是，Map 不是

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

List 以特定次序来持有元素，可有重复元素。 Set无法拥有重复元素 ,内部排序。 Map保存 key-value值， value可多值。

64、说出 ArrayList,Vector, LinkedList的存储性能和特性

ArrayList 和Vector 都是使用数组方式存储数据，索引数据快而插入数据慢， Vector由于使用了 synchronized方法（线程安全），通常性能上较 ArrayList差，而 LinkedList使用双向链表实现存储，所以插入速度较快。

LinkedList 也是线程不安全的， LinkedList提供了一些方法，使得 LinkedList可以被当作堆栈和队列来使用。

65、去掉一个 Vector集合中重复的元素

Vector newVector = new Vector();

For (int i=0;i<vector.size();i++)

{

Object obj = vector.get(i);

if(!newVector.contains(obj);

newVector.add(obj);

}

还有一种简单的方式， HashSet set = new HashSet(vector);

66、 Collection和 Collections 的区别。

Collection 是集合类的上级接口，继承与他的接口主要有 Set和 List.

Collections 是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

67、 Set里的元素是不能重复的，那么用什么方法来区分重复与否呢 ?是用== 还是equals()?它们有何区别 ?

Set 里的元素是不能重复的，元素重复与否是使用 equals()方法进行判断的。

68、你所知道的集合类都有哪些？主要方法？

最常用的集合类是 List 和 Map。 List的具体实现包括 ArrayList和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List适用于按数值索引访问元素的情形。

Map 提供了一个更通用的元素存储方法。 Map集合类用于存储元素对（称作 "键 "和 "值 "），其中每个键映射到一个值。

它们都有增删改查的方法， set，大概的方法是 add,remove, contains；对于 map，大概的方法就是 put,remove， contains等， List类会有 get(int index)这样的方法，因为它可以按顺序取元素，而 set类中没有 get(int index)这样的方法。 List和 set都可以迭代出所有元素，迭代时先要得到一个 iterator对象，所以， set和 list类都有一个 iterator方法，用于返回那个 iterator对象。 map可以返回三个集合，一个是返回所有的 key的集合，另外一个返回的是所有 value的集合，再一个返回的 key和 value组合成的 EntrySet对象的集合， map也有 get方法，参数是 key，返回值是 key对应的 value。

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

对。

如果对象要保存在 HashSet或 HashMap中，它们的 equals相等，那么，它们的 hashcode值就必须相等。

如果不是要保存在 HashSet或 HashMap，则与 hashcode没有什么关系了，这时候 hashcode不等是可以的，

70、 TreeSet里面放对象，如果同时放入了父类和子类的实例对象，那比较时使用的是父类的 compareTo方法，还是使用的子类的 compareTo方法，还是抛异常！

当前的 add方法放入的是哪个对象，就调用哪个对象的 compareTo方法

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

常用的类： BufferedReader BufferedWriter FileReader FileWirter String Integer java.util.Date ，System ，Class ，List,HashMap

常用的包： java.lang java.io java.util java.sql javax.servlet, org.apache.strtuts.action, org.hibernate

常用的接口： Remote List Map Document NodeList, Servlet, HttpServletRequest, HttpServletResponse, Transaction(Hibernate)、 Session(Hibernate),HttpSession

72、 java中有几种类型的流？ JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？

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

73、字节流与字符流的区别

字符流是字节流的包装，字符流则是直接接受字符串，它内部将串转成字节，再写入底层设备，

74、什么是 java序列化，如何实现 java序列化？或者请解释 Serializable接口的作用。

将一个 java对象变成字节流的形式传出去或者从一个字节流中恢复成一个 java象，

需要被序列化的类必须实现 Serializable接口，该接口是一个 mini接口，其中没有需要实现的方法， implementsSerializable 只是为了标注该对象是可被序列化的。

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

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

76、 heap和stack 有什么区别。

java 的内存分为两类，一类是栈内存，一类是堆内存。栈内存是指程序进入一个方法时，会为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。

堆是与栈作用不同的内存，一般用于存放不放在当前方法栈中的那些数据，例如，使用 new创建的对象都放在堆里，所以，它不会随方法的结束而消失。方法中的局部变量使用 final修饰后，放在堆中，而不是栈中。

77、 GC是什么 ?为什么要有GC?

GC是垃圾收集的意思（ Gabage Collection） ,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃， Java提供的 GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的， Java语言没有提供释放已分配内存的显示操作方法。

78、垃圾回收的优点和原理。并考虑 2种回收机制。

Java 语言中一个显著的特点就是引入了垃圾回收机制，使 c++程序员最头疼的内存管理的问题迎刃而解，它使得 Java程序员在编写程序的时候不再需要考虑内存管理垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。

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

回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

79、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？

对于 GC来说，当程序员创建对象时， GC就开始监控这个对象的地址、大小以及使用情况。通常， GC采用有向图的方式记录和管理堆 (heap)中的所有对象。通过这种方式确定哪些对

象是

" 可达的" ，哪些对象是 "不可达的 "。当 GC确定一些对象为 "不可达 "时， GC就有责任回收这些内存空间。可以。程序员可以手动执行 System.gc()，通知 GC运行，但是 Java语言规范并不保证 GC一定会执行。

80、什么时候用 assert。

assertion( 断言) 在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中， assertion就是在程序中的一条语句，它对一个 boolean表达式进行检查，一个正确程序必须保证这个 boolean表达式的值为 true；如果该值为 false，说明程序已经处于不正确的状态下， assert将给出警告或退出。一般来说， assertion用于保证程序最基本、关键的正确性。 assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后， assertion检查通常是关闭的。

81、 java中会存在内存泄漏吗，请简单描述。

所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。 java中有垃圾回收机制，它可以保证一对象不再被引用的时候，即对象编程了孤儿的时候，对象将自动被垃圾回收器从内存中清除掉。由于 Java使用有向图的方式进行垃圾回收管理，可以消除引用循环的问题，

java 中的内存泄露的情况：程序员可能创建了一个对象，以后一直不再使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是 java中可能出现内存泄露的情况，例如，缓存系统，我们加载了一个对象放在缓存中 

82、能不能自己写个类，也叫 java.lang.String？

可以，但在应用的时候，需要用自己的类加载器去加载，否则，系统的类加载器永远只是去加载 jre.jar包中的那个 java.lang.String。

83. Java代码查错

1. abstract class Name { private String name; public abstract boolean isStupidName(String name) {} } 大侠们，这有何错误 ? 答案 : 错。 abstract method必须以分号结尾，且不带花括号。 2. public class Something { void doSomething () { private String s = ""; int l = s.length(); } } 有错吗 ? 答案 : 错。局部变量前不能放置任何访问修饰符 (private， public，和 protected)。 final可以用来修饰局部变量 (final如同 abstract和 strictfp，都是非访问修饰符， strictfp只能修饰 class和 method而非 variable)。 3. abstract class Something { private abstract String doSomething (); } 这好像没什么错吧 ? 答案 : 错。 abstract的 methods不能以 private修饰。 abstract的 methods就是让子类 implement(实现 )具体细节的，怎么可以用 private把 abstract method封锁起来呢 ? (同理， abstract method前不能加 final)。 4. public class Something { public int addOne(final int x) {

return ++x; } }

这个比较明显。 答案 : 错。 int x被修饰成 final，意味着 x不能在 addOne method中被修改。 5. public class Something { public static void main(String[] args) { Other o = new Other(); new Something().addOne(o); } public void addOne(final Other o) { o.i++; } } class Other { public int i; } 和上面的很相似，都是关于 final的问题，这有错吗 ? 答案 : 正确。在 addOne method中，参数 o被修饰成 final。如果在 addOne method里我们修改了 o的 reference (比如 : o = new Other();)，那么如同上例这题也是错的。但这里修改的是 o的 member vairable (成员变量 )，而 o的 reference并没有改变。 6. class Something { int i; public void doSomething() { System.out.println("i = "+ i); } } 有什么错呢 ? 看不出来啊。 答案 : 正确。输出的是 "i = 0"。 int i属於 instant variable (实例变量，或叫成员变量 )。 instant variable有 default value。 int的 default value是 0。 7.

class Something { final int i; public void doSomething() { System.out.println("i = "+ i); } }

和上面一题只有一个地方不同，就是多了一个 final。这难道就错了吗 ? 答案 : 错。 final int i是个 final的 instant variable (实例变量，或叫成员变量 )。 final的 instant variable没有 default value，必须在 constructor (构造器 )结束之前被赋予一个明确的值。可以修改为 "final int i =0;" 。 8. public class Something { public static void main(String[] args) { Something s = new Something(); System.out.println("s.doSomething() returns " + doSomething()); } public String doSomething() { return "Do something ..."; } } 看上去很完美。 答案 : 错。看上去在 main里 call doSomething没有什么问题，毕竟两个 methods都在同一个 class里。但仔细看， main是 static的。 static method不能直接 call non-staticmethods。可改成 "System.out.println("s.doSomething()returns " + s.doSomething());"。同理， static method不能访问 non-static instant variable 。 9. 此处，Something 类的文件名叫 OtherThing.java class Something { private static void main(String[] something_to_do){ System.out.println("Dosomething ..."); } } 这个好像很明显。 答案 : 正确。从来没有人说过 Java的 Class名字必须和其文件名相同。但 public class的名字必须和文件名相同。

10

． interface A{ int x = 0; } class B{ int x =1; } class C extends B implements A { public void pX(){ System.out.println(x); } public static void main(String[] args) { new C().pX(); } } 答案：错误。在编译时会发生错误 (错误描述不同的 JVM有不同的信息，意思就是未明确的 x调用，两个 x都匹配（就象在同时 import java.util和 java.sql两个包时直接声明 Date一样）。对于父类的变量 ,可以用 super.x来明确，而接口的属性默认隐含为 public staticfinal. 所以可以通过A.x 来明确。 11. interface Playable { void play(); } interface Bounceable { void play(); } interface Rollable extends Playable, Bounceable { Ball ball = new Ball("PingPang"); } class Ball implements Rollable { private String name; public String getName() { return name; } public Ball(String name) {

this.name =name; } public void play() { ball = newBall("Football"); System.out.println(ball.getName()); } }

这个错误不容易发现。 答案 : 错。 "interfaceRollable extends Playable, Bounceable" 没有问题。interface 可继承多个 interfaces，所以这里没错。问题出在 interface Rollable里的 "Ball ball =new Ball("PingPang");" 。任何在interface 里声明的 interface variable (接口变量，也可称成员变量 )，默认为 public static final。也就是说 "Ball ball = new Ball("PingPang");"实际上是 "public staticfinal Ball ball = new Ball("PingPang");" 。在Ball 类的Play() 方法中， "ball = newBall("Football");" 改变了ball 的reference ，而这里的 ball来自 Rollable interface， Rollable interface里的 ball是 public static final的， final的 object是不能被改变 reference的。因此编译器将在 "ball = newBall("Football");"这里显示有错。

二. 算法与编程

1、编写一个程序，将 a.txt文件中的单词与 b.txt文件中的单词交替合并到 c.txt文件中， a.txt文件中的单词用回车符分隔， b.txt文件中用回车或空格进行分隔。

答：

packagecn.itcast;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

public class MainClass{

public static voidmain(String[] args) throws Exception{

FileManager a= new FileManager("a.txt",new char[]{'\n'});

FileManager b= new FileManager("b.txt",new char[]{'\n',' '});

FileWriter c= new FileWriter("c.txt");

String aWord= null;

String bWord= null;

while((aWord= a.nextWord()) !=null ){

c.write(aWord+ "\n");

bWord= b.nextWord();

if(bWord!= null)

c.write(bWord+ "\n");

}

while((bWord= b.nextWord()) != null){

c.write(bWord+ "\n");

}

c.close();

}

}

class FileManager{

String[] words =null;

int pos = 0;

publicFileManager(String filename,char[] seperators) throws Exception{

File f = newFile(filename);

FileReaderreader = new FileReader(f);

char[] buf =new char[(int)f.length()];

int len =reader.read(buf);

Stringresults = new String(buf,0,len);

String regex= null;

if(seperators.length>1 ){

regex= "" + seperators[0] + "|" + seperators[1];

}else{

regex= "" + seperators[0];

}

words =results.split(regex);

}

public StringnextWord(){

if(pos ==words.length)

returnnull;

returnwords[pos++];

}

}

2、编写一个程序，将 d:\java目录下的所有 .java文件复制到 d:\jad目录下，并将原来文件的扩展名从 .java改为 .jad。

（大家正在做上面这道题，网上迟到的朋友也请做做这道题，找工作必须能编写这些简单问题的代码！）

答： listFiles方法接受一个 FileFilter对象，这个 FileFilter对象就是过虑的策略对象，不同的人提供不同的 FileFilter实现，即提供了不同的过滤策略。

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FilenameFilter;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

public class Jad2Java {

public static voidmain(String[] args) throws Exception {

File srcDir =new File("java");

if(!(srcDir.exists()&& srcDir.isDirectory()))

thrownew Exception(" 目录不存在");

File[] files= srcDir.listFiles(

newFilenameFilter(){

publicboolean accept(File dir, String name) {

returnname.endsWith(".java");

}

}

);

System.out.println(files.length);

File destDir= new File("jad");

if(!destDir.exists())destDir.mkdir();

for(File f:files){

FileInputStream fis = new FileInputStream(f);

StringdestFileName = f.getName().replaceAll("\\.java$", ".jad");

FileOutputStreamfos = new FileOutputStream(new File(destDir,destFileName));

copy(fis,fos);

fis.close();

fos.close();

}

}

private static voidcopy(InputStream ips,OutputStream ops) throws Exception{

int len = 0;

byte[] buf =new byte[1024];

while((len =ips.read(buf)) != -1){

ops.write(buf,0,len);

}

}

}

由本题总结的思想及策略模式的解析：

1.

class jad2java{

1. 得到某个目录下的所有的 java文件集合

1.1 得到目录 File srcDir = newFile("d:\\java");

1.2 得到目录下的所有 java文件： File[] files =srcDir.listFiles(new MyFileFilter());

1.3 只想得到.java 的文件： class MyFileFilterimplememyts FileFilter{

publicboolean accept(File pathname){

returnpathname.getName().endsWith(".java")

}

}

2.将每个文件复制到另外一个目录，并改扩展名

2.1 得到目标目录，如果目标目录不存在，则创建之

2.2 根据源文件名得到目标文件名，注意要用正则表达式，注意 .的转义。

2.3 根据表示目录的File 和目标文件名的字符串，得到表示目标文件的 File。

//要在硬盘中准确地创建出一个文件，需要知道文件名和文件的目录。

2.4 将源文件的流拷贝成目标文件流，拷贝方法独立成为一个方法，方法的参数采用抽象流的形式。

//方法接受的参数类型尽量面向父类，越抽象越好，这样适应面更宽广。

}

分析 listFiles方法内部的策略模式实现原理

File[] listFiles(FileFilter filter){

File[] files =listFiles();

//ArraylistacceptedFilesList = new ArrayList();

File[] acceptedFiles= new File[files.length];

int pos = 0;

for(File file:files){

booleanaccepted = filter.accept(file);

if(accepted){

//acceptedFilesList.add(file);

acceptedFiles[pos++]= file;

}

}

Arrays.copyOf(acceptedFiles,pos);

//return(File[])accpetedFilesList.toArray();

}

3、编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串，但要保证汉字不被截取半个，如 “我 ABC” ，4，应该截取 “我 AB” ，输入“ 我ABC汉 DEF” ，6，应该输出 “我 ABC” ，而不是“ 我ABC+汉的半个 ”。

答：

首先要了解中文字符有多种编码及各种编码的特征。

假设 n为要截取的字节数。

public static voidmain(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 staticint trimGBK(byte[] buf,int n){

int num = 0;

booleanbChineseFirstHalf = false;

for(inti=0;i<n;i++)

{

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

bChineseFirstHalf= true;

}else{

num++;

bChineseFirstHalf= false;

}

}

return num;

}

4、有一个字符串，其中包含中文字符、英文字符和数字字符，请统计和打印出各个字符的个数。

答：哈哈，其实包含中文字符、英文字符、数字字符原来是出题者放的烟雾弹。

String content = “中国aadf 的111 萨bbb 菲的zz 萨菲” ;

HashMap map = new HashMap();

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

{

char c =content.charAt(i);

Integer num =map.get(c);

if(num == null)

num = 1;

else

num = num +1;

map.put(c,num);

}

for(Map.EntrySet entry : map)

{

system.out.println(entry.getkey()+ “: ” + entry.getValue());

}

估计是当初面试的那个学员表述不清楚，问题很可能是：

如果一串字符如 "aaaabbc中国 1512"要分别统计英文字符的数量，中文字符的数量，和数字字符的数量，假设字符中没有中文字符、英文字符、数字字符之外的其他特殊字符。

int engishCount;

int chineseCount;

int digitCount;

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

{

charch = str.charAt(i);

if(ch>= ’0 ’&& ch<= ’9 ’)

{

digitCount++

}

elseif((ch>= ’a ’&& ch<= ’z ’) || (ch>= ’A ’ && ch<= ’Z ’))

{

engishCount++;

}

else

{

chineseCount++;

}

}

System.out.println( ……………);

5、说明生活中遇到的二叉树，用 java实现二叉树

这是组合设计模式。

我有很多个 (假设 10万个 )数据要保存起来，以后还需要从保存的这些数据中检索是否存在某个数据，（我想说出二叉树的好处，该怎么说呢？那就是说别人的缺点），假如存在数组中，

那么，碰巧要找的数字位于

99999 那个地方，那查找的速度将很慢，因为要从第 1个依次往后取，取出来后进行比较。平衡二叉树（构建平衡二叉树需要先排序，我们这里就不作考虑了）可以很好地解决这个问题，但二叉树的遍历（前序，中序，后序）效率要比数组低很多，原理如下图：

代码如下：

package com.huawei.interview;

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

return right.find(value);

} else

{

if (left ==null ) returnfalse;

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

}

}

----------------- 又一次临场写的代码 ---------------------------

importjava.util.Arrays;

importjava.util.Iterator;

public class Node{

private Node left;

private Node right;

private int value;

//private int num;

public Node(int value){

this.value = value;

}

public void add(int value){

if(value > this.value)

{

if(right != null)

right.add(value);

else

{

Node node = new Node(value);

right = node;

}

}

else{

if(left != null)

left.add(value);

else

{

Node node = new Node(value);

left = node;

}

}

}

public boolean find(int value){

if(value == this.value) return true;

else if(value > this.value){

if(right == null) return false;

else return right.find(value);

}else{

if(left == null) return false;

else return left.find(value);

}

}

public void display(){

System.out.println(value);

if(left != null) left.display();

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

}

/*public Iterator iterator(){

}*/

public static void main(String[] args){

int[] values = new int[8];

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

int num = (int)(Math.random() * 15);

//System.out.println(num);

//if(Arrays.binarySearch(values,num)<0)

if(!contains(values,num))

values[i] = num;

else

i--;

}

System.out.println(Arrays.toString(values));

Node root = new Node(values[0]);

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

root.add(values[i]);

}

System.out.println(root.find(13));

root.display();

}

public static boolean contains(int [] arr,int value){

int i = 0;

for(;i<arr.length;i++){

if(arr[i] == value) return true;

}

return false;

}

}

6、从类似如下的文本文件中读取出所有的姓名，并打印出重复的姓名和重复的次数，并按重复次数排序：

1,张三 ,28

2,李四 ,35

3,张三 ,28

4,王五 ,35

5,张三 ,28

6,李四 ,35

7,赵六 ,28

8,田七 ,35

程序代码如下（答题要博得用人单位的喜欢，包名用该公司，面试前就提前查好该公司的网址，如果查不到，现场问也是可以的。还要加上实现思路的注释）：

package com.huawei.interview;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.TreeSet;

publicclass GetNameTest {

/**

* @paramargs

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

//InputStream ips =GetNameTest.class.getResourceAsStream("/com/huawei/interview/info.txt");

//用上一行注释的代码和下一行的代码都可以，因为 info.txt与 GetNameTest类在同一包下面，所以，可以用下面的相对路径形式

Map results = new HashMap();

InputStream ips = GetNameTest. class.getResourceAsStream("info.txt");

BufferedReader in = newBufferedReader( new InputStreamReader(ips));

String line = null;

try {

while ((line=in.readLine())!= null)

{

dealLine(line,results);

}

sortResults(results);

} catch (IOException e) {

// TODO Auto-generated catchblock

e.printStackTrace();

}

}

static class User

{

public String name;

public Integer value;

public User(String name,Integervalue)

{

this .name = name;

this .value = value;

}

@Override

public boolean equals(Object obj) {

// TODO Auto-generated methodstub

//下面的代码没有执行，说明往 treeset中增加数据时，不会使用到 equals方法。

boolean result =super .equals(obj);

System.out .println(result);

return result;

}

}

private static void sortResults(Map results) {

// TODO Auto-generated method stub

TreeSet sortedResults = newTreeSet(

new Comparator(){

public int compare(Object o1, Object o2) {

// TODOAuto-generated method stub

User user1 = (User)o1;

User user2 = (User)o2;

/*如果 compareTo返回结果 0，则认为两个对象相等，新的对象不会增加到集合中去

* 所以，不能直接用下面的代码，否则，那些个数相同的其他姓名就打印不出来。

* */

//returnuser1.value-user2.value;

//returnuser1.value<user2.value?-1:user1.value==user2.value?0:1;

if (user1.value<user2.value)

{

return -1;

} else if(user1.value>user2.value)

{

return 1;

} else

{

return user1.name.compareTo(user2.name);

}

}

}

);

Iterator iterator =results.keySet().iterator();

while (iterator.hasNext())

{

String name = (String)iterator.next();

Integer value =(Integer)results.get(name);

if (value > 1)

{

sortedResults.add( newUser(name,value));

}

}

printResults(sortedResults);

}

private static void printResults(TreeSet sortedResults)

{

Iterator iterator = sortedResults.iterator();

while (iterator.hasNext())

{

User user = (User)iterator.next();

System.out .println(user.name +":" + user.value);

}

}

public static void dealLine(String line,Map map)

{

if (!"".equals(line.trim()))

{

String [] results =line.split(",");

if (results.length == 3)

{

String name = results[1];

Integer value =(Integer)map.get(name);

if (value ==null )value = 0;

map.put(name,value + 1);

}

}

}

}

7、写一个 Singleton出来。

第一种：饱汉模式

public classSingleTon {

private SingleTon(){

}

//实例化放在静态代码块里可提高程序的执行效率，但也可能更占用空间

private final static SingleTon instance =new SingleTon();

public static SingleTon getInstance(){

return instance;

}

}

第二种：饥汉模式

public classSingleTon {

private SingleTon(){}

private static instance = null;//newSingleTon();

public static synchronized SingleTongetInstance(){

if(instance == null)

instance = new SingleTon();

return instance;

}

}

第三种：用枚举

public enum SingleTon{

ONE;

}

第三：更实际的应用（在什么情况用单例）

public classSequenceGenerator{

//下面是该类自身的业务功能代码

private int count = 0;

public synchronized int getSequence(){

++count;

}

//下面是把该类变成单例的代码

private SequenceGenerator(){}

private final static instance = newSequenceGenerator();

public static SingleTon getInstance(){

return instance;

}

}

第四：

public class MemoryDao

{

private HashMap map = new HashMap();

publicvoid add(Student stu1){

map.put(SequenceGenerator.getInstance().getSequence(),stu1);

}

//把 MemoryDao变成单例

}

Singleton 模式主要作用是保证在 Java应用程序中，一个类 Class只有一个实例存在。

一般 Singleton模式通常有几种种形式 :

第一种形式 : 定义一个类，它的构造函数为 private的，它有一个 static的 private的该类变量，在类初始化时实例话，通过一个 public的 getInstance方法获取对它的引用 ,继而调用其中的方法。

public class Singleton {

private Singleton(){}

//在自己内部定义自己一个实例，是不是很奇怪？

//注意这是 private只供内部调用

private staticSingleton instance = new Singleton();

//这里提供了一个供外部访问本 class的静态方法，可以直接访问

public staticSingleton getInstance() {

return instance;

}

}

第二种形式 :

public class Singleton {

private static Singleton instance = null;

public static synchronized Singleton getInstance() {

//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次

//使用时生成实例，提高了效率！

if (instance==null)

instance ＝new Singleton();

return instance;

}

}

其他形式 :

定义一个类，它的构造函数为 private的，所有方法为 static的。

一般认为第一种形式要更加安全些

8、递归算法题 1

一个整数，大于 0，不用循环和本地变量，按照 n， 2n， 4n， 8n的顺序递增，当值大于 5000时，把值按照指定顺序输出来。 例： n=1237 则输出为： 1237， 2474， 4948， 9896， 9896， 4948， 2474， 1237，

提示：写程序时，先致谢按递增方式的代码，写好递增的以后，再增加考虑递减部分。

public static void doubleNum(int n)

{

System.out.println(n);

if(n<=5000)

doubleNum(n*2);

System.out.println(n);

}

Gaibaota(N) = Gaibaota(N-1) + n

9、递归算法题 2

第 1个人 10，第 2个比第 1个人大 2岁，依次递推，请用递归方式计算出第 8个人多大？

package cn.itcast;

import java.util.Date;

publicclass A1 {

public static void main(String [] args)

{

System.out .println(computeAge(8));

}

public static int computeAge(int n)

{

if (n==1)return 10;

return computeAge(n-1) + 2;

}

}

public static void toBinary(int n,StringBuffer result)

{

if (n/2 != 0)

toBinary(n/2,result);

result.append(n%2);

}

10、排序都有哪几种方法？请列举。用 JAVA实现一个快速排序。

本人只研究过冒泡排序、选择排序和快速排序，下面是快速排序的代码：

public class QuickSort {

/** *

快速排序 * @param strDate * @param left * @param right */ public void quickSort(String[] strDate,int left,int right){ String middle,tempDate; int i,j; i=left; j=right; middle=strDate[(i+j)/2]; do{ while(strDate[i].compareTo(middle)<0&& i<right) i++; //找出左边比中间值大的数 while(strDate[j].compareTo(middle)>0&& j>left) j--; // 找出右边比中间值小的数 if(i<=j){ // 将左边大的数和右边小的数进行替换 tempDate=strDate[i]; strDate[i]=strDate[j]; strDate[j]=tempDate; i++; j--; } }while(i<=j); //当两者交错时停止 if(i<right){ quickSort(strDate,i,right);// 从 } if(j>left){ quickSort(strDate,left,j); } } /** * @param args

*/ public static void main(String[] args){ String[] strVoid=newString[]{"11","66","22","0","55","22","0","32"}; QuickSort sort=new QuickSort(); sort.quickSort(strVoid,0,strVoid.length-1); for(int i=0;i<strVoid.length;i++){ System.out.println(strVoid[i]+" "); } } }

11、有数组 a[n]，用 java代码将数组元素顺序颠倒

//用下面的也可以

//for(inti=0,int j=a.length-1;i<j;i++,j--) 是否等效于 for(int i=0;i<a.length/2;i++)呢？

importjava.util.Arrays;

public classSwapDemo{

public static void main(String[] args){

int [] a = new int[]{

(int)(Math.random() *1000),

(int)(Math.random() * 1000),

(int)(Math.random() *1000),

(int)(Math.random() *1000),

(int)(Math.random() * 1000)

};

System.out.println(a);

System.out.println(Arrays.toString(a));

swap(a);

System.out.println(Arrays.toString(a));

}

public static void swap(int a[]){

int len = a.length;

for(int i=0;i<len/2;i++){

int tmp = a[i];

a[i] = a[len-1-i];

a[len-1-i] = tmp;

}

}

}

12．金额转换，阿拉伯数字的金额转换成中国传统的形式如：（￥ 1011）－ >（一千零一拾一元整）输出。

去零的代码：

returnsb.reverse().toString().replaceAll(" 零[ 拾佰仟 ]","零 ").replaceAll(" 零+ 万"," 万").replaceAll(" 零+ 元"," 元").replaceAll(" 零+"," 零");

public class RenMingBi {

/**

* @param args add by zxx ,Nov 29, 2008

*/

private static finalchar[] data = new char[]{

'零 ','壹 ','贰 ','叁 ','肆 ','伍 ','陆 ','柒 ','捌 ','玖 '

};

private static finalchar[] units = new char[]{

'元 ','拾 ','佰 ','仟 ','万 ','拾 ','佰 ','仟 ','亿 '

};

public static voidmain(String[] args) {

// TODOAuto-generated method stub

System.out.println(

convert(135689123));

}

public static Stringconvert(int money)

{

StringBuffersbf = new StringBuffer();

int unit = 0;

while(money!=0)

{

sbf.insert(0,units[unit++]);

intnumber = money%10;

sbf.insert(0,data[number]);

money/= 10;

}

returnsbf.toString();

}

}

三. html&JavaScript&ajax 部分

1. 判断第二个日期比第一个日期大

如何用脚本判断用户输入的的字符串是下面的时间格式 2004-11-21必须要保证用户的输入是此格式，并且是时间，比如说月份不大于 12等等，另外我需要用户输入两个，并且后一个要比前一个晚，只允许用 JAVASCRIPT，请详细帮助作答， ,

//这里可用正则表达式判断提前判断一下格式，然后按下提取各时间字段内容

<script type="text/javascript">

window.onload =function()

{

//这么写是为了实现 js代码与 html代码的分离，当我修改 js时，不能影响 html代码。

document.getElementById("frm1").onsubmit=

function(){

vard1 = this.d1.value;

vard2 = this.d2.value;

if(!verifyDate(d1)) {alert(" 第一个日期格式不对 ");return false;}

if(!verifyDate(d2)) {alert(" 第二个日期格式不对 ");return false;}

if(!compareDate(d1,d2)){alert(" 第二个日期比第一日期小 ");return false;}

};

}

functioncompareDate(d1,d2)

{

var arrayD1= d1.split("-");

var date1 =new Date(arrayD1[0],arrayD1[1],arrayD1[2]);

var arrayD2= d2.split("-");

var date2 =new Date(arrayD2[0],arrayD2[1],arrayD2[2]);

if(date1> date2) return false;

return true;

}

functionverifyDate(d)

{

vardatePattern = /^\d{4}-(0?[1-9]|1[0-2])-(0?[1-9]|[1-2]\d|3[0-1])$/;

returndatePattern.test(d);

}

</script>

<form id="frm1" action="xxx.html">

<input type="text" name="d1" />

<input type="text" name="d2" />

<input type="submit"/>

</form>

2. 用 table显示 n条记录，每3 行换一次颜色，即 1，2， 3用红色字体， 4，5， 6用绿色字体， 7，8， 9用红颜色字体。

<body>

<table id="tbl">

<tr><td>1</td></tr>

<tr><td>2</td></tr>

<tr><td>3</td></tr>

<tr><td>4</td></tr>

<tr><td>5</td></tr>

<tr><td>6</td></tr>

<tr><td>7</td></tr>

<tr><td>8</td></tr>

<tr><td>9</td></tr>

<tr><td>10</td></tr>

</table>

</body>

<script type="text/javascript">

window.onload=function()

{

var tbl =document.getElementById("tbl");

rows =tbl.getElementsByTagName("tr");

for(i=0;i<rows.length;i++)

{

var j= parseInt(i/3);

if(j%2==0)rows[i].style.backgroundColor="#f00";

else rows[i].style.backgroundColor="#0f0";

}

}

</script>

3、 HTML的 form 提交之前如何验证数值文本框的内容全部为数字 ?否则的话提示用户并终止提交 ?

<form onsubmit= ’return chkForm(this) ’>

<input type="text" name="d1"/>

<input type="submit"/>

</form>

<script type= ”text/javascript ” />

function chkForm(this)

{

var value = thist.d1.value;

var len =value.length;

for(vari=0;i<len;i++)

{

if(value.charAt(i)>"9"|| value.charAt(i)<"0")

{

alert(" 含有非数字字符");

returnfalse;

}

}

return true;

}

</script>

4、请写出用于校验 HTML文本框中输入的内容全部为数字的 javascript代码

<input type="text" id="d1" onblur=" chkNumber(this)"/>

<script type= ”text/javascript ” />

function chkNumber(eleText)

{

var value =eleText.value;

var len =value.length;

for(vari=0;i<len;i++)

{

if(value.charAt(i)>"9"|| value.charAt(i)<"0")

{

alert(" 含有非数字字符");

eleText.focus();

break;

}

}

}

</script>

除了写完代码，还应该在网页上写出实验步骤和在代码中加入实现思路，让面试官一看就明白你的意图和检查你的结果。

5、说说你用过那些 ajax技术和框架，说说它们的区别

四. Java web 部分

1、 Tomcat的优化经验

答 :去掉对 web.xml的监视，把 jsp提前编辑成 Servlet。

有富余物理内存的情况，加大 tomcat使用的 jvm的内存

2、 HTTP请求的 GET与POST方式的区别

答 :servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由 javax.servlet.Servlet 接口的init,service 和destroy 方法表达。

3、解释一下什么是 servlet;

答 :servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由 javax.servlet.Servlet 接口的init,service 和destroy 方法表达。

4、说一说 Servlet的生命周期 ?

答 :servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由 javax.servlet.Servlet 接口的init,service 和destroy 方法表达。

Servlet 被服务器实例化后，容器运行其 init方法，请求到达时运行其 service方法， service方法自动派遣运行与请求对应的 doXXX方法（ doGet， doPost）等，当服务器决定将实例销毁的时候调用其 destroy方法。

web 容器加载servlet ，生命周期开始。通过调用 servlet的 init()方法进行 servlet的初始化。通过调用 service()方法实现，根据请求的不同调用不同的 do***()方法。结束服务， web容器调用 servlet的 destroy()方法。

5、 Servlet的基本架构

public class ServletName extends HttpServlet {

public void doPost(HttpServletRequest request,HttpServletResponse response) throws

ServletException, IOException {

}

public void doGet(HttpServletRequest request,HttpServletResponse response) throws

ServletException, IOException {

}

}

6、 SERVLET API中forward() 与redirect()的区别？

答 :前者仅是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址；后者则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。所以，前者更加高效，在前者可以满足需要时，尽量使用forward() 方法，并且，这样也有助于隐藏实际的链接。在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用

sendRedirect() 方法。

7、什么情况下调用 doGet()和doPost() ？

Jsp 页面中的FORM 标签里的 method属性为 get时调用 doGet()，为 post时调用 doPost()。

8、 Request对象的主要方法：

setAttribute(String name,Object) ：设置名字为name 的request 的参数值

getAttribute(String name) ：返回由name 指定的属性值

getAttributeNames() ：返回request 对象所有属性的名字集合，结果是一个枚举的实例

getCookies() ：返回客户端的所有 Cookie对象，结果是一个 Cookie数组

getCharacterEncoding() ：返回请求中的字符编码方式

getContentLength() ：返回请求的Body 的长度

getHeader(String name) ：获得HTTP 协议定义的文件头信息

getHeaders(String name) ：返回指定名字的 request Header的所有值，结果是一个枚举的实例

getHeaderNames() ：返回所以request Header 的名字，结果是一个枚举的实例

getInputStream() ：返回请求的输入流，用于获得请求中的数据

getMethod() ：获得客户端向服务器端传送数据的方法

getParameter(String name) ：获得客户端传送给服务器端的有 name指定的参数值

getParameterNames() ：获得客户端传送给服务器端的所有参数的名字，结果是一个枚举的实例

getParametervalues(String name) ：获得有name 指定的参数的所有值

getProtocol() ：获取客户端向服务器端传送数据所依据的协议名称

getQueryString() ：获得查询字符串

getRequestURI() ：获取发出请求字符串的客户端地址

getRemoteAddr() ：获取客户端的IP 地址

getRemoteHost() ：获取客户端的名字

getSession([Boolean create]) ：返回和请求相关 Session

getServerName() ：获取服务器的名字

getServletPath() ：获取客户端所请求的脚本文件的路径

getServerPort() ：获取服务器的端口号

removeAttribute(String name) ：删除请求中的一个属性

9、 forward和redirect 的区别

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

redirect 就是服务端根据逻辑 ,发送一个状态码 ,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以 session,request参数都可以获取。

10、 request.getAttribute()和 request.getParameter()有何区别 ?

getParameter得到的都是String类型的。或者是http://a.jsp?id=123中的123，或者是某个表单提交过去的数据。

getAttribute则可以是对象。

getParameter()是获取POST/GET传递的参数值；

getAttribute()是获取对象容器中的数据值；

getParameter：用于客户端重定向时，即点击了链接或提交按扭时传值用，即用于在用表单或url重定向传值时接收数据用。

getAttribute：用于服务器端重定向时，即在sevlet中使用了forward函数,或struts中使用了mapping.findForward。getAttribute只能收到程序用setAttribute传过来的值。

getParameter()是获取POST/GET传递的参数值；

getAttribute()是获取SESSION的值；

另外，可以用setAttribute,getAttribute发送接收对象.而getParameter显然只能传字符串。setAttribute是应用服务器把这个对象放在该页面所对应的一块内存中去，当你的页面服务器重定向到另一个页面时，应用服务器会把这块内存拷贝另一个页面所对应的内存中。这样getAttribute就能取得你所设下的值，当然这种方法可以传对象。session也一样，只是对象在内存中的生命周期不一样而已。getParameter只是应用服务器在分析你送上来的request页面的文本时，取得你设在表单或url重定向时的值。

getParameter返回的是String, 用于读取提交的表单中的值;

getAttribute返回的是Object，需进行转换,可用setAttribute设置成任意对象，使用很灵活，可随时用；

11. jsp有哪些内置对象 ?作用分别是什么 ?分别有什么方法？

答 :JSP共有以下 9个内置的对象：

request 用户端请求，此请求会包含来自 GET/POST请求的参数

response 网页传回用户端的回应

pageContext 网页的属性是在这里管理

session 与请求有关的会话期

application servlet 正在执行的内容

out 用来传送回应的输出

config servlet 的构架部件

page JSP 网页本身

exception 针对错误网页，未捕捉的例外

request 表示HttpServletRequest 对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取 cookie, header,和 session数据的有用的方法。

response 表示HttpServletResponse 对象，并提供了几个用于设置送回浏览器的响应的方法（如 cookies,头信息等）

out 对象是javax.jsp.JspWriter 的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。

pageContext 表示一个javax.servlet.jsp.PageContext 对象。它是用于方便存取各种范围的名字空间、 servlet相关的对象的 API，并且包装了通用的 servlet相关功能的方法。

session 表示一个请求的javax.servlet.http.HttpSession 对象。 Session可以存贮用户的状态信息

applicaton 表示一个javax.servle.ServletContext 对象。这有助于查找有关 servlet引擎和 servlet环境的信息

config 表示一个javax.servlet.ServletConfig 对象。该对象用于存取 servlet实例的初始化参数。

page 表示从该页面产生的一个 servlet实例

12. jsp有哪些动作 ?作用分别是什么 ?

（这个问题似乎不重要，不明白为何有此题）

答 :JSP共有以下 6种基本动作

jsp:include ：在页面被请求的时候引入一个文件。

jsp:useBean ：寻找或者实例化一个 JavaBean。

jsp:setProperty ：设置JavaBean 的属性。

jsp:getProperty ：输出某个JavaBean 的属性。

jsp:forward ：把请求转到一个新的页面。

jsp:plugin ：根据浏览器类型为 Java插件生成 OBJECT或 EMBED标记

13、 JSP的常用指令

isErrorPage( 是否能使用Exception 对象) ，isELIgnored( 是否忽略表达式 )

14. JSP中动态 INCLUDE与静态 INCLUDE的区别？

答：动态 INCLUDE用 jsp:include动作实现

<jsp:include page=included.jsp flush=true /> 它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数 静态INCLUDE 用include 伪码实现 ,定不会检查所含文件的变化，适用于包含静态页面 <%@include file=included.htm %>

15、两种跳转方式分别是什么 ?有什么区别 ?

（下面的回答严重错误，应该是想问 forward和 sendRedirect的区别，毕竟出题的人不是专业搞文字艺术的人，可能表达能力并不见得很强，用词不一定精准，加之其自身的技术面也可能存在一些问题，不一定真正将他的意思表达清楚了，严格意思上来讲，一些题目可能根本就无人能答，所以，答题时要掌握主动，只要把自己知道的表达清楚就够了，而不要去推敲原始题目的具体含义是什么，不要一味想着是在答题）

答：有两种，分别为：

<jsp:include page=included.jsp flush=true>

<jsp:forward page= nextpage.jsp/>

前者页面不会转向 include所指的页面，只是显示该页的结果，主页面还是原来的页面。执行完后还会回来，相当于函数调用。并且可以带参数 .后者完全转向新页面，不会再回来。相当于 go to 语句。

16、页面间对象传递的方法

request ，session ，application ，cookie 等

17、 JSP和Servlet 有哪些相同点和不同点，他们之间的联系是什么？

JSP 是Servlet 技术的扩展，本质上是 Servlet的简易方式，更强调应用的外表表达。 JSP编译后是 "类 servlet"。 Servlet和 JSP最主要的不同点在于， Servlet的应用逻辑是在 Java文件中，并且完全从表示层中的 HTML里分离开来。而 JSP的情况是 Java和 HTML可以组合成一个扩展名为 .jsp的文件。 JSP侧重于视图， Servlet主要用于控制逻辑。

18、 MVC的各个部分都有那些技术来实现 ?如何实现 ?

答 :MVC是 Model－ View－ Controller的简写。 Model代表的是应用的业务逻辑（通过 JavaBean， EJB组件实现）， View是应用的表示面（由 JSP页面产生）， Controller是提供应用的处理过程控制（一般是一个 Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。

19、我们在 web应用开发过程中经常遇到输出某种编码的字符，如 iso8859-1等，如何输出一个某种编码的字符串？

Public String translate(String str) {

String tempStr ="";

try {

tempStr = newString(str.getBytes("ISO-8859-1"), "GBK");

tempStr =tempStr.trim();

}

catch (Exception e) {

System.err.println(e.getMessage());

}

return tempStr;

}

20、现在输入 n个数字，以逗号，分开；然后可选择升或者降序排序；按提交键就在另一页面显示按什么排序，结果为，提供 reset

五. 数据库部分

1、用两种方式根据部门号从高到低，工资从低到高列出每个员工的信息。

employee:

eid,ename,salary,deptid;

select * from employeeorder by deptid desc,salary

2、列出各个部门中工资高于本部门的平均工资的员工数和部门号，并按部门号排序

创建表：

mysql> createtable employee921(id int primary key auto_increment,name varchar(5

0),salary bigint,deptid int);

插入实验数据：

mysql> insert into employee921values(null,'zs',1000,1),(null,'ls',1100,1),(null

,'ww',1100,1),(null,'zl',900,1) ,(null,'zl',1000,2), (null,'zl',900,2),(null,'z

l',1000,2) , (null,'zl',1100,2);

编写 sql语句：

（） select avg(salary) from employee921 group by deptid;

（） mysql> selectemployee921.id,employee921.name,employee921.salary,employee921.dep

tid tid from employee921where salary > (select avg(salary) from employee921 where deptid = tid);

效率低的一个语句，仅供学习参考使用（在 group by之后不能使用 where，只能使用 having，在 group by之前可以使用 where，即表示对过滤后的结果分组）：

mysql> selectemployee921.id,employee921.name,employee921.salary,employee921.dep

tid tid from employee921where salary > (select avg(salary) from employee921 group by deptid havingdeptid = tid);

（） select count(*) ,tid

from (

selectemployee921.id,employee921.name,employee921.salary,employee921.deptid tid

from employee921

where salary>

(selectavg(salary) from employee921 where deptid = tid)

) as t

group by tid ;

另外一种方式：关联查询

select a.ename,a.salary,a.deptid

from emp a,

(selectdeptd,avg(salary) avgsal from emp group by deptid ) b

where a.deptid=b.deptidand a.salary>b.avgsal;

3、存储过程与触发器必须讲，经常被面试到 ?

create procedure insert_Student (_name varchar(50),_age int ,out_id int)

begin

insert into studentvalue(null,_name,_age);

select max(stuId)into _id from student;

end;

call insert_Student('wfz',23,@id);

select @id;

mysql> create trigger update_Student BEFORE update on studentFOR EACH ROW

-> select * from student;

触发器不允许返回结果

create trigger update_StudentBEFORE update on student FOR EACH ROW

insert into student value(null,'zxx',28);

mysql 的触发器目前不能对当前表进行操作

create trigger update_StudentBEFORE update on student FOR EACH ROW

delete from articles where id=8;

这个例子不是很好，最好是用删除一个用户时，顺带删除该用户的所有帖子

这里要注意使用 OLD.id

触发器用处还是很多的，比如校内网、开心网、 Facebook，你发一个日志，自动通知好友，其实就是在增加日志时做一个后触发，再向通知表中写入条目。因为触发器效率高。而 UCH没有用触发器，效率和数据处理能力都很低。

存储过程的实验步骤：

mysql> delimiter |

mysql> create procedure insertArticle_Procedure (pTitle varchar(50),pBid int,out

pId int)

-> begin

-> insert into article1value(null,pTitle,pBid);

-> select max(id) into pId fromarticle1;

-> end;

-> |

Query OK, 0 rows affected (0.05sec)

mysql> callinsertArticle_Procedure(' 传智播客',1,@pid);

-> |

Query OK, 0 rows affected (0.00sec)

mysql> delimiter ;

mysql> select @pid;

+------+

| @pid |

+------+

| 3 |

+------+

1 row in set (0.00 sec)

mysql> select * fromarticle1;

+----+--------------+------+

| id | title | bid |

+----+--------------+------+

| 1 | test | 1 |

| 2 | chuanzhiboke | 1 |

| 3 | 传智播客 | 1 |

+----+--------------+------+

3 rows in set (0.00 sec)

触发器的实验步骤：

create table board1(id intprimary key auto_increment,name varchar(50),ar

ticleCount int);

create table article1(id intprimary key auto_increment,title varchar(50)

,bid int referencesboard1(id));

delimiter |

create triggerinsertArticle_Trigger after insert on article1 for each ro

w begin

-> update board1 setarticleCount=articleCount+1 where id= NEW.bid;

-> end;

-> |

delimiter ;

insert into board1 value(null,'test',0);

insert into article1value(null,'test',1);

还有，每插入一个帖子，都希望将版面表中的最后发帖时间，帖子总数字段进行同步更新，用触发器做效率就很高。下次课设计这样一个案例，写触发器时，对于最后发帖时间可能需要用 declare方式声明一个变量，或者是用 NEW.posttime来生成。

4、数据库三范式是什么 ?

第一范式（ 1NF）：字段具有原子性 ,不可再分。所有关系型数据库系统都满足第一范式）

数据库表中的字段都是单一属性的，不可再分。例如，姓名字段，其中的姓和名必须作为一个整体，无法区分哪部分是姓，哪部分是名，如果要区分出姓和名，必须设计成两个独立的字段。

第二范式（ 2NF）：

第二范式（ 2NF）是在第一范式（ 1NF）的基础上建立起来的，即满足第二范式（ 2NF）必须先满足第一范式（ 1NF）。

要求数据库表中的每个实例或行必须可以被惟一地区分。通常需要为表加上一个列，以存储各个实例的惟一标识。这个惟一属性列被称为主关键字或主键。

第二范式（ 2NF）要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性，如果存在，那么这个属性和主关键字的这一部分应该分离出来形成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列，以存储各个实例的惟一标识。简而言之，第二范式就是非主属性非部分依赖于主关键字。

第三范式的要求如下：

满足第三范式（ 3NF）必须先满足第二范式（ 2NF）。简而言之，第三范式（ 3NF）要求一个数据库表中不包含已在其它表中已包含的非主关键字信息。

所以第三范式具有如下特征： 1，每一列只有一个值 2，每一行都能区分。 3，每一个表都不包含其他表已经包含的非主关键字信息。

例如，帖子表中只能出现发帖人的 id，而不能出现发帖人的 id，还同时出现发帖人姓名，否则，只要出现同一发帖人 id的所有记录，它们中的姓名部分都必须严格保持一致，这就是数据冗余。

5、说出一些数据库优化方面的经验 ?

用 PreparedStatement一般来说比 Statement性能高：一个 sql发给服务器去执行，涉及步骤：语法检查、语义分析，编译，缓存

“ inert into user values(1,1,1)” -à二进制

“ inert into user values(2,2,2)” -à二进制

“ inert into user values(?,?,?)” -à二进制

有外键约束会影响插入和删除性能，如果程序能够保证数据的完整性，那在设计数据库时就去掉外键。（比喻：就好比免检产品，就是为了提高效率，充分相信产品的制造商）

（对于 hibernate来说，就应该有一个变化： empleyee->Deptment 对象，现在设计时就成了 employeeà deptid）

看 mysql帮助文档子查询章节的最后部分，例如，根据扫描的原理，下面的子查询语句要比第二条关联查询的效率高：

1. select e.name,e.salarywhere e.managerid=(select id from employee where name='zxx');

2. select e.name,e.salary,m.name,m.salary fromemployees e,employees m where

e.managerid = m.id andm.name='zxx';

表中允许适当冗余，譬如，主题帖的回复数量和最后回复时间等

将姓名和密码单独从用户表中独立出来。这可以是非常好的一对一的案例哟！

sql 语句全部大写，特别是列名和表名都大写。特别是 sql命令的缓存功能，更加需要统一大小写， sql语句à发给 oracle服务器à语法检查和编译成为内部指令à缓存和执行指令。根据缓存的特点，不要拼凑条件，而是用 ?和 PreparedStatment

还有索引对查询性能的改进也是值得关注的。

备注：下面是关于性能的讨论举例

4航班 3个城市

m*n

select * from flight,city where flight.startcityid=city.cityidand city.name='beijing';

m + n

select * from flight where startcityid = (select cityid fromcity where cityname='beijing');

select flight.id,'beijing',flight.flightTime from flight wherestartcityid = (select cityid from city where cityname='beijing')

6、 union和union all 有什么不同?

假设我们有一个表 Student，包括以下字段与数据：

drop table student;

create table student ( id int primary key, name nvarchar2(50) not null, score number not null );

insert into student values(1,'Aaron',78); insert into student values(2,'Bill',76); insert into student values(3,'Cindy',89); insert into student values(4,'Damon',90); insert into student values(5,'Ella',73); insert into student values(6,'Frado',61); insert into student values(7,'Gill',99); insert into student values(8,'Hellen',56); insert into student values(9,'Ivan',93); insert into student values(10,'Jay',90);

commit;

Union 和Union All 的区别。

select * from student where id < 4

union

select * from student where id > 2 and id < 6

结果将是

1 Aaron 78 2 Bill 76

3 Cindy 89 4 Damon 90 5 Ella 73

如果换成 Union All连接两个结果集，则返回结果是：

1 Aaron 78 2 Bill 76 3 Cindy 89 3 Cindy 89 4 Damon 90 5 Ella 73

可以看到， Union和 Union All的区别之一在于对重复结果的处理。

UNION 在进行表链接后会筛选掉重复的记录，所以在表链接后会对所产生的结果集进行排序运算，删除重复的记录再返回结果。实际大部分应用中是不会产生重复的记录，最常见的是过程表与历史表 UNION。如： select * from gc_dfys union select * from ls_jg_dfys 这个SQL 在运行时先取出两个表的结果，再用排序空间进行排序删除重复的记录，最后返回结果集，如果表数据量大的话可能会导致用磁盘进行排序。 而UNION ALL 只是简单的将两个结果合并后就返回。这样，如果返回的两个结果集中有重复的数据，那么返回的结果集就会包含重复的数据了。 从效率上说，UNION ALL 要比UNION 快很多，所以，如果可以确认合并的两个结果集中不包含重复的数据的话，那么就使用 UNION ALL，

7.分页语句

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

sql server 方案1 ：

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

sql server 方案2 ：

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

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

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

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

pageSize=20;

pageNo = 5;

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

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

oracle: sql = "select * from " +

"(selectrownum r,* from " +

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

"whererownum<= " + pageNo*pageSize +") tmp " +

"wherer>" + (pageNo-1)*pageSize;

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

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

sqlserver:sql = "select top 10 * from id not id(select top" + (pageNo-1)*pageSize + "id from articles)"

DataSource ds = new InitialContext().lookup(jndiurl);

Connection cn = ds.getConnection();

//"select * from user where id=?" --->binary directive

PreparedStatement pstmt = cn.prepareSatement(sql);

ResultSet rs = pstmt.executeQuery()

while(rs.next())

{

out.println(rs.getString(1));

}

2.不可滚动的游标

pageSize=20;

pageNo = 5;

cn = null

stmt = null;

rs = null;

try

{

sqlserver:sql = "select * from articles";

DataSource ds = new InitialContext().lookup(jndiurl);

Connection cn = ds.getConnection();

//"select * from user where id=?" --->binary directive

PreparedStatement pstmt = cn.prepareSatement(sql);

ResultSet rs = pstmt.executeQuery()

for(int j=0;j<(pageNo-1)*pageSize;j++)

{

rs.next();

}

int i=0;

while(rs.next() && i<10)

{

i++;

out.println(rs.getString(1));

}

}

cacth(){}

finnaly

{

if(rs!=null)try{rs.close();}catch(Exceptione){}

if(stm.........

if(cn............

}

3.可滚动的游标

pageSize=20;

pageNo = 5;

cn = null

stmt = null;

rs = null;

try

{

sqlserver:sql = "select * from articles";

DataSource ds = new InitialContext().lookup(jndiurl);

Connection cn = ds.getConnection();

//"select * from user where id=?" --->binary directive

PreparedStatement pstmt = cn.prepareSatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,...);

//根据上面这行代码的异常 SQLFeatureNotSupportedException ，就可判断驱动是否支持可滚动游标

ResultSet rs = pstmt.executeQuery()

rs.absolute((pageNo-1)*pageSize)

int i=0;

while(rs.next() && i<10)

{

i++;

out.println(rs.getString(1));

}

}

cacth(){}

finnaly

{

if(rs!=null)try{rs.close();}catch(Exceptione){}

if(stm.........

if(cn............

}

8.用一条 SQL语句查询出每门课都大于 80分的学生姓名

name kecheng fenshu 张三 语文 81 张三 数学 75 李四 语文 76 李四 数学 90 王五 语文 81 王五 数学 100 王五 英语 90

准备数据的 sql代码：

create table score(id int primary key auto_increment,namevarchar(20),subject varchar(20),score int);

insert into score values

(null,' 张三',' 语文',81),

(null,' 张三',' 数学',75),

(null,' 李四',' 语文',76),

(null,' 李四',' 数学',90),

(null,' 王五',' 语文',81),

(null,' 王五',' 数学',100),

(null,' 王五 ',' 英语',90);

提示：当百思不得其解时，请理想思维，把小变成大做，把大变成小做，

答案： A: select distinct name from score where name not in (selectdistinct name from score where score<=80)

B:select distince name t1 from score where 80< all (selectscore from score where name=t1);

9.所有部门之间的比赛组合

一个叫 department的表，里面只有一个字段 name,一共有 4条纪录，分别是 a,b,c,d,对应四个球对，现在四个球对进行比赛，用一条 sql语句显示所有可能的比赛组合 .

答： select a.name,b.name from team a, team b where a.name < b.name

10.每个月份的发生额都比 101科目多的科目

请用 SQL语句实现：从 TestDB数据表中查询出所有月份的发生额都比 101科目相应月份的发生额高的科目。请注意： TestDB中有很多科目，都有 1－ 12月份的发生额。 AccID：科目代码， Occmonth：发生额月份， DebitOccur：发生额。 数据库名： JcyAudit，数据集： Select * from TestDB

准备数据的 sql代码：

drop table if exists TestDB;

create table TestDB(id int primary key auto_increment,AccIDvarchar(20), Occmonth date, DebitOccur bigint);

insert into TestDB values

(null,'101','1988-1-1',100),

(null,'101','1988-2-1',110),

(null,'101','1988-3-1',120),

(null,'101','1988-4-1',100),

(null,'101','1988-5-1',100),

(null,'101','1988-6-1',100),

(null,'101','1988-7-1',100),

(null,'101','1988-8-1',100);

--复制上面的数据，故意把第一个月份的发生额数字改小一点

insert into TestDB values

(null,'102','1988-1-1',90),

(null,'102','1988-2-1',110),

(null,'102','1988-3-1',120),

(null,'102','1988-4-1',100),

(null,'102','1988-5-1',100),

(null,'102','1988-6-1',100),

(null,'102','1988-7-1',100),

(null,'102','1988-8-1',100);

--复制最上面的数据，故意把所有发生额数字改大一点

insert into TestDB values

(null,'103','1988-1-1',150),

(null,'103','1988-2-1',160),

(null,'103','1988-3-1',180),

(null,'103','1988-4-1',120),

(null,'103','1988-5-1',120),

(null,'103','1988-6-1',120),

(null,'103','1988-7-1',120),

(null,'103','1988-8-1',120);

--复制最上面的数据，故意把所有发生额数字改大一点

insert into TestDB values

(null,'104','1988-1-1',130),

(null,'104','1988-2-1',130),

(null,'104','1988-3-1',140),

(null,'104','1988-4-1',150),

(null,'104','1988-5-1',160),

(null,'104','1988-6-1',170),

(null,'104','1988-7-1',180),

(null,'104','1988-8-1',140);

--复制最上面的数据，故意把第二个月份的发生额数字改小一点

insert into TestDB values

(null,'105','1988-1-1',100),

(null,'105','1988-2-1',80),

(null,'105','1988-3-1',120),

(null,'105','1988-4-1',100),

(null,'105','1988-5-1',100),

(null,'105','1988-6-1',100),

(null,'105','1988-7-1',100),

(null,'105','1988-8-1',100);

答案： select distinct AccID from TestDB

where AccID not in

(selectTestDB.AccIDfrom TestDB,

(select * from TestDB where AccID='101') asdb101

whereTestDB.Occmonth=db101.Occmonth and TestDB.DebitOccur<=db101.DebitOccur

);

11.统计每年每月的信息

year monthamount 1991 1 1.1 1991 2 1.2 1991 3 1.3 1991 4 1.4 1992 1 2.1

1992 2 2.2 1992 3 2.3 1992 4 2.4

查成这样一个结果 year m1 m2 m3 m4 1991 1.1 1.2 1.3 1.4 1992 2.1 2.2 2.3 2.4

提示：这个与工资条非常类似，与学生的科目成绩也很相似。

准备 sql语句：

drop table if existssales;

create table sales(idint auto_increment primary key,year varchar(10), month varchar(10), amountfloat(2,1));

insert into salesvalues

(null,'1991','1',1.1),

(null,'1991','2',1.2),

(null,'1991','3',1.3),

(null,'1991','4',1.4),

(null,'1992','1',2.1),

(null,'1992','2',2.2),

(null,'1992','3',2.3),

(null,'1992','4',2.4);

答案一、 select sales.year ,

(select t.amount fromsales t where t.month='1' and t.year= sales.year) '1',

(select t.amount fromsales t where t.month='1' and t.year= sales.year) '2',

(select t.amount fromsales t where t.month='1' and t.year= sales.year) '3',

(select t.amount fromsales t where t.month='1' and t.year= sales.year) as '4'

from sales group by year;

12.显示文章标题，发帖人、最后回复时间

表： id,title,postuser,postdate,parentid

准备 sql语句：

drop table if exists articles;

create table articles(id int auto_increment primary key,titlevarchar(50), postuser varchar(10), postdate datetime,parentid int referencesarticles(id));

insert into articles values

(null,' 第一条',' 张三','1998-10-10 12:32:32',null),

(null,' 第二条',' 张三','1998-10-10 12:34:32',null),

(null,' 第一条回复1',' 李四','1998-10-10 12:35:32',1),

(null,' 第二条回复1',' 李四','1998-10-10 12:36:32',2),

(null,' 第一条回复2',' 王五','1998-10-10 12:37:32',1),

(null,' 第一条回复3',' 李四','1998-10-10 12:38:32',1),

(null,' 第二条回复2',' 李四','1998-10-10 12:39:32',2),

(null,' 第一条回复4',' 王五','1998-10-10 12:39:40',1);

答案：

select a.title,a.postuser,

(selectmax(postdate) from articles where parentid=a.id) reply

from articles a where a.parentid is null;

注释：子查询可以用在选择列中，也可用于 where的比较条件中，还可以用于 from从句中。

13.删除除了 id号不同 ,其他都相同的学生冗余信息

2.学生表如下 : id号 学号 姓名课程编号课程名称分数 1 2005001 张三 0001 数学 69 2 2005002 李四 0001 数学 89 3 2005001 张三 0001 数学 69 A: delete from tablename where id号 not in(select min(id号 ) from tablename group by 学号, 姓名, 课程编号 ,课程名称 ,分数 )

实验：

create table student2(id int auto_increment primary key,codevarchar(20),name varchar(20));

insert into student2 values(null,'2005001',' 张三'),(null,'2005002',' 李四'),(null,'2005001',' 张三');