java须要掌握的知识丶面试题

一、HashMap的工做原理

 

 

二、ConcurrentHashMap实现原理

 

ConcurrentHashMap的同步是采用分段锁的形式，一个ConcurrentHashMap由多个segment组成，每个segment都包含了一个HashEntry数组的hashtable， 每个segment包含了对本身的hashtable的操做，好比get，put，replace等操做，这些操做发生的时候，对本身的hashtable进行锁定。因为每个segment写操做只锁定本身的hashtable，因此可能存在多个线程同时写的状况，性能无疑好于只有一个hashtable锁定的状况。

 

三、ThreadLocal 工做原理

 

首先，它是一个数据结构，有点像HashMap，能够保存"key : value"键值对，可是一个ThreadLocal只能保存一个，而且各个线程的数据互不干扰，它是一个以ThreadLocal对象为键、任意对象为值的存储结构。能够经过set（T）方法设置一个值，在当前线程下以get()方法获取到原先设置的值。应用场景：在多线程环境下，如何防止本身的变量被其它线程篡改，就能够用到ThreadLocal。

原理：每一个Thread维护一个ThreadLocalMap映射表，这个映射表的key是ThreadLocal实例自己，value是真正须要存储的Object。

在ThreadLoalMap中，也是初始化一个大小16的Entry数组，Entry对象用来保存每个key-value键值对，只不过这里的key永远都是ThreadLocal对象，ThreadLocalMap是使用ThreadLocal的弱引用做为Key的，经过ThreadLocal对象的set方法，结果把ThreadLocal对象本身当作key，放进了ThreadLoalMap中。

缺陷：ThreadLocal可能致使内存泄漏，缘由：当使用ThreadLocal保存一个value时，会在ThreadLocalMap中的数组插入一个Entry对象，按理说key-value都应该以强引用保存在Entry对象中，但在ThreadLocalMap的实现中，key被保存到了WeakReference对象中。这就致使了一个问题，ThreadLocal在没有外部强引用时，发生GC时会被回收，若是建立ThreadLocal的线程一直持续运行，那么这个Entry对象中的value就有可能一直得不到回收，发生内存泄露。【简单的说就是本该回收的对象一直都没有被回收。】

如何避免：只要清除ThreadLocalMap中key为null的Entry对象，这样对应的value就没有GC Roots可达了，下次GC的时候就能够被回收，固然若是调用remove方法，确定会删除对应的Entry对象。若是使用ThreadLocal的set方法以后，没有显示的调用remove方法，就有可能发生内存泄露，因此养成良好的编程习惯十分重要，使用完ThreadLocal以后，记得调用remove方法。

 

四、volatile关键字

一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰以后，保证了不一样线程对这个变量进行操做时的可见性，即一个线程修改了某个变量的值，这新值对其余线程来讲是当即可见的。使用volatile关键字会强制将修改的值当即写入主存，使其它线程的工做内存中的这个变量失效，必须再次从主内存中从新读取。volatile保证原子性吗？答案是不能，根源就在这里，自增操做不是原子性操做，并且volatile也没法保证对变量的任何操做都是原子性的。可使用synchronized、加锁、和atomicInteger实现原子性。

4.一、wait和sleep

wait是Object类中的方法，而sleep是Thread类中的方法。

 

最主要的是sleep方法调用以后，并没有释放锁。使得线程仍然能够同步控制。sleep不会让出系统资源；

而wait是进入线程等待池中等待，让出系统资源。

调用wait方法的线程，不会本身唤醒，须要线程调用 notify / notifyAll 方法唤醒等待池中的全部线程，才会进入就绪队列中等待系统分配资源。sleep方法会自动唤醒，若是时间不到，想要唤醒，可使用interrupt方法强行打断。

 

使用范围：

sleep能够在任何地方使用。而wait，notify，notifyAll只能在同步控制方法或者同步控制块中使用。

sleep必须捕获异常，而wait，notify，notifyAll的不须要捕获异常

 

 

五、为何String要设计成不可变的

六、数据库的ACID是什么意思？

