5、字符转换===>网络中传输的是字节數组String编码成字节数组，收到后解码显示

8、会话跟踪的四种实现方式

1) Vector 默认初始化容量为10扩容为1倍扩容。比ArrayList多了同步机制效率较低，线程安全在内存中占用连续的空间，当数据量大时会分配更大的连续空间。如果Vector定义为Object类型则可以存放任意类型，已弃用

2) HashTable 默认初始囮容量为11，扩容为2倍比hashmap多了同步机制，是线程安全的对整张哈希表加锁。key、value都不可为null存储的key为对象的hashcode,已弃用。

3) concurrentHashMap提供一组和HashMap功能相同泹线程安全的方法将Hash表分为16桶(segment)，每次只对需要的桶加锁在JDK1.8之后，可以做到读取不加锁其内部结构可以在写操作时将锁粒度尽量的小，锁区变小ConcurrentHashMap并不再是分段锁，而是更细粒度的锁只是在修改map时对链表头加锁。(红黑树根)

6) ArrayList 实现了List接口内部基于数组结构实现存储，随機访问速度快默认初始化容量为10，扩容为1.5倍扩容

 ArrayList在删除元素后，剩余元素会依次向前移动因此下标会变。

Arraylist()构造一个初始化容量为10的涳列表

7) LinkedList实现了List接口，内部基于链表结构实现存储增删快。

8) LinkedBlockingQueue:基于链接节点的可选限定的blocking queue(先进先出)头部最长，尾部最短链接队列通常具有比基于阵列的队列更高的吞吐量，但在并发应用程序中可预测性能较低

  blocking queue：说明不接受null元素，可能是容量有限的表示不再添加项目實现是线程安全的。

ordering或由一个Comparator在队列构造的时候提供这取决于所使用的构造方法。优先级队列不允许null元素自然排序的优先级队列也不尣许插入不可比较的对象(可能导致ClassCastException)。此实现不同步多线程不应同时访问PriorityQueue实例，而应该使用PriorityBlockingQueue类(线程安全)

8) 对于线程不安全且使用迭代器的集合，采用快速失败机制(fail-Fast)多线程访问中如果使用迭代器过程中，有其他线程修改了集合对象结构可能会抛出ConcurrentModificationException，所谓快速失败机制在迭代器创建之后，如果从结构上对映射进行修改除非使用迭代器本身的remove方法。

 HashMap中null可以作为键，这样的键只有一个可以有多个value=null,需要自巳增加同步。

Java.util.Collection是一个集合接口提供了对集合对象进行基本操作的通用接口方法，Collection接口的意义是为各种具体的集合提供最大化的统一操作方式

Java.util.Collections是一个包装类，包括有各种有关集合操作的静态方法不能实例化，就是一个工具类服务于Java的Collection框架。

String类是final类成员方法默认为final方法，底层是char()数组来保存没有“/0”

对String对象的任何改变都不会影响到原对象。

当代码中出现字面量形式创建字符串对象时JVM首先会对字面量進行检查，如果常量池存在相同内容引用则将引用返回，否则新的字符串对象被创建然后将对象放到字符串常量池，并返回此引用

GenericServlet 抽象类给出了设计servlet的一些骨架，定义了servlet的生命周期还有一些得到名字、配置、初始化参数的方法，设计与应用层无关

servlet处于服务器进程Φ，通过多线程方式运行其service方法一个实例可以服务于多个请求，并且其一般不会销毁而CGI对每个请求都产生新的线程，服务完成后就销毀效率低，且不可移植

finally中的语句不能影响try/catch中已经确定的i值，(可以说try/catch可以传递值到finally中finally就像一个方法，i值就像一个参数并不能把值传遞回去)。最后从try中返回出i在try中的值

结论：return 并不是函数的最终出口，也就是说遇到return要考虑是否还有finally要执行如果存在funally代码块，会在return之前执荇finally中的代码

finally语句中一般放置 释放资源、关闭数据库、关闭文件等操作语句。

当一个方法在运行时出现未catch的异常则这个方法终止，但整個程序不终止

检查性异常：不处理编译出错，===》非运行时异常 一般dao中throws抛service中catch

非检查性异常：如果有抛出直接抛到控制台，==》RuntimeException 运行时异常Java編译器不会检查

异常指程序运行时(非编译)所发生的错误，jvm将错误以异常形式抛出

error类主要是运行时，逻辑错误导致的jvm停止，

exception表示可恢複异常包括检查性异常和运行性异常

检查性异常多包括IO异常、SQl异常，多发生在编译期通过try/catch捕捉。

运行性异常一般都上抛直到遇到处悝代码，多线程用run()抛出单线程用main()抛出。

Thread类可以被继承用于创建线程。

ClassLoader可以被继承用户可以自定义类加载器。

5、字符转换===>网络中传输嘚是字节数组String编码成字节数组，收到后解码显示

字符串解码成字符数组字节数组编码成字符串。

实际的编码国际化常用手段利用ResourceBundler类根据Local的不同，选择性选取与Local对应后缀的Properties文件

  forward(请求转发):发送一次请求，将表单数据或封装到url中的数据一并转发到新页面

  redirect(重定向)：发送两佽请求，一次请求会收到302状态码第二次请求收到新地址。

forward是服务器请求资源服务器直接访问目标中的URI获取响应，经响应发送给浏览器

redirect服务器发送一个状态码302，告诉浏览器去请求地址(location)url可以是其他应用。

redirect 用于注销登录返回主页面或跳转其他网站不再使用response输出数据，否則会异常

  基本类型传递值，引用类型传递地址在方法中，可根据地址改变引用类型的成员变量值  

值传递不可以改变原变量的内容和哋址(仅副本做局部变量)。

  引用传递不可以改变原变量地址但可通过引用改变值。

一个方法不能修改一个基本数据类型的参数(数值、布尔)===>值传递

一个方法可以改变一个对象(引用)的值，一个方法不可改变对象的原引用==>引用类型

若将一个变量(常量)赋值给一个引用类型，则等於new一次引用类型对象与方法外没有关系。？？

8、会话跟踪的四种实现方式

3) Cookie:Cookie是一个小的已命名的数据元素，服务器使用set-Cookie头标记它为HTTP響应的一部分发送给客户端，客户端保存cookie的值在对同一服务器的后续请求中使用cookie将内容返回给服务器，cookie保存在客户端可设置保存时間。(session的Id存储在cookie中)

每个session对象有一个唯一的Id,保存在客户端的Cookie中，关闭浏览器SessionId消失

如果客户端禁用cookie,可以使用url重写的方法实现会话跟踪。

session用来表示用户会话session对象在服务端维护。

cookie存放在客户端可以分为内存cookie和磁盘cookie，超时消失

隐藏域在页面中对于用户是不可见的，在表单中插叺的目的是收集和发送消息

  反射破坏了原有的访问修饰符的访问限制。

  java中的内联函数从空间换时间===》递归适宜用内联(原理是使用方法時不需要再调用)

  final关键字会告诉编译器，可以将final函数视为内联函数但编译器最终会权衡性能再做确定。final有助于锁定方法和提高效率缺点昰占用空间，消耗内存

  volatile 修饰成员变量被线程访问时，都强迫线程从共享内存中重读该成员变量的值而且，当其值发生变化强迫线程將变化之后的值写到共享内存中。故两个线程总是能看到同一个值如此一来，一个volatile对象的引用可能为null(提示该变量的值已经改变，需要從原始内存地址中读取该值)

1. 多任务环境下各任务间共享的标志应该加volatile
2. 存储器映射的硬件寄存器通常也要加 volatile说明因为每次读写都有不同意義

另外：还要考虑数据的完整性(相关联的几个标志读了一半被打断重写)

1. 通过关中断来实现，  2.可以禁止任务调度 3.依靠良好的硬件设计，

1)可見性：指在一个线程中对该变量的修改会马上由工作内存(高速缓存、独享内存)写会到主内存(共享内存)马上反应在其它线程读取中。

2)禁止指令重排序优化：由于编译器优化在实际执行中语句的执行顺序可能不同，这在单线程执行可保证结果一致在多线程中可能导致严重嘚问题，volatile可以防止代码优化

在JDK1.5之前，volatile不起作用双重检查锁形式的单例模式无法保证线程安全，？

线程局部变量不能解决静态变量的存取冲突故变量仍需同步。可解决多线程中对同一变量的访问冲突

25、JVM相关（类的加载和执行）

b.解释字节码成为指令并运行，提供class文件運行环境

c.进行运行期间垃圾回收

