2015网易校招Java开发工程师(技术架构)在线笔试题

1、  程序和进程的本质区别是？

A、在外存和内存存储

B、非顺序和顺序执行机器指令

C、独占使用和分时使用计算机资源

D、静态和动态特征

参考答案分析：

进程与应用程序的区别：

进程（Process）是最初定义在Unix等多用户、多任务操作系统环境下用于表示应用程序在内存环境中基本执行单元的概念。以Unix操作系统 为例，进程是Unix操作系统环境中的基本成分、是系统资源分配的基本单位。Unix操作系统中完成的几乎所有用户管理和资源分配等工作都是通过操作系统 对应用程序进程的控制来实现的。 　　 　　

C、C++、Java等语言编写的源程序经相应的编译器编译成可执行文件后，提交给计算机处理器运行。这时，处在可执行状态中的应用程序称为进程。 从用户角度来看，进程是应用程序的一个执行过程。从操作系统核心角度来看，进程代表的是操作系统分配的内存、CPU时间片等资源的基本单位，是为正在运行 的程序提供的运行环境。进程与应用程序的区别在于应用程序作为一个静态文件存储在计算机系统的硬盘等存储空间中，而进程则是处于动态条件下由操作系统维护的系统资源管理实体。

多任务环境下应用程序进程的主要特点包括： 　　 　　

●进程在执行过程中有内存单元的初始入口点，并且进程存活过程中始终拥有独立的内存地址空间； 　　 　　

●进程的生存期状态包括创建、就绪、运行、阻塞和死亡等类型； 　　 　　

●从应用程序进程在执行过程中向CPU发出的运行指令形式不同，可以将进程的状态分为用户态和核心态。处于用户态下的进程执行的是应用程序指令、处于核心态下的应用程序进程执行的是操作系统指令。 　　 　　

在Unix操作系统启动过程中，系统自动创建swapper、init等系统进程，用于管理内存资源以及对用户进程进行调度等。在Unix环境下无论是由操作系统创建的进程还要由应用程序执行创建的进程，均拥有唯一的进程标识（PID）

参考网址：http://blog.csdn.net/you_off3/article/details/7460914

2、  假设某算法的时间复杂度符合递推关系式T(n)=2T(n/2)+n，那么该算法的时间复杂度相当于

A、O(n)

B、O(lgn)

C、O(nlgn)

D、O(n²)

参考答案分析：

解析：由时间代价严格推出时间复杂度比较复杂，对于这种题，可用特例验证，不过需要注意的是特例不能取太少，至少n取到5，这样规律基本就可以确定了。 
  T(1)=1 
  T(2)=2T(1)+2=4 
  T(3)=2T(1)+3=5 
  T(4)=2T(2)+4=12 
  T(5)=2T(2)+5=13
  很容易排除D选项，其递增速率介于O(n)和O(n²)之间，实际上可以参考归并排序的递推公式。

参考网址：http://www.shangxueba.com/ask/1581189.html

3、  下图一个非确定有限自动机（NFA）的状态转换，其等价的正规式为（）

A、0*|(0|1)0
B、(0|10)*
C、0*((0|1)0)*
D、0*(10)*

参考答案分析：

根据分析题目中给出的状态转换图可知，该NFA可识别空串以及任意数目0组成的串，但若出现1，则其后至少要有1个0才能到达终态，因此，该自动机识别的串等价于正规式(0|10)*。

参考网址：http://www.shangxueba.com/ask/1379242.html

扩展阅读：

有限自动机（FiniteAutomata）

有限自动机（DeterministicFA）

非确定有限自动机（NondeterministicFA）

词法分析器的工作过程（参考阅读）：

参考网址：

http://wenku.baidu.com/link?url=723LWUUKvHqLl2T6nf_EocLZKDBgk0lJ8iXxsmF2LBHSId8HAETAjNBwXslnE5EeG8afFZoHHt-om9ULUAYVxQMH5cWrrSlGaPxfU7OxKYC

详细文献阅读：http://www.360doc.com/content/10/0927/19/832113_56859620.shtml

4、  IPv6地址占____个字节

