史上最全 javaSE基础和高级面试题整理

javaSE基础和高级

一.面向对象基础

1.面向对象的特征有哪些方面？

面向对象的编程语言有封装、继承 、多态、抽象等4个主要的特征。

封装：

​ 面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现对象的封装，把握一个原则：把对同一事物进行操作的方法和相关的方法放在同一个类中，把方法和它操作的数据放在同一个类中。

继承：

​ 在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

多态： 父类 接受 子类的实例 接口接受实现类的实例

​ 靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

抽象：

​ 抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。例如，看到一只蚂蚁和大象，你能够想象出它们的相同之处，那就是抽象。抽象包括行为抽象和状态抽象两个方面。

2.static关键字的用法

• 修饰类变量，将其变为类的成员，从而实现所有对象对于该成员的共享 ；
• 修饰类方法，将其变为类方法，可以直接使用“类名.方法名”的方式调用，常用于工具类 ；
• 静态代码块，将多个类成员放在一起初始化，使得程序更加规整，其中理解对象的初始化过程非常关键；

(https://blog.csdn.net/shuyizhi/article/details/79700054)

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

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

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

4.abstract class和interface有什么区别?（重要）

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

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

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

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

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

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

4.抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

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

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

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

5.this和super的用法总结

this标识当前对象，代表对象本身

1.引用	
	如果继承了父类，那么通过this既可以访问当前类的属性和方法，也可以访问父类的属性和方法，但是当子类重写了父类的方法之后，super.方法名,访问的是父类的方法，this.方法名访问的是子类的方法
2.形参与成员名字重名，用this来区分
3.引用构造函数	这个和super放在一起讲，见下面

super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。

1.普通的直接引用
与this类似，super相当于是指向当前对象的父类，这样就可以用super.xxx来引用父类的成员。
2.子类中的成员变量或方法与父类中的成员变量或方法同名
3.引用构造函数
super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。
this（参数）：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。

this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。

6. 说说&和&&的区别。

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

&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作。

7.switch语句的使用?

在switch（expr1）中，expr1只能是一个整数表达式或者枚举常量，整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。

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

break和return方法都可以跳出当前的多重嵌套循环。

当用break时，最好是让外层的循环条件表达式的结果可以受到里层循环体代码的控制。然后有条件的跳出循环。

break 和 continue 的区别？

break 和 continue 都是用来控制循环的语句。
break 用于完全结束一个循环，跳出循环体执行循环后面的语句。
continue 用于跳过本次循环，执行下次循环。

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

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

如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。

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

9.Overload和Override的区别?

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

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

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

在覆盖要注意以下的几点：

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

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

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

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

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

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

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

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

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

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

Final修饰的属性是常量 Final修饰的方法不可以重写 Final修饰的类不可以继承

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

12.Integer与int的区别？

int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。

1.int的默认值为0，而Integer的默认值为null，例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。

2.在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，所以用el表达式在文本框中显示时，结果为0，所以，int不适合作为web层的表单数据的类型。

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

13.格式化日期

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date dat=new Date();
//把日期转化为字符串
String str=sdf.format(dat);
System.out.println(str);
//将字符串转化为日期
Java.util.Date d1=sdf.parse(“yyyy-mm-dd”);

14.打印昨天的当前时刻

public class YesterdayCurrent{
	public void main(String[] args){
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DATE, -1);
		System.out.println(cal.getTime());
	}
} 

14.如何将数字转换为字符？如何将数值型字符转换为数字？

数字转字符：先把int类型变成包装类，然后在调用toString方法.

字符转数字：Integer.parseInt(“1234”) Double.parseDouble(“123.2”)

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

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

在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰符。

在方法外部定义的内部类前面可以加上static关键字，从而成为Static Nested Class，它不再具有内部类的特性，所有，从狭义上讲，它不是内部类。Static Nested Class与普通类在运行时的行为和功能上没有什么区别，只是在编程引用时的语法上有一些差别。

16.String 和StringBuffer/stringbuilder的区别

1.String类提供了数值不可改变的字符串，而这个StringBuffer类提供的字符串进行修改。

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

3.stringbuffer线程安全，stringbuilder线程不安全，但是效率高.

17.final, finally, finalize的区别。

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

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

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

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

要多列你在做ssh项目中涉及的那些东西

常用的类：BufferedReader BufferedWriter FileReader FileWirter String Integer

java.util.Date，System，Class，List,HashMap

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

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

