校招总结

简历投递

• 内推和提前批
  * 华为。java应用软件开发（IT产品线），paas（cloud bu）（8月1日投递）
  * 今日头条。后端研发工程师（8月5日投递）
  * 腾讯。软件开发-后台开发方向（8月5日投递）
  * 网易。Java开发工程师（网易杭州）-跨境电商(考拉海购)（8月5日投递）
  * 百度。北京-软件研发工程师（8月5日投递）
  * 阿里。研发工程师JAVA（8月5日投递）
  * 携程。后台开发工程师-2018秋-内（8月5日投递）
  * 好未来。java开发工程师（8月5日投递）
  * 滴滴。后台开发工程师（8月12日投递）
  * 蘑菇街。电商技术部分-应用开发工程师（8月15日投递）
  * 五八集团。后台开发工程师（8月18日投递）
  * 招商银行信用卡中心。IT工程师（开发方向）（8月18日投递）
  * 中国银联。研发工程师JAVA（8月18日投递）
  * FreeWheel。WEB全栈开发（8月18日投递）
  * 招银网络科技。软件开发工程师（杭州）（8月19日投递）
  * 除了java开发岗位，对于有数学基础的人还有金融建模等开发岗位（类似于券商的交易系统开发等，使用c#和java等），是招行最赚钱的岗位。
  * 去哪儿。开发工程师（2018-J11887）（8月19日投递）
  * 搜狐。开发工程师
  * 京东。Java开发工程师（8月28日投递）
  * 51信用卡。JAVA开发工程师 浙江省-杭州市（9月1日投递）
• 校招
  * 阿里。研发工程师JAVA
  * 搜狐。开发工程师
  * 搜狐。UP·推荐系统研发工程师（9月16日投递）
  * 腾讯。软件开发-后台开发方向
  * 搜狗。Java开发工程师（部门1网页搜索，部门2商业平台）
  * 京东。Java开发工程师
  * 百度。北京-软件研发工程师
  * 唯品会。助理Java开发工程师（上海）（产品技术中心）
  * 中移物联网。Java开发岗
  * 亚马逊。软件开发工程师 北京
  * 小米。服务端开发工程师,招聘地点:成都
  * 微策略。开发工程师 Associate Software Engineer
  * 网易。java开发工程师（网易邮箱事业部）
  * 58集团。后台开发工程师（北京）
  * 国家互联网应急中心。北京
  * 上汽大众。前瞻研究与驾驶辅助研发（上海）（所属机构：新能源车研发）
  * WAP。软件研究开发工程师（Research&Development Engineer）（可选择应聘技术研究方向 or 产品开发方向）
  * ThoughtWorks。软件开发工程师（北京）
  * 上海哔哩哔哩科技有限公司。后端开发工程师
  * 中国银联。研发工程师(Java)（上海）（第二志愿：技术研究（区块链技术与应用研究）（上海））
  * 因为时间冲突，没有参加笔试。
  * 中国移动杭州研发中心。后端开发方向（杭州）
  * 科大讯飞。软件开发工程师（杭州）
  * 新浪。研发工程师_JAVA方向
  * 美团。后台开发工程师—上海
  * 微软（中国）有限公司。第1志愿：Software Engineer-C+E

笔试考点

行测题目

    * 图表分析题
            * 环比、同比。
                    * 环比和同比在英文中没有单一单词对应的翻译。同比英文可翻译为 compare with the performance/figure/statistics last year， year-on-year ratio， increase/decrease on a year-on-year basis。而环比则只需把前面的year改为month或season即可。
            * 精确的数值计算。使用计算器。
    * 智力题
            * 数列找规律。使用百度，同时注意总结常见思路
            * 图形规律。注意总结常见思路，可以在牛客网刷题时总结。

