互联网公司校招Java面试题总结及答案——网易_网易面试java代码题目

因为时间有限，所以这部分很多都没有整理答案，后序有时间再补上。

其他请参看我的系列文章：

互联网公司校招Java面试题总结及答案——阿里、腾讯

互联网公司校招Java面试题总结及答案——微店、去哪儿、蘑菇街

互联网公司校招Java面试题总结及答案——招银科技

互联网公司校招Java面试题总结及答案——乐视、滴滴、华为

互联网公司校招Java面试题总结及答案——CVTE

互联网公司校招Java面试题总结及答案——美团

（ 百度Java面经）互联网公司校招Java面试题总结及答案——百度（目前只是部分总结）

互联网公司校招Java面试题总结及答案——京东

--------------------------------------------网易--------------------------------------------

2.输入www.baidu.com会发生什么？

除了说HTTP请求，面试官还暗示想让说CDN和负载均衡的知识

3.Linux下 给定一个文件，里面存放的是IP地址，统计各个IP地址出现的次数

4.针对HashMap中某个Entry链太长，查找的时间复杂度可能达到O(n)，怎么优化？

目前在jdk1.8中，采用了新的红黑树的结构来实现，当链表的数量大于8的时，就会将冲突的节点保存在红黑树里。

5.对10G个数进行排序，限制内存为1G,但是这10G个数可能是整数，字符串以及中文改如何排序

用外排序+k路归并解决

8.hash冲突的四种办法

开放地址法，链地址法，建立公共溢出区，再hash

10.给你一个表只有一列name~~有重复的name, 然后求出前十个name数最大的：

select name,count(name) from table group by name desc limit 10

12.为什么java要有垃圾回收？

1、为什么要进行垃圾回收：

　      在C++中，对象所占的内存在程序结束运行之前一直被占用，在明确释放之前不能分配给其它对象；而在Java中，当没有对象引用指向原先分配给 某个对象 的内存时，该内存便成为垃圾。 垃圾回收能自动释放内存空间，减轻编程的负担，JVM的一个系统级线程会自动释放该内存块。垃圾回收意味着程序不再需要的对象是"无用信息"，这些信息将 被丢弃。当一个对 象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用。事实上，除了 释放没用的对象，垃圾回收也可以 清除内存记录碎片。由于创建对象和垃圾回收器释放丢弃对象所占的内存空间，内存会出现碎片。碎片是分配给对象的内存块之间的空闲内存洞。碎片整理将所占用的堆内存移到堆的一端，JVM将整理出的内存分配给新的对象。

2、如何进行垃圾回收：

          Java语言规范没有明确地说明JVM使用哪种垃圾回收算法，但是任何一种垃圾回收算法一般要做2件基本的事情：（1）发现无用信息对象；（2）回收被无用对象占用的内存空间，使该空间可被程序再次使用。

　 　大多数垃圾回收算法使用了根集(root set)这个概念；所谓根集就是正在执行的Java程序可以访问的引用变量的集合(包括局部变量、参数、类变量)，程序可以使用引用变量访问对象的属性和 调用对象的方法。垃圾回收首先需要确定从根开始哪些是可达的和哪些是不可达的，从根集可达的对象都是活动对象，它们不能作为垃圾被回收，这也包括从根集间 接可达的对象。

3、对于特殊区域的垃圾回收（比如调用cc语言中的malloc（）函数进行空间的分配那么垃圾回收机制就不能回收这类特殊空间）： 之所以要使用finalize()，是存在着垃圾回收器不能处理的特殊情况。假定你的对象（并非使用new方法）获得了一块“特殊”的内存区域，由于垃圾 回收器只知道那些显示地经由new分配的内存空间，所以它不知道该如何释放这块“特殊”的内存区域，那么这个时候java允许在类中定义一个由 finalize()方法

4、触发GC（Garbage Collector）的条件：

　JVM进行次GC的频率很高,但因为这种GC占用时间极短,所以对系统产生的影响不大。更值得关注的是主GC的触发条件,因为它对系统影响很明显。总的来说,有两个条件会触发主GC:

