1.什么是B/S架构？什么是C/S架构

B/S(Browser/Server)，浏览器/服务器程序
C/S(Client/Server)，客户端/服务端，桌面应用程序

3.Java都有那些开发平台？

JAVA SE：主要用在客户端开发
JAVA EE：主要用在web应用程序开发
JAVA ME：主要用在嵌入式应用程序开发

4.什么是JVM？java虚拟机包括什么？

JVM：java虚拟机，运用硬件或软件手段实现的虚拟的计算机，Java虚拟机包括：寄存器，堆栈，处理器

5.Java是否需要开发人员回收内存垃圾吗？

大多情况下是不需要的。Java提供了一个系统级的线程来跟踪内存分配，不再使用的内存区将会自动回收

6.什么是JDK？什么是JRE?

JDK：java development kit：java开发工具包，是开发人员所需要安装的环境

JRE：java runtime environment：java运行环境，java程序运行所需要安装的环境

7.什么是数据结构？

计算机保存，组织数据的方式

8.Java的数据结构有那些？

线性表（ArrayList）
链表（LinkedList）
栈（Stack）
队列（Queue）
图（Map）
树（Tree）

9.什么是OOP?

面向对象编程

10.什么是面向对象？

世间万物都可以看成一个对象。每个物体包括动态的行为和静态的属性，这些就构成了一个对象。

11.类与对象的关系?

类是对象的抽象，对象是类的具体，类是对象的模板，对象是类的实例

12.Java中有几种数据类型

整形：byte,short,int,long
浮点型：float,double
字符型：char
布尔型：boolean

13.什么是隐式转换，什么是显式转换

显示转换就是类型强转，把一个大类型的数据强制赋值给小类型的数据；隐式转换就是大范围的变量能够接受小范围的数据；隐式转换和显式转换其实就是自动类型转换和强制类型转换。

14.Char类型能不能转成int类型？能不能转化成string类型，能不能转成double类型

Char在java中也是比较特殊的类型，它的int值从1开始，一共有2的16次方个数据；Char<int<long<float<double；Char类型可以隐式转成int,double类型，但是不能隐式转换成string；如果char类型转成byte，short类型的时候，需要强转。

15.什么是拆装箱？

拆箱：把包装类型转成基本数据类型
装箱：把基本数据类型转成包装类型

16.Java中的包装类都是那些？

byte：Byte short：Short int：Integer long：Long float：Float double：Double char：Character boolean：Boolean

17.一个java类中包含那些内容？

属性、方法、内部类、构造方法、代码块。

18.例如： if(a+1.0=4.0)，这样做好吗？

不好，因为计算机在浮点型数据运算的时候，会有误差，尽量在布尔表达式中不使用浮点型数据(if,while,switch中判断条件不使用浮点型)

19.那针对浮点型数据运算出现的误差的问题，你怎么解决？

使用Bigdecimal类进行浮点型数据的运算

20.++i与i++的区别

++i：先赋值，后计算
i++：先计算，后赋值

21.程序的结构有那些？

顺序结构
选择结构
循环结构

22.数组实例化有几种方式？

静态实例化：创建数组的时候已经指定数组中的元素,

1	`int[] a=new` `int[]{1,3,3}`

动态实例化：实例化数组的时候，只指定了数组程度，数组中所有元素都是数组类型的默认值

23.Java中各种数据默认值

Byte,short,int,long默认是都是0
Boolean默认值是false
Char类型的默认值是’’
Float与double类型的默认是0.0
对象类型的默认值是null

24.Java常用包有那些？

Java.lang
Java.io
Java.sql
Java.util
Java.awt
Java.net
Java.math

25.Java最顶级的父类是哪个？

Object

26.Object类常用方法有那些？

Equals
Hashcode
toString
wait
notify
clone
getClass

27.java中有没有指针？

有指针，但是隐藏了，开发人员无法直接操作指针，由jvm来操作指针

28.java中是值传递引用传递？

理论上说，java都是引用传递，对于基本数据类型，传递是值的副本，而不是值本身。对于对象类型，传递是对象的引用，当在一个方法操作操作参数的时候，其实操作的是引用所指向的对象。

29.假设把实例化的数组的变量当成方法参数，当方法执行的时候改变了数组内的元素，那么在方法外，数组元素有发生改变吗？

改变了，因为传递是对象的引用，操作的是引用所指向的对象

30.实例化数组后，能不能改变数组长度呢？

不能，数组一旦实例化，它的长度就是固定的

31.假设数组内有5个元素，如果对数组进行反序，该如何做？

创建一个新数组，从后到前循环遍历每个元素，将取出的元素依次顺序放入新数组中

32.形参与实参

形参：全称为“形式参数”，是在定义方法名和方法体的时候使用的参数，用于接收调用该方法时传入的实际值；实参：全称为“实际参数”，是在调用方法时传递给该方法的实际值。

33.构造方法能不能显式调用？

不能构造方法当成普通方法调用，只有在创建对象的时候它才会被系统调用

34.构造方法能不能重写？能不能重载？

不可以重写，可以重载

35.什么是方法重载？

方法的重载就是在同一个类中允许同时存在一个以上的同名方法，只要它们的参数个数或者类型不同即可。在这种情况下，该方法就叫被重载了，这个过程称为方法的重载（override）

36.内部类与静态内部类的区别？

静态内部类相对与外部类是独立存在的，在静态内部类中无法直接访问外部类中变量、方法。如果要访问的话，必须要new一个外部类的对象，使用new出来的对象来访问。但是可以直接访问静态的变量、调用静态的方法；

普通内部类作为外部类一个成员而存在，在普通内部类中可以直接访问外部类属性，调用外部类的方法。

如果外部类要访问内部类的属性或者调用内部类的方法，必须要创建一个内部类的对象，使用该对象访问属性或者调用方法。

如果其他的类要访问普通内部类的属性或者调用普通内部类的方法，必须要在外部类中创建一个普通内部类的对象作为一个属性，外同类可以通过该属性调用普通内部类的方法或者访问普通内部类的属性

如果其他的类要访问静态内部类的属性或者调用静态内部类的方法，直接创建一个静态内部类对象即可。

37.Static关键字有什么作用？

Static可以修饰内部类、方法、变量、代码块

Static修饰的类是静态内部类

Static修饰的方法是静态方法，表示该方法属于当前类的，而不属于某个对象的，静态方法也不能被重写，可以直接使用类名来调用。在static方法中不能使用this或者super关键字。

Static修饰变量是静态变量或者叫类变量，静态变量被所有实例所共享，不会依赖于对象。静态变量在内存中只有一份拷贝，在JVM加载类的时候，只为静态分配一次内存。

Static修饰的代码块叫静态代码块，通常用来做程序优化的。静态代码块中的代码在整个类加载的时候只会执行一次。静态代码块可以有多个，如果有多个，按照先后顺序依次执行。

38.Final在java中的作用

Final可以修饰类，修饰方法，修饰变量。
修饰的类叫最终类。该类不能被继承。
修饰的方法不能被重写。
修饰的变量叫常量，常量必须初始化，一旦初始化后，常量的值不能发生改变。

39.Java中操作字符串使用哪个类？

String，StringBuffer，StringBuilder

40.StringBuffer，Stringbuilder有什么区别？

StringBuffer与StringBuilder都继承了AbstractStringBulder类，而AbtractStringBuilder又实现了CharSequence接口，两个类都是用来进行字符串操作的。

在做字符串拼接修改删除替换时，效率比string更高。

StringBuffer是线程安全的，Stringbuilder是非线程安全的。所以Stringbuilder比stringbuffer效率更高，StringBuffer的方法大多都加了synchronized关键字

41.String str=”aaa”,与String str=new String(“aaa”)一样吗？

