Java中的比较

Java SE、Java EE、Java ME区别

是什么：

Java SE=Java Standard Edition=J2SE= Java标准版

Java EE=Java Enterprise Edition=J2EE= Java企业版

Java ME=Java Mobile Edition=J2ME = Java移动版

特点：

SE主要用于桌面程序（Swing），控制台开发(main程序)。

EE企业级开发(JSP，Struts，Spring，Hibernate，EJB，iBATIS等)，用于企业级软件开发，网络开发，Web开发。

ME嵌入式开发(手机，小家电，PDA)。[苹果的IOS，黑莓]

三者之间的关系：

Java SE就是基于JDK和JRE的。

Java SE为Java EE提供了基础。

Java SE包括用于开发Java Web的类库

Java EE除了基于我们这个所谓的Java SE外，还新加了企业应用所需的类库

Java EE技术的基础就是核心Java SE或J2SE

JDK、JRE、JVM的区别

JDK[Java Development Kit]就是Java开发工具箱， JDK是整个Java的核心里边包含了JRE，它除了包含JRE之外还包含了一些javac的工具类，把Java源文件编译成class文件，Java文件是用来运行这个程序的，除此之外，里边还包含了Java源生的API，java.lang.Integer在rt.jar包里边[可以在项目中看到]，通过rt.jar这个架包来调用我们的这些IO流写入写出等

JDK有以下三种版本：

Java SE，Standard Edition，标准版，是我们通常用的一个版本

Java EE，Enterpsise Edtion，企业版，使用这种JDK开发J2EE应用程序

Java ME，Mobile Edtion，移动版，主要用于移动设备、嵌入式设备上的Java应用程序

JRE[Java Runtime Enviromental]是Java运行时环境，那么所谓的Java运行时环境，就是为了保证Java程序能够运行时，所必备的一基础环境，也就是它只是保证Java程序运行的，不能用来开发，而JDK才是用来开发的，所有的Java程序都要在JRE下才能运行。

包括JVM和Java核心类库和支持文件。与JDK相比，它不包含开发工具——编译器、调试器和其它工具。

JRE里边包含JVM

JVM：[Java Virtual Mechinal]，Java虚拟机，因为JRE是Java运行时环境，Java运行靠什么运行，而底层就是依赖于JVM，即Java虚拟机，Java虚拟机用来加载类文件，Java中之所以有跨平台的作用，就是因为拥有JVM

关系：

Java SE是基于JDK和JRE，

JDK是整个Java的核心里边包含了JRE，

JRE里边包含JVM。

说说&和&&的区别。

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

&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if(str != null && !str.equals(""))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException，如果将&&改为&，则会抛出NullPointerException异常。又例如，当x!=33时，执行if(x==33 & ++y>0) y会增长，if(x==33 && ++y>0)不会增长

&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 &0x0f的结果为0x01。

备注：这道题先说两者的共同点，再说出&&和&的特殊之处，并列举一些经典的例子来表明自己理解透彻深入、实际经验丰富。

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

对于short s1 = 1; s1 = s1 + 1; 加号右边为1是int型，加号左边s1是short类型，为了避免降低数据的精度，s1+1运算时会自动提升表达式的类型，所以右边结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。

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

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

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

如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。

equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：

String a=new String("foo");

String b=new String("foo");

两条new语句创建了两个对象，然后用a，b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。

在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input = …;input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。

如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：

boolean equals(Object o){

return this==o;

}

这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

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

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

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

例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个staticVar变量，并且每创建一个实例对象，这个staticVar就会加1；但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。

public class VariantTest{ public static int staticVar = 0; public int instanceVar = 0; public VariantTest(){ staticVar++; instanceVar++; System.out.println(“staticVar=” + staticVar  + ”,instanceVar=” + instanceVar); } }

备注：这个解答除了说清楚两者的区别外，最后还用一个具体的应用例子来说明两者的差异，体现了自己有很好的解说问题和设计案例的能力，思维敏捷，超过一般程序员，有写作能力！

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中还定义了表示整数的最大值和最小值的常量。

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

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

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

重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。

