常见Java面试题100道

注意：
看代码题的时候，一定要先找主方法，不要从上到下从第一行代码开始看，看主方法中调用了哪些方法，在根据其方法名找其具体方法

1、goto
goto是保留关键字，没有goto语句，也没有任何使用goto关键字的地方

2、break，continue
①单独使用情况下：break语句作用是结束当前的循环迭代体，进而执行剩余的语句。continue语句的作用是结束本次迭代过程，继续执行下一轮迭代。
import java.util.Random;/*** 语句标签测试** @author leizhimin 2009-7-16 11:43:08*/ public class TestLable { public static void main(String[] args) { outer: for (int i = 0; i < 10; i++) { System.out.println("\nouter_loop:" + i); inner: for (int k = 0; i < 10; k++) { System.out.print(k + " “); int x = new Random().nextInt(10); if (x > 7) { System.out.print(” >>x == " + x + “，结束inner循环，继续迭代执行outer循环了！”); continue outer; } if (x == 1) { System.out.print(" >>x == 1，跳出并结束整个outer和inner循环！"); break outer; } } } System.out.println("------>>>所有循环执行完毕！"); }}
3、左结合，右结合
考试

7、char型变量能不能存储一个汉字，为什么？

8、用最有效率的方法算出2乘以8等于几。
使用位运算，左移三位
10、使用 final 关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？
public class finalTest {public static void main(String[] args) {final StringBuffer a=new StringBuffer(“你好”);System.out.println(a.hashCode());System.out.println(a.append(“吗”).hashCode());//final StringBuffer a=new StringBuffer(“你好”);//final StringBuffer a=new StringBuffer(“你好吗”);String b=(“中国”);String b2=(“中国”);System.out.println(bb2);final int c=5;c=15;/final Stub stub=new Stub(1);stub./ }class Stub{}}
13 不能在静态方法中调用非静态方法，要么将方法改为静态的要么先创建对象，通过对象调用
//是否可以从一个 static 方法内部发出对非 static 方法的调用？public class Test001 { public static void main(String[] args) {System.out.println(“静态方法内部可以直接调用静态方法：”+add(5,10));//sul(5,10); 非静态方法，不能再静态方法中调用，要么将方法改为静态的要么先创建对象Test001 t=new Test001();System.out.println(“通过对象调用非静态方法：”+t.sul(5, 10));}static int add(int a,int b) {return a+b;}int sul(int x,int y) {return x*y;}}
静态方法和非静态方法中都不能有静态变量，但是可以调用外部的静态变量
public class Method {static String string=“静态变量”;public static void main(String[] args) {//static String string="";静态方法中不能有静态变量System.out.println(“静态方法可以调用外部的静态变量”+string);//methodA();不能在静态方法中调用非静态方法}public static int add(int a,int b) {return a+b;}void methodA() {//static int w=20; 非静态方法中不能有静态变量}static void methodB() {//static String string="";静态方法中不能有静态变量}}
14
public class Test002 {public static void main(String[] args) {int a = 0; //默认值为0Integer b = null;//默认值为nullInteger c=50;//自动装箱System.out.println(a);System.out.println(b);Integer d=new Integer(“41”);//将字符串转换成IntegerSystem.out.println(d+5);//自动拆箱int e=Integer.parseInt(“55”);System.out.println(Integer.toBinaryString(50));//将十进制转换成二进制int cc=c.intValue();//将Integer转换成intSystem.out.println(“int的最大值：”+Integer.MAX_VALUE);System.out.println(“double的最小值：”+Double.MIN_VALUE);} }
18、重载与重写
同类，同名不同参，和访问修饰符，返回值无关——重载
子类继承父类，子类的方法同名同参同返回值——重写
19、类方法与实例方法
类方法就是静态方法，可以直接通过类名调用
实例方法也叫对象方法，必须要创建对象才能调用
20、路径
./表示当前目录
…/表示上一级路径（父级目录）
以”/”开头表示根目录
A文件夹与B文件夹是同级文件夹，其中A下有a.htm，B下有b.htm文件，希望在a.htm文件中创建超链接，链接到b.htm，应该在a.htm页面代码中如何描述链接内容( )A)b.htm B)././././B/b.htm C)…/B/b.htm D)…/…/b.htm
21、相对路径与绝对路径
23、实现接口时，如果是抽象类实现接口不必将接口中的方法都实现，若果不是抽象类就要实现接口中的全部的方法，接口中的方法或属性，不能是保留的或私有的，只能是默认的或者公共的
24、一个Java源文件只能有一个声明包的语句，可以多个引入，即只能有一个package，可以有多个import
25、访问权限
访问权限 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ × （包子类）
默认（不写） √ √ × × （同包）
private √ × × ×
26、&和&&的区别
&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）
27、断言assert
assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。
28、数组有没有length()这个方法? String有没有length()这个方法
数组没有length()这个方法，有length的属性。String有有length()这个方法
29、重载和重写Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写是运行时多态重载是编译多态。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型，方法重载和返回值类型无关。子类重写父类的方法时，子类方法的访问修饰符应该比父类的更大不能更小可以一样。
30、Set集合里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用还是equals()? 它们有何区别
Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等
equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值
31、最常见到的runtime exception（运行时异常）
NullPointerException, （空指针异常）
ArithmeticException（数学运算异常，例如除0）,
ClassCastException, （类型转换异常）
IndexOutOfBoundsException, （索引越界异常）
illegalArgumentException：参数传递异常
EmptyStackException, （空栈异常）
MissingResourceException, （资源丢失异常）
ArrayStoreException,
32、error和exception有什么区别
首先，Error类和Exception类都是继承Throwable类
Error（错误）是系统中的错误，程序员是不能改变的和处理的，是在程序编译时出现的错误，只能通过修改程序才能修正。一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。
Exception（异常）表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。
　　 Exception又分为两类
　　　　CheckedException：（编译时异常，受检查异常） 需要用try——catch显示的捕获，对于可恢复的异常使用CheckedException。
　　　　UnCheckedException（RuntimeException）：（运行时异常）不需要捕获，对于程序错误（不可恢复）的异常使用RuntimeException。
33、abstract class和interface有什么区别
抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。
接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。如果实现了这个接口，那么就必须确保使用这些方法，将其重写。接口只是一种形式，接口自身不能做任何事情。
参数 抽象类 接口
默认的方法实现 它可以有默认的方法实现 接口完全是抽象的。它根本不存在方法的实现
实现 子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。 子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
构造器 抽象类可以有构造器 接口不能有构造器
与正常Java类的区别 除了你不能实例化抽象类之外，它和普通Java类没有任何区别 接口是完全不同的类型
访问修饰符 抽象方法可以有public、protected和default这些修饰符 接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法 抽象方法可以有main方法并且我们可以运行它 接口没有main方法，因此我们不能运行它。
多继承 抽象方法可以继承一个类和实现多个接口 接口只可以继承一个或多个其它接口
速度 它比接口速度要快 接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
添加新方法 如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。 如果你往接口中添加方法，那么你必须改变实现该接口的类。
1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
2、抽象类要被子类继承，接口要被类实现。
3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
6、抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果
7、抽象类里可以没有抽象方法
8、如果一个类里有抽象方法，那么这个类只能是抽象类
9、抽象方法要被实现，所以不能是静态的，也不能是私有的。
10、接口可继承接口，并可多继承接口，但类只能单根继承。
11、接口可以继承接口。抽象类可以实现(implements)接口
12、接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法
13、类可以实现很多个接口，但是只能继承一个（抽象）类
14、类如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须是抽象的
34、构造器Constructor是否可被override
构造器不能被继承，因此不能重写，但可以被重载
35、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后
会执行，在return前执行
36、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递
是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的
37、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上
switch的参数必须是整型不能是浮点型和布尔，支持byte，short，int和字符型char不支持long，1.7之后可以是String
38、ArrayList和Vector的区别
ArrayList是为可变数组实现的，当更多的元素添加到ArrayList的时候，它的大小会动态增大。它的元素可以通过get/set方法直接访问，因为ArrayList本质上是一个数组。
LinkedList是是以元素列表的形式存储它的数据，每一个元素都和它的前
一个和后一个元素链接在一起。相对于 ArrayList，LinkedList 的插入，添加，删除操作速度更快，因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算大小或者是更新索引。LinkedList 比 ArrayList 更占内存，因为 LinkedList 为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素。
Vector和ArrayList几乎是一样的，区别在于Vector是线程安全的，同步的，因为这个原因，它的性能较ArrayList差

39、HashMap和Hashtable
HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题。Hashtable是线程安全的，它的每个方法中都加入了Synchronize方法
HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。Hashtable既不支持Null key也不支持Null value
40、list和set区别
List：
1.可重复有序（保持了每个元素的插入顺序，输出的顺序和插入的顺序一致），可以有多个空元素（可以插入null）
2.常用的实现类有 ArrayList、LinkedList 和 Vector。ArrayList 最为流行，它提供了使用索引的随意访问，而 LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适。
Set：
1.不允许重复对象，是无序容器（无法保证每个元素的存储顺序）， 只允许一个 null 元素
2.Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet。最流行的是基于 HashMap 实现的 HashSet；TreeSet 还实现了 SortedSet 接口，因此 TreeSet 是一个根据其 compare() 和 compareTo() 的定义进行排序的有序容器。
Map：
不是collection的子接口或者实现类。Map是一个接口。
2.Map 的 每个 Entry 都持有两个对象，也就是一个键一个值，Map 可能会持有相同的值对象但键对象必须是唯一的。
3. TreeMap 也通过 Comparator 或者 Comparable 维护了一个排序顺序。
4. Map 里你可以拥有随意个 null 值但最多只能有一个 null 键。
5.Map 接口最流行的几个实现类是 HashMap、LinkedHashMap、Hashtable 和 TreeMap。（HashMap、TreeMap最常用）
41、GC是什么? 为什么要有GC
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。
42、float型float f=3.4是否正确?
不正确，会报错。精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4或者float f=3.4f;
43、STRING与STRINGBUFFER的区别。
STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法
StringBuffer对象的内容可以修改;而字符串对象一旦产生后就不可以被修改，重新赋值其实是两个对象
StringBuffer的内部实现方式和字符串不同，StringBuffer的在进行字符串处理时，不生成新的对象，在内存使用上要优于串类。所以在实际使用时，如果经常需要对一个字符串进行修改，例如插入，删除等操作，使用StringBuffer要更加适合一些。
StringBuffer是线程安全的，在多线程程序中也可以很方便的进行使用，但是程序的执行效率相对来说就要稍微慢一些
总结：
　String：适用于少量的字符串操作的情况
　StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
　StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
44、final, finally, finalize的区别
final—修饰符（关键字）如果一个类被声明为final，意味着不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）
finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的
45、面向对象的特征有哪些方面
1.抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
2.继承：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3.封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
4. 多态性：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
46、int 和 Integer 有什么区别
Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。原始类型-包装类,boolean-Boolean,char-Character,byte-Byte,short-Short,int-Integer,long-Long,float-Float,double-Double
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关
47、heap和stack有什么区别
栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。堆是栈的一个组成元素
48、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？
Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。
用try来指定一块预防所有"异常"的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的"异常"的类型。
throw语句用来明确地抛出一个"异常"。
throws用来标明一个成员函数可能抛出的各种"异常"。
Finally为确保一段代码不管发生什么"异常"都被执行一段代码。
可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，"异常"的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种"异常"进行处理，堆栈就会展开，直到遇到有处理这种"异常"的try语句。
throw是语句抛出一个异常，一般是在代码块的内部，当程序出现某种逻辑错误时由程序员主动抛出某种特定类型的异常

throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)，当某个方法可能会抛出某种异常时用于throws 声明可能抛出的异常，然后交给上层调用它的方法程序处理

49、java中实现多态的机制是什么？
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
50、面向对象的优点
代码开发模块化，更易维护和修改。
代码复用。
增强代码的可靠性和灵活性。
增加代码的可理解性。
51、面向对象三大特性
1、封装：封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法来改变它内部的数据。在 Java 当中，有 3 种修饰符：public，private 和 protected。每一种修饰符给其他的位于同一个包或者不同包下面对象赋予了不同的访问权限。
下面列出了使用封装的一些好处：
通过隐藏对象的属性来保护对象内部的状态。
提高了代码的可用性和可维护性，因为对象的行为可以被单独的改变或者是扩展。
禁止对象之间的不良交互提高模块化。
2、继承：
继承给对象提供了从基类获取字段和方法的能力。继承提供了代码的重用行，也可以在不修改类的情况下给现存的类添加新特性
3、多态：
4、抽象：抽象是把想法从具体的实例中分离出来的步骤，因此，要根据他们的功能而不是实现细节来创建类
52、抽象和封装的不同点
抽象和封装是互补的概念。一方面，抽象关注对象的行为。另一方面，封装关注对象行为的。细节。一般是通过隐藏对象内部状态信息做到封装，因此，封装可以看成是用来提供抽象的一种策略。
53、”static”关键字是什么意思？Java 中是否可以覆盖(override)一个 private 或者是 static 的方法？
“static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问，即不需要创建对象就能调用。Java 中 static 方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而 static 方法是编译时静态绑定的。static 方法跟类的任何实例都不相关，所以概念上不适用
54、Java 中，什么是构造函数？什么是构造函数重载？什么是复制构造函数？
当新对象被创建的时候，构造函数会被调用。每一个类都有构造函数。在程序员没有给类提供构造函数的情况下，Java 编译器会为这个类创建一个默认的构造函数。
Java 中构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。
Java 不支持像 C++中那样的复制构造函数，这个不同点是因为如果你不自己写构造函数的情况下，Java 不会创建默认的复制构造函数。
55、什么是值传递和引用传递？
对象被值传递，意味着传递了对象的一个副本。因此，就算是改变了对象副本，也不会影响源对象的值。
对象被引用传递，意味着传递的并不是实际的对象，而是对象的引用。因此，外部对引用对象所做的改变会反映到所有的对象上
56、进程和线程的区别是什么？
几乎任何的操作系统都支持运行多个任务，通常一个任务就是一个程序，而一个程序就对应一个进程。当一个进程运行时，内部可能包括多个顺序执行流，每个顺序执行流就是一个线程。
进程是执行着的应用程序，而线程是进程内部的一个执行序列。一个进程可以有多个线程。
线程又叫做轻量级进程
57、创建线程有几种不同的方式？你喜欢哪一种？为什么？
①继承 Thread 类
②实现 Runnable 接口
③应用程序可以使用 Executor 框架来创建线程池
实现 Runnable 接口这种方式更受欢迎，因为这不需要继承 Thread 类。在应用设计中已经继承了别的对象的情况下，这需要多继承（而 Java 不支持多继承），只能实现接口。同时，线程池也是非常高效的，很容易实现和使用
58、概括的解释下线程的几种可用状态。
①就绪(Runnable):线程准备运行，不一定立马就能开始执行。
②运行中(Running)：进程正在执行线程的代码。
③等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。
④睡眠中(Sleeping)：线程被强制睡眠。
⑤I/O 阻塞(Blocked on I/O)：等待 I/O 操作完成。
⑥同步阻塞(Blocked on Synchronization)：等待获取锁。
⑦死亡(Dead)：线程完成了执行。
59、Iterator 和 ListIterator 的区别是什么？
Iterator 可用来遍历 Set 和 List 集合，但是 ListIterator 只能用来遍历 List。
Iterator 对集合只能是前向遍历，ListIterator 既可以前向也可以后向。ListIterator 实现了 Iterator 接口，并包含其他的功能，比如：增加元素，替换元素，获取前一个和后一个元素的索引，等等。
60、数组(Array)和列表(ArrayList)有什么区别？什么时候应该使用 Array 而不是 ArrayList？
Array 可以包含基本类型和对象类型，ArrayList 只能包含对象类型。
Array 大小是固定的，ArrayList 的大小是动态变化的。
ArrayList 提供了更多的方法和特性，比如：addAll()，removeAll()，iterator()等等。
对于基本类型数据，集合使用自动装箱来减少编码工作量。但是，当处理固定大小的基本数据类型的时候，这种方式相对比较慢
61、Comparable 和 Comparator 接口是干什么的？列出它们的区别。
Java 提供了只包含一个 compareTo()方法的 Comparable 接口。这个方法可以个给两个对象排序。具体来说，它返回负数，0，正数来表明输入对象小于，等于，大于已经存在的对象。Java 提供了包含 compare()和 equals()两个方法的 Comparator 接口。compare()方法用来给两个输入参数排序，返回负数，0，正数表明第一个参数是小于，等于，大于第二个参数。equals()方法需要一个对象作为参数，它用来决定输入参数是否和 comparator 相等。只有当输入参数也是一个 comparator 并且输入参数和当前 comparator 的排序结果是相同的时候，这个方法才返回 true
62、异常处理完成以后，Exception 对象会发生什么变化？
Exception 对象会在下一个垃圾回收过程中被回收掉
63、什么是 JDBC？
Java数据库连接
64、数据库连接池是什么意思？
负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；像打开关闭数据库连接这种和数据库的交互可能是很费时的，尤其是当客户端数量增加的时候，会消耗大量的资源，成本是非常高的。可以在应用服务器启动的时候建立很多个数据库连接并维护在一个池中。连接请求由池中的连接提供。在连接使用完毕以后，把连接归还到池中，以用于满足将来更多的请求
65、什么是 Servlet？
狭义上讲servlet 是运行在 Web 服务器中的小型 Java 程序。是JavaEE中的一个接口servlet 通常通过 HTTP（超文本传输协议）接收和响应来自 Web 客户端的请求，是用来处理客户端请求并产生动态网页内容的 Java 类。广义上讲所有实现类servlet 的类都是servlet。Servlet 主要是用来处理或者是存储 HTML 表单提交的数据，产生动态内容，在无状态的 HTTP 协议下管理状态信息
66、 Servlet 的体系结构。
所有的 Servlet 都必须要实现的核心的接口是 javax.servlet.Servlet。每一个 Servlet 都必须要直接或者是间接实现这个接口，或者是继承javax.servlet.GenericServlet 或 者javax.servlet.http.HTTPServlet。最后，Servlet 使用多线程可以并行的为多个请求服务。
67、Servlet 的生命周期。
对每一个客户端的请求，Servlet 引擎载入 （实例化）Servlet，调用它的 init()方法，完成 Servlet 的初始化。然后，Servlet 对象通过为每一个请求单独调用 service()方法来处理所有随后来自客户端的请求，最后，调用Servlet的destroy()方法把Servlet销毁
68、doGet()方法和 doPost()方法有什么区别？
doGet：GET 方法会把名值对追加在请求的 URL 后面。因为 URL 对字符数目有限制，进而限制了用在客户端请求的参数值的数目。并且请求中的参数值是可见的，因此，敏感信息不能用这种方式传递。
doPOST：POST 方法通过把请求参数值放在请求体中来克服 GET 方法的限制，因此，可以发送的参数的数目是没有限制的。最后，通过 POST 请求传递的敏感信息对外部客户端是不可见的
69、sleep() 和 wait() 有什么区别?
sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。（到一定时间会自动醒来）
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。（会一致等待知道被唤醒）
70、同步和异步有何异同，在什么情况下分别使用他们？举例说明。

71、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。
public class ThreadTest1 {private int j;public static void main(String args[]){ThreadTest1 tt=new ThreadTest1();Inc inc=tt.new Inc();Dec dec=tt.new Dec();for(int i=0;i<2;i++){Thread t=new Thread(inc);t.start();t=new Thread(dec);t.start();}}private synchronized void inc(){j++;System.out.println(Thread.currentThread().getName()+"-inc:"+j);}private synchronized void dec(){j–;System.out.println(Thread.currentThread().getName()+"-dec:"+j);}//内部类class Inc implements Runnable{public void run(){for(int i=0;i<100;i++){inc();}}}class Dec implements Runnable{public void run(){for(int i=0;i<100;i++){dec();}}}}
72、启动一个线程是用run()还是start()?
启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。
73、编程题: 写一个单例
/定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。///饿汉式public class Singleton {//构造函数私有化private Singleton() {} //创建私有静态的本类对象 private static Singleton instance=new Singleton() ; //提供了公有的本类对象的静态方法，将该对象返回，供外界直接访问　　 public static Singleton getInstance() { return instance; } }
//懒汉式public class Singleton2 {//构造方法私有化private Singleton2() {}//先赋值为空private static Singleton2 singleton2=null;public static Singleton2 getSingleton2() {if(singleton2==null) {singleton2=new Singleton2();}return singleton2;}}
74、请说出你所知道的线程同步的方法。
①Wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
②Sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
③Notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
④Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
75、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
多线程有两种实现方法，分别是继承Thread类重写run()方法与实现Runnable接口重写run()方法
同步的实现方面有两种，分别是synchronized,wait与notify
76、线程的基本概念、线程的基本状态以及状态之间的关系
线程指在程序执行过程中，能够执行程序代码的一个执行单位，每个程序至少都有一个线程，也就是程序本身。
Java中的线程有四种状态分别是：运行、就绪、挂起、结束。
77、servlet的生命周期
web容器加载servlet，生命周期开始。通过调用servlet的init()方法进行servlet的初始化。通过调用service()方法实现，根据请求的不同调用不同的do***()方法。结束服务，web容器调用servlet的destroy()方法。
78、简述逻辑操作(&,|,^)与条件操作(&&,||)的区别
a.条件操作只能操作布尔型的,而逻辑操作不仅可以操作布尔型,而且可以操作数值型
b.逻辑操作不会产生短路
79、描述一下你最常用的编程风格
①类名首字母大写。字段、方法以及对象的首字母小写
②尽可能细致地加上注释
③尽量使用interfaces，不要使用abstract类
80、启动一个线程是用run()还是start()?
是start()方法。每个线程都是通过某个特定的线程对象所对应的run（）方法来完成其操作的，run()称为线程体。通过调用Thread类的start()方法来启动一个线程。
81、Class.forName的作用?
返回与给定的字符串名称相关联的类或接口的Class对象。
是一个静态方法，同样可以用来加载类。创建一个类的实例化对象。在JDBC中经常用这个方法注册数据库驱动。Class.forName(String name)参数 name表示的是类的全名
82、short s1 = 1; s1 = s1 + 1;有什么错?
short s1 = 1; s1 += 1;有什么错?
s1+1运算结果是int型，需要强制转换类型，s1 = (short) (s1 + 1);
short s1 = 1; s1 += 1;（可以正确编译）
83、synchronized和java.util.concurrent.locks.Lock的异同 ？
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。可以获得的更广泛的锁定操作。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。
84、请对以下在J2EE中常用的名词进行解释

85、什么是java序列化，如何实现java序列化
序列化：把Java对象转换为二进制的字节序列的过程，序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。

Serializable
序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，
然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
86、写clone()方法时，通常都有一行代码，是什么？
Clone 有缺省行为，super.clone();他负责产生正确大小的空间，并逐位复制。
87、代码查错
①错误点：局部变量前不能放置任何访问修饰符 (private，public，和protected)
void methodA( public String s) { System.out.println(“查错”);}
final可以修饰局部变量
void methodA( final String s) {System.out.println(“查错”);}
②抽象类中的抽象方法不能被private和final修饰，因为抽象类就是为了让子类继承的
抽象类中的抽象方法不能有方法体
抽象类中可以有非抽象方法
public abstract class Something {//private abstract String doSomething ();//抽象方法不能被private 修饰//final abstract String doSomething ();//抽象犯法不能用final protected abstract String doSomething (); void doSomething2 () { //抽象类中可以有非抽象方法 }; //abstract String doSomething () {}; //抽象方法不能有方法体}
③局部变量被final修饰成为常量，不能被更改，即x的是不能在改变
public class SomeThing2 {/public int addOne(final int x) {return ++x; }///局部变量被final修饰成为常量，不能被更改public int addOne2( int x) {return ++x; }}
④此处修改的是成员变量o的属性，常量o并未改变，正确
public class SomeThing2 {public static void main(String[] args) {Other o = new Other();new SomeThing2().addOne(o);;}public void addOne(final Other o) {o.i++;} }
class Other {public int i;}
⑤成员变量有默认值可以不初始化直接使用，局部变量必须要先初始化才能使用，所以局部变量y未进行初始化不能直接调用
public class SomeThing2 {int i;public void show() {int y;System.out.println(i);//System.out.println(y);}}
⑥常量必须要先初始化，常量i必须要在定义的时候给其同时赋值
public class Some {//final int i;public void show() {System.out.println(i);}}
⑦静态方法不能直接访问非静态方法
public class Some {public static void main(String[] args) {Some some=new Some();some.doSomething();//doSomething();}public String doSomething() {return “Do something …”; }}
88、线程的基本概念、线程的本状态以及状态之间的关系
①新建 (Born) : 新建的线程处于新建状态•就绪 (Ready) : 在创建线程后，它将处于就绪状态，
②等待 start() 方法被调用运行 (Running) : 线程在开始执行时进入运行状态
③睡眠 (Sleeping) : 线程的执行可通过使用 sleep() 方法来暂时中止。
④在睡眠后，线程将进入就绪状态等待 (Waiting) : 如果调用了 wait() 方法，线程将处于等待状态。用于在两个或多个线程并发运行时。
⑤挂起 (Suspended) : 在临时停止或中断线程的执行时，线程就处于挂起状态。 ⑥恢复 (Resume) : 在挂起的线程被恢复执行时，可以说它已被恢复。
⑦阻塞 (Blocked) – 在线程等待一个事件时（例如输入/输出操作），就称其处于阻塞状态。
⑧死亡 (Dead) – 在 run() 方法已完成执行或其 stop() 方法被调用之后，线程就处于死亡状态。
89、JAVA的国际化
Java程序的国际化的思路是将程序中的标签、提示等信息放在资源文件中，程序需要支持哪些国家、语言环境，就对应提供相应的资源文件。资源文件是key-value对，每个资源文件中的key是不变的，但value则随不同国家、语言改变。
90、java中对象之间的通讯采用什么方法
直接调用另一对象方法来进行通讯以及数据的交换
91、Java程序怎么优化？
提高JAVA的性能，一般考虑如下的四个主要方面：
①程序设计的方法和模式
② JAVA布署的环境。
③ JAVA应用程序的实现
④ 硬件和操作系统
为了提高JAVA程序的性能，需要遵循如下的六个步骤。
a) 明确对性能的具体要求
b) 了解当前程序的性能
c) 找到程序的性能瓶颈
d) 采取适当的措施来提高性能
e) 只进行某一方面的修改来提高性能
f) 返回到步骤
92、你知道Object类中有那些方法？
getClass()
equals(Object obj)
clone()
toString()
finalize()
93、请问java中的网络通信有那些方式,有什么区别
分别是TCP和UDP是一种面向连接的保证可靠传输的协议。
TCP协议是一种以固连线为基础的协议，它提供两台计算机之间可靠的数据传送。可以保证从一端数据传至连接的另一端时，数据能够确实送达
而UDP是一种无连接的协议，每个数据都是一个独立的信息，包括完整的源地址和目的地址 ，不保证可靠数据的传输。但能够同时向若干目标发送数据。UDP协议适合于一些对数据准确性要求不高的场合。
94、有一组数字（3，10，6，8，98，22），请编程排序（升降序皆可）

95、 super()与this()的区别？
在Java中，this通常指当前对象，super则指父类的。this（）表示调用当前类的无参构造，super(）表示调用父类的无参构造
96、在JAVA中，如何跳出当前的多重嵌套循环？
使用break
97、一个“.java”源文件中是否可以包括多个类（不是内部类）？有什么限制？
可以有多个类存在于一个“.java”文件中，但是只能有一个public的类且文件名必须与public的类的类名一致
98、排序都有哪几种方法？
插入排序、交换排序（冒泡排序，快速排序）、归并排序、选择排序。
99、什么是类的反射机制?
通过类名获得类的相关信息。可以实例化这个类。在spring中经常用到反射机制。在代理模式中常用反射
100、得到Class的三个过程是什么?
getclass()；
.class；
class.fornam()；
101、静态变量，实例变量，局部变量的区别
实例变量又称成员变量：　
　　1⃣️成员变量定义在类中，在整个类中都可以被访问
　　2⃣️成员变量随着对象的建立而建立，随对象的消失而消失，存在于对象所在的堆内存中
　　3⃣️成员变量有默认初始值
局部变量：
　　1⃣️定义在方法中或方法的参数列表（或者语句中）
　　2⃣️存在于栈内存中，作用的范围结束，变量空间自动释放
　　3⃣️默认没有初始化值，使用时需要进行初始化
静态变量又称类变量：用static修饰
　　1⃣️存储在方法区中
　　2⃣️随着类的加载而存在，随着类的消失而消失
　　3⃣️可以由类名或对象调用
102、 JDBC如何做事务处理？
在JDBC中处理事务，都是通过Connection完成的。同一事务中所有的操作，都在使用同一个Connection对象。
①开启事务，设置自动提交为false，con.setAutoCommit(false)
②在SQL语句后执行commit()，提交事务
③在try，catch{}中进行事务回滚，rollback（）
try{ con.setAutoCommit(false);//开启事务 …SQL语句 con.commit();//try的最后提交事务 } catch（） { con.rollback();//回滚事务}
103、编程题
①打印一个倒立的直角三角形
②打印昨天现在这个时间

③当前时间，年月日，时分秒

④排序
方法重构前
public class 排序 {public static void main(String[] args) {//原数组int s[]= {-3,10,6,8,-98,22,0};//外层控制循环的圈数内层控制循环的次数，次数等于长度减去圈数for(int i=0;i<s.length;i++) {for(int j=0;j<s.length-i-1;j++) {if(s[j]>s[j+1]) {int temp=s[j];s[j]=s[j+1];s[j+1]=temp;}}}for(int x=0;x<s.length;x++) {System.out.print(s[x]+",");}}}
方法重构后
public class 排序 {public static void main(String[] args) {int s[]= {-3,10,6,8,-98,22,0};System.out.print(“排序前：”);show(s);paixu(s);//调用排序方法System.out.print(“排序后：”);show(s);}public static void paixu(int nums[]) {for(int i=0;i<nums.length;i++) {for(int j=0;j<nums.length-i-1;j++) {if(nums[j]>nums[j+1]) {int temp=nums[j];nums[j]=nums[j+1];nums[j+1]=temp;}}}}public static void show(int nums[]) {//遍历数组的方法for(int x=0;x<nums.length;x++) {System.out.print(nums[x]+",");}System.out.println();}}
⑤列出某个目录下的所有文件