不一样的。因为内存分配的方式不一样。
第一种，创建的”aaa”是常量，jvm都将其分配在常量池中。
第二种创建的是一个对象，jvm将其值分配在堆内存中。

42.String str=”aa”,String s=”bb”,String aa=aa+s;一种创建了几个对象？

一共有两个引用，三个对象。因为”aa”与”bb”都是常量，常量的值不能改变，当执行字符串拼接时候，会创建一个新的常量是” aabbb”,有将其存到常量池中。

43.将下java中的math类有那些常用方法？

Pow()：幂运算
Sqrt()：平方根
Round()：四舍五入
Abs()：求绝对值
Random()：生成一个0-1的随机数，包括0不包括1

44.String类的常用方法有那些？

charAt：返回指定索引处的字符
indexOf()：返回指定字符的索引
replace()：字符串替换
trim()：去除字符串两端空白
split()：分割字符串，返回一个分割后的字符串数组
getBytes()：返回字符串的byte类型数组
length()：返回字符串长度
toLowerCase()：将字符串转成小写字母
toUpperCase()：将字符串转成大写字符
substring()：截取字符串
format()：格式化字符串
equals()：字符串比较

45.判断两个对象是否相同，能使用equlas比较吗？

不能。Equlas大多用来做字符串比较，要判断基本数据类型或者对象类型，需要使用==

46.==与equlas有什么区别？

==可以判断基本数据类型值是否相等，也可以判断两个对象指向的内存地址是否相同，也就是说判断两个对象是否是同一个对象，Equlas通常用来做字符串比较。

47.如何将字符串反转？

Stringbuilder或者stringbuffer的reverse方法

48.面向对象的语言有那些特征？

封装、继承、多态

49.Java中的继承是单继承还是多继承

Java中既有单继承，又有多继承。对于java类来说只能有一个父类，对于接口来说可以同时继承多个接口

50.什么是重写？什么是重载？

重载和重写都是java多态的表现。

重载叫override，在同一个类中多态的表现。当一个类中出现了多个相同名称的方法，但参数个数和参数类型不同，方法重载与返回值无关

重写叫overwrite，是字符类中多态的表现。当子类出现与父类相同的方法，那么这就是方法重写。方法重写时，子类的返回值必须与父类的一致。如果父类方法抛出一个异常，子类重写的方法抛出的异常类型不能小于父类抛出的异常类型。

51.构造方法能不能重载？能不能重写？

可以重载，必须重写

52.如果父类只有有参构造方法，那么子类必须要重写父类的构造方法吗？

必须重写

53.创建一个子类对象的时候，那么父类的构造方法会执行吗？

会执行。当创建一个子类对象，调用子类构造方法的时候，子类构造方法会默认调用父类的构造方法。

54.什么是父类引用指向子类对象？

是java多态一种特殊的表现形式。创建父类引用，让该引用指向一个子类的对象

55.当父类引用指向子类对象的时候，子类重写了父类方法和属性，那么当访问属性的时候，访问是谁的属性？调用方法时，调用的是谁的方法？

子类重写了父类方法和属性，访问的是父类的属性，调用的是子类的方法

56.Super与this表示什么？

Super表示当前类的父类对象
This表示当前类的对象

57.抽象的关键字是什么？

Abstract

58.抽象类必须要有抽象方法吗

不是必须。抽象类可以没有抽象方法。

59.如果一个类中有抽象方法，那么这个一定是抽象类？

包含抽象方法的类一定是抽象类

60.抽象类可以使用final修饰吗？

不可以。定义抽象类就是让其他继承的，而final修饰类表示该类不能被继承，与抽象类的理念违背了

61.普通类与抽象类有什么区别？

普通类不能包含抽象方法，抽象类可以包含抽象方法
抽象类不能直接实例化，普通类可以直接实例化

62.什么是接口？

接口就是某个事物对外提供的一些功能的声明，是一种特殊的java类

63.JAVA为什么需要接口？

接口弥补了java单继承的缺点

64.接口有什么特点？

接口中声明全是public static final修饰的常量
接口中所有方法都是抽象方法
接口是没有构造方法的
接口也不能直接实例化
接口可以多继承

65.接口与抽象类有什么区别？

抽象类有构造方法，接口没有构造方法
抽象类只能单继承，接口可以多继承
抽象类可以有普通方法，接口中的所有方法都是抽象方法
接口的属性都是public static final修饰的，而抽象的不是

66.Java中异常分为哪两种？

编译时异常
运行时异常

67.说几个常见的编译时异常类？

NullPointerException：空指针异常
ArrayIndexOutOfBoundsException：数组下标越界
NumberFormatException：数字转换异常
IllegalArgumentException：参数不匹配异常
InstantiationException：对象初始化异常
ArithmeticException：算术异常

68.异常的处理机制有几种？

异常捕捉：try…catch…finally，异常抛出：throws。

69.如何自定义一个异常

继承一个异常类，通常是RumtimeException或者Exception

70.在异常捕捉时，如果发生异常，那么try.catch.finally块外的return语句会执行吗？

会执行，如果有finally，在finally之后被执行，如果没有finally，在catch之后被执行

71.Try.catch.finally是必须要存在的吗？

Try块必须存在，catch和finally可以不存在，但不能同时不存在

72.Thow与thorws区别

Throw写在代码块内，throw后面跟的是一个具体的异常实例
Throw写在方法前面后面，throws后面跟的是异常类，异常类可以出现多个

73.Error与Exception区别？

Error和Exception都是java错误处理机制的一部分，都继承了Throwable类。

Exception表示的异常，异常可以通过程序来捕捉，或者优化程序来避免。

Error表示的是系统错误，不能通过程序来进行错误处理。

74.使用Log4j对程序有影响吗？

有，log4j是用来日志记录的，记录一些关键敏感的信息，通常会将日志记录到本地文件或者数据库中。记录在本地文件中，会有频繁的io操作，会耗费一些系统资源。记录在数据库中，会频繁地操作数据库表，对系统性能也有一定的影响。但是为了程序安全以及数据的恢复或者bug的跟踪，这点资源消耗是可以承受的。

75.Log4j日志有几个级别？

由低到高：debug、info、wran、error

76.除了使用new创建对象之外，还可以用什么方法创建对象？

Java反射

77.Java反射创建对象效率高还是通过new创建对象的效率高？

通过new创建对象的效率比较高。通过反射时，先找查找类资源，使用类加载器创建，过程比较繁琐，所以效率较低

78.Java中集合框架的有几个？

Coillection、Map。

79.Collection接口下有那些集合框架？

List：线性表、Set：无序集合。

80.List接口有什么特点？

顺序存储、可以有重复值。

81.Set接口有什么特点

无须存储、不能有重复值。

82.ArrayList与LinkedList有什么区别？

ArrayList与LinkedList都实现了List接口。
ArrayList是线性表，底层是使用数组实现的，它在尾端插入和访问数据时效率较高， 
Linked是双向链表，他在中间插入或者头部插入时效率较高，在访问数据时效率较低

83.Array与ArrayList有什么不一样？

Array与ArrayList都是用来存储数据的集合。ArrayList底层是使用数组实现的，但是arrayList对数组进行了封装和功能扩展，拥有许多原生数组没有的一些功能。我们可以理解成ArrayList是Array的一个升级版。

84.Map有什么特点

以键值对存储数据
元素存储循序是无须的
不允许出现重复键

85.JDBC操作的步骤

加载数据库驱动类
打开数据库连接
执行sql语句
处理返回结果
关闭资源

86.在使用jdbc的时候，如何防止出现sql注入的问题。

使用PreparedStatement类，而不是使用Statement类

参考文章：https://www.jb51.net/article/108987.htm

87.怎么在JDBC内调用一个存储过程

使用CallableStatement

