计算机网络

• HTTP1.0和HTTP1.1的主要区别
  • 长连接和流水线
• TCP和UDP的区别
• 三次握手，两次可以吗

• 3次握手描述

  TCP三次握手详解及释放连接过程
  TCP协议中的三次握手和四次挥手(图解)
  SYN=1 ACK=0 seq=x
  SYN=1 ACK=1 seq=y ack=x+1
  ACK=1 seq=x+1 ack=y+1

  • ACK ： TCP协议规定，只有ACK=1时有效，也规定连接建立后所有发送的报文的ACK必须为1
  • SYN(SYNchronization) ： 在连接建立时用来同步序号。当SYN=1而ACK=0时，表明这是一个连接请求报文。对方若同意建立连接，则应在响应报文中使SYN=1和ACK=1. 因此, SYN置1就表示这是一个连接请求或连接接受报文。
  • FIN （finis）即完，终结的意思， 用来释放一个连接。当 FIN = 1 时，表明此报文段的发送方的数据已经发送完毕，并要求释放连接。

• 为什么连接的时候是三次握手，关闭的时候却是四次握手？
  答：因为当Server端收到Client端的SYN连接请求报文后，可以直接发送SYN+ACK报文。其中ACK报文是用来应答的，SYN报文是用来同步的。但是关闭连接时，当Server端收到FIN报文时，很可能并不会立即关闭SOCKET，所以只能先回复一个ACK报文，告诉Client端，"你发的FIN报文我收到了"。只有等到我Server端所有的报文都发送完了，我才能发送FIN报文，因此不能一起发送。故需要四步握手。

• 为什么TIME_WAIT状态需要经过2MSL(最大报文段生存时间)才能返回到CLOSE状态？
  答：B向A发送 FIN = 1 的释放连接请求，但这个报文丢失了， A没有接到不会发送确认信息， B 超时会重传，这时A在 WAIT_TIME 还能够接收到这个请求，这时再回复一个确认就行了。（A收到 FIN = 1 的请求后 WAIT_TIME会重新记时）

• TCP滑动窗口

  TCP 的那些事儿（下） http://coolshell.cn/articles/11609.html

是否了解针对3次握手的恶意攻击，如何应对

1. OSI与TCP/IP各层的结构与功能，都有哪些协议。
2. TCP与UDP的区别。
3. TCP报文结构。
4. TCP的三次握手与四次挥手过程，各个状态名称与含义，TIMEWAIT的作用。
5. TCP拥塞控制。
6. TCP滑动窗口与回退N针协议。
7. Http的报文结构。
8. Http的状态码含义。
9. Http request的几种类型。
10. Http1.1和Http1.0的区别
11. Http怎么处理长连接。
12. Cookie与Session的作用于原理。
13. 电脑上访问一个网页，整个过程是怎么样的：DNS、HTTP、TCP、OSPF、IP、ARP。
14. Ping的整个过程。ICMP报文是什么。
15. C/S模式下使用socket通信，几个关键函数。
16. IP地址分类。
17. 路由器与交换机区别。

• 滑动窗口
• epoll模型
• socket
• 完整访问一个域名的具体流程
• RIP：距离向量路由算法
  • 路径较多时，收敛慢，广播路由信息时占用的带宽资源多，适用于网络拓扑结构相对简单且数据链路故障率低的小型网络（小于15跳）
  • RIP通过UDP数据包更新路由信息。每隔30s更新一次路由信息，如果在180s内没有收到相邻路由器的回应，则认为去往该路由器的路由不可用，该路由器不可到达。如果在240s后仍未收到该路由器的应答，则把有关该路由器的路由信息从路由表中删除。
  • 配置简单
• OSPF：采用链路状态路由选择技术，开放最短路径优先算法
  • 每个 OSPF 路由器维护相同自治系统拓扑结构的数据库。从这个数据库里，构造出最短路径树来计算出路由表。当拓扑结构发生变化时， OSPF 能迅速重新计算出路径，而只产生少量的路由协议流量。
  • 收敛速度快；没有跳数限制； 支持服务类型选路； 提供负载均衡和身份认证；
  • OSPF支持通往相同目的的多重路径，支持费用相同的多条链路上的负载均衡。
  • OSPF使用路由标签区分不同的外部路由。
  • OSPF支持路由验证，只有互相通过路由验证的路由器之间才能交换路由信息；并且可以对不同的区域定义不同的验证方式，从而提高了网络的安全性。
  • 适用于规模庞大、环境复杂的互联网，支持大型异构网络的互联。
  • 通过IP报文传输路由信息
