面試錯題

時間 2019-11-30

標籤面試欄目快樂工作简体版

原文原文鏈接

請問object的hash該怎麼設計？html

下面是解釋最簡單的一種hash算法java

哈希算法又叫散列算法，是將任意長度的二進制值映射爲較短的固定長度的二進制值，這個小的二進制值稱爲哈希值。它的原理其實很簡單，就是把一段交易信息轉換成一個固定長度的字符串。mysql

即一個從明文到密文的不可逆映射，只有加密過程，沒有解密過程。web

不管輸入是什麼數字格式、文件有多大，輸出都是固定長度的比特串。正則表達式

每一個bit就是一位0或者1，256bit就是256個0或者1二進制數字串，用16進制數字表示的話，就是多少位呢？算法

16等於2的4次方，因此每一位16進制數字能夠表明4位bit。那麼，256位bit用16進制數字表示，固然是256除以4等於64位。spring

因而你一般看到的哈希值，就是這樣的了：sql

00740f40257a13bf03b40f54a9fe398c79a664bb21cfa2870ab07888b21eeba8。數據庫

易壓縮：對於任意大小的輸入x，Hash值的長度很小，在實際應用中，函數H產生的Hash值其長度是固定的。編程

易計算：對於任意給定的消息，計算其Hash值比較容易。

單向性：對於給定的Hash值，要找到使得在計算上是不可行的，即求Hash的逆很困難。在給定某個哈希函數H和哈希值H（M）的狀況下，得出M在計算上是不可行的。即從哈希輸出沒法倒推輸入的原始數值。這是哈希函數安全性的基礎。

抗碰撞性：理想的Hash函數是無碰撞的，但在實際算法的設計中很難作到這一點。

有兩種抗碰撞性：一種是弱抗碰撞性，即對於給定的消息，要發現另外一個消息，知足在計算上是不可行的；另外一種是強抗碰撞性，即對於任意一對不一樣的消息，使得在計算上也是不可行的。

高靈敏性：這是從比特位角度出發的，指的是1比特位的輸入變化會形成1/2的比特位發生變化。消息M的任何改變都會致使哈希值H（M）發生改變。即若是輸入有微小不一樣，哈希運算後的輸出必定不一樣。

2不可逆加密阿呆：小星，你看這樣能夠不，我想一個A，通過下面的過程：

1.A+123=B

2.B^2=C

3.取C中第2~4位數，組成一個3位數D

4.D/12的結果求餘數，獲得E

小星：嗯，我想一想，假如阿呆你想的A爲5，那麼：

5+123=128

128^2=16384

D=638 E=638mod12=53

(mod表示除法的求餘數)

這種丟掉一部分信息的加密方式稱爲「單向加密」，也叫哈希算法

當兩個不一樣的對象計算出相同的散列值時，咱們稱其爲發生了哈希碰撞。當出現碰撞時，哈希表會從碰撞產生的位置開始向後尋找，把新的元素放在第一個可供放置的位置,隨着哈希表變得愈來愈緻密，發生碰撞的可能性也會隨之增長，致使查找可用位置花費的時間也會增長（這也是爲何咱們但願哈希函數的結果分佈更接近於均勻分佈）

http://www.sohu.com/a/232586831_100078137

哈希算法的實現方式不少，有興趣的本身看吧

數據庫三範式

第一範式（1NF）：數據表中的每一列（每一個字段）必須是不可拆分的最小單元，也就是確保每一列的原子性；

第二範式（2NF）：知足1NF後，，沒有包含在主鍵中的列必須徹底依賴於主鍵，不能只依賴於主鍵的一部分。

第三範式（3NF）：必須先知足第二範式（2NF），非主鍵列必須直接依賴於主鍵不能存在傳遞依賴。

spring支持編程式事務管理和聲明式事務管理兩種方式。

編程式事務使用TransactionTemplate或者直接使用底層的PlatformTransactionManager。對於編程式事務管理，spring推薦使用TransactionTemplate。
聲明式事務是創建在AOP之上的。其本質是對方法先後進行攔截，而後在目標方法開始以前建立或者加入一個事務，在執行完目標方法以後根據執行狀況提交或者回滾事務。聲明式事務最大的優勢就是不須要經過編程的方式管理事務，這樣就不須要在業務邏輯代碼中摻瑣事務管理的代碼，只需在配置文件中作相關的事務規則聲明(或經過基於@Transactional註解的方式)，即可以將事務規則應用到業務邏輯中。

顯然聲明式事務管理要優於編程式事務管理，這正是spring倡導的非侵入式的開發方式。聲明式事務管理使業務代碼不受污染，一個普通的POJO對象，只要加上註解就能夠得到徹底的事務支持。和編程式事務相比，聲明式事務惟一不足地方是，它的最細粒度只能做用到方法級別，沒法作到像編程式事務那樣能夠做用到代碼塊級別。可是即使有這樣的需求，也存在不少變通的方法，好比，能夠將須要進行事務管理的代碼塊獨立爲方法等等。

聲明式事務管理也有兩種經常使用的方式，一種是基於tx和aop名字空間的xml配置文件，另外一種就是基於@Transactional註解。顯然基於註解的方式更簡單易用，更清爽。

http://www.javashuo.com/article/p-euqdpimt-bp.html

Spring有七大功能模塊，分別是Spring Core，AOP，ORM，DAO，MVC，WEB，Context。 1，Spring Core Core模塊是Spring的核心類庫，Spring的全部功能都依賴於該類庫，Core主要實現IOC功能，Sprign的全部功能都是藉助IOC實現的。

ORM的全稱是Object Relational Mapping，即對象關係映射。它的實現思想就是將關係數據庫中表的數據映射成爲對象，以對象的形式展示，這樣開發人員就能夠把對數據庫的操做轉化爲對這些對象的操做。所以它的目的是爲了方便開發人員以面向對象的思想來實現對數據庫的操做。

3．Spring DAO: DAO (Data Access Object)提供了JDBC的抽象層，它可消除冗長的JDBC編碼和解析數據庫廠商特有的錯誤代碼。而且，JDBC封裝包還提供了一種比編程性更好的聲明性事務管理方法，不只僅是實現了特定接口，並且對全部的POJOs（plain old Java objects）都適用。

對於ORM Spring沒有提供本身的實現。只對JDBC和其餘ORM框架進行了封裝。

1.Serial收集器
單線程收集器，收集時會暫停全部工做線程（咱們將這件事情稱之爲Stop The World，下稱STW），使用複製收集算法，虛擬機運行在Client模式時的默認新生代收集器。

2.ParNew收集器
ParNew 收集器就是Serial的多線程版本，除了使用多條收集線程外，其他行爲包括算法、STW、對象分配規則、回收策略等都與Serial收集器一摸同樣。對應的這種收集器是虛擬機運行在Server模式的默認新生代收集器，在單CPU的環境中，ParNew收集器並不會比Serial收集器有更好的效果。

3.Parallel Scavenge收集器
Parallel Scavenge收集器（下稱PS收集器）也是一個多線程收集器，也是使用複製算法，但它的對象分配規則與回收策略都與ParNew收集器有所不一樣，它是以吞吐量最大化（即GC時間佔總運行時間最小）爲目標的收集器實現，它容許較長時間的STW換取總吞吐量最大化。