参考文章：https://www.cnblogs.com/fjdingsd/p/5272923.html

88.是否了解连接池，使用连接池有什么好处？

数据库连接是非常消耗资源的，影响到程序的性能指标。连接池是用来分配、管理、释放数据库连接的，可以使应用程序重复使用同一个数据库连接，而不是每次都创建一个新的数据库连接。通过释放空闲时间较长的数据库连接避免数据库因为创建太多的连接而造成的连接遗漏问题，提高了程序性能。

参考文章：https://www.cnblogs.com/sharpest/p/6240475.html

89.你所了解的数据源技术有那些？使用数据源有什么好处？

Dbcp,c3p0等，用的最多还是c3p0，因为c3p0比dbcp更加稳定，安全；通过配置文件的形式来维护数据库信息，而不是通过硬编码。当连接的数据库信息发生改变时，不需要再更改程序代码就实现了数据库信息的更新。

90.Java的io流分为哪两种？

按功能来分

输入流(input)，输出流(output)

按类型来分

字节流，字符流

91.常用io类有那些？

File
FileInputSteam，FileOutputStream
BufferInputStream，BufferedOutputSream
PrintWrite
FileReader，FileWriter
BufferReader，BufferedWriter
ObjectInputStream，ObjectOutputSream

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

以字节为单位输入输出数据，字节流按照8位传输
以字符为单位输入输出数据，字符流按照16位传输

93.final、finalize()、finally

性质不同

final为关键字；
finalize()为方法；
finally为区块标志，用于try语句中；

作用

final为用于标识常量的关键字，final标识的关键字存储在常量池中（在这里final常量的具体用法将在下面进行介绍）；
finalize()方法在Object中进行了定义，用于在对象“消失”时，由JVM进行调用用于对对象进行垃圾回收，类似于C++中的析构函数；用户自定义时，用于释放对象占用的资源（比如进行I/0操作）；
finally{}用于标识代码块，与try{}进行配合，不论try中的代码执行完或没有执行完（这里指有异常），该代码块之中的程序必定会进行；

94.抽象类和接口的区别?

抽象类：

抽象方法，只有行为的概念，没有具体的行为实现。使用abstract关键字修饰，没有方法体。子类必须重写这些抽象方法。
包含抽象方法的类，一定是抽象类。
抽象类只能被继承，一个类只能继承一个抽象类。

接口：

全部的方法都是抽象方法，属型都是常量
不能实例化，可以定义变量。
接口变量可以引用具体实现类的实例
接口只能被实现，一个具体类实现接口，必须实现全部的抽象方法
接口之间可以多实现
一个具体类可以实现多个接口，实现多继承现象

95.线程同步的方法

wait():让线程等待。将线程存储到一个线程池中。
notify()：唤醒被等待的线程。通常都唤醒线程池中的第一个。让被唤醒的线程处于临时阻塞状态。
notifyAll(): 唤醒所有的等待线程。将线程池中的所有线程都唤醒。

96.线程与进程的区别

进程是系统进行资源分配和调度的一个独立单位，线程是CPU调度和分派的基本单位

进程和线程的关系：

一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
资源分配给进程，同一进程的所有线程共享该进程的所有资源。
线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
线程是指进程内的一个执行单元，也是进程内的可调度实体。

线程与进程的区别：

调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位。
并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行。
拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。
系统开销：在创建或撤销进程的时候，由于系统都要为之分配和回收资源，导致系统的明显大于创建或撤销线程时的开销。但进程有独立的地址空间，进程崩溃后，在保护模式下不会对其他的进程产生影响，而线程只是一个进程中的不同的执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但是在进程切换时，耗费的资源较大，效率要差些。

97.&和&&的区别

&是位运算符。&&是布尔逻辑运算符，在进行逻辑判断时用&处理的前面为false后面的内容仍需处理，用&&处理的前面为false不再处理后面的内容。

98.重载与重写

Overload为重载，Override为重写方法的重写和重载是Java多态性的不同表现。重写是父类与子类之间多态性的一种表现，重载是一个类中多态性的一种表现。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Override)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。
如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overload)。
重载的方法是可以改变返回值的类型。

99.如果对象的引用被置为null，垃圾收集器是否会立即释放对象占用的内存？

不会，在下一个垃圾回收周期中，这个对象将是可被回收的。

100.串行(serial)收集器和吞吐量(throughput)收集器的区别是什么？

吞吐量收集器使用并行版本的新生代垃圾收集器，它用于中等规模和大规模数据的应用程序。而串行收集器对大多数的小应用(在现代处理器上需要大概100M左右的内存)就足够了。

101、String,StringBuffer, StringBuilder 的区别是什么？String为什么是不可变的？
1. String是字符串常量，StringBuffer和StringBuilder是字符串变量。StringBuffer是线程安全的，StringBuilder是非线程安全的。具体来说String是一个不可变的对象，每次修改String对象实际上是创新新对象，并将引用指向新对象。效率很低。StringBuffer

是可变的，即每次修改只是针对其本身，大部分情况下比String效率高，StringBuffer保证同步（synchronized），所以线程安全。StringBuilder没有实现同步，所以非线程安全。但效率应该比StringBuffer高。StringBuffer使用时最好指定容量，这样会比不指定容量快30%-40%，甚至比不指定容量的StringBuilder还快。

102、VECTOR,ARRAYLIST, LINKEDLIST的区别是什么？
vector是同步的，arraylist和linkedlist不是同步的。底层方面，vector与arraylist都是基于object[]array实现的，但考虑vector线程安全，所以arraylist效率上回比vector较快。元素随机访问上，vector与arraylist是基本相同的，时间复杂度是O(1)，linkedlist的随机访问元素的复杂度为O(n)。但在插入删除数据上，linkedlist则比arraylist要快很多。linkedlist比arraylist更占内存，因为linkedlist每个节点上还要存储对前后两个节点的引用。

103、HASHTABLE, HASHMAP，TreeMap区别
Hashmap和HashTable都实现了Map接口，但HashTable是线程安全的，HashMap是非线程安全的。HashMap中允许key-value值均为null，但HashTable则不允许。HashMap适合单线程，HashTable适合多线程。HashTAble中的hash数字默认大小是11，增加方式为old*2+1,HashMap中的hash默认大小为16，且均为2的指数。TreeMap则可以将保持的数据根据key值进行排列，可以按照指定的排序方式。默认为升序。

104、ConcurrentHashMap和HashTable的区别
两者均应用于多线程中，但当HashTable增大到一定程度时，其性能会急剧下降。因为迭代时会被锁很长时间。但ConcurrentHashMap则通过引入分割来保证锁的个数不会很大。简而言之就是HashTable会锁住真个map，而ConcurrentHashMap则只需要锁住map的一个部分。

105、Tomcat，apache，jboss的区别
Tomcat是servlet容器，用于解析jsp，servlet。是一个轻量级的高效的容器；缺点是不支持EJB，只能用于Java应用。

Apache是http服务器（web服务器），类似于IIS可以用来建立虚拟站点，编译处理静态页面。支持SSL技术，支持多个虚拟主机等功能。

Jboss是应用服务器，运行EJB的javaee应用服务器，遵循javaee规范，能够提供更多平台的支持和更多集成功能，如数据库连接，JCA等。其对servlet的支持是通过集成其他servlet容器来实现的。如tomcat。

106、GET POST区别
get是从服务器上获取数据，post是向服务器发送数据。

get是把参数数据队列加到提交表单的action属性所指的URL中，值和表单内各个字段一一对应，在url中可以看到。post是通过HTTPpost机制，将表单内各个字段与其内容放置在html header内一起传送到action属性所指的url地址。

