本部分內容主要有集合框架及泛型，實用類，輸入和輸出處理，註解與多執行緒，網路程式設計與XML技術。初次學習這部分會感覺很難，主要是概念難於理解，最好是多看看例子，多練習。下面是個人的總結
一、集合框架及泛型

1、集合框架

是一套效能優良、使用方便的介面和類（位於java.util包中）解決陣列在儲存上不能很好適應元素數量動態變化，查詢效率低的缺陷

集合介面： Map、Collection(子介面List、Set) 、 Iterator

介面實現類：HashMap  TreeMap 、ArrayList  LinkedList、 HashSet  TreeSet  實現map、list、set介面

集合工具類：Arrays 、Collections  提供對集合元素進行操作的演算法

2、介面的區別

Collection 介面儲存一組可重複，無序的物件（包括List  Set介面）

通用方法：clear() 清除元素    isEmpty()判斷集合是否為空

iterator() 獲得集合的迭代器  toArray()集合轉換為陣列

List 介面儲存一組可重複，有序的物件

Set 介面儲存一組唯一，無序的物件

Map介面儲存一組鍵值物件，鍵是唯一的，Map和Set很像

4、介面實現類

• ArrayList：在記憶體中分配連續的空間。根據下標遍歷元素和隨機訪問元素的效率比較高，而增加和刪除由於位置移動操作很慢

常用方法： add(Objiect o)在列表末尾順序新增元素

            get(int index) 返回指定索引位置處的元素

            size() 返回列表中的元素個數

            contains(Objiect o) 判斷列表中是否存在指定元素

            remove(Objiect o) 刪除列表中的元素

• LinkedList：採用連結串列儲存方式。所有順序查詢的時候很慢，而插入、刪除元素時無需移動位置，效率比較高

常用方法：addFirst(Objiect 0)在列表首部新增元素

           addLast(Objiect 0)在列表尾部新增元素

           getFirst()獲得當前集合的第一個元素

           getLast()獲得當前集合的最後一個元素

           removeFirst() 刪除並返回列表中的第一個元素

           removeFirst()刪除並返回列表中的最後一個元素

• TreeSet|TreeMap比較：底層是二叉樹結構；

TreeMap、TreeSet都儲存了物件的排列次序；

TreeSet只儲存一個物件，而TreeMap儲存兩個物件Key和Value；

儲存速度比Hash集合慢。

• HashSet|HashMap比較：底層資料結構為雜湊表；

HashMap儲存鍵值對，鍵唯一，而HashSet僅僅儲存物件，物件唯一；

HashMap使用唯一的鍵來獲取物件，速度相對較快。

• HashSet集合方法：

add(Objiect o)  新增物件

size()    返回元素個數

contains(Objiect o) 判斷是否存在

remove(Objiect o) 移除有關物件

• HashMap集合方法：

        put（key,value）新增鍵值對

        get(key)         獲取與key有關的值

        remove(key) 移除與key有關的對映，並返回舊值

        containsKey( ) containsValue( )判斷是否存在key value

                size()返回元素個數

 keySet()獲取所有key的集合

 values()獲取所有values的集合

5、集合遍歷

三種方法：普通for迴圈  增強for迴圈  Iterator迭代器遍歷

1.for (Object object : list) { System.out.println(object); }

2.for (int i = 0 ;i<list.size();i++) { int j= (Integer) list.get(i);  System.out.println(j); }

3.Iterator iterator = list.iterator();while(iterator.hasNext()){

int i = (Integer) iterator.next();  System.out.println(i); }

Iterator方法：

HasNext()判斷是否存在下一個可訪問的元素，如果可以，返回true

Next() 返回要訪問的下一個元素

6、Collections工具類

作用：實現對元素的排序、查詢和替換操作

如果要比較一個類的物件之間的大小，必須要實現Comparable介面。

Comparable介面：對實現它的每個類的物件進行自然排序。

comparableTo(Object obj)方法：用於比較此物件與指定物件的順序

返回值：0等於、1大於、-1小於指定物件obj

方法：

fill( ) 替換集合中所有元素為相同元素的方法

sort( ) 對集合進行排序的方法

binarySearch( ) 對集合進行查詢的方法

max( )\min( ) 查詢最大值、最小值

7、泛型集合

• 泛型即引數化型別，通過指定集合中的元素型別來實現約束

作用：將物件的型別作為引數，指定到其他類或者方法上，從而保證型別轉換的安全性和穩定性

舉例：List<Integer> list=new ArrayList<Integer>( );

ArrayList<Student> students = new ArrayList<Student>();

•   典型的泛型集合：ArrayList<E>、HashMap<K,V>

泛型類： public class User<T>{}

泛型介面：public interface Pair<T>{}

泛型方法： public <T> void getMiddle(T[] b) {}  注意<T>的位置

在泛型中，基本型別是不可以做泛型引數，只能使用包裝類、引用資料型別。
二、實用類

1、基本概念

Java API：Java應用程式的程式設計介面、Java幫助文件

實用類：   由Java API提供的常用類