数据结构与算法

    * 排序算法中，简单选择排序和堆排序是**无法写成**稳定的排序算法。
            * 容易理解。像简单选择排序这种有间隔的交换容易造成不稳定现象，如果快排也是这样写，也会产生不稳定现象。
    * 堆排序
            * 小顶堆的建堆过程。  [杨柳给我讲懂了。只要记住**从最后一个非叶子节点开始**]
            * 堆排序的时间复杂度分为：首先构建一颗完全二叉树（是...），第一次建堆的时间复杂度(是O(n))，每次调整堆的时间复杂度（是O(logn)，[自然的。要么只需调整左子树，要么只需调整右子树]）。
    * 简单选择排序
            * 第一趟，把最小的**交换到**最左边。多次比较但一次交换
    *
    * 冒泡排序bubbleSort
            * 第一趟，把最大的**冒泡到**最右边。多次比较和多次两两交换
    * 快速排序
            * 每一趟，有一个枢纽元素**按插入排序的移动方式排到了**最终的位置。
            * 喜欢每一趟partition都能均匀地分成大致相等的两部分。
    * 二路归并排序
            * 每一趟，**二分到2个一组2个一组或最后有1个为一组**，每组都已排好序。剩下的趟数就是合并merge操作了。
    * 插入排序
            * 第一趟，**前一个元素**已经是排序好的状态。
            * 喜欢每一趟插入都“不用插入”。
    * 二分查找。最快查找次数1，最慢查找次数logn**左右**。
    * 平衡二叉树（实际中，红黑树比平衡二叉树更具有实用性）
            * 平衡二叉树是在**二叉排序树(BST)**上引入的，就是为了解决二叉排序树的不平衡性导致时间复杂度大大下降。所以每次的插入和删除都要确保二叉树的平衡
            * 调整过程。（调整不平衡树的基本方法就是：旋转，基本思路都是转换到左旋和右旋。）
                    1. 右旋。插入以后左边深度过大，围绕根节点，向右边旋转一格。  [简单]
                    2. 左旋。插入以后右边深度过大，围绕根节点，向左边旋转一格。  [简单]
                    3. 右左。先围绕次根节点右旋，再围绕根节点左旋。  [难点。其实是先解决子问题，再处理上层的根节点]
                    4. 左右。先围绕次根节点左旋，再围绕根节点右旋。  [难点。其实是先解决子问题，再处理上层的根节点]
                    * // （）（很清楚）https://segmentfault.com/a/1190000006123188

java基础知识

    * ThreadLocal类。  [难点。其他暂略]
            * 既synchronized之后，另一种实现并发需求的方式。当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
            * 使用ThreadLocal的话，表示每个线程的本地变量中都有SimpleDateFormat这个实例的引用，也就是**各个线程之间完全没有关系，也就不存在同步问题了**（ThreadLocal的变量在被多个线程使用时候，每个线程只能拿到该变量的一个副本）。
                    * // 不会造成内存泄露。每一个线程对资源副本都有一个weekReference：只要线程还在运行，使用ThreadLocal就是可以获取的。当一个线程运行结束销毁时，所有的资源副本都是可以被垃圾回收的（ThreadLocalMap对象保存在Thread对象中，当某个线程终止后，存储在其中的线程隔离的变量，也将作为Thread实例的垃圾被回收掉，所以完全不用担心内存泄漏的问题），这段注释表明，ThreadLocal的使用是不会造成内存泄露的。
            * 该线程的局部变量保存在ThreadLocalMap内部类对象中（每个线程对象都有一个自己的ThreadLocalMap内部类容器对象），k值为当前线程Thread类型的对象，value值为存储的局部变量。
            * ThreadLocal类有get()方法和set(T value)方法。
    * super()构造器和this()构造器
            * this()。
                    * 除了在构造器中使用，this永远指向一个具体的对象实例，所以this不能在静态方法中使用。
                    * this()。通过this调用另一个构造方法（可带参数），this()要放在第一行，这个**仅仅**在类的构造方法中，别的地方不能这么用。
            * super()。
                    * super永远是用在派生类中的。
                    * super()。通过super调用直接基类的构造方法（可带参数），super()也只能放到第一行（所以super()和this()不能同时出现）。
    * 泛型  [简单]
            * <? extends T>。
            * <? super T>。定义了下界是T
    * jvm内存配置：-Xmx2048m -Xms2048m -Xmn1024m
    * jvm内存配置：-XX:MaxPermSize=256m -XXSurvivorRatio=2。其最小内存值和Survivor区总大小分别是？
            * -Xmx2048m。最大堆的内存大小。
            * -Xms2048m。初始堆的内存大小。（与最大堆大小相等时，可以避免堆区垃圾回收完成后jvm自动调整（缩容）至-Xms指定大小）
            * -Xmn1024m。年轻代大小(jdk1.4 or lator)。
                    * 此处的大小是（eden+ 2 survivor space).与jmap -heap中显示的New gen是不同的。整个堆大小 = 年轻代大小 + 年老代大小 + 持久代大小.
            * -XXSurvivorRatio=v。两个Survivor区与一个Eden区的比值为2:v。
            * -XX:MaxPermSize=256m。[略]
            * 故最小内存值是2048m，Survivor区总大小是512m。