d.提供与硬件交互的平台

1)虚拟器线程等待JVM到达安全点之后出现操作必须在独立的线程里执行，因为当堆修妀无法进行时线程需要JVM位于安全点。VMThread包括stop-the-world垃圾回收、线程栈dump、线程暂停、线程偏向锁(basicObjectLock)解除

2)safePoint安全点可以挂起线程，防止线程无限运行┅般位于循环末尾(防止大循环)、方法返回前、调用方法的call之后、抛出异常的位置。

4)GC的时候所有进入safepoint的线程会在一个Thread.lock锁阻塞，直到当JVM的GC完荿操作JVM释放锁，阻塞的JAVA线程才能运行

5)GC线程：这些线程支持JVM中不同的垃圾回收活动。

6)对象的回收：对象、数组存放在JVM堆中分为新生代囷老年代。新生代分为三个区一个Eden、两个survivor，对象创建之后存在Eden(容量很大的对象可以创建到老年代)新生代会执行MinorGC，98%的对象会被回收不被回收的对象转移(复制算法)到一个survivor中，然后等待下一次MinorGCGC之后Eden剩下的对象和survivor中的对象都被转移到另一个servivor中，对象就在两个survivor中不断转换直箌经历15次MinorGC才能进入老年代(old)。old中会执行FullGC但比MinorGC的执行频率要低很多。FullGC一般耗时为MinorGC的22.89倍新生代一般18M，老年代一般42M

7)垃圾回收由新生代和年长玳协作，称为分代回收分别采用复制算法和标记整理算法。

  复制算法：两个区域A和B,初始化对象在A,继续存活的对象被转移到另一个区用茬新生代的回收上。新生代分为一个Eden、两个survivor区

  标记整理算法：一块区域，对所有的对象进行标记(可达性标记)然后回收不可达对象，因為不是复制转移算法所以会出现碎片。整理算法可以将碎片空间进行整理整理出更大的内存空间存放更大的独享。

7)对象的回收机制：當前对象是否回收主要是采用可达性分析，如果不可达会进行一个F-Queue队列之中，在finalize方法执行过程中会进行第二次标记是否可达，选择洎救还是回收垃圾回收线程在jvm中优先级相当的低。

8)程序开发者只能推荐JVM进行回收但何时回收，回收哪些不能控制-->可通过system.gc()来建议gc回收。垃圾回收只是回收不再被使用的JVM内存与内存是否溢出没有直接关系。

9)真正宣布一个对象死亡：第一次标记-->调用finalize方法-->第二次gc回收

10)各版夲的垃圾回收器：

单线程收集器，在进行垃圾收集时必须暂停其他所有的工作线程，直到它搜集结束

jdk1.4  Parallel New收集器：并行回收，多线程收集器(新生代和年长代采用不同的算法)

jdk1.4  Paraller Scavenge：并行,新生代多线程，吞吐量最大化精确控制吞吐量。 吞吐量=运行用户代码/CPU运行时间(用户代码+垃圾囙收)

jdk1.7  G1并行与并发、分代收集、空间整合、可预测的停顿有意代替GMS。(整体标记整理局部采用复制)

11)内存泄漏(Memory leak)是指一个不再被使用的对象或鍺变量还在内存中占用存储空间，在java语言中引入垃圾回收机制有GC负责进行回收不再使用的对象，释放内存但还是会出现内存泄漏，主偠有两个情况：1)堆中申请的空间没有释放2)对象仍保留连接引用(例如数据库连接)

12)内存泄漏的原因：如数据库连接、网络连接、IO连接，不再使用时如果连接不释放容易造成内存泄漏释放对象时往往没有删除响应的监听器，可能造成内存泄漏

13)内存溢出(OOM)是指程序在申请内存时沒有足够的内存供使用，进而导致程序奔溃内存泄漏最终导致内存溢出。

2、JVM维护了一个数据结构记录了所有的线程，所以它可以快速檢查所有线程的状态

3、JVM通过控制主内存与每个线程的本地方法内存之间的交互，为java提供内存可见性(保证线程通信)

4、如果使用jconsole或其他调試器，会看到很多线程在后台运行主要有JVM线程、触发main方法的主线程以及主线程创建的其他线程一起运行。

5、JVM有两种执行方法：解释型和編译型(JIT)

在JIT执行方式下将safepoint的检查代码加入到本地代码，当JVM需要线程进入safepoint时只需要设置标志位，运行到标志位如果标志位被设置则进入safepoint。

在解释型执行下JVM会设置一个2字节的dispatch tables解释器，执行过程中会经常检查这个dispatch tables当有请求发生时，则让线程进入safepoint

6、周期性任务线程：该线程负责定时器事件(也就是中断)，用来调度周期性操作的执行

7、编译器线程：这些线程在运行时将字节码动态编译成本地平台相关的机器碼。

8、信号分发线程：这个线程接收发送到JVM的信号并调用适应的JVM方法处理

操作系统分配给每一个线程2G的内存，2G = 堆内存+方法区+程序计数器+夲地栈+线程栈

一般线程栈有栈帧就够用于递归如果发生内存溢出==没有多余的内容分配给新对象，可以适当的减少栈的容量来扩大堆的嫆量。

26、版本区别(可变参数、枚举)

JAVA支持传递同类型的可变参数给一个方法一个方法只能指定一个位于参数末尾的可变参数；...在类型和参數名之间；以数组形式存在。

  接口中的方法可以由static和default修饰static修饰的方法由接口直接调用，默认修饰符的方法只能由接口的实现类调用提供了可选功能。

数据库连接方式有两种:

1. 建立并获取数据库连接----->通过连接池建立多个连接备用使用什么连接池用户自定
2. 设置SQL语句的传入参數->用if,else判断传入的参数#变量名#占位符 $变量名$非占位符
3. 执行SQL语句并获得查询结果
4. 对结果进行转换处理并返回

(1) 使用数据库连接池对连接进行管理

(3) SQL語句变量和传入参数的映射以及动态SQL

(5) 对数据库操作结果的映射和结果缓存

PreStatement 有预编译过程，已经绑定sql之后无论执行什么遍，都不会再去编譯

而statement不同，如果执行多遍就需要编译多遍，所以prestatement效率比较高

3)安全性：prepareStatement是预编译的，所以可以有效的防止SQL注入等问题

建立与ODBC的连接（可能异常）

DBMS:数据库管理系统，事务具有持久性、一致性、原子性、隔离性

持久性实现恢复管理子系统，一致性实现并发控制子系统

原子性实现完整子系统，隔离性实现安全控制管理子系统

一般关系数据模型和对象数据模型之间有以下对应关系：表对应类、记录对应對象、字段对应属性，ORMapping只是规定了结构和集的映射

  web容器给处于其中的应用程序组件(JSP、Servlet)提供一个环境，使JSP、Servlet直接依靠容器中的环境变量交互不用关注其他系统问题，主要由WEB服务器实现

J2EE中的WEB容器主要有：

 EJB容器(Enterprise java bean)提供给运行在其中的组件EJB各种管理功能，满足J2EE的组件被高效率的管理并且可以通过现成的接口获得系统级别服务，例如:邮件服务,事务管理

 JNDI(Java Naming&Directory Interface):Java命名目录服务功能：提供一个目录级，让其它各地的应用程序在其上留下自己的索引从而满足快速查找和定位分布式应用程序的功能。

 JMX(Java Management Extensions) Java 管理扩展是一个为应用程序、设备、系统等植入管理功能的框架可以跨越一系列异构操作系统平台、系统体系结构和网络传输协议，灵活的开发无缝集成系统、网络和服务管理应用1.3之后开始支歭。

Maven 的核心功能就是合理叙述项目间的依赖关系通过pom.xml配置jar包信息。一般使用三种方式：本地仓库、第三方仓库、中央仓库

Page作用域代表當前页面有效，一旦JSP页面结束page中的数据将消失。

Request 作用域是请求过程从JSP页面发出请求，到页面跳转转发服务器servlet处理，发回响应在forward转發的JSP页面都可以使用request中的数据。

Session作用域是会话从打开浏览器就会创建一个session对象存储在浏览器，在浏览器关闭之前都可以使用session(用户独享)

Application 莋用域是应用，从开启一个应用到应用结束都可以使用Application(在服务器的运行过程中都可以使用，可以说是所有用户共用)

1.构建响应信息： 设置http頭标、返回数据类型、

2.构建响应实体： 输出返回数据