• BGP：BGP必须依靠面向连接的TCP会话以提供连接状态
  • BGP通过携带AS路径信息，可以彻底的解决路由循环问题。
  • 为了控制路由的传播和路由的选择，为路由附带属性信息。
  • 使用TCP作为其传输层协议，提高了协议的可靠性。端口号179。
  • BGP-4支持CIDR（无类别域间选路），CIDR的引入简化了路由聚合，减化了路由表。
  • BGP更新时只发送增量路由，减少了BGP传播路由占用的带宽。
  • 提供了丰富的路由策略。

操作系统

• 分页、分段、段页
• ps top 命令

1. 进程和线程的区别。
2. 死锁的必要条件，怎么处理死锁。
3. Window内存管理方式：段存储，页存储，段页存储。
4. 进程的几种状态。
5. IPC几种通信方式。
6. 什么是虚拟内存。
7. 虚拟地址、逻辑地址、线性地址、物理地址的区别。

数据结构

• took算法
• 手写内存拷贝

1. 链表与数组。
2. 队列和栈，出栈与入栈。
3. 链表的删除、插入、反向。
4. 字符串操作。
5. Hash表的hash函数，冲突解决方法有哪些。
6. 各种排序：冒泡、选择、插入、希尔、归并、快排、堆排、桶排、基数的原理、平均时间复杂度、最坏时间复杂度、空间复杂度、是否稳定。
7. 快排的partition函数与归并的Merge函数。
8. 对冒泡与快排的改进。
9. 二分查找，与变种二分查找。
10. 二叉树、B+树、AVL树、红黑树、哈夫曼树。
11. 二叉树的前中后续遍历：递归与非递归写法，层序遍历算法。
12. 图的BFS与DFS算法，最小生成树prim算法与最短路径Dijkstra算法。
13. KMP算法。
14. 排列组合问题。
15. 动态规划、贪心算法、分治算法。（一般不会问到）
16. 大数据处理：类似10亿条数据找出最大的1000个数.........等等

数据库

> 运维角度浅谈MySQL数据库优化 http://blog.jobbole.com/87450/

• 范式

• 存储过程

• 事务

• 索引

  数据库中聚簇索引与非聚簇索引的区别（不错）
  http://www.jb51.net/article/29693.htm
  http://blog.jobbole.com/86594/

• 索引块与数据块的区别
  大家都知道，索引可以提高检索效率，因为它的二叉树结构以及占用空间小，所以访问速度块。让我们来算一道数学题：如果表中的一条记录在磁盘上占用
  1000字节的话，我们对其中10字节的一个字段建立索引，那么该记录对应的索引块的大小只有10字节。我们知道，SQL
  Server的最小空间分配单元是“页（Page）”，一个页在磁盘上占用8K空间，那么这一个页可以存储上述记录8条，但可以存储索引800条。现在我
  们要从一个有8000条记录的表中检索符合某个条件的记录，如果没有索引的话，我们可能需要遍历8000条×1000字节/8K字节=1000个页面才能
  够找到结果。如果在检索字段上有上述索引的话，那么我们可以在8000条×10字节/8K字节=10个页面中就检索到满足条件的索引块，然后根据索引块上
  的指针逐一找到结果数据块，这样IO访问量要少的多。