學習這部分一定要多看 Java API 。Java幫助文件提供的常用包如下：

lang包：包含基礎類和介面  如 Comparable介面 、包裝類、  String、Math類

Util包：包含系統輔助類 如 Collection、Map介面、 Date、Arrays類

Io包：   與輸入輸出有關類 如 Serializable介面、File、Reader、Writer類

Net包：與網路有關類  如CookieStore介面 、Socket、URL、ServerSocket類

Sql包： 與資料庫有關類  如 Statement介面、DriverManager、DriverPropertyInfo類

2、列舉

指由一組固定的常量組成的型別。使用enum關鍵字定義

舉例：定義：public enum Genders{男,女} 呼叫：Genders.男

作用：型別安全、易於輸入、程式碼清新

3、包裝類

概念：把基本資料型別包裝為物件，方便物件的操作，體現了java面向物件的特點。 ag：int→Integer char→Character  byte→Byte

包裝類作用：

• 方便在各種型別之間的轉化  如：int型別和String型別互相轉換
• 提供了基本資料型別的相關屬性與方法 如：最小值、toString() 、valueOf()、equals()方法

常用方法：

toString()：將基本資料型別轉換為字串型別

valueOf()：靜態的過載方法 將基本資料型別、字串轉換為包裝類

parseInt()、parseBoolean()：把字串轉換為相應基本資料型別

4、型別轉換

• 基本型別轉包裝類：Integer i=5;或 Integer i=new Integer(5);或Integer i=new Integer(“5”);或Integer i=Integer.valueOf(“5”);

注意：除Character包裝類外，都可以將字串作為引數來構造例項

• 包裝類轉基本型別：int intId=id.intvalue();或int intId=id；
• 自動轉換： Integer i=5;//裝箱 基本→包裝     int j=i;//拆箱 包裝→基本

jdk 1.5以後，基本型別和包裝類的轉換，編譯器會自動完成

5、String類

• 在Java中，字串常被作為String型別的物件來處理。
• 建立String物件方法：

String a=”hello”或String a = new String(“hello”);

注意：第2個方法 ，建立了兩個物件：一個”hello”字串物件，在堆記憶體中；一個s物件，在棧記憶體中。

• 常用方法：

判斷：    equals():判斷兩個字串的內容是否相同

equalsIgnoreCase():判斷兩個字串的內容是否相同，不區分大小寫

contains(String s):判斷一個字串中是否包含另一個字串

endsWith(String s):測試此字串是否以指定的字尾結束

startsWith(String s):測試此字串是否以指定的字首開始

isEmpty():測試字串是否為空

獲取：    int length():返回此字串的長度

char charAt(int index):返回指定索引處的char值(字元)

int indexOf():返回指定字元(串)在此字串中第一次出現處的索引

int lastIndexOf(int c):返回指定字元在此字串中最後一次出現的索引

String substring(int beginIndex, int endIndex)返回一個新字串，它是此字串的一個子字串,包含頭不包含尾。

轉換：    byte[] getBytes()：從字串到位元組陣列的方法

char[] toCharArray()：從字串到字元陣列的方法

String valueOf(資料型別):把該資料型別的資料轉換成字串

String toLowerCase()：把字串轉換成小寫

String toUpperCase()：把字串轉換成大寫

String concat(String str):將指定字串連線到此字串的結尾

替換分割： String replace(char oldChar, char newChar):用新字元替換舊字元

String[] split(String regex)：根據指定的字串把一個字串分割成一個字串陣列

    String trim():去除字串的前後空格

    int compareTo(String anotherString)按字典順序比較兩個字串

    int compareToIgnoreCase(String str)按字典順序比較兩個字串，不考慮大小寫

6、StringBuffer

• 相當於給字串一個緩衝區，是String的增強類。對字串頻繁修改（如字串連線）時，使用StringBuffer類可以大大提高程式執行效率。
• StringBuffer宣告

StringBuffer strb = new StringBuffer();

StringBuffer strb = new StringBuffer(“aaa”);

• 常用方法：

增加：append(“**”)：追加各種型別的資料到字串之後

insert (1, “**”): 在容器指定位置插入各種型別的資料

刪除：deleteCharAt() : 刪除指定位置的字元

    delete()： 清空StringBuffer的緩衝區

替換：replace()：用新字元替換舊字元

    toString()：將StringBuffer型別的字串轉換為String型別的物件

獲取：charAt() ：返回指定索引處的char值(字串)

    length():返回此字串的長度

• JDK5.0後提供了StringBuilder，等價StringBuffer。但是是單執行緒的，效率相對較高，但是不保證執行緒安全。

7、Math類

提供了常用的數學運算方法和兩個靜態常量E（自然對數的底數）和PI（圓周率）

常用方法：

abs():返回絕對值；

max()：返回最大值；

random()：返回隨機數

ag：生成[0,10)區間的整數 int random = (int)(Math.random()*10);

8、Random類

是產生隨機數的一個類

常用方法：

• 構造方法

Random() 建立一個新的隨機數生成器。