　　1)当应用程序空闲时,即没有应用线程在运行时,GC会被调用。 因为GC在优先级最低的线程中进行,所以当应用忙时,GC线程就不会被调用,但以下条件除外。

　　2) Java堆内存不足时,GC会被调用。 当应用线程在运行,并在运行过程中创建新对象,若这时内存空间不足,JVM就会强制地调用GC线程,以便回收内存用于新的分配。若GC一次之后仍不能满足 内存分配的要求,JVM会再进行两次GC作进一步的尝试,若仍无法满足要求,则 JVM将报“out of memory”的错误,Java应用将停止。

5、减少GC开销的措施：

1. 不要显示的调用System.gc（）
2. 尽量减少临时对象的使用
3. 对象不用的时候最好显示置空
4. 尽量使用StringBuffer，不实用String累加字符串（String的特性有关）
5. 能使用基本数据类型就不要使用封装类
6. 尽量减少静态对象变量的使用

6、注意：

1. GC的回收时间是不确定的，即使你显示的调用的System.gc()。因为和线程优先级有关
2. 使用了finalize（）方法之后，GC是在这个方法执行之后的下一次进行垃圾的回收。

14.String 转出 int型，判断能不能转？如何转？

15.controller怎么处理的请求：路由

16.介绍数据仓库

数据仓库，是为 企业所有级别的决策制定过程，提供所有类型数据支持的战略 集合。数据仓库（Data Warehouse）是一个面向主题的（Subject Oriented）、集成的（Integrate）、相对稳定的（Non-Volatile）、反映历史变化（Time Variant）的数据集合，用于支持管理决策。

所谓的

（1） 面向主题：指数据仓库中的数据是按照一定的主题域进行组织。主题是指用户使用数据仓库进行决策时所关心的重点方面，一个主题通常与多个操作型信息系统相关。

（2）集成：指对原有分散的数据库数据经过系统加工, 整理得到的消除源数据中的不一致性。

（3）相对稳定：指一旦某个数据进入数据仓库以后只需要定期的加载、刷新。数据仓库是不可更新的，数据仓库主要是为 决策分析提供数据，所涉及的操作主要是数据的查询；

（4）反映历史变化：指通过这些信息，对企业的发展历程和未来趋势做出定量分析预测。

19.treemap的实现

底层是红黑树实现。

21.如何解决Java GC 导致的延迟问题.

设置gc的算法，优化程序，使用分布式jvm等等方法吧

23.动态代理的原理

AOP的原理就是java的动态代理机制。在java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)。每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用 一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy:　　指代我们所代理的那个真实对象

method:　　指代的是我们所要调用真实对象的某个方法的Method对象

args:　　指代的是调用真实对象某个方法时接受的参数

Proxy这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是  newProxyInstance 这个方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

loader:　　一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载

interfaces:　　一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了

h:　　一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

24.java虚拟机类加载机制

加载：阶段主要完成 三件事，即通过一个类的全限定名来获取定义此类的二进制字节流，将这个字节流所代表的静态 存储结构转化为方法区的运行时数据结构，在Java堆中生成一个代表此类的Class对象，作为访问方法区这些数据的入口。

验证：确保Class文件的字节流中包含信息符合当前虚拟机要求，不会危害虚拟机自身安全。主要包括四种验证：文件格式验证、元数据验证、字节码验证、符号引用验证。

准备：仅仅为类变量(即static修饰的字段变量)分配内存并且设置该类变量的初始值即零值，这里不包含用final修饰的static，因为final在编 译的时候就会分配了，同时这里也不会为实例变量分配初始化。类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中。

解析：主要就是将常量池中的符号引用替换为直接引用的过程。

初始化：阶段依旧是初始化类变量和其他资源，这里将执行用户的static字段和静态语句块的赋值操作。这个过程就是执行类构造器方法的过程。

类加载器的分类：启动类加载器、扩展类类加载器、应用程序类加载器。

1)使用new关键字 实例化对象的时候，读取或设置一个类的静态字段时候(除final修饰的static外)，调用类的静态方法时候，都只会初始化该静态字段或者静态方法所定义的类。

　　2)使用reflect包对类进行放射调用的时候，如果类没有进行初始化，则先要初始化该类