操作系统

    * 磁盘阵列。  [记不住可放弃]
    * 线程的优点
            * 线程提高了不同执行程序间的通信效率（实际上指的是，由于在同一个进程中的线程共享内存和文件，它们无须调用内核就可以互相通信。）
    * LRU分页式调度内存。  [简单]
    * 软链接与硬链接
            * 软链接（又叫符号链接）。优点是普通用户就可创建；不受不同文件系统的影响；可以作用在目录文件上。
            * 硬链接。相当于指针，指向inode。
    * 父进程，子进程  [难点。其他暂略]
            * 一个进程可能下属多个子进程，但最多只能有1个父进程，而若某一进程没有父进程，则可知该进程很可能由内核直接生成。
            * 子进程总是可以调用getppid来获得父进程的pid,父进程在调用fork函数时可以获得子进程的pid。

计算机网络

    * TCP协议。
            * TCP协议中保证数据传输可靠性的机制，是通过**数据重传**和**数据确认应答**来实现的。
            * TCP协议中三次握手机制解决的是，连接的建立。
            * TCP协议中三次握手和四次挥手客户端和服务器端各自发送和接收的信号有。
            * UDP包最大长度。  [记不住可放弃，或者查百度]
    * 网络分层
            * 数据链路层的主要功能是差错控制、流量控制和提供对物理层的控制。
            * 交换机工作在数据链路层，路由器工作在网络层。
                    * // 交换机与集线器不同之处是，集线器会将网络内某一用户发送的数据包传至所有已连接到集线器的电脑。
                         而交换机则只会将数据包发送到指定目的地的电脑（通过MAC表），相对上能减少数据碰撞及数据被窃听的机会。交换机更能将同时传到的数据包分别处理，而集线器则不能。
    * 子网掩码和ip地址  [其他暂略]
            * C类ip地址规定，前3个字节代表**网络地址**，最后1个字节代表**主机地址**。所以在不继续划分子网的情况下，最大的最常用的子网掩码是255.255.255.0
            * 若要继续划分子网，则肯定是对最后一个字节的高位几位的占用，对应新增加的子网掩码变为255.255.255.x（x代表了划分行为对最后一个字节的占用）
    * 总线
            * 总线（峰值）带宽 = 频率 * 位数 / 8。  [记住即可]    

组成原理

    * 中断。
            * 中断占据CPU时间的计算问题。  [难点。如果不是高频率题可以放弃]

数据库知识

    * 数据库是长期存储在计算机内的**有组织，可共享的数据集合**。  [记住即可]
    * 数据库管理系统的主要功能是**定义数据库**。
    * 事务。事务的并发。
    * 事务中的读操作和写操作（事务隔离级别）
            * （）（较简明）http://dr-yanglong.github.io/2016/06/06/transaction-feature/
            1. 脏读。写操作写，读操作读，写操作未成功读操作就读到了。
            2. 不可重复读。重点在于**修改**。读操作读，读操作又读，两次读结果竟然不一样。
            3. 幻读。重点在于**新增/删除**。读操作读，读操作又读，两次总记录竟然不一样。
    * SQL查询语言
            * 增加新的一列。

linux的bash上的命令

    * ps, top, netstat, ifconfig, df等各自的意思。
    * free。查看内存
    * rsync。本地与远程/远程与本地，同步
    * chmod。
            * 绝对模式。4, 2, 1相加。例如chmod 777 onefile
            * 符号模式。u, g, o, (a)。例如chomd ugo+r+w+x onefile

面试考点

自我介绍

[因为博客开放，所以略]

数据库

    * 索引，事务等概念
            * （）（聂庆的笔记）
            * 索引的作用。加快数据检索速度，其他...
    * JDBC连接过程
            * 加载驱动器。Class.forName(drive);
            * 建立与数据库的连接。DriverManager.getConnection()方法
            * 执行SQL语句。获得PreparedStatement对象
            * 关闭连接。
    * 内联结和外联结的区别。
            * 即使是在连接条件不满足的情况下，外部连接也会在结果集内返回行，而内部连接不会在结果集类返回行 
    * where, group by, order by, join的执行顺序。
            * 先ON，再JOIN，再WHERE，再GROUP BY，再HAVING，再SELECT，再DISTINCT，再ORDER BY，再LIMIT
    * MySQL数据库了解多少？索引了解吗？
            * 有哪些引擎类型；
            * 索引是不是越多越好；
            * 索引对顺序是敏感的吗

