java面试题

4、float f=3.4;是否正确？
答案：不正确。
原因：精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4 或float f = 3.4f

在java里面，没小数点的默认是int,有小数点的默认是 double;

编译器可以自动向上转型，如int 转成 long 系统自动转换没有问题，因为后者精度更高
double 转成 float 就不能自动做了，所以后面的加上个 f;

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

1.高位转低位需要强制转换            

2.低位转高位自动转.

因为S1是short型的，占2个字节，而1是int型的,占4个字节。在两个类型的值相加的时候，会发生自动类型的提升,要不然数据也装不下呀，是这个道理吧*_*。也就是说s1+1后，其结果是int型的，而不是short型的，所以可以想想看，把4个字节的东西放在两个字节的空间里，肯定编译不通过。       

后面的那个不会发生类型的提升，JAVA规范上说 【e1+=e2    实际上是    e1=(T1)(e1+e2) 】，其中T1是e1的数据类型。   s1+=1等效于   s1=(short)(s1+1),所以是正确的。     

9、解释内存中的栈(stack)、堆(heap)和静态区(static area)的用法。

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

String str = new String(“hello”);

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

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

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

11、switch 是否能作用在byte 上，是否能作用在long 上，是否能作用在String上？

/**
 * 问题：switch语句能否作用在byte上,能否作用在long上,能否作用在String上
 * 基本类型的包装类（如：Character、Byte、Short、Integer）
 *
 * switch可作用于char byte short int
 * switch可作用于char byte short int对应的包装类
 * switch不可作用于long double float boolean，包括他们的包装类
 * switch中可以是字符串类型,String(jdk1.7之后才可以作用在string上)
 * switch中可以是枚举类型

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

2 << 3，
因为将一个数左移n 位，就相当于乘以了2 的n 次方，那么，一个数乘以8 只要将其左移3 位
即可，而位运算cpu 直接支持的，效率最高，所以，2 乘以8 等於几的最效率的方法是2 << 3。

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

字符串求长度用length()方法

集合求长度用size()方法

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

java 中已知的三种跳出多重循环的方式：

 System.out.println("---------java中跳出多重循环的三种方式：---------");

        System.out.println("---------第一种，使用带有标号的的break语句---------");

        String a1 = "";

        String b1 = "";

        here:

        for (int i = 1; i <= 4; i++) {

            a1 = "外层循环第"+i+"层";

            for (int j = 1; j <= 4; j++) {

                b1 = "内层循环第"+j+"层";

                if (2 == j & 2 == i) {

                    break here;

                }

            }

        }

        System.out.println(a1+b1);

        System.out.println("---------第二种，外层的循环条件收到内层的代码控制限制---------");

        String a2 = "";

        String b2 = "";

        Boolean state =  true;

        for (int i = 1; i <= 4 && state; i++) {

            a2 = "外层循环第"+i+"层";

            for (int j = 1; j <= 4 && state; j++) {

                b2 = "内层循环第"+j+"层";

                if (2 == j & 2 == i) {

                    state = false;

                }

            }

        }

        System.out.println(a2+b2);

        System.out.println("---------第三种，使用try/catch强制跳出循环---------");

        String a3 = "";

        String b3 = "";

        try {

            for (int i = 1; i <= 3; i++) {

                a3 = "外层循环第"+i+"层";

                for (int j = 1; j <= 3; j++) {

                    b3 = "内层循环第"+j+"层";

                    if (2 == j & 2 == i) {

                        throw new Exception();

                    }

                }

            }

        } catch (Exception e) {

            System.out.println(a3+b3);

        }

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

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

17、是否可以继承String类？

因为Sting是这样定义的：public final class String extends Object，里边有final关键字，所以不能被继承。

什么样的类不能被继承？

　一，在Java中，只要是被定义为final的类，也可以说是被final修饰的类，就是不能被继承的。
　二，final是java中的一个关键字，可以用来修饰变量、方法和类。用关键词final修饰的域成为最终域。用关键词final修饰的变量一旦赋值，就不能改变，也称为修饰的标识为常量。如果一个类的域被关键字final所修饰，它的取值在程序的整个执行过程中将不会改变。
　三，假如说整个类都是final，就表明自己不希望从这个类继承，或者不答应其他任何人采取这种操作。换言之，出于这样或那样的原因，我们的类肯定不需要进行任何改变；或者出于安全方面的理由，我们不希望进行子类化（子类处理）。

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

Java中没有指针，所以也没有引用传递了，仅仅有值传递不过可以通过对象的方式来实现引用传递 类似java没有多继承 但可以用多次implements接口实现多继承的功能
值传递：方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参 

数的值。
引用传递：也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。

19、String和StringBuilder、StringBuffer的区别？

String 字符串常量
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）
 简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
 而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的：
 String S1 = “This is only a” + “ simple” + “ test”;
 StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
 你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个
 String S1 = “This is only a” + “ simple” + “test”; 其实就是：
 String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：
String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;
这时候 JVM 会规规矩矩的按照原来的方式去做

在大部分情况下 StringBuffer > String
StringBuffer
Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。
StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。
在大部分情况下 StringBuilder > StringBuffer

java.lang.StringBuilde
java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

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

问：重载（Overload）和重写（Override）的区别。

重载的方法能否根据返回类型进行区分？ 

 

答：

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。

 

重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；

 

重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。

 

重载对返回类型没有特殊的要求。

 

举例说明为什么不能根据返回类型来区分重载：

 

java里允许调用一个有返回值的方法的时候不必将返回值赋给变量;
这样JVM就不知道你调用的是有返回值的还是没返回值的.
如
class Test{
  public static void testMethod(){

  }
  public static int testMethod(){

  }//姑且假设允许吧
  public static void main(String[] args){
    int i = testMethod();//这个还说的过去 知道是调用哪个
    testMethod();//这个就无法判断调用哪个方法了
  } 
}

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

Java语言是一种具有动态性的解释型语言，类（class）只有被加载到JVM后才能运行。当运行指定程序时，JVM会将编译生成的.class文件按照需求和一定的规则加载到内存中，并组织成为一个完整的Java应用程序。这个加载过程是由类加载器完成，具体来说，就是由ClassLoader和它的子类来实现的。类加载器本身也是一个类，其实质是把类文件从硬盘读取到内存中。

类的加载方式分为隐式加载和显示加载。隐式加载指的是程序在使用new等方式创建对象时，会隐式地调用类的加载器把对应的类加载到JVM中。显示加载指的是通过直接调用class.forName()方法来把所需的类加载到JVM中。

任何一个工程项目都是由许多类组成的，当程序启动时，只把需要的类加载到JVM中，其他类只有被使用到的时候才会被加载，采用这种方法一方面可以加快加载速度，另一方面可以节约程序运行时对内存的开销。此外，在Java语言中，每个类或接口都对应一个.class文件，这些文件可以被看成是一个个可以被动态加载的单元，因此当只有部分类被修改时，只需要重新编译变化的类即可，而不需要重新编译所有文件，因此加快了编译速度。

在Java语言中，类的加载是动态的，它并不会一次性将所有类全部加载后再运行，而是保证程序运行的基础类（例如基类）完全加载到JVM中，至于其他类，则在需要的时候才加载。

类加载的主要步骤：

1>装载。根据查找路径找到相应的class文件，然后导入。

2>链接。链接又可分为3个小步：

1)检查，检查待加载的class文件的正确性。

2)准备，给类中的静态变量分配存储空间。

3)解析，将符号引用转换为直接引用（这一步可选）

3>初始化。对静态变量和静态代码块执行初始化工作。

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

可以
        1 bit   = 1  二进制数据
        1 byte  = 8  bit
        1 字母  = 1  byte = 8 bit
        1 汉字 = 2  byte = 16 bit
Java基本数据类型
        Int: 4 byte
        short: 2 byte
        long: 8字节
        byte: 1字节(8bit)
        char: 2字节
        float: 4字节
        double: 8字节

      在C语言中，char类型占1一个字节，而汉子占2个字节，所以不能存储。

      在Java中，char类型占2个字节，而且Java默认采用Unicode编码，以个Unicode码是16位，所以一个Unicode码占两个字节，Java中无论汉子还是英文字母都是用Unicode编码来表示的。所以，在Java中，char类型变量可以存储一个中文汉字。

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

首先，内部类的创建依赖一个外部内对象作为宿主，就跟寄生虫一样，内部内必须寄生在外部类对象中才能创建实例。

其次，静态都是用来修饰类的内部成员的。比如静态方法，静态成员变量，静态常量。它唯一的作用就是随着类的加载（而不是随着对象的产生）而产生，以致可以用类名+静态成员名直接获得。

这样静态内部类就可以理解了，因为这个类没有必要单独存放一个文件，它一般来说只被所在外部类使用。并且它可以直接被用 外部类名+内部类名 获得。

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

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

java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景，通俗地说，就是程序员可能创建了一个对象，以后一直不再使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是java中可能出现内存泄露的情况，例如，缓存系统，我们加载了一个对象放在缓存中(例如放在一个全局map对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。 
检查java中的内存泄露，一定要让程序将各种分支情况都完整执行到程序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。

如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持久外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露。

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

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

29、如何实现对象克隆？

王浩祥

如何实现对象克隆？

有两种方式：
1). 实现Cloneable接口并重写Object类中的clone()方法；
2). 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下。

31、String s = new String("xyz");创建了几个字符串对象？引用自这位朋友:http://blog.sina.com.cn/s/blog_6a6b14100100zn6r.html

 

你知道在java中除了8中基本类型外，其他的都是类对象以及其引用。所以 "xyz "在java中它是一个String对象.对于string类对象来说他的对象值是不能修改的，也就是具有不变性。 


看： 
String   s= "Hello "; 
s= "Java "; 
String   s1= "Hello "; 
String   s2=new   String( "Hello "); 

啊，s所引用的string对象不是被修改了吗？之前所说的不变性，去那里了啊？ 

你别着急，让我告诉你说发生了什么事情： 
在jvm的工作过程中，会创建一片的内存空间专门存入string对象。我们把这片内存空间叫做string池。 

String   s= "Hello ";当jvm看到 "Hello "，在string池创建string对象存储它，并将他的引用返回给s。 
s= "Java "，当jvm看到 "Java "，在string池创建新的string对象存储它，再把新建的string对象的引用返回给s。而原先的 "Hello "仍然在string池内。没有消失，他是不能被修改的。 

所以我们仅仅是改变了s的引用，而没有改变他所引用的对象，因为string对象的值是不能被修改的。 

String   s1= "Hello ";jvm首先在string池内里面看找不找到字符串 "Hello ",找到,返回他的引用给s1，否则,创建新的string对象，放到string池里。这里由于s= "Hello "了,对象已经被引用，所以依据规则s和s1都是引用同一个对象。所以   s==s1将返回true。(==,对于非基本类型，是比较两引用是否引用内存中的同一个对象) 

String   s2=String( "Hello ");jvm首先在string池内里面看找不找到字符串 "Hello ",找到,不做任何事情，否则,创建新的string对象，放到string池里面。由于遇到了new，还会在内存上（不是string池里面）创建string对象存储 "Hello "，并将内存上的（不是string池内的）string对象返回给s2。所以s==s2将返回false，不是引用同一个对象。 

好现在我们看题目： 
String   s   =   new   String( "xyz "); 
首先在string池内找，找到？不创建string对象，否则创建，   这样就一个string对象 
遇到new运算符号了，在内存上创建string对象，并将其返回给s，又一个对象 

所以总共是2个对象 

 

一个例子: 
public class Test 
{ 
public static void main(String [] args) 
{ 
String s1=new String("test");//创建2个对象，一个Class和一个堆里面 
String s2="test";//创建1个对象，s2指向pool里面的"test"对象 
String s3="test";//创建0个对象,指向s2指想pool里面的那个对象 
String s4=s2;//创建0个对象,指向s2,s3指想pool里面的那个对象 
String s5=new String("test");//创建1个对象在堆里面，注意，与s1没关系 

System.out.println(s2=="test");//true s2=="test"很明显true 
System.out.println(s2==s3);//true,因为指向的都是pool里面的那个"test" 
System.out.println(s2==s4);//true,同上,那么s3和s4...:) 
System.out.println(s1==s5);//false,很明显,false 
System.out.println(s1==s2);//false,指向的对象不一样,下面再说 
System.out.println(s1=="test");//false,难道s1!="tset"？下面再说 

System.out.println("---------------"); 

s1=s2; 
System.out.println(s1=="test");//true,下面说 
} 
} 
说明：1,System.out.println(s1==s2);很明显，s2指向的对象"test"是在pool里面，而s1指向的是堆里面的"test"对象(s1指向的内存区)，所以返回false. 
2,System.out.println(s1=="test");s1指向的是堆里面的"test"对象(s1指向的内存区)，而"test"是程序 刚刚建立的(其实是共用pool里面的那个已经创建了的"test"对象,也就是我们s2="test"时候，在pool里面创建的)，所以s1指向的堆 里的"test"对象 
和"test"(pool里面)并不是一样个对象，所以返回false. 
3,当我们s1=s2;的时候，很明显，把s2的指给了s1,s1指向pool里面的"test",这个时候，s2也指向了pool里面的"test"对 象了，当System.out.println(s1=="test");时候，java虚拟机创建"test"对象，注意，其实没创建，和前面讲的一 样，公用s1="test"创建的"test"对象(pool里面的),所以，s1=="test"(pool里面的)，同 样，s1=s2=s3=s4！ 

而为什么在网上都说String s=new String("test");创建了2个对象？那可能因为它就写这么一句代码，误让人默认的认为执行代码之前并不实例任何一个String对象过（也许 很多人不会这么想，），跟着别人或者不经思考的就说2个，斟是说存放在栈内存中专门存放String对象引用的s变量是一个对象！实在不可原谅！ 

 

33、一个".java"源文件中是否可以包含多个类（不是内部类）？有什么限制？这个是可以的，一个“.java”源文件里面可以包含多个类，但是只允许有一个public类，并且类名必须和文件名一致。

每个编译单元只能有一个public 类。这么做的意思是，每个编译单元只能有一个公开的接口，而这个接口就由其public 类来表示。
你可以根据需要，往这个文件里面添加任意多个提供辅助功能的package 权限的类。但是如果这个编译单元里面有两个或两个以上的public 类的话，程序就不知道从哪里导入了，编译器就会报错。

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

回答：匿名内部类在实现时必须借助一个借口或者一个抽象类或者一个普通类来构造，从这过层次上讲匿名内部类是实现了接口或者继承了类，但是不能通过extends或implement关键词来继承类或实现接口。

 

匿名内部类即没有名字的内部类。当我们只需要用某一个类一次时，且该类从意义上需要实现某个类或某个接口，这个特殊的扩展类就以匿名内部类来展现。

一般的用途：

1、覆盖某个超类的方法，并且该扩展类只在本类内用一次。

2、继承抽象类，并实例化其抽象方法，并且该扩展类只在本类内用一次。

3、实现接口，实例化其方法，并且该扩展类只在本类内用一次。

 

代码示例：

class Car{

    void move(){}

}

interface Person{

    void learn();

}

abstract class Animal{

    abstract void eat();

}

public class AnonymousInnerClassDemo {

 

    public static void main(String[] args) {

        Car car = new Car(){

            @Override

            void move() {

                System.out.println("匿名内部类的move方法");

            }

        };

        car.move();

 

        Person person = new Person() {

 

            public void learn() {

                System.out.println("匿名内部类的learn方法");

            }

        };

        person.learn();

 

        Animal animal = new Animal() {

            @Override

            void eat() {

                System.out.println("匿名内部类的eat方法");

            }

        };

        animal.eat();

    }

}

 

 

几点说明：

一、由于匿名内部类没有名字，所以它没有构造函数。因为没有构造函数，所以它必须完全借用父类的构造函数来实例化，匿名内部类完全把创建对象的任务交给了父类去完成。

二、在匿名内部类里创建新的方法没有太大意义，但它可以通过覆盖父类的方法达到神奇效果，如上例所示。这是多态性的体现。 

三、因为匿名内部类没有名字，所以无法进行向下的强制类型转换，持有对一个匿名内部类对象引用的变量类型一定是它的直接或间接父类类型。 

四、注意匿名内部类的声明是在编译时进行的，实例化在运行时进行。这意味着for循环中的一个new语句会创建相同匿名类的几个实例，而不是创建几个不同匿名类的一个实例。

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

答题时，也要能察言观色，揣摩提问者的心思，显然人家希望你说的是静态内部类不能访问外部类的成员，但你一上来就顶牛，这不好，要先顺着人家，让人家满意，然后再说特殊情况，让人家吃惊。

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

在静态内部类下，不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，

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

可用字符串构造一 StringBuffer 对象,然后调用 StringBuffer 中的 reverse

方法即可实现字符串的反转,调用 replace 方法即可实现字符串的替换。

[java] view plain copy print?

1. public class test {  
2.     public static void main(String[] args) {  
3.       StringBuffer sb=new StringBuffer("hello");  
4.         System.out.println(sb);  
5.         sb.reverse();  
6.         System.out.println(sb);  
7.      }  
8. }   

public class test {

    public static void main(String[] args) {

      StringBuffer sb=new StringBuffer("hello");

        System.out.println(sb);

        sb.reverse();

        System.out.println(sb);

     }

}

输出结果：

hello
olleh

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

如何实现把gb2312的字符串编码转换成iso-8859-1的字符串

   try{

    String s = "java学习";
            System.out.println(s);
            String result = new String(s.getBytes("GB2312"),"iso-8859-1");
            System.out.println(s);
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

解释：通过JDK1.6知道String类中getBytes（”编码“）方法可以讲一个数用指定的编码转成一个字节数组，String中通过指定的 charset解码指定的 byte 数组，构造一个新的 String

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

我的方法
//一天时间有1000毫秒*60秒*60小时*24小时   这就是一天时间的毫秒数 (1000*60*60*24)
//再用Date自带方法获取从自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数new Date().getTime()
//再用Date自带方法设置毫秒数，显示时间new Date(long);
System.out.println(new Date(new Date().getTime() - (1000*60*60*24)));


网上的方法

Calendar cal = Calendar.getInstance();
  cal.add(Calendar.DATE, -1);
  System.out.println(cal.getTime());

 

45、Error和Exception有什么区别？

Error和Exception的联系

• 继承结构：Error和Exception都是继承于Throwable，RuntimeException继承自Exception。
• Error和RuntimeException及其子类称为未检查异常（Unchecked exception），其它异常成为受检查异常（Checked Exception）。
• Error类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢出等。如java.lang.StackOverFlowError和Java.lang.OutOfMemoryError。对于这类错误，Java编译器不去检查他们。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和预防，遇到这样的错误，建议让程序终止。
• Exception类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。

Error和Exception的区别

运行时异常和受检查的异常

Exception又分为运行时异常（Runtime Exception）和受检查的异常(Checked Exception )。

• RuntimeException：其特点是Java编译器不去检查它，也就是说，当程序中可能出现这类异常时，即使没有用try……catch捕获，也没有用throws抛出，还是会编译通过，如除数为零的ArithmeticException、错误的类型转换、数组越界访问和试图访问空指针等。处理RuntimeException的原则是：如果出现RuntimeException，那么一定是程序员的错误。
• 受检查的异常（IOException等）：这类异常如果没有try……catch也没有throws抛出，编译是通不过的。这类异常一般是外部错误，例如文件找不到、试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。

throw 和 throws两个关键字有什么不同

• throw      是用来抛出任意异常的，你可以抛出任意 Throwable，包括自定义的异常类对象；throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。如果方法抛出了异常，那么调用这个方法的时候就需要处理这个异常。

try-catch-finally-return执行顺序

• 1、不管是否有异常产生，finally块中代码都会执行；
• 2、当try和catch中有return语句时，finally块仍然会执行；
• 3、finally是在return后面的表达式运算后执行的，所以函数返回值是在finally执行前确定的。无论finally中的代码怎么样，返回的值都不会改变，仍然是之前return语句中保存的值；
• 4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

53、阐述ArrayList、Vector、LinkedList的存储性能和特性。

      ArrayList 和Vector他们底层的实现都是一样的，都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢。

      Vector中的方法由于添加了synchronized修饰，因此Vector是线程安全的容器，但性能上较ArrayList差，因此已经是Java中的遗留容器。

      LinkedList使用双向链表实现存储（将内存中零散的内存单元通过附加的引用关联起来，形成一个可以按序号索引的线性结构，这种链式存储方式与数组的连续存储方式相比，内存的利用率更高），按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。            

      Vector属于遗留容器（Java早期的版本中提供的容器，除此之外，Hashtable、Dictionary、BitSet、Stack、Properties都是遗留容器），已经不推荐使用，但是由于ArrayList和LinkedListed都是非线程安全的，如果遇到多个线程操作同一个容器的场景，则可以通过工具类Collections中的synchronizedList方法将其转换成线程安全的容器后再使用（这是对装潢模式的应用，将已有对象传入另一个类的构造器中创建新的对象来增强实现）。

54、Collection和Collections的区别？

Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

57、Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行，它们有什么区别?

sleep和wait有什么区别

第一种解释：

功能差不多,都用来进行线程控制,他们最大本质的区别是:sleep()不释放同步锁,wait()释放同步缩.  
   
  还有用法的上的不同是:sleep(milliseconds)可以用时间指定来使他自动醒过来,如果时间不到你只能调用interreput()来强行打断;wait()可以用notify()直接唤起.

第二种解释：

sleep是Thread类的静态方法。sleep的作用是让线程休眠制定的时间，在时间到达时恢复，也就是说sleep将在接到时间到达事件事恢复线程执行，例如：

try{
System.out.println("I'm going to bed");
Thread.sleep(1000);
System.out.println("I wake up");
}
catch(IntrruptedException e) {
}

wait是Object的方法，也就是说可以对任意一个对象调用wait方法，调用wait方法将会将调用者的线程挂起，直到其他线程调用同一个对象的notify方法才会重新激活调用者，例如：

//Thread 1

try{
obj.wait();//suspend thread until obj.notify() is called
}
catch(InterrputedException e) {
}

第三种解释：

这两者的施加者是有本质区别的.
sleep()是让某个线程暂停运行一段时间,其控制范围是由当前线程决定,也就是说,在线程里面决定.好比如说,我要做的事情是 "点火->烧水->煮面",而当我点完火之后我不立即烧水,我要休息一段时间再烧.对于运行的主动权是由我的流程来控制.

而wait(),首先,这是由某个确定的对象来调用的,将这个对象理解成一个传话的人,当这个人在某个线程里面说"暂停!",也是 thisOBJ.wait(),这里的暂停是阻塞,还是"点火->烧水->煮饭",thisOBJ就好比一个监督我的人站在我旁边,本来该线 程应该执行1后执行2,再执行3,而在2处被那个对象喊暂停,那么我就会一直等在这里而不执行3,但正个流程并没有结束,我一直想去煮饭,但还没被允许, 直到那个对象在某个地方说"通知暂停的线程启动!",也就是thisOBJ.notify()的时候,那么我就可以煮饭了,这个被暂停的线程就会从暂停处 继续执行.

其实两者都可以让线程暂停一段时间,但是本质的区别是一个线程的运行状态控制,一个是线程之间的通讯的问题

 在java.lang.Thread类中，提供了sleep()，
而java.lang.Object类中提供了wait()， notify()和notifyAll()方法来操作线程
sleep()可以将一个线程睡眠，参数可以指定一个时间。
而wait()可以将一个线程挂起，直到超时或者该线程被唤醒。
    wait有两种形式wait()和wait(milliseconds).
sleep和wait的区别有：
  1，这两个方法来自不同的类分别是Thread和Object
  2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
  3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
    任何地方使用
   synchronized(x){
      x.notify()
     //或者wait()
   }
   4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

58、线程的sleep()方法和yield()方法有什么区别？

关于sleep()方法和yield()方法的区别如下：

1.sleep()方法暂停当前线程后，会给其他线程执行机会，不会理会其他线程的优先级；但yield()方法只会给优先级相同，或优先级更高的线程执行机会。

2.sleep()方法会将线程转入阻塞状态，直到经过阻塞时间才会转入就绪状态；而yield()方法不会将线程转入阻塞状态，它只是强制当前线程进入就绪状态。因此完全有可能某个线程调用yield()方法暂停之后，立即再次获得处理器资源被执行。

3.sleep()方法声明抛出了InterruptedException异常，所以调用sleep()方法时要么捕捉该异常，要么显式声明抛出该异常；而yield()方法则没有声明抛出任何异常。

4.sleep()方法比yield()方法有更好的可移植性，通常不建议使用yield()方法来控制并发线程的执行。

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

可以进入其他非synchronized的方法，synchronized的方法不可以的！
Java中的每个对象都有一个锁（lock）或者叫做监视器（monitor），当访问某个对象的synchronized方法时，表示的将该对象上锁，此时其他任何线程都无法再去访问该synchronized方法了，直到之前的那个线程执行方法完毕后（或者是抛出了异常），才将该对象的锁释放掉，其他线程才有可能再去访问该synchronized方法。
如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。

60、请说出与线程同步以及线程调度相关的方法。

wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁；
- sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理InterruptedException异常；
- notify()：唤醒一个处于等待状态的线程，当然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且与优先级无关；

- notityAll()：唤醒所有处于等待状态的线程，该方法并不是将对象的锁给所有线程，而是让它们竞争，只有获得锁的线程才能进入就绪状态；

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

Java 5以前实现多线程有两种实现方法：一种是继承Thread类；另一种是实现Runnable接口。

两种方式都要通过重写run()方法来定义线程的行为，推荐使用后者，因为Java中的继承是单继承，一个类有一个父类，如果继承了Thread类就无法再继承其他类了，显然使用Runnable接口更为灵活

62、synchronized关键字的用法？

在java编程中，经常需要用到同步，而用得最多的也许是synchronized关键字了，下面看看这个关键字的用法。

因为synchronized关键字涉及到锁的概念，所以先来了解一些相关的锁知识。

java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。

java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，知道线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。

java的对象锁和类锁：java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，两个锁实际是有很大的区别的，对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的

 
 到这里，对synchronized的用法已经有了一定的了解。这时有一个疑问，既然有了synchronized修饰方法的同步方式，为什么还需要synchronized修饰同步代码块的方式呢？而这个问题也是synchronized的缺陷所在

 
 synchronized的缺陷：当某个线程进入同步方法获得对象锁，那么其他线程访问这里对象的同步方法时，必须等待或者阻塞，这对高并发的系统是致命的，这很容易导致系统的崩溃。如果某个线程在同步方法里面发生了死循环，那么它就永远不会释放这个对象锁，那么其他线程就要永远的等待。这是一个致命的问题。

一个类的对象锁和另一个类的对象锁是没有关联的，当一个线程获得A类的对象锁时，它同时也可以获得B类的对象锁。

可能上面只有理论和代码，对刚接触的人比较难理解，下面举一个例子，

打个比方：一个object就像一个大房子，大门永远打开。房子里有 很多房间（也就是方法）。

 
这些房间有上锁的（synchronized方法）， 和不上锁之分（普通方法）。房门口放着一把钥匙（key），这把钥匙可以打开所有上锁的房间。

另外我把所有想调用该对象方法的线程比喻成想进入这房子某个 房间的人。所有的东西就这么多了，下面我们看看这些东西之间如何作用的。

 
在此我们先来明确一下我们的前提条件。该对象至少有一个synchronized方法，否则这个key还有啥意义。当然也就不会有我们的这个主题了。

 
一个人想进入某间上了锁的房间，他来到房子门口，看见钥匙在那儿（说明暂时还没有其他人要使用上锁的 房间）。于是他走上去拿到了钥匙，并且按照自己 的计划使用那些房间。注意一点，他每次使用完一次上锁的房间后会马上把钥匙还回去。即使他要连续使用两间上锁的房间，中间他也要把钥匙还回去，再取回来。

 
因此，普通情况下钥匙的使用原则是：“随用随借，用完即还。”

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

以通讯为例   
           同步:发送一个请求,等待返回,然后再发送下一个请求   
           异步:发送一个请求,不等待返回,随时可以再发送下一个请求   
           并发:同时发送多个请求

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

你好，提问者：
    1、启动一个线程是start()方法。
    2、启动线程之后start()方法会去调用run方法内容。
    区别：start是创建并启动一个线程，而run是要运行线程中的代码。

 

一、区别

Java中启动线程有两种方法，继承Thread类和实现Runnable接口，由于Java无法实现多重继承，所以一般通过实现Runnable接口来创建线程。但是无论哪种方法都可以通过start()和run()方法来启动线程，下面就来介绍一下他们的区别。

start方法：

通过该方法启动线程的同时也创建了一个线程，真正实现了多线程。无需等待run()方法中的代码执行完毕，就可以接着执行下面的代码。此时start()的这个线程处于就绪状态，当得到CPU的时间片后就会执行其中的run()方法。这个run()方法包含了要执行的这个线程的内容，run()方法运行结束，此线程也就终止了。

run方法：

通过run方法启动线程其实就是调用一个类中的方法，当作普通的方法的方式调用。并没有创建一个线程，程序中依旧只有一个主线程，必须等到run()方法里面的代码执行完毕，才会继续执行下面的代码，这样就没有达到写线程的目的。

下面我们通过一个很经典的题目来理解一下：

public class Test {

    public static void main(String[] args) {

        Thread t = new Thread(){

            public void run() {

                pong();

            }

        };

        t.run();

        System.out.println("ping");

    }

    static void pong() {

        System.out.println("pong");

    }

}

代码如图所示，那么运行程序，输出的应该是什么呢？没错，输出的是”pong ping”。因为t.run()实际上就是等待执行new Thread里面的run()方法调用pong()完毕后，再继续打印”ping”。它不是真正的线程。

而如果我们将t.run();修改为t.start();那么，结果很明显就是”ping pong”，因为当执行到此处，创建了一个新的线程t并处于就绪状态，代码继续执行，打印出”ping”。此时，执行完毕。线程t得到CPU的时间片，开始执行，调用pong()方法打印出”pong”。

如果感兴趣，还可以多加几条语句自己看看效果。

 

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

线程池可以解决两个不同问题：由于减少了每个任务调用的开销，它们通常可以在执行大量异步任务时提供增强的性能，并且还可以提供绑定和管理资源（包括执行任务集时使用的线程）的方法。

 

Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。下面这张图完整描述了线程池的类体系结构。

                       

几个比较重要的类

ExecutorService： 真正的线程池接口。
ScheduledExecutorService 能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。
ThreadPoolExecutor ExecutorService的默认实现。

 

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

缓存型池子通常用于执行一些生存期很短的异步型任务
newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
newSingleThreadExecutor：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

 

官方的API中建议大家尽量使用上述的工厂方法。但是如果你想定制更灵活的Executor，可以通过ThreadPoolExcutor类，如果甚有其他的需求，可以去参照ThreadPoolExcutor类的源码。

线程池类为 java.util.concurrent.ThreadPoolExecutor，常用构造方法为： 
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) 
 
corePoolSize： 线程池维护线程的最少数量
maximumPoolSize：线程池维护线程的最大数量
keepAliveTime： 线程池维护线程所允许的空闲时间
unit： 线程池维护线程所允许的空闲时间的单位
workQueue： 线程池所使用的缓冲队列
handler： 线程池对拒绝任务的处理策略

 

当一个任务通过execute(Runnable)方法欲添加到线程池时： 
a，如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
b，如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
c，如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
d，如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。
e，当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

 

unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：
NANOSECONDS、
MICROSECONDS、
MILLISECONDS、
SECONDS。

 

当 Executor 已经关闭，并且 Executor 将有限边界用于最大线程和工作队列容量，且已经饱和时，在方法 execute(java.lang.Runnable) 中提交的新任务将被拒绝。
A.        在默认的 ThreadPoolExecutor.AbortPolicy 中，处理程序遭到拒绝将抛出运行时 RejectedExecutionException。
B.        在 ThreadPoolExecutor.CallerRunsPolicy 中，线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。
C.        在 ThreadPoolExecutor.DiscardPolicy 中，不能执行的任务将被删除。
D.        在 ThreadPoolExecutor.DiscardOldestPolicy 中，如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。

 

下面看看具体的几个工厂方法的实现，

public static ExecutorService newFixedThreadPool(int nThreads) {

        return new ThreadPoolExecutor(nThreads, nThreads,

                                      0L, TimeUnit.MILLISECONDS,

                                      new LinkedBlockingQueue<Runnable>());

    }

相同的corePoolSize和maximumPoolSize的大小，未设置keep alive，BlockingQueue选择了LinkedBlockingQueue，该queue有一个特点，他是无界的。

 

public static ExecutorService newSingleThreadExecutor() {

        return new FinalizableDelegatedExecutorService

            (new ThreadPoolExecutor(1, 1,

                                    0L, TimeUnit.MILLISECONDS,

                                    new LinkedBlockingQueue<Runnable>()));

    }

同上一个比，size都设置为1

 

public static ExecutorService newCachedThreadPool() {

        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

                                      60L, TimeUnit.SECONDS,

                                      new SynchronousQueue<Runnable>());

    }

maximumPoolSize大小为big，其次BlockingQueue的选择上使用SynchronousQueue。简单说：该QUEUE中，每个插入操作必须等待另一个线程的对应移除操作。比如，我先添加一个元素，接下来如果继续想尝试添加则会阻塞，直到另一个线程取走一个元素，反之亦然。（想到什么？就是缓冲区为1的生产者消费者模式^_^）


先从BlockingQueue<Runnable> workQueue这个入参开始说起。在JDK中，其实已经说得很清楚了，一共有三种类型的queue。以下为引用：（我会稍微修改一下，并用红色突出显示） 
 
所有 BlockingQueue 都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互：
如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，而不进行排队。（什么意思？如果当前运行的线程小于corePoolSize，则任务根本不会存放，添加到queue中，而是直接抄家伙（thread）开始运行）
如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。
如果无法将请求加入队列，则创建新的线程，除非创建此线程超出 maximumPoolSize，在这种情况下，任务将被拒绝。
先不着急举例子，因为首先需要知道queue上的三种类型。

排队有三种通用策略：
直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。  

总结：
ThreadPoolExecutor的使用还是很有技巧的。
使用无界queue可能会耗尽系统资源。
使用有界queue可能不能很好的满足性能，需要调节线程数和queue大小
线程数自然也有开销，所以需要根据不同应用进行调节。

 

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

线程与进程区别

一个进程有一个或多个线程。线程更细化于进程，使得多线程程序的并发性高。进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

线程在执行过程中与进程的区别在于每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用来实现进程的调度和管理以及资源分配。

 

线程状态

1.新建

new语句创建的线程对象处于新建状态，此时它和其他java对象一样，仅被分配了内存。

2.等待

当线程在new之后，并且在调用start方法前，线程处于等待状态。

3.就绪

当一个线程对象创建后，其他线程调用它的start()方法，该线程就进入就绪状态。处于这个状态的线程位于Java虚拟机的可运行池中，等待cpu的使用权。

4.运行状态

处于这个状态的线程占用CPU，执行程序代码。在并发运行环境中，如果计算机只有一个CPU，那么任何时刻只会有一个线程处于这个状态。

只有处于就绪状态的线程才有机会转到运行状态。

5.阻塞状态

阻塞状态是指线程因为某些原因放弃CPU，暂时停止运行。当线程处于阻塞状态时，Java虚拟机不会给线程分配CPU，直到线程重新进入就绪状态，它才会有机会获得运行状态。

阻塞状态分为三种:

1、等待阻塞:运行的线程执行wait（）方法，JVM会把该线程放入等待池中。

2、同步阻塞:运行的线程在获取对象同步锁时，若该同步锁被别的线程占用，则JVM会把线程放入锁池中。

3、其他阻塞:运行的线程执行Sleep（）方法，或者发出I/O请求时，JVM会把线程设为阻塞状态。当Sleep（）状态超时、或者I/O处理完毕时，线程重新转入就绪状态。

6.死亡状态

当线程执行完run()方法中的代码，或者遇到了未捕获的异常，就会退出run()方法，此时就进入死亡状态，该线程结束生命周期。

 

状态之间的转换

 

参照别人做的图：

 

68、Java中如何实现序列化，有什么意义？

序列化的过程就是对象写入字节流和从字节流中读取对象。
java对象序列化可以保留一个对象的数据，而且还可以递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用对象序列化可以进行对象的“深复制”，即复制对象本身及引用的对象本身。序列化一个对象可 能得到整个对象序列。
序列化分为两大部分：序列化和反序列化。序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例。

要实现序列化，需要让一个类实现Serializable接口，该接口是一个标识性接口，标注该类对象是可被序列化的，然后使用一个输出流来构造一个对象输出流并通过writeObject(Object)方法就可以将实现对象写出（即保存其状态）；如果需要反序列化则可以用一个输入流建立对象输入流，然后通过readObject方法从流中读取对象。序列化除了能够实现对象的持久化之外，还能够用于对象的深度克隆。

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

1. import java.io.BufferedReader;  
2. import java.io.FileReader;  
3.    
4. public final class MyUtil {  
5.    
6.     // 工具类中的方法都是静态方式访问的，因此将构造器私有，不允许创建对象（绝对好习惯）  
7.     private MyUtil() {  
8.         throw new AssertionError();  
9.     }  
10.    
11.     /** 
12.      * 统计给定文件中给定字符串的出现次数 
13.      *  
14.      * @param filename  文件名 
15.      * @param word 字符串 
16.      * @return 字符串在文件中出现的次数 
17.      */  
18.     public static int countWordInFile(String filename, String word) {  
19.         int counter = 0;  
20.         try (FileReader fr = new FileReader(filename)) {  
21.             try (BufferedReader br = new BufferedReader(fr)) {  
22.                 String line = null;  
23.                 while ((line = br.readLine()) != null) {  
24.                     int index = -1;  
25.                     while (line.length() >= word.length() && (index = line.indexOf(word)) >= 0) {  
26.                         counter++;  
27.                         line = line.substring(index + word.length());  
28.                     }  
29.                 }  
30.             }  
31.         } catch (Exception ex) {  
32.             ex.printStackTrace();  
33.         }  
34.         return counter;  
35.     }  
36.    
37. }  