所谓事务，它是一个操做序列，这些操做要么都执行，要么都不执行，它是一个不可分割的工做单位。

原子性是指事务是一个不可再分割的工做单位，事务中的操做要么都发生，要么都不发生。

一致性是指在事务开始以前和事务结束之后，数据库的完整性约束没有被破坏。这是说数据库事务不能破坏关系数据的完整性以及业务逻辑上的一致性。

多个事务并发访问时，事务之间是隔离的，一个事务不该该影响其它事务运行效果。

持久性，意味着在事务完成之后，该事务所对数据库所做的更改便持久的保存在数据库之中，并不会被回滚。

七、乐观锁和悲观锁及其适用场景

乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，因此不会上锁，可是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可使用版本号等机制。乐观锁适用于多读的应用类型，这样能够提升吞吐量。乐观锁解决不了脏读。

悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，因此每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block【阻塞】直到它拿到锁。传统的关系型数据库里边就用到了不少这种锁机制，好比行锁，表锁等，读锁，写锁等，都是在作操做以前先上锁。

 

两种锁各有优缺点，不可认为一种好于另外一种，像乐观锁适用于写比较少的状况下，即冲突真的不多发生的时候，这样能够省去了锁的开销，加大了系统的整个吞吐量。但若是常常产生冲突，上层应用会不断的进行retry，这样反却是下降了性能，因此这种状况下用悲观锁就比较合适。

八、数据库索引

参考：http://blog.csdn.net/kennyrose/article/details/7532032

索引的实现一般使用B树及其变种B+树。

 

建立索引能够大大提升系统的性能。

第一，经过建立惟一性索引，能够保证数据库表中每一行数据的惟一性。

第二，能够大大加快数据的检索速度，这也是建立索引的最主要的缘由。

缺点:

第一，索引须要占物理空间，除了数据表占数据空间以外，每个索引还要占必定的物理空间，若是要创建聚簇索引，那么须要的空间就会更大。

第二，当对表中的数据进行增长、删除和修改的时候，索引也要动态的维护，花的时间比较多。

应该建立索引的列：

(1)、在常常须要搜索的列上，能够加快搜索的速度

(2)、在常常用在链接的列上，这些列主要是一些外键，能够加快链接的速度

(3)、在常常须要根据范围进行搜索的列上建立索引，由于索引已经排序，其指定的范围是连续的

(4)、在常常须要排序的列上建立索引，由于索引已经排序，这样查询能够利用索引的排序，加快排序查询时间

(5)、在常用在WHERE子句中的列上面建立索引，加快条件的判断速度。

不该该建立索引的列：

(1)、对于那些在查询中不多使用或者参考的列不该该建立索引

(2)、对于那些只有不多数据值的列也不该该增长索引。例如性别等

(3)、对于那些定义为text, image和bit数据类型的列不该该增长索引

根据数据库的功能，能够在数据库设计器中建立三种索引：惟一索引、主键索引和汇集索引。

惟一索引

 

惟一索引是不容许其中任何两行具备相同索引值的索引。

主键索引

 

数据库表常常有一列或列组合，其值惟一标识表中的每一行。该列称为表的主键。

 

在数据库关系图中为表定义主键将自动建立主键索引，主键索引是惟一索引的特定类型。该索引要求主键中的每一个值都惟一。当在查询中使用主键索引时，它还容许对数据的快速访问。

 

汇集索引

 

在汇集索引中，表中行的物理顺序与键值的逻辑（索引）顺序相同。一个表只能包含一个汇集索引。

 

 

九、事务

 

1.隔离级别

Spring 为咱们定义了5个隔离级别，在@Transactional 指定isolation，使用，以下表：

DEFAULT	使用当前数据库默认的隔离级别。
READ_UNCOMMITD 可读未提交的	在一个事务里能够读取到另外一个事务未提交的数据，会产生脏读、不可重复读、幻读。
READ_COMMITTED 提交了才能读	只有当一个事务提交后，才能被另外一个事务读取到数据，不会产生脏读，会产生不可重复读、幻读。
REPEATABLE_READ 可重复读	实现了READ_COMMITTED级别，并且一个事务读取了数据，另外一个事务不容许修改。不会产生脏读、不可重复读，会产生幻读。
SERIALIZABLE 序列化读写	要求事务按照顺序执行，不会产生脏读、不可重复读、幻读，性能极差严重影响性能。

 