至于Overloaded的方法是否可以改变返回值的类型这个问题，要看你到底想问什么呢？这个题目很模糊。如果几个Overloaded的方法的参数列表不一样，它们的返回者类型当然也可以不一样。但我估计你想问的问题是：如果两个方法的参数列表完全一样，是否可以让它们的返回值不同来实现重载Overload。这是不行的，我们可以用反证法来说明这个问题，因为我们有时候调用一个方法时也可以不定义返回结果变量，即不要关心其返回结果，例如，我们调用map.remove(key)方法时，虽然remove方法有返回值，但是我们通常都不会定义接收返回结果的变量，这时候假设该类中有两个名称和参数列表完全相同的方法，仅仅是返回类型不同，Java就无法确定编程者倒底是想调用哪个方法了，因为它无法通过返回结果类型来判断。

Override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖时要注意以下的几点：

1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；

3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

Overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，JVM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：

1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int);

2、不能通过访问权限、返回类型、抛出的异常进行重载；

3、方法的异常类型和数目不会对重载造成影响；

4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

抽象类和接口的区别

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

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

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

1. 抽象类中可以有普通成员变量、静态成员变量，且静态成员变量的访问类型可以任意。但接口中定义的变量只能是public static final类型的，没有普通成员变量。

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

3. 抽象类中可以包含非抽象的普通方法、静态方法。抽象方法的访问类型可以是public，protected的。但接口中的所有方法必须都是抽象的，不能有非抽象的普通方法、不能包含静态方法、抽象方法只能是public类型的，而且默认即为public abstract类型。

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

下面接着再说说两者在应用上的区别：

接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码，伪代码如下：