71、如何用Java代码列出一个目录下所有的文件？

38. class Test12 {

1. 39.  
2. 40.     public static void main(String[] args) {
3. 41.         File f = new File("/Users/Hao/Downloads");
4. 42.         for(File temp : f.listFiles()) {
5. 43.             if(temp.isFile()) {
6. 44.                 System.out.println(temp.getName());
7. 45.             }
8. 46.         }
9. 47.     }

48.}

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

权声明：本文为博主原创文章，未经博主允许不得转载。

a: 两种定义形式 dtd（文档类型定义）  schema（XML模式）；

b: XML Schema和DTD都用于文档验证，但二者还有一定区别，本质区别:schema本身是xml的，可以被XML解析器解析(这也是从DTD上发展schema的根本目的)。另外：

XML Schema是内容开放模型，可扩展，功能性强；而DTD可扩展性差；

XML Schema支持丰富的数据类型，而DTD不支持元素的数据类型，对属性的类型定义也很有限；

XML Schema支持命名空间机制，而DTD不支持；

XML Schema可针对不同情况对整个XML文档或文档局部进行验证；而DTD缺乏这种灵活性；

XML Schema完全遵循XML规范，符合XML语法，可以和DOM结合使用，功能强大；而DTD语法本身有自身的语法和要求，难以学习；