Random(long seed) 使用單個種子建立一個新的隨機數生成器。

注意：種子數只是隨機演算法的起源數字，和生成的隨機數字的區間無關

ag：Random rand = new Random(10);

• 成員方法

int nextInt() 返回下一個偽隨機數，它是此隨機數生成器的序列中均勻分佈的 int 值。

int nextInt(int n) 返回一個偽隨機數，該值介於[0,n)的區間。

ag：生成[0,10)區間的整數     int num = rand.nextInt(10);

11、Scanner類

位於java.util包，是獲取從鍵盤的輸入資料的一個類

• 構造方法

Scanner(InputStream source) 建立一個用來解析基本型別和字串的文字掃描器

ag：Scanner sc = new Scanner(System.in);

• 成員方法

hasNext() 判斷掃描器中當前掃描位置後是否還存在下一段。

hasNextLine() 如果在此掃描器的輸入中存在另一行，則返回 true。

nextInt() 將輸入資訊的下一個標記掃描為一個int，接受整型變數。

next() 以換行或空格符為分界線接收下一個String型別變數。如：輸入hello world!,接收到的只是hello

nextLine() 以換行為分界線接收下一個String型別變數。如：輸入hello world!,接收到的是hello word!

12、Date類

位於java.util包，表示日期和時間的類

• 構造方法

Date() 分配Date物件並初始化此物件，以表示分配它的時間（精確到毫秒）。

Date(long date) 分配Date物件並初始化此物件，以表示從標準基準時間（即1970年1月1日00:00:00GMT）以來的指定毫秒數。

• 成員方法

int compareTo(Date anotherDate) 比較兩個日期的順序

boolean equals(Object obj) 比較兩個日期的相等性。

13、SimpleDateFormat類

位於java.text包，格式化和解析日期的具體類

固定寫法：

//建立日期物件 Date date = new Date();

//定製日期格式 SimpleDateFormat f= new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

String now = f.format(date);  System.out.println(now);

14、Calendar類

位於java.util包，用於設定和獲取日期/時間資料的特定部分

int get(int field)       返回給定日曆欄位的值

YEAR  指示年     MONTH   指示月

DAY_OF_MONTH   指示一個月中的某天

DAY_OF_WEEK        指示一個星期中的某天
三、輸入/輸出和反射

1、File類

位於java.io包，用來操作檔案目錄和屬性

• 構造方法：

File(String pathname)指定檔案路徑

File(String dir,String subpath)dir引數指定目錄路徑，subpath引數指定檔名

File(File parent,String subpath)parent引數指定目錄檔案，subpath引數指定檔名

• 常用方法：

建立：

boolean createNewFile( )  建立名稱的空檔案，不建立資料夾

boolean mkdir() 建立由該File物件表示的目錄（一級資料夾）

boolean mkdirs() 建立包括父目錄的目錄（二級資料夾）

判斷：

boolean exists( )  判斷檔案或目錄是否存在

boolean isFile( )   判斷是否是檔案

boolean isDirectory( )  判斷是否是目錄

獲取：

String getPath( )   返回此物件表示的檔案的相對路徑名

String getAbsolutePath( )   返回此物件表示的檔案的絕對路徑名

String getName( )   返回此物件表示的檔案或目錄的名稱

String getParent()  返回此物件父目錄的路徑名；

long length()  返回檔案的長度，單位為位元組, 如果檔案不存在，則返回0L

刪除：

boolean delete( )   刪除此物件指定的檔案或目錄

2、相對路徑與絕對路徑

相對路徑：從中間目錄出發，到目前位置路徑。

絕對路徑：從根目錄出發，到目前位置的路徑。

3、Java IO流

指二進位制的位元組序列，是一連串流動的字元，是以先進先出方式傳送資訊的通道

分類：

(1)按照流操作的資料型別分為：位元組流和字元流。

位元組流是8 位通用位元組流，字元流是16位Unicode字元流

(2)按照流的流向分為：輸入流，輸出流（相對計算機程式而言，先入後出、先讀後寫）

源資料來源（鍵盤、硬碟）→輸入流（讀）→程式→輸出流（寫）→目標資料來源（控制檯）

4、IO流常用基類

注意：( )裡面是子類 如File**類，Buffered**類

Buffered**類帶有緩衝區，有按行讀取內容的readLine()方法

• 位元組流

位元組輸入流：InputStream    (FileInputStream、BufferedInputStream)

位元組輸出流：OutputStream (FileOutputStream、BufferedOutStream)

• 字元流

字元輸入流：Reader (FileReader、BufferedReader)

字元輸出流：Writer  (FileWriter、BufferedWriter)

5、常用基類的方法

• 位元組輸入流InputStream類方法

void close() 關閉此輸入流並釋放與該流關聯的所有系統資源

int read() 讀取一個位元組資料

int read(byte[] b) 讀取一定數量的位元組，並將其儲存陣列中

int read(byte[] b, int off, int len)  將輸入流中最多 len 個數據位元組，儲存到位元組陣列b中