对于get方式，服务区端用request.QueryString获取变量值，对于post方式，服务器端用request.Form获取提交的数据。get传送的数据量较小，post较大，一般不受限制。get安全性比post要低，但执行效率较高。

107、SESSION, COOKIE区别
session数据放在服务器上，cookie则放在客户浏览器上。cookie不太安全，因为可以分析出本地cookie，并进行cookie欺骗，考虑安全应使用session。session会在一定时间内保存在服务器上，当访问增多时，会比较占用服务器的性能，考虑减轻服务器压力则应该使用cookie。单个cookie保持的数据不超过4k，很多浏览器都限制要给站点最多保存20个cookie。

108、Servlet的生命周期
主要分三个阶段：初始化——调用init()方法，响应客户请求阶段——调用service()方法，终止阶段——调用destroy方法。工作原理：客户发送一个请求，servlet调用service方法对请求进行响应，即对请求方式进行匹配，选择调用doGet、doPost方法等，然后进入对于的方法中调用逻辑层的方法，实现对客户的响应。自定义的servlet必须首先servlet接口。

具体生命周期包括：装载Servlet、服务器创建Servlet实例、服务器调用Servlet的init()方法、客户请求到达服务器、服务器创建请求对象、服务创建相应对象、服务器激活Servlet的service方法，请求对象和响应对象作为service()方法的参数、service()方法获得关于请求对象的信息，处理请求，访问其他资源，获得需要的信息、service()方法可能激活其他方法以处理请求，如doGet()，doPost()

109、HTTP 报文包含内容

请求方法包括GET,POST,HEAD,PUT,TRACE,OPTIONS,DELETE。请求头如：Host、User-Agent、Connection、Accept-Charset等。请求头部的最后会有一个空行，表示请求头部结束，接下来为请求正文，这一行非常重要，必不可少。请求正文为可选部分，如get就没有。
110、Statement与PreparedStatement的区别,什么是SQL注入，如何防止SQL注入
使用PreparedStatement可以提升代码的可读性和可维护性，可以尽最大可能提高性能。因为Statement每次执行一个SQL命令都会对其编译，但PreparedStatement则只编译一次。PreparedStatement就类似于流水线生产。另一方面PreparedStatement可以极大提高安全性：它对传递过来的参数进行了强制参数类型转换，确保插入或查询数据时，与底层数据库格式匹配。

SQL注入：就是通过将sql命令插入到web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意SQL命令。如sql命令：select id from test where name='1' or 1=1; drop table test,但用PreparedStatement就可以避免这种问题。

111、redirect, forward区别
redirect：服务器根据逻辑，发送一个状态码，告诉浏览器重新去请求那个地址。所以地址栏显示是新的url。forward是指服务器请求资源，直接访问目标地址url，把响应的内容读取过来并再发送给浏览器，浏览器并不知道资源从哪里来，所以地址栏不变。

redirect不能共享数据，forward转发页面和转发到页面可以贡献request中的数据。redirect用于注销，forward用于登陆。forward效率高于redirect。

112、关于JAVA内存模型，一个对象（两个属性，四个方法）实例化100次，现在内存中的存储状态，几个对象，几个属性，几个方法。
Java新建的对象都放在堆里，如果实例化100次，堆中产生100个对象，一般对象与其属性和方法属于一个整体，但如果属性和方法是静态的，则属性和方法只在内存中存一份。

113、谈谈Hibernate的理解，一级和二级缓存的作用，在项目中Hibernate都是怎么使用缓存的
一级缓存为session基本的缓存，是内置的不能卸载。一个Session做了一个查询操作，它会把这个结果放在一级缓存中，如果短时间内这个session又做了同一个操作，那么hibernate就直接从一级缓存中获取数据。

二级缓存是SessionFactory的缓存，分为内置缓存和外置缓存两类。即查询结果放在二级缓存中，如果同一个sessionFactory创建的某个session执行了相同的操作，hibernate就会从二级缓存中获取结果。适合放在二级缓存中的数据包括：很少被修改的数据，不是很重要的数据，允许出现偶偶并发的数据，不会被并发访问的数据，参考数据。不适合放在二级缓存中的数据：经常被修改的数据，财务数据，绝对不允许出现并发，与其他应用共享的数据。

114、反射讲一讲，主要是概念,都在哪需要反射机制，反射的性能，如何优化
能够分析类能力的程序称为反射。反射机制可以用来：在运行中分析类的能力，在运行中查看对象，如编写一个toString方法供所有类使用。实现通用的数据操作代码。利用Method对象，这个对象很像C++的指针。

反射性能优化方法主要为设置不用做安全检查。

115、谈谈Hibernate与Ibatis的区别，哪个性能会更高一些
Ibatis相当较为简单，容易上手，Hibernate比较复杂，门槛较高。如果系统需要处理数据量很大，性能要求很高，需要执行高度优化的sql语句才能达到性能要求，则此时Ibatis会比较好。

对不同数据库支持方面Hibernate较好，因为Ibatis需要修改的字段较多。另外Hibernate现已成为主流的o/r Mapping框架，开发效率高。

116、对Spring的理解，项目中都用什么？怎么用的？对IOC、和AOP的理解及实现原理

117、线程同步，并发操作怎么控制
线程同步不一定就是同时，而是协同步骤，或协同步调。线程同步就是多个线程在逻辑上互有因果关系，所以要对其执行顺序进行协调。

线程并发是指同一时间间隔内，多个线程同时执行。如果线程在时间上能够区分，那么就可以上线程休眠指定的时间来进行同步，可用sleep()方法完成。如果线程在时间上不能区分，但在逻辑顺序上可以区分的话，那么可用jion()方法来完成，一个先执行完，然后执行另一个。如果线程设计较为复杂，那么就只有通过wait()，notify()方法来完成了

118、描述struts的工作流程。

简略过程就是web应用启动，接收用户请求并进行匹配，返回用户请求信息。
1. 在web应用启动时，加载并初始化ActionServlet,ActionServlet从struct-config.xml文件中读取配置信息，把它们存放到各个配置对象中。

2. 当ActionServlet接收到一个客户请求时，首先检索和用户请求相配的ActionMapping实例，如果不存在，返回用户请求路径无效信息。

3. 如ActionForm实例不存在，则创建一个ActionForm对象，把客户提交的表单数据保存到ActionForm对象中。

4. 根据配置信息决定是否需要表单验证。如果需要验证，就调用ActionForm的Validate()方法。如果Valiedate()方法返回null或返回一个不包含ActionMessage的ActionErrors对象，则表示表单验证成功。

5. ActionServlet更加ActionMapping实例包含的映射信息决定请请求转发给哪个Action。如果相应的Action实例不存在，则先创建这个实例，然后调用Action的execute()方法。

6. Action的execute()方法返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象指向的JSP组建。

7. ActionForward对象指向的jsp组件生成的动态网页，返回给客户。

119、Tomcat的session处理，如果让你实现一个tomcatserver，如何实现session机制
当一个session开始时，Servlet容器会创建一个HttpSession对象，在某些情况下把这些HttpSession对象从内存中转移到文件系统中或数据库中。需要访问的时候将它们载入到内存中。这样的好处就是节省内存，当web服务器产生故障时，还可以从文件系统或数据库中恢复Session的数据。管理session有两个类：1）StandardManager，这是一个默认的类，当tomcat启动或重载时将会session对象保存到指定文件中。2）PersistentManager，管理方式更加灵活，具有容错能力，可以及时把Session备份到Session Store中，可以控制内存中Session的数量。

120、关于Cache(Ehcache,Memcached)
Memcache:分布式内存对象缓存系统，占用其他机子的内存。很多互联网，负载均衡三台(以三台为例)web服务器可以共享一台Memcache的资源。传递的信息以键值对的形式存储。传递的数据要实现序列化。