c:有DOM（文档对象模型）,SAX（Simple API for XML）,STAX等

    DOM:文档驱动，处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问

SAX:不同于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问，且是只读的。当前浏览器不支持SAX

SAXParserFactory factory= SAXParserFactory.newInstance();

SAXParser saxparser= factory.newSAXParser();//创建SAX解析器

MyHandler handler=new MyHandler();//创建事件处理器

saxParser.parse(new File(“Sax_1.xml”),handler);//绑定文件和事件处理者

STAX:Streaming API for XML (StAX) Streaming API for XML (StAX)

是用 Java™ 语言处理 XML 的最新标准。StAX 与其他方法的区别就在于应用程序能够把 XML 作为一个事件流来处理。StAX 允许应用程序代码把这些事件逐个拉出来，而不用提供在解析器方便时从解析器中接收事件的处理程序。

75、阐述JDBC操作数据库的步骤。

JDBC操作数据库的基本步骤：

    1）加载（注册）数据库驱动（到JVM）。

    2）建立（获取）数据库连接。

    3）创建（获取）数据库操作对象。

    4）定义操作的SQL语句。

    5）执行数据库操作。

    6）获取并操作结果集。

   7）关闭对象，回收数据库资源（关闭结果集-->关闭数据库操作对象-->关闭连接）。