• 位元組輸出流OutputStream類方法

void close() 關閉此輸出流並釋放與此流有關的所有系統資源

write(int b)  寫入一個位元組資料

void write(byte[] b) 寫入陣列b的所有位元組

void write(byte[] b, int off, int len)將位元組陣列中從偏移量 off 開始的 len 個位元組寫入到輸出流

• 字元輸入流Reader類方法

void close() 關閉輸入流

int read() 讀取單個字元

int read(char[] c)  將c.length長度的字元讀入陣列c中

int read(char[] c, int off, int len) 將最多len長度的字元讀入陣列c，儲存位置從off位置開始

• 字元輸出流Writer類方法

void close() 關閉輸出流

void flush() 重新整理輸出流

int read() 讀取單個字元。

int read(char[] cbuf)  將字元讀入陣列

int read(char[] cbuf, int off, int len) 將字元讀入陣列的某一部分

6、節點流與包裝流

節點流：建立物件時，引數是字串或File類物件

包裝流:建立物件時，引數是流物件。

包裝的作用：1.提高效率 2.方便書寫程式碼

7、使用位元組流讀寫文字檔案

• 使用FileInputStream 讀文字檔案

//構造位元組輸入流物件

FileInputStream fis= new FileInputStream(“c:\\test.txt”);

//迴圈讀取檔案資料  最後關閉流物件fis.close();

System.out.println(“可讀取的位元組數”+fis.available());

byte []buf = new byte[1024];   int len=0;

while((len=fis.read(buf))>0){ System.out.write(buf, 0, len); }

• 使用FileOutputStream 寫文字檔案

//構造位元組輸入流物件

FileOutputStream fos=new FileOutputStream(“f:/java.txt”);

//把資料寫入文字檔案 最後關閉流物件fos.close();

int num=12345;String s=String.valueOf(num);

fos.write(s.getBytes(), 0, s.getBytes().length);

8、使用字元流讀寫文字檔案

• 使用FileReader/BufferedReader讀取檔案

//建立FileReader/BufferedReader物件

Reader fr= new FileReader(“D:\\myDoc\\簡介.txt”);//節點流

BufferedReader br=new BufferedReader(fr); //包裝流

//呼叫readLine()方法讀取文字檔案的資料  最後關閉流物件

String s=null; while((s=br.readLine())!=null){…}

• 使用FileWriter/BufferedWriter寫檔案

//建立FileWriter/BufferedWriter物件

FileWriter fw= new FileWriter(“D:\\myDoc\\簡介.txt”);

BufferedWriter bw=new BufferedWriter(fw);

//呼叫write()方法寫文字檔案的資料  最後關閉流物件

fw.write();  fw.close();

9、解決讀取時中文亂碼

//使用InputStreamReader並設定編碼格式

InputStreamReader fr=new InputStreamReader(fis,”UTF-8”);

//以位元組陣列的形式讀取

byte []buf = new byte[1024];  fis.read(buf)

10、讀寫二進位制檔案

• 使用FileInputStream/DataInputStream讀取二進位制檔案

//構造資料輸入物件

FileInputStream fis=new FileInputStream(“C:\\HelloWorld.class”);

DataInputStream dis=new DataInputStream(fis);

//呼叫read()方法讀取

dis.readInt();  dis.close();

• 使用FileOutputStream/DataOutputStream寫二進位制檔案

//構造資料輸出物件

FileOutputStream outFile=newFileOutputStream(“C:\\temp.txt”);

DataOutputStream out=new DataOutputStream(outFile);

//呼叫write()方法寫入

out.write();  out.close();

11、序列化與反序列化

序列化：將物件的狀態寫入到特定的流中的過程。物件—>流

反序列化：從特定的流中獲取資料重新構建物件的過程。流—>物件

作用：Java物件序列化後，得到的二進位制位元組序列可以方便的儲存到磁碟或者雲上。二進位制序列可以方便地跨平臺傳輸，不用擔心因平臺問題而顯示異常。

實現步驟：

1、實現Serializable介面

2、建立物件輸出流ObjectOutputStream(序列化)/輸入流ObjectInputStrean(反序列化)

3、呼叫writeObject()/readObject ()方法將物件寫入檔案(序列化)/讀取物件(反序列化)

4、關閉物件輸入流

注意：使用transient關鍵字修飾物件的某些屬性時，這些屬性將不再被序列化

12、java反射

反射：指java程式能自描述和自控制，它允許程式在執行時才載入、探知、使用編譯期間完全未知的類

反射機制：指在執行狀態中，動態獲取類資訊以及動態呼叫物件方法的功能

反射常用API：

Class類—可獲取類和類的成員資訊

Field類—可訪問類的屬性

Method類—可呼叫類的方法

Constructor類—可呼叫類的構造方法

使用反射的步驟：

1、匯入java.lang.reflect.*;

2、獲取需要操作類的Class物件

3、呼叫Class的方法獲取Field、Method等物件

4、使用反射API進行操作

反射的應用：

獲取Class物件：getClass()方法  Class.forName()方法  .class 方法

