一、String, StringBuffer, StringBuilder的区别是什么？String为什么是不可变的？

1、String是字符串常量，StringBuffer和StringBuilder都是字符串变量。后两者的字符内容可变，而前者创建后内容不可变。
2、String不可变是因为在JDK中String类被声明为一个final类。
3、StringBuffer是线程安全的，而StringBuilder是非线程安全的。

补充说明：线程安全会带来额外的系统开销，所以StringBuilder的效率比StringBuffer高。如果对系统中的线程是否安全很掌握，可用StringBuffer，在线程不安全处加上关键字Synchronize。

二、Vector, ArrayList, LinkedList的区别是什么？

1、Vector、ArrayList都是以类似数组的形式存储在内存中，LinkedList则以链表的形式进行存储。
2、List中的元素有序、允许有重复的元素，Set中的元素无序、不允许有重复元素。
3、Vector线程同步，ArrayList、LinkedList线程不同步。
4、LinkedList适合指定位置插入、删除操作，不适合查找；ArrayList、Vector适合查找，不适合指定位置的插入、删除操作。
5、ArrayList在元素填满容器时会自动扩充容器大小的约50%，而Vector则是100%，因此ArrayList更节省空间。

三、HashTable, HashMap， TreeMap的区别是什么？

1、HashTable线程同步，HashMap非线程同步。
2、HashTable不允许<键,值>有空值，HashMap允许<键,值>有空值。
3、HashTable使用Enumeration，HashMap使用Iterator。
4、HashTable中hash数组的默认大小是11，增加方式的old*2+1，HashMap中hash数组的默认大小是16，增长方式一定是2的指数倍。
5、TreeMap能够把它保存的记录根据键排序，默认是按升序排序。

面小易说：以上三个问题所涉及的都是Java语言中的一些比较高级的数据结构，从字符串相关到容器再到哈希表和树等数据结构，因此我们在学习Java语言的时候，也需要更加深入地去对比比较类似的数据结构的使用场景以及其优缺点。

四、Tomcat，Apache，JBoss的区别？

1、Apache是HTTP服务器，Tomcat是Web服务器，JBoss是应用服务器。
2、Apache解析静态的Html文件；Tomcat可解析jsp动态页面、也可充当
容器。

面小易说：对于服务器而言，在面试中可能并不会过多涉及，相对而言，面小易认为像是Liunx、Tomcat这些背后的原理可能更受面试官的青睐。

五、GET，POST请求之间的区别？

基础知识：HTTP的请求格式如下。
主要包含三个信息：1、请求的类型（GET或POST），2、要访问的资源（如resimga.jif），3、HTTP版本（http/1.1）

区别：
1、Get是从服务器端获取数据，Post则是向服务器端发送数据。
2、在客户端，Get方式通过URL提交数据，在URL地址栏可以看到请求消息，该消息被编码过；Post数据则是放在Html header内提交。
3、对于Get方式，服务器端用Request.QueryString获取变量的值；对用Post方式，服务器端用Request.Form获取提交的数据值。
4、Get方式提交的数据最多1024字节，而Post则没有限制。
5、Get方式提交的参数及参数值会在地址栏显示，不安全，而Post不会，比较安全。

六、Session, Cookie的区别是什么？

1、Session由应用服务器维护的一个服务器端的存储空间；Cookie是客户端的存储空间，由浏览器维护。
2、用户可以通过浏览器设置决定是否保存Cookie，而不能决定是否保存Session，因为Session是由服务器端维护的。
3、Session中保存的是对象，Cookie中保存的是字符串。
4、Session和Cookie不能跨窗口使用，每打开一个浏览器系统会赋予一个SessionID，此时的SessionID不同，若要完成跨浏览器访问数据，可以使用 Application。
5、Session、Cookie都有失效时间，过期后会自动删除，减少系统开销。

七、HTTP 报文包含内容

主要包含四部分：
1、request line
2、header line
3、blank line
4、request body

面小易说：上面的三个问题是网络编程的基础知识问题，作为Java工程师也需要掌握HTTP的知识，而如今HTTPS同样也成为了标准，也需要大家进一步了解。此外，相对于大家在课本或者课堂中所学习的HTTP 1.0/1.1这些协议而言，很多公司已经迈入了HTTP 2.0时代，因此两者之间的差别也需要我们进一步了解。

八、Servlet的生命周期

大致分为4部：Servlet类加载–>实例化–>服务–>销毁

Tomcat中Servlet的时序图如下所示：

1、Web Client向Servlet容器(Tomcat)发出HTTP请求。
2、Servlet容器接收Client端的请求。
3、Servlet容器创建一个HttpRequest对象，将Client的请求信息封装到这个对象中。
4、Servlet创建一个HttpResponse对象。
5、Servlet调用HttpServlet对象的service方法，把HttpRequest对象和HttpResponse对象作为参数传递给HttpServlet对象中。
6、HttpServlet调用HttpRequest对象的方法，获取Http请求，并进行相应处理。
7、处理完成HttpServlet调用HttpResponse对象的方法，返回响应数据。
8、Servlet容器把HttpServlet的响应结果传回客户端。

其中的3个方法说明了Servlet的生命周期：
1、init()：负责初始化Servlet对象。
2、service()：负责响应客户端请求。
3、destroy()：当Servlet对象推出时，负责释放占用资源。

九、Statement与PreparedStatement的区别,什么是SQL注入，如何防止SQL注入？

1、PreparedStatement支持动态设置参数，Statement不支持。
2、PreparedStatement可避免如类似 单引号 的编码麻烦，Statement不可以。
3、PreparedStatement支持预编译，Statement不支持。
4、在SQL语句出错时PreparedStatement不易检查，而Statement则更便于查错。
5、PreparedStatement可防止SQL助于，更加安全，而Statement不行。

补充说明-什么是SQL注入以及应对策略： 通过SQL语句的拼接达到无参数查询数据库数据目的的方法。如将要执行的SQL语句为 select * from table where name = “+appName+”，利用appName参数值的输入，来生成恶意的SQL语句，如将[‘or’1’=‘1’] 传入可在数据库中执行。因此可以采用PrepareStatement来避免SQL注入，在服务器端接收参数数据后，进行验证，此时PrepareStatement会自动检测，而Statement不行，需要手工检测。

十、sendRedirect, foward区别

1、foward是服务器端控制页面转向，在客户端的浏览器地址中不会显示转向后的地址；sendRedirect则是完全的跳转，浏览器中会显示跳转的地址并重新发送请求链接。原理：forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后再将这些内容返回给浏览器，浏览器根本不知道服务器发送的这些内容是从哪来的，所以地址栏还是原来的地址。
2、redirect是服务器端根据逻辑，发送一个状态码，告诉浏览器重新去请求的那个地址，浏览器会用刚才的所有参数重新发送新的请求。

面小易说：以上的三个问题在之前网络相关的知识上更进一步，上升到了Java网络编程的相关知识，这部分意在考察面试者对于Java网络编程相关知识的掌握程度。

十一、谈谈Hibernate的理解，一级和二级缓存的作用，在项目中Hibernate都是怎么使用缓存的？

Hibernate是一个开发的对象关系映射框架（ORM）。它对JDBC进行了非常对象封装，Hibernate允许程序员采用面向对象的方式来操作关系数据库。

Hibernate的优点：
1、程序更加面向对象
2、提高了生产率
3、方便移植
4、无入侵性

Hibernate的缺点：
1、效率比JDBC略差
2、不适合批量操作
3、只能配置一种关联关系