package com.yangshengjie.jdbc;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

 

public class JDBCTest {

         /**

          * 使用JDBC连接并操作mysql数据库

          */

         public static void main(String[] args) {

                 // 数据库驱动类名的字符串

                 String driver = "com.mysql.jdbc.Driver";

                 // 数据库连接串

                 String url = "jdbc:mysql://127.0.0.1:3306/jdbctest";

                 // 用户名

                 String username = "root";

                 // 密码

                 String password = "mysqladmin";

                 Connection conn = null;

                 Statement stmt = null;

                 ResultSet rs = null;

                 try {

                          // 1、加载数据库驱动（ 成功加载后，会将Driver类的实例注册到DriverManager类中）

                          Class.forName(driver );

                          // 2、获取数据库连接

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

                          // 3、获取数据库操作对象

                          stmt = conn.createStatement();

                          // 4、定义操作的SQL语句

                          String sql = "select * from user where id = 100";

                          // 5、执行数据库操作

                          rs = stmt.executeQuery(sql);

                          // 6、获取并操作结果集

                          while (rs.next()) {

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

                                   System.out.println(rs.getString("name"));

                          }

                 } catch (Exception e) {

                          e.printStackTrace();

                 } finally {

                          // 7、关闭对象，回收数据库资源

                          if (rs != null) { //关闭结果集对象

                                   try {

                                            rs.close();

                                   } catch (SQLException e) {

                                            e.printStackTrace();

                                   }

                          }

                          if (stmt != null) { // 关闭数据库操作对象

                                   try {

                                            stmt.close();

                                   } catch (SQLException e) {

                                            e.printStackTrace();

                                   }

                          }

                          if (conn != null) { // 关闭数据库连接对象

                                   try {

                                            if (!conn.isClosed()) {

                                                    conn.close();

                                            }

                                   } catch (SQLException e) {

                                            e.printStackTrace();

                                   }

                          }

                 }

         }

}

 

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