建立Class物件：newInstance()方法

訪問類的屬性：getXxx()方法  setXxx()方法

       訪問類的方法：getMethod()方法  invoke()方法
四、註解和多執行緒

1、註解

Java程式碼裡的特殊標記。它為在程式碼中新增用Java程式無法表達的額外資訊提供了一種形式化的方法。註解可以看成修飾符，修飾程式元素。

註解可以在編譯、類載入、執行時被讀取。而註釋不會被程式所讀取。

2、註解分類

(1)內建註解：標準註解型別;

@Overrid 限定重寫父類方法

@Deprecated 標示已過時

@SuppressWarnings 抑制編譯器警告

(2)元註解: 修飾其他的註解定義

@Target  指定被其修飾的註解能用於修飾哪些程式元素

@Retention  指定該註解可使用反射讀取

@Documented  指定該註解將被JavaDoc工具提取成文件

@Inherited  指定被其修飾的註解將具有繼承性

(3)自定義註解: 註解型別是一種介面

使用關鍵字@interface定義新註解

如：public @interface AnnotationTest{}

3、讀取註解資訊

AnnotatedElement介面是所有程式元素的父介面，指定了程式中可以接受註解的程式元素。通過反射獲取物件資訊。

getAnnotation()方法：返回該程式元素上存在的、指定型別的註解

getAnnotations()方法：返回該程式元素上存在的所有註解

4、程序與執行緒

• 程式：是對資料描述與操作的程式碼的集合。
• 程序：指程式的一次動態執行過程。是系統執行程式的基本單位，有獨立的記憶體空間和系統資源
• 執行緒：指程序中的一個執行流程。是程序中執行運算的最小單位，真正在處理機上執行的是執行緒，一個程序中至少要有一個執行緒。
• 執行緒建立與啟動：

（1）繼承java.lang.Thread類         如：class MyThread extends Thread{}

（2）實現java.lang.Runnable介面 如：class MyThread implements Runnable{}

都需要重寫run()方法，呼叫start()方法

MyThread myThread = new MyThread();      new Thread(myThread).start();

5、執行緒狀態

   ↙阻塞|睡眠狀態↘

新生狀態—>可執行狀態<—>執行狀態—>死亡狀態

新生狀態：執行緒物件已經建立，還沒有在其上呼叫start()方法。

可執行狀態：當執行緒有資格執行，但排程程式還沒有把它選定為執行執行緒時執行緒所處的狀態。

執行狀態：執行緒排程程式從可執行池中選擇一個執行緒作為當前執行緒時執行緒所處的狀態

等待/阻塞/睡眠狀態：是執行緒有資格執行、只是沒有條件使執行緒甦醒所處的狀態。

死亡狀態：當執行緒的run()方法完成時就認為執行緒死去

6、執行緒排程

多個執行緒處於可執行狀態，執行緒排程會根據優先順序來決定執行緒進入可執行狀態的次序。

執行緒的優先順序用1～10 表示，10的優先順序最高，預設值是5

設定優先順序：setPriority(int grade)  如：myThread.setPriority(3);

排程方法：

join()：將指定的執行緒加入到當前執行緒。先執行完呼叫該方法的執行緒再繼續執行本執行緒

sleep()：當前執行緒在指定毫秒內停止執行而轉入不可執行狀態

 yield()：當前執行緒轉入暫時停止執行的狀態

7、執行緒同步

當兩個或多個執行緒需要訪問同一資源時，需要以某種順序來確保該資源某一時刻只能被一個執行緒使用。同步就相當於上鎖，上了鎖的執行緒首先訪問資源，其他執行緒等待。

實現執行緒同步：

同步方法: 用synchronized關鍵字修飾的方法

public synchronized void save(){}

同步程式碼塊: 用synchronized關鍵字修飾的程式碼塊

synchronized(object){}

注意：多執行緒使用同步存在”死鎖”的潛在危險。

死鎖：如果多個執行緒都處於等待狀態而無法被喚醒，就構成了死鎖。比如同步方法裡面有sleep()方法，那麼這個鎖就成了死鎖。

8、執行緒通訊

執行緒同步可以阻止併發訪問同一資源，但不能實現不同執行緒之間的訊息傳遞。所以需要用到執行緒通訊。注意下面方法只能在同步方法或同步程式碼塊中使用

wait()方法：

掛起當前執行緒，並釋放共享資源的鎖

notify()方法：喚醒執行緒

在因呼叫該物件的wait()方法而阻塞的執行緒中隨機選擇一個解除阻塞，但要等到獲得鎖後才可執行

notifyAll()方法：

       將因呼叫該物件的wait()方法而阻塞的所有執行緒一次性全部解除阻塞
五、網路程式設計技術

1、基本概念

網路：是資訊傳輸、接收、共享的虛擬平臺，把各個點、面、體的資訊聯絡到一起，從而實現資源共享

網路程式設計：通過使用套接字來達到程序間通訊目的的程式設計

2、IP地址（Internet Protocol）

概念：唯一標識網路上的每一臺計算機