19.Hashcode的作用。

以上这段官方文档的定义，我们可以抽出成以下几个关键点：

1、hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的；

2、如果两个对象相同，就是适用于equals 方法，那么这两个对象的hashCode一定要相同；

3、如果对象的equals方法被重写，那么对象的hashCode也尽量重写，并且产生hashCode使用的对象，一定要和equals方法中使用的一致，否则就会违反上面提到的第2点；

4、两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定适用于equals(java.lang.Object) 方法，只能够说明这两个对象在散列存储结构中，如Hashtable，他们“存放在同一个篮子里”。

20.Object有哪些公用方法？

https://blog.csdn.net/qq_42669161/article/details/86154034

21.枚举类？

​ 其实枚举就是在一个类里定义几个静态变量，每个变量都是这个类的实例。
比如说，类Human有两个静态变量：Man,Woman，每一个变量都是Human类的实例。用的时候就直接写Human.Man，Human.Woman，用的时候就直接用Human.Man.hasXJJ()或者Human.Woman.hasXJJ()方法，这不就是枚举么。

作用么，其实就是提供常量。

好处么，三言两语说不完，用着用着就明白了。

https://blog.csdn.net/qq_27093465/article/details/52180865

22.泛型能否强制转换??

泛型中不要去强制类型转换！！！

23.java和c++比有什么优势？

1.Java比C,C++简单，学起来比C\C++容易

2.Java面向对象

3.Java中没有指针这样不安全(虽然指针速度快)的概念。

4.Java内存管理机制，能自动垃圾回收

5.Java中有完善的异常机制(标准C++中不够完善)。

6.跨平台，Java原生支持多线程

24.for each和正常for的？

需要循环数组结构的数据时，建议使用普通for循环，因为for循环采用下标访问，对于数组结构的数据来说，采用下标访问比较好。
需要循环链表结构的数据时，一定不要使用普通for循环，这种做法很糟糕，数据量大的时候有可能会导致系统崩溃。

原因：foreach使用的是迭代器

​

二.集合，I/O，多线程

集合---------

1.Collection 和 Collections的区别

• Collection是集合类的上级接口，子接口主要有Set 和List。

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

2.集合与数组的区别

• 集合与数组都是容器，数组大小固定，只能存储相同数据类型的数据，集合大小可动态扩展，可以存储各种类型的数据；
• 集合只能存放对象，如果放一个int类型的数，集合会自动转成它的包装类再进行存储，数组可以存放基本数据类型。

转换：

数组转换为集合： Arrays.asList(数组)

集合转换为数组： 集合.toArray();

3.ArrayList和Vector的区别

（1）同步性：

   Vector是线程安全的，也就是说是它的方法之间是线程同步的，而ArrayList是线程序不安全的，它的方法之间是线程不同步的。
   
   如果只有一个线程会访问到集合，那最好是使用ArrayList，因为它不考虑线程安全，效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们自己再去考虑和编写线程安全的代码。

（2）数据增长：

   ArrayList与Vector都有一个初始的容量大小，当存储进它们里面的元素的个数超过了容量时，就需要增加ArrayList与Vector的存储空间。
   
   Vector默认增长为原来两倍，而ArrayList的增长为原来的1.5倍。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小。

4.HashMap和Hashtable的区别

主要从三方面来说：

一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现

二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的

三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

hashmap有多大??? :HashMap：默认初始容量为16.，不够就翻倍

（为何是16：16是2^4，可以提高查询效率，另外，32=16<<1)

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

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

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

• 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对象的集合。

6.说出ArrayList,Vector, LinkedList的存储性能和特性。

• 1.ArrayList和Vector都是使用数组方式存储数据，都允许直接按序号索引元素，但是索引数据快而插入数据慢。Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%。

• 2.Vector由于使用了synchronized方法（线程安全），ArrayList非线程安全，Vector通常性能上较ArrayList差。

• 3.LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快查询较慢。LinkedList也是线程不安全的。

  总结：如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。 如果要考虑到线程安全问题，可以使用Vector。

7.Collection框架中实现比较要实现什么接口

comparable/comparator？？？

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

equals（）和= =的区别

• = =主要用在基本数据类型及引用，来比较两个变量的值是否相等，如果一个变量只想的数据是对象类型，那么= = 比较两个变量指向的内存地址是否相同。
• equals 方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。
• ==方法决定引用值是否指向同一对象 ，equals方法在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