与Statement相比:

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

②PreparedStatement中的SQL语句是可以带参数的，避免了用字符串连接拼接SQL语句的麻烦和不安全；

③当批量处理SQL或频繁执行相同的查询时，PreparedStatement有明显的性能上的优势，由于数据库可以将编译优化后的SQL语句缓存起来，下次执行相同结构的语句时就会很快（不用再次编译和生成执行计划）

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

1. 使用数据连接池(Connection Pool), 避免使用DriverManager.getConnection。2. 合理的配置数据连接池参数，设置数据连接池的初始大小，最大连接数，连接超时时间等。3. 选择合适的事务等级，按照不同的数据库操作类型选择不同的事务等级。4. 及时关闭Connection，不关闭的话会严重影响系统的性能，甚至造成系统罢工。5. 优化Statement1) 选择合适的Statement, 根据不同的数据库操作选择Statement, PreparedStatement 或者 CallableStatement， 具体选择哪个可以通过搜索引擎了解。2) 尽可能的使用batch, 这样可以减少调 用JDBC的次数。 具体的方法是使用statement.addBatch("your sql") 添加batch, 然后执行statement.executeBatch()来一起执行。3) Statement执行完毕后关闭Statement6. 优化你的SQL, 尽量减少你的结果集，不要每次都"select * from XXX"7. 使用一些缓存工具进行缓存，特别是大数据量大访问量的系统，合理的缓存往往会显著的提高系统的

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