　　3)当初始化一个类的时候，如果其父类没有初始化过，则先要触发其父类初始化。

　　4)虚拟机启动的时候，会初始化一个有main方法的主类

注意：通过子类引用父类静态字段，只会初始化父类不会初始化子类;通过数组定义来引用类，也不会触发该类的初始化;常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此也不会触发定义常量的类的初始化。

25.包装类型和基本类型比较问题（例如，Integer类型的变量能否==int类型变量，能否作比较，什么时候不能作比较）

一个包装对象和一个基本类型的值进行比较是比较值，而不是比较引用。

26.java锁机制

把代码块声明为  synchronized，有两个重要后果，通常是指该代码具有  原子性（atomicity）和  可见性（visibility）。

volatile只保证可见性，不保证原子性！

ReentrantLock  类实现了 Lock  ，它拥有与 synchronized  相同的并发性和内存语义，但是添加了类似 锁投票 、 定时锁等候 和 可中断锁等候 的一些特性。此外，它还提供了在激烈争用情况下 更佳的性能 。

用sychronized修饰的方法或者语句块在代码执行完之后锁自动释放，而是用Lock需要我们 手动释放锁，所以为了保证锁最终被释放(发生异常情况)， 要把互斥区放在try内，释放锁放在finally内！！

读写锁ReadWriteLock，与互斥锁定相比，读-写锁定允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程（ writer 线程）可以修改共享数据，但在许多情况下，任何数量的线程可以同时读取共享数据（ reader 线程）。

Condition可以替代传统的线程间通信， 用 await() 替换wait()，用 signal() 替换notify()，用 signalAll() 替换notifyAll()。

——为什么方法名不直接叫wait()/notify()/nofityAll()？因为Object的这几个方法是final的，不可重写！

临界区(Critical Section)，互斥量(Mutex)，信号量(Semaphore)都是同步的一种手段

在任意时刻只允许一个线程对 临界区共享资源进行访问。

互斥量比临界区复杂。因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享，而且可以在不同应用程序的线程之间实现对资源的安全共享。

管程和信号量是一个概念。指一个互斥独占锁定的对象，或称互斥体。

协同式：线程的执行时间由线程本身来控制，线程任务执行完成之后主动通知系统切换到另一个线程去执行。（  不推荐）

    优点：实现简单，线程切换操作对线程本身是可知的，不存在线程同步问题。

    缺点：线程执行时间不可控制，如果线程长时间执行不让出CPU执行时间可能导致系统崩溃。

抢占式：每个线程的执行时间有操作系统来分配，操作系统给每个线程分配执行的时间片，抢到时间片的线程执行，时间片用完之后重新抢占执行时间，线程的切换不由线程本身来决定（  Java使用的线程调度方式就是抢占式调度）。

    优点：线程执行时间可控制，不会因为一个线程阻塞问题导致系统崩溃。

ReentrantLock相比于synchronized的优势：

• 等待可中断：在持有锁的线程长时间不释放锁的时候,等待的线程可以选择放弃等待.
• 公平锁：按照申请锁的顺序来一次获得锁称为公平锁.synchronized的是非公平锁,ReentrantLock可以通过构造函数实现公平锁.    new RenentrantLock(boolean fair)
• 锁绑定多个条件：通过多次newCondition可以获得多个Condition对象,可以简单的实现比较复杂的线程同步的功能.通过await(),signal();

为了让线程获得锁的代价更低而引入了偏向锁。当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退 出同步块时不需要花费CAS操作来加锁和解锁，而只需简单的测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁，如果测试成功，表示线程已经获得了锁，如果测试失败，则需要再测试下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁），如果没有设置，则使用CAS竞争锁，如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线 程。

偏向锁的撤销：偏向锁使用了一种等到竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。偏向锁的撤销，需要等待全局 安全点（在这个时间点上没有字节码正在执行），它会首先暂停拥有偏向锁的线程，然后检查持有偏向锁的线程是否活着，如果线程不处于活动状态，则将对象头设 置成无锁状态，如果线程仍然活着，拥有偏向锁的栈会被执行，遍历偏向对象的锁记录，栈中的锁记录和对象头的Mark Word要么重新偏向于其他线程，要么恢复到无锁或者标记对象不适合作为偏向锁，最后唤醒暂停的线程。