public abstract class BaseServlet extends HttpServlet{
public final void service(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException {
//记录访问日志，进行权限判断
if(具有权限){
try{
doService(request,response);
} catch(Excetpion e) {
//记录异常信息
      }
   }
}
protected abstract void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException{
//注意访问权限定义成protected，显得既专业，又严谨，因为它是专门给子类用的
 }
}
public class MyServlet1 extends BaseServlet {
        protected void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException {
//本Servlet只处理的具体业务逻辑代码
   }
}

父类方法中间的某段代码不确定，留给子类干，就用模板方法设计模式。

什么是内部类？static nested class和inner class的不同。

内部类就是在一个类的内部定义的类，内部类中不能定义静态成员变量（静态成员变量不是对象的特性，只是为了找一个容身之处，所以需要放到一个类中而已，这么一点小事，你还要把它放到类内部的一个类中，过分了啊！提供内部类，不是为让你干这种事情，无聊，不让你干。我想可能是既然静态成员变量类似C语言的全局变量，而内部类通常是用于创建内部对象用的，所以，把“全局变量”放在内部类中就是毫无意义的事情，既然是毫无意义的事情，就应该被禁止），内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中，如下所示：

public class Outer { int out_x  = 0; public void method() { Inner1 inner1 = new Inner1(); public class Inner2 { //在方法体内部定义的内部类 public void method() { out_x = 3; } } Inner2 inner2 = new Inner2(); } //在方法体外面定义的内部类 public class Inner1 { } }

在方法体外面定义的内部类的访问类型可以是public，protected，默认的，private等4种类型，这就好像类中定义的成员变量有4种访问类型一样，它们决定这个内部类的定义对其他类是否可见；对于这种情况，我们也可以在外面创建内部类的实例对象，创建内部类的实例对象时，一定要先创建外部类的实例对象，然后用这个外部类的实例对象去创建内部类的实例对象，代码如下： Outer outer = new Outer(); Outer.Inner1 inner1 = outer.new Innner1();

在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰符。这种内部类对其他类是不可见的其他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问。这种内部类必须是先定义，后使用，即内部类的定义代码必须出现在使用该类之前，这与方法中的局部变量必须先定义后使用的道理也是一样的。这种内部类可以访问方法体中的局部变量，但是，该局部变量前必须加final修饰符。

在方法体内部还可以采用如下语法来创建一种匿名内部类，即定义某一接口或类的子类的同时，还创建了该子类的实例对象，无需为该子类定义名称：

public class Outer {

public void start() {

new Thread(new Runable(){

public void run(){

};

}).start();

}

}

最后，在方法外部定义的内部类前面可以加上static关键字，从而成为static nested class，它不再具有内部类的特性，所有，从狭义上讲，它不是内部类。static nested class与普通类在运行时的行为和功能上没有什么区别，只是在编程引用时的语法上有一些差别，它可以定义成public、protected、默认的、private等多种类型，而普通类只能定义成public和默认的这两种类型。在外面引用static nested class类的名称为“外部类名.内部类名”。在外面不需要创建外部类的实例对象，就可以直接创建static nested class，例如，假设Inner是定义在Outer类中的static nested class，那么可以使用如下语句创建Inner类：

Outer.Inner inner = new Outer.Inner();

由于static nested class不依赖于外部类的实例对象，所以，static nested class能访问外部类的非static成员变量。当在外部类中访问static nested class时，可以直接使用static nested class的名字，而不需要加上外部类的名字了，在static nested class中也可以直接引用外部类的static的成员变量，不需要加上外部类的名字。

在静态方法中定义的内部类也是static nested class，这时候不能在类前面加static关键字，静态方法中的static nested class与普通方法中的内部类的应用方式很相似，它除了可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final修饰符。

备注：首先根据你的印象说出你对内部类的总体方面的特点：例如，在两个地方可以定义，可以访问外部类的成员变量，不能定义静态成员，这是大的特点。然后再说一些细节方面的知识，例如，几种定义方式的语法区别，静态内部类，以及匿名内部类。

String 和StringBuffer的区别

Java平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffer来动态构造字符数据。另外，String实现了equals方法，new String("abc").equals(new String("abc"))的结果为true，而StringBuffer没有实现equals方法，所以，new StringBuffer("abc").equals(new StringBuffer("abc"))的结果为false。

接着要举一个具体的例子来说明，我们要把1到100的所有数字拼起来，组成一个串。

StringBuffer sbf = new StringBuffer();

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

sbf.append(i);

}

上面的代码效率很高，因为只创建了一个StringBuffer对象，而下面的代码效率很低，因为创建了101个对象。

String str = new String();

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

str = str + i;

}

String覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和hashCode方法，所以，将StringBuffer对象存储进Java集合类中时会出现问题。

在讲两者区别时，应把循环的次数搞成10000，然后用endTime-beginTime来比较两者执行的时间差异，最后还要讲讲StringBuilder与StringBuffer的区别。（区别如下）

StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容，可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。（从 JDK 5 开始，为该类补充了一个单个线程使用的等价类，即 StringBuilder。与该类相比，通常应该优先使用 StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。）

StringBuilder一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。（如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。但将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用 StringBuffer。）

StringBuffer和StringBuilder上的主要操作都是append和insert方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append方法始终将这些字符添加到缓冲区的末端；而 insert方法则在指定的点添加字符。

例如，如果z引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。

通常，如果sb引用 StringBuilder的一个实例，则sb.append(x)和sb.insert(sb.length(), x) 具有相同的效果。只要发生有关源序列（如在源序列中追加或插入）的操作，该类就只在执行此操作的字符串缓冲区上而不是在源上实现同步。

final，finally，finalize的区别。

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

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

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

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

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

异常表示程序运行过程中可能出现的非正常状态。

运行时异常表示虚拟机的通常操作中可能遇到的异常，是由于程序错误导致的异常，是一种常见运行错误。

一般异常（其他异常）是程序本身没有错误，但由于像I/O错误这类问题导致的异常。

Java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。因为运行时错误完全在我们的控制之下，与其将更多的时间花费在错误发生的可能性上，还不如将时间花费在修正程序中的错误上。

Error和Exception有什么区别?

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

内存泄露和内存溢出

内存泄露 (Memory Leak)，是指应用程序在申请内存后，无法释放已经申请的内存空间。一次内存泄露危害可以忽略，但如果任其发展最终会导致内存溢出(Out Of Memory)。如读取文件后流要进行及时的关闭以及对数据库连接的释放。内存溢出（Out Of Memory）是指应用程序在申请内存时，没有足够的内存空间供其使用。如我们在项目中对于大批量数据的导入，采用分段批量提交的方式。

线程和进程的区别

1.线程(Thread)与进程（Process）

进程定义的是应用程序与应用程序之间的边界，通常来说一个进程就代表一个与之对应的应用程序。不同的进程之间不能共享代码和数据空间，而同一进程的不同线程可以共享代码和数据空间。

一个进程可以包括若干个线程，同时创建多个线程来完成某项任务，便是多线程。实现线程的两种方式：继承Thread类，实现Runable接口

sleep()和wait()有什么区别

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

sleep就是正在执行的线程主动让出CPU，CPU去执行其他线程，在sleep指定的时间（以毫秒计）过后，CPU才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了CPU，但其他被同步锁挡住了的线程也无法得到执行。wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增加一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态，程序可以再次得到锁后继续向下运行。

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

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

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

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

首先，List与Set具有相似性，它们都是单列元素的集合，继承了共同的父接口，Collection。

List表示有先后顺序的集合， 注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用add(Obj e)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Obj e)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。

Set里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不是仅仅是相同）的对象 ，即假设Set集合中有了一个A对象，现在我要向Set集合再存入一个B对象，但B对象与A对象equals相等，则B对象存储不进去，所以，Set集合的add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true，当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。

Map与List和Set不同，它是双列的集合，其中有put方法，定义如下：put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Object key)返回值为key 所对应的value。另外，也可以获得所有的key的结合，还可以获得所有的value的结合，还可以获得key和value组合成的Map.Entry对象的集合。