IP組成：32位，由4個8位二進位制陣列成(ipv4)

11000000.10101000.00000001.11001000–>192.168.1.200

IP地址=網路地址+主機地址

3、IP檢測

檢視IP地址：cmd—ipconfig

檢測網路是否通暢：ping IP地址

4、DNS

域名解析器，把IP地址對映到域名。實現網站通過域名訪問

5、網路伺服器

指在網路環境下，具有較高計算能力，能夠提供使用者服務功能的計算機(郵件伺服器；web伺服器 如Apache Tomcat 阿里雲)

客戶機→伺服器 （Client/Server） （ c/s）

瀏覽器→伺服器 （Browser/Server）（ b/s）

6、網路通訊協議

為了在網路中不同的計算機之間進行通訊而建立的規則、標準或約定的集合

應用層     HTTP FTP TFTP  SMTP  SNMP  DNS協議

傳輸層     TCP     UDP 協議

網路層     ICMP   IGMP  IP  ARP  RARP 協議

資料鏈路層和物理層      由底層網路定義的協議

7、Socket程式設計

• Socket(套接字)：是通訊鏈路的端點。也是Java提供的介面。因為Socket的底層機制複雜，所以Java提供了API方便我們使用Socket程式設計
• Socket通訊模型：進行網路通訊時，Socket需要藉助資料流來完成資料的傳遞工作
• 流式套接字：基於TCP協議的Socket網路程式設計

1、客戶端Socket 類

//建立一個客戶端Socket

Socket socket = new Socket（“localhost”，埠引數）

//通過輸出流，傳送請求 getOutputStream( ) write（）

      OutputStream os=Socket.get OutputStream( );

      byte[] infos=info.getBytes();

      os.write(infos);

//關閉輸出流

      socket.shutdownOutput();

      通過輸入流，接收服務端響應

      Inputstream  is = socket.getInputStream();

//釋放資源

2、伺服器端ServerSocket類

//建立一個伺服器Socket

      ServerSocket serverSocket=new ServerSocket(5000)

//使用accept（）方法等待客戶的通訊

     Socket socket=serverSocket.accpet();

//獲得輸入流，獲得客戶端請求

InputStream is=socket.getInputStream();

      把獲得的位元組流包裝成字元流

BufferedReader br=new BufferedReader(new IputStreamReader(is));

//通過輸出流，傳送響應

OutputStream os = socket. getOutputStream（）；  Os.write(replys);

//釋放相應資源

• 資料包式套接字：基於UDP協議的Socket網路程式設計

①利用DatagramPacket物件封裝資料包

②利用DatagramSocket傳送資料包（send（））

③利用DatagramSocket接收資料包（receive（））

④利用DatagramPacket處理資料包

• TCP與UDP的區別

               TCP                       UDP

是否連線              面向連線                面向非連線

傳輸可靠性          安全可靠                不可靠

速度                     慢                             快
六、XML技術

1、XML簡介

XML(Extensibel Markup Language)：即可擴充套件標記語言，是一種簡單的資料儲存語言，使用一些列簡單的標記描述資料。

特點：與作業系統、開發平臺無關；規範統一

作用：資料互動；配置應用程式和網站；Ajax基石

2、XML基本結構

（1）XML宣告。如：<?xml version=”1.0” encoding=”UTF-8”?>

（2）唯一的根元素。如： <books> </books>

（3）元素描述資訊。  如<book id=”1”><title>java程式設計思想</title></book>

3、XML標籤

<元素名  屬性名 = “屬性值”>元素內容</元素名>

如：<id name=”id”  column=”id”>  <generator class=”sequence”/>  </id>

注意：屬性值用雙引號包裹。有多個屬性用空格隔開

4、XML轉義符

< 對應轉移符&lt;           >  對應轉移符 &gt;

”對應轉移符&quot;      ’對應轉移符&apos;

& 對應轉移符&amp;

當元素中出現很多特殊字元時，可以使用CDATA節 ：<![CDATA[from Student where sid=?]]>

5、XML解析器

非驗證解析器：檢查文件格式是否良好 (eclipse自帶)

驗證解析器：  使用DTD（文件型別定義）或Schema檢查文件的有效性

6、XML名稱空間

寫法：< xmlns：name=”url”>

舉例：xmlns:canon=”http://www.canon” –XML名稱空間

xmlns=”http://www.Aptech_edu.ac”  —屬性名稱空間

7、解析XML技術

DOM（文件物件模型）：把XML文件對映成一個倒掛的樹

• DOM：基於XML文件樹結構的解析。適用於多次訪問的XML文件。特點：比較消耗資源

步驟：

1.建立解析器工廠物件

DocumentBuilderFactory  dbf=DocumentBuilderFactory.newInstance( );

2.解析器工廠物件建立解析器物件

DocumentBuilder  db = dbf.newDocumentBuilder( );

3.解析器物件指定XML檔案建立Document物件

Document  document = db.parse(“要解析的路徑”)

4.以Document物件為起點操作DOM樹