Hibernate有四种查询方式：
1、get、load方法，根据ID号查询对象。
2、Hibernate Query Language, HQL
3、标准查询语言
4、通过SQL查询

Hibernate工作原理：
1、配置Hibernate对象关系映射文件、启动服务器
2、服务器通过实例化Configuration对象，读取hibernate.cfg.xml文件的配置内容，并根据相关的需求建好表以及表之间的映射关系。
3、通过实例化的Configuration对象建立SessionFactory实例，通过SessionFactory实例创建Session对象。
4、通过Session对象完成数据库的增删改查操作。

Hibernate中的状态转移：
临时状态（Transient）
1、不处于Session缓存中
2、数据库中没有对象记录

补充说明-Java是如何进入临时状态的：1、通过new语句创建一个对象时。2、刚调用Session的delete()方法时，从Session缓存中删除一个对象时。

持久化状态(Persisted)
1、处于Session缓存中
2、持久化对象数据库中没有对象记录
3、Session在特定的时刻会保存两者同步

补充说明-Java如何进入持久化状态：1、Session的save()方法。2、Session的load().get()方法返回的对象。3、Session的find()方法返回的list集合中存放的对象。4、Session的update().save()方法。

流离状态（Detached）
1、不再位于Session缓存中
2、游离对象由持久化状态转变而来，数据库中还没有相应记录。

补充说明-Java如何进入流离状态：1、Session的close()。2、 Session的evict()方法，从缓存中删除一个对象。

具体如下图所示：

Hibernate中的缓存主要有Session缓存（一级缓存）和SessionFactory缓存（二级缓存，一般由第三方提供）。

十二、谈谈Hibernate与iBatis的区别，哪个性能会更高一些

1、Hibernate偏向于对象的操作达到数据库相关操作的目的；而iBatis更偏向于SQL语句的优化。
2、Hibernate的使用的查询语句是自己的HQL，而iBatis则是标准的SQL语句。
3、Hibernate相对复杂，不易学习；iBatis类似SQL语句，简单易学。

性能方面：
1、如果系统数据处理量巨大，性能要求极为苛刻时，往往需要人工编写高性能的SQL语句或存错过程，此时iBatis具有更好的可控性，因此性能优于Hibernate。
2、同样的需求下，由于Hibernate可以自动生成HQL语句，而iBatis需要手动写SQL语句，此时采用Hibernate的效率高于iBatis。

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

Spring是一个开源框架，处于MVC模式中的控制层，它能应对需求快速的变化，其主要原因它有一种面向切面编程（AOP）的优势，其次它提升了系统性能，因为通过依赖倒置机制（IOC），系统中用到的对象不是在系统加载时就全部实例化，而是在调用到这个类时才会实例化该类的对象，从而提升了系统性能。这两个优秀的性能使得Spring受到许多J2EE公司的青睐，如阿里中使用最多的也是Spring相关技术。

Spring的优点：
1、降低了组件之间的耦合性，实现了软件各层之间的解耦。
2、可以使用容易提供的众多服务，如事务管理，消息服务，日志记录等。
3、容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。
Spring中AOP技术是设计模式中的动态代理模式。只需实现jdk提供的动态代理接口InvocationHandler，所有被代理对象的方法都由InvocationHandler接管实际的处理任务。面向切面编程中还要理解切入点、切面、通知、织入等概念。
Spring中IOC则利用了Java强大的反射机制来实现。所谓依赖注入即组件之间的依赖关系由容器在运行期决定。其中依赖注入的方法有两种，通过构造函数注入，通过set方法进行注入。

十四、描述Struts的工作流程

1、在web应用启动时，加载并初始化ActionServlet，ActionServlet从struts-config.xml文件中读取配置信息，将它们存放到各个配置对象中。
2、当ActionServlet接收到一个客户请求时，首先检索和用户请求相匹配的ActionMapping实例，如果不存在，就返回用户请求路径无效信息。
3、如果ActionForm实例不存在，就创建一个ActionForm对象，把客户提交的表单数据保存到ActionForm对象中。
4、根据配置信息决定是否需要验证表单，如果需要，就调用ActionForm的validate()方法，如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActionErrors对象，就表示表单验证成功。
5、ActionServlet根据ActionMapping实例包含的映射信息决定请求转发给哪个Action，如果相应的Action实例不存在，就先创建一个实例，然后调用Action的execute()方法。

面小易说：以上部分的相关问题考察面试者在实际软件开发中所使用的Java语言相关框架以及对于框架原理的了解程度，这一部分我们需要注意一些常见的框架，不仅需要知道它们是干什么的，还需要知道它们背后的原理，常会问到的框架有Spring Boot/Spring Cloud全家桶、Hibernate、MyBaits、Netty、Kafka等，最重要的还有阿里巴巴开源的Apache Dubbo框架。

十五、关于Java内存模型，一个对象（两个属性，四个方法）实例化100次，现在内存中的存储状态，几个对象，几个属性，几个方法。由于Java中new出来的对象都是放在堆中，所以如果要实例化100次，将在堆中产生100个对象，一般对象与其中的属性、方法都属于一个整体，但如果 属性和方法是静态的，就是用static关键字声明的，那么属于类的属性和方法永远只在内存中存在一份。

十六、反射讲一讲，主要是概念,都在哪需要反射机制，反射的性能，如何优化？

反射机制的定义：
是在运行状态中，对于任意的一个类，都能够知道这个类的所有属性和方法，对任意一个对象都能够通过反射机制调用一个类的任意方法，这种动态获取类信息及动态调用类对象方法的功能称为java的反射机制。

反射的作用：
1、动态地创建类的实例，将类绑定到现有的对象中，或从现有的对象中获取类型。
2、应用程序需要在运行时从某个特定的程序集中载入一个特定的类。

十七、线程同步，并发操作怎么控制？

Java中可在方法名前加关键字syschronized来处理当有多个线程同时访问共享资源时候的问题。syschronized相当于一把锁，当有申请者申请该资源时，如果该资源没有被占用，那么将资源交付给这个申请者使用，在此期间，其他申请者只能申请而不能使用该资源，当该资源被使用完成后将释放该资源上的锁，其他申请者可申请使用。并发控制主要是为了多线程操作时带来的资源读写问题。如果不加以空间可能会出现死锁，读脏数据、不可重复读、丢失更新等异常。

并发操作可以通过加锁的方式进行控制，锁又可分为乐观锁和悲观锁。

悲观锁：
悲观锁并发模式假定系统中存在足够多的数据修改操作，以致于任何确定的读操作都可能会受到由个别的用户所制造的数据修改的影响。也就是说悲观锁假定冲突总会发生，通过独占正在被读取的数据来避免冲突。但是独占数据会导致其他进程无法修改该数据，进而产生阻塞，读数据和写数据会相互阻塞。

乐观锁：
乐观锁假定系统的数据修改只会产生非常少的冲突，也就是说任何进程都不大可能修改别的进程正在访问的数据。乐观并发模式下，读数据和写数据之间不会发生冲突，只有写数据与写数据之间会发生冲突。即读数据不会产生阻塞，只有写数据才会产生阻塞。

十八、Java集合框架是什么？说出集合框架的优点？

每种编程语言中都有集合，最初的Java版本包含几种集合类：Vector、Stack、HashTable和Array。

Java1.2提出了囊括所有集合接口、实现和算法的集合框架。在保证线程安全的情况下使用泛型和并发集合类，Java已经经历了很久。它还包括在Java并发包中，阻塞接口以及它们的实现。

集合框架的部分优点如下：