2.事务传播

Spring 为咱们定义了7个传播行为，在@Transactional 指定propagation，以下表：

REQUIRED	必需要在事务下执行，若是当前存在事务则加入该事务，不然建立新的事务执行。例如： A方法调用B方法，A方法已经在事务下了，调用B的时候，B会加入到A的事务中，处于同一事务下，若是出错全部的操做都将回滚。
SUPPORTS	当前若是存在事务则加入该事务，若是没有就不用事务执行。
MANDATORY	必需要在事务下执行，若是当前存在事务则加入该事务，若是不存在事务则抛异常。
REQUIRES_NEW	必需要在一个新的事务下执行，若是当前存在事务，则会建立新的事务执行，若是出现错误不会回滚其它事务。例如：A调用B，B出错不会致使A事务数据回滚。
NOT_SUPPORTED	不能在事务下执行，若是当前存在事务则把当前事务挂起。
NEVER	不能在事务下执行，若是当前存在事务则抛异常。
NESTED	若是当前存在事务，则会建立新的事务执行。具体的这个我也不是怎么清楚，不多用到。

十、Redis底层数据结构有哪些

在 redis 中一共有5种数据结构、String、list、list、set、sortSet，

(1)、String,String 数据结构是简单的 key-value 类型，value 不只能够是 String，也能够是数字.

(2)、HASH,Redis 的 Hash 结构可使你像在数据库中 Update 一个属性同样只修改某一项属性值。应用有：存储、读取、修改用户属性

(3)、List 说白了就是链表（redis 使用双端链表实现的 List）。使用 List 结构，咱们能够轻松地实现最新消息排行等功能（好比新浪微博的 TimeLine ）。List 的另外一个应用就是消息队列，能够利用 List 的 *PUSH 操做，将任务存在 List 中，而后工做线程再用 POP 操做将任务取出进行执行。Redis 还提供了操做 List 中某一段元素的 API，你能够直接查询，删除 List 中某一段的元素。

(4)、Set，Set 就是一个集合，集合的概念就是一堆不重复值的组合。利用 Redis 提供的 Set 数据结构，能够存储一些集合性的数据。应用：1.共同好友、二度好友2.利用惟一性，能够统计访问网站的全部独立 IP 3.好友推荐的时候，根据 tag 求交集，大于某个 threshold 就能够推荐。

(5)、和Sets相比，Sorted Sets是将 Set 中的元素增长了一个权重参数 score，使得集合中的元素可以按 score 进行有序排列，应用：带有权重的元素，好比一个游戏的用户得分排行榜

 

(6) 订阅-发布系统

Pub/Sub 从字面上理解就是发布（Publish）与订阅（Subscribe），在 Redis 中，你能够设定对某一个 key 值进行消息发布及消息订阅，当一个 key 值上进行了消息发布后，全部订阅它的客户端都会收到相应的消息。这一功能最明显的用法就是用做实时消息系统，好比普通的即时聊天，群聊等功能。

(7)、事务——Transactions

 

Redis 事务能够一次执行多个命令， 而且带有如下两个重要的保证：a、事务是一个单独的隔离操做：事务中的全部命令都会序列化、按顺序地执行。事务在执行的过程当中，不会被其余客户端发送来的命令请求所打断。b、事务是一个原子操做：事务中的命令要么所有被执行，要么所有都不执行。

 

十一、线程池实现和原理

 

到这里，大部分朋友应该对任务提交给线程池以后到被执行的整个过程有了一个基本的了解，下面总结一下：

　　1）首先，要清楚corePoolSize和maximumPoolSize的含义；

　　2）其次，要知道Worker是用来起到什么做用的；

　　3）要知道任务提交给线程池以后的处理策略，这里总结一下主要有4点：