List 单列数据集合，以特定次序来持有元素（有顺序），可有重复元素。Set 单列数据集合，内部排序，没有重复元素。Map双列数据集合， 保存key-value值，没有顺序，key不可重复，value可重复。

HashSet按照hashcode值的某种运算方式进行存储，而不是直接按hashCode值的大小进行存储。例如，"abc" ---> 78，"def" ---> 62，"xyz" ---> 65在HashSet中的存储顺序不是62,65,78。HashSet按插入的顺序存储，那被存储对象的hashcode方法还有什么作用呢？想想!hashset集合比较两个对象是否相等，首先看hashcode方法是否相等，然后看equals方法是否相等。new 两个Student插入到HashSet中，看HashSet的size，实现hashcode和equals方法后再看size。

同一个对象可以在Vector中加入多次。往集合里面加元素，相当于集合里用一根绳子连接到了目标对象。往HashSet中却加不了多次的。

说出ArrayList，Vector，LinkedList的存储性能和特性

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素和删除元素要涉及数组元素移动等内存操作，所以索引数据快而插入删除数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以索引数据慢插入删除速度较快。

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

HashMap和Hashtable的区别

HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都实现了Map接口，主要区别在于HashMap允许空（null）键（key）值（value），由于非线程安全，在只有一个线程访问的情况下，效率要高于Hashtable。

HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。

HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey。因为contains方法容易让人引起误解。

Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map接口的一个实现。

最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。

Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

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

Collection 和 Collections的区别。

Collection是集合类的父类接口，继承与他的接口主要有Set 和List。Collections是针对集合类的一个帮助类，是一个封装了众多关于集合操作的静态方法的工具类，因为构造方法是私有的，所以不能实例化。他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

字节流与字符流的区别

要把一片二进制数据逐一输出到某个设备中，或者从某个设备中逐一读取一片二进制数据，不管输入输出设备是什么，我们要用统一的方式来完成这些操作，用一种抽象的方式进行描述，这个抽象描述方式起名为IO流，对应的抽象类为InputStream和OutputStream，不同的实现类就代表不同的输入和输出设备，它们都是针对字节进行操作的。

在应用中，经常要将全部是字符的一段文本输出去或读进来，用字节流可以吗？计算机中的一切最终都是二进制的字节形式存在。对于“中国”这些字符，首先要得到其对应的字节，然后将字节写入到输出流。读取时，首先读到的是字节，可是我们要把它显示为字符，我们需要将字节转换成字符。由于这样的需求很广泛，人家专门提供了字符流的包装类。