使用核心集合类降低开发成本，而非实现我们自己的集合类。
随着使用经过严格测试的集合框架类，代码质量会得到提高。
通过使用JDK附带的集合类，可以降低代码维护成本。
复用性和可操作性。

十九、集合框架中的泛型有什么优点？

Java1.5引入了泛型，所有的集合接口和实现都大量地使用它。

泛型允许我们为集合提供一个可以容纳的对象类型，因此，如果你添加其它类型的任何元素，它会在编译时报错。

这避免了在运行时出现ClassCastException，因为你将会在编译时得到报错信息。

泛型也使得代码整洁，我们不需要使用显式转换和instanceOf操作符。

它也给运行时带来好处，因为不会产生类型检查的字节码指令。

二十、Java集合框架的基础接口有哪些？

Collection为集合层级的根接口。一个集合代表一组对象，这些对象即为它的元素。Java平台不提供这个接口任何直接的实现。

Set是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模，被用来代表集合，就如一副牌。

List是一个有序集合，可以包含重复元素。你可以通过它的索引来访问任何元素。List更像长度动态变换的数组。

Map是一个将key映射到value的对象.一个Map不能包含重复的key：每个key最多只能映射一个value。

一些其它的接口有Queue、Dequeue、SortedSet、SortedMap和ListIterator。

二十一、为何Collection不从Cloneable和Serializable接口继承？

Collection接口指定一组对象，对象即为它的元素。如何维护这些元素由Collection的具体实现决定。例如，一些如List的Collection实现允许重复的元素，而其它的如Set就不允许。

很多Collection实现有一个公有的clone方法。然而，把它放到集合的所有实现中也是没有意义的。这是因为Collection是一个抽象表现。重要的是实现。

当与具体实现打交道的时候，克隆或序列化的语义和含义才发挥作用。所以，具体实现应该决定如何对它进行克隆或序列化，或它是否可以被克隆或序列化。点击这里一文学会序列化。

在所有的实现中授权克隆和序列化，最终导致更少的灵活性和更多的限制。特定的实现应该决定它是否可以被克隆和序列化。点击这里一文学会序列化。

二十二、为何Map接口不继承Collection接口？

尽管Map接口和它的实现也是集合框架的一部分，但Map不是集合，集合也不是Map。因此，Map继承Collection毫无意义，反之亦然。

如果Map继承Collection接口，那么元素去哪儿？Map包含key-value对，它提供抽取key或value列表集合的方法，但是它不适合“一组对象”规范。

二十三、Iterator是什么？

Iterator接口提供遍历任何Collection的接口。我们可以从一个Collection中使用迭代器方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者在迭代过程中移除元素。

二十四、Enumeration和Iterator接口的区别？

Enumeration的速度是Iterator的两倍，也使用更少的内存。Enumeration是非常基础的，也满足了基础的需要。但是，与Enumeration相比，Iterator更加安全，因为当一个集合正在被遍历的时候，它会阻止其它线程去修改集合。

迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者从集合中移除元素，而Enumeration不能做到。为了使它的功能更加清晰，迭代器方法名已经经过改善。

二十五、为何没有像Iterator.add()这样的方法，向集合中添加元素？

语义不明，已知的是，Iterator的协议不能确保迭代的次序。然而要注意，ListIterator没有提供一个add操作，它要确保迭代的顺序。

二十六、为何迭代器没有一个方法可以直接获取下一个元素，而不需要移动游标？

它可以在当前Iterator的顶层实现，但是它用得很少，如果将它加到接口中，每个继承都要去实现它，这没有意义。

二十七、Iterater和ListIterator之间有什么区别？

（1）我们可以使用Iterator来遍历Set和List集合，而ListIterator只能遍历List。

（2）Iterator只可以向前遍历，而LIstIterator可以双向遍历。

（3）ListIterator从Iterator接口继承，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。

二十八、通过迭代器fail-fast属性，你明白了什么？

每次我们尝试获取下一个元素的时候，Iterator fail-fast属性检查当前集合结构里的任何改动。如果发现任何改动，它抛出ConcurrentModificationException。Collection中所有Iterator的实现都是按fail-fast来设计的（ConcurrentHashMap和CopyOnWriteArrayList这类并发集合类除外）。

二十九、fail-fast与fail-safe有什么区别？

Iterator的fail-fast属性与当前的集合共同起作用，因此它不会受到集合中任何改动的影响。Java.util包中的所有集合类都被设计为fail-fast的，

而java.util.concurrent中的集合类都为fail-safe的。

Fall—fast迭代器抛出ConcurrentModificationException，

fall—safe迭代器从不抛出ConcurrentModificationException。

三十、在迭代一个集合的时候，如何避免？

ConcurrentModificationException？

在遍历一个集合的时候我们可以使用并发集合类来避免ConcurrentModificationException，比如使用CopyOnWriteArrayList，而不是ArrayList。

三十一、为何Iterator接口没有具体的实现？

Iterator接口定义了遍历集合的方法，但它的实现则是集合实现类的责任。每个能够返回用于遍历的Iterator的集合类都有它自己的Iterator实现内部类。

这就允许集合类去选择迭代器是fail-fast还是fail-safe的。比如，ArrayList迭代器是fail-fast的，而CopyOnWriteArrayList迭代器是fail-safe的。

三十二、UnsupportedOperationException是什么？

UnsupportedOperationException是用于表明操作不支持的异常。在JDK类中已被大量运用，在集合框架java.util.Collections.UnmodifiableCollection将会在所有add和remove操作中抛出这个异常。

三十三、hashCode()和equals()方法有何重要性？

HashMap使用Key对象的hashCode()和equals()方法去决定key-value对的索引。点击这里一文搞懂它们之间的关系。

当我们试着从HashMap中获取值的时候，这些方法也会被用到。如果这些方法没有被正确地实现，在这种情况下，两个不同Key也许会产生相同的hashCode()和equals()输出，HashMap将会认为它们是相同的，然后覆盖它们，而非把它们存储到不同的地方。

同样的，所有不允许存储重复数据的集合类都使用hashCode()和equals()去查找重复，所以正确实现它们非常重要。equals()和hashCode()的实现应该遵循以下规则：

如果o1.equals(o2)，那么o1.hashCode() == o2.hashCode()总是为true的。

如果o1.hashCode() == o2.hashCode()，并不意味着o1.equals(o2)会为true。

三十四、Map接口提供了哪些不同的集合视图？

Map接口提供三个集合视图：

（1）Set keyset()：返回map中包含的所有key的一个Set视图。集合是受map支持的，map的变化会在集合中反映出来，反之亦然。当一个迭代器正在遍历一个集合时，若map被修改了（除迭代器自身的移除操作以外），迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。

它不支持add和addAll操作。

2）Collection values()：返回一个map中包含的所有value的一个Collection视图。这个collection受map支持的，map的变化会在collection中反映出来，反之亦然。当一个迭代器正在遍历一个collection时，若map被修改了（除迭代器自身的移除操作以外），迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。

3）Set<Map.Entry<K,V>> entrySet()：返回一个map钟包含的所有映射的一个集合视图。这个集合受map支持的，map的变化会在collection中反映出来，反之亦然。当一个迭代器正在遍历一个集合时，若map被修改了（除迭代器自身的移除操作，以及对迭代器返回的entry进行setValue外），迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。

三十五、HashMap和HashTable有何不同？

（1）HashMap允许key和value为null，而HashTable不允许。

（2）HashTable是同步的，而HashMap不是。所以HashMap适合单线程环境，HashTable适合多线程环境。

