2015網易校招Java開發工程師(技術架構)在線筆試題

時間 2019-12-20

標籤網易 java 開發工程師技術架構在線筆試欄目 Java 简体版

原文原文鏈接

一、程序和進程的本質區別是？html

A、在外存和內存存儲java

B、非順序和順序執行機器指令程序員

C、獨佔使用和分時使用計算機資源web

D、靜態和動態特徵算法

參考答案分析：api

進程與應用程序的區別：安全

進程（Process）是最初定義在Unix等多用戶、多任務操做系統環境下用於表示應用程序在內存環境中基本執行單元的概念。以Unix操做系統爲例，進程是Unix操做系統環境中的基本成分、是系統資源分配的基本單位。Unix操做系統中完成的幾乎全部用戶管理和資源分配等工做都是經過操做系統對應用程序進程的控制來實現的。　　　　服務器

C、C++、Java等語言編寫的源程序經相應的編譯器編譯成可執行文件後，提交給計算機處理器運行。這時，處在可執行狀態中的應用程序稱爲進程。從用戶角度來看，進程是應用程序的一個執行過程。從操做系統核心角度來看，進程表明的是操做系統分配的內存、CPU時間片等資源的基本單位，是爲正在運行的程序提供的運行環境。進程與應用程序的區別在於應用程序做爲一個靜態文件存儲在計算機系統的硬盤等存儲空間中，而進程則是處於動態條件下由操做系統維護的系統資源管理實體。網絡

多任務環境下應用程序進程的主要特色包括：　　　　session

●進程在執行過程當中有內存單元的初始入口點，而且進程存活過程當中始終擁有獨立的內存地址空間；　　　　

●進程的生存期狀態包括建立、就緒、運行、阻塞和死亡等類型；　　　　

●從應用程序進程在執行過程當中向CPU發出的運行指令形式不一樣，能夠將進程的狀態分爲用戶態和核心態。處於用戶態下的進程執行的是應用程序指令、處於核心態下的應用程序進程執行的是操做系統指令。　　　　

在Unix操做系統啓動過程當中，系統自動建立swapper、init等系統進程，用於管理內存資源以及對用戶進程進行調度等。在Unix環境下不管是由操做系統建立的進程還要由應用程序執行建立的進程，均擁有惟一的進程標識（PID）

參考網址：http://blog.csdn.net/you_off3/article/details/7460914

二、假設某算法的時間複雜度符合遞推關係式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

三、下圖一個非肯定有限自動機（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

四、 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

五、如下關於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簡介。

六、一棟大樓共及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

七、請描述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

八、描述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

九、在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/

十、請簡述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寫的很不錯）

十一、檢查程序，是否存在問題，若是存在指出問題所在，若是不存在，說明輸出結果。

[java] view plain copy

package algorithms.com.guan.javajicu;
public class TestDemo {
public static String output ="";
public static void foo(inti){
try{
if(i == 1){
throw new Exception();
}
}catch(Exception e){
output += "2";
return ;
}finally{
output += "3";
}
output += "4";
}
public static void main(String[] args) {
foo(0);
foo(1);
System.out.println(output); //3423
}
}

考點分析：考察異常拋出和異常捕獲，注意finally{}無論異常是否拋出都要最終執行。

十二、檢查程序，是否存在問題，若是存在指出問題所在，若是不存在，說明輸出結果。

[java] view plain copy

package algorithms.com.guan.javajicu;
public class HelloB extends HelloA{
public HelloB(){
System.out.println("HelloB");
}
{
System.out.println("I'm B class");
}
static{
System.out.println("static B");
}
public static void main(String[] args) {
new HelloB();
/**輸出結果參考答案：
* static A
staticB
I'mA class
HelloA
I'mB class
HelloB
*/
}
}
class HelloA{
public HelloA(){
System.out.println("HelloA");
}
{
System.out.println("I'm A class"); //這句話是何時加載？
}
static{
System.out.println("static A");
}
}

考點分析：考察java類/對象初始化順序以及靜態代碼塊的使用。

總之一句話：靜態代碼塊先執行（父先子後），接着執行父類非靜態代碼塊和構造方法，最後執行子類非靜態代碼塊和構造方法。

注意靜態變量初始化先於靜態代碼塊。

1三、檢查程序，是否存在問題，若是存在指出問題所在，若是不存在，說明輸出結果。

[java] view plain copy

package algorithms.com.guan.javajicu;
public class Inc {
public static void main(String[] args) {
Inc inc = new Inc();
int i = 0;
inc.fermin(i);
i= i ++;
System.out.println(i); //輸出結果爲0
}
void fermin(int i){
i++;
}
}

考點分析：

1四、檢查程序，是否存在問題，若是存在指出問題所在，若是不存在，說明輸出結果。

[java] view plain copy

package algorithms.com.guan.javajicu;
public class Example {
String str = new String("good");
char[] ch = {'a','b','c'};
public static void main(String[] args) {
Example ex = new Example();
ex.change(ex.str, ex.ch);
System.out.print(ex.str +"and");
System.out.print(ex.ch);
//參考答案輸出結果：goodandgbc
}
public void change(String str, char ch[]){
str= "test ok";
ch[0]= 'g';
}
}

考點分析：

1五、檢查程序，是否存在問題，若是存在指出問題所在，若是不存在，說明輸出結果。

[java] view plain copy

package algorithms.com.guan.javajicu;
import java.util.Date;
public class SuperTest extends Date{
private static final long serialVersionUID = 1L;
private void test(){
System.out.println(super.getClass().getName());
//參考答案輸出：algorithms.com.guan.javajicu.SuperTest
}
public static void main(String[]args){
new SuperTest().test();
}
}

這題有點繞，分析以下：
第一：不論是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();

1六、任意2n個整數，從其中選出n個整數，使得選出的n個整數和同剩下的n個整數之和的差最小。

1七、有兩個有序的集合，集合的每一個元素都是一段範圍，求其交集，例如集合{[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+"]";
    }
}

1八、一個文件中有10000個數，用Java實現一個多線程程序將這個10000個數輸出到5個不一樣文件中（不要求輸出到每一個文件中的數量相同）。要求啓動10個線程，兩兩一組，分爲5組。每組兩個線程分別將文件中的奇數和偶數輸出到該組對應的一個文件中，須要偶數線程每打印10個偶數之後，就將奇數線程打印10個奇數，如此交替進行。同時須要記錄輸出進度，每完成1000個數就在控制檯中打印當前完成數量，並在全部線程結束後，在控制檯打印」Done」.

可供參考的文獻：

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