• 聚簇索引与非聚簇索引的本质区别
  聚簇索引的叶节点就是数据节点，而非聚簇索引的页节点仍然是索引检点，并保留一个链接指向对应数据块。

  还是通过一道数学题来看看它们的区别吧：假设有一8000条记录的表，表中每条记录在磁盘上占用1000字节，如果在一个10字节长的字段上建立非 聚簇索引主键，需要二叉树节点16000个（这16000个节点中有8000个叶节点，每个页节点都指向一个数据记录），这样数据将占用8000条 ×1000字节/8K字节=1000个页面；索引将占用16000个节点×10字节/8K字节=20个页面，共计1020个页面。

  同样一张表，如果我们在对应字段上建立聚簇索引主键，由于聚簇索引的页节点就是数据节点，所以索引节点仅有8000个，占用10个页面，数据仍然占有1000个页面。
  下面我们看看在执行插入操作时，非聚簇索引的主键为什么比聚簇索引主键要快。主键约束要求主键不能出现重复，那么SQL Server是怎么知道不出现重复的呢？唯一的方法就是检索。对于非聚簇索引，只需要检索20个页面中的16000个节点就知道是否有重复，因为所有主键 键值在这16000个索引节点中都包含了。但对于聚簇索引，索引节点仅仅包含了8000个中间节点，至于会不会出现重复必须检索另外1000个页数据节点 才知道，那么相当于检索10+1000=1010个页面才知道是否有重复。所以聚簇索引主键的插入速度要比非聚簇索引主键的插入速度慢很多。

  让我们再来看看数据检索的效率，如果对上述两表进行检索，在使用索引的情况下（有些时候SQL Server执行计划会选择不使用索引，不过我们这里姑且假设一定使用索引），对于聚簇索引检索，我们可能会访问10个索引页面外加1000个数据页面得 到结果（实际情况要比这个好），而对于非聚簇索引，系统会从20个页面中找到符合条件的节点，再映射到1000个数据页面上（这也是最糟糕的情况），比较 一下，一个访问了1010个页面而另一个访问了1020个页面，可见检索效率差异并不是很大。所以不管非聚簇索引也好还是聚簇索引也好，都适合排序，聚簇 索引仅仅比非聚簇索引快一点。

• MySQL中有哪些索引，怎么实现的（B树）

  • 普通索引
  • 唯一索引（主键）
  • 全文索引
  • 多列索引 ALTER TABLE tableName ADD INDEX indexName(col, col...);
    • 优点：最左前缀：创建多列索引，相当于创建了多组索引

• 选择索引列：在where和join子句中出现的列上创建索引，MySQL只有对以下操作符才使用索引：<，<=，=，>，>=，BETWEEN，IN，以及某些时候的LIKE。可以在LIKE操作中使用索引的情形是指另一个操作数不是以通配符（%或者_）开头的情形。例如，“SELECT peopleid FROM people WHERE firstname LIKE ‘Mich%’;”这个查询将使用索引，但“SELECT peopleid FROM people WHERE firstname LIKE ‘%ike’;”这个查询不会使用索引。

• 分析索引效率：EXPLAIN sql 以及 profile工具
  索引为什么会提高效率

• 索引为什么不是越多越好

  • 创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
  • 索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
  • 当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度

• MySQL存储过程：Mysql储存过程是一组为了完成特定功能的SQL语句集，经过编译之后存储在数据库中，当需要使用该组SQL语句时用户只需要通过指定储存过程的名字并给定参数就可以调用执行它了，简而言之就是一组已经写好的命令

  http://www.cnblogs.com/findumars/archive/2013/05/20/3089861.html

  • 优点
    • 可以使用流控制语句编写，灵活性强，可以完成较复杂的判断和运算
    • 允许标准组件式编程，封装与抽象
    • 编译优化，实现较快的执行速度
    • 减少网络流量，只需传输调用语句
    • 可以作为一种安全机制，系统管理员通过执行某一存储过程的权限进行限制，能够实现对相应的数据的访问权限的限制，避免了非授权用户对数据的访问，保证了数据的安全。
  • 修改DELIMITER
  • 存储过程只有三种类型参数 IN,OUT,INOUT调用过程时过程有几个参数传几个参数，只是IN型的参数可以传的是变量，可以是常量，而OUT和INOUT型的参数传的必须是变量传给out，inout参数的变量值会随着在过程中改变在外部也改变，而给in参数的变量外部值则不受过程内变量值改变的影响
  • 存储过程如果只有一个语句则语句不用 begin...end包围存储过程中可以直接使用外部定义的变量存储过程中用set和select定义的变量就是全局的，执行该过程后内部用set和select定义的变量外部可以访问，其他过程也可以直接使用

• 游标
  在Java中调用存储过程的方法
  数据库中的范式

• MySQL锁

  http://www.jb51.net/article/50047.htm

  • 表级锁：开销小，加锁快；不会出现死锁；锁定粒度大，发生锁冲突的概率最高，并发度最低。
  • 行级锁：开销大，加锁慢；会出现死锁；锁定粒度最小，发生锁冲突的概率最低，并发度也最高。
  • 页面锁：开销和加锁时间界于表锁和行锁之间；会出现死锁；锁定粒度界于表锁和行锁之间，并发度一般。