Oscache:页面级缓存（网上强调最多的东西）,占用本机的内存资源。可以选择缓存到硬盘，如存取到硬盘重启服务也可重新获得上次持久化的资源，而如果缓存到内存就不行。一般没必要缓存到硬盘，因为I/O操作也是比较耗资源，和从数据库取往往优势很小。Oscache存取数据的作用域分为application和session两种。

EhCache：Hibernate缓存，DAO缓存，安全性凭证缓存（Acegi），Web缓存，应用持久化和分布式缓存。EhCache在默认情况下，即在用户未提供自身配置文件ehcache.xml或ehcache-failsafe.xml时，EhCache会依据其自身Jar存档包含的ehcache-failsafe.xml文件所定制的策略来管理缓存。如果用户在classpath下提供了ehcache.xml或ehcache-failsafe.xml文件，那么EhCache将会应用这个文件。如果两个文件同时提供，那么EhCache会使用ehcache.xml文件的配置。

121、sql的优化相关问题
1. 对查询优化，避免全表扫描

2. 尽量避免where子句中对段进行null值判断，否则将导致引擎放弃使用索引而进行全表扫描。

3. 尽量避免where子句中出现!=或<>，否则将导致引擎放弃使用索引而进行全表扫描。

4. 尽量避免where子句中出现or来连接条件。

5. 慎用in和not in，否则导致全表扫描

6. where中不要用函数操作。

7. Update 语句，如果只更改1、2个字段，不要Update全部字段，否则频繁调用会引起明显的性能消耗，同时带来大量日志。

8. 对于多张大数据量（这里几百条就算大了）的表JOIN，要先分页再JOIN，否则逻辑读会很高，性能很差。

9. 尽可能的使用 varchar/nvarchar 代替 char/nchar，节省空间，提高查询效率

10. select count(*) from table；这样不带任何条件的count会引起全表扫描，并且没有任何业务意义，是一定要杜绝的。

122、oracle中 rownum与rowid的理解，一千条记录我查200到300的记录怎么查？

123、如何分析ORACLE的执行计划？

124、 DB中索引原理，种类，使用索引的好处和问题是什么？
原理：因为检索磁盘比对数据，需要大量的时间和IO，所以就需要构造某列的数据的btree、hash值、位图索引。一般的索引能快速的查找比对，而索引的值记录了磁盘的位置，直接读取数据库字段对应位置的内容。

索引好处：加快数据检索速度、加速表与表之间的连接特别是实现数据的参考完整性方面有特别的意义、减少查询中分组和排序的时间，使用优化隐藏器，提高系统性能。

缺点：创建和维护索引需要时间，索引需要占用物理空间，当对表中的数据惊醒增删改时所有也需要动态维护。

125、JVM垃圾回收实现原理。垃圾回收的线程优先级。
JVM的堆空间中主要分为年轻代、年老代和永久代。年轻代和年老代是存储动态产生的对象。永久代主要是存储java类信息，包括解析得到的方法属性、字段等等。永久代基本不参与垃圾回收。年轻代分为一个eden区和两个相同的survior区。刚开始创建的对象都放置在eden区。这样主要是为了将生命周期短的对象尽量留在年轻代中。当eden区申请不到空间时，进行minorGC，把存活的对象拷贝到survior。年老代主要存放生命周期比较长的对象，如缓存对象。具体JVM垃圾回收过程如下：

1、对象在Eden区完成内存分配。2、当Eden区满了，在创建对象就会申请不到空间，则触发minorGC，进行young（eden区和1survivor区的垃圾回收）。3、在minorGC时，Eden不能被回收的对象呗放入到空的survior（即Eden肯定被清空），另一个survivor里不能被GC回收的地想也会被放入到这个survivor，始终保证一个survivor是空的。4、当完成第三步的时候、如果发现survivor满了，则这些对象呗copy到old区，或者survivor并没有满，但有些对象已经足够old了，也被放入到old区。当old区北放满之后，进行fullGC。

126、jvm 最大内存设置。设置的原理。结合垃圾回收讲讲。

JVM内存可以分为堆内存和非堆内存，堆内存给开发人员用的，非堆内存给JVM本身用的，用来存放类型信息，即使GC时也不会释放空间。

堆内存设置：

-Xms 初始堆内存，默认物理内存1/64，也是最小分配堆内存，当空余堆内存小于40%时，会增加到-Xms的最大限制。

-Xmx 最大堆内存分配，默认物理内存1/4，当空余堆内存大于70%时，会减小打-Xms的最小限制。

非堆内存设置：

-XX:PermSize 非堆内存的初始值，默认物理内存的1/64，也是最小非堆内存。

-XX:MaxPermSize 非堆内存最大值，默认物理内存的1/4。

查看堆大小命令为Runtime.getRuntime().maxMemory()。

127、jvm怎样通过参数调整内存大小

本地环境变量中JVM参数设置：

new一个JAVA_OPTS:

variable name: JAVA_OPTS

variable value: -Xms256M -Xmx512M -XX:PermSize=256M -XX:MaxPermSize=512M

eclipse中参数设置：在缺省VM参数中输入：-Xmx128m -Xms64m -Xmn32m -Xss16m

128、进程与线程的区别

线程是进程的一个单元，也是进程内的可调度实体。区别就是：1、进程内的线程共享地址空间，进程则自己独立的地址空间。2、进程是资源分配和拥有的单位，同一个进程内的线程共享进程资源。3、线程是处理器调度的基本单位。4、两者均可并发执行。

129、怎样避免死锁

1. 使用事务时，尽量缩短事务idea逻辑处理过程，及早提交或回滚事务

2. 设置死锁的超时参数为合理范围，如3-10分钟，若超过时间，自动放弃本次操作，避免进程悬挂。

3. 优化程序，检查并避免死锁现象出现。

4. 对所有的脚本和sp都要仔细测试。

5. 所有的sp都要有错误处理。

6. 一般不要修改sql事务的默认级别。不推荐强行加锁。

130、垃圾回收算法使用的产品、场景

标记-清除算法：标记阶段，确定所有要回收的对象，并标记，清除阶段则将需要回收的对象清除。

复制算法：把内存分为大小相等的两块，每次使用其中的一块，当垃圾回收时，把存活的对象复制到另一块上，然后把这块内存整个清理掉。两块内存比是8：1

标记整理算法：把存活的对象往内存的一端移动，然后直接回收边界以外的内存。标记-整理算法提高了内存的利用率，并且它适合在收集对象存活时间较长的老年代。

分代回收算法：根据对象的存活时间把内存分为新生代和老年代，根据各代对象的存活特点，每代采用不同的GC算法。新生代用标记-复制算法，老年代用标记-整理算法。

如何配置

131、实际项目中JVM调优

1、JVM启动参数：调整各代的内存比例和垃圾回收算法，提高吞吐量。

2、改进程序逻辑算法，提高性能

3、自定义封装线程池，解决用户响应时间长的问题。比如设置线程最小数量、最大数量

4、连接池

132、jdk并发包的集合介绍

Map并发包，其实现为ConcurrentHashMap，它实现了ConcurrentMap接口。put方法为根据计算出的hash值去获取segment对象。找到segment对象后调用该对象的put方法完成操作。segment中的put方法则是先加锁，之后判断数组大小，然后觉得是否扩充。然后得到key索要放置的位置。

List并发包，客在高并发环境下使用CopyOnWriteArrayList代替ArrayList。添加元素是利用数组的copy功能和加锁机制。并发情况下，CopyOnWriteArrayList比ArrayList略快了些。

set并发，CopyOnWriteSet和CopyOnWriteArrayList底层实现差不多就是在添加元素时会进行唯一性判断，如果对象数组已经含有重复的元素，不进行增加处理。