NodeList  dogList= document.getElmentsByTagName(“節點”)

DOM介面方法

Document介面：

getElementById（）getElementsByTagName（） getElementsByName（）等方法

Node介面：

getparentNode() getchildNodes() getfirstChild() getlastChild()

getnextSibling () getpreviousSibling() createTextNode( ) removeChild()等方法

Element介面：

getTagName()  createElement( )等方法

• SAX：基於事件的解析。適用於大資料量的XML文件。特點：佔用資源少，記憶體消耗小
• DOM4J：非常優秀的Java XML API。效能優異、功能強大。特點：開放原始碼

DOM4J解析XML方法

//建立SAXReader物件   SAXReader reader = new SAXReader();

//獲取XML文件物件    Document document = reader.read(“xml/users.xml”);

//獲取root(根)節點    Element root = document.getRootElement();

//獲取節點下的所有子節點集合  List<Element> users=root.elements();

//遍歷輸出 for(Element user:users){…}

DOM4J建立XML方法

//建立了一個xml文件

Document document=DocumentHelper.createDocument();

//建立一個根節點 和一個子節點 並新增屬性

Element root=document.addElement(“users”);

Element user = root.addElement(“user”).addAttribute(“id”, “1”);

//設定子節點的文字

user.addElement(“username”).addText(“zs”);

user.addElement(“password”).addText(“111”);

//建立輸出流物件

File file = new File(“src/xml/users.xml”);

FileOutputStream out = new FileOutputStream(file);

//建立一個XMLWriter的物件 呼叫write方法寫入

       writer=new XMLWriter(out, OutputFormat.createPrettyPrint());  writer.write(document);
七、相關程式碼