• MySQL的事务操作：ACID

  http://blog.csdn.net/chosen0ne/article/details/10036775

  • Atomicity
  • Consistency
  • Isolation

  • 脏读：事务A修改了一个数据，但未提交，事务B读到了事务A未提交的更新结果，如果事务A提交失败，事务B读到的就是脏数据。
  • 不可重复读：在同一个事务中，对于同一份数据读取到的结果不一致。比如，事务B在事务A提交前读到的结果，和提交后读到的结果可能不同。不可重复读出现的原因就是事务并发修改记录，要避免这种情况，最简单的方法就是对要修改的记录加锁，这回导致锁竞争加剧，影响性能。另一种方法是通过MVCC可以在无锁的情况下，避免不可重复读。
  • 幻读：在同一个事务中，同一个查询多次返回的结果不一致。事务A新增了一条记录，事务B在事务A提交前后各执行了一次查询操作，发现后一次比前一次多了一条记录。幻读是由于并发事务增加记录导致的，这个不能像不可重复读通过记录加锁解决，因为对于新增的记录根本无法加锁。需要将事务串行化，才能避免幻读。

  • Durability

• 事务隔离级别

  • Read Uncommitted（读取未提交内容）

  在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。读取未提交的数据，也被称之为脏读（Dirty Read）。

  • Read Committed（读取提交内容）

  这是大多数数据库系统的默认隔离级别（但不是MySQL默认的）。它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。这种隔离级别 也支持所谓的不可重复读（Nonrepeatable Read），因为同一事务的其他实例在该实例处理其间可能会有新的commit，所以同一select可能返回不同结果。

  • Repeatable Read（可重读）

  这是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。不过理论上，这会导致另一个棘手的问题：幻读 （Phantom Read）。简单的说，幻读指当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的“幻影” 行。InnoDB和Falcon存储引擎通过多版本并发控制（MVCC，Multiversion Concurrency Control）机制解决了该问题。

  • Serializable（可串行化）

  这是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。

  • 这四种隔离级别采取不同的锁类型来实现，若读取的是同一个数据的话，就容易发生问题。例如：
    • 脏读(Drity Read)：某个事务已更新一份数据，另一个事务在此时读取了同一份数据，由于某些原因，前一个RollBack了操作，则后一个事务所读取的数据就会是不正确的。
    • 不可重复读(Non-repeatable read):在一个事务的两次查询之中数据不一致，这可能是两次查询过程中间插入了一个事务更新的原有的数据。
    • 幻读(Phantom Read):在一个事务的两次查询中数据笔数不一致，例如有一个事务查询了几列(Row)数据，而另一个事务却在此时插入了新的几列数据，先前的事务在接下来的查询中，就会发现有几列数据是它先前所没有的。

• MyISAM和innoDB的区别

  • MySQL默认采取MyISAM
  • MyISAM不支持事务，而InnoDB支持。InnoDB的AUTOCOMMIT默认是打开的，即每条SQL语句会默认被封装成一个事务，自动提交，这样会影响速度，所以最好是把多条SQL语句显示放在begin和commit之间，组成一个事务去提交。
  • InnoDB支持数据行锁定，MyISAM不支持行锁定，只支持锁定整个表。即MyISAM同一个表上的读锁和写锁是互斥的，MyISAM并发读写时如果等待队列中既有读请求又有写请求，默认写请求的优先级高，即使读请求先到，所以MyISAM不适合于有大量查询和修改并存的情况，那样查询进程会长时间阻塞。因为MyISAM是锁表，所以某项读操作比较耗时会使其他写进程饿死。
  • InnoDB支持外键，MyISAM不支持。
  • InnoDB的主键范围更大，最大是MyISAM的2倍。
  • InnoDB不支持全文索引，而MyISAM支持。全文索引是指对char、varchar和text中的每个词（停用词除外）建立倒排序索引。MyISAM的全文索引其实没啥用，因为它不支持中文分词，必须由使用者分词后加入空格再写到数据表里，而且少于4个汉字的词会和停用词一样被忽略掉。
  • MyISAM支持GIS数据，InnoDB不支持。即MyISAM支持以下空间数据对象：Point,Line,Polygon,Surface等。
  • 没有where的count()使用MyISAM要比InnoDB快得多。因为MyISAM内置了一个计数器，count()时它直接从计数器中读，而InnoDB必须扫描全表。所以在InnoDB上执行count()时一般要伴随where，且where中要包含主键以外的索引列。为什么这里特别强调“主键以外”？因为InnoDB中primary index是和raw data存放在一起的，而secondary index则是单独存放，然后有个指针指向primary key。所以只是count()的话使用secondary index扫描更快，而primary key则主要在扫描索引同时要返回raw data时的作用较大。
  • 如果执行大量的select，选择MyISAM;如果执行大量的insert、update操作，选择innoDB

