Java基础学习（面试宝典）：
1.java中“==”和equals方法究竟有什么区别？
（1）==操作符专门用来比较两个变量的值是否相等，也即是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。 如果一个变量指向的数据是对象类型的，那么，这时候涉及到两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Object obj = new Object()；变量obj是一个内存，new Object()是另一个内存。此时变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。
（2）equals方法适用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，比较的两个对象是独立的，对于两个不同的对象，它们的首地址是不同的，但是对象的内容是相同的，返回true.字符串比较基本上都是用equals方法。 如果一个类没有自己定义的equals方法，它默认的equals方法（从Object类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象。此时如果希望比较该类创建的两个实例对象内容是否相同，必须覆盖equals方法。
2.静态变量和实例变量的区别？
（1）语法定义上：静态变量前要加上static关键字，实例变量前不加
（2）程序运行时：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也被称为类变量，只要 程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。
（3）总结，实例变量必须创建对象后才可以通过这个对象来使用，静态变量可以直接使用类名来引用。
3.是否可以从一个static方法内部发出对非static方法的调用？
不可以。非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。当一个static方法被调用是，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上呢。逻辑无法成立。
4.Integer和Int的区别？
int是Java提供的8中原始数据类型之一。Java为每个原始类型提供了封装类，Integer是int提供的封装类。
（1）int的默认值为0 ，而integer的默认值是null，Integer可以区分出为赋值和值为0的区别，int无法表达出为赋值的情况。
（2）Integer提供了多个整数相关的操作方法，例如将一个字符串转换成整数，定义了整数最大值和最小值常量。
5.位运算是cpu直接支持的，效率最高。将一个数左移N位，就相当于乘以2的N次方，<<左移 >>右移
6.一个.java源文件中可以包括多个类，但是只能有一个public类，并且public的类名必须和文件名一致
7.java中有goto，goto是保留字，想在没有在java中使用
8.说说&和&&的区别？
（1）相同点：&和&&都可以用作逻辑与的运算符。当运算符两边表达式都为true时候结果为true，否则为false
（2）不同点：&&具有短路功能，如果第一个表达式为false不再计算第二个表达式，&不具有短路功能。 &可以用作为运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作。通常使用0x0f来与一个整数进行&运算，来获取整数的最低4个bit位。
9.java中如何跳出当前多重嵌套循环？
（1）在外面循环语句前定义一个标号，然后在里层循环体的代码中使用带标号的break语句，即可跳出外层循环。
begin:
break begin;
（2）一般不使用标号这种方式，而是让外层循环条件表达式的结果可以收到里层循环体代码的控制，可以设置一个标记位。
boolean find = false;
for(int i = 0 ; i < n && !find ; i++){
for(int j = 0 ; j < n ; j++){
if(data[i][j] == key){
find = true;
break;
}
}
}
10.switch(expr1)中，expr1只能是一个整数表达式或者枚举常量（更大字体）,整数表达式可以是Int基本类型或者Integer包装类型。由于byte,short,char都可以隐式转换为Int,所以这些类型以及这些类型的包装类都是可以的。long和string都不符合语法规定，并且不能被隐式转换为int，不能直接用于switch语句。
11.(1)short s1 = 1;s1 = s1 + 1;由于s1+1运算时会自动提升表达式的类型，所以结果是int型，编译器会报告需要强制转换类型的错误。
(2)short s1 = 1 ; s1 += 1;由于+=是java语言规定的运算符， java编译器会对它进行特殊处理，可以通过编译。
12.char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字了。unicode编码占用两个字节，所以char类型的变量也是占用两个字节
13.设计一个一百亿的计算器具体步骤
设计一个类(BigInteger)可以表示很大的整数，并且提供了与另外一个整数进行加减乘除的功能。
（1）内部有两个成员变量，一个表示符号(sign)，另一个用字节数组表示数值的二进制数（通过位运算原理计算）。
（2）有一个构造方法，把一个包含有多个数值的字符串转换到内部的符号和字节数组中
（3）提供加减乘除的功能 add substract multiply divide
14.使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。
15.Math类中提供了三个与取整有关的方法：ceil、floor、round。
（1）ceil英文意思天花板，表示向上取整
（2）floor英文意思地板，表示向下取整
（3）round方法表示四舍五入，算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整
16.public,private,protected作用域
（1）public 当前类+相同包内的类+不同包内的类+子孙类
（2）protected 当前类+相同包内的类+子孙类
（3）friendly 当前类+相同包内的类（如果在修饰的元素上没有写任何访问修饰符，表示friendly）
（4）private 当前类
17.overload和override的区别？
（1）overload是重载的意思，override是覆盖的意思，也就是重写
（2）overload表示同一个类中可以有多个名称相同的方法，当这些方法的参数列表各不相同（参数个数或类型）但是如果两个方法的参数列表完全一样，不能通过返回值的不同来实现重载overload。如果不定义接收返回结果的变量，那么无法通过返回类型来判断。
（3）override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中定义方法，相当于把父类中定义的完全相同的方法覆盖掉。这是面向对象编程的多态性的一种表现。
18.构造器Constructor不能被继承，因此不能重写override，但可以被重载overload
19.抽象类和普通类的唯一区别就是不能创建实例对象和允许有abstract方法
20.写clone()方法时，通常都有一行代码super.clone()，应为clone有缺省行为，首先要把父类中的成员复制到位，然后才是复制自己的成员。
21.面向对象的特征有哪些方面？
面向对象的编程语言有封装、继承、抽象、多态4个主要特征。
（1）封装：封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。在面向对象的编程语言中，对象是封装的最基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个对象中的属性。通常情况下，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现对象的封装，就很容易找出要分配到这个类上的方法了，就基本上算是会面向对象的编程了。把握一个原则：把对同一事物进行操作的方法和相关的方法放在同一个类中，把方法和它操作的数据放在同一个类中。
（2）抽象：抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。例如，看到一只蚂蚁和大象，你能够想象出它们的相同之处，那就是抽象。抽象包括行为抽象和状态抽象两个方面。
（3）继承：在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。
（4）多态：态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。例如，下面代码中的UserDao是一个接口，它定义引用变量userDao指向的实例对象由daofactory.getDao()在执行的时候返回，有时候指向的是UserJdbcDao这个实现，有时候指向的是UserHibernateDao这个实现，这样，不用修改源代码，就可以改变userDao指向的具体类实现，从而导致userDao.insertUser()方法调用的具体代码也随之改变，即有时候调用的是UserJdbcDao的insertUser方法，有时候调用的是UserHibernateDao的insertUser方法：
UserDao userDao = daofactory.getDao();
userDao.insertUser(user);
22.java中试想多态的机制是什么？
靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。
23.abstract class 和interface的区别？
（1）abstract:含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
（2）接口（interface）：可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
（3）语法区别：
a.抽象类可以有构造方法，接口中不能有构造方法。
b.抽象类中可以有普通成员变量，接口中没有普通成员变量
c.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
d.抽象类中的抽象方法的访问类型可以是public，protected和（默认类型friendly,虽然eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
e.抽象类中可以包含静态方法，接口中不能包含静态方法
f.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
g. 一个类可以实现多个接口，但只能继承一个抽象类。
(4)应用区别：接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约，而抽象类在代码实现方面发挥作用，可以实现代码的重用。例如，模板方法设计模式是抽象类的一个典型应用，父类方法中间的某段代码不确定，留给子类干，就用模板方法设计模式。
24.abstract的method不可以是static的，
因为抽象的方法是要被子类实现的。static与子类无关
nativenative方法表示该方法要用另外一种依赖平台的编程语言实现的，不存在着被子类实现的问题，所以，它也不能是抽象的，不能与abstract混用。
synchronized应该是作用在一个具体的方法上才有意义。而且，方法上的synchronized同步所使用的同步锁对象是this，而抽象方法上无法确定this是什么。
25.内部类：内部类就是在一个类的内部定义的类，内部类可以访问外部类的成员变量，内部类中不能定义静态成员（静态成员不是对象的特性，只是为了找一个容身之处，所以需要放到一个类中而已，这么一点小事，你还要把它放到类内部的一个类中，过分了啊！提供内部类，不是为让你干这种事情，无聊，不让你干。我想可能是既然静态成员类似c语言的全局变量，而内部类通常是用于创建内部对象用的，所以，把“全局变量”放在内部类中就是毫无意义的事情，既然是毫无意义的事情，就应该被禁止），内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中。
public class Outer{
int out_x = 0;
public void method(){
final int in_x = 0;
Inner1 inner1 = new Inner1();
class Inner2{
public void method(){
out_x = in_x + 3;
}
}
Inner2 inner2 = new Inner2();
}
public class Inner1{
//在方法体外面定义的内部类
}
}
（1）在方法体外面定义的内部类的访问类型可以是public,protecte,默认的（friendly），private等4种类型，这就好像类中定义的成员变量有4种访问类型一样，它们决定这个内部类的定义对其他类是否可见；对于这种情况，我们也可以在外面创建内部类的实例对象，创建内部类的实例对象时，一定要先创建外部类的实例对象，然后用这个外部类的实例对象去创建内部类的实例对象，代码如下：
Outer outer = new Outer();
Outer.Inner1 inner1 = outer.new Innner1();
（2）在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰符。这种内部类对其他类是不可见的其他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问。这种内部类必须是先定义，后使用，即内部类的定义代码必须出现在使用该类之前，这与方法中的局部变量必须先定义后使用的道理也是一样的。这种内部类可以访问方法体中的局部变量，但是，该局部变量前必须加final修饰符。
（3）在方法外部定义的内部类前面可以加上static关键字，从而成为Static Nested（嵌套） Class，它不再具有内部类的特性，所有，从狭义上讲，它不是内部类。Static Nested Class与普通类在运行时的行为和功能上没有什么区别，只是在编程引用时的语法上有一些差别，在外面引用Static Nested Class类的名称为“外部类名.内部类名”。在外面不需要创建外部类的实例对象，就可以直接创建Static Nested Class。Outer.Inner inner = new Outer.Inner();
由于static Nested Class不依赖于外部类的实例对象，所以，static Nested Class能访问外部类的非static成员变量。当在外部类中访问Static Nested Class时，可以直接使用Static Nested Class的名字，而不需要加上外部类的名字了，在Static Nested Class中也可以直接引用外部类的static的成员变量，不需要加上外部类的名字。
26.内部类可以引用它的包含类的成员。如果不是静态内部类，没有限制
。
如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，例如下面的代码：
public class Outer{
static int out_x = 0;
static class Inner{
void test(){
System.out.println(out_x);
}
}
}
27.Anonymous Inner Class (匿名内部类) 可以extends(继承)其它类，可以implements(实现)interface(接口)
28.super.getClass()方法调用。
下面程序的输出结果是多少？
import java.util.Date;
public class Test extends Date{
public static void main(String[] args) {
new Test().test();
}
public void test(){
System.out.println(super.getClass().getName());
}
}
结果是Test
在test方法中，直接调用getClass().getName()方法，返回的是Test类名，由于getClass()在Object类中定义成了final，子类不能覆盖该方法，所以，在test方法中调用getClass().getName()方法，其实就是在调用从父类继承的getClass()方法，等效于调用super.getClass().getName()方法，所以，super.getClass().getName()方法返回的也应该是Test。如果想得到父类的名称，应该用如下代码：getClass().getSuperClass().getName();
29.String不是最基本的数据类型。基本数据类型包括byte、int、char、long、float、double、boolean和short。
java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类。
30.String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？
没有，String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。
(1)StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。
(2)对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。
(3)不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即 StringBuffer。
31.String s = new String("xyz");创建了几个String Object? 二者之间有什么区别？
两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。New String每写一遍，就创建一个新的对象，它依据那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。
32.String和StringBuffer的区别：
（1）相同点：JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。
（2）不同点：
a.String类提供了数值不可改变的字符串。而StringBuffer类提供的字符串进行修改。
b.String实现了equals方法，new String(“abc”).equals(new String(“abc”)的结果为true,而StringBuffer没有实现equals方法，所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的结果为false。
c.String覆盖了hashCode方法，而StringBuffer没有覆盖hashCode方法，所以，将StringBuffer对象存储进Java集合类中时会出现问题。
33，如何把一段逗号分隔的字符串转换成一个数组？
(1)String[] result = str.split(",");
(2)StringTokenizer是字符串分隔解析类型，属于：java.util包。
String str = "he,ll,on,iha,o";
StringTokenizer tokener = new StringTokenizer(str , ",");
String[] result = new String[tokener.countTokens()];
int index = 0;
while(tokener.hasMoreElements()){
result[index++] = tokener.nextToken();
}
34.数组没有length()方法，有length属性，String有length()方法。
35.String s="a"+"b"+"c"+"d";语句一共创建了多少个对象？
1个，javac编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。
36.try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
public class smallT
{
public static void main(String args[])
{
smallT t = new smallT();
int b = t.get();
System.out.println(b);
}
public int get()
{
try
{
return 1 ;
}
finally
{
return 2 ;
}
}
}
返回结果是2.
原因：try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行，所以，返回的结果是2。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。
结论：finally中的代码比return和break语句后执行。
37.final, finally, finalize的区别。
（1）final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。 内部类要访问局部变量，局部变量必须定义成final类型
（2）finally是异常处理语句结构的一部分，表示总是执行。
（3）finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用。
Java技术使用finalize()方法在垃圾收集器将对象从内存中清除出去前，做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在Object类中定义的，因此所有的类都继承了它。子类覆盖finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的。
38.运行时异常与一般异常有何异同？
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。
39.error和exception有什么区别?
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。 exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。
40.Java中的异常处理机制的简单原理和应用。
（1）异常是指java程序运行时（非编译）所发生的非正常情况或错误。
（2）Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception，Error 表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。Exception表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。
（3）java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，而系统异常可以处理也可以不处理，所以，编译器不强制用try..catch处理或用throws声明，所以系统异常也称为unchecked异常。
41.请写出最常见的5个runtime exception.
系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉。系统异常都是RuntimeException的子类在jdk doc中查RuntimeException类，就可以看到其所有的子类列表，也就是看到所有的系统异常。例如数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）。
42.介绍Collection框架的结构
集合框架(Collection Framework)泛指java.util包的若干个类和接口.
如Collection,List,ArrayList,LinkedList,Vector(自动增长数组),HashSet,HashMap等.
Collection
--List：-----------------------以特定次序存储元素。所以取出来的顺序可能和放入顺序不同。
---ArrayList
---LinkedList
---Vector
--Set ：----------------------- 不含有重复的元素
--- HashSet
--- TreeSet
Map
---HashMap
---HashTable
---TreeMap
补充：
List，Set，Map将存入的数据一律视为Object类型。
Collection、List、Set、Map都是接口，不能实例化。继承自它们的 ArrayList, Vector, HashTable,HashMap是具象class，这些才可被实例化。
vector不进行边界检查。
43.Collection框架中实现比较要实现什么接口？comparable/comparator
44.ArrayList和Vector的区别？
（1）相同点：这两个类都实现了List接口（List接口继承了Collection接口），他们都是有序集合，即存储在这两个集合中的元素的位置都是有顺序的，相当于一种动态的数组，我们以后可以按位置索引号取出某个元素，，并且其中的数据是允许重复的，这是HashSet之类的集合的最大不同处，HashSet之类的集合不可以按索引号去检索其中的元素，也不允许有重复的元素（本来题目问的与hashset没有任何关系，但为了说清楚ArrayList与Vector的功能，我们使用对比方式，更有利于说明问题）。
（2）不同点：
a.同步性：Vector是线程安全的，也就是说是它的方法之间是线程同步的，而ArrayList是线程序不安全的，它的方法之间是线程不同步的。如果只有一个线程会访问到集合，那最好是使用ArrayList，因为它不考虑线程安全，效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们自己再去考虑和编写线程安全的代码。
备注：对于Vector&ArrayList、Hashtable&HashMap，要记住线程安全的问题，记住Vector与Hashtable是旧的，是java一诞生就提供了的，它们是线程安全的，ArrayList与HashMap是java2时才提供的，它们是线程不安全的。
b.数据增长：ArrayList与Vector都有一个初始的容量大小，当存储进它们里面的元素的个数超过了容量时，就需要增加ArrayList与Vector的存储空间，每次要增加存储空间时，不是只增加一个存储单元，而是增加多个存储单元，每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector默认增长为原来两倍，而ArrayList的增长策略在文档中没有明确规定（从源代码看到的是增长为原来的1.5倍）。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小，而ArrayList没有提供设置增长空间的方法。
总结：即Vector增长原来的一倍，ArrayList增加原来的0.5倍。
45.HashMap和Hashtable的区别?
（1）相同点：HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。
（2）不同点：
a.HashMap允许空（null）键值（key）,由于非线程安全，在只有一个线程访问的情况下，效率要高于Hashtable。
b.HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
c.HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。
d.Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
最大的不同是，Hashtable的方法是Synchronize的，也就是线程安全的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。
46.List 和 Map 区别?
一个是存储单列数据的集合，另一个是存储键和值这样的双列数据的集合，List中存储的数据是有顺序，并且允许重复；Map中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的。
47.List,Set继承自Collection接口，Map不是
48.List、Map、Set三个接口，存取元素时，各有什么特点？
（1）List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口，叫Collection。
a.Set里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不是仅仅是相同）的对象 ，即假设Set集合中有了一个A对象，现在我要向Set集合再存入一个B对象，但B对象与A对象equals相等，则B对象存储不进去，所以，Set集合的add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true，当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。
b.List表示有先后顺序的集合， 注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用add(Obj e)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Obj e)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。
(2)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对象的集合。
(3)List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。
49.ArrayList,Vector, LinkedList的存储性能和特性?
(1)ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差。
(2)LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。LinkedList也是线程不安全的，LinkedList提供了一些方法，使得LinkedList可以被当作堆栈和队列来使用。
50.Collection 和 Collections的区别。
Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。 例如Collections.sort();
51.Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?
Set里的元素是不能重复的，元素重复与否是使用equals()方法进行判断的。
equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。
52.最常用的集合类是 List 和 Map。
(1)List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。
(2)Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。
53.两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
对。
如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。
如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode，当然，我们没有理由不实现，通常都会去实现的。
54.说出一些常用的类，包，接口，请各举5个。
常用的类：BufferedReader BufferedWriter FileReader FileWirter String Integer java.util.Date，System，Class，ArrayList,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
55.java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？
字节流，字符流。字节流继承于InputStream OutputStream，字符流继承于InputStreamReader OutputStreamWriter。在java.io包中还有许多其他的流，主要是为了提高性能和使用方便。
56.字节流与字符流的区别?
(1)要把一片二进制数据数据逐一输出到某个设备中，或者从某个设备中逐一读取一片二进制数据，不管输入输出设备是什么，我们要用统一的方式来完成这些操作，用一种抽象的方式进行描述，这个抽象描述方式起名为IO流，对应的抽象类为OutputStream和InputStream ，不同的实现类就代表不同的输入和输出设备，它们都是针对字节进行操作的。
(2)在应用中，经常要完全是字符的一段文本输出去或读进来，用字节流可以吗？计算机中的一切最终都是二进制的字节形式存在。对于“中国”这些字符，首先要得到其对应的字节，然后将字节写入到输出流。读取时，首先读到的是字节，可是我们要把它显示为字符，我们需要将字节转换成字符。由于这样的需求很广泛，人家专门提供了字符流的包装类。
(3)底层设备永远只接受字节数据，有时候要写字符串到底层设备，需要将字符串转成字节再进行写入。字符流是字节流的包装，字符流则是直接接受字符串，它内部将串转成字节，再写入底层设备，这为我们向IO设别写入或读取字符串提供了一点点方便。
(4)字符向字节转换时，要注意编码的问题，因为字符串转成字节数组.
57.什么是java序列化，如何实现java序列化？或者请解释Serializable接口的作用。
有时候将一个java对象变成字节流的形式传出去或者从一个字节流中恢复成一个java对象，例如，要将java对象存储到硬盘或者传送给网络上的其他计算机，这个过程我们可以自己写代码去把一个java对象变成某个格式的字节流再传输，但是，jre本身就提供了这种支持，我们可以调用OutputStream的writeObject方法来做，如果要让java 帮我们做，要被传输的对象必须实现serializable接口，这样，javac编译时就会进行特殊处理，编译的类才可以被writeObject方法操作，这就是所谓的序列化。需要被序列化的类必须实现Serializable接口，该接口是一个mini接口，其中没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的。
例如，在web开发中，如果对象被保存在了Session中，tomcat在重启时要把Session对象序列化到硬盘，这个对象就必须实现Serializable接口。如果对象要经过分布式系统进行网络传输或通过rmi等远程调用，这就需要在网络上传输对象，被传输的对象就必须实现Serializable接口。
58.描述一下JVM加载class文件的原理机制?
JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。
59.heap和stack有什么区别?
java的内存分为两类，一类是栈内存，一类是堆内存。
(1)栈内存是指程序进入一个方法时，会为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。
(2)堆是与栈作用不同的内存，一般用于存放不放在当前方法栈中的那些数据，例如，使用new创建的对象都放在堆里，所以，它不会随方法的结束而消失。方法中的局部变量使用final修饰后，放在堆中，而不是栈中。
60.GC是什么? 为什么要有GC?
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显式操作方法。
61.垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？
（1）垃圾回收的优点：Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有"作用域"的概念，只有对象的引用才有"作用域"。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。
（2）基本原理：对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。
（3）垃圾回收器可以马上回收内存，程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行
扫一扫
181
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
