J2SE

J2SE

1）如何調整JVM與Tomcat的內存大小？

TomCat的內存大小：

安裝版：在安裝目錄找到Bin目錄下的Tomcat7w.exe 進去以後選擇Java選項卡，修改最大與最小內存；

綠色版：在bin目錄下找到catalina.bat，用編輯工具打開後，在:gotHome後輸入set "JAVA_OPTS=-Xms512m -Xmx1024m" ；

JVM的內存大小：

Eclise 中設置jvm內存: 改動eclipse的配置文件,對所有project都起做用改動eclipse根文件夾下的eclipse.ini文件

-vmargs  //虛擬機設置

-Xms40m //初始內存

-Xmx256m //最大內存

-Xmn16m //最小內存

-XX:PermSize=128M //非堆內存

-XX:MaxPermSize=256M

2）Java語言裏的類型分類？八大基本類型之間轉換問題

類型分爲基本類型和引用類型；類型轉換，大轉小自動轉，小轉大強制轉，強制轉可能損失精度；

3）面向對象思想

封裝 繼承 多態

繼承：

在定義和實現一個類的時候，能夠在一個已經存在的類的基礎之上來進行，把這個已經存在的類所定義的內容做爲本身的內容，並能夠加入若干新的內容，或修改原來的方法使之更適合特殊的須要，這就是繼承。繼承是子類自動共享父類數據和方法的機制，這是類之間的一種關係，提升了軟件的可重用性和可擴展性。

封裝：

封裝是保證軟件部件具備優良的模塊性的基礎，封裝的目標就是要實現軟件部件的「高內聚、低耦合」，防止程序相互依賴性而帶來的變更影響。在面向對象的編程語言中，對象是封裝 的最基本單位，面向對象的封裝比傳統語言的封裝更爲清晰、更爲有力。面向對象的封裝就是把描述一個對象的屬性和行爲的代碼封裝在一個「模塊」中，也就是一個類中，屬性用變量定義，行爲用方法進行定義，方法能夠直接訪問同一個對象中的屬性。一般狀況下，只要記 住讓變量和訪問這個變量的方法放在一塊兒，將一個類中的成員變量所有定義成私有的，只有這個類本身的方法才能夠訪問到這些成員變量，這就基本上實現對象的封裝，就很容易找出要分配到這個類上的方法了，就基本上算是會面向對象的編程了。把握一個原則:把 對同一事物進行操做的方法和相關的方法放在同一個類中，把方法和它操做的數據放在同 一個類中。

例如，人要在黑板上畫圓，這一共涉及三個對象:人、黑板、圓，畫圓的方法要分配給哪一個對象呢?因爲畫圓須要使用到圓心和半徑，圓心和半徑顯然是圓的屬性，若是將它們在類中定義成了私有的成員變量，那麼，畫圓的方法必須分配給圓，它才能訪問到圓心和半徑這兩 個屬性，人之後只是調用圓的畫圓方法、表示給圓發給消息而已，畫圓這個方法不該該分配在人這個對象上，這就是面向對象的封裝性，即將對象封裝成一個高度自治和相對封閉的 個體，對象狀態(屬性)由這個對象本身的行爲(方法)來讀取和改變。

一個更便於理解的例子就是，司機將火車剎住了，剎車的動做是分配給司機，仍是分配給火車，顯然，應該分配給火車，由於司機自身是不可能有那麼大的力氣將一個火車給停下來的，只有火車本身 才能完成這一動做，火車須要調用內部的離合器和剎車片等多個器件協做才能完成剎車這個動做，司機剎車的過程只是給火車發了一個消息，通知火車要執行剎車動做而已。

多態：

多態是指程序中定義的引用變量所指向的具體類型和經過該引用變量發出的方法調用在編 程時並不肯定，而是在程序運行期間才肯定，即一個引用變量倒底會指向哪一個類的實例對象， 該引用變量發出的方法調用究竟是哪一個類中實現的方法，必須在由程序運行期間才能決定。 由於在程序運行時才肯定具體的類，這樣，不用修改源程序代碼，就可讓引用變量綁定到 各類不一樣的類實現上，從而致使該引用調用的具體方法隨之改變，即不修改程序代碼就能夠 改變程序運行時所綁定的具體代碼，讓程序能夠選擇多個運行狀態，這就是多態性。多態性 加強了軟件的靈活性和擴展性。例如，下面代碼中的 UserDao 是一個接口，它定義引用變 量 userDao 指向的實例對象由 daofactory.getDao()在執行的時候返回，有時候指向的是 UserJdbcDao 這個實現，有時候指向的是 UserHibernateDao 這個實現，這樣，不用修改 源代碼，就能夠改變 userDao 指向的具體類實現，從而致使 userDao.insertUser()方法調用 的具體代碼也隨之改變，即有時候調用的是 UserJdbcDao 的 insertUser 方法，有時候調用 的是 UserHibernateDao 的 insertUser 方法:

UserDao userDao =daofactory.getDao(); userDao.insertUser(user);

比喻:人吃飯，你看到的是左手，仍是右手?

4）如何理解多態（3個特徵）

什麼是多態

面向對象的三大特性：封裝、繼承、多態。從必定角度來看，封裝和繼承幾乎都是爲多態而準備的。這是咱們最後一個概念，也是最重要的知識點。

多態的定義：指容許不一樣類的對象對同一消息作出響應。即同一消息能夠根據發送對象的不一樣而採用多種不一樣的行爲方式。（發送消息就是函數調用）

實現多態的技術稱爲：動態綁定（dynamic binding），是指在執行期間判斷所引用對象的實際類型，根據其實際的類型調用其相應的方法。

多態的做用：消除類型之間的耦合關係。

現實中，關於多態的例子不勝枚舉。比方說按下 F1 鍵這個動做，若是當前在 Flash 界面下彈出的就是 AS 3 的幫助文檔；若是當前在 Word 下彈出的就是 Word 幫助；在 Windows 下彈出的就是 Windows 幫助和支持。同一個事件發生在不一樣的對象上會產生不一樣的結果。

下面是多態存在的三個必要條件，要求你們作夢時都能背出來！

多態存在的三個必要條件
1、要有繼承；
2、要有重寫；
3、父類引用指向子類對象。

 多態的好處：

1.可替換性（substitutability）。多態對已存在代碼具備可替換性。例如，多態對圓Circle類工做，對其餘任何圓形幾何體，如圓環，也一樣工做。
2.可擴充性（extensibility）。多態對代碼具備可擴充性。增長新的子類不影響已存在類的多態性、繼承性，以及其餘特性的運行和操做。實際上新加子類更容易得到多態功能。例如，在實現了圓錐、半圓錐以及半球體的多態基礎上，很容易增添球體類的多態性。
3.接口性（interface-ability）。多態是超類經過方法簽名，向子類提供了一個共同接口，由子類來完善或者覆蓋它而實現的。如圖8.3 所示。圖中超類Shape規定了兩個實現多態的接口方法，computeArea()以及computeVolume()。子類，如Circle和Sphere爲了實現多態，完善或者覆蓋這兩個接口方法。
4.靈活性（flexibility）。它在應用中體現了靈活多樣的操做，提升了使用效率。
5.簡化性（simplicity）。多態簡化對應用軟件的代碼編寫和修改過程，尤爲在處理大量對象的運算和操做時，這個特色尤其突出和重要。
Java中多態的實現方式：接口實現，繼承父類進行方法重寫，同一個類中進行方法重載。

5）具備繼承關係類之間的類型轉換問題

繼承中類型轉換的兩種方式
1.向上轉型 
  將子類對象轉換成父類類型，例如：
  Pet pet=new Dog();
  此類型轉換爲自動轉換
  由於子類的功能比父類更增強大，至關於讓一個能力強的對象去作一件簡單的事情，所以能夠自動轉換完成


2.向下轉型

向下轉型的時候須要用instanceof判斷一個對象是否屬於右邊的類型。(強制轉換可能失敗)

將父類對象轉換爲子類類型，例如：
  Pet pet=new Pet();
  Dog dog=(Dog)pet;
  此類型轉換爲強制轉換
  由於反之，父類的功能要弱於子類，所以須要強制轉換

6）抽象類與接口的關係

區別：接口只能有賦值的全局常量；接口的全部方法只能是Public修飾的；而且沒有構造函數。

抽象類有構造函數，有普通成員變量，能夠有帶方法體的方法，也能夠是抽象方法；

聯繫：a)接口和抽象類都有抽象方法

      b)都不能直接去new ，只能new不是抽象類型的子類（實現類）。

徹底抽象化的抽象類，能夠叫作接口。

接口不是特殊的抽象類。

7）類與類之間的關係