queue并发，并发类是ArrayBlockingQueue，底层为数组，并对关键的方法入队、出队操作加入了锁队机制。

Atomic系列类，比如AtomicInteger类，通过使用计数器操作时，一般为了避免线程安全问题，在方法上加锁操作。有了并发包下的原子系列类，我们就可以直接使用。

133、线程之间的通信

主要包括互斥锁、条件变量、读写锁和线程信号灯。

互斥锁：以排他方式防止数据被并发修改。互斥锁两个状态0和1。具体为申请锁、占用锁以防止数据被修改，此时默认阻塞等等，最后释放锁。

条件变量通信机制：原理，条件变量出现时，可以弥补互斥锁的缺陷，有些问题仅仅依靠互斥锁无法解决。但条件变量不能单独使用，必须配合互斥锁一起实现对资源的互斥访问。

读写锁:在对数据读写时，往往读占主要部分。基本原则是如果其他线程读数据，则允许其他线程执行读操作，但不允许写操作。如果有其他线程申请写操作，则其他线程不能申请读操作和写操作。

线程信号：线程拥有与信号相关的私有数据——线程信号掩码。线程可以向别的线程发送信号，每个线程可以设置自己的阻塞集合。所有线程中，同一信号子任何线程里的对该信号的处理一定相同。

134、介绍threadlocal

可以叫做线程本地变量或线程本地存储。ThreadLocal为变量在每个线程中都创建了一个副本，每个线程都可以访问自己内部的副本变量。但可能这样做会导致内存占用较大。

ThreadLocal类的几个方法：get() 用来获取ThreadLocal在当前线程中保存的变量副本，set()用来设置当前线程中变量的副本，remove()用来一冲当前线程中的变量副本，initialValue()一般用来在使用时进行重写，是一个延迟加载方法。最常见的ThreadLocal使用场景是用来解决数据库连接、Session管理等。

135、jdbc的操作过程

加载数据库驱动包、连接数据库、使用sql语句操作数据库、关闭数据库连接

136、HTTP1.1的新特性

支持持续连接，通过建立一个TCP后，发送请求并得到响应，然后发送更多的请求并得到更多的响应。通过把简历和释放TCP连接的开销分摊到多个请求上，则对每个请求而言，优于TCP而造成的相对开销被大大降低。而且还可以发送流水线请求。

137、异常处理，包含了什么

参考：http://lavasoft.blog.51cto.com/62575/18920/

138、堆排序与快速排序

View Code

堆排序是渐进最优的比较排序算法，达到了O(nlgn)这一下界，而快排有一定的可能性会产生最坏划分，时间复杂度可能为O(n^2)。堆排比较的几乎都不是相邻元素，对cache极不友好。数学复杂度并不一定代表实际运行的复杂度。

139、Collection有哪些类

Set, List, Map, SortedSet, SortedMap, HashSet, TreeSet, ArrayList, LinkedList, Vector, Collections, Arrays, AbstractCollection

140、Hashcode总为1会怎样，如何解决hash冲突

当所有对象Hashcode返回都为1时，所有对象都出现hash冲突，其性能会下降

解决hash冲突：

线性再散列法、插入元素时，如果发生冲突，算法会简单的遍历hash表，直到找到表中的下一个空槽，并将该元素放入该槽中。查找元素时，首先散列值所指向的槽，如果没有找到匹配，则继续遍历hash表，直到：（1）找到相应的元素；（2）找到一个空槽（指示查找的元素不存在）；（3）整个hash表遍历完毕（指示该元素不存在并且hash表是满的）。

非线性再散列法、线性再散列法是从冲突位置开始，采用一个步长以顺序方式遍历hash表，来查找一个可用的槽，从上面的讨论可以看出，它容易产生聚集现象。非线性再散列法可以避免遍历散列表，它会计算一个新的hash值，并通过它跳转到表中一个完全不同的部分。

外部拉链法、将hash表看作是一个链表数组，表中的每个槽要不为空，要不指向hash到该槽的表项的链表。

141、如何用两个队列实现栈

即可以将A队列作为栈push，B队列作为栈pop。量队列数据相同。

142、Object的通用方法

通用方法有equals(), finalize(), toString(), 其他native方法有hashcode(), registerNatives(), getClass(), clone(), notify(), notifyAll(), wait()等。

143、Java中如何实现多态

多态是OOP中的一个重要特性，主要用来实现动态联编，程序的最终状态只有在执行过程中才被决定而非在编译期间就决定了。有利于提高大型系统的灵活性和扩展性。

多态的三个必要条件：有继承、有方法重写、父类引用指向子类对象。

引用变量的两种类型：编译时类型由申明类型决定，运行时类型由实际对应的对象决定。

View Code

多态内存：

144、Java内存泄漏

内存泄漏一般情况下有两种情况：C++/C语言中，在堆中分配的内存，没有将其释放掉就删除了所有能访问到这块内存的方式全部删除。（如指针重新赋值）

另一种情况就是在内存对象已经不需要时，还保留这块内存和它的访问方式（引用），由于Java中GC机制，所以Java中的内存泄漏通常指第二种情况。

尽管对于C/C++中的内存泄露情况来说，Java内存泄露导致的破坏性小，除了少数情况会出现程序崩溃的情况外，大多数情况下程序仍然能正常运行。但是，在移动设备对于内存和CPU都有较严格的限制的情况下，Java的内存溢出会导致程序效率低下、占用大量不需要的内存等问题。这将导致整个机器性能变差，严重的也会引起抛出OutOfMemoryError，导致程序崩溃。

在不涉及复杂数据结构情况下，Java内存泄漏表现为一个内存对象的生命周期超出程序需要它的长度。（称为对象游离）。

内存泄漏实例：Java堆溢出、虚拟机栈和本地方法栈溢出、方法区和运行时常量池溢出、本机直接内存溢出

145、final字段总结

1. final类不能被继承，其中的方法也是默认final类型，没有子类。

2. final方法不能被子类覆盖，但可以继承

3. final变量表示常量，只能被赋值一次赋值后不改变

4. final不能用于构造方法

146、override（重写）和overload（重载）区别

override：子类在继承父类时，子类可以定义某些方法与父类的方法名称、参数个数、类型、顺序、返回值类型一致，但调用时自动调用子类的方法，父类相当于被覆盖了。

overload：可以表现在类的多态上，函数名相同，但其他参数个数、类型、顺序、返回值等都不相同。

147、spring MVC与struts2的区别:
参考： https://blog.csdn.net/chenleixing/article/details/44570681

1、Struts2是类级别的拦截，一个类对应一个request上下文，SpringMVC是方法级别的拦截

2、SpringMVC的方法之间基本上独立的，独享request response数据

3、由于Struts2需要针对每个request进行封装，把request，session等servlet生命周期的变量封装成一个一个

Map，供给每个Action使用，并保证线程安全，所以在原则上，是比较耗费内存的

4、拦截器实现机制上，Struts2有以自己的interceptor机制，SpringMVC用的是独立的AOP方式

5、SpringMVC的入口是servlet，而Struts2是filter

6、SpringMVC集成了Ajax

7、SpringMVC验证支持JSR303，处理起来相对更加灵活方便，而Struts2验证比较繁琐，感觉太烦乱

8、Spring MVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高

9、Struts2更加符合OOP的编程思想， SpringMVC就比较谨慎，在servlet上扩展

10、SpringMVC开发效率和性能高于Struts2

11、SpringMVC可以认为已经100%零配置

148、黑盒测试、灰盒测试、白盒测试、单元测试有什么区别？

黑盒测试关注程序的功能是否正确，面向实际用户；

白盒测试关注程序源代码的内部逻辑结构是否正确，面向编程人员；

灰盒测试是介于白盒测试与黑盒测试之间的一种测试。

