技術標籤：java

java基礎

java簡介

Java 語法規範

基本語法

• 物件：物件是類的一個例項，有狀態和行為。類：類是一個模板，它描述一類物件的行為和狀態。方法：方法就是行為，一個類可以有很多方法。例項變數：每個物件都有獨特的例項變數，物件的狀態由這些例項變數的值決定。

Java 識別符號

• 子主題 1

java修飾符

• 訪問控制修飾符 : default, public , protected, private非訪問控制修飾符 : final, abstract, static, synchronized

Java 變數

• 區域性變數
• 類變數（靜態變數）
• 成員變數（非靜態變數）

Java 關鍵字

java繼承

• 一個類可以由其他類派生。如果你要建立一個類，而且已經存在一個類具有你所需要的屬性或方法，那麼你可以將新建立的類繼承該類。利用繼承的方法，可以重用已存在類的方法和屬性，而不用重寫這些程式碼。被繼承的類稱為超類（super class），派生類稱為子類（subclass）。

Java 基本資料型別

內建資料型別

• Java 各個型別的預設值

引用資料型別

• 引用型別的變數非常類似於C/C++的指標。引用型別指向一個物件，指向物件的變數是引用變數。

Java 常量

• Java 中使用 final 關鍵字來修飾常量

• 轉義字元序列

自動型別轉換

• a ,查 ASCII 碼錶可知對應的 int 型別值為 97

強制型別轉換

• int強制型別轉換為byte後的值等於123

Java 變數的型別

Java語言支援的變數型別有：類變數：獨立於方法之外的變數，用 static 修飾。例項變數：獨立於方法之外的變數，不過沒有 static 修飾。區域性變數：類的方法中的變數。

• Java 區域性變數

• 區域性變數宣告在方法、構造方法或者語句塊中；區域性變數在方法、構造方法、或者語句塊被執行的時候建立，當它們執行完成後，變數將會被銷燬；訪問修飾符不能用於區域性變數；區域性變數只在宣告它的方法、構造方法或者語句塊中可見；區域性變數是在棧上分配的。區域性變數沒有預設值，所以區域性變數被聲明後，必須經過初始化，才可以使用。

• 例項變數

• 例項變數宣告在一個類中，但在方法、構造方法和語句塊之外；當一個物件被例項化之後，每個例項變數的值就跟著確定；例項變數在物件建立的時候建立，在物件被銷燬的時候銷燬；例項變數的值應該至少被一個方法、構造方法或者語句塊引用，使得外部能夠通過這些方式獲取例項變數資訊；例項變數可以宣告在使用前或者使用後；訪問修飾符可以修飾例項變數；例項變數對於類中的方法、構造方法或者語句塊是可見的。一般情況下應該把例項變數設為私有。通過使用訪問修飾符可以使例項變數對子類可見；例項變數具有預設值。數值型變數的預設值是0，布林型變數的預設值是false，引用型別變數的預設值是null。變數的值可以在宣告時指定，也可以在構造方法中指定；例項變數可以直接通過變數名訪問。但在靜態方法以及其他類中，就應該使用完全限定名：ObejectReference.VariableName。

• 類變數（靜態變數）

• 類變數也稱為靜態變數，在類中以 static 關鍵字宣告，但必須在方法之外。無論一個類建立了多少個物件，類只擁有類變數的一份拷貝。靜態變數除了被宣告為常量外很少使用。常量是指宣告為public/private，final和static型別的變數。常量初始化後不可改變。靜態變數儲存在靜態儲存區。經常被宣告為常量，很少單獨使用static宣告變數。靜態變數在第一次被訪問時建立，在程式結束時銷燬。與例項變數具有相似的可見性。但為了對類的使用者可見，大多數靜態變數宣告為public型別。預設值和例項變數相似。數值型變數預設值是0，布林型預設值是false，引用型別預設值是null。變數的值可以在宣告的時候指定，也可以在構造方法中指定。此外，靜態變數還可以在靜態語句塊中初始化。靜態變數可以通過：ClassName.VariableName的方式訪問。類變數被宣告為public static final型別時，類變數名稱一般建議使用大寫字母。如果靜態變數不是public和final型別，其命名方式與例項變數以及區域性變數的命名方式一致。