繼承：

  繼承指的是一個類（稱爲子類、子接口）繼承另外的一個類（稱爲父類、父接口）的功能，並能夠增長它本身的新功能的能力。在Java中繼承關係經過關鍵字extends明確標識，在設計時通常沒有爭議性。在UML類圖設計中，繼承用一條帶空心三角箭頭的實線表示，從子類指向父類，或者子接口指向父接口。

實現：

實現指的是一個class類實現interface接口（能夠是多個）的功能，實現是類與接口之間最多見的關係。在Java中此類關係經過關鍵字implements明確標識，在設計時通常沒有爭議性。在UML類圖設計中，實現用一條帶空心三角箭頭的虛線表示，從類指向實現的接口。 

依賴：

簡單的理解，依賴就是一個類A使用到了另外一個類B，而這種使用關係是具備偶然性的、臨時性的、很是弱的，可是類B的變化會影響到類A。好比某人要過河，須要借用一條船，此時人與船之間的關係就是依賴。表如今代碼層面，爲類B做爲參數被類A在某個method方法中使用。在UML類圖設計中，依賴關係用由類A指向類B的帶箭頭虛線表示。

關聯：

一對一  多對多   一對多

關聯體現的是兩個類之間語義級別的一種強依賴關係，好比我和個人朋友，這種關係比依賴更強、不存在依賴關係的偶然性、關係也不是臨時性的，通常是長期性的，並且雙方的關係通常是平等的。關聯能夠是單向、雙向的。表如今代碼層面，爲被關聯類B以類的屬性形式出如今關聯類A中，也多是關聯類A引用了一個類型爲被關聯類B的全局變量。在UML類圖設計中，關聯關係用由關聯類A指向被關聯類B的帶箭頭實線表示，在關聯的兩端能夠標註關聯雙方的角色和多重性標記。 

聚合：

 聚合是關聯關係的一種特例，它體現的是總體與部分的關係，即has-a的關係。此時總體與部分之間是可分離的，它們能夠具備各自的生命週期，部分能夠屬於多個總體對象，也能夠爲多個總體對象共享。好比計算機與CPU、公司與員工的關係等，好比一個航母編隊包括海空母艦、驅護艦艇、艦載飛機及核動力攻擊潛艇等。表如今代碼層面，和關聯關係是一致的，只能從語義級別來區分。在UML類圖設計中，聚合關係以空心菱形加實線箭頭表示。

組合：

組合也是關聯關係的一種特例，它體現的是一種contains-a的關係，這種關係比聚合更強，也稱爲強聚合。它一樣體現總體與部分間的關係，但此時總體與部分是不可分的，總體的生命週期結束也就意味着部分的生命週期結束，好比人和人的大腦。表如今代碼層面，和關聯關係是一致的，只能從語義級別來區分。在UML類圖設計中，組合關係以實心菱形加實線箭頭表示。 

總結： 對於繼承、實現這兩種關係沒多少疑問，它們體現的是一種類和類、或者類與接口間的縱向關係。其餘的四種關係體現的是類和類、或者類與接口間的引用、橫向關係，是比較難區分的，有不少事物間的關係要想準肯定位是很難的。前面也提到，這四種關係都是語義級別的，因此從代碼層面並不能徹底區分各類關係，但總的來講，後幾種關係所表現的強弱程度依次爲：組合>聚合>關聯>依賴。

8）內部類

爲何要出現內部類：方便一個類去訪問一個類裏面私有的內容；

內部類的分類：成員式內部類，方法式內部類，匿名內部類

建立靜態內部類對象的通常形式爲：  外部類類名.內部類類名 xxx = new 外部類類名.內部類類名()

建立成員內部類對象的通常形式爲：  外部類類名.內部類類名 xxx = 外部類對象名.new 內部類類名()

9）Object

內容的比較（equal  hascode）

equal比較的是對象的值；==比較的是對象的地址；

hascode是更具特殊的算法算出的每一個實例的碼；

對象的克隆（clone）

clone方法是用來複制一個對象。不一樣於「=」。
對於值類型的數據是能夠經過「=」來實現複製的。可是對於引用類型的對象，「=」只能複製其內存地址，使對象的引用指向同一個對象，而不會建立新的對象。clone則能夠建立與原來對象相同的對象。

引用類型轉換成字符串

toString  如需改變須要重寫toString和hascode方法；

Wait：將線程放置鎖池  notify：喚醒一個至運行隊列    notifyall：所有喚醒至運行隊列