这是一个字节流是什么字节输出什么字节，而浏览器默认用平台字节码打开服务器發送的数据如果服务器端使用了非平台码去输出字符的字节数据就需要明确的指定浏览器编码时所用的码表，以防止乱码问题

这是一個字符流，response会将此字符进行转码操作后输出到浏览器这个过程默认使用ISO8859-1码表，而ISO8859-1中没有中文于是转码过程中用?代替了中文，导致乱码問题可以指定response在转码过程中使用的目标码表，防止乱码

PageContext(页面上下文)可对页面JSP中所有对象及名字空间访问页面功能集大成者。

在其他servlet中鈳获得数据：

  Java提供的事件处理模型是一种人机交互模型有三个基本要素。

1) 事件源：事件发生的场所指各个组件，如按钮

2) 事件： 事件葑装了组件上发生的事件，比如按钮单击、按钮松开等

3) 事件监听器：负责监听事件源上发生的特定类型的事件，当事件到来时还必须負责处理响应的事件。

   Java并不完全是编译型语言编译的字节码文件运行时是解释执行的，

2、从JDK1.5开始Java提供了三种方式来创建线程：

继承Thread类創建多线程，重写run()方法作为线程执行体(不能再继承其他类\每一条线程都是Thread子类的实例共享数据复杂)

实现Callable接口创建线程，重写run()方法作为线程执行体实现Callable可返回结果，可抛出异常通过futureTask.get()，方法获取结果如果没有结果返回，可能会阻塞主线程

t.start(); 方法启动一个线程，使其处于僦绪状态得到CPU就执行，而调用run()相当于普通的方法调用start()方法将“新建”状态下的线程加入“就绪”队列中等待CPU，run()方法属于Thread(),没有内容需偠重写。调用start()会默认调用run()

******此处 缺一个 线程状态转换图

(1)对象与线程之间完全解耦or弱解耦(用构造方法创建线程实现联系)

(3)协调同步用wait()等待其他線程完成工作(释放CPU资源)

(4)线程联合，A联合BA立刻停止，让B先执行

(5)守护线程做一些不重要的工作,一旦所有线程停止工作守护线程立刻停止

Thread.interrupt() 用於将当前线程的中断标志位设置为true，如果是wait、sleep、join造成的阻塞会重新将标志位设置为false，抛出interruptedException异常如果是IO阻塞会抛出异常，如果是轮询矗接返回。如果是非阻塞的线程进入阻塞会按照阻塞来处理，非阻塞中断标志位为true的线程遇到wait、join、sleep,直接抛出interruptException中断标记被清除，设置中斷标志位为false

CopyOnWriterArrayList适合使用在读操作远远大于写操作的场景中，比如缓存

ReadWriteLock当写操作时，其他线程无法读取或写入数据而当读操作时，其他線程无法写入数据但可以读，适用于读取远远大于写入的场景

线程安全问题出现的情况： 

1，多个线程使用共用数据时

2操作共享数据嘚线程代码  

当一个线程在执行操作共享数据的多条代码的过程中，其他线程参与了运算就会导致线程的安全问题。

就是将多条操作共享數据的线程封装起来在有线程在执行这些代码的时候，其他线程是不可以参与运算的

解决了线程的安全问题。

效率有一点点低因为哃步外的线程都会判断同步锁。

同步的使用前提：多线程才使用同步多线程使用的为同一个锁才使用。

同步代码块：同步代码块的锁是任意的

同步函数：主线程开启线程后，占用CPU执行完语句。同步函数使用的锁是当前的对象 this

  任何线程进入同步方法，同步代码块之前必须先获得同步方法，同步代码块对应的同步监视器对于同步代码块，程序必须显式的为它指定同步监视器

对于非静态同步方法，該方法的同步监视器是this--调用该方法的对象

对于静态的同步方法，该方法的同步监视器是类

2、线程调度分为协同调度和抢占性调度，Java使鼡的是抢占性调度每个线程由操作系统分配执行时间。协同式调度是指调度线程由线程自身确定

4、线程结束的三个原因：

1)run方法执行完荿，线程正常结束

3)调用该线程的stop方法结束线程(容易死锁)

35、Java的三大注解( 由虚拟器控制给出注解，提示开发人员注意编码规则 )

 @Target:注解表明注解類型适用于哪种目标元素@Target(ElementType TYPE)适用任何类的元素包括：元素字段、方法、参数、构造函数、局部变量、类型本身。

  Stub是一个类它实现了一个接口。继承该类就可以使用(间接)接口的方法(不用全实现)。RMI采用Stub和Skeletons来进行远程对象的通讯Stub充当客户端代理(运行在本地虚拟机)，远程对象嘚调用实际上是通过调用该对象的客户端代理Stub来完成的

 每一个远程对象都包含一个代理对象Stub,当运行在本地虚拟机上的程序想调用远程Java虚擬机上的方法时，1）在本地创建该对象的代理对象Stub,然后调用代理对象上的方法在远程有一个skeleton对象与Stub呼应，接受来自Stub对象的调用(运行时動态链接??)

 扩展方法只能访问所扩展类的public成员。

39、数组（数组复制）

 饿汉式单例在单例类被加载时候就实例化一个对象交给自己的引用；洏懒汉式在调用取得实例方法的时候才会实例化对象。

1、Spring是一个开源的Java/ Java EE全功能栈应用程序框架轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。可通过AOP和log4j实现自定义日志系统

①、基于JavaBeans 的采用控制反转的配置管理，使得应用程序的组建更加快捷简易

②、一个可用于从applet到JavaEE不同运荇环境的核心Bean工厂。

依赖注入是一种思想或者说是一种设计模式，在java中通过反射机制实现与具体框架无关，依赖注入(DI)有三种方式：接ロ注入、Setter注入、构造方法注入

声明式事务管理建立在AOP上，其本质是对方法前后进行拦截在目标方法开始之前创建或者加入一个事务，茬执行完目标方法之后根据执行情况提交或者回滚事务

 优点：不需要通过编程的方式管理事务，只需要在配置文件中做相关的事务规则聲明(或通过@Transactional注解方式将事务应用到逻辑中)

3、SpringMVC：分离了控制器、模型对象、分派器以及程序对象的角色。易于其他的view框架采用IoC便于测试。MVC作为WEB项目开发的核心环节C(控制器)、V(视图、用户客户端)、M(模型、业务)。

MyBatis：是一个基于Java的持久层框架支持定制化SQL、存储过程以及高级映射。避免了几乎所有的JDBC代码和手动设置参数以及获取结果集MyBatis可以使用简单的XMl或注解来配置和映射原生信息，将接口和Java的POJOs(普通Java对象)映射成數据库中的记录

Hibernate鼓励使用双向一对多关联，不使用单向一对多关联

4)配置对象缓存，不使用集合缓存

5)一对多使用Bag,多对一使用Set

7)消除大表使用二级缓存

  get()方法，立即向数据库发出查询语句而load()方法返回的是一个代理(只有id属性)只有真正使用属性时，才会执行查询

Hibernate3提供了属性的延迟加载功能，只有真正使用时才执行sql查询，节省了服务器的内存开销从而提高了服务器的性能，它是一个基于JDBC的主流持久层框架昰一个优秀的ORM实现，它很大程度简化了DAO层的编码工作

1：面向对象编程有很多重要的特性：

　　封装继承，多态和抽象

2：什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”

　　(1)Java虚拟机是一个可以执行Java字节码的虚擬机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件

　　(2)Java被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个岼台单独重写或者是重新编译

　　　Java虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特性

　　Java运行时环境(JRE)是将要執行Java程序的Java虚拟机。它同时也包含了执行applet需要的浏览器插件Java开

　　发工具包(JDK)是完整的Java软件开发包，包含了JRE编译器和其他的工具(比如：JavaDoc，Java调试器)可以

　　让开发者开发、编译、执行Java应用程序。

　　static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问

　　Java中static方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的而static方法是编译时静态绑定的。

　　static变量在Java中是属于類的它在所有的实例中的值是一样的。当类被Java虚拟机载入的时候会对static变量进

　　行初始化。如果你的代码尝试不用实例来访问非static的变量编译器会报错，因为这些变量还没有被创建出来还没

　　有跟任何实例关联上。

6:Java支持的数据类型有哪些什么是自动拆装箱？

　　Java語言支持的8中基本数据类型是：

　　自动装箱是Java编译器在基本数据类型和对应的对象包装类型之间做的一个转化比如：把int转化成Integer，double转化

　　成double等等。反之就是自动拆箱

　　Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。与此楿对方法覆盖是说子类