Set 里的元素是不能重复的，元素重复与否先调用hashCode方法，如果不相同，证明不相等。如果相同，再调用equals方法，如果equals方法相同，证明相等，不相同，证明不相等。

集合中是否包含某一个元素用contains来判断。

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

​ 我记的不是方法名，而是思想，我知道它们都有增删改查的方法，但这些方法的具体名称，我记得不是很清楚，对于set，大概的方法是add,remove, contains；对于map，大概的方法就是put,remove，contains等，因为，我只要在eclispe下按点操作符，很自然的这些方法就出来了。我记住的一些思想就是List类会有get(int index)这样的方法，因为它可以按顺序取元素，而set类中没有get(int index)这样的方法。List和set都可以迭代出所有元素，迭代时先要得到一个iterator对象，所以，set和list类都有一个iterator方法，用于返回那个iterator对象。map可以返回三个集合，一个是返回所有的key的集合，另外一个返回的是所有value的集合，再一个返回的key和value组合成的EntrySet对象的集合，map也有get方法，参数是key，返回值是key对应的value。

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

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

如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode，当然，我们没有理由不实现，通常都会去实现的。

11. TreeMap、HashMap、LindedHashMap的区别？

https://blog.csdn.net/xin_jmail/article/details/25975085

12.hashmap和concurrntHashmap的区别？

https://www.cnblogs.com/heyonggang/p/9112731.html

多线程---------

ThreadLocal？

https://baijiahao.baidu.com/s?id=1609916413785756020&wfr=spider&for=pc

1.什么是进程，什么是线程，有 那些区别?

​ 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以有多个线程。比如在 Windows 系统中，一个运行的 xx.exe 就是一个进程。Java 程序的进程里有几个线程: 主线程, 垃圾回收线程( 后台线程)
线程是指进程中的一个执行任务(控制单元)，一个进程中可以运行多个线程,多个线程可共享数据。

区别：

• 地址空间：同一进程的线程共享本进程的地址空间，而进程之间则是独立的地址空间。

• 资源拥有：同一进程内的线程共享本进程的资源如内存、I/O、cpu等，但是进程之间的资源是独立的。

• 一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。

• 进程切换时，消耗的资源大，效率高。所以涉及到频繁的切换时，使用线程要好于进程。同样如果要求同时进行并且又要共享某些变量的并发操作，只能用线程不能用进程

• 线程是处理器调度的基本单位，但是进程不是。

2.创建线程方式

1 、 继承 Thread 类

子类覆写父类中的 run 方法，将线程运行的代码存放在 run 中。
建立子类对象的同时线程也被创建。通过调用 start 方法开启线程。

2 、 实现 Runnable 接口

子类覆盖接口中的 run 方法。
通过 Thread 类创建线程，并将实现了 Runnable 接口的子类对象作为参数传递给 Thread类的构造函数。Thread 类对象调用 start 方法开启线程。
可使用匿名内部类来写

3.通过Callable和FutureTask创建线程

4.通过线程池创建线程

3.线程同步的方法？

七种同步方法

4.run()和 和 start() 方法的区别

run() 方法: 在本线程内调用该 Runnable 对象的 run() 方法 ， 可以重复多次调用 ；
start() 方法: 启动一个线程 ， 调用该 Runnable 对象的 run() 方法 ， 不能多次启动一个线程 ；

5.sleep() 和 wait() 有什么区别?

— 拥有对象不同

— wait****可以释放对象锁，sleep保留对象锁

— wait****可以是任意对象来调用，sleep只能当前线程调用

— wait****可以通过notify随时唤醒，sleep只能等待设定时间结束后自然唤醒，否则将引发异常

— wait****必须在同步方法或同步块中进行调用，sleep可以在任意位置调用

6.线程的生命周期

Java线程具有五中基本状态

新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

2.同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

3.其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期

7.请说出同步线程及线程调度相关的方法？、

wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁；
sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理 InterruptedException 异常；
notify()：唤醒一个处于等待状态的线程，当然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，
而是由 JVM 确定唤醒哪个线程，而且与优先级无关；
notityAll()：唤醒所有处于等待状态的线程，该方法并不是将对象的锁给所有线程，而是让它们竞争，只有获得锁
的线程才能进入就绪状态；
注意：java 5 通过 Lock 接口提供了显示的锁机制，Lock 接口中定义了加锁（lock（）方法）和解锁（unLock（）
方法），增强了多线程编程的灵活性及对线程的协调

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