算法和数据结构

• 红黑树底层实现
• B+、B树

Java

122个Java面试题：http://www.importnew.com/17232.html
volatile和Synchronized区别

• Thread和Runnable区别
  • Thread编写简单，获取线程，无需使用Thread.currentThread(),this就可以
  • Runnable避免了Java单继承带来的局限
  • Runnable有利于实现多个线程共享资源
    原子性、可见性的概念
    equals hashcode
    几个项目技术点提问
    线程池的概念、好处、常见的线程池举例
    Java用过哪些数据结构
• stringbuffer与stringbuilder的区别
  • string是字符串常量
  • stringbuffer是字符串变量，线程安全
  • stringbuilder是字符串变量，非线程安全
    Callable和Runnable的区别
    hashmap的实现原理
    treemap的实现原理
    手写代码，一组字符串按字典顺序排序
    复杂度分析，有没有更快点的
    手写代码，一组字符串按出现次数排序
    comparable与comparator的区别
    iterator迭代器用法
    手写代码，写一个线程安全的单例模式
• 生产者和消费者模式

//使用阻塞队列
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.logging.Level;
import java.util.logging.Logger;
 
public class ProducerConsumerPattern {
 
    public static void main(String args[]){
 
     //Creating shared object
     BlockingQueue sharedQueue = new LinkedBlockingQueue();
 
     //Creating Producer and Consumer Thread
     Thread prodThread = new Thread(new Producer(sharedQueue));
     Thread consThread = new Thread(new Consumer(sharedQueue));
 
     //Starting producer and Consumer thread
     prodThread.start();
     consThread.start();
    }
 
}
 
//Producer Class in java
class Producer implements Runnable {
 
    private final BlockingQueue sharedQueue;
 
    public Producer(BlockingQueue sharedQueue) {
        this.sharedQueue = sharedQueue;
    }
 