计算机网络

    * TCP/IP四层模型（TCP/IP参考模型）
            * 应用层。HTTP协议作用到的层
            * 传输层。TCP协议和UDP协议作用到的层
            * 最核心。IP协议作用到的层
            * 底层。
    * TCP协议的三次握手与四次挥手
            * TCP 并不能保证数据一定会被对方接收到，因为这是不可能的。TCP 能够做到的是，如果有可能，就把数据递送到接收方，否则就（通过放弃重传并且中断连接这一手段）通知用户
            * 建立连接的三次握手为什么不能改成两次。  [重要]
                    * 三次握手这个说法不好，其实是双方各一次握手，各一次确认，其中一次握手和确认合并在一起
                    * 如果改成两次，只有一次握手，和一次确认。 如果改成两次，无法解决“为了防止已失效的连接请求报文段突然又传送到了服务端，因而产生错误”。
            * 关闭连接的四次挥手为什么不能一样改成三次。  [重要]
                    * 原因是因为tcp是全双工模式，接收到FIN时意味将没有数据再发来，但是还是可以继续发送数据。
                    * 所以，在tcp三次握手建立连接时SYN是和ACK一起发送，但四次挥手关闭连接时FIN却没有和ACK一起发送。
    * TCP怎样实现面向连接？（TCP怎样保证面向连接的）。从几个维度来说明（1连接建立时2连接断开时3数据传输中时）
    * TCP协议报文头部都有哪些字段?
            * 源端口号。
            * 目的端口号。
            * 序号。
            * 确认序号。
            * 首部长度
            * 保留位
            * 窗口大小
            * 校验和
            * （紧急指针）
            * 数据
    * TCP协议的滑动窗口。
            * 发送窗口（发送者的发送缓冲区的一部分）
            * TCP建立连接的初始，接收端会告诉发送端自己的接收窗口大小。
            * TCP利用滑动窗口实现**流量控制**。
                    * 所谓流量控制，主要是接收方传递信息给发送方，使其不要发送数据太快，是一种端到端的控制。
                      主要的方式就是返回的ACK中会包含自己的**接收窗口的大小**，并且利用大小来控制发送方的数据发送。
            * 拥塞控制。  [难点]
                    * 慢开始、拥塞控制；快重传、快恢复
    * Http协议和http2.0
            * Http协议是用于从服务器传输**超文本**到本地浏览器的传输协议。
            * 默认使用80端口，本地浏览器发起一个请求，建立一个到服务器指定端口（默认是80端口）的TCP连接。
            * HTTP/1.0规定浏览器与服务器只保持短暂的连接，浏览器的每次请求都需要与服务器建立一个TCP连接，服务器完成请求处理后立即断开TCP连接，服务器不跟踪每个客户也不记录过去的请求。
            * HTTP/1.1支持持久连接，在一个TCP连接上可以传送多个HTTP请求和响应，减少了建立和关闭连接的消耗和延迟。
            * HTTP/2.0。  [略。不会]
            * HTTPS协议。
                    * HTTP协议直接运行在TCP协议之上。所有传输的内容都是明文，客户端和服务器端都无法验证对方的身份。
                    * https是HTTP协议运行在SSL之上，SSL运行在TCP协议之上。所有传输的内容都经过对称加密，但对称加密的密钥用服务器方的证书进行了非对称加密。
                    * [其他略。不会]
    * Http协议的报文的内容。其中的POST和GET方法主要是用来做什么的。