A、4

B、6

C、8

D、16

参考答案分析：

IPv4采用32位地址长度，约有43亿地址，IPv6地址为128位长，但通常写作8组，每组为四个十六进制数的形式。例如：FE80:0000:0000:0000:AAAA:0000:00C2:0002 是一个合法的IPv6地址。

IPv4映像地址布局如下：

| 80bits |16 | 32bits |

0000....................0000 | FFFF | IPv4 address |

IPv4兼容地址写法如下：::192.168.89.9

如同IPv4映像地址，这个地址仍然是一个IPv6地址，只是0000:0000:0000:0000:0000:0000:c0a8:5909的另外一种写法罢了

参考网址：http://zh.wikipedia.org/wiki/IPv6

5、  以下关于RARP协议的说法中，正确的是（）？

A、RARP协议根据主机ＩＰ地址查询对应的MAC地址

B、RARP协议用于对IP协议进行差错控制

C、RARP协议根据MAC地址求主机对应的IP地址

D、RARP协议根据交换的路由信息动态改变路由表

参考答案分析：

逆地址解析协议（Reverse Address Resolution Protocol，RARP），是一种网络协议，互联网工程任务组（IETF）在RFC903中描述了RARP[1]。RARP使用与ARP相同的报头结构，作用与ARP相反。RARP用于将MAC地址转换为IP地址。其因为较限于IP地址的运用以及其他的一些缺点，因此渐为更新的BOOTP或DHCP所取代。

RARP的工作原理：

1.     发送主机发送一个本地的RARP广播，在此广播包中，声明自己的MAC地址并且请求任何收到此请求的RARP服务器分配一个IP地址；

2.     本地网段上的RARP服务器收到此请求后，检查其RARP列表，查找该MAC地址对应的IP地址；

3.     如果存在，RARP服务器就给源主机发送一个响应数据包并将此IP地址提供给对方主机使用；

4.     如果不存在，RARP服务器对此不做任何的响应；

5.     源主机收到从RARP服务器的响应信息，就利用得到的IP地址进行通讯；如果一直没有收到RARP服务器的响应信息，表示初始化失败

参考文献：

http://zh.wikipedia.org/wiki/%E9%80%86%E5%9C%B0%E5%9D%80%E8%A7%A3%E6%9E%90%E5%8D%8F%E8%AE%AE

ARP及RARP简介。

6、  一栋大楼共及200层，某种类型的鸡蛋从某一楼层及其以上楼层下来时会被打破，从该楼层（即临界楼层）以下楼层摔下该鸡蛋，鸡蛋不会出现破损。现在给你2个完全一样的该种类型的鸡蛋，问：如何通过这2个鸡蛋找到该临界楼层？

参考答案分析：（智能题_假设只有100层_楼层的层数随意_思想关键_用算法解决分析实际问题）

假设我们从第2个楼层开始试探，往楼层号码渐次增长的方向，每隔数个楼层，试探一次，并在试探到第1个鸡蛋摔破的地方停下来，用第2个鸡蛋来从最近一次试
探没有摔破的楼层之上的那个楼层开始逐个楼层进行试探，知道鸡蛋被摔破，我们就得到了临界楼层，如果鸡蛋一直没有被摔破，那么第一个鸡蛋摔破的楼层就是临
界楼层。现在假设第2个楼层和下一次试探的楼层之间有x个楼层，即第2次试探的楼层号是A(2)=x+3，以后试探的楼层间隔分别减少1，那么我们第3次
试探的楼层号为A(3)=2x+3，第4次为A(4)=3x+2，第5次为A(5)=4x，第n次为A(n)=(n-1)*x-(1/2)*n*n+(5
/2)*n，这里需要注意，我们试探的n不能超过x+1，可以这么想来：跳跃测试的n不应超过第一次最大的跨度（也即第一种需要连续测试的区间大小），及
n<=x+1。那么把x替换为n-1，得到A(n)=(1/2)*n*(n+1)+1。楼层为100，那么A(n)=(1/2)*n*
(n+1)+1>=100，得到n(n+1)>=198，得n=14，x=13，那么A(n)=(31*n-n*n-26)/2.