    @Override
    public void run() {
        for(int i=0; i<10; i++){
            try {
                System.out.println("Produced: " + i);
                sharedQueue.put(i);
            } catch (InterruptedException ex) {
                Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
 
}
 
//Consumer Class in Java
class Consumer implements Runnable{
 
    private final BlockingQueue sharedQueue;
 
    public Consumer (BlockingQueue sharedQueue) {
        this.sharedQueue = sharedQueue;
    }
 
    @Override
    public void run() {
        while(true){
            try {
                System.out.println("Consumed: "+ sharedQueue.take());
            } catch (InterruptedException ex) {
                Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
 
}

//非阻塞队列

public class BlockQueue(){
    private List queue = new LinkedList();
    private int limit = 10;
    
    public BlockQueue(int limit){
        this.limit = limit;
    }
    
    public synchronized void enqueue(Object obj){
        if(this.limit == this.queue.size()){
            wait();
        }
        
        if(this.queue.size() == 0){
            notifyAll();
        }
        
        this.queue.add(obj);
    }
    
        public synchronized void dequeue(Object obj){
        if(this.limit == 0){
            wait();
        }
        
        if(this.queue.size() == this.limit){
            notifyAll();
        }
        
        this.queue.remove(obj);
    }
}

• 饱汉与饿汉的区别

//饱汉模式，面临多线程访问的安全问题，需要做双重锁定才能保证安全
public class Singleton{
    private static Singleton instance = null;
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance = new Singleton();  //创建和赋值是分两步进行的，JVM并不保证这两者发生的顺序，因此可能先创建了一个对象，直接赋值给instance，然后初始化，引起错误；由此改进方法必须确保初始化在赋值之前发生
                }
            }
            
        }
        
        return instance;
            
    }
}
// 改进版
public class Singleton{
    private Singleton(){}
    
    private static class SingletonFactory{
        private static Singleton instance = new Singleton();
    }
    
    public static Singleton getInstance(){
        return SingletonFactory.instance;
    }
}

//饿汉模式，类加载就实例化对象，不管是否使用
pubilc class Singleton{
    private static Singleton instance = new Singleton();
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        return instance;
    }
}

• 方法重载(overload)：实现的是编译时的多态性，也称为前绑定
• 方法重写(overwrite)：实现的是运行时的多态性，也称为后绑定
• 面向对象开发基本原则
  • 单一职责：
  • 开放封闭：对扩展开放，对修改关闭
  • 里氏替换：子类可以替换掉父类
  • 依赖倒置：面向接口编程（方法的返回值、引用类型等最好是抽象类型而不是具体类型）
  • 合成聚合复用：优先使用聚合和合成复用代码
  • 接口隔离：接口应该小而专，而不是大而全，接口应该是高内聚的
  • 迪米特法则：一个对象对其他对象应当尽可能少的了解
    string类有哪些方法
    hashmap的实现原理
    容量超了怎么办
    concurrenthashmap的实现原理
    深拷贝与浅拷贝描述
    线程之间通信的方法
    怎么用信号量实现资源共享
    深拷贝与浅拷贝描述
    comparable与comparator的区别
    iterator迭代器用法
    手写代码，写一个线程安全的单例模式
• 强、软、弱、虚
  • 任何一个强引用对象都不能被垃圾回收器回收
  • 对于软引用指向的对象，只有在JVM需要内存时，才进行回收，适合用来实现高速缓存
  • 对于弱引用的对象，当没有强引用时，可以立即回收。使用于存储元数据，另外WeakHashMap的键值采用的是弱引用
  • 拥有虚引用的对象，可以在任何时候被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收的活动。虚引用必须和引用队列（ReferenceQueue）配合使用，当垃圾回收器准备回收一个对象时，如果该对象还有虚引用，则把这个虚引用加入到与之关联的引用队列中。

1. 九种基本数据类型的大小，以及他们的封装类。

2. Switch能否用string做参数？

3. equals与==的区别。

4. Object有哪些公用方法？

5. Java的四种引用，强弱软虚，用到的场景。

6. Hashcode的作用。

7. ArrayList、LinkedList、Vector的区别。

8. String、StringBuffer与StringBuilder的区别。

9. Map、Set、List、Queue、Stack的特点与用法。

10. HashMap和HashTable的区别。

11. HashMap和ConcurrentHashMap的区别，HashMap的底层源码。

12. TreeMap、HashMap、LindedHashMap的区别。

13. Collection包结构，与Collections的区别。

14. try catch finally，try里有return，finally还执行么？

15. Excption与Error包结构。OOM你遇到过哪些情况，SOF你遇到过哪些情况。

16. Java面向对象的三个特征与含义。

17. Override和Overload的含义去区别。

18. Interface与abstract类的区别。

19. Static class 与non static class的区别。

20. java多态的实现原理。

21. 实现多线程的两种方法：Thread与Runable。

22. 线程同步的方法：sychronized、lock、reentrantLock等。

23. 锁的等级：方法锁、对象锁、类锁。

24. 写出生产者消费者模式。

25. ThreadLocal的设计理念与作用。

26. ThreadPool用法与优势。

27. Concurrent包里的其他东西：ArrayBlockingQueue、CountDownLatch等等。

28. wait()和sleep()的区别。

29. foreach与正常for循环效率对比。

30. Java IO与NIO。

31. 反射的作用于原理。

32. 泛型常用特点，List<String>能否转为List<Object>。

33. 解析XML的几种方式的原理与特点：DOM、SAX、PULL。

34. Java与C++对比。

35. Java1.7与1.8新特性。

36. 设计模式：单例、工厂、适配器、责任链、观察者等等。

37. JNI的使用。

38. 内存模型以及分区，需要详细到每个区放什么。

39. 堆里面的分区：Eden，survival from to，老年代，各自的特点。

40. 对象创建方法，对象的内存分配，对象的访问定位。

41. GC的两种判定方法：引用计数与引用链。

42. GC的三种收集方法：标记清除、标记整理、复制算法的原理与特点，分别用在什么地方，如果让你优化收集方法，有什么思路？

43. GC收集器有哪些？CMS收集器与G1收集器的特点。

44. Minor GC与Full GC分别在什么时候发生？

45. 几种常用的内存调试工具：jmap、jstack、jconsole。

46. 类加载的五个过程：加载、验证、准备、解析、初始化。

47. 双亲委派模型：Bootstrap ClassLoader、Extension ClassLoader、ApplicationClassLoader。

48. 分派：静态分派与动态分派。