（3）在Java1.4中引入了LinkedHashMap，HashMap的一个子类，假如你想要遍历顺序，你很容易从HashMap转向LinkedHashMap，但是HashTable不是这样的，它的顺序是不可预知的。

（4）HashMap提供对key的Set进行遍历，因此它是fail-fast的，但HashTable提供对key的Enumeration进行遍历，它不支持fail-fast。

（5）HashTable被认为是个遗留的类，如果你寻求在迭代的时候修改Map，你应该使用CocurrentHashMap。

三十六、如何决定选用HashMap还是TreeMap？

对于在Map中插入、删除和定位元素这类操作，HashMap是最好的选择。然而，假如你需要对一个有序的key集合进行遍历，TreeMap是更好的选择。基于你的collection的大小，也许向HashMap中添加元素会更快，将map换为TreeMap进行有序key的遍历。

三十七、ArrayList和Vector有何异同点？

ArrayList和Vector在很多时候都很类似。

（1）两者都是基于索引的，内部由一个数组支持。

（2）两者维护插入的顺序，我们可以根据插入顺序来获取元素。

（3）ArrayList和Vector的迭代器实现都是fail-fast的。

（4）ArrayList和Vector两者允许null值，也可以使用索引值对元素进行随机访问。

以下是ArrayList和Vector的不同点。

（1）Vector是同步的，而ArrayList不是。然而，如果你寻求在迭代的时候对列表进行改变，你应该使用CopyOnWriteArrayList。

（2）ArrayList比Vector快，它因为有同步，不会过载。

（3）ArrayList更加通用，因为我们可以使用Collections工具类轻易地获取同步列表和只读列表。

三十八、Array和ArrayList有何区别？什么时候更适合用Array？

Array可以容纳基本类型和对象，而ArrayList只能容纳对象。

Array是指定大小的，而ArrayList大小是固定的。

Array没有提供ArrayList那么多功能，比如addAll、removeAll和iterator等。尽管ArrayList明显是更好的选择，但也有些时候Array比较好用。

（1）如果列表的大小已经指定，大部分情况下是存储和遍历它们。

（2）对于遍历基本数据类型，尽管Collections使用自动装箱来减轻编码任务，在指定大小的基本类型的列表上工作也会变得很慢。

（3）如果你要使用多维数组，使用[][]比List<List<>>更容易。

22.ArrayList和LinkedList有何区别？
ArrayList和LinkedList两者都实现了List接口，但是它们之间有些不同。

（1）ArrayList是由Array所支持的基于一个索引的数据结构，所以它提供对元素的随机访问，复杂度为O(1)，但LinkedList存储一系列的节点数据，每个节点都与前一个和下一个节点相连接。所以，尽管有使用索引获取元素的方法，内部实现是从起始点开始遍历，遍历到索引的节点然后返回元素，时间复杂度为O(n)，比ArrayList要慢。

（2）与ArrayList相比，在LinkedList中插入、添加和删除一个元素会更快，因为在一个元素被插入到中间的时候，不会涉及改变数组的大小，或更新索引。

（3）LinkedList比ArrayList消耗更多的内存，因为LinkedList中的每个节点存储了前后节点的引用。

三十九、哪些集合类提供对元素的随机访问？

ArrayList、HashMap、TreeMap和HashTable类提供对元素的随机访问。

四十、哪些集合类是线程安全的？

Vector、HashTable、Properties和Stack是同步类，所以它们是线程安全的，可以在多线程环境下使用。Java1.5并发API包括一些集合类，允许迭代时修改，因为它们都工作在集合的克隆上，所以它们在多线程环境中是安全的。点击这里一文搞懂问什么线程不安全。

四十一、并发集合类是什么？

Java1.5并发包（java.util.concurrent）包含线程安全集合类，允许在迭代时修改集合。迭代器被设计为fail-fast的，会抛出ConcurrentModificationException。一部分类为：CopyOnWriteArrayList、 ConcurrentHashMap、CopyOnWriteArraySet。

四十二、队列和栈是什么，列出它们的区别？

栈和队列两者都被用来预存储数据。java.util.Queue是一个接口，它的实现类在Java并发包中。队列允许先进先出（FIFO）检索元素，但并非总是这样。Deque接口允许从两端检索元素。栈与队列很相似，但它允许对元素进行后进先出（LIFO）进行检索。Stack是一个扩展自Vector的类，而Queue是一个接口。

四十三、Collections类是什么？

Java.util.Collections是一个工具类仅包含静态方法，它们操作或返回集合。

它包含操作集合的多态算法，返回一个由指定集合支持的新集合和其它一些内容。这个类包含集合框架算法的方法，比如折半搜索、排序、混编和逆序等。

四十四、Comparable和Comparator接口有何区别？

Comparable和Comparator接口被用来对对象集合或者数组进行排序。Comparable接口被用来提供对象的自然排序，我们可以使用它来提供基于单个逻辑的排序。

Comparator接口被用来提供不同的排序算法，我们可以选择需要使用的Comparator来对给定的对象集合进行排序。

四十五、我们如何对一组对象进行排序？

如果我们需要对一个对象数组进行排序，我们可以使用Arrays.sort()方法。如果我们需要排序一个对象列表，我们可以使用Collection.sort()方法。

两个类都有用于自然排序（使用Comparable）或基于标准的排序（使用Comparator）的重载方法sort()。Collections内部使用数组排序方法，所有它们两者都有相同的性能，只是Collections需要花时间将列表转换为数组。

四十六、当一个集合被作为参数传递给一个函数时，如何才可以确保函数不能修改它？

在作为参数传递之前，我们可以使用Collections.unmodifiableCollection(Collection c)方法创建一个只读集合，这将确保改变集合的任何操作都会抛出UnsupportedOperationException。

四十七、请说出 Java 14 版本中更新的重要功能

Java 14 发布于 2020 年 3 月 17 日，更新的重要功能有：

  • switch 表达式

  • instanceof 增强表达式，预览功能

  • 文本块，第二次预览

  • Records，预览功能

刚好我之前写过一篇文章，关于 Java 14 的开箱体验，很香，读者朋友需要的话，可以点下面的链接看一看。

Java 14 开箱，它真香香香香

四十八、请说出 Java 13 版本中更新的重要功能

Java 13 发布于 2019 年 9 月 17 日，更新的重要功能有：

  • 文本块，预览功能

  • switch 表达式，预览功能

  • Java Socket 重新实现

  • FileSystems.newFileSystem() 方法

  • 支持 Unicode 12.1

  • 可伸缩、低延迟的垃圾收集器改进，用于返回未使用的内存

四十九、请说出 Java 12 版本中更新的重要功能

Java 12 发布于 2019 年 3 月 19 日，更新的重要功能有：

  • JVM 更新

  • File.mismatch() 方法

  • 紧凑型数字格式

  • String 类新增了一些方法，比如说 indent()

五十、请说出 Java 11 版本中更新的重要功能

Java 11 是继 Java 8 之后的第二个商用版本，如果你下载的是 Oracle JDK，则需要进行付费；如果想继续使用免费版本，需要下载 Open JDK。

Oracle JDK 中会有一些 Open JDK 没有的、商用闭源的功能。

Java 11 更新的重要功能有：

  • 可以直接使用 java 命令运行 Java 程序，源代码将会隐式编译和运行。

  • String 类新增了一些方法，比如说 isBlank()、lines()、strip() 等等。

  • Files 类新增了两个读写方法，readString() 和 writeString()。

  • 可以在 Lambda 表达式中使用 var 作为变量类型。