4.Serial Old收集器
Serial Old是單線程收集器，使用標記－整理算法，是老年代的收集器，上面三種都是使用在新生代收集器。

5.Parallel Old收集器
老年代版本吞吐量優先收集器，使用多線程和標記－整理算法，JVM 1.6提供，在此以前，新生代使用了PS收集器的話，老年代除Serial Old外別無選擇，由於PS沒法與CMS收集器配合工做。

6.CMS（Concurrent Mark Sweep）收集器
CMS 是一種以最短停頓時間爲目標的收集器，使用CMS並不能達到GC效率最高（整體GC時間最小），但它能儘量下降GC時服務的停頓時間，這一點對於實時或者高交互性應用（譬如證券交易）來講相當重要，這類應用對於長時間STW通常是不可容忍的。CMS收集器使用的是標記－清除算法，也就是說它在運行期間會產生空間碎片，因此虛擬機提供了參數開啓CMS收集結束後再進行一次內存壓縮。

效率：System.arraycopy > clone > Arrays.copyOf > for循環

總結：

（1）從速度上看：System.arraycopy > clone > Arrays.copyOf > for
（2）for的速度之因此最慢是由於下標表示法每次都從起點開始尋位到指定下標處（現代編譯器應該對其有進行優化，改成指針），另外就是它每一次循環都要判斷一次是否達到數組最大長度和進行一次額外的記錄下標值的加法運算。
（3）查看Arrays.copyOf的源碼能夠發現，它其實本質上是調用了System.arraycopy。之因此時間差距比較大，是由於很大一部分開銷全花在了Math.min函數上了。

這裏面在System類源碼中給出了arraycopy的方法，是native方法，也就是本地方法，確定是最快的

類中聲明的變量有默認初始值；方法中聲明的變量沒有默認初始值，必須在定義時初始化，不然在訪問該變量時會出錯。

boolean類型默認值是false

解析：處理異經常用的兩種方式：
一、try...catch(捕獲處理機制)；
二、throws(冒泡處理機制).
注意細節：使用try...catch塊捕獲時能夠沒有catch塊,但當沒用catch塊的時候必須得有finally塊.故選A）

數組引用類型的變量的默認值爲 null。當數組變量的實例後，若是沒有沒有顯示的爲每一個元素賦值，Java 就會把該數組的全部元素初始化爲其相應類型的默認值。

int型的默認值爲0

結構型模式是描述如何將類對象結合在一塊兒，造成一個更大的結構，結構模式描述兩種不一樣的東西：類與類的實例。故能夠分爲類結構模式和對象結構模式。

在GoF設計模式中，結構型模式有：

1.適配器模式 Adapter

適配器模式是將一個類的接口轉換成客戶但願的另一個接口。適配器模式使得本來因爲接口不兼容而不能一塊兒工做的那些類能夠一塊兒工做。

兩個成熟的類須要通訊，可是接口不一樣，因爲開閉原則，咱們不能去修改這兩個類的接口，因此就須要一個適配器來完成銜接過程。

2.橋接模式 Bridge

橋接模式將抽象部分與它的實現部分分離，是它們均可以獨立地變化。它很好的支持了開閉原則和組合鋸和複用原則。實現系統可能有多角度分類，每一種分類都有可能變化，那麼就把這些多角度分離出來讓他們獨立變化，減小他們之間的耦合。

3.組合模式 Composite

組合模式將對象組合成樹形結構以表示部分-總體的層次結構，組合模式使得用戶對單個對象和組合對象的使用具備一致性。

4.裝飾模式 Decorator

裝飾模式動態地給一個對象添加一些額外的職責，就增長功能來講，它比生成子類更靈活。也能夠這樣說，裝飾模式把複雜類中的核心職責和裝飾功能區分開了，這樣既簡化了複雜類，有去除了相關類中重複的裝飾邏輯。 裝飾模式沒有經過繼承原有類來擴展功能，但卻達到了同樣的目的，並且比繼承更加靈活，因此能夠說裝飾模式是繼承關係的一種替代方案。

5.外觀模式 Facade

外觀模式爲子系統中的一組接口提供了贊成的界面，外觀模式定義了一個高層接口，這個接口使得這一子系統更加容易使用。

外觀模式中，客戶對各個具體的子系統是不瞭解的，因此對這些子系統進行了封裝，對外只提供了用戶所明白的單一而簡單的接口，用戶直接使用這個接口就能夠完成操做，而不用去理睬具體的過程，並且子系統的變化不會影響到用戶，這樣就作到了信息隱蔽。

6.享元模式 Flyweight

享元模式爲運用共享技術有效的支持大量細粒度的對象。由於它能夠經過共享大幅度地減小單個實例的數目，避免了大量很是類似類的開銷。.

享元模式是一個類別的多個對象共享這個類別的一個對象，而不是各自再實例化各自的對象。這樣就達到了節省內存的目的。

7.代理模式 Proxy

爲其餘對象提供一種代理，並由代理對象控制對原對象的引用，以間接控制對原對象的訪問。

i++ 使用i的值以後 i的值 +1

++i 在使用i 以前先使 i 的值加 1

i-- 使用 i 的值以後使 i 的值 -1

--i 使用 i 以前先使 i 的值 -1

一、一個類能夠有多個接口；
二、一個類只能繼承一個父類；
三、接口中能夠不聲明任何方法，和成員變量
interface testinterface{
	
}
四、抽象類能夠不包含抽象方法，但有抽象方法的類必定要聲明爲抽象類
 abstract class abstclass{
	abstract void meth();
}