启动一个线程是调用 start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由 JVM 调度并
执行，这并不意味着线程就会立即运行。
run()方法是线程启动后要进行回调（callback）的方法。

9.发生死锁的条件？

死锁

I/O流---------

https://www.cnblogs.com/xrq730/category/743509.html

1.java中有几种类型的流？

​ 按照流的方向：输入流（inputStream）和输出流（outputStream）。按照实现功能分：节点流（可以从或向一个特定的地方（节点）读写数据。如 FileReader）和处理流（是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如 BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。）
按照处理数据的单位：字节流和字符流。字节流继承于 InputStream 和 OutputStream，字符流继承于
InputStreamReader 和 OutputStreamWriter。

2.字节流与字符流的区别

• 字符流处理的单元为 2 个字节的 Unicode 字符，分别操作字符、字符数组或字符串，而字节流处理单元为 1 个字节，操作字节和字节数组。
• 字符流（一次可以处理一个缓冲区）一次操作比字节流（一次一个字节）效率高。
• 字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的。
• 字节流在操作文件时，即使不关闭资源（close方法），文件也能输出，但是如果字符流不使用close方法的话，则不会输出任何内容，说明字符流用的是缓冲区，并且可以使用flush方法强制进行刷新缓冲区。

3.java序列化？*（重要）

​ 序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。　　序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