由于创建连接和释放连接都有很大的开销（尤其是数据库服务器不在本地时，每次建立连接都需要进行TCP的三次握手，释放连接需要进行TCP四次握手，造成的开销是不可忽视的）。

为了提升系统访问数据库的性能，可以事先创建若干连接置于连接池中，需要时直接从连接池获取，使用结束时归还连接池而不必关闭连接，从而避免频繁创建和释放连接所造成的开销，这是典型的用空间换取时间的策略（浪费了空间存储连接，但节省了创建和释放连接的时间）。

 

80、事务的ACID是指什么？

在JDBC的数据库操作中，一项事务是由一条或是多条表达式所组成的一个不可分割的工作单元。我们通过提交commit()或是回退rollback()来结束事务的操作。关于事务操作的方法都位于接口java.sql.Connection中。

首先我们要注意，在JDBC中，事务操作默认是自动提交。也就是说，一条对数据库的更新表达式代表一项事务操作。操作成功后，系统将自动调用commit()来提交，否则将调用rollback()来回退。

其次，在JDBC中，可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务，在操作完成 后调用commit()来进行整体提交。倘若其中一个表达式操作失败，都不会执行到commit()，并且将产生响应的异常。此时就可以在异常捕获时调用 rollback()进行回退。这样做可以保持多次更新操作后，相关数据的一致性。