元字符	描述
\	將下一個字符標記符、或一個向後引用、或一個八進制轉義符。例如，「\\n」匹配\n。「\n」匹配換行符。序列「\\」匹配「\」而「\(」則匹配「(」。即至關於多種編程語言中都有的「轉義字符」的概念。
^	匹配輸入字符串的開始位置。若是設置了RegExp對象的Multiline屬性，^也匹配「\n」或「\r」以後的位置。
$	匹配輸入字符串的結束位置。若是設置了RegExp對象的Multiline屬性，$也匹配「\n」或「\r」以前的位置。
*	匹配前面的子表達式任意次。例如，zo能匹配「z」，也能匹配「zo」以及「zoo」。等價於o{0,}
+	匹配前面的子表達式一次或屢次(大於等於1次）。例如，「zo+」能匹配「zo」以及「zoo」，但不能匹配「z」。+等價於{1,}。
?	匹配前面的子表達式零次或一次。例如，「do(es)?」能夠匹配「do」或「does」中的「do」。?等價於{0,1}。
{n}	n是一個非負整數。匹配肯定的n次。例如，「o{2}」不能匹配「Bob」中的「o」，可是能匹配「food」中的兩個o。
{n,}	n是一個非負整數。至少匹配n次。例如，「o{2,}」不能匹配「Bob」中的「o」，但能匹配「foooood」中的全部o。「o{1,}」等價於「o+」。「o{0,}」則等價於「o*」。
{n,m}	m和n均爲非負整數，其中n<=m。最少匹配n次且最多匹配m次。例如，「o{1,3}」將匹配「fooooood」中的前三個o爲一組，後三個o爲一組。「o{0,1}」等價於「o?」。請注意在逗號和兩個數之間不能有空格。
?	當該字符緊跟在任何一個其餘限制符（*,+,?，{n}，{n,}，{n,m}）後面時，匹配模式是非貪婪的。非貪婪模式儘量少的匹配所搜索的字符串，而默認的貪婪模式則儘量多的匹配所搜索的字符串。例如，對於字符串「oooo」，「o+」將盡量多的匹配「o」，獲得結果[「oooo」]，而「o+?」將盡量少的匹配「o」，獲得結果 ['o', 'o', 'o', 'o']
.點	匹配除「\r\n」以外的任何單個字符。要匹配包括「\r\n」在內的任何字符，請使用像「[\s\S]」的模式。
(pattern)	匹配pattern並獲取這一匹配。所獲取的匹配能夠從產生的Matches集合獲得，在VBScript中使用SubMatches集合，在JScript中則使用$0…$9屬性。要匹配圓括號字符，請使用「$」或「$」。
(?:pattern)	非獲取匹配，匹配pattern但不獲取匹配結果，不進行存儲供之後使用。這在使用或字符「(\|)」來組合一個模式的各個部分時頗有用。例如「industr(?:y\|ies)」就是一個比「industry\|industries」更簡略的表達式。
(?=pattern)	非獲取匹配，正向確定預查，在任何匹配pattern的字符串開始處匹配查找字符串，該匹配不須要獲取供之後使用。例如，「Windows(?=95\|98\|NT\|2000)」能匹配「Windows2000」中的「Windows」，但不能匹配「Windows3.1」中的「Windows」。預查不消耗字符，也就是說，在一個匹配發生後，在最後一次匹配以後當即開始下一次匹配的搜索，而不是從包含預查的字符以後開始。
(?!pattern)	非獲取匹配，正向否認預查，在任何不匹配pattern的字符串開始處匹配查找字符串，該匹配不須要獲取供之後使用。例如「Windows(?!95\|98\|NT\|2000)」能匹配「Windows3.1」中的「Windows」，但不能匹配「Windows2000」中的「Windows」。
(?<=pattern)	非獲取匹配，反向確定預查，與正向確定預查相似，只是方向相反。例如，「(?<=95\|98\|NT\|2000)Windows」能匹配「2000Windows」中的「Windows」，但不能匹配「3.1Windows」中的「Windows」。
(?<!pattern)	非獲取匹配，反向否認預查，與正向否認預查相似，只是方向相反。例如「(?<!95\|98\|NT\|2000)Windows」能匹配「3.1Windows」中的「Windows」，但不能匹配「2000Windows」中的「Windows」。這個地方不正確，有問題此處用或任意一項都不能超過2位，如「(?<!95\|98\|NT\|20)Windows正確，「(?<!95\|980\|NT\|20)Windows 報錯，如果單獨使用則無限制，如(?<!2000)Windows 正確匹配
x\|y	匹配x或y。例如，「z\|food」能匹配「z」或「food」(此處請謹慎)。「[zf]ood」則匹配「zood」或「food」。
[xyz]	字符集合。匹配所包含的任意一個字符。例如，「[abc]」能夠匹配「plain」中的「a」。
[^xyz]	負值字符集合。匹配未包含的任意字符。例如，「[^abc]」能夠匹配「plain」中的「plin」。
[a-z]	字符範圍。匹配指定範圍內的任意字符。例如，「[a-z]」能夠匹配「a」到「z」範圍內的任意小寫字母字符。注意:只有連字符在字符組內部時,而且出如今兩個字符之間時,才能表示字符的範圍; 若是出字符組的開頭,則只能表示連字符自己.
[^a-z]	負值字符範圍。匹配任何不在指定範圍內的任意字符。例如，「[^a-z]」能夠匹配任何不在「a」到「z」範圍內的任意字符。
\b	匹配一個單詞邊界，也就是指單詞和空格間的位置（即正則表達式的「匹配」有兩種概念，一種是匹配字符，一種是匹配位置，這裏的\b就是匹配位置的）。例如，「er\b」能夠匹配「never」中的「er」，但不能匹配「verb」中的「er」。
\B	匹配非單詞邊界。「er\B」能匹配「verb」中的「er」，但不能匹配「never」中的「er」。
\cx	匹配由x指明的控制字符。例如，\cM匹配一個Control-M或回車符。x的值必須爲A-Z或a-z之一。不然，將c視爲一個原義的「c」字符。
\d	匹配一個數字字符。等價於[0-9]。grep 要加上-P，perl正則支持
\D	匹配一個非數字字符。等價於[^0-9]。grep要加上-P，perl正則支持
\f	匹配一個換頁符。等價於\x0c和\cL。
\n	匹配一個換行符。等價於\x0a和\cJ。
\r	匹配一個回車符。等價於\x0d和\cM。
\s	匹配任何不可見字符，包括空格、製表符、換頁符等等。等價於[ \f\n\r\t\v]。
\S	匹配任何可見字符。等價於[^ \f\n\r\t\v]。
\t	匹配一個製表符。等價於\x09和\cI。
\v	匹配一個垂直製表符。等價於\x0b和\cK。
\w	匹配包括下劃線的任何單詞字符。相似但不等價於「[A-Za-z0-9_]」，這裏的"單詞"字符使用Unicode字符集。
\W	匹配任何非單詞字符。等價於「[^A-Za-z0-9_]」。

C。因爲replaceAll方法的第一個參數是一個正則表達式，而"."在正則表達式中表示任何字符，因此會把前面字符串的全部字符都替換成"/"。

若是想替換的只是"."，那麼久要寫成"\\.".

1.Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

2. DriverManager.registerDriver(new com.mysql.jdbc.Driver());

3.System.setProperty("jdbc.drivers", "com.mysql.jdbc.Driver");

   建立一個以JDBC鏈接數據庫的程序，包含7個步驟：  1、加載JDBC驅動程序： 
在鏈接數據庫以前，首先要加載想要鏈接的數據庫的驅動到JVM（Java虛擬機）， 
這經過java.lang.Class類的靜態方法forName(String className)實現。 
例如：
 
try{ //加載MySql的驅動類  
      Class.forName("com.mysql.jdbc.Driver"); 
   }
catch(ClassNotFoundException e)
   {  
    System.out.println("找不到驅動程序類 ，加載驅動失敗！");
    e.printStackTrace();
   }
 
    成功加載後，會將Driver類的實例註冊到DriverManager類中。 
 
2、提供JDBC鏈接的URL
 
<blockquote style="vertical-align: baseline;">
    <ul style="vertical-align: baseline;">
        <li style="vertical-align: baseline;">
            鏈接URL定義了鏈接數據庫時的協議、子協議、數據源標識。
         
        </li><li style="vertical-align: baseline;">
            書寫形式：協議：子協議：數據源標識
         
        </li><li style="vertical-align: baseline;">
            協議：在JDBC中老是以jdbc開始
         
        </li><li style="vertical-align: baseline;">
            子協議：是橋鏈接的驅動程序或是數據庫管理系統名稱。
         
        </li><li style="vertical-align: baseline;">
            數據源標識：標記找到數據庫來源的地址與鏈接端口。
         
     
 
jdbc:mysql:  
    //localhost:3306/test?useUnicode=true&characterEncoding=gbk;
 
    useUnicode=true：表示使用Unicode字符集。 
 
若是characterEncoding設置爲gb2312或GBK，本參數必須設置爲true &characterEncoding=gbk;字符編碼方式。 
 
3、建立數據庫的鏈接
 
<blockquote style="vertical-align: baseline;">
    <ul style="vertical-align: baseline;">
        <li style="vertical-align: baseline;">
            要鏈接數據庫，須要向java.sql.DriverManager請求並得到Connection對象,該對象就表明一個數據庫的鏈接。
         
        </li><li style="vertical-align: baseline;">
            使用DriverManager的getConnectin(String url , String username , String password )方法傳入指定的欲鏈接的數據庫的路徑、數據庫的用戶名和密碼來得到。
         
     
 
 
    例如：
 
//鏈接MySql數據庫，用戶名和密碼都是root  
String url = "jdbc:mysql://localhost:3306/test" ;   
String username = "root" ;  
String password = "root" ;  
try{  
    Connection con = DriverManager.getConnection(url , username , password ) ;  
     }catch(SQLException se){  
            System.out.println("數據庫鏈接失敗！");  
            se.printStackTrace() ;  
      }
 
    4、建立一個Statement
 
<blockquote style="vertical-align: baseline;">
    <ul style="vertical-align: baseline;">
        <li style="vertical-align: baseline;">
            要執行SQL語句，必須得到java.sql.Statement實例，Statement實例分爲如下3 
 
種類型： 
 
            <ol style="vertical-align: baseline;">
                <li style="vertical-align: baseline;">
                    執行靜態SQL語句。一般經過Statement實例實現。
                 
                </li><li style="vertical-align: baseline;">
                    執行動態SQL語句。一般經過PreparedStatement實例實現。
                 
                </li><li style="vertical-align: baseline;">
                    執行數據庫存儲過程。一般經過CallableStatement實例實現。
                 
             
         
     
 
 
    具體的實現方式：
 
Statement stmt = con.createStatement() ;  
   PreparedStatement pstmt = con.prepareStatement(sql) ;  
   CallableStatement cstmt = con.prepareCall("{CALL demoSp(? , ?)}") ;
 
    5、執行SQL語句
 
<blockquote style="vertical-align: baseline;">
    <ul style="vertical-align: baseline;">
        <li style="vertical-align: baseline;">
            Statement接口提供了三種執行SQL語句的方法：executeQuery 、executeUpdate和execute 
 
            <ol style="vertical-align: baseline;">
                <li style="vertical-align: baseline;">
                    ResultSet executeQuery(String sqlString)：執行查詢數據庫的SQL語句，返回一個結果集（ResultSet）對象。
                 
                </li><li style="vertical-align: baseline;">
                    int executeUpdate(String sqlString)：用於執行INSERT、UPDATE或 
 
DELETE語句以及SQL DDL語句，如：CREATE TABLE和DROP TABLE等
                 
                </li><li style="vertical-align: baseline;">
                    execute(sqlString):用於執行返回多個結果集、多個更新計數或兩者組合的 
 
語句。
                 
             
         
     
 
ResultSet rs = stmt.executeQuery("SELECT * FROM ...") ;  
  int rows = stmt.executeUpdate("INSERT INTO ...") ;  
  boolean flag = stmt.execute(String sql) ;
<ul style="vertical-align: baseline;text-align: right;">
     
    <li style="vertical-align: baseline;">
        1
     
 
    </li><li style="vertical-align: baseline;">
        2
     
 
    </li><li style="vertical-align: baseline;">
        3
     
 
 
 
 
    6、處理結果
 
<blockquote style="vertical-align: baseline;">
    <ul style="vertical-align: baseline;">
        <li style="vertical-align: baseline;">
            兩種狀況： 
 
            <ol style="vertical-align: baseline;">
                <li style="vertical-align: baseline;">
                    執行更新返回的是本次操做影響到的記錄數。
                 
                </li><li style="vertical-align: baseline;">
                    執行查詢返回的結果是一個ResultSet對象。
                 
             
         
     
 
<ul style="vertical-align: baseline;color: rgb(153,153,153);">
    <li style="vertical-align: baseline;">
        ResultSet包含符合SQL語句中條件的全部行，而且它經過一套get方法提供了對這些 
 
行中數據的訪問。
     
    </li><li style="vertical-align: baseline;">
        使用結果集（ResultSet）對象的訪問方法獲取數據：
     
 
while(rs.next()){ String name = rs.getString("name") ; String pass = rs.getString(1) ; // 此方法比較高效  }
<ul style="vertical-align: baseline;text-align: right;">
     
    <li style="vertical-align: baseline;">
        1
     
 
    </li><li style="vertical-align: baseline;">
        2
     
 
    </li><li style="vertical-align: baseline;">
        3
     
 
    </li><li style="vertical-align: baseline;">
        4
     
 
 
 
 
    （列是從左到右編號的，而且從列1開始） 
 
7、關閉JDBC對象 
 
操做完成之後要把全部使用的JDBC對象全都關閉，以釋放JDBC資源，關閉順序和聲 
 
明順序相反： 
 
1、關閉記錄集 
 
2、關閉聲明
 
if(rs != null){   // 關閉記錄集  
    try{  
        rs.close() ;  
    }catch(SQLException e){  
        e.printStackTrace() ;  
    }  
      }  
      if(stmt != null){   // 關閉聲明  
    try{  
        stmt.close() ;  
    }catch(SQLException e){  
        e.printStackTrace() ;  
    }  
      }  
      if(conn != null){  // 關閉鏈接對象  
     try{  
        conn.close() ;  
     }catch(SQLException e){  
        e.printStackTrace() ;  
     }  
      }

View Code

Java的靜態方法屬於類的成員，實例方法屬於對象的成員。

===========================

javaScript 的經常使用事件

onblur 當元素失去焦點觸發此事件

onchange 當前元素失去焦點而且元素內容發生改變時觸發此事件

onfocus 當某個元素得到焦點時觸發此事件

onsubmit 當表單被提交時觸發此事件

onload 當頁面加載完成觸發此事件。、

http是一種超文本傳輸協議是一種請求/響應式協議客戶端在與服務器端創建鏈接後就能夠向服務器端發送請求，這種請求比成爲http請求

http 是無狀態協議，無狀態是指協議對於事務處理沒有記憶能力，若是後續處理須要前面的信息，則它必須重傳，這樣可能致使每次鏈接傳送的數據量增大。

==============================================

請求參數中的中文亂碼

對於post 請求只須要一步

request.setCharacterEncoding("UTF_8")

對於get 請求也須要

new String(name.getBytes("iso8859-1","UTF_8"))

若是瀏覽器請求另一個web資源的時候，用於響應封裝消息體的HttpServletResponse 對象已經建立，

該對象在編碼時採用默認的ISO-8859-1

當客戶端對接收到的數據進行解碼時，WEB服務器會繼續保持調用HttpServletResponse

對象中的信息，因此會對輸出的東西產生亂碼

解決辦法： response.setContentType("text/html","charset=utf-8");

===========================

cookie 的做用相似會員卡

當用戶經過瀏覽器發消息給服務器時服務器會給瀏覽器響應一些信息，這些信息都保存在Cookie 中這樣當瀏覽器再次訪問服務器時

都會在請求頭中將Cookie發送給服務器方便服務器對瀏覽器作出正確的響應。

服務器向客戶端發送Cookie時，會在Htttp 響應頭字段中增長Set-Cookie 響應頭字段

set-cookie 頭字段中設置的Cookie遵循必定的語法格式

Set-Cookie：user=itcast； Path=/

上述用例中；User表示Cookie的名稱 itcast 表示Cookie的值 Path表示Cookie的屬性，Cookie必須以鍵值對的形式存在，其屬性能夠有多個，可是這些

屬性之間務必使用 ; 或者空格分開。

Cookie 保存在瀏覽器的緩衝區中，Cookie一旦建立它的名稱就不能修改，Cookie值能夠爲任何值，建立後容許被修改

Cookie 技術能夠將用戶信息保存在各自的瀏覽器中，而且能夠在屢次請求下實現數據的共享，可是若是傳遞的消息比較多使用Cookie

顯然會增大服務器端處理的難度，這時可使用session技術，Session是一種將會話數據保存在服務器端的技術

=============================

jsp容器仙劍jsp文件轉換成一個java 源文件在轉換過程當中若是發現，jsp文件中存在任何語法錯誤，則中斷轉換過程，並向服務器端和客戶端返回錯誤信息

，若是轉換成功，則jsp容器將會生成java的源文件而後編譯成字節碼文件 .class 改class 文件就是一個Servlet Servlet容器hi像處理其餘Servlet同樣處理它

由Servlet容器加載轉換後的Servlet類（.class）建立一個Servlet實例並執行Servlet的jspInit()方法，而且這個方法在Servlet整個生命週期中只會執行一次

執行jspService()方法來處理客戶端的請求，對於每個請求jsp容器就會建立一個新的線程來處理它，若是多個客戶端同時請求該jsp文件則jsp容器也會建立多個線程

使得每個客戶端請求都對應一個線程，Servlet實例是常駐內存的因此響應速度很是快，若是jsp頁面輩成新編譯了會使用從新編譯後的結果取代內存中常駐的Servlet並繼續處理過程

=========================================

jsp的隱式對象(內置對象)

out : 用於頁面輸出

request ：獲得請求用戶信息

response：服務器象客戶端的迴應信息

config: 服務器配置，能夠取得初始化參數

session:用來保存用戶的信息

application：全部用戶的共享信息

page：指當前頁面轉換後的Servlet類的實例

pageContext： Jsp頁面容器

exception: 表示jsp頁面所發生的異常，在錯誤頁面中才起做用

在jsp頁面中 pageContext對象能夠獲取jsp的其餘8個隱式對象

===============================

爲了下降jsp頁面的複雜度，加強代碼的重用性Sun公司制定了一套標準標籤庫JSTL

同時爲了獲取Servlet域對象中存儲的數據

EL的隱式對象

EL中的隱式對象共有11 個

pageContext 對用於jsp頁面中中的pageContext 對象

pageScope 表明page 域中保存屬性的map對象

requestScope 表明request域中保存屬性的map對象

sessionScope 表明session域中保存屬性的map對象

applicationScope 表明application域中保存屬性的map對象

param 表示一個保存了全部請求的Map對象

paramValue 表示一個保存了全部請求的Map對象，他對於某個請求參數返回的是一個String類型的數組

header 表示一個保存了全部HTTP請求頭字段的Map對象

headerValues 表示一個保存了全部HTTP請求頭字段的Map對象,返回String類型數組

cookie 用來取得使用者的Cookie的值，cookie的類型是map

initParam 表示一個保存了全部WEB應用初始化參數的map 對象。

======================

filter 過濾器攔截的範圍 jsp;Servlet Html

================================================

通常關係數據模型和對象數據模型之間有如下對應關係：表對應類，記錄對應對象，表的字段對應類的屬性

目前ORMapping只是規定了數據結構和數據集的映射關係，還沒到規定賴關係的階段

在Applet中：

init(): 初始化；

start() 激活；

stop(): 當Applet被覆蓋時，可用stop()方法中止線程，典型做用是掛起一個線程；

destroy() ：終止Applet,釋放Applet的全部資源

字符用單引號，字符串用雙引號，與引號中的內容無關

選A

thread.Join把指定的線程加入到當前線程，能夠將兩個交替執行的線程合併爲順序執行的線程。好比在線程B中調用了線程A的Join()方法，直到線程A執行完畢後，纔會繼續執行線程B。

t.join(); //使調用線程 t 在此以前執行完畢。
t.join(1000); //等待 t 線程，等待時間是1000毫秒

Java中對字段屬性是靜態綁定，方法成員是動態綁定，這裏錯在：在子類中試圖訪問父類的private字段，因此編譯不經過，將private去掉就可訪問，不是動態綁定的問題，它原本就屬於靜態綁定

類的加載包括：加載，驗證，準備，解析，初始化。

選項A：生成java.lang.Class對象是在加載時進行的。生成Class對象做爲方法區這個類的各類數據的訪問入口。

選項B：既然是對象成員，那麼確定在實例化對象後纔有。在類加載的時候會賦予初值的是類變量，而非對象成員。

選項C：這個會調用。能夠用反射試驗。

選項D：類方法解析發生在解析過程。

類加載過程

類從被加載到虛擬機內存中開始，到卸載出內存爲止，它的整個生命週期包括：加載（Loading）、驗證（Verification）、準備(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using)和卸載(Unloading)7個階段。其中準備、驗證、解析3個部分統稱爲鏈接（Linking）。如圖所示。

加載、驗證、準備、初始化和卸載這5個階段的順序是肯定的，類的加載過程必須按照這種順序循序漸進地開始，而解析階段則不必定：它在某些狀況下能夠在初始化階段以後再開始，這是爲了支持Java語言的運行時綁定（也稱爲動態綁定或晚期綁定）。如下陳述的內容都已HotSpot爲基準。

加載

在加載階段（能夠參考java.lang.ClassLoader的loadClass()方法），虛擬機須要完成如下3件事情：

經過一個類的全限定名來獲取定義此類的二進制字節流（並無指明要從一個Class文件中獲取，能夠從其餘渠道，譬如：網絡、動態生成、數據庫等）；
將這個字節流所表明的靜態存儲結構轉化爲方法區的運行時數據結構；
在內存中生成一個表明這個類的java.lang.Class對象，做爲方法區這個類的各類數據的訪問入口；

加載階段和鏈接階段（Linking）的部份內容（如一部分字節碼文件格式驗證動做）是交叉進行的，加載階段還沒有完成，鏈接階段可能已經開始，但這些夾在加載階段之中進行的動做，仍然屬於鏈接階段的內容，這兩個階段的開始時間仍然保持着固定的前後順序。

驗證

驗證是鏈接階段的第一步，這一階段的目的是爲了確保Class文件的字節流中包含的信息符合當前虛擬機的要求，而且不會危害虛擬機自身的安全。
驗證階段大體會完成4個階段的檢驗動做：

文件格式驗證：驗證字節流是否符合Class文件格式的規範；例如：是否以魔術0xCAFEBABE開頭、主次版本號是否在當前虛擬機的處理範圍以內、常量池中的常量是否有不被支持的類型。
元數據驗證：對字節碼描述的信息進行語義分析（注意：對比javac編譯階段的語義分析），以保證其描述的信息符合Java語言規範的要求；例如：這個類是否有父類，除了java.lang.Object以外。
字節碼驗證：經過數據流和控制流分析，肯定程序語義是合法的、符合邏輯的。
符號引用驗證：確保解析動做能正確執行。

驗證階段是很是重要的，但不是必須的，它對程序運行期沒有影響，若是所引用的類通過反覆驗證，那麼能夠考慮採用-Xverifynone參數來關閉大部分的類驗證措施，以縮短虛擬機類加載的時間。

準備

準備階段是正式爲類變量分配內存並設置類變量初始值的階段，這些變量所使用的內存都將在方法區中進行分配。這時候進行內存分配的僅包括類變量（被static修飾的變量），而不包括實例變量，實例變量將會在對象實例化時隨着對象一塊兒分配在堆中。其次，這裏所說的初始值「一般狀況」下是數據類型的零值，假設一個類變量的定義爲：

 
         1 
       
          publicstaticintvalue=123;

那變量value在準備階段事後的初始值爲0而不是123.由於這時候還沒有開始執行任何java方法，而把value賦值爲123的putstatic指令是程序被編譯後，存放於類構造器()方法之中，因此把value賦值爲123的動做將在初始化階段纔會執行。
至於「特殊狀況」是指：public static final int value=123，即當類字段的字段屬性是ConstantValue時，會在準備階段初始化爲指定的值，因此標註爲final以後，value的值在準備階段初始化爲123而非0.

解析

解析階段是虛擬機將常量池內的符號引用替換爲直接引用的過程。解析動做主要針對類或接口、字段、類方法、接口方法、方法類型、方法句柄和調用點限定符7類符號引用進行。

初始化

類初始化階段是類加載過程的最後一步，到了初始化階段，才真正開始執行類中定義的java程序代碼。在準備極端，變量已經付過一次系統要求的初始值，而在初始化階段，則根據程序猿經過程序制定的主管計劃去初始化類變量和其餘資源，或者說：初始化階段是執行類構造器<clinit>()方法的過程.

<clinit>()方法是由編譯器自動收集類中的全部類變量的賦值動做和靜態語句塊static{}中的語句合併產生的，編譯器收集的順序是由語句在源文件中出現的順序所決定的，靜態語句塊只能訪問到定義在靜態語句塊以前的變量，定義在它以後的變量，在前面的靜態語句塊能夠賦值，可是不能訪問

原文連接 http://www.importnew.com/18548.html

子類的構造方法老是先調用父類的構造方法，若是子類的構造方法沒有明顯地指明使用父類的哪一個構造方法，子類就調用父類不帶參數的構造方法。
而父類沒有無參的構造函數，因此子類須要在本身的構造函數中顯示的調用父類的構造函數。

在子類繼承父類中，通常有一行super的語句，須要記住三種使用方法：

一、super.變量/對象名；
使用這種方法能夠直接訪問父類中的變量或對象，進行修改賦值等操做

二、super.方法名()；
直接訪問並調用父類中的方法

三、super();
調用父類的初始化方法，其實就是調用父類中的public xxx()方法，一般第三種指代的是super()的省略寫法，系統會默認添加此句。
特殊狀況：若是父類沒有無參的構造函數，因此子類須要在本身的構造函數中顯示的調用父類的構造函數，即不能使用系統默認的「super()」，而須要顯性寫出super(xxx)

Jsp只會在客戶端第一次發請求的時候被編譯，以後的請求不會再編譯，同時tomcat能自動檢測jsp變動與否，變動則再進行編譯。

第一次編譯並初始化時調用： init() ；銷燬調用： destroy() 。在整個jsp生命週期中均只調用一次。

service()方法是接收請求，返回響應的方法。每次請求都執行一次，該方法被HttpServlet封裝爲doGet和doPost方法

BC正確，選項B解釋，java核心卷I中43頁有以下表述：兩個數值進行二元操做時，會有以下的轉換操做：

若是兩個操做數其中有一個是double類型，另外一個操做就會轉換爲double類型。

不然，若是其中一個操做數是float類型，另外一個將會轉換爲float類型。

不然，若是其中一個操做數是long類型，另外一個會轉換爲long類型。

不然，兩個操做數都轉換爲int類型。

故，x==f1[0]中，x將會轉換爲float類型。

Java程序的種類有：

（a）內嵌於Web文件中，由瀏覽器來觀看的_Applet

（b）可獨立運行的 Application

（c）服務器端的 Servlets

Applet
―Java小程序」不能獨立運行（嵌入到Web頁中）。
由Java兼容瀏覽器控制執行。

在每一個線程中都是順序執行的，因此sl.printAll();必須在前三句執行以後執行，也就是輸出的內容必有（連續或非連續的）ABC。

而線程之間是穿插執行的，因此一個線程執行 sl.printAll();以前可能有另外一個線程執行了前三句的前幾句。

E答案至關於線程1順序執行完而後線程2順序執行完。

G答案則是線程1執行完前三句add以後線程2插一腳執行了一句add而後線程1再執行 sl.printAll();輸出ABCA。接着線程2順序執行完輸出

-------------------------------------------=======================================

 
         public 
         class 
         Enclosingone { 
        
         //非靜態內部類 
        
         public 
         class 
         InsideOne {} 
        
         //靜態內部類 
        
         public 
         static 
         class 
         InsideTwo{} 
        
         } 
        
         class 
         Mytest02{ 
        
         public 
         static 
         void 
         main(String args []){ 
        
         Enclosingone.InsideOne obj1 =  
         new 
         Enclosingone(). 
         new 
         InsideOne(); 
         //非靜態內部類對象 
        
         Enclosingone.InsideTwo obj2 =  
         new 
         Enclosingone.InsideTwo(); 
         //靜態內部類對象 
        
         } 
        
         }

關於封裝：

封住、繼承、多態是面向對象的三大特徵，其重要性與使用頻率不言而喻。------因此B錯誤。

1 、什麼是封裝？

封裝就是將屬性私有化，提供公有的方法訪問私有屬性。------------------- 因此CD錯誤。

作法就是：修改屬性的可見性來限制對屬性的訪問，併爲每一個屬性建立一對取值（ getter ）方法和賦值（ setter ）方法，用於對這些屬性的訪問。

如： private String name;

public String getName(){

return;

}

public void setName(String name){

this.name=name;

}

二、爲何須要封裝？

經過封裝，能夠實現對屬性的數據訪問限制，同時增長了程序的可維護性。

因爲取值方法和賦值方法隱藏了實現的變動，所以並不會影響讀取或修改該屬性的類，避免了大規模的修改，程序的可維護性加強

class A{
    public A foo(){return this;}
}
class B extends A{
    public A foo(){
        return this;
    }
}
class C extends B

{
    _______

}

若是子類的方法名與父類的方法名和參數相同，jvm會認爲子類是想要覆蓋（重寫）父類的方法的，若是是重寫，那麼不只方法名要相同，返回值和參數列表都要相同，爲何要這樣設定？
我想應該是爲了約束吧。若是方法名相同，參數相同但返回值不一樣，會有可能致使jvm認爲這兩個方法不是被子類方法重寫了（繼承中不存在重載），那麼子類經過這個方法名調用方法的時候，就會有有歧義了，不能肯定是調用自身的方法仍是父類的方法。好比說B選項這種狀況，public int foo(){return 1;}，當我c.foo()；那c此時調用的是自身foo方法仍是父類的呢？因此jvm若是發現是方法名和參數同樣的方法，默認爲這是重寫父類方法。

Ant和Maven都是基於Java的構建(build)工具。理論上來講，有些相似於（Unix）C中的make ，但沒有make的缺陷。Ant是軟件構建工具，Maven的定位是軟件項目管理和理解工具。
Ant特色
沒有一個約定的目錄結構必須明確讓ant作什麼，何時作，而後編譯，打包沒有生命週期，必須定義目標及其實現的任務序列沒有集成依賴管理
Maven特色
擁有約定，知道你的代碼在哪裏，放到哪裏去擁有一個生命週期，例如執行 mvn install 就能夠自動執行編譯，測試，打包等構建過程只須要定義一個pom.xml,而後把源碼放到默認的目錄，Maven幫你處理其餘事情擁有依賴管理，倉庫管理

重載是在同一個類中，有多個方法名相同，參數列表不一樣(參數個數不一樣，參數類型不一樣),與方法的返回值無關，與權限修飾符無關，B中的參數列表和題目的方法徹底同樣了。

必須明確行數，列數不重要

數組有length屬性，字符串只有length()方法

內存泄露(Memory Leak)是指一個再也不被使用的對象或者變量還在內存中佔有存儲空間。

在C/C++語言中，內存泄露出如今開發人員忘記釋放已分配的內存就會形成內存泄露。在java語言中引入垃圾回收機制，有GC負責進行回收再也不使用的對象，釋放內存。可是仍是會存在內存泄露的問題。

內存泄露主要有兩種狀況：1.在堆中申請的空間沒有釋放。2.對象已再也不被使用(注意：這裏的不在被使用是指對程序來講沒有用處，如數據庫鏈接使用後沒有關。可是仍是存在着引用)，可是仍然在內存中保留着。GC機制的引入只能解決第一種狀況，對於第2種狀況沒法保證再也不使用的對象會被釋放。java語言中的內存泄露主要指第2種狀況。
內存泄露的緣由：1.靜態集合類。如HashMap和Vector。這些容器是靜態的，生命週期和程序的生命週期一致，那麼在容器中對象的生命週期也和其同樣，對象在程序結束以前將不能被釋放，從而會形成內存泄露。2.各類鏈接，如數據庫鏈接，網絡鏈接，IO鏈接，再也不使用時若是鏈接不釋放容易形成內存泄露。3.監聽器，釋放對象時每每沒有相應的刪除監聽器，可能會致使內存泄露。
內存溢出（OOM）是指程序在申請內存時沒有足夠的內存供使用，進而致使程序崩潰這是結果描述。內存泄露（Memory Leak）最終會致使內存溢出。

優先級高的並不必定會立刻執行。

sleep方法會阻塞一個線程並不會終止

建立一個新的線程時也不會終止另外一個線程

當拋出一個異常後程序會結束，因此線程也會被終止

同一個類內，private變量能夠訪問，因此CD錯。因爲x是static的，存貯在類內，而不是對象內，因此++、--操做的是同一個變量。

ArrayList的構造函數總共有三個：

（1）ArrayList()構造一個初始容量爲 10 的空列表。

（2）ArrayList(Collection<? extends E> c)構造一個包含指定 collection 的元素的列表，這些元素是按照該 collection 的迭代器返回它們的順序排列的。

（3）ArrayList(int initialCapacity)構造一個具備指定初始容量的空列表。

調用的是第三個構造函數，直接初始化爲大小爲20的list，沒有擴容，因此選擇A

類的初始化過程也就是方法執行的過程父類的靜態變量-父類的靜態代碼塊子類的靜態變量-子類的靜態代碼塊父類的非靜態變量-父類的非靜態代碼塊-父類的構造函數子類的非靜態變量-子類的非靜態代碼塊-子類的構造函數規律就是父類先於子類靜態的先於非靜態的變量先於代碼塊

派生類自己的構造函數 這個應該指的是構造代碼塊

枚舉類有三個實例，故調用三次構造方法，打印三次It is a account type

JEE5.0中的Servlet相關的就下面這幾個包:
javax.servlet
javax.servlet.jsp
java.servlet.jsp.el
java.servlet.jsp.tagext
而最用得多的就是
javax.servlet
javax.servlet.http
這兩個包了.

構造函數的做用是完成對象的初始化。當程序執行到new操做符時， 首先去看new操做符後面的類型，由於知道了類型，才能知道要分配多大的內存空間。分配完內存以後，再調用構造函數，填充對象的各個域，這一步叫作對象的初始化。而選項B、D中，對象的初始化並非經過構造函數完成的，而是讀取別的內存區域中的對象的各個域來完成。

含有abstract修飾符的class即爲抽象類，abstract類不能建立的實例對象。含有abstract方法的類必須定義爲abstract class，abstract class類中的方法沒必要是抽象的。abstract class

類中定義抽象方法必須在具體

(Concrete)子類中實現，因此，不能有抽象構造方法或抽象靜態方法。若是的子類沒有實現抽象父類中的全部抽象方法，那麼子類也必須定義爲abstract類型。

接口（interface）能夠說成是抽象類的一種特例，接口中的全部方法都必須是抽象的。接口中的方法定義默認爲public abstract類型，接口中的成員變量類型默認爲public static final。

1.抽象類能夠有構造方法，接口中不能有構造方法。

2.抽象類中能夠有普通成員變量，接口中沒有普通成員變量

3.抽象類中能夠包含非抽象的普通方法，接口中的全部方法必須都是抽象的，不能有非抽象的普通方法。

4. 抽象類中的抽象方法的訪問類型能夠是public，protected和（默認類型,雖然

eclipse下不報錯，但應該也不行），但接口中的抽象方法只能是public類型的，而且默認即爲public abstract類型。

5. 抽象類中能夠包含靜態方法，接口中不能包含靜態方法

6. 抽象類和接口中均可以包含靜態成員變量，抽象類中的靜態成員變量的訪問類型能夠任意，但接口中定義的變量只能是public static final類型，而且默認即爲public static final類型。

A，D考的一個知識點，final修飾變量，變量的引用（也就是指向的地址）不可變，可是引用的內容能夠變（地址中的內容可變）。

B，finally表示老是執行。可是其實finally也有不執行的時候，可是這個題不要扣字眼。

1. 在try中調用System.exit(0)，強制退出了程序，finally塊不執行。

2. 在進入try塊前，出現了異常，finally塊不執行。

C，finalize方法，這個選項錯就錯在，這個方法一個對象只能執行一次，只能在第一次進入被回收的隊列，並且對象所屬於的類重寫了finalize方法纔會被執行。第二次進入回收隊列的時候，不會再執行其finalize方法，而是直接被二次標記，在下一次GC的時候被GC。

A. request.getAttribute:getAttribute是在服務器端的操做。
好比說 request.setAttribute(k,v),其行爲動做在服務器端。
而在服務端放入cookies是經過response.addCookie(cookie)。所以，A錯了

B. Accept 瀏覽器可接受的MIME類型
Accept-Charset 瀏覽器支持的字符編碼
Accept-Encoding 瀏覽器知道如何解碼的數據編碼類型(如 gzip)。Servlets 能夠預先檢查瀏覽器是否支持gzip並能夠對支持gzip的瀏覽器返回gzipped的HTML頁面，並設置Content-Encoding迴應頭(response header)來指出發送的內容是已經gzipped的。在大多數狀況下，這樣作能夠加快網頁下載的速度。
Accept-Language 瀏覽器指定的語言，當Server支持多語種時起做用。
Authorization 認證信息，通常是對服務器發出的WWW-Authenticate頭的迴應。
Connection 是否使用持續鏈接。若是servlet發現這個字段的值是Keep-Alive，或者由發出請求的命令行發現瀏覽器支持 HTTP 1.1 (持續鏈接是它的默認選項)，使用持續鏈接可使保護不少小文件的頁面的下載時間減小。
Content-Length (使用POST方法提交時，傳遞數據的字節數)
Cookie (很重要的一個Header，用來進行和Cookie有關的操做，詳細的信息將在後面的教程中介紹)
Host (主機和端口)
If-Modified-Since (只返回比指定日期新的文檔，若是沒有，將會反回304 "Not Modified")
Referer (URL)
User-Agent (客戶端的類型，通常用來區分不一樣的瀏覽器)

C.request.getParameter()方法獲取從客戶端中經過get 或者post方式傳送到服務器端的參數。行爲操做在服務器端。因此cookies明顯不是經過url或者form表單提交過來的。C錯

D.看方法名字就好了。

java是不須要使用者關注內存分配以及管理的

MVC只是將分管不一樣功能的邏輯代碼進行了隔離，加強了可維護和可擴展性，加強代碼複用性，所以能夠減小代碼重複。可是不保證減小代碼量，多層次的調用模式還有可能增長代碼量

A，Java沒有指針，只有引用。

C，並非程序結束的時候進行GC，GC的時間是不肯定的，且GC的過程須要通過可達性分析，一個對象只有被標記兩次纔會被GC。

下圖是一個對象被GC的全過程。

當你建立一個新的實例對象時，它會獲得一塊新的內存空間。可是類中的靜態成員變量是全部對象共有的，也就是在一片屬於類的存儲空間中，被全部對象共有。

A:不存在x[25] 索引從0開始到length-1
B:x[24] 存的是默認值0(java中沒有'\0'這一說)
C:超出內存正確
D:第二元素

玩文字遊戲呢！指向的內容在常量池中不能夠變，可是能夠改變string的指向

第四行：由於有new關鍵字，因此在heap中開闢了一塊新內存放置值爲59的Integer對象。

sleep和wait的區別有：
  1，這兩個方法來自不一樣的類分別是Thread和Object
  2，最主要是sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得敏感詞線程可使用同步控制塊或者方法。
  3，wait，notify和notifyAll只能在同步控制方法或者同步控制塊裏面使用，而sleep能夠在
    任何地方使用
   synchronized(x){
      x.notify()
     //或者wait()
   }
   4,sleep必須捕獲異常，而wait，notify和notifyAll不須要捕獲異常

由於兩次new() 分出的內存也不一樣

析構函數(destructor) 與構造函數相反，當對象結束其生命週期時（例如對象所在的函數已調用完畢），系統自動執行析構函數。析構函數每每用來作「清理善後」的工做（例如在創建對象時用new開闢了一片內存空間，應在退出前在析構函數中用delete釋放）。

A:.java編譯成的是字節碼，再被各系統的jvm翻譯成本系統能夠識別的機器碼，這就是java一次編程多平臺應用的跨平臺性 B:java源文件生成的是class文件，與系統無關 C:注意字節碼和機器碼不是一回事 java程序在運行時字節碼纔會被jvm翻譯成機器碼，因此說java是解釋性語言 D:注意jvm的版本，比如人穿褲子，一條褲子能被任何人穿上嗎

-Xmx：最大堆大小

-Xms：初始堆大小

-Xmn:年輕代大小

-XXSurvivorRatio：年輕代中Eden區與Survivor區的大小比值

年輕代5120m， Eden：Survivor=3，Survivor區大小=1024m（Survivor區有兩個，即將年輕代分爲5份，每一個Survivor區佔一份），總大小爲2048m。

-Xms初始堆大小即最小內存值爲10240m

虛擬機中的共劃分爲三個代：年輕代（Young Generation）、年老點（Old Generation）和持久代（Permanent Generation）。其中持久代主要存放的是Java類的類信息，與垃圾收集要收集的Java對象關係不大。年輕代和年老代的劃分是對垃圾收集影響比較大的。

　年輕代:

　　全部新生成的對象首先都是放在年輕代的。年輕代的目標就是儘量快速的收集掉那些生命週期短的對象。年輕代分三個區。一個Eden區，兩個 Survivor區(通常而言)。大部分對象在Eden區中生成。當Eden區滿時，還存活的對象將被複制到Survivor區（兩個中的一個），當這個 Survivor區滿時，此區的存活對象將被複制到另一個Survivor區，當這個Survivor去也滿了的時候，從第一個Survivor區複製過來的而且此時還存活的對象，將被複制「年老區(Tenured)」。須要注意，Survivor的兩個區是對稱的，沒前後關係，因此同一個區中可能同時存在從Eden複製過來對象，和從前一個Survivor複製過來的對象，而複製到年老區的只有從第一個Survivor去過來的對象。並且，Survivor區總有一個是空的。同時，根據程序須要，Survivor區是能夠配置爲多個的（多於兩個），這樣能夠增長對象在年輕代中的存在時間，減小被放到年老代的可能。

　　年老代:

　　在年輕代中經歷了N次垃圾回收後仍然存活的對象，就會被放到年老代中。所以，能夠認爲年老代中存放的都是一些生命週期較長的對象。

-Xmx10240m：表明最大堆

-Xms10240m：表明最小堆

-Xmn5120m：表明新生代

-XXSurvivorRatio=3：表明Eden:Survivor = 3 根據Generation-Collection算法(目前大部分JVM採用的算法)，通常根據對象的生存週期將堆內存分爲若干不一樣的區域，通常狀況將新生代分爲Eden ，兩塊Survivor；計算Survivor大小， Eden:Survivor = 3，總大小爲5120,3x+x+x=5120 x=1024

新生代大部分要回收，採用Copying算法，快！

老年代大部分不須要回收，採用Mark-Compact算法

注意x是Byte類型，也就是byte的包裝類型，屬於引用類型。實例該類對象時，若是成員變量沒有顯示初始化那麼Java默認初始化爲null.

該題中引用類型t做爲形參進行傳遞，形參的改變會改變實參的值，因此再次打印t.x時已經變爲42了。

suspend() 和 resume() 方法：兩個方法配套使用，suspend()使得線程進入阻塞狀態，而且不會自動恢復，必須其對應的 resume() 被調用，才能使得線程從新進入可執行狀態

Hashtable：

（1）Hashtable 是一個散列表，它存儲的內容是鍵值對(key-value)映射。

（2）Hashtable 的函數都是同步的，這意味着它是線程安全的。它的key、value都不能夠爲null。

（3）HashTable直接使用對象的hashCode。

HashMap：

（1）由數組+鏈表組成的，基於哈希表的Map實現，數組是HashMap的主體，鏈表則是主要爲了解決哈希衝突而存在的。

（2）不是線程安全的，HashMap能夠接受爲null的鍵(key)和值(value)。