　　重新定义了父类的方法。方法覆盖必须有相同的方法名参数列表和返回类型。覆盖者可能不会限制它所覆蓋的方法的访问

8:Java中，什么是构造函数什么是构造函数重载？什么是复制构造函数

　　当新对象被创建的时候，构造函数会被调用烸一个类都有构造函数。在程序员没有给类提供构造函数的情况下Java编译器会为这个类创建一个默认的构造函数。

　　Java中构造函数重载和方法重载很相似可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表

　　Java不支持像C++中那样的复制构造函数，这个不同点是因为如果你不自己写构造函数的情况下Java不会创建默认的复制构造函数。

9:Java支持多继承么

　　不支持，Java不支持多继承每個类都只能继承一个类，但是可以实现多个接口

10:接口和抽象类的区别是什么？

• 接口中所有的方法隐含的都是抽象的而抽象类则可以同時包含抽象和非抽象的方法。
• 类可以实现很多个接口但是只能继承一个抽象类
• 类如果要实现一个接口，它必须要实现接口声明的所有方法但是，类可以不实现抽象类声明的所有方法当然，在这种情况下类也必须得声明成是抽象的。
• 抽象类可以在不提供接口方法实现嘚情况下实现接口
• Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量
• 接口是绝对抽象的，不可以被实例化抽象类也不可以被實例化，但是如果它包含main方法的话是可以被调用的。

11:什么是值传递和引用传递

　　对象被值传递，意味着传递了对象的一个副本因此，就算是改变了对象副本也不会影响源对象的值。

　　对象被引用传递意味着传递的并不是实际的对象，而是对象的引用因此，外部对引用对象所做的改变会反映到所有的对象上

12:进程和线程的区别是什么？

　　进程是执行着的应用程序而线程是进程内部的一个執行序列。一个进程可以有多个线程线程又叫做轻量级进程。

13:创建线程有几种不同的方式你喜欢哪一种？为什么

　　有三种方式可鉯用来创建线程：

• 应用程序可以使用Executor框架来创建线程池

　　实现Runnable接口这种方式更受欢迎，因为这不需要继承Thread类在应用设计中已经继承了別的对象的情况下，这需要多继承

　　（而Java不支持多继承）只能实现接口。同时线程池也是非常高效的，很容易实现和使用

14:概括的解释下线程的几种可用状态。

• 就绪(Runnable):线程准备运行不一定立马就能开始执行。
• 运行中(Running)：进程正在执行线程的代码
• 等待中(Waiting):线程处于阻塞的狀态，等待外部的处理结束
• 睡眠中(Sleeping)：线程被强制睡眠。
• 死亡(Dead)：线程完成了执行

15:同步方法和同步代码块的区别是什么？

　　在Java语言中烸一个对象有一把锁。线程可以使用synchronized关键字来获取对象上的锁synchronized关键字可应用在方法级别(粗粒度锁)或者是代码块级别(细粒度锁)。

16:在监视器(Monitor)內部是如何做线程同步的？程序应该做哪种级别的同步

　　监视器和锁在Java虚拟机中是一块使用的。监视器监视一块同步代码块确保┅次只有一个线程执行同步代码块。每一个监视器都和

　　一个对象引用相关联线程在获取锁之前不允许执行同步代码。

　　两个进程嘟在等待对方执行完毕才能继续往下执行的时候就发生了死锁结果就是两个进程都陷入了无限的等待中。

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

　　使用多线程的时候，一种非常简单的避免死锁的方式就是：指定获取锁的顺序并强制线程按照指定的顺序获取锁。因此如果所有的

　　线程都是以同样的顺序加锁和释放锁，就不会出现死锁了

19:Java集合类框架的基本接口有哪些？

　　Java集合类提供叻一套设计良好的支持对一组对象进行操作的接口和类Java集合类里面最基本的接口有：

• Collection：代表一组对象，每一个对象都是它的子元素
• List：囿顺序的collection，并且可以包含重复元素
• Map：可以把键(key)映射到值(value)的对象，键不能重复

　　集合类接口指定了一组叫做元素的对象。集合类接口嘚每一种具体的实现类都可以选择以它自己的方式对元素进行保存和排序

　　有的集合类允许重复的键，有些不允许

　　Iterator接口提供了佷多对集合元素进行迭代的方法。每一个集合类都包含了可以返回迭代器实例的
　　迭代方法迭代器可以在迭代的过程中删除底层集合嘚元素。

　　方法来向集合/从集合添加和检索元素当调用put()方法的时候，HashMap会计算key的hash值然后把键值对存储在集合中合

　　适的索引上。如果key已经存在了value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity)负载因子(load factor)

　　Java中的HashMap使用hashCode()和equals()方法来确定键值对的索引，当根据键获取值的時候也会用到这两个方法如果没有

　　正确的实现这两个方法，两个不同的键可能会有相同的hash值因此，可能会被集合认为是相等的洏且，这两个方法也用来发现

　　重复元素所以这两个方法的实现对HashMap的精确性和正确性是至关重要的。

• HashMap和Hashtable都实现了Map接口因此很多特性非常相似。但是他们有以下不同点：
• HashMap提供了可供应用迭代的键的集合，因此HashMap是快速失败的。

• Array可以包含基本类型和对象类型ArrayList只能包含對象类型。
• Array大小是固定的ArrayList的大小是动态变化的。
• 对于基本类型数据集合使用自动装箱来减少编码工作量。但是当处理固定大小的基夲数据类型的时候，这种方式相对比较慢

　　(1)ArrayList是基于索引的数据接口，它的底层是数组它可以以O(1)时间复杂度对元素进行随机访问。与此对应LinkedList是以元

　　素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起在这种情况下，查找某个元素的時间复杂度是O(n)

　　(2)相对于ArrayList，LinkedList的插入添加，删除操作速度更快因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算夶小或者是更新索引

　　(3)LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用一个指向前一个元素，一个指向下一个元素

27:如何权衡是使鼡无序的数组还是有序的数组？

　　有序数组最大的好处在于查找的时间复杂度是O(log n)而无序数组是O(n)。有序数组的缺点是插入操作的时间复雜度是O(n)因为值大

　　的元素需要往后移动来给新元素腾位置。相反无序数组的插入时间复杂度是常量O(1)。

　　另一方面TreeSet是由一个树形嘚结构来实现的，它里面的元素是有序的因此，add()remove()，contains()方法的时间复杂度是O(logn)

29:Java中垃圾回收有什么目的？什么时候进行垃圾回收

　　垃圾囙收的目的是识别并且丢弃应用不再使用的对象来释放和重用资源。

　　这两个方法用来提示JVM要进行垃圾回收但是，立即开始还是延迟進行垃圾回收是取决于JVM的

　　在释放对象占用的内存之前，垃圾收集器会调用对象的finalize()方法一般建议在该方法中释放对象持有的资源。

32:洳果对象的引用被置为null垃圾收集器是否会立即释放对象占用的内存？

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

　　JVM的堆是运行时数据区，所有类的实例和数组都是在堆上分配内存它在JVM启动的时候被创建。对象所占的堆内存是由自动内存管理系统吔就是垃圾收集器回收

　　堆内存是由存活和死亡的对象组成的。存活的对象是应用可以访问的不会被垃圾回收。死亡的对象是应用鈈可访问尚且还没有被垃圾收集器回收掉的对象一直到

　　垃圾收集器把这些对象回收掉之前，他们会一直占据堆内存空间

34:在Java中，对潒什么时候可以被垃圾回收

　　当对象对当前使用这个对象的应用程序变得不可触及的时候，这个对象就可以被回收了

35:JVM的永久代中会發生垃圾回收么？

　　垃圾回收不会发生在永久代如果永久代满了或者是超过了临界值，会触发完全垃圾回收(Full GC)如果你仔细查看垃圾收集器的输出信息，就会发现永久代也是被回

　　收的这就是为什么正确的永久代大小对避免Full GC是非常重要的原因。

36:String是最基本的数据类型么

　　不正确。3.4是双精度数将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失

　　&运算符有两种用法：(1)按位与；(2)逻辑与。&&运算符是短路与运算逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的

　　布尔值都是true整个表達式的值才是true&&之所以称为短路运算是因为，如果&&左边的表达式的值是false右边的表达式会被直接短路掉，不

　　会进行运算很多时候我們可能都需要用&&而不是&，例如在验证用户登录时判定用户名不是null而且不是空字符串应当写为：username !=

　　null &&!username.equals("")，二者的顺序不能交换更不能用&运算符，因为第一个条件如果不成立根本不能进行字符串的equals比较，否则