java基础

    * I/O有哪些类，涉及到哪些设计模式
            * 适配器设计模式。把InputStream等字节流类转换成Reader等字符流类
            * 装饰器设计模式。增加了缓冲的功能。例如把Reader类装饰为BufferedReader类
    * 阻塞io与非阻塞io（Java NIO的非阻塞模式）
            * 阻塞io。当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。**该线程在此期间不能再干任何事情了**。
            * Java NIO的非阻塞模式。使一个线程从**某通道**发送请求读取（写入）数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。（写入时不需要等待它完全写入。）而不是保持线程阻塞，所以**直至数据变的可以读取之前，该线程可以继续做其他的事情**。
            * 选择器（Selectors）。用一个线程来处理多个通道。  [暂略]
    * linux中的select和epoll。
            * 
    * java中的NIO、BIO和AIO分别是什么
            (1) BIO。多个线程同步访问资源，采用互斥锁。     （叫作，同步并阻塞。）  -> 编程简单
            (2) NIO。多个线程同步访问资源，采用I/O多路复用。（叫作，同步非阻塞）    -> 
            (3) AIO。高级，充分调用操作系统参与并发操作。   （叫作，异步）          -> 编程复杂、困难
    * 什么时候用抽象类，什么时候用接口
            * 抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法;
            * 抽象类可以有静态代码块和静态方法;
            * 一个类却可以实现多个接口（类似c++中的多继承）
            * 那么何时用抽象类？何时用接口呢？
                    * 抽象类表示它是什么，接口表示它能做什么。
                      抽象类适合用来定义某个领域的固有属性，也就是本质，接口适合用来定义某个领域的扩展功能
                    * 接口容易被滥用。《java编程思想》中说到，要合适地使用，而不是滥用。
    * 进程间通信，linux
            * （）（简单）http://www.imooc.com/article/11177
            * 管道。
            * 信号signal。信号是比较复杂的通信方式。  [难点]
            * 消息队列。
            * 共享内存。最快，往往与信号量通信方式相结合。
            * 信号量semaphore。主要作为多个进程间（或多个线程间）的同步手段。
            * socket。更为一般的进程间通信机制，可用于不同机器之间的进程通信。
    * 多线程：三个线程运行，处理完后回到主线程，怎么做？
            * 没有限定三个线程之间是同步关系还是异步关系，但要求“处理完后回到主线程”，则主线程和这三个线程之间限定为是同步的关系。
            * 可以设置一个线程安全的计数器类，(该计数器类可以用传统的synchronized/互斥锁/同步锁机制来实现)，在主线程中判断当计数器类型的变量count==3时，跳出while(true)循环，进而执行主线程接下来的操作。
    * HashMap的实现原理
            (1) HashMap在数据结构中又叫散列表，映射表。它的特点是，借助hash算法来存储k-v键值对，并可以在O(1)时间内找到k对应的v。
            (2) java里HashMap的实现是通过table数组和单链表实现的。其中单链表采用头插法来增加新的结点，单链表中存储<k, v> pair。
            (3) 最后以put()方法做原理说明。先得到key对象的hashcode值，该值是int4字节32位，把它右移16位再与原值本身做异或（即把它的高16位和低16位做异或）得到新值，把这个新值进行hash算法（& table数组的长度-1。当length总是2的n次方时，h& (length-1)运算等价于对length取模，也就是h%length，但是&比%具有更高的效率）得到在table数组中的索引值。
                若该索引值下已经有单链表存在，则循环单链表，判断key对象是否存在...；若该索引值下为空，则填充table数组（创建一个单链表）...
                // 注意插入成功后，要进行扩充判断（判断已填充容量是否大于负载因子0.75， 若大于则容量扩充到两倍）（按2倍长度的递增）。
                        * // 扩容时，是在内存中开辟新的内存空间。  [难点]
            // 在jdk1.8中，若单链表的节点数大于8，则会转化成红黑树（进一步提高查询效率）。
    * 怎么样把HashMap变成线程安全的（ConcurrentHashMap的实现原理）  [重要。经常被问到]
            * 要回答到3点。什么，什么与扩容。  [难点。要会]
    * HashMap扩容时容易发生内存溢出的原因，java的内存泄漏与内存溢出。
            * HashMap要保存<k, v> pair, 相对于其他List容器，多占用了内存，并且它的扩容策略是2倍长度的递增, 因此发生扩容需求时，如果内存里没有这么大的地方, 就报错了（出现内存溢出）。
              所以，我们应该尽量让HashMap中的元素少量并简单。
            * 内存泄露是指无用对象（不再使用的对象）持续占有内存或无用对象的内存得不到及时释放，从而造成的内存空间的浪费称为内存泄露。
                    * 那么，Java内存泄露根本原因是什么呢？长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露。
                      尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景。
                    * 像HashMap、Vector等的使用最容易出现内存泄露，这些静态变量的生命周期和应用程序一致，他们所引用的所有的对象Object也不能被释放，因为他们也将一直被Vector等容器引用着。 
            * 内存溢出：指程序运行过程中无法申请到足够的内存而导致的一种错误。内存泄露是内存溢出的一种诱因，不是唯一因素。
    * 多线程会写吗？多线程有没有应用到实际工程项目中的例子？
    * 有没有使用过（接触过）java的开源框架、各种中间件、消息队列什么的？
            * 网易一面面试官给我的建议。“互联网后端的技术体系已经比较成熟，如果你要从事互联网公司的后端开发这一类方向，需要对它们（技术体系）有了解和熟悉。
              缓存、扩容扩表的数据库和其他中间件等，就是为了解决大数据量、高并发环境等痛点而产生的。这些中间件、消息队列和缓存等，你最终都需要掌握它们。
              当然，J2EE（spring框架、struts框架）等，也都需要了解和熟悉和掌握它们。”
            * 美团点评二面面试官给我的建议。加强基础这样来突出优势点。（因为相比有契合项目的同学来说，你要有突出的优点作为闪光点。）
    * 实现多线程的方式
            * 继承Thread类，并重写run()方法
            * 实现Runnable接口
    * 线程安全问题
            * 定义。如果一个类在多个线程访问下正常运转，并且访问类不需要进行额外的并发手段，那么我们认为这个类是线程安全的。
    * 什么是线程池？如果让你设计一个动态大小的线程池，如何设计，应该有哪些方法？
            * 定义。事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕后不需要销毁线程而是返回池中，从而减小创建和销毁线程对象的开销。
            * 一个线程池包括以下四个基本单位：
                    * ThreadPool。                                                -> 创建线程池，销毁线程池
                    * 线程池中的线程，在没有任务时，处于等待任务的状态。
                    * 任务队列TaskQueue。用于存放待处理的任务，提供一种缓冲机制。 -> execute(Runnable task)把任务加入任务队列
                    * 任务接口。用于定义一个任务
    * volatile与synchronized区别
            (1) volatile保证可见性，但不保证原子性。  -> 代价小
            (2) synchronized保证了可见性和原子性。    -> 代价高
    * synchronized与lock的区别，使用场景，看过synchronized的源码没？
            * lock是jdk1.5新增加的，是显式锁（需要程序员手动书写加锁和解锁的语句），提供更细粒度的同步锁机制。
            * [暂略]
    * sleep()方法和wait()方法
            (1) sleep()是Thread类的方法，而wait()是Object类中的方法（一般与notify()/notifyAll()连用）。。
            (2) sleep()是类方法（static方法），只是将CPU让给其他线程几秒钟而该线程进入阻塞状态，但该线程本身并不会释放同步锁（互斥锁），因此几秒钟后就会从阻塞状态回到就绪状态。
                而wait()是实例方法，该线程会释放它占有的同步锁（互斥锁）并进入阻塞状态，但除非接下来调用了该线程对象的notify()/notifyAll()方法，才会进入等锁池（若重新获得锁，就会回到就绪状态）。
    * 设计模式 -单例模式
            * 最简单方法。2个规定：
                    * 规定构造器是private的，所以通过调用其他非private方法来间接调用该构造器，进而这种方法必须是static的。
                    * 规定只能创建一个对象。所以由static成员变量来指向这个单例对象。
                    * // 但在多线程环境下，此方法并不能保证只会创建一个对象。
            * 第二种方法。把调用构造器的那个方法加synchronized关键字。
            * 常考。**双重检查锁方法**和**枚举类方法**。  [难点]
    * 异常。
            * 异常分为两种（Exception，Error）。
            * Error程序无法处理，Exception程序可以处理（可以细分为，编译期异常和运行时异常）。
    * static和final的区别和用途。
            * static
                    (1) 类变量。内存中只有一个
                    (2) 类方法。
                    (3) 静态代码块。注意初始化顺序（基类静态代码块->派生类静态代码块->基类其他代码块和基类构造器->派生类其他代码块和派生类构造器）。  [重点。难点]
            * final
                    (1) 常量。特殊的java成员变量。
                    (2) final方法。无法被派生类访问到（没权限，相当于加了private），进而无法重写。
                    (3) final类。无法被extends继承（如java的Math类，String类）
    * 字符串。
            (1) String, StringBuffer和StringBuilder。
                    * 都是final类，因而无法被extends继承。
                    * String类型的对象长度不可变（不变性），而后两者长度是可变的。
                    * StringBuffer是线程安全的，而StringBuilder线程不安全。StringBuilder比StringBuffer拥有更好的性能。
            (2) String不变性的理解。
                    * 是final类，无法被extends继承。
                    * 使用“+”连接符时，会创建新的字符串（实际底层会转成通过一个StringBuilder对象的append()方法来实现）。（涉及到两块内存区域，常量区的字符串常量、堆中的String对象。）
    * Object类的hashcode()和equals()
            (1) hashcode是equals的必要不充分条件。
            (2) 自己定义一个类（包括学号，姓名，年龄）。当年龄自然增加时，需要保证其hashcode不能改变。
    * java的封装、继承和多态。  [其他暂略]
    * 重载方法与重写方法的区别。如果参数是List<Integer>和List<String>时，是否可以成功写成两个不同的重载方法。
    * 泛型的两种加参数的写法？
    * 匿名内部类。
    * java序列化。  [重点]
            (1) 定义。将**实现Serializable接口**的对象转换成一个字节序列。（字节流比字符流原始，）并能够在以后将这个字节序列完全恢复为原来的对象（反序列化）。
                涉及到io类库的ObjectOutputStream类和ObjectInputStream类。
            (2) 常见的序列化协议有哪些？
                    * JSON
                    * COM
                    * XML
                    * ...
            (3) // 被static修饰的成员变量（类变量）不能被序列化。
    * java序列化需要实现哪个接口（实现Serializable接口）？序列化中ID需要做什么特殊处理？如果成员变量不想让它被序列化，需要加什么关键字?
    * java里面的引用计数器放在哪儿里面？（栈，堆，还是方法区）
    * 给你两个字符串，你会怎样计算它们之间的相似度？（用什么样的数据结构，或者用什么样的方法）
    * 数据库字段（float型，或double型）精度丢失问题。怎么解决？
    * java内存模型。
            * （infoq）（很精彩）http://www.infoq.com/cn/articles/java-memory-model-1
            * 通信是指线程之间以何种机制来交换信息。在命令式编程中，线程之间的通信机制有两种：共享内存和消息传递。
            * Java的并发采用的是共享内存模型，Java线程之间的通信总是隐式进行，整个通信过程对程序员完全透明。
                    * // 在共享内存的并发模型里，线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信。
            * 主内存与工作内存。
                    * 在java中，所有实例成员变量、类成员变量和数组元素存储在堆内存中，堆内存在线程之间共享；而局部变量等不会在线程之间共享，它们不会有内存可见性问题，也不受内存模型的影响。
                    * java内存模型决定一个线程对共享变量的写入何时对另一个线程可见。注意到本地内存中保存主内存中共享变量的副本。
                      java内存模型通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证。
                            * // 本地内存是java内存模型的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。
    * java内存区域（java虚拟机内存区域）
            * 堆（区）。                                          -> 公共
            * 方法区。常量、静态变量等编译后的数据。              -> 公共
            * 程序计数器。当前线程所执行的字节码的**行号指示器**。-> 线程私有
            * 虚拟机栈。                                          -> 线程私有
            * 本地方法栈。                                        -> 线程私有
    * 垃圾回收机制（垃圾回收算法）
            1. 标记-清除算法。缺点：会产生大量不连续的内存碎片。
            2. 复制算法。分成两块，一块作为缓存使用。
            3. 标记-整理算法。数组移动来“填洞”。
            4. 新生代老生代算法。把java的堆分为新生代和老生代。
    * 对象已死吗？
            * 引用计数器。主流的java虚拟机里没有采用它，因为它很难解决对象之间相互循环引用的问题。
            * 可达性分析。当一个对象到GC Roots没有任何引用链相连（用图论的话来说，就是从GC Roots到这个对象不可达）时，则证明此对象是不可用的。
    * 类的加载过程（类加载机制）（类从class文件到实际加载到内存中）。
            * 虚拟机把Class文件加载到内存，并对数据进行校验、解析和初始化，这就是虚拟机的类加载机制。
            1. 加载
                    * 查找该类对应的.class文件。
                    * 载入.class文件。
                    * 生成并装载该类的**Class对象**。
            2. 验证
            2. 准备
            2. 解析
                    * 验证。  [略。校验一类的工作，没什么可讲的。]
                    * 准备。为类变量分配内存并设置类变量初始值。（都将在方法区分配，final类变量特例。）  [重要]
                    * 解析。可延迟开始。
            3. 初始化
                    * [重要]
            （4. 使用）
            （5. 卸载）
            *
            * 类加载器（ClassLoader）
                    * 用于加载类的一种方法。jvm生成几个ClassLoader，调用指定的ClassLoader去加载.class文件。
                            * 是“委派”结构，而不是继承结构。
                    1. Bootstrap Loader（启动类加载器）。
                    2. ExtendedLoader（标准扩展类加载器）。
                    3. AppClassLoader（系统类加载器）。
                    * // 最后由AppClassLoader加载HelloWorld类。
    *
    * c++模板Template
            * 类模板。如果一个类中数据成员的数据类型不能确定，或者是某个成员函数的参数或返回值的类型不能确定，就必须将此类声明为模板，它的存在不是代表一个具体的、实际的类，而是代表着一类类。
            * 函数模板。函数模板可以用来创建一个通用的函数，以支持多种不同的形参，避免重载函数的函数体重复设计。
    * 敏捷开发是什么
            * 是一种**应对快速变化的需求**的一种软件开发能力，频繁交付新的软件版本。  [其他略]
    * 一个软件开发项目的整体流程是什么？（传统的瀑布流开发）
            * 需求分析
            * 可行性分析
            * 编写项目计划书。项目功能模块划分开发周期安排，开发人员安排及工作分配。
            * 系统设计
            * 数据库设计
            * 架构设计
            * 代码开发
            * 测试
            * 发布或提交给客户
    * 白盒测试和黑盒测试
            * 黑盒测试。不考虑内部逻辑结构、针对软件界面和软件功能进行测试。（黑盒是模拟用户操作，点点看看。）是穷举输入测试，只有把所有可能的输入都作为测试情况使用，才能以这种方法查出程序中所有的错误。
            * 白盒测试。一般是程序员自己所做的测试。了解程序内部逻辑结构，检查程序内部的逻辑。