Java 修飾符

訪問控制修飾符

• default (即預設，什麼也不寫）: 在同一包內可見，不使用任何修飾符。使用物件：類、介面、變數、方法。
• private : 在同一類內可見。使用物件：變數、方法。 注意：不能修飾類（外部類）
• public : 對所有類可見。使用物件：類、介面、變數、方法
• protected : 對同一包內的類和所有子類可見。使用物件：變數、方法。 注意：不能修飾類（外部類）。
• 訪問許可權

非訪問修飾符

• static 修飾符，用來修飾類方法和類變數。

• 靜態變數：static 關鍵字用來宣告獨立於物件的靜態變數，無論一個類例項化多少物件，它的靜態變數只有一份拷貝。 靜態變數也被稱為類變數。區域性變數不能被宣告為 static 變數

• 靜態方法：static 關鍵字用來宣告獨立於物件的靜態方法。靜態方法不能使用類的非靜態變數。靜態方法從引數列表得到資料，然後計算這些資料。

• final 修飾符，用來修飾類、方法和變數，final 修飾的類不能夠被繼承，修飾的方法不能被繼承類重新定義，修飾的變數為常量，是不可修改的。

• final 方法的主要目的是防止該方法的內容被修改

• final 類不能被繼承，沒有類能夠繼承 final 類的任何特性。

• abstract 修飾符，用來建立抽象類和抽象方法。

• 一個類不能同時被 abstract 和 final 修飾。如果一個類包含抽象方法，那麼該類一定要宣告為抽象類，否則將出現編譯錯誤。

• 抽象方法是一種沒有任何實現的方法，該方法的的具體實現由子類提供。抽象方法不能被宣告成 final 和 static。任何繼承抽象類的子類必須實現父類的所有抽象方法，除非該子類也是抽象類。如果一個類包含若干個抽象方法，那麼該類必須宣告為抽象類。抽象類可以不包含抽象方法。

• synchronized 和 volatile 修飾符，主要用於執行緒的程式設計。

• transient 修飾符序列化的物件包含被 transient 修飾的例項變數時，java 虛擬機器(JVM)跳過該特定的變數。

• synchronized 關鍵字宣告的方法同一時間只能被一個執行緒訪問。synchronized 修飾符可以應用於四個訪問修飾符。

• volatile 修飾的成員變數在每次被執行緒訪問時，都強制從共享記憶體中重新讀取該成員變數的值。而且，當成員變數發生變化時，會強制執行緒將變化值回寫到共享記憶體。這樣在任何時刻，兩個不同的執行緒總是看到某個成員變數的同一個值。一個 volatile 物件引用可能是 null。

Java 運算子

算術運算子

關係運算符

位運算子

邏輯運算子

賦值運算子

運算子優先順序

Java 條件語句

if else
Java switch case 語句
switch(expression){ case value : //語句 break; //可選 case value : //語句 break; //可選 //你可以有任意數量的case語句 default : //可選 //語句}

• 一定會先進行匹配，匹配成功返回當前 case 的值，再根據是否有 break，判斷是否繼續輸出，或是跳出判斷。
• 如果 case 語句塊中沒有 break 語句時，匹配成功後，從當前 case 開始，後續所有 case 的值都會輸出。

Java 迴圈結構

while 迴圈

• while( 布林表示式 ) { //迴圈內容}

do…while 迴圈

• do { //程式碼語句} while(布林表示式);

for 迴圈

• for(初始化; 布林表示式; 更新) { //程式碼語句}
• for(宣告語句 : 表示式) { //程式碼句子}

• 宣告語句：宣告新的區域性變數，該變數的型別必須和陣列元素的型別匹配。其作用域限定在迴圈語句塊，其值與此時陣列元素的值相等。表示式：表示式是要訪問的陣列名，或者是返回值為陣列的方法。

• 增強的for迴圈是沒有下標的，一般用於不需要下標時的操作，如查詢

break 關鍵字

• break 跳出最裡層的迴圈，並且繼續執行該迴圈下面的語句。

continue 關鍵字

• 在 for 迴圈中，continue 語句使程式立即跳轉到更新語句。在 while 或者 do…while 迴圈中，程式立即跳轉到布林表示式的判斷語句。

Java 陣列

宣告陣列變數

• dataType[] arrayRefVar

建立陣列

• arrayRefVar = new dataType[arraySize];

處理陣列

• 通常使用基本迴圈(arr.length)
• For-Each 迴圈

• for(type element: array) { System.out.println(element);}

• 陣列作為函式的引數
• 陣列作為函式的返回值

多維陣列

• type[][] typeName = new type[typeLength1][typeLength2];type 可以為基本資料型別和複合資料型別，arraylength1 和 arraylength2 必須為正整數，arraylength1 為行數，arraylength2 為列數。

Arrays 類

• 給陣列賦值：通過 fill 方法。
• 對陣列排序：通過 sort 方法,按升序。
• 比較陣列：通過 equals 方法比較陣列中元素值是否相等。
• 查詢陣列元素：通過 binarySearch 方法能對排序好的陣列進行二分查詢法操作。
• ava.util.Arrays 類能方便地運算元組，它提供的所有方法都是靜態的

Java 方法

修飾符 返回值型別 方法名(引數型別 引數名){ ... 方法體 ... return 返回值;}

通過值傳遞引數

方法的過載

變數作用域

命令列引數的使用

構造方法

• 當一個物件被建立時候，構造方法用來初始化該物件。構造方法和它所在類的名字相同，但構造方法沒有返回值。一旦你定義了自己的構造方法，預設構造方法就會失效.

可變引數

Java Scanner 類

Scanner s = new Scanner(System.in);

• 通過 Scanner 類的 next() 與 nextLine() 方法獲取輸入的字串，在讀取前我們一般需要 使用 hasNext 與 hasNextLine 判斷是否還有輸入的資料：

next() 與 nextLine() 區別

• next():1、一定要讀取到有效字元後才可以結束輸入。2、對輸入有效字元之前遇到的空白，next() 方法會自動將其去掉。3、只有輸入有效字元後才將其後面輸入的空白作為分隔符或者結束符。next() 不能得到帶有空格的字串。nextLine()：1、以Enter為結束符,也就是說 nextLine()方法返回的是輸入回車之前的所有字元。2、可以獲得空白。

java面向物件

多型

多型是同一個行為具有多個不同表現形式或形態的能力，多型就是同一個介面，使用不同的例項而執行不同操作

多型的實現方式

• 方式一：重寫
• 方式二：介面

繼承

繼承就是子類繼承父類的特徵和行為，使得子類物件（例項）具有父類的例項域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。

• class 父類 {}class 子類 extends 父類 {}

• Java 不支援多繼承，但支援多重繼承

extends關鍵字,extends 只能繼承一個類

implements關鍵字,可以同時繼承多個介面

super 與 this 關鍵字

• super關鍵字：我們可以通過super關鍵字來實現對父類成員的訪問，用來引用當前物件的父類。
• this關鍵字：指向自己的引用。

final關鍵字

• final 關鍵字宣告類可以把類定義為不能繼承的，即最終類；或者用於修飾方法，該方法不能被子類重寫

構造器

• 子類是不繼承父類的構造器（構造方法或者建構函式）的，它只是呼叫（隱式或顯式）。如果父類的構造器帶有引數，則必須在子類的構造器中顯式地通過 super 關鍵字呼叫父類的構造器並配以適當的引數列表。

封裝

封裝的優點

• 良好的封裝能夠減少耦合。類內部的結構可以自由修改。可以對成員變數進行更精確的控制。隱藏資訊，實現細節

實現Java封裝的步驟(getter和setter方法)

• 以上例項中public方法是外部類訪問該類成員變數的入口。通常情況下，這些方法被稱為getter和setter方法。因此，任何要訪問類中私有成員變數的類都要通過這些getter和setter方法。
• 修改屬性的可見性來限制對屬性的訪問（一般限制為private）
• 對每個值屬性提供對外的公共方法訪問，也就是建立一對賦取值方法，用於對私有屬性的訪問

抽象

由於抽象類不能例項化物件，所以抽象類必須被繼承，才能被使用，一個類只能繼承一個抽象類，而一個類卻可以實現多個介面。

抽象方法

• 如果一個類包含抽象方法，那麼該類必須是抽象類。
• 任何子類必須重寫父類的抽象方法，或者宣告自身為抽象類。

抽象類

• 抽象類不能被例項化(初學者很容易犯的錯)，如果被例項化，就會報錯，編譯無法通過。只有抽象類的非抽象子類可以建立物件。
• 抽象類中不一定包含抽象方法，但是有抽象方法的類必定是抽象類。
• 抽象類中的抽象方法只是宣告，不包含方法體，就是不給出方法的具體實現也就是方法的具體功能。
• 構造方法，類方法（用 static 修飾的方法）不能宣告為抽象方法。
• 抽象類的子類必須給出抽象類中的抽象方法的具體實現，除非該子類也是抽象類。

類

物件

例項

重寫與過載

重寫

• 重寫是子類對父類的允許訪問的方法的實現過程進行重新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！

• 引數列表必須完全與被重寫方法的相同。

• 返回型別與被重寫方法的返回型別可以不相同，但是必須是父類返回值的派生類（java5 及更早版本返回型別要一樣，java7 及更高版本可以不同）。

• 訪問許可權不能比父類中被重寫的方法的訪問許可權更低。例如：如果父類的一個方法被宣告為 public，那麼在子類中重寫該方法就不能宣告為 protected。

• 父類的成員方法只能被它的子類重寫。

• 宣告為 final 的方法不能被重寫。

• 宣告為 static 的方法不能被重寫，但是能夠被再次宣告。

• 子類和父類在同一個包中，那麼子類可以重寫父類所有方法，除了宣告為 private 和 final 的方法。

• 子類和父類不在同一個包中，那麼子類只能夠重寫父類的宣告為 public 和 protected 的非 final 方法。

• 重寫的方法能夠丟擲任何非強制異常，無論被重寫的方法是否丟擲異常。但是，重寫的方法不能丟擲新的強制性異常，或者比被重寫方法宣告的更廣泛的強制性異常，反之則可以。

• 構造方法不能被重寫。

• 如果不能繼承一個方法，則不能重寫這個方法。

• Super 關鍵字的使用

• class Animal{ public void move(){ System.out.println("動物可以移動"); }}class Dog extends Animal{ public void move(){ super.move(); // 應用super類的方法 System.out.println("狗可以跑和走"); }}public class TestDog{ public static void main(String args[]){ Animal b = new Dog(); // Dog 物件 b.move(); //執行 Dog類的方法 }}

過載

• 過載(overloading) 是在一個類裡面，方法名字相同，而引數不同。返回型別可以相同也可以不同。

• 被過載的方法必須改變引數列表(引數個數或型別不一樣)；

• 被過載的方法可以改變返回型別；

• 被過載的方法可以改變訪問修飾符；

• 被過載的方法可以宣告新的或更廣的檢查異常；

• 方法能夠在同一個類中或者在一個子類中被過載。

• 無法以返回值型別作為過載函式的區分標準。

區別

• 方法過載是一個類中定義了多個方法名相同,而他們的引數的數量不同或數量相同而型別和次序不同,則稱為方法的過載(Overloading)。
• 方法重寫是在子類存在方法與父類的方法的名字相同,而且引數的個數與型別一樣,返回值也一樣的方法,就稱為重寫(Overriding)。
• 方法過載是一個類的多型性表現,而方法重寫是子類與父類的一種多型性表現。

Java 介面

介面通常以interface來宣告，介面無法被例項化，但是可以被實現。

介面與類相似點

• 一個介面可以有多個方法。
• 介面檔案儲存在 .java 結尾的檔案中，檔名使用介面名。
• 介面的位元組碼檔案儲存在 .class 結尾的檔案中。
• 介面相應的位元組碼檔案必須在與包名稱相匹配的目錄結構中。

介面與類的區別

• 介面不能用於例項化物件。
• 介面沒有構造方法。
• 介面中所有的方法必須是抽象方法。
• 介面不能包含成員變數，除了 static 和 final 變數。
• 介面不是被類繼承了，而是要被類實現。
• 介面支援多繼承。

介面特性

• 介面中每一個方法也是隱式抽象的,介面中的方法會被隱式的指定為 public abstract（只能是 public abstract，其他修飾符都會報錯）。
• 介面中可以含有變數，但是介面中的變數會被隱式的指定為 public static final 變數（並且只能是 public，用 private 修飾會報編譯錯誤）。
• 介面中的方法是不能在介面中實現的，只能由實現介面的類來實現介面中的方法。

抽象類和介面的區別

• 抽象類中的方法可以有方法體，就是能實現方法的具體功能，但是介面中的方法不行。
• 抽象類中的成員變數可以是各種型別的，而介面中的成員變數只能是 public static final 型別的。
• 介面中不能含有靜態程式碼塊以及靜態方法(用 static 修飾的方法)，而抽象類是可以有靜態程式碼塊和靜態方法。
• 一個類只能繼承一個抽象類，而一個類卻可以實現多個介面。

Java 包(package)

package pkg1[．pkg2[．pkg3…]];

• java.lang-打包基礎的類
• java.io-包含輸入輸出功能的函式

import package1[.package2…].(classname|*);

作用

• 1、把功能相似或相關的類或介面組織在同一個包中，方便類的查詢和使用。
• 2、如同資料夾一樣，包也採用了樹形目錄的儲存方式。同一個包中的類名字是不同的，不同的包中的類的名字是可以相同的，當同時呼叫兩個不同包中相同類名的類時，應該加上包名加以區別。因此，包可以避免名字衝突。
• 3、包也限定了訪問許可權，擁有包訪問許可權的類才能訪問某個包中的類。

java核心API

Java Number & Math 類

Java Character 類

Character 類在物件中包裝一個基本型別 char 的值

轉義序列

Character 方法

Java String 類

public class StringDemo{ public static void main(String args[]){ char[] helloArray = { 'n', 'o', 'w', 'c', 'o', 'd', 'e', 'r'}; String helloString = new String(helloArray); System.out.println( helloString ); }}

String 類是不可改變的，所以你一旦建立了 String 物件，那它的值就無法改變了

如果需要對字串做很多修改，那麼應該選擇使用 StringBuffer & StringBuilder 類。

字串長度：length

連線字串：string1.concat(string2);

建立格式化字串

方法

Java StringBuffer 類

主要方法

• 1 public StringBuffer append(String s) 將指定的字串追加到此字元序列。
• 2public StringBuffer reverse() 將此字元序列用其反轉形式取代。
• 3public delete(int start, int end) 移除此序列的子字串中的字元。
• 4public insert(int offset, int i) 將 int 引數的字串表示形式插入此序列中。
• 5replace(int start, int end, String str) 使用給定 String 中的字元替換此序列的子字串中的字元。

Java 正則表示式

Matcher 類的方法

Java 流(Stream)、檔案(File)和IO

Java.io 包幾乎包含了所有操作輸入、輸出需要的類。所有這些流類代表了輸入源和輸出目標。

讀取控制檯輸入，把 System.in 包裝在一個 BufferedReader 物件中來建立一個字元流。

• BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

從控制檯讀取多字元輸入

檔案和I/O

• 建立目錄

• mkdir( )方法建立一個資料夾，成功則返回true，失敗則返回false。失敗表明File物件指定的路徑已經存在，或者由於整個路徑還不存在，該資料夾不能被建立。

• mkdirs()方法建立一個資料夾和它的所有父資料夾。

• 讀取目錄

• 如果建立一個 File 物件並且它是一個目錄，那麼呼叫 isDirectory() 方法會返回 true。可以通過呼叫該物件上的 list() 方法，來提取它包含的檔案和資料夾的列表。

• 刪除目錄或檔案

• 刪除檔案可以使用 java.io.File.delete() 方法。以下程式碼會刪除目錄 /tmp/java/，需要注意的是當刪除某一目錄時，必須保證該目錄下沒有其他檔案才能正確刪除，否則將刪除失敗。

Java 異常處理

原因

• 使用者輸入了非法資料。
• 要開啟的檔案不存在。
• 網路通訊時連線中斷，或者JVM記憶體溢位。

三種類型

• 檢查性異常：最具代表的檢查性異常是使用者錯誤或問題引起的異常，這是程式設計師無法預見的。例如要開啟一個不存在檔案時，一個異常就發生了，這些異常在編譯時不能被簡單地忽略。
• 執行時異常： 執行時異常是可能被程式設計師避免的異常。與檢查性異常相反，執行時異常可以在編譯時被忽略。
• 錯誤： 錯誤不是異常，而是脫離程式設計師控制的問題。錯誤在程式碼中通常被忽略。例如，當棧溢位時，一個錯誤就發生了，它們在編譯也檢查不到的。

捕獲異常

• try/catch程式碼塊中的程式碼稱為保護程式碼

• try { // 程式程式碼}catch(ExceptionName e1) { //Catch 塊}

• 多重捕獲塊

• 一個 try 程式碼塊後面跟隨多個 catch 程式碼塊的情況就叫多重捕獲

• try{ // 程式程式碼}catch(異常型別1 異常的變數名1){ // 程式程式碼}catch(異常型別2 異常的變數名2){ // 程式程式碼}catch(異常型別2 異常的變數名2){ // 程式程式碼}

• throws/throw 關鍵字

• 可以使用 throw 關鍵字丟擲一個異常，無論它是新例項化的還是剛捕獲到的。

• finally關鍵字

通用異常

• JVM(Java虛擬機器) 異常：由 JVM 丟擲的異常或錯誤。例如：NullPointerException 類，ArrayIndexOutOfBoundsException 類，ClassCastException 類。
• 程式級異常：由程式或者API程式丟擲的異常。例如 IllegalArgumentException 類，IllegalStateException 類。

Java 資料結構

列舉（Enumeration）

• 1boolean hasMoreElements( ) 測試此列舉是否包含更多的元素。
• 2Object nextElement( ) 如果此列舉物件至少還有一個可提供的元素，則返回此列舉的下一個元素。

位集合（BitSet）

向量（Vector）

• Vector 類實現了一個動態陣列。和 ArrayList 很相似，但是兩者是不同的：Vector 是同步訪問的。Vector 包含了許多傳統的方法，這些方法不屬於集合框架。

•

棧（Stack）

• 棧是Vector的一個子類，它實現了一個標準的後進先出的棧。堆疊只定義了預設建構函式，用來建立一個空棧。 堆疊除了包括由Vector定義的所有方法，也定義了自己的一些方法。

•

字典（Dictionary）

• Dictionary 類是一個抽象類，用來儲存鍵/值對，作用和Map類相似。給出鍵和值，你就可以將值儲存在Dictionary物件中。一旦該值被儲存，就可以通過它的鍵來獲取它。所以和Map一樣， Dictionary 也可以作為一個鍵/值對列表。

•

雜湊表（Hashtable）

屬性（Properties）

• Properties 繼承於 Hashtable.表示一個持久的屬性集.屬性列表中每個鍵及其對應值都是一個字串。

Java 集合框架

目標

• 該框架必須是高效能的。基本集合（動態陣列，連結串列，樹，雜湊表）的實現也必須是高效的。該框架允許不同型別的集合，以類似的方式工作，具有高度的互操作性。對一個集合的擴充套件和適應必須是簡單的。

類別

• 一種是集合（Collection）：儲存一個元素集合

• List、Set 和 Queue

• 另一種是圖（Map）：儲存鍵/值對對映。

集合框架體系

Set和List的區別

• Set 介面例項儲存的是無序的，不重複的資料。List 介面例項儲存的是有序的，可以重複的元素。
• Set檢索效率低下，刪除和插入效率高，插入和刪除不會引起元素位置改變 (實現類有HashSet,TreeSet)。
• List和陣列類似，可以動態增長，根據實際儲存的資料的長度自動增長List的長度。查詢元素效率高，插入刪除效率低，因為會引起其他元素位置改變 (實現類有ArrayList,LinkedList,Vector) 。

集合實現類（集合類）

如何使用迭代器

• 迭代器，使你能夠通過迴圈來得到或刪除集合的元素。ListIterator 繼承了Iterator，以允許雙向遍歷列表和修改元素。

• import java.util.*;public class Test{ public static void main(String[] args) { List<String> list=new ArrayList<String>(); list.add("Hello"); list.add("World"); list.add("HAHAHAHA"); //第一種遍歷方法使用 For-Each 遍歷 List for (String str : list) { System.out.println(str); } //第二種遍歷，把連結串列變為陣列相關的內容進行遍歷 String[] strArray=new String[list.size()]; list.toArray(strArray); for(int i=0;i<strArray.length;i++) { System.out.println(strArray[i]); } //第三種遍歷 使用迭代器進行相關遍歷 Iterator<String> ite=list.iterator(); while(ite.hasNext()) { System.out.println(ite.next()); } }}

• import java.util.*;public class Test{ public static void main(String[] args) { Map<String, String> map = new HashMap<String, String>(); map.put("1", "value1"); map.put("2", "value2"); map.put("3", "value3"); //第一種：普遍使用，二次取值 System.out.println("通過Map.keySet遍歷key和value："); for (String key : map.keySet()) { System.out.println("key= "+ key + " and value= " + map.get(key)); } //第二種 System.out.println("通過Map.entrySet使用iterator遍歷key和value："); Iterator<Map.Entry<String, String>> it = map.entrySet().iterator(); while (it.hasNext()) { Map.Entry<String, String> entry = it.next(); System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue()); } //第三種：推薦，尤其是容量大時 System.out.println("通過Map.entrySet遍歷key和value"); for (Map.Entry<String, String> entry : map.entrySet()) { System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue()); } //第四種 System.out.println("通過Map.values()遍歷所有的value，但不能遍歷key"); for (String v : map.values()) { System.out.println("value= " + v); } }}

Java 多執行緒程式設計

基本概念

• 執行緒同步
• 執行緒間通訊
• 執行緒死鎖
• 執行緒控制：掛起、停止和恢復

建立執行緒的三種方式的對比

• 採用實現 Runnable、Callable 介面的方式建立多執行緒時，執行緒類只是實現了 Runnable 介面或 Callable 介面，還可以繼承其他類。
• 使用繼承 Thread 類的方式建立多執行緒時，編寫簡單，如果需要訪問當前執行緒，則無需使用 Thread.currentThread() 方法，直接使用 this 即可獲得當前執行緒。

建立一個執行緒

• 通過實現 Runnable 介面；
• 通過繼承 Thread 類本身；
• 通過 Callable 和 Future 建立執行緒。

Java 網路程式設計

兩種常見的網路協議

• TCP：TCP 是傳輸控制協議的縮寫，它保障了兩個應用程式之間的可靠通訊。通常用於網際網路協議，被稱 TCP / IP。
• UDP：UDP 是使用者資料報協議的縮寫，一個無連線的協議。提供了應用程式之間要傳送的資料的資料包。

Socket 程式設計

URL 處理

• URL 解析

• 協議為(protocol)：http

• 主機為(host:port)：www.nowcoder.com

• 埠號為(port): 80 ，以上URL例項並未指定埠，因為 HTTP 協議預設的埠號為 80。

• 檔案路徑為(path)：/index.html

• 請求引數(query)：language=cn

• 定位位置(fragment)：j2se，定位到網頁中 id 屬性為 j2se 的 HTML 元素位置 。

https://www.nowcoder.com/tutorial/10001/5fc0c07cd9d44e66b3baafd76f1f5b9f