10）如何來實現對自定義類設置排序規則？

//採用實現Comparable接口的方法實現排序  

class S1 implements Comparable{  

   //實現排序方法。先比較x，若是相同比較y  

    @Override  

    public int compareTo(Object o) {  

        S1 obj = (S1) o;  

        if(x != obj.x)  

        {  

            return x - obj.x;  

        }  

        return y - obj.y;  

}  

實現Comparator

11）String  StringBuffer  StringBuild

主要在字符串拼接，String是把拼接的每次結果都開闢內存空間。

StringBuffer  的全部方法都實現了同步，因此慢

StringBuild 是線程不安全的，因此快。

12）線程安全    線程不安全

主要體如今多線程中，線程不安全容易形成不可預估的錯亂。而線程安全的只有每次執行完整纔會讓下一個線程進入；

13）基本類型   包裝類    字符串

基本類型轉包裝類叫裝箱

包裝類轉基本類型叫拆箱

JDK1.5以後支持自動裝箱與拆箱。

字符串轉基本類型經過各自包裝類的解析方法解析；或者經過特有的構造函數；

14）實現數組對象的複製

Arrays.copyOf(被複制的數組，複製長度)。

copyOf(),,不是System的方法，而是Arrays的方法,下面是源碼，能夠看到本質上是調用的arraycopy方法。，那麼其效率必然是比不上 arraycopy的.

public static int[] copyOf(int[] original, int newLength) {

   int[] copy = new int[newLength];

   System.arraycopy(original, 0, copy, 0,

   Math.min(original.length, newLength));

   return copy;

}

使用方法： 
1.使用clone 
int[] src={1,3,5,6,7,8}; 
int[] dest; 
dest=(int[]) src.clone();//使用clone建立副本,注意clone要使用強制轉換

二、使用System.arraycopy 
int[] src={1,3,5,6,7,8}; 
int[] dest = new int[6]; 
System.arraycopy(src, 0, dest, 0, 6);

15）垃圾回收機制

能夠經過System.gc()進行提醒

能夠重寫Object類裏的析構函數finalize

在對象回首以前會調用finalize（） 相似C語言中的析構函數這個；

方法區：
1. 有時候也成爲永久代，在該區內不多發生垃圾回收，可是並不表明不發生GC，在這裏進行的GC主要是對方法區裏的常量池和對類型的卸載
2. 方法區主要用來存儲已被虛擬機加載的類的信息、常量、靜態變量和即時編譯器編譯後的代碼等數據。
3. 該區域是被線程共享的。
4. 方法區裏有一個運行時常量池，用於存放靜態編譯產生的字面量和符號引用。該常量池具備動態性，也就是說常量並不必定是編譯時肯定，運行時生成的常量也會存在這個常量池中。

虛擬機棧:
1. 虛擬機棧也就是咱們日常所稱的棧內存,它爲java方法服務，每一個方法在執行的時候都會建立一個棧幀，用於存儲局部變量表、操做數棧、動態連接和方法出口等信息。
2. 虛擬機棧是線程私有的，它的生命週期與線程相同。
3. 局部變量表裏存儲的是基本數據類型、returnAddress類型（指向一條字節碼指令的地址）和對象引用，這個對象引用有多是指向對象起始地址的一個指針，也有多是表明對象的句柄或者與對象相關聯的位置。局部變量所需的內存空間在編譯器間肯定
4.操做數棧的做用主要用來存儲運算結果以及運算的操做數，它不一樣於局部變量表經過索引來訪問，而是壓棧和出棧的方式
5.每一個棧幀都包含一個指向運行時常量池中該棧幀所屬方法的引用，持有這個引用是爲了支持方法調用過程當中的動態鏈接.動態連接就是將常量池中的符號引用在運行期轉化爲直接引用。

本地方法棧
本地方法棧和虛擬機棧相似，只不過本地方法棧爲Native方法服務。

堆
java堆是全部線程所共享的一塊內存，在虛擬機啓動時建立，幾乎全部的對象實例都在這裏建立，所以該區域常常發生垃圾回收操做。

程序計數器
內存空間小，字節碼解釋器工做時經過改變這個計數值能夠選取下一條須要執行的字節碼指令，分支、循環、跳轉、異常處理和線程恢復等功能都須要依賴這個計數器完成。該內存區域是惟一一個java虛擬機規範沒有規定任何OOM狀況的區域

判斷一個對象是否存活有兩種方法:
1. 引用計數法
所謂引用計數法就是給每個對象設置一個引用計數器，每當有一個地方引用這個對象時，就將計數器加一，引用失效時，計數器就減一。當一個對象的引用計數器爲零時，說明此對象沒有被引用，也就是「死對象」,將會被垃圾回收.
引用計數法有一個缺陷就是沒法解決循環引用問題，也就是說當對象A引用對象B，對象B又引用者對象A，那麼此時A,B對象的引用計數器都不爲零，也就形成沒法完成垃圾回收，因此主流的虛擬機都沒有采用這種算法。

2.可達性算法(引用鏈法)
該算法的思想是：從一個被稱爲GC Roots的對象開始向下搜索，若是一個對象到GC Roots沒有任何引用鏈相連時，則說明此對象不可用。
在java中能夠做爲GC Roots的對象有如下幾種:

虛擬機棧中引用的對象

方法區類靜態屬性引用的對象

方法區常量池引用的對象

本地方法棧JNI引用的對象

雖然這些算法能夠斷定一個對象是否能被回收，可是當知足上述條件時，一個對象比不必定會被回收。當一個對象不可達GC Root時，這個對象並不會立馬被回收，而是出於一個死緩的階段，若要被真正的回收須要經歷兩次標記
若是對象在可達性分析中沒有與GC Root的引用鏈，那麼此時就會被第一次標記而且進行一次篩選，篩選的條件是是否有必要執行finalize()方法。當對象沒有覆蓋finalize()方法或者已被虛擬機調用過，那麼就認爲是不必的。
若是該對象有必要執行finalize()方法，那麼這個對象將會放在一個稱爲F-Queue的對隊列中，虛擬機會觸發一個Finalize()線程去執行，此線程是低優先級的，而且虛擬機不會承諾一直等待它運行完，這是由於若是finalize()執行緩慢或者發生了死鎖，那麼就會形成F-Queue隊列一直等待，形成了內存回收系統的崩潰。GC對處於F-Queue中的對象進行第二次被標記，這時，該對象將被移除」即將回收」集合，等待回收。

簡述java垃圾回收機制?

在java中，程序員是不須要顯示的去釋放一個對象的內存的，而是由虛擬機自行執行。在JVM中，有一個垃圾回收線程，它是低優先級的，在正常狀況下是不會執行的，只有在虛擬機空閒或者當前堆內存不足時，纔會觸發執行，掃面那些沒有被任何引用的對象，並將它們添加到要回收的集合中，進行回收。

16）異常處理機制

異常分爲：編譯期異常   運行期異常

常見的異常：

NO.1  Java.alng.NullPointerException 

這個異常你們確定都常常遇到，異常的解釋是 「程序趕上了空指針 「，簡單地說就是調用了未經初始化的對象或者是不存在的對象，這個錯誤常常出如今建立圖片，調用數組這些操做中，好比圖片未經初始化，或者圖片建立時的路徑錯誤等等。對數組操做中出現空指針，不少狀況下是一些剛開始學習編程的朋友常犯的錯誤，即把數組的初始化和數組元素的初始化混淆起來了。數組的初始化是對數組分配須要的空間，而初始化後的數組，其中的元素並無實例化，
依然是空的，因此還須要對每一個元素都進行初始化（若是要調用的話）。
　　在jsp編程中常常出現：if (request.getParameter(「username」).equals(「xxx」))、out.println(session.getAttribute(「record」))等。解決這個問題的方法是在使用前進行判空比較：
　　 if (request.getParameter(「username」)!=null)
　　{if if (request.getParameter(「username」).
　　equals(「xxx」))…}

 

NO.2　java.lang.ClassNotFoundException

這個異常是不少本來在JB等開發環境中開發的程序員，把JB下的程序包放在WTk下編譯常常出現的問題，異常的解釋是 「指定的類不存在 「，這裏主要考慮一下類的名稱和路徑是否正確便可，若是是在JB下作的程序包，通常都是默認加上Package的，因此轉到WTK下後要注意把Package的路徑加上。

 

NO.3　java.lang.ArithmeticException

這個異常的解釋是 「數學運算異常 「，好比程序中出現(1/0)除以零這樣的運算就會出這樣的異常，對這種異常，你們就要好好檢查一下本身程序中涉及到數學運算的地方，公式是否是有不妥了。

 

NO.4　java.lang.ArrayIndexOutOfBoundsException
　　這個異常相信不少朋友也常常遇到過，異常的解釋是 「數組下標越界 「，如今程序中大多都有對數組的操做，所以在調用數組的時候必定要認真檢查，看本身調用的下標是否是超出了數組的範圍，通常來講，顯示（即直接用常數當下標）調用不太容易出這樣的錯，但隱式（即用變量表示下標）調用就常常出錯了，還有一種狀況，是程序中定義的數組的長度是經過某些特定方法決定的，不是事先聲明的，這個時候，最好先查看一下數組的length，以避免出現這個異常

 

NO.5　java.lang.IllegalArgumentException
　　這個異常的解釋是 「方法的參數錯誤 「，不少J2ME的類庫中的方法在一些狀況下都會引起這樣的錯誤，好比音量調節方法中的音量參數若是寫成負數就會出現這個異常，再好比g.setColor(int red,int green,int blue)這個方法中的三個值，若是有超過２５５的也會出現這個異常，所以一旦發現這個異常，咱們要作的，就是趕忙去檢查一下方法調用中的參數傳遞是否是出現了錯誤。

 