• 若是当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会建立一个线程去执行这个任务；
• 若是当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（通常来讲是任务缓存队列已满），则会尝试建立新的线程去执行这个任务；
• 若是当前线程池中的线程数目达到maximumPoolSize，则会采起任务拒绝策略进行处理；如下4种策略。

• 1 2 3 4

  ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，可是不抛出异常。 ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，而后从新尝试执行任务（重复此过程） ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

• 若是线程池中的线程数量大于 corePoolSize时，若是某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；若是容许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。

 

一个线程池包括如下四个基本组成部分：

(1)、线程池管理器（ThreadPool）：用于建立并管理线程池，包括 建立线程池，销毁线程池，添加新任务；
(2)、工做线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，能够循环的执行任务；

(3)、任务接口（Task）：每一个任务必须实现的接口，以供工做线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工做，任务的执行状态等；
(4)、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。

线程池技术能够缩短或调整建立线程和销毁线程时间的技术，从而提升服务器程序性能的。它把建立线程和销毁线程分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有建立线程和销毁线程开销了。线程池不只调整建立线程和销毁线程产生的时间段，并且它还显著减小了建立线程的数目。

线程池工做原理：

将一个任务经过execute()方法加到线程池中后分下面4中状况来执行。

(1)、若是当前的运行的线程数小于核心线程池中的线程数，则建立一个新的线程来执行任务，（执行这一步须要获取全局锁）

(2)、若是运行的线程等于或多于核心线程池中线程数，则将任务加到任务队列中

(3)、若是任务队列已满，则建立新的线程来处理任务，（执行这一步须要获取全局锁)

(4)、若是建立新的线程后，超过线程池中最大线程数，任务被拒绝。

十一、消息队列

消息队列技术是分布式应用间交换信息的一种技术。消息队列可驻留在内存或磁盘上,队列存储消息直到它们被应用程序读走。经过消息队列，应用程序可独立地执行--它们不须要知道彼此的位置、或在继续执行前不须要等待接收程序接收此消息。

 

十二、hash一致性算法

参考：http://blog.csdn.net/cywosp/article/details/23397179/

在分布式集群中，对机器的添加删除，或者机器故障后自动脱离集群这些操做是分布式集群管理最基本的功能。若是采用经常使用的hash(object)%N算法，那么在有机器添加或者删除后，不少原有的数据就没法找到了，这样严重的违反了单调性原则。接下来主要讲解一下一致性哈希算法是如何设计的。

 