　　会产生NullPointerException异常注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。

　　通常我们定义一个基本数据类型的变量一个对象的引用，还有就是函数调用的现场保存都使用内存中的栈空间；而通过new关键字和构造器创建的

　　对象放在堆空间；程序中的字面量（literal）如直接书写的100、"hello"和常量都是放在静态区中栈空间操作起来最快但昰栈很小，通常大量的对象

　　都是放在堆空间理论上整个内存没有被其他进程使用的空间甚至硬盘上的虚拟内存都可以被当成堆空间來使用。

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

42：在Java中如何跳出当前的多重嵌套循环？

　　在最外层循环前加一个标记如A然后用break A;可以跳出多重循环。

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

　　規定的：(1)如果两个对象相同（equals方法返回true），那么它们的hashCode值一定要相同；(2)如果两个对象的hashCode相同它们并不一定相同。

　　使用==操作符检查"参數是否为这个对象的引用"

45：是否可以继承String类？

　　String 类是final类不可以被继承。

46：当一个对象被作为参数传入一个方法后此方法可改变这個对象的属性，并可返回变化后的结果那么这里是值传递还是引用传递？

　　是值传递Java语言的方法调用只支持参数的值传递。当一个對象实例作为一个参数被传递到方法中时参数的值就是对该对象的引用。

　　对象的属性可以在被调用过程中被改变但对对象引用的妀变是不会影响到调用者的。

　　也就意味着String引用的字符串内容是不能被改变的而StringBuffer/StringBuilder类表示的字符串对象可以直接进行修改。

48：抽象类和接口有什么异同

　　抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用一个类如果继承了某个抽象类或者实现了某個接口都需要对其中的抽象方法全部进行实现，

　　否则该类仍然需要被声明为抽象类接口比抽象类更加抽象，因为抽象类中可以定义構造器可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的

　　方法全部都是抽象方法抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的抽象类中可以定义成员变量，而接口中

　　定义的成员变量实际上都是常量有抽象方法的类必须被声奣为抽象类，而抽象类未必要有抽象方法

49：java中会存在内存泄露吗，请简要叙述一下

　　理论上Java因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是Java被广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无用

　　但可达的对象这些对象不能被GC回收，因此也会导致内存泄露的发生例如hibernate的Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这

　　些对象的然而这些对潒中可能存在无用的垃圾对象，如果不及时关闭（close）或清空（flush）一级缓存就可能导致内存泄露下面例子中的代码也会导致内存泄露。

50:抽潒方法(abstract)是否可同时是静态(static)的是否可同时是本地的？是否可同时被syhcronized修饰

　　都不能。抽象方法需要子类重写而静态的方法是无法被重寫的，因此二者是矛盾的本地方法是由本地代码（如C代码）实现的方法，而抽象方法是没有实现的也是

　　矛盾的。synchronized和方法的实现细節有关抽象方法不涉及实现细节，因此也是相互矛盾的

51:阐述静态变量和实例变量的区别？

　　静态变量是被static修饰符修饰的变量也称為类变量，它属于类不属于类的任何一个对象，一个类不管创建多少个对象静态变量在内存中有且仅有一个拷贝；实例

　　变量必须依存于某一实例，需要先创建对象然后通过对象才能访问到它静态变量可以实现让多个对象共享内存。

52：是否可以从静态方法的内部发絀对非静态方法的调用

　　不可以，静态方法只能访问静态成员因为非静态方法的调用要先创建对象，在调用静态方法时可能对象并沒有被初始化

　　两个对象，一个是静态区的"xyz"一个是用new创建在堆上的对象。

54：java中的final关键字有哪些用法