具体：(https://www.cnblogs.com/yangchunze/p/6728086.html)

​ 例如，在web开发中，如果对象被保存在了Session中，tomcat在重启时要把Session对象序列化到硬盘，这个对象就必须实现Serializable接口。如果对象要经过分布式系统进行网络传输或通过rmi等远程调用，这就需要在网络上传输对象，被传输的对象就必须实现Serializable接口。

4.如何将一个 java 对象序列化到文件里？

在 java 中能够被序列化的类必须先实现 Serializable 接口，该接口没有任何抽象方法只是起到一个标记作用。

 //对象输出流
 ObjectOutputStream objectOutputStream =
 			new ObjectOutputStream(new FileOutputStream(new File("D://obj")));
 objectOutputStream.writeObject(new User("zhangsan", 100));
 objectOutputStream.close();
 //对象输入流
 ObjectInputStream objectInputStream =
 			new ObjectInputStream(new FileInputStream(new File("D://obj")));
 User user = (User)objectInputStream.readObject();
 System.out.println(user);
 objectInputStream.close();

5.IO与NIO？

http://blog.51cto.com/12222886/2070597

https://www.cnblogs.com/kzfy/p/5063467.html

6.如何实现对象克隆？

1 为什么要用clone？

在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能会需要一个和A完全相同新对象B，并且此后对B 任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。在Java语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单，也是最高效的手段。

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

三.异常，GC，内存溢出，JVM

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

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

运行时异常 ：表示java JVM抛出的异常，代码中不用处理。是在代码运行过程中产生的 ，是一种常见运行错误。

非运行时异常：就是编译的时候产生的异常，java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

2.error和exception有什么区别?

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

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

​ Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception，Error 表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了。

​ java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try…catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，而系统异常可以处理也可以不处理，所以，编译器不强制用try…catch处理或用throws声明，所以系统异常也称为unchecked异常。

4.请写出你最常见到的5个runtime exception。

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

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

Try:执行部分，产生异常

Catch:捕捉异常

Finally:不管有没有异常都执行

Throws:在方法声明处声明要抛出的异常，调用者必须对其进行处理。

Throw:抛出一个异常

在try中可以抛出异常，一般与声明的异常相同。

自定义异常要继承于Exception或Exception的子类

6.垃圾回收机制GC是什么? 为什么要有GC?

​ GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，垃圾收集是将分配给对象但不再使用的内存回收或释放的过程,如果一个对象没有指向它的引用或者其赋值为null,则次对象适合进行垃圾回收 。

• 安全性考虑；
• 减少内存泄露；
• 减少程序员工作量

​ java 事件委托机制的概念,一个源产生一个事件并将它送到一个或多个监听器那里。在这种方案中，监听器简单的等待，直到它收到一个事件。一旦事件被接受，监听器将处理这个事件，然后返回。

7.强弱软虚，java中的四种引用？

	强引用(Strong Reference):Object obj = new Object();只要强引用还存在，GC 永远不会回收掉被引用的对象。

	软引用(Soft Reference)：描述一些还有用但非必需的对象。在系统将会发生内存溢出之前，会把这些对象列入回收范围进行二次回收（即系统将会发生内存溢出了，才会对他们进行回收。）

	弱引用(Weak Reference):程度比软引用还要弱一些。这些对象只能生存到下次 GC 之前。当 GC 工作时，无论内存是否足够都会将其回收（即只要进行 GC，就会对他们进行回收。）

	虚引用(Phantom Reference):一个对象是否存在虚引用，完全不会对其生存时间构成影响。

8.Java 的 GC 什么时候回收垃圾?

​ 在 Java，C#等语言中，比较主流的判定一个对象已死的方法是：可达性分析(Reachability Analysis).所有生成的对象都是一个称为"GC Roots"的根的子树。从 GC Roots 开始向下搜索，搜索所经过的路径称为引用链(Reference Chain)，当一个对象到 GC Roots 没有任何引用链可以到达时，就称这个对象是不可达的（不可引用的），也就是可以被 GC 回收了。

9.介绍下垃圾收集机制（在什么时候，对什么，做了什么）?

回收机制

10.垃圾收集有哪些算法，各自的特点?

算法

11.在开发中遇到过内存溢出么？原因有哪些？解决方法有哪些？

引起内存溢出的原因有很多种，常见的有以下几种：

• 1.内存中加载的数据量过于庞大，如一次从数据库取出过多数据；
• 2.集合类中有对对象的引用，使用完后未清空，使得 JVM 不能回收；
• 3.代码中存在死循环或循环产生过多重复的对象实体；
• 4.使用的第三方软件中的 BUG；
• 5.启动参数内存值设定的过小；

内存溢出的解决方案：

• 第一步，修改 JVM 启动参数，直接增加内存。(-Xms，-Xmx 参数一定不要忘记加。)
• 第二步，检查错误日志，查看“OutOfMemory”错误前是否有其它异常或错误。
• 第三步，对代码进行走查和分析，找出可能发生内存溢出的位置。

重点排查以下几点：

• 1.检查对数据库查询中，是否有一次获得全部数据的查询。一般来说，如果一次取十万条记录到内存，就可能引起内存溢出。这个问题比较隐蔽，在上线前，数据库中数据较少，不容易出问题，上线后，数据库中数据多了，一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。
• 2.检查代码中是否有死循环或递归调用。
• 3.检查是否有大循环重复产生新对象实体。
• 4.检查 List、MAP 等集合对象是否有使用完后，未清除的问题。List、MAP 等集合对象会始终存有对对象的引用，使得这些对象不能被 GC 回收。

最后，使用内存查看工具动态查看内存使用情况。

12.OOM:内存用完

内存泄露：申请使用完的内存没有释放，导致虚拟机不能再次使用该内存，此时这段内存就泄露了，因为申请者不用了，而又不能被虚拟机分配给别人用。

内存溢出：申请的内存超出了JVM能提供的内存大小，此时称之为溢出。

13.什么是虚拟内存？

​ 虚拟内存,就是用硬盘来模拟内存使用. 客观来说,如果你的内存足够大,是不需要虚拟内存的.但事实上,这往往不可能.

​ 操作系统为了更好地有效利用内存资源,通常把最最常用的模块加载到缓存中,然后把常用模块放入内存中,把最不常用但在运行中需要调用的模块放入硬盘中.

​ 这样,可以有效提升资源使用率.而虚拟内存,就是放入硬盘的这部分东西组成的一个逻辑概念 。

14.虚拟地址、逻辑地址、线性地址、物理地址的区别？

线性地址：是CPU所能寻址的空间或者范围。

物理地址：是机器中实际的内存地址。换言之，是机器中的内存容量范围。

逻辑地址：是对程序而言的。一般以Seg:Offset来表示。（程序员自己看到的地址）

四.注解，反射，类加载

1.注解

//定义注解
@Target(ElementType.METHOD) //代表使用在方法上
@Retention(RetentionPolicy.RUNTIME) // 代表运行时也保留
public @interface UseCase {
     public String id(); //字段，defalut表示默认值
     public String description() default "no description";
}

//使用注解
public class PasswordUtils {
    //赋初始值
     @UseCase(id = 47, description = "Passwords must contain at least one numeric")
     public boolean validatePassword(String password) {
         return (password.matches("\\w*\\d\\w*"));
     }
 }

2.什么是类的反射机制？

​ 通过class对象，可以得出当前类的方法，构造方法，接口，父类等信息，同时可以通过反射实例化出一个类，设置属性，调用方法。  Spring中一切都是反射，struts，hibernate都是通过类的反射进行开发的。  Class.forName(“类所对应的完整包的路径”);

3.说说你对 Java 中反射的理解？

Java 中 的 反 射 首 先 是 能 够 获 取 到 Java 中 要 反 射 类 的 字 节 码 ， 获 取 字 节 码 有 三 种 方 法 ，
1.Class.forName(className) 2.类名.class 3.this.getClass()。然后将字节码中的方法，变量，构造函数等映射成
相应的 Method、Filed、Constructor 等类，这些类提供了丰富的方法可以被我们所使用

3.类什么时候被初始化？

1.创建类的实例，也就是new一个对象的时候

2.访问某个类或接口的静态变量，或者对该静态变量赋值

3.调用类的静态方法

4.反射（class.forName(“com.chenlie.test”)）

5.初始化一个类的子类（会首先初始化子类的父类）

6.jvm启动的时候表面启动的类，即文件名和类名相同的那个类

4.类初始化的步骤？

JVM加载class文件的原理机制：

​ java 程序中的 .java 文件编译完会生成 .class 文件，而 .class 文件就是通过被称为类加载器的 ClassLoader加载的，而 ClassLoder 在加载过程中会使用“双亲委派机制”来加载 .class 文件。

1.如果这个类还没被加载，那就先进行加载和链接

2.加入这个类存在直接父类，并且这个父类还没有被初始化，那就初始化直接的父类（注意在一个类加载器中，一个类只能被加载一次）

3.加入类中存在初始化语句（如static变量和static块），就先依次执行这些初始化语句

5.描述一下 JVM 加载 class ???

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

	由于 Java 的跨平台性，经过编译的 Java 源程序并不是一个可执行程序，而是一个或多个类文件。当 Java 程序需要使用某个类时,JVM 会确保这个类已经被加载、连接（验证、准备和解析）和初始化。类的加载是指把的.class文件中的数据读入到内存中，通常是创建一个字节数组读入.class 文件，然后产生与所加载类对应的 Class 对象。加载完成后，Class 对象还不完整，所以此时的类还不可用。当类被加载后就进入连接阶段，这一阶段包括验证、准备（为静态变量分配内存并设置默认的初始值）和解析（将符号引用替换为直接引用）三个步骤。最后 JVM 对类进行初始化，包括：

如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；

如果类中存在初始化语句，就依次执行这些初始化语句。类的加载是由类加载器完成的，类加载器包括：根加载器
（BootStrap）、扩展加载器（Extension）、系统加载器（System）和用户自定义类加载器（java.lang.ClassLoader的子类）。

	从 Java 2（JDK 1.2）开始，类加载过程采取了父亲委托机制（PDM）。PDM 更好的保证了 Java 平台的安全性，在该机制中，JVM 自带的 Bootstrap 是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM 不会向 Java 程序提供对 Bootstrap 的引用。

下面是关于几个类加载器的说明：
• Bootstrap：一般用本地代码实现，负责加载 JVM 基础核心类库（rt.jar）；

• Extension：从 java.ext.dirs 系统属性所指定的目录中加载类库，它的父加载器是 Bootstrap；

• System：又叫应用类加载器，其父类是 Extension。它是应用最广泛的类加载器。它从环境变量 classpath  或者系统属性 java.class.path 所指定的目录中记载类，是用户自定义加载器的默认父加载器。

6.获得一个类对象有哪些方式？

类型.class，例如：String.class
对象.getClass()，例如：”hello”.getClass()
Class.forName()，例如：Class.forName(“java.lang.String”)

正则？

邮箱格式：

^[A-Za-z\d]+([-_.][A-Za-z\d]+)*@([A-Za-z\d]+[-.])+[A-Za-z\d]{2,4}$ 

一个简单的js验证：

<script>
  function checkEmail(str){
    var re = /^[A-Za-z\d]+([-_.][A-Za-z\d]+)*@([A-Za-z\d]+[-.])+[A-Za-z\d]{2,4}$/; 
    if (re.test(str)) {
      alert("ok");
    } else {
      alert("nope");
    }
  }

</script> 
Email:<input type="text" id="mail" value=""/>
<input type="button" value="check" onclick="checkEmail(document.getElementById('mail').value);"/>