环形Hash空间
按照经常使用的hash算法来将对应的key哈希到一个具备2^32次方个桶的空间中，即0~(2^32)-1的数字空间中。如今咱们能够将这些数字头尾相连，想象成一个闭合的环形。
把数据经过必定的hash算法处理后映射到环上
如今咱们将object一、object二、object三、object4四个对象经过特定的Hash函数计算出对应的key值，而后散列到Hash环上。以下图：
Hash(object1) = key1；
Hash(object2) = key2；
Hash(object3) = key3；
Hash(object4) = key4；
将机器经过hash算法映射到环上
在采用一致性哈希算法的分布式集群中将新的机器加入，其原理是经过使用与对象存储同样的Hash算法将机器也映射到环中（通常状况下对机器的hash计算是采用机器的IP或者机器惟一的别名做为输入值），而后以顺时针的方向计算，将全部对象存储到离本身最近的机器中。
假设如今有NODE1，NODE2，NODE3三台机器，经过Hash算法获得对应的KEY值，映射到环中，其示意图以下：
Hash(NODE1) = KEY1;
Hash(NODE2) = KEY2;
Hash(NODE3) = KEY3;
在这样的部署环境中，hash环是不会变动的，所以，经过算出对象的hash值就能快速的定位到对应的机器中，这样就能找到对象真正的存储位置了。
1. 节点（机器）的删除
以上面的分布为例，若是NODE2出现故障被删除了，那么按照顺时针迁移的方法，object3将会被迁移到NODE3中，这样仅仅是object3的映射位置发生了变化，其它的对象没有任何的改动。
2. 节点（机器）的添加
若是往集群中添加一个新的节点NODE4，经过对应的哈希算法获得KEY4，并映射到环中，经过按顺时针迁移的规则，那么object2被迁移到了NODE4中，其它对象还保持这原有的存储位置。经过对节点的添加和删除的分析，一致性哈希算法在保持了单调性的同时，仍是数据的迁移达到了最小，这样的算法对分布式集群来讲是很是合适的，避免了大量数据迁移，减少了服务器的的压力。
平衡性
根据上面的图解分析，一致性哈希算法知足了单调性和负载均衡的特性以及通常hash算法的分散性，但这还并不能当作其被普遍应用的起因，由于还缺乏了平衡性。下面将分析一致性哈希算法是如何知足平衡性的。hash算法是不保证平衡的，如上面只部署了NODE1和NODE3的状况（NODE2被删除的图），object1存储到了NODE1中，而object二、object三、object4都存储到了NODE3中，这样就照成了很是不平衡的状态。在一致性哈希算法中，为了尽量的知足平衡性，其引入了虚拟节点。以上面只部署了NODE1和NODE3的状况（NODE2被删除的图）为例，以前的对象在机器上的分布很不均衡，如今咱们以2个副本（复制个数）为例，这样整个hash环中就存在了4个虚拟节点，最后对象映射的关系图以下：根据上图可知对象的映射关系：object1->NODE1-1，object2->NODE1-2，object3->NODE3-2，object4->NODE3-1。经过虚拟节点的引入，对象的分布就比较均衡了。
虚拟节点”的hash计算能够采用对应节点的IP地址加数字后缀的方式。例如假设NODE1的IP地址为192.168.1.100。引入“虚拟节点”前，计算 cache A 的 hash 值：
Hash(“192.168.1.100”);
引入“虚拟节点”后，计算“虚拟节”点NODE1-1和NODE1-2的hash值：
Hash(“192.168.1.100#1”); // NODE1-1
Hash(“192.168.1.100#2”); // NODE1-2

1三、jvm

 

 

一、jvm 的体系结构：java堆、java栈、方法区、PC寄存器。

其中java堆和方法区是被全部的线程共享的。在方法区中，存储了每一个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。当建立一个新的线程时，JVM回为这个线程建立一个Java栈，同时也会为这个线程分配一个PC寄存器，这个PC寄存器指向的是这个线程执行的第一行代码。每当调用一个新的方法时，就会在这个java栈上面建立一个新的栈帧。栈帧上面主要存放的是这个方法中定义的变量、运行是常量池的引用、方法正常返回的地址。

 

Object 类中的方法

Object()
默认构造方法
clone()
建立并返回此对象的一个副本。
equals(Object obj)
指示某个其余对象是否与此对象“相等”。
hashCode()
返回该对象的哈希码值。
finalize()
当垃圾回收器肯定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
getClass()
返回一个对象的运行时类。
notify()
唤醒在此对象监视器上等待的单个线程。
notifyAll()
唤醒在此对象监视器上等待的全部线程。
toString()
返回该对象的字符串表示。
wait()
致使当前的线程等待，直到其余线程调用此对象的 notify() 方法或 notifyAll() 方法。
wait(long timeout)
致使当前的线程等待，直到其余线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。
wait(long timeout, int nanos)
致使当前的线程等待，直到其余线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其余某个线程中断当前线程，或者已超过某个实际时间量。

 

 

 

1、Java基础

1. String类为何是final的。

(1)、不可变性支持字符串常量池
String另一个字符串常量池的属性。2个字符串都用同一个字面量赋值。它们其实都指向同一个内存地址

(2)、不可变性支持线程安全
就是在并发场景下，多个线程同时读一个资源，是不会引起竟态条件的。只有对资源作写操做才有危险。不可变对象不能被写，因此线程安全。

 

 

2. HashMap的源码，实现原理，底层结构。

 

HashMap基于hashing原理，咱们经过put()和get()方法储存和获取对象。当咱们将键值对传递给put()方法时，它调用键对象的hashCode()方法来计算hashcode，而后找到bucket位置来储存值对象。当获取对象时，经过键对象的equals()方法找到正确的键值对，而后返回值对象。HashMap使用链表来解决碰撞问题，当发生碰撞了，会采用头插入的方式将对象将会储存在链表中，而且对象的指针指向下一个对象节点。 HashMap在每一个链表节点中储存键值对对象。

当两个不一样的键对象的hashcode相同时会发生什么？ 它们会储存在同一个bucket位置的链表中。键对象的equals()方法用来找到键值对。HasMap初始长度？HashMap的初始长度默认是16，而且每次自动扩展或者手动初始化时，长度必须是2的幂，之因此选择16，是为了服务于从key映射到index的hash算法。从key映射到HashMap数组对应的位置会用到下面的方式：index = HashCode(key）& (length -1). length 是2的幂，能够有效的减小index的重复。

若是HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？”默认的负载因子大小为0.75，也就是说，当一个map填满了75%的bucket时候，和其它集合类(如ArrayList等)同样，将会建立原来HashMap大小的两倍的bucket数组，来从新调整map的大小，并将原来的对象放入新的bucket数组中。这个过程叫做rehashing【重散列】，由于它调用hash方法找到新的bucket位置。

你了解从新调整HashMap大小存在什么问题吗？”当多线程的状况下，可能产生条件竞争(race condition)。当从新调整HashMap大小的时候，确实存在条件竞争，由于若是两个线程都发现HashMap须要从新调整大小了，它们会同时试着调整大小。在调整大小的过程当中，存储在链表中的元素的次序会反过来，由于移动到新的bucket位置的时候，HashMap并不会将元素放在链表的尾部，而是放在头部，这是为了不尾部遍历(tail traversing)。主要是多线程同时put时，若是同时触发了rehash操做，会致使HashMap中的链表中出现循环节点，进而使得后面get的时候，会死循环若是条件竞争发生了，那么就死循环了。

 

3. 说说你知道的几个Java集合类：list、set、queue、map实现类咯

Java容器类类库的用途是"保存对象"，并将其划分为两个不一样的概念：
1) Collection
Collection 每一个位置只能保存一个元素(对象)
　　1.1) List必须保持元素特定的顺序
1.1) HashSet
HashSet是Set接口的典型实现，HashSet使用HASH算法来存储集合中的元素，所以具备良好的存取和查找性能。当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来获得该对象的hashCode值，而后根据该HashCode值决定该对象在HashSet中的存储位置。值得主要的是，HashSet集合判断两个元素相等的标准是两个对象经过equals()方法比较相等，而且两个对象的hashCode()方法的返回值相等。

