一、String和Stringbuffer和StringBuilder的区别？
String：字符串常量
StringBuffer：字符串变量；线程安全的
StringBuilder：字符串变量；线程非安全的
三者执行速度比较：StringBuilder > StringBuffer > String
1.String类的内容一旦声明后是不可改变的，改变的只是其内存的指向，而StringBuffer类的对象内容是可以改变的。
2.对于StringBuffer，不能像String那样直接通过赋值的方式完成对象实例化，必须通过构造方法的方式完成。
3.StringBuffer在进行字符串处理时，不生成新的对象，在内存使用上要优于字符串类。所以在实际使用时，如果经常需要对一个字符串进行修改，例如插入，删除等操作，使用StringBuffer要更加适合一些。
4.StringBuilder，StringBuffer 之间的最大不同在于 StringBuilder 的方法是线程非安全的（不能同步访问）。
5.StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类，然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
StringBuilder与StringBuffer二者的区别主要是在运行速度和线程安全这两方面。
1、StringBuffer 与 StringBuilder 中的方法和功能完全是等价的
2、只是StringBuffer 中的方法大都采用了 synchronized 关键字进行修饰，因此是线程安全的，而 StringBuilder 没有这个修饰，可以被认为是线程不安全的。
3、在单线程程序下，StringBuilder效率更快，因为它不需要加锁，不具备多线程安全而StringBuffer则每次都需要判断锁，效率相对更低。
三者使用的总结：1.如果要操作少量的数据用 = String
2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
二、ArrayList,Vector, LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized思路方法(线程安全) ，通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项前后项即可，所以插入速度较快
三、HashMap和Hashtable的区别
HashMap：①线程非安全的
②性能方面：由于线程是非安全的，所以每个方法不需要阻塞其他线程，所以性能要优于HashTable
③空值问题：允许键值为Null
④实现方式：继承AbstractMap类
⑤扩容：源码中初始值 1 << 4 ,初始值为16，负载因子默认为0.75（详细请看该链接下《说说hashMap 使用的是哪种数据结构》链接内容）
⑥迭代器：HashMap 中的 Iterator 迭代器是 fail-fast 的，当其他线程改变了HashMap 的结构，如：增加、删除元素，将会抛出 ConcurrentModificationException 异常，而 Hashtable 则不会。
HashTable：①线程安全的，线程安全的原因是所有的元素操作都是用synchronized修饰的，而HashMap没有
②性能方面：由于是线程安全的，所以每个方法需要阻塞其他线程，所以性能要弱于HashMap
③空值问题：不允许键值为null
④实现方式：继承Dictionary类
⑤扩容：源码中初始值为11，负载因子默认为0.75
⑥迭代器： Hashtable 的 Enumerator 不是 fail-fast 的，Enumeration是个接口，不是类，再次，这个东西就是为了实现遍历的，现在已经被迭代器Iterator取代了，Enumeration和iterator最主要区别，其实就是Iterator可以删除元素，但是Enumration却不能。
最大的区别是，Hashtable的思路方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的思路方法实现同步，而HashMap 就必须为的提供外同步。
四、 final, finally, finalize的区别
final：用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally：是异常处理语句结构的一部分，表示总是执行。
finalize：是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。
五、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?
swtich中只能用byte short int char
六、线程的几种状态
创建：当new了一个线程，并没有调用start之前，线程处于创建状态；
就绪：当调用了start之后，线程处于就绪状态，这是，线程调度程序还没有设置执行当前线程；
运行：线程调度程序执行到线程时，当前线程从就绪状态转成运行状态，开始执行run方法里边的代码；
阻塞：线程在运行的时候，被暂停执行（通常等待某项资源就绪后在执行，sleep、wait可以导致线程阻塞），这是该线程处于阻塞状态；
死亡：当一个线程执行完run方法里边的代码或调用了stop方法后，该线程结束运行
生命周期如下图：
七、多线程有几种实现方式?
多线程的几种实现方式：①继承Thread类，重写Run()
②实现Runnable接口,创建步骤如下：
定义一个类实现Runnable接口，作为线程任务类
重写run方法，并实现方法体，方法体的代码就是线程所执行的代码
定义一个可以运行的类，并在main方法中创建线程任务类
创建Thread类，并将线程任务类做为Thread类的构造方法传入
启动线程
③使用内部类的方式：将Thread和Runnable作为内部子类实现
④定时器：定时器Timer（JDK提供API）是一个基于线程的工具类，可以定时的来执行某个任务。 提供定时任务的三方框架：Spring的Schedule和Quartz框架
⑤带返回值的线程实现方式：
1)实现Callable接口，实现call(),这个接口类似于Runnable接口，但比Runnable接口更加强大， 增加了异常和返回值。
2)创建一个FutureTask，指定Callable对象，做为线程任务。
3)创建线程，指定线程任务。
4)启动线程
⑥基于线程池的方式:
概念：一些线程的集合称为线程池，线程池可以很好的提高性能，线程池在系统启动时创建大量的空闲线程，程序将任务提交以后，线程就会启动一个线程执行该任务，任务结束以后，线程并不会死亡，而是返回线程池，成为空闲状态，当代执行下一个任务。
工作机制：①在线程池的编程模式下，任务是提交给整个线程池的，而不是直接提交给某一个线程，线程池在获取到任务后，会寻找是否有空闲的线程，如果有则将任务提交给这个线程
②一个线程只能执行一个任务，但可以同时向一个线程池提交多个任务
使用线程池的原因：多线程运行时，系统会不断的启动和关闭新线程，成本高，会过度消耗资源，以及过度的切换线程，会造成系统资源的崩溃，所以，线程池是最优选择
四种常见的线程池：
①线程池的返回值都是ExecutorService，ExecutorService是Java提供的用于管理线程池的类。该类作用是：控制线程数量和重用线程
②四种线程池介绍：
1）Executors.newCacheThreadPool():可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务
2)Executors.newFixedThreadPool(int n):创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。
3)Executors.newScheduledThreadPool(int n):创建一个定长线程池，支持定时及周期性任务执行
4)Executors.newSingleThreadExecutor():创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
八、线程池的参数总结：
①corePoolSize：核心线程数
* 核心线程会一直存活，及时没有任务需要执行
* 当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理
* 设置 allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭
②queueCapacity：任务队列容量（阻塞队列）
* 当核心线程数达到最大时，新任务会放在队列中排队等待执行
③maxPoolSize：最大线程数
* 当线程数>=corePoolSize，且任务队列已满时。线程池会创建新线程来处理任务
* 当线程数=maxPoolSize，且任务队列已满时，线程池会拒绝处理任务而抛出异常
④keepAliveTime：线程空闲时间
* 当线程空闲时间达到 keepAliveTime时，线程会退出，直到线程数量=corePoolSize
* 如果 allowCoreThreadTimeout=true，则会直到线程数量=0
⑤allowCoreThreadTimeout：允许核心线程超时
⑥rejectedExecutionHandler：任务拒绝处理器
* 两种情况会拒绝处理任务：
- 当线程数已经达到 maxPoolSize ，切队列已满，会拒绝新任务
- 当线程池被调用 shutdown()后，会等待线程池里的任务执行完毕，再shutdown。如果在调用 shutdown()和线程池真正 shutdown之间提交任务，会拒绝新任务
* 线程池会调用 rejectedExecutionHandler来处理这个任务。如果没有设置默认是AbortPolicy，会抛出异常
* ThreadPoolExecutor类有几个内部实现类来处理这类情况：
- AbortPolicy 丢弃任务，抛运行时异常
- CallerRunsPolicy 执行任务
- DiscardPolicy 忽视，什么都不会发生
- DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务
* 实现 RejectedExecutionHandler 接口，可自定义处理器
基于JDK1.8的ConcurrentHashMap的源码分析：
ConcurrentHashMap是线程安全的，利用的是 CAS算法和Synchronized 来保证并发更新的安全
数据机构是：数组+链表+红黑树
重要的成员变量：
table：默认为null，初始化发生在第一次插入操作，默认大小为16的数组，用来存储Node节点数据，扩容时大小总是2的幂次方。
nextTable：默认为null，扩容时新生成的数组，其大小为原数组的两倍。
sizeCtl ：默认为0，用来控制table的初始化和扩容操作，具体应用在后续会体现出来。
① -1 代表table正在初始化
②-N 表示有N-1个线程正在进行扩容操作
③其余情况：
1、如果table未初始化，表示table需要初始化的大小。
2、如果table初始化完成，表示table的容量，默认是table大小的0.75倍，居然用这个公式算0.75（n - (n >>> 2)）。
```
public classConcurrentHashMapextendsAbstractMapimplementsConcurrentMap, Serializable {private static final longserialVersionUID = 7249069246763182397L;// 表的最大容量private static final intMAXIMUM_CAPACITY = 1 << 30;// 默认表的大小private static final intDEFAULT_CAPACITY = 16;// 最大数组大小static final intMAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;// 默认并发数private static final intDEFAULT_CONCURRENCY_LEVEL = 16;// 装载因子private static final floatLOAD_FACTOR = 0.75f;// 转化为红黑树的阈值static final intTREEIFY_THRESHOLD = 8;// 由红黑树转化为链表的阈值static final intUNTREEIFY_THRESHOLD = 6;// 转化为红黑树的表的最小容量static final intMIN_TREEIFY_CAPACITY = 64;// 每次进行转移的最小值private static final intMIN_TRANSFER_STRIDE = 16;// 生成sizeCtl所使用的bit位数private static intRESIZE_STAMP_BITS = 16;// 进行扩容所允许的最大线程数private static final intMAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;// 记录sizeCtl中的大小所需要进行的偏移位数private static final intRESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;// 一系列的标识static final intMOVED = -1;// hash for forwarding nodesstatic final intTREEBIN = -2;// hash for roots of treesstatic final intRESERVED = -3;// hash for transient reservationsstatic final intHASH_BITS = 0x7fffffff;// usable bits of normal node hash//
/** Number of CPUS, to place bounds on some sizings */
// 获取可用的CPU个数static final intNCPU = Runtime.getRuntime().availableProcessors();//
/** For serialization compatibility. */
// 进行序列化的属性private static finalObjectStreamField[] serialPersistentFields = {newObjectStreamField("segments", Segment[].class),newObjectStreamField("segmentMask", Integer.TYPE),newObjectStreamField("segmentShift", Integer.TYPE) };// 表transient volatileNode[] table; // 下一个表private transient volatileNode[] nextTable; //
/**
* Base counter value, used mainly when there is no contention,
* but also as a fallback during table initialization
* races. Updated via CAS.
*/
// 基本计数private transient volatile longbaseCount; //
/**
* Table initialization and resizing control. When negative, the
* table is being initialized or resized: -1 for initialization,
* else -(1 + the number of active resizing threads). Otherwise,
* when table is null, holds the initial table size to use upon
* creation, or 0 for default. After initialization, holds the
* next element count value upon which to resize the table.
*/
// 对表初始化和扩容控制private transient volatile intsizeCtl;/**
* The next table index (plus one) to split while resizing.
*/
// 扩容下另一个表的索引private transient volatile inttransferIndex;/**
* Spinlock (locked via CAS) used when resizing and/or creating CounterCells.
*/
// 旋转锁private transient volatile intcellsBusy;/**
* Table of counter cells. When non-null, size is a power of 2.
*/
// counterCell表private transientvolatileCounterCell[] counterCells;// views
// 视图private transientKeySetView keySet;private transientValuesView values;private transientEntrySetView entrySet; // Unsafe mechanicsprivate static finalsun.misc.Unsafe U;private static final longSIZECTL;private static final longTRANSFERINDEX;private static final longBASECOUNT;private static final longCELLSBUSY;private static final longCELLVALUE;private static final longABASE;private static final intASHIFT; static{try{ U = sun.misc.Unsafe.getUnsafe(); Class k = ConcurrentHashMap.class; SIZECTL = U.objectFieldOffset (k.getDeclaredField("sizeCtl")); TRANSFERINDEX = U.objectFieldOffset (k.getDeclaredField("transferIndex")); BASECOUNT = U.objectFieldOffset (k.getDeclaredField("baseCount")); CELLSBUSY = U.objectFieldOffset (k.getDeclaredField("cellsBusy")); Class ck = CounterCell.class; CELLVALUE = U.objectFieldOffset (ck.getDeclaredField("value")); Class ak = Node[].class; ABASE = U.arrayBaseOffset(ak);intscale = U.arrayIndexScale(ak);if((scale & (scale - 1)) != 0)throw newError("data type scale not a power of two"); ASHIFT = 31 - Integer.numberOfLeadingZeros(scale); }catch(Exception e) {throw newError(e); } }}
```