五十一、请说出 Java 10 版本中更新的重要功能

Java 10 更新的重要功能有：

  • 局部变量类型推断，举个例子，var list = new ArrayList<string style="margin: 0px; padding: 0px; max-width: 100%; box-sizing: border-box !important; word-wrap: break-word !important; font-size: inherit; color: inherit; line-height: inherit; overflow-wrap: break-word !important;">();</string>，可以使用 var 来作为变量类型，Java 编译器知道 list 的类型为字符串的 ArrayList。

  • 增强 java.util.Locale。

  • 提供了一组默认的根证书颁发机构（CA）。

五十二、请说出 Java 9 版本中更新的重要功能

Java 9 更新的重要功能有：

  • 模块系统

  • 不可变的 List、Set、Map 的工厂方法

  • 接口中可以有私有方法

  • 垃圾收集器改进

五十三、请说出 Java 8 版本中更新的重要功能

Java 8 发布于 2014 年 3 月份，可以说是 Java 6 之后最重要的版本更新，深受开发者的喜爱。

我强烈建议点开上面的链接阅读以下，以正确理解这些概念。

五十四、请说出 Java 面向对象编程中的一些重要概念

五十五、Java 声称的平***立性指的是什么？

常见的操作系统有 Windows、Linux、OS-X，那么平***立性意味着我们可以在任何操作系统中运行相同源代码的 Java 程序，比如说我们可以在 Windows 上编写 Java 程序，然后在 Linux 上运行它。

五十六、什么是 JVM？

JVM（Java Virtual Machine）俗称 Java 虚拟机。之所以称为虚拟机，是因为它实际上并不存在。它提供了一种运行环境，可供 Java 字节码在上面运行。

JVM 提供了以下操作：

  • 加载字节码

  • 验证字节码

  • 执行字节码

  • 提供运行时环境

JVM 定义了以下内容：

  • 存储区

  • 类文件格式

  • 寄存器组

  • 垃圾回收堆

  • 致命错误报告等

我们来尝试理解一下 JVM 的内部结构，它包含了类加载器（Class Loader）、运行时数据区（Runtime Data Areas）和执行引擎（Excution Engine）。

1）类加载器

类加载器是 JVM 的一个子系统，用于加载类文件。每当我们运行一个 Java 程序，它都会由类加载器首先加载。Java 中有三个内置的类加载器：

  • 启动类加载器（Bootstrap Class-Loader），加载 jre/lib 包下面的 jar 文件，比如说常见的 rt.jar（包含了 Java 标准库下的所有类文件，比如说 java.lang 包下的类，java.net 包下的类，java.util 包下的类，java.io 包下的类，java.sql 包下的类）。

  • 扩展类加载器（Extension or Ext Class-Loader），加载 jre/lib/ext 包下面的 jar 文件。

  • 应用类加载器（Application or App Clas-Loader），根据程序的类路径（classpath）来加载 Java 类。

一般来说，Java 程序员并不需要直接同类加载器进行交互。JVM 默认的行为就已经足够满足大多数情况的需求了。不过，如果遇到了需要和类加载器进行交互的情况，而对类加载器的机制又不是很了解的话，就不得不花大量的时间去调试
ClassNotFoundException 和 NoClassDefFoundError 等异常。

对于任意一个类，都需要由它的类加载器和这个类本身一同确定其在 JVM 中的唯一性。也就是说，如果两个类的加载器不同，即使两个类来源于同一个字节码文件，那这两个类就必定不相等（比如两个类的 Class 对象不 equals）。

是不是有点晕，来来来，通过一段简单的代码了解下。

public class Test {    public static void main(String[] args) {        ClassLoader loader = Test.class.getClassLoader();        while (loader != null) {            System.out.println(loader.toString());            loader = loader.getParent();        }    }}

每个 Java 类都维护着一个指向定义它的类加载器的引用，通过 类名.class.getClassLoader() 可以获取到此引用；然后通过 loader.getParent() 可以获取类加载器的上层类加载器。

上面这段代码的输出结果如下：

sun.misc.Launcher$AppClassLoader@18b4aac2sun.misc.Launcher$ExtClassLoader@4617c264

第一行输出为 Test 的类加载器，即应用类加载器，它是 sun.misc.Launcher$AppClassLoader 类的实例；第二行输出为扩展类加载器，是 sun.misc.Launcher$ExtClassLoader 类的实例。那启动类加载器呢？

按理说，扩展类加载器的上层类加载器是启动类加载器，但在我这个版本的 JDK 中， 扩展类加载器的 getParent() 返回 null。所以没有输出。

2）运行时数据区

运行时数据区又包含以下内容。

  • PC寄存器（PC Register），也叫程序计数器（Program Counter Register），是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的信号指示器。

  • JVM 栈（Java Virtual Machine Stack），与 PC 寄存器一样，JVM 栈也是线程私有的。每一个 JVM 线程都有自己的 JVM 栈，这个栈与线程同时创建，它的生命周期与线程相同。

  • 本地方法栈（Native Method Stack），JVM 可能会使用到传统的栈来支持 Native 方法（使用 Java 语言以外的其它语言［C语言］编写的方法）的执行，这个栈就是本地方法栈。

  • 堆（Heap），在 JVM 中，堆是可供各条线程共享的运行时内存区域，也是供所有类实例和数据对象分配内存的区域。

  • 方法区（Method area），在 JVM 中，被加载类型的信息都保存在方法区中。包括类型信息（Type Information）和方法列表（Method Tables）。方法区是所有线程共享的，所以访问方法区信息的方法必须是线程安全的。

  • 运行时常量池（Runtime Constant Pool），运行时常量池是每一个类或接口的常量池在运行时的表现形式，它包括了编译器可知的数值字面量，以及运行期解析后才能获得的方法或字段的引用。简而言之，当一个方法或者变量被引用时，JVM 通过运行时常量区来查找方法或者变量在内存里的实际地址。

3）执行引擎

执行引擎包含了：

  • 解释器：读取字节码流，然后执行指令。因为它一条一条地解释和执行指令，所以它可以很快地解释字节码，但是执行起来会比较慢。

  • 即时（Just-In-Time，JIT）编译器：即时编译器用来弥补解释器的缺点，提高性能。执行引擎首先按照解释执行的方式来执行，然后在合适的时候，即时编译器把整段字节码编译成本地代码。然后，执行引擎就没有必要再去解释执行方法了，它可以直接通过本地代码去执行。执行本地代码比一条一条进行解释执行的速度快很多。编译后的代码可以执行的很快，因为本地代码是保存在缓存里的。

五十七、JDK 和 JVM 有什么区别？

JDK 是 Java Development Kit 的首字母缩写，是提供给 Java 开发人员的软件环境，包含 JRE 和一组开发工具。可分为以下版本：

  • 标准版（大多数开发人员用的就是这个）

  • 企业版

  • 微型版

JDK 包含了一个私有的 JVM 和一些其他资源，比如说编译器（javac 命令）、解释器（java 命令）等，帮助 Java 程序员完成开发工作。

五十八、JVM 和 JRE 有什么区别？

Java Runtime Environment（JRE）是 JVM 的实现。JRE 由 JVM 和 Java 二进制文件以及其他类组成，可以执行任何程序。JRE 不包含 Java 编译器，调试器等任何开发工具。

五十九、哪个类是所有类的超类？

java.lang.Object 是所有 Java 类的超类，我们不需要继承它，因为是隐式继承的。

六十、为什么 Java 不支持多重继承？