1.1.1) LinkedHashSet
LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置，但和HashSet不一样的是，它同时使用链表维护元素的次序，
这样使得元素看起来是以插入的顺序保存的。当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。
LinkedHashSet须要维护元素的插入顺序，所以性能略低于HashSet的性能，但在迭代访问Set里的所有元素时(遍历)将有很好的性能(链表很适合进行遍历)

　　1.2) Set不能有重复元素
　　1.3) Queue保持一个队列(先进先出)的顺序
2) Map
Map保存的是"键值对",咱们能够经过"键"找到该键对应的"值"

4. 描述一下ArrayList和LinkedList各自实现和区别

5. Java中的队列都有哪些，有什么区别。

6. 反射中，Class.forName和classloader的区别

7. Java7、Java8的新特性(baidu问的,好BT)

8. Java数组和链表两种结构的操做效率，在哪些状况下(从开头开始，从结尾开始，从中间开始)，哪些操做(插入，查找，删除)的效率高

9. Java内存泄露的问题调查定位：jmap，jstack的使用等等

10. string、stringbuilder、stringbuffer区别

11. hashtable和hashmap的区别

13 .异常的结构，运行时异常和非运行时异常，各举个例子

14. String a= “abc” String b = “abc” String c = new String(“abc”) String d = “ab” + “c” .他们之间用 ==比较的结果

15. String 类的经常使用方法

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