85、获得一个类的类对象有哪些方式？

- 方法1：类型.class，例如：String.class
- 方法2：对象.getClass()，例如："hello".getClass()
- 方法3：Class.forName()，例如：Class.forName("java.lang.String")

JAVA有三种方式可以获得Class对象

1、通过类名.class方式获得，Class<?>  cType = ClassName.class;

public class Client {
public static void main(String[] args) {
Class<?> cType1 = Test.class;
}
}
class Test{
static { 

                System.out.println("static block");

}

{
System.out.println("dynamic block");
}
}

2、通过Class.forName()方法获得，Class<?>  cType = Class.forName("类全名");

package com.lynstudy;
public class Client {
public static void main(String[] args) {
try {
Class<?> cType2 = Class.forName("com.lynstudy.Test");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
class Test{
static {
System.out.println("static block");
}
{
System.out.println("dynamic block");
}
}

3、通过对象名.getClass()方法获取，Class<?> cType3 = objName.getClass();

package com.lynstudy;
public class Client {
public static void main(String[] args) {
Class<?> cType3 = new Test().getClass();
}
}
class Test{
static {
System.out.println("static block");
}
{
System.out.println("dynamic block");
}
}

 

总结：三种方式均能够获得Class对象，区别是方法一不执行静态块和动态构造块，方法二执行静态块、不执行动态构造块，方法三需要创建对象，静态块和动态构造块均会执行；

 

81、JDBC中如何进行事务处理？
82、JDBC能否处理Blob和Clob？
83、简述正则表达式及其用途。
84、Java中是如何支持正则表达式操作的？
85、获得一个类的类对象有哪些方式？
86、如何通过反射创建对象？

Class classType = Class.forName("lxf.Person");
		Object obj = classType.newInstance();

根据以上代码：.使用反射机制创建对象的步骤如下：
1、先声明你要创建的对象的类全称；使用Class类的静态方法forName(String.className)加载这个类的字节码（注意，加载字节码不等于实例化对象） ，返回 一个Class对象，这个对象代表的是一个字节码文件。

2、调用这个类对象（字节码）的方法newInstance()方法（注意：这里的这个newInstance方法默认调用默认的构造方法即调用无参的构造方法， 一旦构造方法有参数时，此方法行不通，需要使用构造方法的对象的相关方法来 实例化）实例化类Person，返回的是Object类型
3、强制转换成Person类型即你所需类型
87、如何通过反射获取和设置对象私有字段的值？

88、如何通过反射调用对象的方法？

这个属于java反射机制范围：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这 种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。主要功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对 象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法，生成动态代理。

动态执行当前类或其父类的方法，支持私有方法。

具体实现方法如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

public static void main(String[] args) throws Exception{     Class c = Dynamic.class;//得到对象     Method[] methods = c.getDeclaredMethods();//得到方法     for(Method method : methods){       System.out.print(method.getName());//打印参数名      Class[] parameterTypes = method.getParameterTypes();       for(int i=0;i<parameterTypes.length;i++){           String nameString=parameterTypes[i].getName();           System.out.print("parameterType:"+nameString);//打印方法参数类型      }               System.out.print("ReturnType:"+method.getReturnType());           System.out.println();       }         Object obj=c.newInstance();//获取到方法对象,假设方法的参数是一个int,String,method名为getAge       Method sAge = c.getMethod("getAge", new Class[] {int.class,String.class});       //获得参数Object        Object[] arguments = new Object[]{new Integer(23),new String("abc")};       //执行方法       String s=(String)sAge.invoke(obj , arguments);      System.out.print(s);      }        public String  getAge(int age,String name){            return name+": "+age;      } }

89、简述一下面向对象的"六原则一法则"。
90、简述一下你了解的设计模式。
91、用Java写一个单例类。

- 饿汉式单例

1 2 3 4 5 6 7

public class Singleton {     private Singleton(){}     private static Singleton instance = new Singleton();     public static Singleton getInstance(){         return instance;     } }

• 懒汉式单例

1 2 3 4 5 6 7 8

public class Singleton {     private static Singleton instance = null;     private Singleton() {}     public static synchronized Singleton getInstance(){         if (instance == null) instance ＝ new Singleton();         return instance;     } }

注意：实现一个单例有两点注意事项，①将构造器私有，不允许外界通过构造器创建对象；②通过公开的静态方法向外界返回类的唯一实例。这里有一个问题可以思考：Spring的IoC容器可以为普通的类创建单例，它是怎么做到的呢？

92、什么是UML？
93、UML中有哪些常用的图？
94、用Java写一个冒泡排序。
95、用Java写一个折半查找。

Java面试题全集（以下列出题目，看答案请转至：Java面试题全集（中））

96、阐述Servlet和CGI的区别?
97、Servlet接口中有哪些方法？
98、转发（forward）和重定向（redirect）的区别？
99、JSP有哪些内置对象？作用分别是什么？
100、get和post请求的区别？

2．GET与POST区别

HTTP 定义了与服务器交互的不同方法，最基本的方法是 GET 和 POST（开发关心的只有GET请求和POST请求）。

GET与POST方法有以下区别：

（1） 在客户端，Get方式在通过URL提交数据，数据在URL中可以看到；POST方式，数据放置在HTML HEADER内提交。

（2） GET方式提交的数据最多只能有1024字节，而POST则没有此限制。

（3） 安全性问题。正如在（1）中提到，使用 Get的时候，参数会显示在地址栏上，而 Post不会。所以，如果这些数据是中文数据而且是非敏感数据，那么使用 get；如果用户输入的数据不是中文字符而且包含敏感数据，那么还是使用 post为好。

（4） 安全的和幂等的。所谓安全的意味着该操作用于获取信息而非修改信息。幂等的意味着对同一 URL的多个请求应该返回同样的结果。完整的定义并不像看起来那样严格。换句话说，GET请求一般不应产生副作用。从根本上讲，其目标是当用户打开一个链接时，她可以确信从自身的角度来看没有改变资源。比如，新闻站点的头版不断更新。虽然第二次请求会返回不同的一批新闻，该操作仍然被认为是安全的和幂等的，因为它总是返回当前的新闻。反之亦然。POST请求就不那么轻松了。POST表示可能改变服务器上的资源的请求。仍然以新闻站点为例，读者对文章的注解应该通过 POST请求实现，因为在注解提交之后站点已经不同了（比方说文章下面出现一条注解）。
101、常用的Web服务器有哪些？
102、JSP和Servlet是什么关系？

应用服务器处理业务逻辑，web服务器是用于处理HTML文件的。

web服务器通常比应用服务器简单，如apache就是web服务器，
Jboss就是EJB应用服务器。

应用服务器：Weblogic、Tomcat、Jboss
WEB SERVER：IIS、 Apache
103、讲解JSP中的四种作用域。

应用服务器处理业务逻辑，web服务器是用于处理HTML文件的。

web服务器通常比应用服务器简单，如apache就是web服务器，
Jboss就是EJB应用服务器。

应用服务器：Weblogic、Tomcat、Jboss
WEB SERVER：IIS、 Apache，Nginx
104、如何实现JSP或Servlet的单线程模式？
105、实现会话跟踪的技术有哪些？
106、过滤器有哪些作用和用法？
107、监听器有哪些作用和用法？
108、web.xml文件中可以配置哪些内容？
109、你的项目中使用过哪些JSTL标签？
110、使用标签库有什么好处？如何自定义JSP标签？
111、说一下表达式语言（EL）的隐式对象及其作用。
112、表达式语言（EL）支持哪些运算符？
113、Java Web开发的Model 1和Model 2分别指的是什么？
114、Servlet 3中的异步处理指的是什么？
115、如何在基于Java的Web项目中实现文件上传和下载？
116、服务器收到用户提交的表单数据，到底是调用Servlet的doGet()还是doPost()方法？
117、JSP中的静态包含和动态包含有什么区别？
118、Servlet中如何获取用户提交的查询参数或表单数据？
119、Servlet中如何获取用户配置的初始化参数以及服务器上下文参数？
120、如何设置请求的编码以及响应内容的类型？
121、解释一下网络应用的模式及其特点。
122、什么是Web Service（Web服务）？
123、概念解释：SOAP、WSDL、UDDI。
124、Java规范中和Web Service相关的规范有哪些？
125、介绍一下你了解的Java领域的Web Service框架。

 

 

 

 http://blog.csdn.net/jackfrued/article/details/44931161

 

126、什么是ORM？
127、持久层设计要考虑的问题有哪些？你用过的持久层框架有哪些？
128、Hibernate中SessionFactory是线程安全的吗？Session是线程安全的吗（两个线程能够共享同一个Session吗）？
129、Hibernate中Session的load和get方法的区别是什么？
130、Session的save()、update()、merge()、lock()、saveOrUpdate()和persist()方法分别是做什么的？有什么区别？
131、阐述Session加载实体对象的过程。
132、Query接口的list方法和iterate方法有什么区别？
133、Hibernate如何实现分页查询？
134、锁机制有什么用？简述Hibernate的悲观锁和乐观锁机制。
135、阐述实体对象的三种状态以及转换关系。
136、如何理解Hibernate的延迟加载机制？在实际应用中，延迟加载与Session关闭的矛盾是如何处理的？
137、举一个多对多关联的例子，并说明如何实现多对多关联映射。
138、谈一下你对继承映射的理解。
139、简述Hibernate常见优化策略。
140、谈一谈Hibernate的一级缓存、二级缓存和查询缓存。
141、Hibernate中DetachedCriteria类是做什么的？
142、@OneToMany注解的mappedBy属性有什么作用？
143、MyBatis中使用<code>#</code>和<code>$</code>书写占位符有什么区别？
144、解释一下MyBatis中命名空间（namespace）的作用。
145、MyBatis中的动态SQL是什么意思？
146、什么是IoC和DI？DI是如何实现的？
147、Spring中Bean的作用域有哪些？
148、解释一下什么叫AOP（面向切面编程）？
149、你是如何理解"横切关注"这个概念的？
150、你如何理解AOP中的连接点（Joinpoint）、切点（Pointcut）、增强（Advice）、引介（Introduction）、织入（Weaving）、切面（Aspect）这些概念？
151、Spring中自动装配的方式有哪些？
152、Spring中如何使用注解来配置Bean？有哪些相关的注解？
153、Spring支持的事务管理类型有哪些？你在项目中使用哪种方式？
154、如何在Web项目中配置Spring的IoC容器？
155、如何在Web项目中配置Spring MVC？
156、Spring MVC的工作原理是怎样的？
157、如何在Spring IoC容器中配置数据源？
158、如何配置配置事务增强？
159、选择使用Spring框架的原因（Spring框架为企业级开发带来的好处有哪些）？
160、Spring IoC容器配置Bean的方式？
161、阐述Spring框架中Bean的生命周期？
162、依赖注入时如何注入集合属性？
163、Spring中的自动装配有哪些限制？
164、在Web项目中如何获得Spring的IoC容器？
165. 大型网站在架构上应当考虑哪些问题？
166、你用过的网站前端优化的技术有哪些？
167、你使用过的应用服务器优化技术有哪些？
168、什么是XSS攻击？什么是SQL注入攻击？什么是CSRF攻击？
169. 什么是领域模型(domain model)？贫血模型(anaemic domain model)和充血模型(rich domain model)有什么区别？
170. 谈一谈测试驱动开发（TDD）的好处以及你的理解。