1.操作系统中 heap 和 stack 的区别：
Heap堆和Satck栈是数据结构的两种，堆主要用来存放对象的，栈主要是用来执行程序的，堆是队列优先，先进先出，栈是先进后出；
栈用来存储临时变量，自动变量，保护现场，CPU会有一个寄存器叫做SP，栈指针，CPU通用寄存器是有限的，不能将每个操作数都放在寄存器中，那暂时不用的就要放到栈内存，叫入栈，要用时在出栈，计算机经常会正在干一件事，忽然有了另一件事，那前一件事的数据就不能继续留在CPU中，做法就是入栈到内存保护现场，等另一件事昨晚了，在将原来数据返回CPU继续做；
堆是预先申请一片内存，可能用到可能用不到，他的生存周期取决于编程者，以申请新的，也可以随时扔掉它，编程者使用到的主要的数据都在这里；
2.什么是基于注解的切面实现：
aspect中的注解实现就是用注解定义切面，切点，一般用在实物和日志记录中；
3.什么是 对象/关系 映射集成模块：
对象关系映射（Object Relational Mapping，简称ORM）是通过使用描述对象和数据库之间映射的元数据，将面向对象语言程序中的对象自动持久化到关系数据库中。本质上就是将数据从一种形式转换到另外一种形式。Spring通过提供ORM模块在JDBC的基础上支持对象关系映射工具。这样的支持使得Spring可以集成主流的ORM框架，包括Hibernate
- 什么是 Java 的反射机制：
是指程序可以访问，检测和修改它本身状态或行为的一种能力，通过反射机制访问java对象的属性，方法，构造方法等
优缺点：
优点：
1、反射提高了程序的灵活性和扩展性。
2、降低耦合性，提高自适应能力。
3、它允许程序创建和控制任何类的对象，无需提前硬编码目标类。
缺点：
1、性能问题：使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和拓展性要求很高的系统框架上，普通程序不建议使用。
2、使用反射会模糊程序内部逻辑；程序员希望在源代码中看到程序的逻辑，反射却绕过了源代码的技术，因而会带来维护的问题，反射代码比相应的直接代码更复杂。
5什么是 ACID：
ACID，指数据库事务正确执行的四个基本要素的缩写。包含：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）。一个支持事务（Transaction）的数据库，必须要具有这四种特性，否则在事务过程（Transaction processing）当中无法保证数据的正确性，交易过程极可能达不到交易方的要求
--原子性(Atomic)：事务中各项操作，要么全做要么全不做，任何一项操作的失败都会导致整个事务的失败；
- 一致性(Consistent)：事务结束后系统状态是一致的；
- 隔离性(Isolated)：并发执行的事务彼此无法看到对方的中间状态；
- 持久性(Durable)：事务完成后所做的改动都会被持久化，即使发生灾难性的失败。通过日志和同步备份可以在故障发生后重建数据.
6.BS与CS的联系与区别：
B/S模式是指在TCP/IP的支持下，以HTTP为传输协议，客户端通过Browser访问Web服务器以及与之相连的后台数据库的技术及体系结构。它由浏览器、Web服务器、应用服务器和数据库服务器组成。客户端的浏览器通过URL访问Web服务器，Web服务器请求数据库服务器，并将获得的结果以HTML形式返回客户端浏览器。
c/s在系统机构上和B/S相似，不过需要在客户端安装一个客户端软件，由这个软件对服务器的数据进行读写，就像我们常用的qq，就是这种模式
- Cookie 和 Session的区别：
Cookie数据存放在客户端，服务器知道其中的数据；Session数据存放在服务器，客户端不知道其中的数据；
Session存放对象，cookie存放字符串；
Cookie不安全，别人可以分析存放在cookie进行cookie欺骗；
Session会在一段时间内保存到服务器中，但是当访问量比较多时，比较占用资源；
单个cookie保存的数据一般不超过4k，一般浏览器限制最多保存20个cookie；
- fail-fast 与 fail-safe 机制有什么区别：
java.util包下面的所有的集合类都是快速失败的，而java.util.concurrent包下面的所有的类都是安全失败的。
fail-fast机制在遍历一个集合时，当集合结构被修改，会抛出Concurrent Modification Exception。
fail-fast会在以下两种情况下抛出ConcurrentModificationException
（1）单线程环境
集合被创建后，在遍历它的过程中修改了结构。
注意 remove()方法会让expectModcount和modcount 相等，所以是不会抛出这个异常。
（2）多线程环境
当一个线程在遍历这个集合，而另一个线程对这个集合的结构进行了修改。
fail-safe任何对集合结构的修改都会在一个复制的集合上进行修改，因此不会抛出ConcurrentModificationException
fail-safe机制有两个问题
（1）需要复制集合，产生大量的无效对象，开销大
（2）无法保证读取的数据是目前原始数据结构中的数据。
9.get 和 post请求的区别
GET方式：
1、GET方式是以实体的方式得到由请求URL所指定资源的信息，如果请求URL只是一个数据产生过程，那么最终要在响应实体中返回的是处理过程的结果所指向的资源，而不是处理过程的描述。也就是说，GET的到的信息是资源，而不是资源的处理过程。
2、请的求的数据会附加在URL之后，以？分隔URL和传输数据，多个参数用&连接。URL编码格式采用的是ASCII编码，而不是Unicode，即所有的非ASCII字符都要编码之后再传输。
3、因为URL的长度限制，GET方式传输的数据大小有所限制，传送的数据量不超过2KB。
4、GET方式服务器端用Request.QueryString获取变量的值。
5、GET方式传输的参数安全性低，因为传输的数据会显示在请求的URL中。
POST方式：
1、用来向目的服务器发出请求，要求它接收被附在请求后的实体，并把它当做请求队列中请求URL所指定资源的附加新子项。
2、POST方式将表单内各个字段和内容放置在HTML HEADER中一起传送到Action属性所指定的URL地址，用户是看不到这个过程的。
3、POST方式传送的数据量比较大，一般被默认为没有限制，但是根据IIS的配置，传输量也是不同的。
4、POST方式在服务器端用Request.Form获取提交的数据。
5、POST方式传输的数据安全性较高，因为数据传输不是明显显示的。
10.Interface 与 abstract 类的区别：
1.abstarct类
- 类中可以出现abstract方法，也可以就包含普通方法。（也就是说一旦出现了抽象方法，那这个类必定是抽象类）
- 不能创建实例对象，就是不能使用new运算符创建类的对象。
- abstract类的对象可以成为子类对象的上转型对象，可以调用子类重写的方法。
- abstract类是可以不用有abstract方法的。
- 若一个抽象类是另一个抽象类的子类，那么它可以重写父类的抽象类，也可以直接继承。
2 interface
- 接口体中包含常量的声明（无变量）和抽象方法2部分。
- 只有抽象方法，没有普通方法。
- 常量的访问权限都是public的，而且都是static常量（允许省略public,final,static修饰符）
- 所有抽象方法的访问权限一定都是public的（允许省略public,static修饰符）。
- 当一个普通类实现了一个接口时，那么必须重写这个接口中的所有方法，而且访问权限只能是
- public.
- 接口也有实现权限之分。
- 字implements声明实现这个接口。若父类实现了某个接口，那么子类也就自然实现了该接口，子类也不必再显示地使用关键
- 接口可以被继承，可以通过关键字extends声明一个接口是另一个接口的子接口。由于接口的方法和常量都是public的，子接口讲继父接口的全部方法和常量。
- IOC的优点是什么:
IOC(Inversion of Control)控制反转，将控制权(创建对象和对象之间的依赖关系的权利)交给
spring容器;
IOC模式将耦合代码从程序中移出，放到统一的XML文件中管理。
由IOC容器通过配置文件来管理对象的生命周期、依赖关系等，这样就不用重新修改并编译具体的代码，从而实现组件之间的解耦
IOC的优点:实现组件之间的解耦，提高程序的灵活性和可维护性。
- IO 和 NIO的区别，NIO优点:
IO是面向流的，NIO是面向缓冲区的
Java IO的各种流是阻塞的,这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。
Java NIO的非阻塞模式,，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）
Java NIO的选择器允许一个单独的线程来监视多个输入通道
13.Java 8 / Java 7 为我们提供了什么新功能:
1.jdk7语法上:
1.1二进制变量的表示,支持将整数类型用二进制来表示，用0b开头。
1.2 Switch语句支持string类型
3.1.可以使用try-with-resources自动关闭Connection, ResultSet, 和 Statement资源对象
14.什么是竞态条件？ 举个例子说明。
当两个线程竞争同一资源时，如果对资源的访问顺序敏感，就称存在竞态条件。
导致竞态条件发生的代码区称作临界区。
在临界区中使用适当的同步就可以避免竞态条件。
临界区实现方法有两种，一种是用synchronized，一种是用Lock显式锁实现。
class Counter {
protected long count = 0;
public void add(long value) {
this.count = this.count + value;
}
}
观察线程A和B交错执行会发生什么，两个线程分别加了2和3到count变量上，两个线程执行结束后count变量的值应该等于5。然而由于两个线程是交叉执行的，两个线程从内存中读出的初始值都是0。然后各自加了2和3，并分别写回内存。最终的值并不是期望的5，而是最后写回内存的那个线程的值，上面例子中最后写回内存的是线程A，但实际中也可能是线程B。如果没有采用合适的同步机制，线程间的交叉执行情况就无法预料。
add()方法就是一个临界区,它会产生竞态条件。
- JRE、JDK、JVM 及 JIT 之间有什么不同
java虚拟机(JVM)
使用java编程语言的主要优势就是平台的独立性。你曾经想知道过java怎么实现平台的独立性吗？对，就是虚拟机，它抽象化了硬件设备，开发者和他们的程序的得以操作系统。虚拟机的职责就是处理和操作系统的交流。java不同的接口规范对任何平台都有良好的支持，因为jvm很好的实现了每个平台的规范。jvm可以理解伪代码字节码，在用户和操作系统之间建立了一层枢纽。
java运行时环境(JRE)
java运行时环境是JVM的一个超集。JVM对于一个平台或者操作系统是明确的，而JRE确实一个一般的概念，他代表了完整的运行时环境。我们在jre文件夹中看到的所有的jar文件和可执行文件都会变成运行时的一部分。事实上，运行时JRE变成了JVM。所以对于一般情况时候使用JRE，对于明确的操作系统来说使用JVM。当你下载了JRE的时候，也就自动下载了JVM。
java开发工具箱(JDK)
java开发工具箱指的是编写一个java应用所需要的所有jar文件和可执行文件。事实上，JRE是JDK的一部分。如果你下载了JDK,你会看到一个名叫JRE的文件夹在里面。JDK中要被牢记的jar文件就是tools.jar,它包含了用于执行java文档的类还有用于类签名的jar包。
即时编译器(JIT)
即时编译器是种特殊的编译器，它通过有效的把字节码变成机器码来提高JVM的效率。JIT这种功效很特殊，因为他把检测到的相似的字节码编译成单一运行的机器码，从而节省了CPU的使用。这和其他的字节码编译器不同，因为他是运行时(第一类执行的编译？)the firs of its kind to perform the compilation(从字节码到机器码）而不是在程序运行之前。正是因为这些，动态编译这个词汇才和JIT有那么紧密的关系
- MVC的各个部分都有那些技术来实现?如何实现?
MVC 是 Model－View－Controller 的简写。 Model 代表的是应用的业务逻辑（ 通过
JavaBean， EJB 组件实现）， View 是应用的表示面（ 由 JSP 页面产生）， Controller 是提供应用的处理过程控制（ 一般是一个 Servlet）， 通过这种设计模型把应用逻辑， 处理过程和显示逻辑分成不同的组件实现。 这些组件可以进行交互和重用。
- RPC 通信和 RMI 区别
1. RPC 不支持对象， 采用http协议
2. RMI支持传输对象。采用tcp／ip 协议
3. RMI只限于JAVA语言，RPC跨语言
18.什么是 Web Service（Web服务）:
WebService是一种跨编程语言和跨操作系统平台的远程调用技术。
谓跨编程语言和跨操作平台，就是说服务端程序采用java编写，客户端程序则可以采用其他编程语言编写，反之亦然！跨操作系统平台则是指服务端程序和客户端程序可以在不同的操作系统上运行。
所谓远程调用，就是一台计算机a上的一个程序可以调用到另外一台计算机b上的一个对象的方法，譬如，银联提供给商场的pos刷卡系统，商场的POS机转账调用的转账方法的代码其实是跑在银行服务器上。再比如，amazon，天气预报系统，淘宝网，校内网，百度等把自己的系统服务以webservice服务的形式暴露出来，让第三方网站和程序可以调用这些服务功能，这样扩展了自己系统的市场占有率，往大的概念上吹，就是所谓的SOA应用。
19.WEB容器主要有哪些功能? 并请列出一些常见的WEB容器名字。.
Web容器给处于其中的应用程序组件（JSP，SERVLET）提供一个环境，使JSP,SERVLET直接跟容器中的环境变量交互，不必关注其它系统问题。主要有WEB服务器来实现。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。
常见的有容器 Apache, IIS, Tomcat, Resin 等等
- 一个”.java”源文件中是否可以包含多个类（不是内部类）？有什么限制
这个是可以的，一个“.java”源文件里面可以包含多个类，但是只允许有一个public类，并且类名必须和文件名一致。
每个编译单元只能有一个public 类。这么做的意思是，每个编译单元只能有一个公开的接口，而这个接口就由其public 类来表示。
你可以根据需要，往这个文件里面添加任意多个提供辅助功能的package 权限的类。但是如果这个编译单元里面有两个或两个以上的public 类的话，程序就不知道从哪里导入了，编译器就会报错。
- 简单说说你了解的类加载器。是否实现过类加载器
虚拟机设计团队把类加载阶段中“通过一个类的全限定名来获取描述此类的二进制字节流”这个动作放到Java虚拟机外部去实现，以便让应用程序自己决定如何去获取所需要的类。实现这个动作的模块称为“类加载器”。
- 解释一下什么叫AOP（面向切面编程）
在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。
- 请简述 Servlet 的生命周期及其相关的方法
Servlet 生命周期：Servlet 加载--->实例化--->服务--->销毁。
init（）：在Servlet的生命周期中，仅执行一次init()方法。它是在服务器装入Servlet时执行的，负责初始化Servlet对象。可以配置服务器，以在启动服务器或客户机首次访问Servlet时装入Servlet。无论有多少客户机访问Servlet，都不会重复执行init（）。
service（）：它是Servlet的核心，负责响应客户的请求。每当一个客户请求一个HttpServlet对象，该对象的Service()方法就要调用，而且传递给这个方法一个“请求”（ServletRequest）对象和一个“响应”（ServletResponse）对象作为参数。在HttpServlet中已存在Service()方法。默认的服务功能是调用与HTTP请求的方法相应的do功能。
destroy（）： 仅执行一次，在服务器端停止且卸载Servlet时执行该方法。当Servlet对象退出生命周期时，负责释放占用的资源。一个Servlet在运行service()方法时可能会产生其他的线程，因此需要确认在调用destroy()方法时，这些线程已经终止或完成。
- 请简述一下 Ajax 的原理及实现步骤
Ajax的原理简单来说通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，然后用javascript来操作DOM而更新页面。
1、创建XMLHttpRequest对象(需要考虑各浏览器兼容的问题)
2、使用XMLHttpRequest对象打开一个连接(指定连接方式<post/get>和连接地址以及是否同步);调用XMLHttpRequest对象的open方法。第一个参数是提交数据的方式，取值为post/get；第二个参数是提交的目标页面(也就是用于处理提交数据的页面)；第三个参数指定是否请求是异步的-缺省值为true，为了发送一个同步请求，需要把这个参数设置为false。
3、设置请求的头部(请求的类型和请求的编码格式)
4、设置回调函数
主要用于处理从服务端发送给客户端的数据，主要使用javascript去调用页面中的元素，并根据服务端返回的结果去控制页面中元素的更新。内部实现实际上是javascript中的事件处理机制。
5、发送请求:调用XMLHttpRequest对象的send方法实现数据的发送。
6、更新页面显示
25.简单描述Struts的主要功能
链接：https://www.cnblogs.com/god-1949-keshi/p/7124277.html
struts2的目的就是把请求和显示的结果分开，而不是单纯的运行一个jsp页面
拦截器可以说相当于是个过滤器：就是把 不想要的或不想显示的内容给过滤掉。拦截器可以抽象出一部分代码可以用来完善原来的action。同时可以减轻代码冗余，提高重用率。
比如在登入一个页面时，如果要求用户密码、权限等的验证，就可以用自定义的拦截器进行密码验证和权限限制。对符合的登入者才跳转到正确页面。这样如果有新增权限的话，不用在action里修改任何代码，直接在interceptor里修改就行了
26.什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”
一、什么是java虚拟机？
java虚拟机是执行字节码文件（.class）的虚拟机进程。
java源程序（.java）被编译器编译成字节码文件（.class）。然后字节码文件，将由java虚拟机，解释成机器码（不同平台的机器码不同）。利用机器码操作硬件和操作系统
二、为什么java被称为平台无关的编程语言？
因为不同的平台装有不同的JVM，它们能够将相同的.class文件，解释成不同平台所需要的机器码。正是因为有JVM的存在，java被称为平台无关的编程语言
- 什么是正则表达式？用途是什么？哪个包使用正则表达式来实现模式匹配
简单的说就是，用一小段简单的各种字符的组合，即叫做 正则表达式，去实现复杂的：
字符串匹配，查找你到你所需要的内容，以便后期提取出来你所要的内容；
java.util.regex
- 什么是懒加载（Lazy Loading）
懒加载就是什么时候使用什么时候开辟空间,不用的时候只是一个指针不占用内存,当使用的时候为其alloc/init,这时候才占用内存.只要不使用就永远不会真正生成,不会占用空间.
29什么是尾递归，为什么需要尾递归
尾递归是指所有递归形式的调用，一定是发生在函数的末尾。形式上只要最后一个return语句是单纯函数就可以。
尾递归和一般的递归不同在对内存的占用，普通递归创建stack累积而后计算收缩，尾递归只会占用恒量的内存（和迭代一样）
30.什么是控制反转（Inversion of Control）与依赖注入（Dependency Injection）
IoC（Inversion of Control，控制反转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。
这是什么意思呢，举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想办法认识她们，投其所好送其所要，然后嘿嘿……这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。
那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。
关键字
finalize
什么是finalize()方法？
finalize()方法什么时候被调用
答：finalize()是Object的protected方法，子类可以覆盖该方法以实现资源清理工作，GC在回收对象之前调用该方法。
主要的用途是回收特殊渠道申请的内存。Java程序有垃圾回收器，所以一般情况下内存问题不用程序员操心。但有一种JNI(Java Native Interface)调用non-Java程序（C或C++），finalize()的工作就是回收这部分的内存。
final 和 finalize 的区别
final关键字有哪些用法
final, finally, finalize的区别
final、finalize 和 finally 的不同之处？
一个类被声明为final类型，表示了什么意思
答：
Final：
final关键字可以用于类，方法，变量前，用来表示该关键字修饰的类，方法，变量具有不可变的特性。
（1）final关键字用于基本数据类型前：这时表明该关键字修饰的变量是一个常量，在定义后该变量的值就不能被修改。
（2）final关键字用于方法声明前：这时意味着该方法时最终方法，只能被调用，不能被覆盖，但是可以被重载。
（3）final关键字用于类名前：此时该类被称为最终类，该类不能被其他类继承。
Finalize：
finalize方法来自于java.lang.Object，用于回收资源。
可以为任何一个类添加finalize方法。finalize方法将在垃圾回收器清除对象之前调用。
在实际应用中，不要依赖使用该方法回收任何短缺的资源，这是因为很难知道这个方法什么时候被调用。
Finally：
当代码抛出一个异常时，就会终止方法中剩余代码的处理，并退出这个方法的执行。假如我们打开了一个文件，但在处理文件过程中发生异常，这时文件还没有被关闭，此时就会产生资源回收问题。对此，java提供了一种好的解决方案，那就是finally子句，finally子句中的语句是一定会被执行的，所以我们只要把前面说的文件关闭的语句放在finally子句中无论在读写文件中是否遇到异常退出，文件关闭语句都会执行，保证了资源的合理回收。
final 与 static 关键字可以用于哪里？它们的作用是什么
1）static方法
static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。
2）static变量
static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
static成员变量的初始化顺序按照定义的顺序进行初始化。
3）static代码块
static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次
能否在运行时向 static final 类型的赋值
答：final static 变量就只能在定义的时候就初始化，否则既无法在构造方法中初始化，系统又不会赋默认值，相当于这个变量被定义出来是毫无用处的。 因此java中final static变量必须初始化。
使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变
答：使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。
throws, throw, try, catch, finally分别代表什么意义？
答：throws是获取异常
throw是抛出异常
try是将会发生异常的语句括起来，从而进行异常的处理，
catch是如果有异常就会执行他里面的语句，
finally不论是否有异常都会进行执行的语句。
throws是用来声明一个方法可能抛出的所有异常信息，而throw则是指抛出的一个具体的异常类型。此外throws是将异常声明但是不处理，而是将异常往上传，谁调用我就交给谁处理；
1、throws出现在方法函数头；而throw出现在函数体。
2、throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常。
3、两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。
Java 有几种修饰符？分别用来修饰什么
答：
方法的修饰符有两类：
1.访问控制修饰符(public,private,protected,package)
2.方法本身修饰符(static,final,abstract,native,synchronized)
类的修饰符：
1.前缀修饰符(public,abstract,final)
2.后缀修饰符(extends,implements)
volatile
volatile 修饰符的有过什么实践
答：
一种实践是用 volatile 修饰 long 和 double 变量，使其能按原子类型来读写。double 和 long 都是64位宽，因此对这两种类型的读是分为两部分的，第一次读取第一个 32 位，然后再读剩下的 32 位，这个过程不是原子的，但 Java 中 volatile 型的 long 或 double 变量的读写是原子的。volatile 修复符的另一个作用是提供内存屏障（memory barrier），例如在分布式框架中的应用。简单的说，就是当你写一个 volatile 变量之前，Java 内存模型会插入一个写屏障（write barrier），读一个 volatile 变量之前，会插入一个读屏障（read barrier）。意思就是说，在你写一个 volatile 域时，能保证任何线程都能看到你写的值，同时，在写之前，也能保证任何数值的更新对所有线程是可见的，因为内存屏障会将其他所有写的值更新到缓存。
volatile 变量是什么？volatile 变量和 atomic 变量有什么不同
答：volatile就是告诉程序，该变量是易变的，不稳定的，每次必须去主存读取，而不要从自己的缓存中获取副本
volatile 类型变量提供什么保证？能使得一个非原子操作变成原子操作吗
答：一个典型的例子是在类中有一个 long 类型的成员变量。如果你知道该成员变量会被多个线程访问，如计数器、价格等，你最好是将其设置为 volatile。为什么？因为 Java 中读取 long 类型变量不是原子的，需要分成两步，如果一个线程正在修改该 long 变量的值，另一个线程可能只能看到该值的一半（前 32 位）。但是对一个 volatile 型的 long 或 double 变量的读写是原子。
能创建 volatile 数组吗？
答：能，Java 中可以创建 volatile 类型数组，不过只是一个指向数组的引用，而不是整个数组。我的意思是，如果改变引用指向的数组，将会受到 volatile 的保护，但是如果多个线程同时改变数组的元素，volatile 标示符就不能起到之前的保护作用了。
transient变量有什么特点？
答：transient是类型修饰符，只能用来修饰字段。在对象序列化的过程中，标记为transient的变量不会被序列化。
super什么时候使用？
答：如果父类的构造函数是无参的，那子类构造函数会在第一行默认调用super().
说明一下public static void main(String args[])这段声明里每个关键字的作用
答：
public: main方法是Java程序运行时调用的第一个方法，因此它必须对Java环境可见。所以可见性设置为public.
static: Java平台调用这个方法时不会创建这个类的一个实例，因此这个方法必须声明为static。
void: main方法没有返回值。
String：是命令行传进参数的类型，args：是指命令行传进的字符串数组。
请说出作用域public, private, protected, 以及不写时的区别
答：private修饰的成员变量和函数只能在类本身和内部类中被访问。
protected 修饰的成员变量和函数能被类本身、子类及同一个包中的类访问。
public修饰的成员变量和函数可以被类、子类、同一个包中的类以及任意其他类访问。
默认情况（不写）下，属于一种包访问，即能被类本身以及同一个包中的类访问。
下面这个表能清楚的说明java中作用域操作符的作用：
作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
sizeof 是Java 的关键字吗
static
static class 与 non static class的区别
答：如果把类比喻成鸡蛋，内部类为蛋黄,外部类是蛋壳。那么静态类相当于熟鸡蛋，就算蛋壳破碎（外部类没有实例化），蛋黄依然完好（内部类可以实例化）；而非静态类相当于生鸡蛋，蛋壳破碎（无实例化），蛋黄也会跟着xx（不能实例化）。
静态类型有什么特点？static 关键字是什么意思？
方便在没有创建对象的情况下来进行调用（方法/变量）。
main() 方法为什么必须是静态的？能不能声明 main() 方法为非静态
答：Main方法作为程序的入口方法，在这之前是不可能有任何对象被建立的，也就在Main之前包括Main自身不可能是非静态方法。所以Main方法一定是静态的。
是否可以从一个静态（static）方法内部发出对非静态（non-static）方法的调用？
不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，
* 才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以
* 直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例
* 对象，如果从一个static方法中发出对非static方法的调用，那个非static
* 方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部
* 发出对非static方法的调用
静态变量在什么时候加载？编译期还是运行期？静态代码块加载的时机呢
静态变量是在类加载的时候分配空间的
成员方法是否可以访问静态变量？为什么静态方法不能访问成员变量
switch
switch 语句中的表达式可以是什么类型数据
在switch(expression)中，expression只能是一个整数表达式或者枚举常量，整数表达式可以是int类型或Integer包装类型。由于，byte，short，char都可以隐式转换为int类型，所以，这些类型也可以用作表达式。
另外jdk7以后，switch表达式也可以为String类型，
switch 是否能作用在byte 上，是否能作用在long 上，是否能作用在String上
switch可作用于char byte short int
* switch可作用于char byte short int对应的包装类
* switch不可作用于long double float boolean，包括他们的包装类
* switch中可以是字符串类型,String(jdk1.7之后才可以作用在string上)
* switch中可以是枚举类型
操作符
&操作符和&&操作符有什么区别?
&：表示普通与，所有的判断条件都要依次执行；
&&：若干个条件，如果前面的条件返回false,那么后面不再判断，就是false;
|：表示普通h或，所有的判断条件都要依次执行；
||：若干个条件，如果前面的条件返回true,那么后面不再判断，就是true;
位运算：&表示位与运算，|表示位或计算
a = a + b 与 a += b 的区别？
1、对于同样类型的a,b来说
两个式子执行的结果确实没有什么区别。但是从编译的角度看吧（武让说的），a+=b;执行的时候效率高。
2、对于不同类型的a,b来说
2.1 不同类型的两个变量在进行运算的时候，我们经常说到的是类型的转换问题。这里，记住两点：一、运算过程中，低精度的类型向高精度类型转换。二、如果将高精度的数值赋值给低精度类型变量，则必须要进行显性的强制转换。
2.2 对于a+=b;这个式子，要明确的一点是，+=运算中，结合了强制类型转换的功能，因此，不会出现编译错误；而对于a=a+b;这个式子，因为是简单的运算，没有类型转换，在编译过程中会报错，
逻辑操作符 (&,|,^)与条件操作符(&&,||)的区别
a.条件操作只能操作布尔型的,而逻辑操作不仅可以操作布尔型,而且可以操作数值型
b.逻辑操作不会产生短路.
3*0.1 == 0.3 将会返回什么？true 还是 false？
false，因为有些浮点数不能完全精确的表示出来。
float f=3.4; 是否正确？
原因：精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4 或float f = 3.4f
short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
对于short s1 = 1; s1 = s1 + 1; 由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。对于short s1 = 1; s1 += 1;由于 += 是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。
数据结构
基础类型(Primitives)
基础类型(Primitives)与封装类型(Wrappers)的区别在哪里？
1.基本类型只能按值传递，而每个基本类型对应的封装类是按引用传递的。
2.从性能上说java中的基本类型是在堆栈上创建的，而所有的对象类型都是在堆上创建的，（对象的引用在堆栈上创建）。
3.封装类的出现，是为了更方便的使用一些基本类型不具备的方法，比如valueOf（），toString（）等等。
4.如果想传递一个int对象的引用，而不是值，那只能用封装类。
5.基本数据可以自动封装成封装类,基本数据类型的好处就是速度快（不涉及到对象的构造和回收），封装类的目的主要是更好的处理数据之间的转换，方法很多，用起来也方便。
注意：
[在堆栈上分配内存的调用效率和在堆上分配内存的效率差太多了。虽然在堆栈上分配内存效率高，不过在堆栈上分配内存有内存泄露的问题。]
简述九种基本数据类型的大小，以及他们的封装类
float和double的默认值是多少？
|
基本类型 |
大小(字节) |
默认值 |
封装类 |
|
byte |
1 |
(byte)0 |
Byte |
|
short |
2 |
(short)0 |
Short |
|
int |
4 |
0 |
Integer |
|
long |
8 |
0L |
Long |
|
float |
4 |
0.0f |
Float |
|
double |
8 |
0.0d |
Double |
|
boolean |
- |
false |
Boolean |
|
char |
2 |
u0000(null) |
Character |
|
void |
- |
- |
Void |
int 和 Integer 哪个会占用更多的内存？
Integer 对象会占用更多的内存。Integer 是一个对象，需要存储对象的元数据。
但是 int 是一个原始类型的数据，所以占用的空间更少。
int 和 Integer 有什么区别？
1、Integer是int的包装类，int则是java的一种基本数据类型
2、Integer变量必须实例化后才能使用，而int变量不需要
3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值
4、Integer的默认值是null，int的默认值是0
parseInt()函数在什么时候使用到？
parseInt() 函数可解析一个字符串，并返回一个整数。
转换函数：把字符串转换为整数。
默认情况下，以字符串形式存储。
如何去小数四舍五入保留小数点后两位
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.NumberFormat;
public class format {
double f = 111231.5585;
public void m1() {
BigDecimal bg = new BigDecimal(f);
double f1 = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
System.out.println(f1);
}
/**
* DecimalFormat转换最简便
*/
public void m2() {
DecimalFormat df = new DecimalFormat("#.00");
System.out.println(df.format(f));
}
/**
* String.format打印最简便
*/
public void m3() {
System.out.println(String.format("%.2f", f));
}
public void m4() {
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMaximumFractionDigits(2);
System.out.println(nf.format(f));
}
public static void main(String[] args) {
format f = new format();
f.m1();
f.m2();
f.m3();
f.m4();
}
}
结果：
111231.56
111231.56
111231.56
111,231.56
char 型变量中能不能存贮一个中文汉字，为什么
char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，
* 所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在
* unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充
* 说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节
类型转换
怎样将 bytes 转换为 long 类型
怎么将 byte 转换为 String
byte[] srtbyte;
String res = new String(srtbyte);
System.out.println(res);
如何将数值型字符转换为数字
使用对象包装类，如Integer.parseInt("1234")
我们能将 int 强制转换为 byte 类型的变量吗？如果该值大于 byte 类型的范围，将会出现什么现象？
因为Java中byte是用8位来存储，只能表示-128~127之间的数，当由int强制类型转化为byte时，系统就采取了截取int后8位的做法。
能在不进行强制转换的情况下将一个 double 值赋值给 long 类型的变量吗
java double转long型是取整运算；
数组
如何权衡是使用无序的数组还是有序的数组
有序数组最大的好处：在于查找的时间复杂度是O(log n)，而无序数组是O(n)。
有序数组的缺点是：插入操作的时间复杂度是O(n)，因为值大的元素需要往后移动来给新元素腾位置。相反，无序数组的插入时间复杂度是常量O(1)。
怎么判断数组是 null 还是为空
int b[]=null;
int a[] = new int [10];
System.out.println("a数组的长度："+a.length);
System.out.println("b数组的长度："+b.length);//会空指针异常；
Array 和 ArrayList有什么区别？什么时候应该使用Array而不是ArrayList
存储内容比较：
Array数组可以包含基本类型和对象类型，
ArrayList却只能包含对象类型。
但是需要注意的是：Array数组在存放的时候一定是同种类型的元素。ArrayList就不一定了，因为ArrayList可以存储Object。
空间大小比较：
它的空间大小是固定的，空间不够时也不能再次申请，所以需要事前确定合适的空间大小。
ArrayList的空间是动态增长的，如果空间不够，它会创建一个空间比原空间大一倍的新数组，然后将所有元素复制到新数组中，接着抛弃旧数组。而且，每次添加新的元素的时候都会检查内部数组的空间是否足够。（比较麻烦的地方）。
方法上的比较：
ArrayList作为Array的增强版，当然是在方法上比Array更多样化，比如添加全部addAll()、删除全部removeAll()、返回迭代器iterator()等。
适用场景：
如果想要保存一些在整个程序运行期间都会存在而且不变的数据，我们可以将它们放进一个全局数组里，但是如果我们单纯只是想要以数组的形式保存数据，而不对数据进行增加等操作，只是方便我们进行查找的话，那么，我们就选择ArrayList。而且还有一个地方是必须知道的，就是如果我们需要对元素进行频繁的移动或删除，或者是处理的是超大量的数据，那么，使用ArrayList就真的不是一个好的选择，因为它的效率很低，使用数组进行这样的动作就很麻烦，那么，我们可以考虑选择LinkedList。
数组和链表数据结构描述，各自的时间复杂度?
1、存取方式上，数组可以顺序存取或者随机存取，而链表只能顺序存取；
2、存储位置上，数组逻辑上相邻的元素在物理存储位置上也相邻，而链表不一定；
3、存储空间上，链表由于带有指针域，存储密度不如数组大；
4、按序号查找时，数组可以随机访问，时间复杂度为O(1)，而链表不支持随机访问，平均需要O(n)；
5、按值查找时，若数组无序，数组和链表时间复杂度均为O(1)，但是当数组有序时，可以采用折半查找将时间复杂度降为O(logn)；
6、插入和删除时，数组平均需要移动n/2个元素，而链表只需修改指针即可；
7、空间分配方面：
数组在静态存储分配情形下，存储元素数量受限制，动态存储分配情形下，虽然存储空间可以扩充，但需要移动大量元素，导致操作效率降低，而且如果内存中没有更大块连续存储空间将导致分配失败；
链表存储的节点空间只在需要的时候申请分配，只要内存中有空间就可以分配，操作比较灵活高效
数组有没有length()这个方法? String有没有length()这个方法
数组中没有length()这个方法，但是数组中有length这个属性。用来表示数组的长度。
String中有length()这个方法。用来得到字符串的长度。
队列
队列和栈是什么，列出它们的区别
队列先进先出，栈先进后出。
栈（Stack）是限定只能在表的一端进行插入和删除操作的线性表。
队列（Queue）是限定只能在表的一端进行插入和在另一端进行删除操作的线性表。
ArrayList、Vector、LinkedList的存储性能和特性
1.ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦.
2.LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引 但是缺点就是查找非常麻烦 要丛第一个索引开始
3.ArrayList和Vector都是用数组方式存储数据,此数组元素数要大于实际的存储空间以便进行元素增加和插入操作,他们都允许直接用序号索引元素,但是插入数据元素涉及到元素移动等内存操作,所以索引数据快而插入数据慢.
4.Vector使用了sychronized方法(线程安全),所以在性能上比ArrayList要差些.
5.LinkedList使用双向链表方式存储数据,按序号索引数据需要前向或后向遍历数据，所以索引数据慢,是插入数据时只需要记录前后项即可,所以插入的速度快.
6.arraylist和vector的区别?
1).同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程不安全的，不是同步的
2).数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
3).Vector不能有种复的值，ArrayList则可有重复的值。
String
StringBuffer
StringBuilder
- 三者在执行速度方面的比较：StringBuilder > StringBuffer > String
- StringBuilder：线程非安全的
- StringBuffer：线程安全的
- 如果要操作少量的数据用 = String
- 单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
- 多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
HashMap
HashMap的工作原理是什么?
通过hash的方法，通过put和get存储和获取对象。存储对象时，我们将K/V传给put方法时，它调用hashCode计算hash从而得到bucket位置，进一步存储，HashMap会根据当前bucket的占用情况自动调整容量(超过Load Facotr则resize为原来的2倍)。获取对象时，我们将K传给get，它调用hashCode计算hash从而得到bucket位置，并进一步调用equals()方法确定键值对。如果发生碰撞的时候，Hashmap通过链表将产生碰撞冲突的元素组织起来，在Java 8中，如果一个bucket中碰撞冲突的元素超过某个限制(默认是8)，则使用红黑树来替换链表，从而提高速度。
HashMap、LinkedMap、TreeMap的区别
A：HashMap 参考其他问题；
LinkedHashMap 保存了记录的插入顺序，在用 Iterator 遍历时，先取到的记录肯定是先插入的；遍历比 HashMap 慢；
TreeMap 实现 SortMap 接口，能够把它保存的记录根据键排序（默认按键值升序排序，也可以指定排序的比较器）
Set
Set 里的元素是不能重复的，那么用什么方法来区分重复与否呢？是用 == 还是 equals()？ 它们有何区别?
1、什么是Set?(what)
Set是Collection容器的一个子接口，它不允许出现重复元素，当然也只允许有一个null对象。
2、如何来区分重复与否呢？(how)
“ 用 iterator() 方法来区分重复与否 ”，这是在网上流传的答案，个人认为这是个错误的答案。API中写的很明白：“set 不包含满足
e1.equals(e2) 的元素对 e1 和 e2 ”，由此可见回答使用equals()区分更合适。
3、为什么用equals()而不用==来区分？(why)
应该从它俩的区别谈起，==是用来判断两者是否是同一对象（同一事物），而equals是用来判断是否引用同一个对象。再看一下Set里面存的是
对象，还是对象的引用。根据java的存储机制可知，set里面存放的是对象的引用，所以当两个元素只要满足了equals()时就已经指向同一个对象，
也就出现了重复元素。所以应该用equals()来判断。
List
List, Set, Map三个接口，存取元素时各有什么特点?
List与Set都是单列元素的集合，它们有一个功共同的父接口Collection。
Set里面不允许有重复的元素，
存元素：add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true；当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。
取元素：没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。
List表示有先后顺序的集合，
存元素：多次调用add(Object)方法时，每次加入的对象按先来后到的顺序排序，也可以插队，即调用add(int index,Object)方法，就可以指定当前对象在集合中的存放位置。
取元素：方法1：Iterator接口取得所有，逐一遍历各个元素
方法2：调用get(index i)来明确说明取第几个。
Map是双列的集合，存放用put方法:put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。
取元素：用get(Object key)方法根据key获得相应的value。
也可以获得所有的key的集合，还可以获得所有的value的集合，
还可以获得key和value组合成的Map.Entry对象的集合。
List以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。
List, Set, Map 是否继承自 Collection 接口
遍历一个 List 有哪些不同的方式
List遍历方式：
第一种：
for(Iterator iterator = list.iterator();iterator.hasNext();){
int i = (Integer) iterator.next();
System.out.println(i);
}
第二种：
Iterator iterator = list.iterator();
while(iterator.hasNext()){
int i = (Integer) iterator.next();
System.out.println(i);
}
第三种：
for (Object object : list) {
System.out.println(object);
}
第四种：
for(int i = 0 ;i<list.size();i++) {
int j= (Integer) list.get(i);
System.out.println(j);
}
LinkedList
LinkedList 是单向链表还是双向链表
双向链表
LinkedList 与 ArrayList 有什么区别
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据
描述下 Java 中集合（Collections），接口（Interfaces），实现（Implementations）的概念。
插入数据时，ArrayList, LinkedList, Vector谁速度较快？
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
ArrayList
ArrayList 和 HashMap 的默认大小是多数？
List 元素是有序的、可重复
ArrayList、Vector默认初始容量为10
Vector：线程安全，但速度慢
底层数据结构是数组结构
加载因子为1：即当 元素个数 超过 容量长度 时，进行扩容
扩容增量：原容量的 1倍
如 Vector的容量为10，一次扩容后是容量为20
ArrayList：线程不安全，查询速度快
底层数据结构是数组结构
扩容增量：原容量的 0.5倍+1
如 ArrayList的容量为10，一次扩容后是容量为16
Set(集) 元素无序的、不可重复。
HashSet：线程不安全，存取速度快
底层实现是一个HashMap（保存数据），实现Set接口
默认初始容量为16（为何是16，见下方对HashMap的描述）
加载因子为0.75：即当 元素个数 超过 容量长度的0.75倍 时，进行扩容
扩容增量：原容量的 1 倍
如 HashSet的容量为16，一次扩容后是容量为32
Map是一个双列集合
HashMap：默认初始容量为16
（为何是16：16是2^4，可以提高查询效率，另外，32=16<<1 -->至于详细的原因可另行分析，或分析源代码）
加载因子为0.75：即当 元素个数 超过 容量长度的0.75倍 时，进行扩容
扩容增量：原容量的 1 倍
如 HashSet的容量为16，一次扩容后是容量为32