1. package com.hfxt.demo02;
2. import java.io.File;
3. import java.io.FileInputStream;
4. import java.io.FileNotFoundException;
5. import java.io.IOException;
6. /**
7.  * 1.輸入：***InputStream(***Reader)/輸出：***OutputStream(***Writer)
8.  * 
9.  * 2.位元組流：***Stream/字元流：***Reader(***Writer)
10.  *
11.  * 3.節點流：建立物件時，引數是字串或File類物件
12.  *   包裝流(裝飾流):建立物件時，引數是流物件，包裝的作用：1.提高效率 2.方便書寫程式碼
13.  */
14. public class Demo01 {
15.     public static void main(String[] args) {
16.         File file = new File(“f:/java/User.java”);
17.         FileInputStream fis=null;
18.         try {
19.             fis=new FileInputStream(file);
20. /*          int data;
21.             while((data=fis.read())!=-1){
22.                 System.out.print((char)data);
23.             }*/
24.             byte []buf = new byte[1024];
25.             int len=0;
26.             while((len=fis.read(buf))>0){
27.                 //System.out.write(buf);
28.                 System.out.write(buf, 0, len);
29.             }
30.         } catch (FileNotFoundException e) {
31.             e.printStackTrace();
32.         } catch (IOException e) {
33.             e.printStackTrace();
34.         }
35.     }
36. }
37. package com.hfxt.demo02;
38. import java.io.*;
39. //二進位制檔案的讀寫
40. public class ReadAndWriteBinaryFile {
41.     public static void main(String[] args){
42.         DataInputStream dis=null;
43.         DataOutputStream dos=null;
44.         FileInputStream fis=null;
45.         FileOutputStream fos=null;
46.         try {
47.             //建立輸入流物件
48.             fis=new FileInputStream(“c:\\myDoc\\star.jpg”);
49.             dis=new DataInputStream(fis);
50.             //建立輸出流物件
51.             fos=new FileOutputStream(“c:\\myDoc\\new.jpg”);
52.             dos=new DataOutputStream(fos);
53.             //讀取檔案並寫入檔案
54.             int temp;
55.             while((temp=dis.read())!=-1){
56.                 dos.write(temp);
57.             }
58.         } catch (FileNotFoundException e) {
59.             e.printStackTrace();
60.         } catch (IOException e) {
61.             e.printStackTrace();
62.         }finally{
63.             try {
64.                 if(dis!=null){
65.                     dis.close();
66.                 }
67.                 if(dos!=null){
68.                     dos.close();
69.                 }
70.                 if(fis!=null){
71.                     fis.close();
72.                 }
73.                 if(fos!=null){
74.                     fos.close();
75.                 }
76.             } catch (IOException e) {
77.                 e.printStackTrace();
78.             }
79.         }
80.     }
81. }
82. package com.hfxt.demo;
83. import java.io.BufferedInputStream;
84. import java.io.BufferedOutputStream;
85. import java.io.File;
86. import java.io.FileInputStream;
87. import java.io.FileNotFoundException;
88. import java.io.FileOutputStream;
89. import java.io.IOException;
90. import java.io.ObjectInputStream;
91. import java.io.ObjectOutputStream;
92. public class Demo08 {
93.     public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
94.         User user = new User(1, “zs”, “111”, “zs”);
95.         //序列化
96.         ObjectOutputStream oos = new ObjectOutputStream(
97.                 new BufferedOutputStream(new FileOutputStream(new File(“f:/wkjava/user.txt”))));
98.         oos.writeObject(user);
99.         if(oos!=null) oos.close();
100.         //反序列化
101.         ObjectInputStream ois = new ObjectInputStream(
102.                 new BufferedInputStream(new FileInputStream(new File(“f:/wkjava/user.txt”))));
103.         User user2=(User) ois.readObject();
104.         System.out.println(user2);
105.     }
106. }
107. package com.hfxt.demo;
108. import java.io.BufferedInputStream;
109. import java.io.BufferedOutputStream;
110. import java.io.File;
111. import java.io.FileInputStream;
112. import java.io.FileNotFoundException;
113. import java.io.FileOutputStream;
114. import java.io.IOException;
115. public class Demo05 {
116.      /*
117.       * 用字元流複製文字檔案
118.       */
119.     public static void main(String[] args) {
120.         //建立文字檔案物件和流物件
121.         File file1 = new File(“f:/wkjava/a.jpg”);
122.         File file2 = new File(“f:/wkjava/3.jpg”);
123.         FileOutputStream fos = null;
124.         FileInputStream fis = null;
125.         BufferedInputStream bis = null;
126.         BufferedOutputStream bos = null;
127.         try {
128.             //將檔案物件放入流物件中
129.             fis = new FileInputStream(file1);
130.             fos = new FileOutputStream(file2);
131.             bis=new BufferedInputStream(fis);
132.             bos=new BufferedOutputStream(fos);
133.             //建立陣列
134.             byte []buf=new byte[1024];
135.             int len=0;
136.             //複製操作：先讀後寫
137.             while((len=bis.read(buf))>0){
138.                 bos.write(buf, 0, len);
139.             }
140.             //清緩衝區
141.             //bos.flush();
142.         } catch (FileNotFoundException e) {
143.             e.printStackTrace();
144.         } catch (IOException e) {
145.             e.printStackTrace();
146.         }finally {  //關閉流
147.             if(bis!=null)
148.                 try {
149.                     bis.close();
150.                 } catch (IOException e) {
151.                     e.printStackTrace();
152.                 }
153.             if(bos!=null)
154.                 try {
155.                     bos.close();
156.                 } catch (IOException e) {
157.                     e.printStackTrace();
158.                 }
159.         }
160. }
161. }
162. package com.hfxt.demo;
163. import java.util.List;
164. import org.dom4j.Document;
165. import org.dom4j.DocumentException;
166. import org.dom4j.Element;
167. import org.dom4j.io.SAXReader;
168. public class ReadXml {
169.     public static void main(String[] args) {
170.         //建立SAXReader物件 
171.         SAXReader reader = new SAXReader();
172.         try {
173.             //讀取檔案 
174.             Document document = reader.read(“xml/users.xml”);
175.             //獲取root(根)節點 
176.             Element root = document.getRootElement();//獲得根元素
177.             /*System.out.println(root.getName());
178.             System.out.println(“*******************”);
179.             System.out.println(root.getText());
180.             System.out.println(“*******************”);*/
181.             //獲取節點下的所有子節點集合 
182.             List<Element> users=root.elements();
183.             //遍歷  
184.             for(Element user:users){
185.                 System.out.println(user.attributeValue(“id”));
186.                 System.out.println(user.elementText(“username”));
187.                 System.out.println(user.elementText(“password”));
188.                 System.out.println(user.elementText(“nickname”));
189.             }
190.         } catch (DocumentException e) {
191.             e.printStackTrace();
192.         }
193.     }
194. }
195. package com.hfxt.demo;
196. import java.io.File;
197. import java.io.FileNotFoundException;
198. import java.io.FileOutputStream;
199. import org.dom4j.Document;
200. import org.dom4j.DocumentHelper;
201. import org.dom4j.Element;
202. import org.dom4j.io.OutputFormat;
203. import org.dom4j.io.XMLWriter;
204. public class WriteXml {
205.     public static void main(String[] args) throws Exception {
206.         XMLWriter writer=null;
207.         //建立文件:使用了一個Helper類
208.         Document document=DocumentHelper.createDocument();
209.         //新增屬性  新增子節點
210.         Element root=document.addElement(“users”);
211.         Element user = root.addElement(“user”).addAttribute(“id”, “1”);
212.         user.addElement(“username”).addText(“zs”);
213.         user.addElement(“password”).addText(“111”);
214.         user = root.addElement(“user”).addAttribute(“id”, “2”);
215.         user.addElement(“username”).addText(“ls”);
216.         user.addElement(“password”).addText(“222”);
217.         String path=“src/xml/users.xml”;
218.         File file = new File(path);
219.         if(!file.getParentFile().exists()){
220.             file.getParentFile().mkdirs();
221.         }
222.         FileOutputStream out = new FileOutputStream(file);
223.         //writer=new XMLWriter(out);
224.         writer=new XMLWriter(out, OutputFormat.createPrettyPrint());
225.         writer.write(document);
226.     }
227. }