如果有两个类共同继承（extends）一个有特定方法的父类，那么该方***被两个子类重写。然后，如果你决定同时继承这两个子类，那么在你调用该重写方法时，编译器不能识别你要调用哪个子类的方法。这也正是著名的菱形问题，见下图。

ClassC 同时继承了 ClassA 和 ClassB，ClassC 的对象在调用 ClassA 和 ClassB 中重载的方法时，就不知道该调用 ClassA 的方法，还是 ClassB 的方法。

六十一、为什么 Java 不是纯粹的面向对象编程语言？

之所以不能说 Java 是纯粹的面向对象编程语言，是因为 Java 支持基本数据类型，比如说 int、short、long、double 等，尽管它们有自己的包装器类型，但它们的确不能算是对象。

六十二、path 和 classpath 之间有什么区别？

path 是操作系统用来查找可执行文件的环境变量，我的电脑上就定义了下图这些 path 变量，比如 Java 和 Maven 的。

classpath 是针对 Java 而言的，用于指定 Java 虚拟机载入的字节码文件路径。

六十三、Java 中 main() 方法的重要性是什么？

每个程序都需要一个入口，对于 Java 程序来说，入口就是 main 方法。

public static void main(String[] args) {}

  • public 关键字是另外一个访问修饰符，除了可以声明方法和变量（所有类可见），还可以声明类。main() 方法必须声明为 public。

  • static 关键字表示该变量或方法是静态变量或静态方法，可以直接通过类访问，不需要实例化对象来访问。

  • void 关键字用于指定方法没有返回值。

另外，main 关键字为方法的名字，Java 虚拟机在执行程序时会寻找这个标识符；args 为 main() 方法的参数名，它的类型为一个 String 数组，也就是说，在使用 java 命令执行程序的时候，可以给 main() 方法传递字符串数组作为参数。

java HelloWorld

javac 命令用来编译程序，java 命令用来执行程序，HelloWorld 为这段程序的类名，为字符串数组，中间通过空格隔开，然后就可以在 main()方法中通过 args[0] 和 args[1] 获取传递的参数值了。

public class HelloWorld {    public static void main(String[] args) {        if ("沉默王二".equals(args[0])) {        }        if (equals(args[1])) {        }    }}

main() 方法的写法并不是唯一的，还有其他几种变体，尽管它们可能并不常见，可以简单来了解一下。

第二种，把方括号 [] 往 args 靠近而不是 String 靠近：

public static void main(String []args) { }

第三种，把方括号 [] 放在 args 的右侧：

public static void main(String args[]) { }

第四种，还可以把数组形式换成可变参数的形式：

public static void main(String...args) { }

第五种，在 main() 方法上添加另外一个修饰符 strictfp，用于强调在处理浮点数时的兼容性：

public strictfp static void main(String[] args) { }

也可以在 main() 方法上添加 final 关键字或者 synchronized 关键字。

第六种，还可以为 args 参数添加 final 关键字：

public static void main(final String[] args) { }

第七种，最复杂的一种，所有可以添加的关键字统统添加上：

final static synchronized strictfp void main(final String[] args) { }

当然了，并不需要为了装逼特意把 main() 方法写成上面提到的这些形式，使用 IDE 提供的默认形式就可以了。

19、main() 方法可以重载吗？

可以，一个类中可以有多个名称为“main”的方法：

public class MainTest {    public static void main(String[] args) {        System.out.println("main(String[] args)");    }    public static void main(String[] args,String arg) {        System.out.println("(String[] args,String arg");    }}

但该类在运行的时候，只会找到一个入口，即 public static void main(String[] args)。

20、一个 Java 源文件中有多个 public 类吗？

一个 Java 源文件中不能有多个 public 类。

21、什么是 Java 的 package（包）？

在 Java 中，我们使用 package（包）对相关的类、接口和子包进行分组。这样做的好处有：

  • 使相关类型更容易查找

  • 避免命名冲突，比如说 com.itwanger.Hello 和 com.itwangsan.Hello 不同

  • 通过包和访问权限控制符来限定类的可见性

可以使用 package 关键字来定义一个包名，需要注意的是，这行代码必须处于一个类中的第一行。强烈建议在包中声明类，不要缺省，否则就失去了包结构的带来的好处。

包的命名应该遵守以下规则：

  • 应该全部是小写字母

  • 可以包含多个单词，单词之间使用“.”连接，比如说 java.lang

  • 名称由公司名或者组织名确定，采用倒序的方式，比如说，我个人博客的域名是 www.itwanger.com，所以我创建的包名是就是 com.itwanger.xxxx。

每个包或者子包都在磁盘上有自己的目录结构，如果 Java 文件时在 com.itwanger.xxxx 包下，那么该文件所在的目录结构就应该是 com->itwanger->xxxx。

默认情况下，java.lang 包是默认导入的，我们不需要显式地导入该包下的任何类。

package com.cmower.bb;public class PackageTest {    public static void main(String[] args) {        Boolean.toString(true);    }}

Boolean 类属于 java.lang 包，当使用它的时候并不需要显式导入。

22、什么是访问权限修饰符？

访问权限修饰符对于 Java 来说，非常重要，目前共有四种：public、private、protected 和 default（缺省）。

一个类只能使用 public 或者 default 修饰，public 修饰的类你之前已经见到过了，现在我来定义一个缺省权限修饰符的类给你欣赏一下。

class Dog {}

哈哈，其实也没啥可以欣赏的。缺省意味着这个类可以被同一个包下的其他类进行访问；而 public 意味着这个类可以被所有包下的类进行访问。

假如硬要通过 private 和 protected 来修饰类的话，编译器会生气的，它不同意。

private 可以用来修饰类的构造方法、字段和方法，只能被当前类进行访问。protected 也可以用来修饰类的构造方法、字段和方法，但它的权限范围更宽一些，可以被同一个包中的类进行访问，或者当前类的子类。

可以通过下面这张图来对比一下四个权限修饰符之间的差别：

  • 同一个类中，不管是哪种权限修饰符，都可以访问；

  • 同一个包下，private 修饰的无法访问；

  • 子类可以访问 public 和 protected 修饰的；

  • public 修饰符面向世界，哈哈，可以被所有的地方访问到。

23、什么是 final 关键字？

final 关键字修饰类的时候，表示该类无法被继承。比如，String 类就是 final 的，无法被继承。

final 关键字修饰方法的时候，表示子类无法覆盖它。

final 关键字修饰变量的时候，表示该变量只能被赋值一次，尽管变量的状态可以更改。

关于 final 更详细的内容，可以参照我之前写了另外一篇文章：

我去，你竟然还不会用 final 关键字

24、什么是 static 关键字？

static 关键字可以用来修饰类变量，使其具有全局性，即所有对象将共享同一个变量。

static 关键字可以用来修饰方法，该方法称为静态方法，只可以访问类的静态变量，并且只能调用类的静态方法。

关于 static 更详细的内容，可以参照我之前写了另外一篇文章：

面试官：兄弟，说说Java的static关键字吧

25、finally 和 finalize 有什么区别？

finally 通常与 try-catch 块一起使用，即使 try-catch 块引发了异常，finally 块中的代码也会被执行，用于释放 try 块中创建的资源。

finalize() 是 Object 类的一个特殊方法，当对象正在被垃圾回收时，垃圾收集器将会调用该方法。可以重写该方法用于释放系统资源。

26、可以将一个类声明为 static 的吗？

不能将一个外部类声明为 static 的，但可以将一个内部类声明为 static 的——称为静态内部类。

27、什么是静态导入？