单元测试(Unit Testing)是对软件基本组成单元进行的测试，如函数或是一个类的方法。这里的单元，就是软件设计的最小单位。

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

答： Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等 equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值

150.Java中的NIO，BIO，AIO分别是什么

BIO:同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。
NIO:同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持。
AIO:异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理.AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

151、一个".java"源文件中是否可以包含多个类（不是内部类）？有什么限制？
答：可以，但一个源文件中最多只能有一个公开类（public class）而且文件名必须和公开类的类名完全保持一致。

152. Java 的引用类型有哪几种

对象的强、软、弱和虚引用（四种引用）

在JDK 1.2以前的版本中，若一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及（reachable）状态，程序才能使用它。从JDK 1.2版本开始，把对象的引用分为4种级别，从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

⑴强引用（StrongReference）
强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。 ps：强引用其实也就是我们平时A a = new A()这个意思。
⑵软引用（SoftReference）
如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存（下文给出示例）。
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
⑶弱引用（WeakReference）
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
⑷虚引用（PhantomReference）
“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

ReferenceQueue queue = new ReferenceQueue ();

PhantomReference pr = new PhantomReference (object, queue);
程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

153，MVC的各个部分都有那些技术来实现?如何实现?

MVC是Model－View－Controller的简写。Model代表的是应用的业务逻辑（通过JavaBean，EJB组件实现），View是应用的表示面（由JSP页面产生），Controller是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。

154，Http中，get和post方法的区别

1，Get是向服务器发索取数据的一种请求，而Post是向服务器提交数据的一种请求

2，Get是获取信息，而不是修改信息，类似数据库查询功能一样，数据不会被修改

3，Get请求的参数会跟在url后进行传递，请求的数据会附在URL之后，以?分割URL和传输数据，参数之间以&相连,％XX中的XX为该符号以16进制表示的ASCII，如果数据是英文字母/数字，原样发送，如果是空格，转换为+，如果是中文/其他字符，则直接把字符串用BASE64加密。
4，Get传输的数据有大小限制，因为GET是通过URL提交数据，那么GET可提交的数据量就跟URL的长度有直接关系了，不同的浏览器对URL的长度的限制是不同的。

5，GET请求的数据会被浏览器缓存起来，用户名和密码将明文出现在URL上，其他人可以查到历史浏览记录，数据不太安全。

在服务器端，用Request.QueryString来获取Get方式提交来的数据
Post请求则作为http消息的实际内容发送给web服务器，数据放置在HTML Header内提交，Post没有限制提交的数据。Post比Get安全，当数据是中文或者不敏感的数据，则用get，因为使用get，参数会显示在地址，对于敏感数据和不是中文字符的数据，则用post。
6，POST表示可能修改变服务器上的资源的请求，在服务器端，用Post方式提交的数据只能用Request.Form来获取。

155，jsp和servlet的区别、共同点、各自应用的范围？

JSP是Servlet技术的扩展，本质上就是Servlet的简易方式。JSP编译后是“类servlet”。

Servlet和JSP最主要的不同点在于：Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。

JSP侧重于视图，Servlet主要用于控制逻辑。在struts框架中,JSP位于MVC设计模式的视图层,而Servlet位于控制层.

156，什么是幻读，哪种隔离级别可以防止幻读？

　　幻读是指一个事务多次执行一条查询返回的却是不同的值。假设一个事务正根据某个条件进行数据查询，然后另一个事务插入了一行满足这个查询条件的数据。之后这个事务再次执行了这条查询，返回的结果集中会包含刚插入的那条新数据。这行新数据被称为幻行，而这种现象就叫做幻读。

　　只有TRANSACTION_SERIALIZABLE隔离级别才能防止产生幻读。

157、谈谈你对Hibernate的理解。

1. 面向对象设计的软件内部运行过程可以理解成就是在不断创建各种新对象、建立对象之间的关系，调用对象的方法来改变各个对象的状态和对象消亡的过程，不管程序运行的过程和操作怎么样，本质上都是要得到一个结果，程序上一个时刻和下一个时刻的运行结果的差异就表现在内存中的对象状态发生了变化。

2.为了在关机和内存空间不够的状况下，保持程序的运行状态，需要将内存中的对象状态保存到持久化设备和从持久化设备中恢复出对象的状态，通常都是保存到关系数据库来保存大量对象信息。从Java程序的运行功能上来讲，保存对象状态的功能相比系统运行的其他功能来说，应该是一个很不起眼的附属功能，java采用jdbc来实现这个功能，这个不起眼的功能却要编写大量的代码，而做的事情仅仅是保存对象和恢复对象，并且那些大量的jdbc代码并没有什么技术含量，基本上是采用一套例行公事的标准代码模板来编写，是一种苦活和重复性的工作。

3.通过数据库保存java程序运行时产生的对象和恢复对象，其实就是实现了java对象与关系数据库记录的映射关系，称为ORM（即Object RelationMapping），人们可以通过封装JDBC代码来实现了这种功能，封装出来的产品称之为ORM框架，Hibernate就是其中的一种流行ORM框架。使用Hibernate框架，不用写JDBC代码，仅仅是调用一个save方法，就可以将对象保存到关系数据库中，仅仅是调用一个get方法，就可以从数据库中加载出一个对象。

4.使用Hibernate的基本流程是：配置Configuration对象、产生SessionFactory、创建session对象，启动事务，完成CRUD操作，提交事务，关闭session。

5.使用Hibernate时，先要配置hibernate.cfg.xml文件，其中配置数据库连接信息和方言等，还要为每个实体配置相应的hbm.xml文件，hibernate.cfg.xml文件中需要登记每个hbm.xml文件。

6.在应用Hibernate时，重点要了解Session的缓存原理，级联，延迟加载和hql查询。

158，谈谈你对Spring的理解。

1.Spring是实现了工厂模式的工厂类（在这里有必要解释清楚什么是工厂模式），这个类名为BeanFactory（实际上是一个接口），在程序中通常BeanFactory的子类ApplicationContext。Spring相当于一个大的工厂类，在其配置文件中通过<bean>元素配置用于创建实例对象的类名和实例对象的属性。

2. Spring提供了对IOC良好支持，IOC是一种编程思想，是一种架构艺术，利用这种思想可以很好地实现模块之间的解耦，IOC也称为DI（Depency Injection）。

3. Spring提供了对AOP技术的良好封装， AOP称为面向切面编程，就是系统中有很多各不相干的类的方法，在这些众多方法中要加入某种系统功能的代码，例如，加入日志，加入权限判断，加入异常处理，这种应用称为AOP。

实现AOP功能采用的是代理技术，客户端程序不再调用目标，而调用代理类，代理类与目标类对外具有相同的方法声明，有两种方式可以实现相同的方法声明，一是实现相同的接口，二是作为目标的子类。

在JDK中采用Proxy类产生动态代理的方式为某个接口生成实现类，如果要为某个类生成子类，则可以用CGLI B。在生成的代理类的方法中加入系统功能和调用目标类的相应方法，系统功能的代理以Advice对象进行提供，显然要创建出代理对象，至少需要目标类和Advice类。spring提供了这种支持，只需要在spring配置文件中配置这两个元素即可实现代理和aop功能。

159，什么是Spring的依赖注入？有哪些方法进行依赖注入

依赖注入，是IOC的一个方面，是个通常的概念，它有多种解释。这概念是说你不用创建对象，而只需要描述它如何被创建。你不在代码里直接组装你的组件和服务，但是要在配置文件里描述哪些组件需要哪些服务，之后一个容器（IOC容器）负责把他们组装起来。

构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。

Setter方法注入：Setter方法注入是容器通过调用无参构造器或无参static工厂方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。

160，什么是Spring beans?

Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化，装配，和管理。这些beans通过容器中配置的元数据创建。比如，以XML文件中<bean/> 的形式定义。