底层设备永远只接受字节数据，有时候要写字符串到底层设备，需要将字符串转成字节再进行写入。字符流是字节流的包装，字符流则是直接接受字符串，它内部将串转成字节，再写入底层设备，这为我们向IO设备写入或读取字符串提供了一点点方便。

字符向字节转换时，要注意编码的问题，因为字符串转成字节数组，其实是转成该字符的某种编码的字节形式，读取也是反之的道理。

讲解字节流与字符流关系的代码案例：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class IOTest {
    public static void main(String[] args) throws Exception {
        String str = "中国人";
        // 写出
        /*
         * FileOutputStream fos = new FileOutputStream("1.txt");
         *
         * fos.write(str.getBytes("UTF-8"));
         *
         * fos.close();
         */

        /*
         * FileWriter fw = new FileWriter("1.txt");
         *
         * fw.write(str);
         *
         * fw.close();
         */

        PrintWriter pw = new PrintWriter("1.txt", "utf-8");
        pw.write(str);
        pw.close();

        // 读入
        /*
         * FileReader fr = new FileReader("1.txt");
         *
         * char[] buf = new char[1024];
         *
         * int len = fr.read(buf);
         *
         * String myStr = new String(buf,0,len);
         *
         * System.out.println(myStr);
         */

        /*
         * FileInputStream fr = new FileInputStream("1.txt");
         *
         * byte[] buf = new byte[1024];
         *
         * int len = fr.read(buf);
         *
         * String myStr = new String(buf,0,len,"UTF-8");
         *
         * System.out.println(myStr);
         */

        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("1.txt"),
                "UTF-8"));
        String myStr = br.readLine();
        br.close();
        System.out.println(myStr);
    }
}

heap（堆）和stack（栈）有什么区别。

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

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

UE和UI的区别

UE（User Experience）是用户体验度
UI（User Interface）是用户界面，界面原型（相当于买房时用的模型）
UI设计则是指对软件的人机交互、操作逻辑、界面美观的整体设计。好的UI设计不仅是让软件变得有个性有品味，还要让软件的操作变得舒适、简单、自由、充分体现软件的定位和特点。 在人和机器的互动过程（Human Machine Interaction）中，有一个层面，即我们所说的界面（Interface）。从心理学意义来分，界面可分为感觉（视觉、触觉、听觉等）和情感两个层次。用户界面设计是屏幕产品的重要组成部分。界面设计是一个复杂的有不同学科参与的工程，认知心理学、设计学、语言学等在此都扮演着重要的角色。用户界面设计的三大原则是：置界面于用户的控制之下；减少用户的记忆负担；保持界面的一致性。所以如果我们将来要建网站，就一定要把握好人机交互，在第一时间赢得客户。
设计UI的作用：
1、帮助程序员工作（界面已由美工设计完成）
2、提前让用户对项目有个宏观的了解，知道效果是什么样子。

JSP与Servlet和JavaBean

JSP是Servlet技术的扩展，本质上是Servlet的简易方式，它更强调应用的外表表达，即侧重于视图，而Servlet主要用于控制逻辑。JSP必须被Web服务器编译成Servlet，实际上在Web服务器运行的是Servlet。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP的情况是Java和HTML组合成一个扩展名为.jsp的文件。但因为Servlet开发成本高，而且使用Servlet充当变现层将导致表现层页面难以维护，不利于美工人工参与Servlet开发，所以实际开发中大都使用JSP充当表现层技术。由于JSP只负责简单的显示逻辑，所以JSP无法直接访问应用的底层状态，Java EE应用会使用JavaBean来传输数据，在严格的Java EE应用中，中间层的组件会将应用底层的状态信息封装成JavaBean集，这些JavaBean也被称为DTO（Data Transfer Objdect，数据传输对象），并将这些DTO集传到JSP页面，从而让JSP可以显示应用的底层状态。启动Tomcat之后JSP被Tomcat生成对应Servlet的Java文件和class文件，路径在：<TOMCAT_HOME>\work\Catalina\localhost