 NO.6　java.lang.IllegalAccessException
　　這個異常的解釋是 「沒有訪問權限 「，當應用程序要調用一個類，但當前的方法即沒有對該類的訪問權限便會出現這個異常。對程序中用了Package的狀況下要注意這個異常。

 

NO.7　java.lang.IncompatibleClassChangeError
不兼容的類變化錯誤。當正在執行的方法所依賴的類定義發生了不兼容的改變時，拋出該異常。通常在修改了應用中的某些類的聲明定義而沒有對整個應用從新編譯而直接運行的狀況下，容易引起該錯誤。

 

NO.8　java.lang.InstantiationError
實例化錯誤。當一個應用試圖經過Java的new操做符構造一個抽象類或者接口時拋出該異常。

 

NO.9　java.lang.LinkageError
連接錯誤。該錯誤及其全部子類指示某個類依賴於另一些類，在該類編譯以後，被依賴的類改變了其類定義而沒有從新編譯全部的類，進而引起錯誤的狀況。

 

NO.10　java.lang.StackOverflowError
堆棧溢出錯誤。當一個應用遞歸調用的層次太深而致使堆棧溢出時拋出該錯誤。

 

異常處理的方法，

對於能處理的異常採用捕獲異常

對於不能處理的異常採用拋出異常交給其餘類處理；

 

17）數據庫來的異常處理

PL-SQL 之拋出異常：

DECLARE

BEGIN

EXCEPTION

WHEN OTHERS THEN

RAISE;

END

PL/SQL處理異常不一樣於其餘程序語言的錯誤管理方法，PL/SQL的異常處理機制與ADA很類似，有一個處理錯誤的全包含方法。當發生錯誤時，程序無條件轉到異常處理部分，這就要求代碼要很是乾淨並把錯誤處理部分和程序的其它部分分開。oracle容許聲明其餘異常條件類型以擴展錯誤/異常處理。這種擴展使PL/SQL的異常處理很是靈活。