27.假如有100万个玩家，需要对这100W个玩家的积分中前100名的积分，按照顺序显示在网站中，要求是实时更新的。积分可能由做的任务和获得的金钱决定。问如何对着100万个玩家前100名的积分进行实时更新？

我的想法是使用小端桶（堆？），先把前100名放进去，然后后面的那些谁的分数变化就与桶中的值比较，如果大就替换。

29.minor GC和Full GC的触发时机

Minor GC触发条件：当Eden区满时，触发Minor GC。

Full GC触发条件：

（1）调用System.gc时，系统建议执行Full GC，但是不必然执行

（2）老年代空间不足

（3）方法去空间不足

（4）通过Minor GC后进入老年代的平均大小大于老年代的可用内存

（5）由Eden区、From Space区向To Space区复制时，对象大小大于To Space可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小

31.重入锁、对象锁、类锁的关系

对象锁(方法锁)，是针对一个对象的，它只在该对象的某个内存位置声明一个标识该对象是否拥有锁，所有它只会锁住当前的对象，一般一个对象锁是对一 个非静态成员变量进行synchronized修饰，或者对一个非静态成员方法进行synchronized进行修饰，对于对象锁，不同对象访问同一个被 synchronized修饰的方法的时候不会阻塞

类锁是锁住整个类，当有多个线程来声明这个类的对象时候将会被阻塞，直到拥有这个类锁的对象呗销毁或者主动释放了类锁，这个时候在被阻塞的线程被挑选出一个占有该类锁，声明该类的对象。其他线程继续被阻塞住。

32.什么情况会栈溢出

（1）可能是由于循环的递归引起的。无限递归

（2）由于分配了过大的局部变量引起。

33.反射机制中可以获取private成员的值吗（没有set和get函数）

35.http状态码3xx 4xx 5xx分别是啥

        重定向，客户端错误，服务器端错误

36.一个项目，理论上需要1.5G的内存就足够，但是项目上线后发现隔了几个星期，占用内存到了2.5G，这时候你会考虑是什么问题？怎么解决？

我回答会首先考虑内存泄漏，使用MemeryAnalyzer之类的工具分析检查哪里有泄漏，然后他又问用过MemeryAnalyzer吗？ 我说没用过。。

38.哪些方法实现线程安全。

        synchronized，reentrantlock，volatile，然后重点说了下volatile在某些情况下可以实现线程安全，然后就把面试官注意力往volatile上引，因为volatile这个专门看了一下，果然，面试官马上问了volatile。

39.volatile是实现了什么功能呢？

        然后就把自己看得乱扯了一通，比如volatile修饰汇编时会在修饰字段前加LOCK字段啊，内存屏障啥啥啥的扯了一通，就是想让面试官觉得对某些方面了解还是蛮深的。

40.如果想实现一个线程安全的队列，可以怎么实现？

        JUC包里的ArrayBlockingQueue 还有LinkedBlockingQueue啥的又结合源码说了一通

1.说说servlet生命周期？

1，初始化阶段  调用init()方法

2，响应客户请求阶段　　调用service()方法

3，终止阶段　　调用destroy()方法

HashMap是非线程安全的，Hashtable是线程安全的，但是由于Hashtable是采用synchronized进行同步，相当于所有线程进行读写时都去竞争一把锁，导致效率非常低下。

ConcurrentHashMap 类中包含两个静态内部类 HashEntry 和 Segment。HashEntry 用来封装映射表的键 / 值对；Segment 用来充当锁的角色，每个 Segment 对象守护整个散列映射表的若干个桶。每个桶是由若干个 HashEntry 对象链接起来的链表。一个 ConcurrentHashMap 实例中包含由若干个 Segment 对象组成的数组。

ConcurrentHashMap为了提高本身的并发能力，在内部采用了一个叫做Segment的结构，一个Segment其实就是一个类Hash Table的结构，Segment内部维护了一个链表数组，我们用下面这一幅图来看下ConcurrentHashMap的内部结构：