Spring 框架定义的beans都是单件beans。在bean tag中有个属性”singleton”，如果它被赋为TRUE，bean 就是单件，否则就是一个 prototype bean。默认是TRUE，所以所有在Spring框架中的beans 缺省都是单件。

161，AJAX有哪些有点和缺点？

优点：

1、最大的一点是页面无刷新，用户的体验非常好。

2、使用异步方式与服务器通信，具有更加迅速的响应能力。

3、可以把以前一些服务器负担的工作转嫁到客户端，利用客户端闲置的能力来处理，减轻服务器和带宽的负担，节约空间和宽带租用成本。并且减轻服务器的负担，ajax的原则是“按需取数据”，可以最大程度的减少冗余请求，和响应对服务器造成的负担。

4、基于标准化的并被广泛支持的技术，不需要下载插件或者小程序。

缺点：

1、ajax不支持浏览器back按钮。

2、安全问题 AJAX暴露了与服务器交互的细节。

3、对搜索引擎的支持比较弱。

4、破坏了程序的异常机制。

5、不容易调试。

162，简单说一下数据库的三范式？

第一范式：数据库表的每一个字段都是不可分割的

第二范式：数据库表中的非主属性只依赖于主键

第三范式：不存在非主属性对关键字的传递函数依赖关系

163、 Java容器有哪些？哪些是同步容器,哪些是并发容器？

https://www.cnblogs.com/ygj0930/p/6543877.html

164、https和http区别，有没有用过其他安全传输手段？

https://blog.csdn.net/rainHistory/article/details/78780227

165、查询中哪些情况不会使用索引？

https://www.cnblogs.com/xixibaby/p/6409928.html

166、数据库索引，底层是怎样实现的，为什么要用B树索引？

https://blog.csdn.net/qq_35571554/article/details/82796278

167、char型变量中能不能存贮一个中文汉字?为什么?

答：char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

168. 如何确保N个线程可以访问N个资源同时又不导致死锁？

答：使用多线程的时候，一种非常简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁了。

169. 什么是迭代器(Iterator)？

答：Iterator接口提供了很多对集合元素进行迭代的方法。每一个集合类都包含了可以返回迭代器实例的迭代方法。迭代器可以在迭代的过程中删除底层集合的元素,但是不可以直接调用集合的 remove(Object Obj)删除，可以通过迭代器的remove()方法删除。

170. Java中的HashMap的工作原理是什么？

答：Java中的HashMap是以键值对(key-value)的形式存储元素的。HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，负载因子(load factor)和扩容极限(threshold resizing)。

171. 什么是RMI？

答：Java远程方法调用(Java RMI)是Java API对远程过程调用(RPC)提供的面向对象的等价形式，支持直接传输序列化的Java对象和分布式垃圾回收。远程方法调用可以看做是激活远程正在运行的对象上的方法的步骤。RMI对调用者是位置透明的，因为调用者感觉方法是执行在本地运行的对象上的。

172. 什么是Servlet？

答：Servlet 是用来处理客户端请求并产生动态网页内容的 Java 类。Servlet 主要是用来处理或者是存储 HTML 表单提交的数据，产生动态内容，在无状态的 HTTP 协议下管理状态信息。

173. 说一下Servlet的体系结构。

答：所有的 Servlet 都必须要实现的核心的接口是 javax.servlet.Servlet。每一个 Servlet 都必须要直接或者是间接实现这个接口，或者是继承 javax.servlet.GenericServlet 或者javax.servlet.http.HTTPServlet。最后，Servlet 使用多线程可以并行的为多个请求服务。

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

答：在最外层循环前加一个标记如A，然后用break A;可以跳出多重循环。（Java中支持带标签的break和continue语句，作用有点类似于C和C++中的goto语句，但是就像要避免使用goto一样，应该避免使用带标签的break和continue，因为它不会让你的程序变得更优雅，很多时候甚至有相反的作用，所以这种语法其实不知道更好）

175、解释内存中的栈（stack）、堆(heap)和静态存储区的用法。

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

String str = new String(“hello”);

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

补充：较新版本的Java中使用了一项叫“逃逸分析“的技术，可以将一些局部对象放在栈上以提升对象的操作性能。

176、构造器（constructor）是否可被重写（override）?

答：构造器不能被继承，因此不能被重写，但可以被重载。

178、String 和StringBuilder、StringBuffer 的区别?

答：Java 平台提供了两种类型的字符串：String和StringBuffer / StringBuilder，它们可以储存和操作字符串。其中String是只读字符串，也就意味着String引用的字符串内容是不能被改变的。而StringBuffer和StringBuilder类表示的字符串对象可以直接进行修改。StringBuilder是JDK 1.5中引入的，它和StringBuffer的方法完全相同，区别在于它是在单线程环境下使用的，因为它的所有方面都没有被synchronized修饰，因此它的效率也比StringBuffer略高。

补充1：有一个面试题问：有没有哪种情况用+做字符串连接比调用StringBuffer / StringBuilder对象的append方法性能更好？如果连接后得到的字符串在静态存储区中是早已存在的，那么用+做字符串连接是优于StringBuffer / StringBuilder的append方法的。

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

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

补充：

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

2.类的加载是由类加载器完成的，类加载器包括：根加载器（BootStrap）、扩展加载器（Extension）、系统加载器（System）和用户自定义类加载器（java.lang.ClassLoader的子类）。从JDK 1.2开始，类加载过程采取了父亲委托机制(PDM)。PDM更好的保证了Java平台的安全性，在该机制中，JVM自带的Bootstrap是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM不会向Java程序提供对Bootstrap的引用。下面是关于几个类加载器的说明：

a)Bootstrap：一般用本地代码实现，负责加载JVM基础核心类库（rt.jar）；

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

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

178、抽象类（abstract class）和接口（interface）有什么异同?

答：抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法。抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的。抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。

179、比较一下Java 和JavaSciprt。

答：JavaScript 与Java是两个公司开发的不同的两个产品。Java 是原Sun 公司推出的面向对象的程序设计语言，特别适合于互联网应用程序开发；而JavaScript是Netscape公司的产品，为了扩展Netscape浏览器的功能而开发的一种可以嵌入Web页面中运行的基于对象和事件驱动的解释性语言，它的前身是LiveScript；而Java 的前身是Oak语言。

下面对两种语言间的异同作如下比较：

1）基于对象和面向对象：Java是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象；JavaScript是种脚本语言，它可以用来制作与网络无关的，与用户交互作用的复杂软件。它是一种基于对象（Object-Based）和事件驱动（Event-Driven）的编程语言。因而它本身提供了非常丰富的内部对象供设计人员使用；

2）解释和编译：Java 的源代码在执行之前，必须经过编译；JavaScript 是一种解释性编程语言，其源代码不需经过编译，由浏览器解释执行；

3）强类型变量和类型弱变量：Java采用强类型变量检查，即所有变量在编译之前必须作声明；JavaScript中变量声明，采用其弱类型。即变量在使用前不需作声明，而是解释器在运行时检查其数据类型；

4）代码格式不一样。

补充：上面列出的四点是原来所谓的标准答案中给出的。其实Java和JavaScript最重要的区别是一个是静态语言，一个是动态语言。目前的编程语言的发展趋势是函数式语言和动态语言。在Java中类（class）是一等公民，而JavaScript中函数（function）是一等公民。对于这种问题，在面试时还是用自己的语言回答会更加靠谱。

参考文章1：https://www.cnblogs.com/Jansens520/p/8608502.html

参考文章2：https://blog.csdn.net/zzhuan_1/article/details/82584684

参考文章3：https://blog.csdn.net/aaaaajiboke/article/details/82886247

Biegral Blog

java面试题大全（含答案）