如果必须在一个类中使用其他类的静态变量或者静态方法，通常我们需要先导入该类，然后使用“类名.变量/方法”的形式调用。

import java.lang.Math;double test = Math.PI * 5;

也可以通过静态导入的方式，就不需要再使用类名了。

import static java.lang.Math.PI;double test = PI * 5;

不过，静态导入容易引发混乱（变量名或者方法名容易冲突），因此最好避免使用静态导入。

28、什么是 try-with-resources？

try-with-resources 是 Java 7 时引入的一个自动资源管理语句，在此之前，我们必须通过 try-catch-finally 的方式手动关闭资源，当我们忘记关闭资源的时候，就容易导致内存泄漏。

关于 try-with-resources 更详细的内容，可以参照我之前写了另外一篇文章：

我去，你竟然还在用 try–catch-finally

29、什么是 multi-catch？

Java 7 改进的另外一个地方就是 multi-catch，可以在单个 catch 中捕获多个异常，当一个 try 块抛出多个类似的异常时，这种写法更短，更清晰。

catch(IOException | SQLException ex){     logger.error(ex);     throw new MyException(ex.getMessage());}

当有多个异常的时候，可以使用管道表示符“|”隔开。

30、什么是 static 块？

static 块是由 Java ClassLoader 将类加载到内存中时执行的代码块。通常用于初始化类的静态变量或者创建静态资源。

31、什么是接口？

接口是 Java 编程语言中的一个核心概念，不仅在 JDK 源码中使用很多，还在 Java 设计模式、框架和工具中使用很多。接口提供了一种在 Java 中实现抽象的方法，用于定义子类的行为约定。

关于接口更详细的内容，可以参照我之前写了另外一篇文章：

可能是把 Java 接口讲得最通俗的一篇文章

能不能吊打面试官，二哥不敢信誓旦旦，但在面试官面前摆出一副趾高气扬的底气，我想是没有问题的。前后各 31 道，合起来就是 62 道，一共两万多字，读起来需要点时间。考虑到小伙伴们消化掉需要花费一些时间，我特意整理了一份 PDF，在「沉默王二」后台回复「面试」就可以获取了，下载到本地啥时候读都可以，离线版，还能省点流量，对吧？

32、什么是抽象类？

在 Java 中，抽象类用于创建具有某些被子类实现的默认方法的类，一个抽象类可以有没有方法体的抽象方法，也可以有和普通类一样有方法体的方法。

abstract 关键字用于声明一个抽象类，抽象类无法实例化，主要用于为子类提供一个模板，子类需要覆盖抽象方法。

关于抽象类更详细的内容，可以参照我之前写了另外一篇文章：

小白，你要的Java抽象类，操碎了心

33、抽象类和接口有什么区别？

  • 声明抽象类的关键字为 abstract，声明接口的关键字为 interface。

  • 抽象类可以有具体的方法，接口不能。

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

  • 接口中的变量只能是隐式的常量，抽象类中可以有任意类型的变量。

  • 如果一个抽象类有 main() 方法，则可以运行它；但接口不能。

  • 抽象类是对类的一种抽象，继承抽象类的类和抽象类本身是一种 is-a 的关系。

  • 接口是对类的某种行为的一种抽象，接口和类之间并没有很强的关联关系，所有的类都可以实现 Serializable 接口，从而具有序列化的功能。

34、一个接口可以实现或者继承另外一个接口吗？

接口不能实现另外一个接口，但可以继承一个接口。

因为接口中不能有具体的方法，所以不会出现菱形问题，所以我们可以在一个接口中继承多个接口。

public interface C extends A,B{}

从 Java 8 开始，接口可以有默认方法，所以当多个接口中存在相同的默认方法时，需要在实现接口的类中提供该方法的实现。

35、什么是标记接口？

标记接口是一个空的接口，没有任何方法，用于强制实现类中的某些功能。比较出名的标记接口有 Serializable 接口、Cloneable 接口。

关于 Serializable 接口更详细的内容，可以参照我之前写了另外一篇文章：

Java Serializable：明明就一个空的接口嘛

36、什么是包装器类？

包装器类是 Java 中八种基本数据类型的对象表示形式，所有的包装器类都是不可变的，并且是 final 的。通过装箱和拆箱，可以将八种基本数据类型和包装器类型互相转换。

关于基本类型和包装类型更详细的内容，可以参照我之前写了另外一篇文章：

面试官：兄弟，说说基本类型和包装类型的区别吧

37、什么是枚举？

enum（枚举）是 Java 1.5 时引入的关键字，它表示一种特殊类型的类，默认继承自 java.lang.Enum。

public enum PlayerType {    TENNIS,    FOOTBALL,    BASKETBALL}

enum 是用于创建枚举的关键字，枚举中的常量都是隐式 static 和 final 的。

关于枚举更详细的内容，可以参照我之前写了另外一篇文章：

恕我直言，我怀疑你并不会用 Java 枚举

38、什么是 Java 注解？

注解是 Java 1.5 时引入的，同 class 和 interface 一样，也属于一种类型，注解提供了一系列数据用来装饰程序代码（类、方法、字段等），但是注解并不是所装饰代码的一部分，它对代码的运行效果没有直接影响（这句话怎么理解呢？），由编译器决定该执行哪些操作。

关于注解更详细的内容，可以参照我之前写了另外一篇文章：

不吹牛逼，撸个注解有什么难的

39、什么是 Java 反射？

Java 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有字段和方法；对于任意一个对象，都能够调用它的任意字段和方法；这种动态获取信息以及动态调用对象方法的功能称为 Java 反射机制。

反射属于高级主题，在常规编程中应该避免使用，因为反射可以通过调用私有的构造方法来破坏设计模式，比如说单例模式。

尽管不建议使用反射机制，但反射机制的存在至关重要，因为如果没有反射，我们将没有 Spring 之类的框架，甚至 Tomcat 之类的服务器。它们通过反射调用适当的方法并对类实例化，省去了很多麻烦。

40、Java 中的组合指的什么？

通过对象组合可以实现代码的重用，Java 组合是通过引用其他对象的引用来实现的，使用组合的好处就是我们可以控制其他对象对使用者的可见性，并且刻意重用我们需要的对象。

41、与继承相比，组合有什么好处？

  • 任何父类的修改都可能会影响到子类，甚至我们没有使用父类的一些方法。举个例子，假如子类有一个方法 test()，而父类之前是没有的，但突然有人在不知情的情况下在父类插入了一个同名但签名不同的 test() 方法，那么就会出现编译错误。组合是不会遇到这个问题的，因为我们仅仅会使用我们需要的方法。

这是父类追加的 test() 方法：

public class Super {    public String test() {        System.out.println("super");        return null;    }}

原来子类的 test() 方法就出错了。

来个表格列举一下两者之间的优缺点：

组 合 关 系 继 承 关 系
优点：不破坏封装，整体类与局部类之间松耦合，彼此相对独立 缺点：破坏封装，子类与父类之间紧密耦合，子类依赖于父类的实现，子类缺乏独立性
优点：具有较好的可扩展性 缺点：支持扩展，但是往往以增加系统结构的复杂度为代价
优点：支持动态组合。在运行时，整体对象可以选择不同类型的局部对象 缺点：不支持动态继承。在运行时，子类无法选择不同的父类
优点：整体类可以对局部类进行包装，封装局部类的接口，提供新的接口 缺点：子类不能改变父类的接口
缺点：整体类不能自动获得和局部类同样的接口 优点：子类能自动继承父类的接口
缺点：创建整体类的对象时，需要创建所有局部类的对象 优点：创建子类的对象时，无须创建父类的对象