    當一個運行時錯誤發生時，稱爲一個異常被拋出。PL/SQL程序編譯時的錯誤不是能被處理得異常，只有在運行時的異常能被處理。在PL/SQL程序設計中異常的拋出和處理是很是重要的內容。

    拋出異常

    由三種方式拋出異常

    . 經過PL/SQL運行時引擎

    . 使用RAISE語句

. 調用RAISE_APPLICATION_ERROR存儲過程

18）文件操做和訪問

文件的增刪改查，文件夾的增刪改查，文件夾的遍歷（遞歸）；

文件壓縮，經過調用7Z命令。

文件的分割合併。

多線程分割

public class MultiThreading extends Thread {

private File file;// 要分割的文件；

private int size;// 每一塊的大小

private int pos;

private File file01;

 

public MultiThreading(File file, int size, int pos, File file01) {

super();

this.file = file;

this.size = size;

this.pos = pos;

this.file01 = file01;

}

 

@Override

public void run() {

try {

segmentation();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

 

public void segmentation() throws IOException {

RandomAccessFile randomAccessFile = new RandomAccessFile(file, "r");

randomAccessFile.seek((int) pos);

byte[] arr = new byte[size];

int read = randomAccessFile.read(arr);

FileOutputStream fileOutputStream = new FileOutputStream(file01);

fileOutputStream.write(arr, 0, read);

randomAccessFile.close();

fileOutputStream.close();

}

 

public static void main(String[] args) throws IOException {

int danwei =  1024*1024*10 ;

File file2 = new File("F:\\系統必備軟件.zip");

long length = file2.length();

int unit = (int) ((length + danwei - 1) / danwei);

for (int i = 0; i < unit; i++) {

File createTempFile = new File("F:\\123\\" + (100000 + i + 1) + ".tmp");

MultiThreading multiThreading = new MultiThreading(file2, danwei, i * danwei, createTempFile);

multiThreading.start();

String name2 = multiThreading.getName();

System.out.println("線程"+name2+"開始運行");

}

 

}

}

文件的合併

public static void he(String path) throws IOException {

File file = new File(path);

int len = -1;

byte[] arr = new byte[1024];

File[] listFiles = file.listFiles();

FileOutputStream fileOutputStream = new FileOutputStream(new File("456.exe"), true);

FileInputStream fileInputStream =null;

for (int i = 0; i < listFiles.length;i++) {

fileInputStream = new FileInputStream(listFiles[i]);

while ((len = fileInputStream.read(arr)) != -1) {

fileOutputStream.write(arr, 0, len);

}

}

fileInputStream.close();

fileOutputStream.close();

}

19）多線程

建立線程的兩種形式？

實現Runnable

繼承Thread

將主要代碼寫在Run方法中

多線程的生命週期

 

同步塊和同步方法

Java語言的關鍵字，當它用來修飾一個方法或者一個代碼塊的時候，可以保證在同一時刻最多隻有一個線程執行該段代碼。

     1、當兩個併發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內只能有一個線程獲得執行。另外一個線程必須等待當前線程執行完這個代碼塊之後才能執行該代碼塊。

     2、然而，當一個線程訪問object的一個synchronized(this)同步代碼塊時，另外一個線程仍然能夠訪問該object中的非synchronized(this)同步代碼塊。

     3、尤爲關鍵的是，當一個線程訪問object的一個synchronized(this)同步代碼塊時，其餘線程對object中全部其它synchronized(this)同步代碼塊的訪問將被阻塞。

     4、第三個例子一樣適用其它同步代碼塊。也就是說，當一個線程訪問object的一個synchronized(this)同步代碼塊時，它就得到了這個object的對象鎖。結果，其它線程對該object對象全部同步代碼部分的訪問都被暫時阻塞。

     5、以上規則對其它對象鎖一樣適用.

舉例說明：  
     1、當兩個併發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內只能有一個線程獲得執行。另外一個線程必須等待當前線程執行完這個代碼塊之後才能執行該代碼塊。

 

死鎖

一個類可能發生死鎖，並不意味着每次都會發生死鎖，這只是表示有可能。當死鎖出現時，每每是在最糟糕的狀況----高負載的狀況下。

一個經典的多線程問題。

當一個線程永遠地持有一個鎖，而且其餘線程都嘗試去得到這個鎖時，那麼它們將永遠被阻塞，這個咱們都知道。若是線程A持有鎖L而且想得到鎖M，線程B持有鎖M而且想得到鎖L，那麼這兩個線程將永遠等待下去，這種狀況就是最簡單的死鎖形式。

 

多線程通訊

那如何讓 兩個線程按照指定方式有序交叉運行呢？

仍是上面那個例子，我如今但願 A 在打印完 1 後，再讓 B 打印 1, 2, 3，最後再回到 A 繼續打印 2, 3。這種需求下，顯然 Thread.join() 已經不能知足了。咱們須要更細粒度的鎖來控制執行順序。

這裏，咱們能夠利用 object.wait() 和 object.notify() 兩個方法來實現。代碼以下：

private static void demo3() {

    Object lock = new Object();

    Thread A = new Thread(new Runnable() {

        @Override

        public void run() {

            synchronized (lock) {

                System.out.println("A 1");

                try {

                    lock.wait();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println("A 2");

                System.out.println("A 3");

            }

        }

    });

    Thread B = new Thread(new Runnable() {

        @Override

        public void run() {

            synchronized (lock) {

                System.out.println("B 1");

                System.out.println("B 2");

                System.out.println("B 3");

                lock.notify();

            }

        }

    });

    A.start();

    B.start();

}

打印結果以下：

A 1

B1

B2

B3

A2

A3

正是咱們要的結果。

那麼，這個過程發生了什麼呢？

首先建立一個 A 和 B 共享的對象鎖 lock = new Object();

當 A 獲得鎖後，先打印 1，而後調用 lock.wait() 方法，交出鎖的控制權，進入 wait 狀態；

對 B 而言，因爲 A 最開始獲得了鎖，致使 B 沒法執行；直到 A 調用 lock.wait() 釋放控制權後， B 才獲得了鎖；

B 在獲得鎖後打印 1， 2， 3；而後調用 lock.notify() 方法，喚醒正在 wait 的 A;

A 被喚醒後，繼續打印剩下的 2，3。

多個線程 操做了共同資源的時候就須要用到同步塊，或者同步方法，

 

線程池（各類類型的線程池）

線程池是一種多線程處理形式，處理過程當中將任務添加到隊列，而後在建立線程後自動啓動這些任務。線程池線程都是後臺線程。每一個線程都使用默認的堆棧大小，以默認的優先級運行，並處於多線程單元中。若是某個線程在託管代碼中空閒（如正在等待某個事件）,則線程池將插入另外一個輔助線程來使全部處理器保持繁忙。若是全部線程池線程都始終保持繁忙，但隊列中包含掛起的工做，則線程池將在一段時間後建立另外一個輔助線程但線程的數目永遠不會超過最大值。超過最大值的線程能夠排隊，但他們要等到其餘線程完成後才啓動。

20）集合

項目開發中用過哪些集合？

List簡單。 Set去重；

集合與前面學過數組的關係

數組的大小不可改變。集合大小能夠改變。

set  list  map 三者之間的區別？

set：不能記住添加元素時的順序，該集合裏的元素不能重複。

     HashSet：

     TreeSet：會對容器裏的元素進行排序。

list:  能夠記住添加元素時的順序，              能夠重複。

     ArrayList: 查詢

     LinkedList：更新  

Map: 添加的是key-value

     HashMap

     TreeMap

21）如何實現集合裏的類的線程安全？

 

22）JDBC

普通處理對象與預處理對象區別

PreparedStatement是預編譯的,對於批量處理能夠大大提升效率.也叫JDBC存儲過程

使用 Statement 對象。在對數據庫只執行一次性存取的時侯，用 Statement 對象進行處理。PreparedStatement對象的開銷比Statement大，對於一次性操做並不會帶來額外的好處。
Statement每次執行sql語句，相關數據庫都要執行sql語句的編譯，preparedstatement是預編譯得,preparedstatement支持批處理

在Web環境中，有惡意的用戶會利用那些設計不完善的、不能正確處理字符串的應用程序。特別是在公共Web站點上,在沒有首先經過PreparedStatement對象處理的狀況下，全部的用戶輸入都不該該傳遞給SQL語句。此外，在用戶有機會修改SQL語句的地方，如HTML的隱藏區域或一個查詢字符串上，SQL語句都不該該被顯示出來。
在執行SQL命令時，咱們有二種選擇：可使用PreparedStatement對象，也可使用Statement對象。不管多少次地使用同一個SQL命令，PreparedStatement都只對它解析和編譯一次。當使用Statement對象時，每次執行一個SQL命令時，都會對它進行解析和編譯。
prepareStatement會先初始化SQL，先把這個SQL提交到數據庫中進行預處理，屢次使用可提升效率。
createStatement不會初始化，沒有預處理，沒次都是從0開始執行SQL

 

調用存儲過程和函數

存儲過程

  String sql = "{call getStudentCount(?)}";

CallableStatement proc = conn.prepareCall(sql);

  proc.registerOutParameter(1, java.sql.Types.INTEGER);

  proc.execute();

  studentCount = proc.getInt(1);

函數

String callFunctionSql = "{?= call getTreeChildList(?)}";

CallableStatement   callableStatement  =  conn.prepareCall(callFunctionSql); callableStatement.registerOutParameter(1,Types.LONGVARCHAR); callableStatement.setString(2, inputStr);

 

sql注入

所謂SQL注入，就是經過把SQL命令插入到Web表單提交或輸入域名或頁面請求的查詢字符串，最終達到欺騙服務器執行惡意的SQL命令。具體來講，它是利用現有應用程序，將（惡意的）SQL命令注入到後臺數據庫引擎執行的能力，它能夠經過在Web表單中輸入（惡意）SQL語句獲得一個存在安全漏洞的網站上的數據庫，而不是按照設計者意圖去執行SQL語句。

 

 

 

數據來源-各類網站整理。