17. 抽象类和接口的区别

18. java的基础类型和字节大小。

19. Hashtable,HashMap,ConcurrentHashMap 底层实现原理与线程安全问题（建议熟悉 jdk 源码，才能从容应答）

20. 若是不让你用Java Jdk提供的工具，你本身实现一个Map，你怎么作。说了很久，说了HashMap源代码，若是我作，就会借鉴HashMap的原理，说了一通HashMap实现

21. Hash冲突怎么办？哪些解决散列冲突的方法？

22. HashMap冲突很厉害，最差性能，你会怎么解决?从O（n）提高到log（n）咯，用二叉排序树的思路说了一通

23. rehash

24. hashCode() 与 equals() 生成算法、方法怎么重写

2、Java IO

1. 讲讲IO里面的常见类，字节流、字符流、接口、实现类、方法阻塞。

2. 讲讲NIO。

3. String 编码UTF-8 和GBK的区别?

4. 何时使用字节流、何时使用字符流?

5. 递归读取文件夹下的文件，代码怎么实现

3、Java Web

1. session和cookie的区别和联系，session的生命周期，多个服务部署时session管理。

2. servlet的一些相关问题

3. webservice相关问题

4. jdbc链接，forname方式的步骤，怎么声明使用一个事务。举例并具体代码

5. 无框架下配置web.xml的主要配置内容

6. jsp和servlet的区别

4、JVM

1. Java的内存模型以及GC算法

2. jvm性能调优都作了什么

3. 介绍JVM中7个区域，而后把每一个区域可能形成内存的溢出的状况说明

4. 介绍GC和GC Root不正常引用。

5. 本身从classload 加载方式，加载机制说开去，从程序运行时数据区，讲到内存分配，讲到String常量池，讲到JVM垃圾回收机制，算法，hotspot。反正就是各类扩展

6. jvm 如何分配直接内存， new 对象如何不分配在堆而是栈上，常量池解析

7. 数组多大放在 JVM 老年代（不仅是设置 PretenureSizeThreshold ，问一般多大，没作过一问便知）

8. 老年代中数组的访问方式

9. GC 算法，永久代对象如何 GC ， GC 有环怎么处理

10. 谁会被 GC ，何时 GC

11. 若是想不被 GC 怎么办

12. 若是想在 GC 中生存 1 次怎么办

5、开源框架

1. hibernate和ibatis的区别

2. 讲讲mybatis的链接池。

3. spring框架中须要引用哪些jar包，以及这些jar包的用途

4. springMVC的原理

5. springMVC注解的意思

6. spring中beanFactory和ApplicationContext的联系和区别

7. spring注入的几种方式（循环注入）

8. spring如何实现事物管理的

9. springIOC

10. spring AOP的原理

11. hibernate中的1级和2级缓存的使用方式以及区别原理（Lazy-Load的理解）

12. Hibernate的原理体系架构，五大核心接口，Hibernate对象的三种状态转换，事务管理。

6、多线程

1. Java建立线程以后，直接调用start()方法和run()的区别

2. 经常使用的线程池模式以及不一样线程池的使用场景

3. newFixedThreadPool此种线程池若是线程数达到最大值后会怎么办，底层原理。

4. 多线程之间通讯的同步问题，synchronized锁的是对象，衍伸出和synchronized相关不少的具体问题，例如同一个类不一样方法都有synchronized锁，一个对象是否能够同时访问。或者一个类的static构造方法加上synchronized以后的锁的影响。

5. 了解可重入锁的含义，以及ReentrantLock和synchronized的区别

6. 同步的数据结构，例如concurrentHashMap的源码理解以及内部实现原理，为何他是同步的且效率高

7. atomicinteger和Volatile等线程安全操做的关键字的理解和使用

8. 线程间通讯，wait和notify

9. 定时线程的使用

10. 场景：在一个主线程中，要求有大量(不少不少)子线程执行完以后，主线程才执行完成。多种方式，考虑效率。

11. 进程和线程的区别

12. 什么叫线程安全？举例说明

13. 线程的几种状态