42、如何在 Java 中对自定义对象的集合进行排序？

需要对自定义对象的类实现 Comparable 接口，重写 compareTo(T obj) 方法，该方法在排序的时候会被调用进行排序。

关于 Comparable 和 Comparator 接口更详细的内容，可以参照我之前写了另外一篇文章：

一文彻底搞懂Java中的Comparable和Comparator

43、什么是内部类？

我们可以在一个类中定义一个类，这个类被称为内部类。内部类可以访问外部类的所有变量和方法，内部类中不能有任何静态变量。

44、什么是匿名内部类？

没有名称的内部类称为匿名内部类，它通过单个语句进行定义和实例化，总是需要扩展一个类或者实现一个接口。

由于匿名内部类没有名称，所以无法为匿名内部类定义构造方法。

45、什么是 Java 中的 Classloader（类加载器）？

当我们要访问任何类时，都需要通过 Java Classloader 将该类的字节码加在到内存当中，可以通过继承 ClassLoader 并重写 loadClass(String name) 方法来创建自定义的类加载器。

46、有哪些不同的类加载器？

  • Bootstrap 类加载器，用来加在 JDK 的内部类，比如说 rt.jar。

  • Extensions 类加载器，它从 JDK 扩展目录（JAVA_HOME/lib/ext）中加载类。

  • System 类加载器，它从当前类路径加载类。

47、什么是三元运算符？

三元运算符是 if-then-else 语句的一个替换，示例如下：

result = testStatement ? value1 : value2;

48、super 关键字有什么用？

当在子类中重写了父类方法时，可以通过 super 关键字访问父类方法。

也可以使用 super 关键字在子类构造方法中调用父类构造方法，它必须是构造方法中的第一条语句。

public class SuperClass {    public SuperClass(){    }    public SuperClass(int i){}    public void test(){        System.out.println("父类的测试方法");    }}

来看子类中如何使用 super 关键字：

public class ChildClass extends SuperClass {    public ChildClass(String str){        // 调用父类的构造方法        super();        // 调用子类的 test 方法        test();        // 使用 super 关键字调用父类的 test 方法        super.test();    }    @Override    public void test(){        System.out.println("child class test method");    }}

49、什么是 break，什么是 continue？

我们可以使用 break 关键字终止 for、while、do-while 循环；可以在 switch 语句中使用 break 退出 case 条件。

我们可以使用 continue 关键字在 for、while、do-while 循环跳过当前迭代；甚至可以使用带有标签的 continue 语句来跳过最外层循环的当前迭代。

50、什么是 this 关键字？

this 关键字提供对当前对象的引用，主要用于确保使用了当前对象的变量，而不是具有相同名称的局部变量。

//constructorpublic Point(int x, int y) {    this.x = x;    this.y = y;}

还可以使用 this 关键字在构造方法中调用其他构造方法：

public Rectangle() {    this(0, 0, 0, 0);}public Rectangle(int width, int height) {    this(0, 0, width, height);}public Rectangle(int x, int y, int width, int height) {    this.x = x;    this.y = y;    this.width = width;    this.height = height;}

关于 this 关键字更详细的内容，可以参照我之前写了另外一篇文章：

我去，你竟然还不会用 this 关键字

51、什么是默认的构造方法？

一个类的无参构造方法被称为默认构造方法。当我们没有为一个类定义构造方法时，Java 编译器会自动为该类创建一个默认的无参构造方法。如果定义了其他构造方法，编译器就不会在为我们创建默认构造方法了。

52、try 块可以没有 catch 吗？

是的，可以直接使用 try-finally，而不需要 catch 捕获异常。

53、什么是垃圾回收？

垃圾回收（Garbage Collection，简称 GC）会查看堆内存，识别正在使用和未使用的对象，以及会自动删除未使用的对象，用来释放内存。

54、什么是序列化和反序列化？

我们可以把一个 Java 对象转化成一个数据流，这被称为序列化。一旦对象被转化为数据流后，就可以将其保存到文件或者通过网络套接字发送。

如果一个对象实现了 Serializable 接口，就可以使用 java.io.ObjectOutputStream将对象写入文件。

将数据流再转化为 Java 对象被称为反序列化。

55、如何通过命令提示符运行 jar 文件？

可以通过 java 命令运行 jar 文件，但需要 jar 文件中有 main 方法。

56、System 类有什么用？

System 类是 Java 的一个核心类，比较常用的就是 System.out.println()。

System 类是 final 的，因此我们不能通过继承来重写它的方法，System 类没有提供任何 public 的构造方法，因此无法实例化，它的所有方法都是 static 的。

57、什么是 instanceof 关键字？

我们可以使用 instanceof 关键字检查对象是否属于一个类。

public static void main(String args[]){    Object str = new String("沉默王二");    if(str instanceof String){        System.out.println("字符串值为：" + str);    }    if(str instanceof Integer){        System.out.println("数字的值是：" + str);    }}

58、可以在 switch 中使用字符串吗？

Java 7 改进的一个功能就是允许在 switch 语句中使用字符串。

关于 switch 更详细的内容，可以参照我之前写了另外一篇文章：

我去，你写的 switch 语句也太老土了吧

59、Java 是按值传递还是按引用传递？

可以很确定地说，Java 是按值传递的。

关于这个问题，可以参照我之前写了另外一篇文章：

面试官：兄弟，说说Java到底是值传递还是引用传递

60、堆（heap）和栈（stack）有什么区别？

  • 堆内存被应用程序的所有部分使用，而栈内存仅由执行线程使用。
  • 当我们创建对象时，它始终存储在堆空间上；栈仅存储该对象的引用，栈内存还可以存储局部的基本类型数据变量。
  • 栈的内存管理方式是 LIFO（后进先出）形式，而堆的内存管理方式更复杂。

61、Java 编译在 JDK 中，还是 JRE，还是 JVM 中？

Java 编译器的任务是将 Java 源代码转换为字节码，可以通过 javac 命令执行，因此它在 JDK 中，JRE 中不需要它。

62、下面这段程序输出什么？

public class Test {    public static String toString(){        System.out.println("测试 toString 方法有没有被调用");        return "";    }    public static void main(String args[]){        System.out.println(toString());    }}

这段代码无法编译通过，因为 java.lang.Object 中的 toString() 方法不是 static 的，它无法被 static 修饰的方法重写。

那下面这段代码呢？

public class Test {    public static String foo(){        System.out.println("测试 foo 方法有没有被调用");        return "";    }    public static void main(String args[]){        Test obj = null;        System.out.println(obj.foo());    }}

这段代码会输出 测试 foo 方法有没有被调用，没有出现 NullPointerException。为什么呢？

命名 obj 为 null 啊，通过 obj 调用 foo() 方法的时候应该抛出 NullPointerException 异常才对啊！

之所以没有抛出异常，是因为 Java 编译器对这段代码做出了优化，因为 foo() 方法是静态方法，所以 obj.foo() 会被优化为 foo()，所以就不会抛出异常了。

来看一下这段代码的字节码就明白了：

public class Test {    public Test() {    }    public static String foo() {        System.out.println("测试 foo 方法有没有被调用");        return "";    }    public static void main(String[] args) {        Test obj = null;        System.out.println(foo());    }}


最新2021整理收集的一些高频面试题（都整理成文档），有很多干货，包含mysql，netty，spring，线程，spring cloud、jvm、源码、算法等详细讲解，也有详细的学习规划图，面试题整理等，需要获取这些内容的朋友添加小助理v：Ainanaya20