数据结构与算法

    * 快速排序
            * 按照分治三步法，将快速排序算法作如下介绍：
                    * 划分问题(partition)。把数组中的各个元素重排后（双指针法，交换）分成左右两部分（插入排序的一部分内容）。  [重点]
                    * 递归求解。把左右两部分分别排序。
                    * 合并问题。不用合并，因为此时数组已经完全有序。
            * // 可以写成有稳定性的。
            * // 划分partition循环结束的标志是。当两个指针位置**交叉**时
    * 归并排序
            * 按照分治三步法，将（二路）归并排序算法作如下介绍：
                    * 划分问题(partition)。尽量分成数量相等的两部分（二分查找的一部分内容）。
                    * 递归求解。把左右两部分分别排序。
                    * 合并问题。需要合并，这是归并排序算法的重点和较容易出错的地方（3个while()循环写法的一部分内容）。  [重点]
            * // 可以写成有稳定性的。
            * // 3个while()循环写法可以简化成1个while()。
    * 10GB的url文件，去重后统计出来。  提示->merge  [暂略]
    * java虚拟机的内存碎片产生的原因和解决措施。  [暂略]
    * class文件保存在哪里（类加载过程）  [暂略]
    * java并发之synchronized关键字底层怎么实现的。信号量  [暂略]
    * 为了避免高并发情形下的过多的上下文切换，java有哪些解决方法？  [暂略]
    * CAS，分布式里面的。了解不？  [暂略]
    * 字符串转成数字。(int)(c - '0')可以优化为位运算的方法c & (~48)  [暂略]
    * 
    * Object类有哪些方法。
    * java的数据类型有哪些。
    * java里本身就有数组类型，那int[]数组和ArrayList类有什么区别？
    * 集合类库里有哪些类，其底层的数据结构实现是什么？
    * 操作系统。ubuntu命令：查看内存、查看所在端口通不通、本地主机与服务器的同步命令
    * 计算机网络。TCP的三次握手为什么不是两次。        

其他，和项目

    * [因为博客开放，所以其他略]
    * 项目1不了解简单介绍一下。项目2详细地说，整个流程说一遍（最好画个图）