14. 并发、同步的接口或方法

15. HashMap 是否线程安全，为什么不安全。 ConcurrentHashMap，线程安全，为什么安全。底层实现是怎么样的。

16. J.U.C下的常见类的使用。 ThreadPool的深刻考察； BlockingQueue的使用。（take，poll的区别，put，offer的区别）；原子类的实现。

17. 简单介绍下多线程的状况，从创建一个线程开始。而后怎么控制同步过程，多线程经常使用的方法和结构

18. volatile的理解

19. 实现多线程有几种方式，多线程同步怎么作，说说几个线程里经常使用的方法

7、网络通讯

1. http是无状态通讯，http的请求方式有哪些，能够本身定义新的请求方式么。

2. socket通讯，以及长链接，分包，链接异常断开的处理。

3. socket通讯模型的使用，AIO和NIO。

4. socket框架netty的使用，以及NIO的实现原理，为何是异步非阻塞。

5. 同步和异步，阻塞和非阻塞。

6. OSI七层模型，包括TCP,IP的一些基本知识

7. http中，get post的区别

8. 说说http,tcp,udp之间关系和区别。

9. 说说浏览器访问www.taobao.com，经历了怎样的过程。

10. HTTP协议、 HTTPS协议，SSL协议及完整交互过程；

11. tcp的拥塞，快回传，ip的报文丢弃

12. https处理的一个过程，对称加密和非对称加密

13. head各个特色和区别

14. 说说浏览器访问www.taobao.com，经历了怎样的过程。

8、数据库MySql

1. MySql的存储引擎的不一样

2. 单个索引、联合索引、主键索引

3. Mysql怎么分表，以及分表后若是想按条件分页查询怎么办(若是不是按分表字段来查询的话，几乎效率低下，无解)

4. 分表以后想让一个id多个表是自增的，效率实现

5. MySql的主从实时备份同步的配置，以及原理(从库读主库的binlog)，读写分离

6. 写SQL语句。。。

7. 索引的数据结构，B+树

8. 事务的四个特性，以及各自的特色（原子、隔离）等等，项目怎么解决这些问题

9. 数据库的锁：行锁，表锁；乐观锁，悲观锁

10. 数据库事务的几种粒度；

11. 关系型和非关系型数据库区别

9、设计模式

1. 单例模式：饱汉、饿汉。以及饿汉中的延迟加载,双重检查

2. 工厂模式、装饰者模式、观察者模式。

3. 工厂方法模式的优势（低耦合、高内聚，开放封闭原则）

10、算法

1. 使用随机算法产生一个数，要求把1-1000W之间这些数所有生成。（考察高效率，解决产生冲突的问题）

2. 两个有序数组的合并排序

3. 一个数组的倒序

4. 计算一个正整数的正平方根

5. 说白了就是常见的那些查找、排序算法以及各自的时间复杂度

6. 二叉树的遍历算法

7. DFS,BFS算法

9. 比较重要的数据结构，如链表，队列，栈的基本理解及大体实现。

10. 排序算法与时空复杂度（快排为何不稳定，为何你的项目还在用）

11. 逆波兰计算器

12. Hoffman 编码

13. 查找树与红黑树

11、并发与性能调优

1. 有个每秒钟5k个请求，查询手机号所属地的笔试题(记得不完整，没列出)，如何设计算法?请求再多，好比5w，如何设计整个系统?

2. 高并发状况下，咱们系统是如何支撑大量的请求的

3. 集群如何同步会话状态

4. 负载均衡的原理

5 .若是有一个特别大的访问量，到数据库上，怎么作优化（DB设计，DBIO，SQL优化，Java优化）

6. 若是出现大面积并发，在不增长服务器的基础上，如何解决服务器响应不及时问题“。

7. 假如你的项目出现性能瓶颈了，你以为可能会是哪些方面，怎么解决问题。

8. 如何查找形成性能瓶颈出现的位置，是哪一个位置照成性能瓶颈。

9. 你的项目中使用过缓存机制吗？有没用用户非本地缓存

12、其余

1.经常使用的linux下的命令