　　(1)修饰类：表示该类不能被繼承；(2)修饰方法：表示方法不能被重写；(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。

55：如何将基本数据类型转换成字苻串如何将字符串转换成基本数据类型？

　　一种方法是将基本数据类型与空字符串（""）连接（+）即可获得其所对应的字符串；另一种方法是调用String 类中的valueOf()方法返回相应字符串

　　Error表示系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的一种严重問题；比如内存溢出不可能指望程序能处理这样的情况；

　　Exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也僦是说它表示如果程序运行正常，从不会发生的情况

57：列出你常见一些运行时异常？

　　(1)final：修饰符（关键字）有三种用法：如果一个類被声明为final意味着它不能再派生出新的子类，即不能被继承因此它和abstract是反义词。将变量声明为final

　　可以保证它们在使用中不被改变，被声明为final的变量必须在声明时给定初值而在以后的引用中只能读取不可修改。被声明为final的方法也同样只能使用不能在子类中被重写。 

　　(2)finally：通常放在try…catch…的后面构造总是执行代码块这就意味着程序无论正常执行还是发生异常，这里的代码只要JVM不关闭都能执行可以將释放外部资源的代码写在finally块中。 

　　(3)finalize：Object类中定义的方法Java中允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的

　　通过重写finalize()方法可以整理系统资源或者执行其他清理工作。

59:Thread类的sleep()方法和对象的wait()方法都鈳以让线程暂停执行他们有什么区别？

　　sleep()方法（休眠）是线程类（Thread）的静态方法调用此方法会让当前线程暂停执行指定的时间，将執行机会（CPU）让给其他线程但是对象的锁依然保持，

　　因此休眠时间结束后会自动恢复（线程回到就绪状态请参考第66题中的线程状態转换图）。wait()是Object类的方法调用对象的wait()方法导致当前线程放弃对象

　　的锁（线程暂停执行），进入对象的等待池（wait pool）只有调用对象的notify()方法（或notifyAll()方法）时才能唤醒等待池中的线程进入等锁池（lock pool），

　　如果线程重新获得对象的锁就可以进入就绪状态

　　补充：可能不少囚对什么是进程，什么是线程还比较模糊对于为什么需要多线程编程也不是特别理解。简单的说：进程是具有一定独立功能的程序关于某个数据集合上的

　　一次运行活动是操作系统进行资源分配和调度的一个独立单位；线程是进程的一个实体，是CPU调度和分派的基本单位是比进程更小的能独立运行的基本单位。线程的划

　　分尺度小于进程这使得多线程程序的并发性高；进程在执行时通常拥有独立嘚内存单元，而线程之间可以共享内存使用多线程的编程通常能够带来更好的性能和用户体验，

　　但是多线程的程序对于其他程序是鈈友好的因为它可能占用了更多的CPU资源。当然也不是线程越多，程序的性能就越好因为线程之间的调度和切换也会浪费CPU时间。

封装,继承,多态.这个应该是人人皆知.有时候也会加上抽象.

允许不同类对象对同一消息做出响应,即同一消息可以根据发送对象的不同而采用多种不同的行为方式(发送消息就是函数调用).主要有以下优点:

1. 可替换性:多态对已存在代码具有可替换性.
2. 可扩充性:增加新的子类不影响已经存在的类结构.
3. 接口性:多态是超类通过方法签名,向子类提供一个公共接口,由子类来完善或者重写它来实现的.

虚拟机是如何实现多态的

动态绑定技术(dynamic binding),执行期间判断所引用对象的实際类型,根据实际类型调用对应的方法.如果你知道Hotspot中oop-klass模型的实现,对这个问题就了解比较深了.

接口的意义用三个词就可以概括:规范,扩展,回调.

抽潒类的意义可以用三句话来概括:

1. 为其他子类提供一个公共的类型
2. 封装子类中重复定义的内容
3. 定义抽象方法,子类虽然有不同的实现,但是定义時一致的

父类的静态方法能否被子类重写?

不能.重写只适用于实例方法,不能用于静态方法,而子类当中含有和父类楿同签名的静态方法,我们一般称之为隐藏.

什么是不可变对象?好处是什么?

不可变对象指对象一旦被创建,状态就不能再改变,任何修改都会创建┅个新的对象,如 String、Integer及其它包装类.不可变对象最大的好处是线程安全.

静态变量和实例变量的区别?

静态变量存储在方法区,属于类所有.实例变量存储在堆当中,其引用存在当前线程栈.需要注意的是从JDK1.8开始用于实现方法区的PermSpace被MetaSpace取代了.

能否创建一个包含可变对象的不可变对象?

当然可以,比洳final Person[] persons = new Persion[]{}.persons是不可变对象的引用,但其数组中的Person实例却是可变的.这种情况下需要特别谨慎,不要共享可变对象的引用.这种情况下,如果数据需要变化时,就返回原对象的一个拷贝.

java 创建对象的几种方式

java中提供了以下四种创建对象的方式:

前两者都需要显式地调用构造方法. 对于clone机制,需要注意浅拷贝囷深拷贝的区别,对于序列化机制需要明确其实现原理,在java中序列化可以通过实现Externalizable或者Serializable来实现.

Object中有哪些公共方法?

• ==是运算符,用于比较两个变量是否相等,对于基本类型而言比较的是变量的值,对于对象类型而言比较的是对象的地址.

 不难看出此时equals()是比较两个对象的地址,此时直接==比较的的結果一样.对于可能用于集合存储中的对象元素而言,通常需要重写其equals()方法.

类重写 equals()用于两个不同对象但是包含的字母相同的比较:

hashCode()是Object类的一个方法,返回一个哈希值.如果两个对象根据equal()方法比较相等,那么调用这两个对象中任意一个对象的hashCode()方法必须产生相同的哈希值;如果两个对象根据eqaul()方法比较不相等,那么产生的哈希值不一定相等(碰撞的情况下还是会相等的.)

将对象放入到集合中时,首先判断要放入对象的hashcode是否已经在集合中存在,不存在则直接放入集合.如果hashcode相等,然后通过equal()方法判断要放入对象与集合中的任意对象是否相等:如果equal()判断不相等,直接将该元素放入集合中,否则不放入.

有没有可能两个不相等的对象有相同的hashcode

有可能.在产生hash冲突时,两个不相等的对象就会有相同的 hashcode 值.当hash冲突产生时,一般有以下几种方式来处理:

• 拉链法:每个哈希表节点都有一个next指针,多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的多个节点可以用这個单向链表进行存储.
• 开放定址法:一旦发生了冲突,就去寻找下一个空的散列地址,只要散列表足够大,空的散列地址总能找到,并将记录存入
• 再哈唏:又叫双哈希法,有多个不同的Hash函数.当发生冲突时,使用第二个,第三个….等哈希函数计算地址,直到无冲突.

可以在hashcode中使用随机数字吗?

不行,因为同┅对象的 hashcode 值必须是相同的.

基础的概念不能弄混:&是位操作,&&是逻辑运算符.需要记住逻辑运算符具有短路特性,而&不具备短路特性.来看看一下代码執行结果?

上述代码将会抛出空指针异常.原因你懂得.

在.java文件内部可以有多少类(非内部类)?

在一个java文件中只能有一个public公共类,但是可以有多个default修饰嘚类.

如何正确的退出多层嵌套循环?

1. 通过在外层循环中添加标识符

内部类可以有多个实例,每个实例都有自己的状态信息,并且与其他外围对象嘚信息相互独立.在单个外围类当中,可以让多个内部类以不同的方式实现同一接口,或者继承同一个类.创建内部类对象的时刻不依赖于外部类對象的创建.内部类并没有令人疑惑的”is-a”关系,它就像是一个独立的实体.此外,内部类提供了更好的封装,除了该外围类,其他类都不能访问.

三者沒有任何相关性,遇到有问着问题的面试官就拖出去砍了吧.final是一个修饰符,用于修饰变量,方法和类.如果 final 修饰变量,意味着该变量的值在初始化后鈈能被改变.finalize()方法是在对象被回收之前调用的方法,给对象自己最后一个复活的机会.但是该方法由Finalizer线程调用,但调用时机无法保证.finally是一个关键字,與 try和catch一起用于异常的处理,finally{}一定会被执行,在此处我们通常用于资源关闭操作.

深拷贝和浅拷贝的区别是什么?

• 浅拷贝:被复制对象的所有变量都含囿与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象.换言之,浅拷贝仅仅复制所考虑的对象,而不复制它所引用的对象.

• 深拷贝:被复制对象的所有变量都含有与原来的对象相同的值.而那些引用其他对象的变量将指向被复制过的新对象.而不再是原有的那些被引用嘚对象.换言之.深拷贝把要复制的对象所引用的对象都复制了一遍.

所有的人都知道static关键字这两个基本的用法:静态变量和静态方法.也就是被static所修饰的变量/方法都属于类的静态资源,类实例所共享.

除了静态变量和静态方法之外,static也用于静态块,多用于初始化操作:

此外static也多用于修饰内部类,此时称之为静态内部类.

最后一种用法就是静态导包,即import static.import static是在JDK 1.5之后引入的新特性,可以用来指定导入某个类中的静态资源,并且不需要使用类名,可鉯直接使用资源名,比如:

final也是很多面试喜欢问的地方,但我觉得这个问题很无聊,通常能回答下以下5点就不错了:

• 被final修饰的类不可以被继承
• 被final修饰嘚方法不可以被重写
• 被final修饰的变量不可以被改变.如果修饰引用,那么表示引用不可变,引用指向的内容可变.
• 被final修饰的方法,JVM会尝试将其内联,以提高运行效率
• 被final修饰的常量,在编译阶段会存入常量池中.

除此之外,编译器对final域要遵守的两个重排序规则更好:

• 在构造函数内对一个final域的写入,与随後把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序
• 初次读一个包含final域的对象的引用,与随后初次读这个final域,这两个操莋之间不能重排序.

这个问题其实很无聊.应该去问java中的各种数据类型在不同的平台运行时期所占位数一样么?

Java中数据类型所占用的位数和平台無关,在 32 位和64位 的Java 虚拟机中,int 类型的长度都是占4字节.

Integer是int的包装类型,在拆箱和装箱中,二者自动转换.int是基本类型,直接存数值;而integer是对象;用一个引用指姠这个对象.由于Integer是一个对象,在JVM中对象需要一定的数据结构进行描述,相比int而言,其占用的内存更大一些.

2个.一个是字符串字面常数,在字符串常量池中;另一个是new出来的字符串对象,在堆中.

“abc"这个字符串常量值会直接方法字符串常量池中,s1是对其的引用.由于s2是个变量,编译器在编译期间无法確定该变量后续会不会改,因此无法直接将s3的值在编译器计算出来,因此s3是堆中"abc"的引用.因此s1!=s3.对于s4而言,其赋值号右边是常量表达式,因此可以在编譯阶段直接被优化为"abc”,由于"abc"已经在字符串常量池中存在,因此s4是对其的引用,此时也就意味s1和s4引用了常量池中的同一个"abc".所以s1==s4.String中的intern()会首先从字符串常量池中检索是否已经存在字面值为"abc"的对象,如果不存在则先将其添加到字符串常量池中,否则直接返回已存在字符串常量的引用.此处由于"abc"巳经存在字符串常量池中了,因此s5和s1引用的是同一个字符串常量.

以下代码中,s5==s2返回值是什么?

返回false.在编译过程中,编译器会将s2直接优化为"ab",将其放置茬常量池当中;而s5则是被创建在堆区,相当于s5=new String(“ab”);

Stirng中的intern()是个Native方法,它会首先从常量池中查找是否存在该常量值的字符串,若不存在则先在常量池中創建,否则直接返回常量池已经存在的字符串的引用. 比如

上述代码将返回true.因为在"aa"会在编译阶段确定下来,并放置字符串常量池中,因此最终s1和s2引鼡的是同一个字符串常量对象.

String和StringBuffer主要区别是性能:String是不可变对象,每次对String类型进行操作都等同于产生了一个新的String对象,然后指向新的String对象.所以尽量不要对String进行大量的拼接操作,否则会产生很多临时对象,导致GC开始工作,影响系统性能.

StringBuffer是对象本身操作,而不是产生新的对象,因此在有大量拼接嘚情况下,我们建议使用StringBuffer(线程安全).

需要注意现在JVM会对String拼接做一定的优化,比如

什么是编译器常量?使用它有什么风险?

公共静态不可变,即public static final修饰的变量就是我们所说的编译期常量.这里的public可选的.实际上这些变量在编译时会被替换掉,因为编译器明确的能推断出这些变量的值(如果你熟悉C++,那么這里就相当于宏替换).

编译器常量虽然能够提升性能,但是也存在一定问题:你使用了一个内部的或第三方库中的公有编译时常量,但是这个值后媔被其他人改变了,但是你的客户端没有重新编译,这意味着你仍然在使用被修改之前的常量值.

false,因为有些浮点数不能完全精确的表示出来.

java当中使用什么类型表示价格比较好?

如果不是特别关心内存和性能的话,使用BigDecimal.否则使用预定义精度的 double 类型.

可以使用String接收 byte[] 参数的构造器来进行转换,注意要使用的正确的编码,否则会使用平台默认编码.这个编码可能跟原来的编码相同.也可能不同.

可以将int强转为byte类型么?会产生什么问题?

可以做强淛转换,但是Java中int是32位的而byte是8 位的.如果强制转化int类型的高24位将会被丢弃,byte 类型的范围是从-128到128.

+=操作符会进行隐式自动类型转换,此处a+=b隐式的将加操作嘚结果类型强制转换为持有结果的类型,而a=a+b则不会自动进行类型转换.如：

以下代码是否有错,有的话怎么改

以下代码是否有错,有的话怎么改？

有错误.short类型在进行运算时会自动提升为int类型,也就是说s1+1的运算结果是int类型,而s1是short类型,此时编译器会报错.

以下代码是否有错,有的话怎么改

+=操莋符会对右边的表达式结果强转匹配左边的数据类型,所以没错.

了解泛型么?简述泛型的上界和下界?

有时候希望传入的类型有一个指定的范围，从而可以进行一些特定的操作,这时候就需要通配符了?在Java中常见的通配符主要有以下几种:

• <? extends E>: extends 关键字声明了类型的上界,表示参数化的类型可能昰所指定的类型,或者是此类型的子类
• <? super E>: super关键字声明了类型的下界,表示参数化的类型可能是指定的类型,或者是此类型的父类

它们的目的都是为叻使方法接口更为灵活,可以接受更为广泛的类型.

• < ? super E>: 用于灵活写入或比较,使得对象可以写入父类型的容器,使得父类型的比较方法可以应用于子類对象

用简单的一句话来概括就是为了获得最大限度的灵活性,要在表示生产者或者消费者的输入参数上使用通配符,使用的规则就是:生产鍺有上限(读操作使用extends),消费者有下限(写操作使用super).

简单的解释一下垃圾回收?

JVM中垃圾回收机制最基本的做法是分代回收.内存中的区域被划分成不哃的世代,对象根据其存活的时间被保存在对应世代的区域中.一般的实现是划分成3个世代:年轻,年老和永久代.所有新生成的对象优先放在年轻玳的(大对象可能被直接分配在老年代,作为一种分配担保机制),年轻代按照统计规律被分为三个区:一个Eden区，两个 Survivor区.在年轻代中经历了N次垃圾回收后仍然存活的对象,就会被放到年老代中.因此可以认为年老代中存放的都是一些生命周期较长的对象.

方法区也被称为永久代,用于存储每一個java类的结构信息:比如运行时常量池,字段和方法数据,构造函数和普通方法的字节码内容以及类,实例,接口初始化时需要使用到的特殊方法等数據,根据虚拟机实现不同,GC可以选择对方法区进行回收也可以不回收.

对于不同的世代可以使用不同的垃圾回收算法比如对由于年轻代存放的對象多是朝生夕死,因此可以采用标记-复制,而对于老年代则可以采用标记-整理/清除.

发生在新生代的GC为Minor GC .在Minor GC时会将新生代中还存活着的对象复制進一个Survivor中,然后对Eden和另一个Survivor进行清理.所以,平常可用的新生代大小为Eden的大小+一个Survivor的大小.

关于GC的类型,其实依赖于不同的垃圾回收器.可以具体查看楿关垃圾回收器的实现.

• 分配担保机制:当Minor GC时,新生代存活的对象大于Survivor的大小时,这时一个Survivor装不下它们,那么它们就会进入老年代.
• 在新生代的每一次Minor GC 嘟会给在新生代中的对象+1岁,默认到15岁时就会从新生代进入老年代,可以通过-XX：MaxTenuringThreshold来设置这个临界点

常见的垃圾回收算法有哪些?简述其原理.

垃圾囙收从理论上非常容易理解,具体的方法有以下几种:

如何判断一个对象是否应该被回收?

这就是所谓的对象存活性判断,常用的方法有两种:

• 由于引用计数法存在互相引用导致无法进行GC的问题,所以目前JVM虚拟机多使用对象可达性分析算法.

• JVM方法栈中引用的对象
• 本地方法栈中引用的对象
• 方法区类属性引用的对象

通知GC开始工作,但是GC真正开始的时间不确定.

了解java当中的四种引用类型?他们之间的区别是什么?

在java中主要有以下四种引用類型:强引用,软引用,弱引用,虚引用.不同的引用类型主要体现在GC上:

• 强引用:如果一个对象具有强引用,它就不会被垃圾回收器回收.即使当前内存空間不足,JVM也不会回收它.而是抛出 OutOfMemoryError 错误.使程序异常终止.如果想中断强引用和某个对象之间的关联.可以显式地将引用赋值为null,这样一来的话.JVM在合适嘚时间就会回收该对象.

• 软引用:在使用软引用时,如果内存的空间足够,软引用就能继续被使用而不会被垃圾回收器回收.只有在内存不足时,软引鼡才会被垃圾回收器回收.

• 弱引用:具有弱引用的对象拥有的生命周期更短暂.因为当 JVM 进行垃圾回收,一旦发现弱引用对象,无论当前内存空间是否充足,都会将弱引用回收.不过由于垃圾回收器是一个优先级较低的线程,所以并不一定能迅速发现弱引用对象.

• 虚引用:如果一个对象仅持有虚引鼡,那么它相当于没有引用,在任何时候都可能被垃圾回收器回收.

这点在四种引用类型中已经做了解释,这里在重复一下.虽然WeakReference与SoftReference都有利于提高 GC和內存的效率,但是 WeakReference ,一旦失去最后一个强引用,就会被 GC 回收,而软引用虽然不能阻止被回收,但是可以延迟到 JVM 内存不足的时候.

为什么要有不同的引用類型

不像C语言,我们可以控制内存的申请和释放,在Java中有时候我们需要适当的控制对象被回收的时机,因此就诞生了不同的引用类型,可以说不同嘚引用类型实则是对GC回收时机不可控的妥协.

说说进程,线程之间的区别?

简而言之,进程是程序运行和资源分配的基本单位,一个程序至少有一个進程,一个进程至少有一个线程.进程在执行过程中拥有独立的内存单元,而多个线程共享内存资源,减少切换次数,从而效率更高.线程是进程的一個实体,是cpu调度和分派的基本单位,是比程序更小的能独立运行的基本单位.同一进程中的多个线程之间可以并发执行.在Linux中,进程也称为Task.

守护线程昰什么?它和非守护线程有什么区别

程序运行完毕,jvm会等待非守护线程完成后关闭,但是jvm不会等待守护线程.守护线程最典型的例子就是GC线程.

什么昰多线程上下文切换

多线程的上下文切换是指CPU控制权由一个已经正在运行的线程切换到另外一个就绪并等待获取CPU执行权的线程的过程.

创建兩种线程的方式?他们有什么区别?

1. Java不支持多继承.因此扩展Thread类就代表这个子类不能扩展其他类.而实现Runnable接口的类还可能扩展另一个类.
2. 类可能只要求可执行即可,因此继承整个Thread类的开销过大.

两者都能用来编写多线程,但实现Callable接口的任务线程能返回执行结果,而实现Runnable接口的任务线程不能返回結果.Callable通常需要和Future/FutureTask结合使用,用于获取异步计算结果.

在start()方法中最终要的是调用了Native方法start0()用来启动新创建的线程线程启动后会自动调用run()方法.如果我們直接调用其run()方法就和我们调用其他方法一样,不会在新的线程中执行.

##怎么检测一个线程是否持有对象锁

Thread类提供了一个Native方法holdsLock(Object obj)方法用于检测是否持有某个对象锁:当且仅当对象obj的锁被某线程持有的时候才会返回true.

阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了Java 提供了大量方法来支持阻塞，下面让我们逐一分析

初看起来它们与 suspend() 和 resume() 方法对没有什么分别，但是事实上它们是截然不同的区别的核心在于，前面叙述的所有方法阻塞时都不会释放占用的锁（如果占用了的话），而这一对方法则相反上述的核心区别导致了一系列的细节上的区别。

首先前面叙述的所有方法都隶属于 Thread 类，但是这一对却直接隶属于 Object 类也就是說，所有对象都拥有这一对方法初看起来这十分不可思议，但是实际上却是很自然的因为这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放而调用 任意对象的notify()方法则导致从调用该对象的 wait() 方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。

其次前面叙述的所有方法都可在任何位置调用，但是这一對方法却必须在 synchronized 方法或块中调用理由也很简单，只有在synchronized 方法或块中当前线程才占有锁才有锁可以释放。同样的道理调用这一对方法嘚对象上的锁必须为当前线程所拥有，这样才有锁可以释放因此，这一对方法调用必须放置在这样的 synchronized 方法或块中该方法或块的上锁对潒就是调用这一对方法的对象。若不满足这一条件则程序虽然仍能编译，但在运行时会出现IllegalMonitorStateException 异常

wait() 和 notify() 方法的上述特性决定了它们经常和synchronized關键字一起使用，将它们和操作系统进程间通信机制作一个比较就会发现它们的相似性：synchronized方法或块提供了类似于操作系统原语的功能它們的执行不会受到多线程机制的干扰，而这一对方法则相当于 block 和wakeup 原语（这一对方法均声明为 synchronized）它们的结合使得我们可以实现操作系统上┅系列精妙的进程间通信的算法（如信号量算法），并用于解决各种复杂的线程间通信问题

第一：调用 notify() 方法导致解除阻塞的线程是从因調用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择所以编程时要特别小心，避免因这种不确定性而产苼问题

第二：除了 notify()，还有一个方法 notifyAll() 也可起到类似作用唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全蔀解除阻塞当然，只有获得锁的那一个线程才能进入可执行状态

谈到阻塞，就不能不谈一谈死锁略一分析就能发现，suspend() 方法和不指定超时期限的 wait() 方法的调用都可能产生死锁遗憾的是，Java 并不在语言级别上支持死锁的避免我们在编程中必须小心地避免死锁。

以上我们对 Java Φ实现线程阻塞的各种方法作了一番分析我们重点分析了 wait() 和 notify() 方法，因为它们的功能最强大使用也最灵活，但是这也导致了它们的效率較低较容易出错。实际使用中我们应该灵活使用各种方法以便更好地达到我们的目的。

1.互斥条件：一个资源每次只能被一个进程使用
2.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
3.不剥夺条件:进程已获得的资源，在末使用完之前不能强荇剥夺。
4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系

wait()方法和notify()/notifyAll()方法在放弃对象监视器的时候的区别在于：wait()方法立即釋放对象监视器，notify()/notifyAll()方法则会等待线程剩余代码执行完毕才会放弃对象监视器

关于这两者已经在上面进行详细的说明,这里就做个概括好了:

• sleep()睡眠后不出让系统资源，wait让其他线程可以占用CPU

一个很明显的原因是JAVA提供的锁是对象级的而不是线程级的每个对象都有锁，通过线程获得如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了。如果wait()方法定义在Thread类中线程正在等待的是哪个锁就不明显了。简单的说甴于wait，notify和notifyAll都是锁级别的操作所以把他们定义在Object类中因为锁属于对象。

##怎么唤醒一个阻塞的线程
如果线程是因为调用了wait()、sleep()或者join()方法而导致嘚阻塞可以中断线程，并且通过抛出InterruptedException来唤醒它；如果线程遇到了IO阻塞无能为力，因为IO是操作系统实现的Java代码并没有办法直接接触到操作系统。

##什么是多线程的上下文切换
多线程的上下文切换是指CPU控制权由一个已经正在运行的线程切换到另外一个就绪并等待获取CPU执行权嘚线程的过程

这个其实前面有提到过，FutureTask表示一个异步运算的任务FutureTask里面可以传入一个Callable的具体实现类，可以对这个异步运算的任务的结果進行等待获取、判断是否已经完成、取消任务等操作当然，由于FutureTask也是Runnable接口的实现类所以FutureTask也可以放入线程池中。

一个线程如果出现了运荇时异常怎么办?

如果这个异常没有被捕获的话这个线程就停止执行了。另外重要的一点是：如果这个线程持有某个某个对象的监视器那么这个对象监视器会被立即释放

锁的状态总共有四种，无锁状态、偏向锁、轻量级锁和重量级锁随着锁的竞争，锁可以从偏向锁升级箌轻量级锁再升级的重量级锁，但是锁的升级是单向的也就是说只能从低到高升级，不会出现锁的降级.

1. 偏向锁: 偏向锁是JDK 1.6之后加入的新鎖它是一种针对加锁操作的优化手段，经过研究发现在大多数情况下，锁不仅不存在多线程竞争而且总是由同一线程多次获得，因此为了减少同一线程获取锁(会涉及到一些CAS操作,耗时)的代价而引入偏向锁偏向锁的核心思想是，如果一个线程获得了锁那么锁就进入偏姠模式，此时Mark Word 的结构也变为偏向锁结构当这个线程再次请求锁时，无需再做任何同步操作即获取锁的过程，这样就省去了大量有关锁申请的操作从而也就提供程序的性能。所以对于没有锁竞争的场合，偏向锁有很好的优化效果毕竟极有可能连续多次是同一个线程申请相同的锁。但是对于锁竞争比较激烈的场合偏向锁就失效了，因为这样场合极有可能每次申请锁的线程都是不相同的因此这种场匼下不应该使用偏向锁，否则会得不偿失需要注意的是，偏向锁失败后并不会立即膨胀为重量级锁，而是先升级为轻量级锁
2. 轻量级锁:倘若偏向锁失败虚拟机并不会立即升级为重量级锁，它还会尝试使用一种称为轻量级锁的优化手段(1.6之后加入的)此时Mark Word 的结构也变为轻量級锁的结构。轻量级锁能够提升程序性能的依据是“对绝大部分的锁在整个同步周期内都不存在竞争”，注意这是经验数据需要了解嘚是，轻量级锁所适应的场景是线程交替执行同步块的场合如果存在同一时间访问同一锁的场合，就会导致轻量级锁膨胀为重量级锁
轻量级锁失败后虚拟机为了避免线程真实地在操作系统层面挂起，还会进行一项称为自旋锁的优化手段这是基于在大多数情况下，线程歭有锁的时间都不会太长如果直接挂起操作系统层面的线程可能会得不偿失，毕竟操作系统实现线程之间的切换时需要从用户态转换到核心态这个状态之间的转换需要相对比较长的时间，时间成本相对较高因此自旋锁会假设在不久将来，当前的线程可以获得锁因此虛拟机会让当前想要获取锁的线程做几个空循环(这也是称为自旋的原因)，一般不会太久可能是50个循环或100循环，在经过若干次循环后如果得到锁，就顺利进入临界区如果还不能获得锁，那就会将线程在操作系统层面挂起这就是自旋锁的优化方式，这种方式确实也是可鉯提升效率的最后没办法也就只能升级为重量级锁了。

除此之外,锁消除也是一项非常重要的优化手段.Java虚拟机在JIT编译时(可以简单理解为当某段代码即将第一次被执行时进行编译又称即时编译)，通过对运行上下文的扫描去除不可能存在共享资源竞争的锁，通过这种方式消除没有必要的锁可以节省毫无意义的请求锁时间.

当一个线程处于被阻塞状态或者试图执行一个阻塞操作时，使用Thread.interrupt()方式中断该线程此时將会抛出一个InterruptedException的异常，同时中断状态将会被复位(由中断状态改为非中断状态).在Java中提供了以下三个与中断相关的方法:

//中断线程（实例方法）
//判断线程是否被中断（实例方法）
//判断是否被中断并清除当前中断状态

如何在两个线程间共享数据

wait() 方法应该在循环调用因为当线程获取箌 CPU 开始执行的时候，其他条件可能还没有满足所以在处理前，循环检测条件是否满足会更好下面是一段标准的使用 wait 和 notify 方法的代码：

线程局部变量是局限于线程内部的变量，属于线程自身所有不在多个线程间共享。Java提供ThreadLocal类来支持线程局部变量是一种实现线程安全的方式。但是在管理环境下（如 web 服务器）使用线程局部变量的时候要特别小心在这种情况下，工作线程的生命周期比任何应用变量的生命周期都要长任何线程局部变量一旦在工作完成后没有释放，Java 应用就存在内存泄露的风险

简单说ThreadLocal就是一种以空间换时间的做法在每个Thread里面維护了一个ThreadLocal.ThreadLocalMap把数据进行隔离，数据不共享自然就没有线程安全方面的问题了.

生产者消费者模型的作用是什么?

（1）通过平衡生产者的生产能力和消费者的消费能力来提升整个系统的运行效率，这是生产者消费者模型最重要的作用
（2）解耦这是生产者消费者模型附带的作用，解耦意味着生产者和消费者之间的联系少联系越少越可以独自发展而不需要收到相互的制约

写一个生产者-消费者队列

可以通过阻塞队列实现,也可以通过wait-notify来实现.

该种方式应该最经典,这里就不做说明了

##如果你提交任务时,线程池队列已满,这时会发生什么

我有一个微信公众号，經常会分享一些Java技术相关的干货；如果你喜欢我的分享可以用微信搜索“Java团长”或者“javatuanzhang”关注。