即通过楼层2,16,29,41,52,62,71,79,86,92,97,101,(104,106).作为间隔就可以在使用2个鸡蛋，不超过14次
测试的情况下找到临界楼层。

参考文献：http://blog.csdn.net/qianlizhima1/article/details/8615657

7、  请描述JAVA异常类的继承体系结构，以及JAVA异常的分类，并为每种类型的异常各举三个例子？

粉红色的是受检查的异常(checked exceptions),其必须被try{}catch语句块所捕获,或者在方法签名里通过throws子句声明.受检查的异常必须在编译时被捕捉处理,命名为 CHeckedException 是因为Java编译器要进行检查,Java虚拟机也要进行检查,以确保这个规则得到遵守。
    绿色的异常是运行时异常(runtime exceptions),需要程序员自己分析代码决定是否捕获和处理,比如 空指针,被0除...
    而声明为Error的，则属于严重错误,需要根据业务信息进行特殊处理,Error不需要捕捉。

比如：AWTError、ThreadDeath、

参考网址：

http://blog.csdn.net/renfufei/article/details/16344847

http://blog.csdn.net/junlixxu/article/details/6096266

 

8、  描述Java类加载器的原理及其组织结构？

Java类加载器的原理。

jvm classLoader architecture :

a、Bootstrap ClassLoader/启动类加载器
主要负责jdk_home/lib目录下的核心 api 或 -Xbootclasspath 选项指定的jar包装入工作.

B、Extension ClassLoader/扩展类加载器
主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作

C、System ClassLoader/系统类加载器
主要负责java -classpath/-Djava.class.path所指的目录下的类与jar包装入工作.

B、 User Custom ClassLoader/用户自定义类加载器(java.lang.ClassLoader的子类)
在程序运行期间, 通过java.lang.ClassLoader的子类动态加载class文件, 体现java动态实时类装入特性.

参考文献：http://www.blogjava.net/zhuxing/archive/2008/08/08/220841.html

http://blog.csdn.net/zdwzzu2006/article/details/2253982

9、  在Web开发中，如何实现会话的跟踪？

参考答案分析：（分为三种：SSH会话、Cookies、URL重定向）

1、SSL会话（Secure Socket Layer）

安全套接字层，是一种运行在TCP/IP之上和像HTTP这种应用层协议之下的加密技术。SSL是在HTTPS协议中使用的加密技术。SSL可以让
采用SSL的服务器认证采用SSL的客户端，并且在客户端和服务器之间保持一种加密了连接，在建立了加密连接的过程中，客户端和服务器都可以产生一种名为
“会话密钥”的东西，它是一种用于加密和解密的对称密钥。基于HTTPS协议的服务器可以使用这个客户端的对称密钥来建立会话

2、Cookies

中文译为小甜饼，由Netscape公司发明，是最常用的跟踪用户会话的方式。Cookies是一种由服务器发送给客户端的片段信息，存储在客户端
的内存或者硬盘上，在客户随后对该服务器的请求中发回它。其实主要就是把服务器为客户端分配的session
ID保存在Cookies中，每次发送请求时把Cookies附加到请求对象中一起发过去，服务器得到这个唯一的session
ID，从而可以唯一的标识一个客户端

3、URL重写

如果客户端禁用了Cookies，那么就只能用URL重写机制了。就是在URL中附加标识客户端的sessionID，web容器解析URL，取出session ID，根据这个session ID将请求与特定的session关联起来。

注意如果采用了URL重写，那么代码里面的所有url都要经过编码，response.sendRedirect(url)中的url用response.encodeRedirectURL(url)编码，其他的用response.encodeURL(url)来编码

参考网址：http://zhaomin819111.blog.163.com/blog/static/10659004200972525222991/

10、请简述Spring架构中IOC的实现原理？

IOC(Inverstion of Control)：Spring控制对象的生命周期以及对象之间的关系，其一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象，这一点是通过DI（Dependency Injection,即依赖注入）来实现的，而DI是通过反射机制实现的。

参考文献阅读：（怎样自己写一个Spring）