　 　从上面的结构我们可以了解到，ConcurrentHashMap定位一个元素的过程需要进行两次Hash操作，第一次Hash定位到Segment， 第二次Hash定位到元素所在的链表的头部，因此，这一种结构的带来的副作用是Hash的过程要比普通的HashMap要长，但是带来的好处是写操作的时 候可以只对元素所在的Segment进行加锁即可，不会影响到其他的Segment，这样，在最理想的情况下，ConcurrentHashMap可以最 高同时支持Segment数量大小的写操作（刚好这些写操作都非常平均地分布在所有的Segment上），所以，通过这一种结 构，ConcurrentHashMap的并发能力可以大大的提高。

 ConcurrentHashMap 的高并发性主要来自于三个方面：

1. 用分离锁实现多个线程间的更深层次的共享访问。
2. 用 HashEntery 对象的不变性来降低执行读操作的线程在遍历链表期间对加锁的需求。
3. 通过对同一个 Volatile 变量的写 / 读访问，协调不同线程间读 / 写操作的内存可见性。

使用分离锁，减小了请求 同一个锁的频率。

通过 HashEntery 对象的不变性及对同一个 Volatile 变量的读 / 写来协调内存可见性，使得 读操作大多数时候不需要加锁就能成功获取到需要的值。由于散列映射表在实际应用中大多数操作都是成功的 读操作，所以 2 和 3 既可以减少请求同一个锁的频率，也可以有效减少持有锁的时间。

（1）线程安全的集合：

vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用。在web应用中，特别是前台页面，往往效率（页面响应速度）是优先考虑的。

statck：堆栈类，先进后出

hashtable：就比hashmap多了个线程安全

enumeration：枚举，相当于迭代器

StringBuffer是线程安全，而StringBuilder是线程不安全的。

（2）

hashTable同步的，线程安全，而HashMap是非同步的，线程不安全，效率上逼hashTable要高。

hashMap允许空键值，而hashTable不允许。

HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。

Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类；

HashMap实现同步的方法：调用Collections的静态方法 Collections.synchronizedMap(Map map);，返回一个同步的Map，这个Map封装了底层的HashMap的所有方法，使得底层的HashMap即使是在多线程的环境中也是安全的。

同时说一下，ArrayList和HashSet，他们也都不是同步的，都是线程不安全的，对其实现同步的方式和HashMap的方式相同，都允许使用null元素，ArrayList分配的初始空间为10，HashSet分配的初始空间为16

4.说一下NIO变成，讲NIO与传统IO作对比。NIO主要用来解决什么问题？

5.Memcache如何进行hash来寻找服务器的，就是说如何实现分布式映射的（求余hash方法，一致性hash算法）。

6.线程池中的主要参数有什么（CorePoolSize，MaxPoolSize）。

7.同步的方式有哪些，为什么叫重入锁（递归锁）？

8.知道哪些设计模式，说说看》

9.写一个函数用来将一个字符串转换成日期（主要考察SimpleDateFormat线程安全，还有并发（用ThreadLocal来做））

10. 关于synchronized的问题，

class A {

synchronized void f1(){}

synchronized void f2(){}

}

Thread T1,T2，分别调用A的f1和f2是否会相互之间有影响。

这个问题实际上很简单，就是对象锁问题。

11.问了项目中心跳机制如何实现的，心跳包内容是什么？

12.写一个单例模式。

13.final关键字

类：在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。final类中的方法默认是final的，变量则不是；

方法：只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。注：类的private方法会隐式地被指定为final方法。

变量：对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

引用变量被final修饰之后，虽然不能再指向其他对象，但是它指向的对象的内容是可变的。

static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。

方便在没有创建对象的情况下来进行调用（方法/变量）。

很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。

static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。

记住，即使没有显示地声明为static，类的构造器实际上也是静态方法。

static是不允许用来修饰局部变量。

static关键字只会出现在类中，不会出现在任何方法中。

这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

一个对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。

总之，java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。

2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。

3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

若实现的是Externalizable接口，则没有任何东西可以自动序列化，需要在writeExternal方法中进行手工指定所要序列化的变量，这与是否被transient修饰无关。