http://jiwenke.iteye.com/blog/493965

http://blog.csdn.net/it_man/article/details/4402245（blog写的很不错）

11、检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。

1. package algorithms.com.guan.javajicu;
2. public class TestDemo {
3. public static String output ="";
4. public static void foo(inti){
5. try{
6. if(i == 1){
7. throw new Exception();
8. }
9. }catch(Exception e){
10. output += "2";
11. return ;
12. }finally{
13. output += "3";
14. }
15. output += "4";
16. }
17. public static void main(String[] args) {
18. foo(0);
19. foo(1);
20. System.out.println(output); //3423
21. }
22. }

考点分析：考察异常抛出和异常捕获，注意finally{}不管异常是否抛出都要最终执行。

12、检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。

1. package algorithms.com.guan.javajicu;
2. public class HelloB extends HelloA{
3. public HelloB(){
4. System.out.println("HelloB");
5. }
6. {
7. System.out.println("I'm B class");
8. }
9. static{
10. System.out.println("static B");
11. }
12. public static void main(String[] args) {
13. new HelloB();
14. /**输出结果参考答案：
15. * static A
16. staticB
17. I'mA class
18. HelloA
19. I'mB class
20. HelloB
21. */
22. }
23. }
24. class HelloA{
25. public HelloA(){
26. System.out.println("HelloA");
27. }
28. {
29. System.out.println("I'm A class");  //这句话是什么时候加载？
30. }
31. static{
32. System.out.println("static A");
33. }
34. }

考点分析：考察java类/对象初始化顺序以及静态代码块的使用。

总之一句话：静态代码块先执行（父先子后），接着执行父类非静态代码块和构造方法，最后执行子类非静态代码块和构造方法。

注意静态变量初始化先于静态代码块。

13、检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。

1. package algorithms.com.guan.javajicu;
2. public class Inc {
3. public static void main(String[] args) {
4. Inc inc = new Inc();
5. int i = 0;
6. inc.fermin(i);
7. i= i ++;
8. System.out.println(i);  //输出结果为0
9. }
10. void fermin(int i){
11. i++;
12. }
13. }

考点分析：

14、             检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。

1. package algorithms.com.guan.javajicu;
2. public class Example {
3. String str = new String("good");
4. char[] ch = {'a','b','c'};
5. public static void main(String[] args) {
6. Example ex = new Example();
7. ex.change(ex.str, ex.ch);
8. System.out.print(ex.str +"and");
9. System.out.print(ex.ch);
10. //参考答案输出结果：goodandgbc
11. }
12. public void change(String str, char ch[]){
13. str= "test ok";
14. ch[0]= 'g';
15. }
16. }

考点分析：

15、             检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。

1. package algorithms.com.guan.javajicu;
2. import java.util.Date;
3. public class SuperTest extends Date{
4. private static final long serialVersionUID = 1L;
5. private void test(){
6. System.out.println(super.getClass().getName());
7. //参考答案输出：algorithms.com.guan.javajicu.SuperTest
8. }
9. public static void main(String[]args){
10. new SuperTest().test();
11. }
12. }

这题有点绕，分析如下：
第一：不管是T1的getClass（）还是Date的getClass()，他们都是非覆盖式的从Object继承来的，因为Object.getClass()是final的。

第二：Object的getClass()方法的释义是：返回此 Object 的运行时类。返回的 Class 对象是由所表示类的 static synchronized 方法锁定的对象。

/**
     * Returns the runtime class of this {@code Object}. The returned
     * {@code Class} object is the object that is locked by {@code
     * static synchronized} methods of the represented class.
     **/

释义指出，要返回此Object运行时类，这外当然不可能指Object自己了，否则所有类调用getClass()方法都返回Object.class了。

那到底谁是Object的运行时类呢，不是Object自己，当然就只能是他的儿子、或各种孙子了，到底是谁呢，举个例子：
    Date作为直接继承Object的类，作为Object的儿子，如果调用Date.getClass(),返回的是什么呢？在Date中，无论
是this.getClass()还是super.getClass(),毫无疑问都指向了Object.getClass()。根据上一段解
释，Object.getClass()返回不可能是Object.class，那没得说，只能是Date.class了。

根据上段：new Date()时，Date是Object的运行时类。

同理：根据LZ的例子，new T1()时，运行是类不可能是T1他老子Date，更不会他各种老老子（如Object），只能是自己。

再回到Object.getClass()释义，返回的只能是T1.class

第三：如果想要从T1中得到Date.class，可以用T1.getClass().getSuperClass();

16、 任意2n个整数，从其中选出n个整数，使得选出的n个整数和同剩下的n个整数之和的差最小。

17、有两个有序的集合，集合的每个元素都是一段范围，求其交集，例如集合{[4,8],[9,13]}和{[6,12]}的交集为{[6,8],[9,12]}

可供参考的文献：

http://blog.csdn.net/jie1991liu/article/details/13168255

http://loveexception.iteye.com/blog/628744

http://bestchenwu.iteye.com/blog/1674624

package wangyi;

import java.util.Arrays;

/**
 * 有两个有序的集合，集合的每个元素都是一段范围，求其交集，
 * 例如集合{[4,8],[9,13]}和{[6,12]}的交集为{[6,8],[9,12]}
 * @author Administrator
 *
 */
public class Mixed {
    public static void main(String[] args) {
        Gather g1 = new Gather(4, 8);
        Gather g2 = new Gather(9, 13);
        Gather g = new Gather(6, 12);
        Gather[] result = max(g1,g2,g);
        for (Gather gather : result) {
            System.out.println(gather);
        }
    }

    /*
     * 计算交集
     * 时间复杂度:排序的时间复杂度(JDK默认的是快排，所以时间复杂度为O(n*log2(n)))+查找的时间复杂度O(n)
     *
     */
    private static Gather[] max(Gather g1, Gather g2, Gather g) {
        //首先对g1,g2,g这个三个集合的左右边界进行排序
        int[] arrays = {g1.getLeft(),g1.getRight(),
                g2.getLeft(),g2.getRight(),g.getLeft(),g.getRight()};
        Arrays.sort(arrays);
        System.out.println(Arrays.toString(arrays));
        //接着从g的左边界开始找右边的那个数，记为t
        int i=0;
        for(;i<arrays.length;i++)
            if(arrays[i]==g.left)
                break;
        //判断t是否为g的右边界：如果是则判断i==1：如果i==1，则说明没有交集；如果i！=1，则说明交集就为[g.left,g.right];
        //如果t不是g的右边界，则说明[g.left,t]是交集的一部分,继续下一步。
        if(arrays[++i] == g.right)
            if(i==1)
                return null;
            else
                return new Gather[]{g};
        //i++,判断arrays[i]==g.right：如果是返回[g.left,t]；如果不是，则返回[g.left,t]和[arrays[i],arrays[++i]].
        i++;
        if(arrays[i]==g.right)
            return new Gather[]{new Gather(g.left, arrays[i--])};
        else
            return new Gather[]{new Gather(g.left, arrays[i-1]),new Gather(arrays[i],arrays[++i])};

    }

}

class Gather{
    int left;
    int right;

    public Gather(int left, int right) {
        super();
        this.left = left;
        this.right = right;
    }
    public int getLeft() {
        return left;
    }
    public void setLeft(int left) {
        this.left = left;
    }
    public int getRight() {
        return right;
    }
    public void setRight(int right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "["+this.left+","+this.right+"]";
    }
}

18、一个文件中有10000个数，用Java实现一个多线程程序将这个10000个数输出到5个不同文件中（不要求输
出到每个文件中的数量相同）。要求启动10个线程，两两一组，分为5组。每组两个线程分别将文件中的奇数和偶数输出到该组对应的一个文件中，需要偶数线程
每打印10个偶数以后，就将奇数线程打印10个奇数，如此交替进行。同时需要记录输出进度，每完成1000个数就在控制台中打印当前完成数量，并在所有线
程结束后，在控制台打印”Done”.

可供参考的文献：

http://blog.csdn.net/vstar283551454/article/details/17362709