Java基礎總結大全(4)

7、流操作的規律：

****流操作的難點：流對象很多，不知道具體用哪個

****規律：

(1)第一步：先明確源和目的

源：

文本：用Reader

字節：用InputStream

目的：

文本：用Writer

字節：用OutputStream

(2)第二步：明確是不是純文本

是：用字符流；

不是：用字節流

(3)第三步：明確流體系后，通過設備來明確具體使用哪個流對象

源設備：

鍵盤：System.in

硬盤：文件流File

內存：數組流ArrayStream

目的設備：

鍵盤：System.out

硬盤：文件流File

內存：數組流ArrayStream

8、File類

構造方法：

File(String pathname)?

通過將給定路徑名字符串轉換為抽象路徑名來創建一個新 File 實例。?

File(String parent, String child)?

根據 parent 路徑名字符串和 child 路徑名字符串創建一個新 File 實例。

File(File parent, String child)?

根據 parent 抽象路徑名和 child 路徑名字符串創建一個新 File 實例。

方法摘要：

(1)創建：

boolean createNewFile()?

當且僅當不存在具有此抽象路徑名指定名稱的文件時，不可分地創建一個新的空文件。?

boolean mkdir()?

創建一級文件夾

boolean mkdirs()?

創建多級文件夾

(判斷)：

boolean canExecute()?

測試應用程序是否可以執行此抽象路徑名表示的文件。?

boolean canRead()?

測試應用程序是否可以讀取此抽象路徑名表示的文件。?

boolean canWrite()?

測試應用程序是否可以修改此抽象路徑名表示的文件。

int compareTo(File pathname)?

按字母順序比較兩個抽象路徑名。?

boolean isAbsolute()?

測試此抽象路徑名是否為絕對路徑名。?

boolean isDirectory()?

測試此抽象路徑名表示的文件是否是一個目錄。?

boolean isFile()?

測試此抽象路徑名表示的文件是否是一個標準文件。?

boolean isHidden()?

測試此抽象路徑名指定的文件是否是一個隱藏文件。

boolean exists()?

測試此抽象路徑名表示的文件或目錄是否存在。?

(3)獲取：

String getParent()?

返回此抽象路徑名父目錄的路徑名字符串；如果此路徑名沒有指定父目錄，則返回 null。?

File getParentFile()?

返回此抽象路徑名父目錄的抽象路徑名；如果此路徑名沒有指定父目錄，則返回 null。?

String getName()?

返回由此抽象路徑名表示的文件或目錄的名稱。

String getPath()?

將此抽象路徑名轉換為一個路徑名字符串。?

String getAbsolutePath()?

返回此抽象路徑名的絕對路徑名字符串。

File getAbsoluteFile()?

返回此抽象路徑名的絕對路徑名形式。

(4)刪除：

boolean delete()?

刪除此抽象路徑名表示的文件或目錄。?

oid deleteOnExit()?

在虛擬機終止時，請求刪除此抽象路徑名表示的文件或目錄。?

(5)獲取全部：(非常重要！！！)

String[] list()?

返回一個字符串數組，這些字符串指定此抽象路徑名表示的目錄中的文件和目錄。?

String[] list(FilenameFilter filter)?

返回一個字符串數組，這些字符串指定此抽象路徑名表示的目錄中滿足指定過濾器的文件和目錄。?

File[] listFiles()?

返回一個抽象路徑名數組，這些路徑名表示此抽象路徑名表示的目錄中的文件。?

File[] listFiles(FileFilter filter)?

返回抽象路徑名數組，這些路徑名表示此抽象路徑名表示的目錄中滿足指定過濾器的文件和目錄。

****FilenameFilter接口只有一個方法：

boolean accept(File dir, String name)?

測試指定文件是否應該包含在某一文件列表中。?

****FileFilter接口只有一個方法：

boolean accept(File dir, String name)?

測試指定文件是否應該包含在某一文件列表中。

8、File類常見需求：

(1)文件名過濾:列出給定目錄的所有.java文件

public void showFileName(File file)

{

String[] filenames = file.list(new FilenameFilter()//匿名內部類

{

public boolean accept(File dir,String name)//復寫唯一方法

{

return name.endsWith(".java");//列出所有.java文件

}

});

}

(2)列出指定目錄下的所有文件和文件夾(遞歸)

**示例1：不帶層次遞歸：

public static void showDir(File dir)

{

File[] files = dir.listFile();

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

{

if(files[i].isDirectory&&!files[i].isHidden())

showDir(files[i]);

else

sop(files[i]);

}

}

**示例2：帶層次遞歸：

public static void showDir(File dir,int level)

{

sop(getLevel(level)+C);//進來先打印層次和目錄

level++;

File[] files = dir.listFile();

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

{

if(files[i].isDirectory&&!files[i].isHidden())

showDir(files[i]);

else

sop(getLevel(level)+files[i]);//是文件就打印層次和目錄

}

}

public static String getLevel(int level)

{

sop("|--");

StringBuilder sb = new StringBuilder();

for(int i=0;i<level;i++)

{

sb.inset(0."| ?")

}

return sb.toString();

}

(3)需求：刪除帶內容的目錄：

public static void removeDir(File dir)

{

File[] files = file.listFile();

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

{

if(files[i].isDirectory&&!files[i].isHidden())

removeDir(files[i]);//如果是文件夾則繼續調用函數

else//如果是文件則刪除。注意刪除的時候打印刪除的結果，防止誤刪或者重刪的情況

sop(files[i].toString()+"::"+files[i].delete());

}

sop(dir+"::"+dir.delete());

}

(4)需求：將制定目錄下的java文件的絕對路徑存儲到文本文件中。

? 思路：

? **對指定目錄進行遞歸

? **獲取遞歸過程中所有java文件的路徑

? **將這些路徑存儲到集合中

? **將集合中的數據寫入文件中

//對指定目錄進行遞歸并將所以Java文件存儲到集合中

public static void getFileName(File file,ArrayList<File> arraylist){

File[] files = file.listFiles();

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

if(files[i].isDirectory()&&!files[i].isHidden()){

getFileName(files[i],arraylist);

}else{

if(files[i].getName().endsWith(".java")){

arraylist.add(files[i]);

}

}

}

}

//將集合中所有數據存儲到新文件中

public static void saveFileToNewDir(ArrayList<File> arraylist,File newDir){

BufferedWriter bufw = null;

try {

bufw = new BufferedWriter(new FileWriter(newDir));

for (File file : arraylist) {

String fileAbsolutePath = file.getAbsolutePath();

bufw.write(fileAbsolutePath);

bufw.newLine();

bufw.flush();

}

} catch (Exception e) {

System.out.println("文件寫入失敗");

}finally{

try {

if(bufw!=null)

bufw.close();

} catch (Exception e2) {

System.out.println("文件寫入流關閉失敗");

}

}

}

9、Properties

(1)Properties是HashTable的子類，具備Map集合的特點，里面存儲的是鍵值對

(2)Properties是IO流合集合相結合的集合容器

(3)Properties的特點是可以用于存儲鍵值對形式的配置文件

(4)構造方法：

Properties()?

創建一個無默認值的空屬性列表。?

Properties(Properties defaults)?

創建一個帶有指定默認值的空屬性列表。?

(5)方法摘要：

Object setProperty(String key, String value)?

調用 Hashtable 的方法 put。

String getProperty(String key)?

用指定的鍵在此屬性列表中搜索屬性。?

void load(InputStream inStream)?

從輸入流中讀取屬性列表（鍵和元素對）。?

void load(Reader reader)?

按簡單的面向行的格式從輸入字符流中讀取屬性列表（鍵和元素對）。?

void list(PrintStream out)?

將屬性列表輸出到指定的輸出流。?

void list(PrintWriter out)?

將屬性列表輸出到指定的輸出流。

void store(OutputStream out, String comments)?

以適合使用 load(InputStream) 方法加載到 Properties 表中的格式，

將此 Properties 表中的屬性列表（鍵和元素對）寫入輸出流。?

void store(Writer writer, String comments)?

以適合使用 load(Reader) 方法的格式，將此 Properties 表中的

屬性列表（鍵和元素對）寫入輸出字符。?

Set<String> stringPropertyNames()?

返回此屬性列表中的鍵集，其中該鍵及其對應值是字符串，如果在主屬性列表中

未找到同名的鍵，則還包括默認屬性列表中不同的鍵?

(6)Properties代碼示例：

public static void show()

{

Properties prop = new Properties();

prop.setProperty("張三","26");

prop.setProperty("李四","30");

prop.setProperty("王五","35");

sop(prop);

String value = prop.getProperty("張三");

Set<String> keys = prop.stringPropertyName();

for(String key : values)

{

sop(key+":"+prop.getPropety(key));

}

}

(7)需求：記錄應用程序的使用次數，如果使用次數已到，則提示用戶注冊。

? ?思路：

? ?**第一次使用時建立一個配置文件用于記錄使用次數

? ?**每次使用都加載該配置文件，并先判斷已使用次數

? ?**每次使用完使用次數加1，寫入配置文件

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

Properties prop = new Properties();//定義Properties，用來和IO流結合

File file = new File("library\\time.ini");//配置文件

if(!file.exists())

file.createNewFile();//如果文件不存在則創建文件(用于第一次使用時創建文件)

FileInputStream fis = new FileInputStream(file);//定義字節讀取流，讀取配置文件中記錄的使用次數

prop.load(fis);//載入流，以獲取文件中配置的鍵值對

int count = 0;//定義使用次數

String countValue = prop.getProperty("time");//通過鍵獲取值

if(countValue!=null){//第一次時countValue為null

count = Integer.parseInt(countValue);//將字符串次數變成數字次數

if(count>3){

System.out.println("您使用次數已到，繼續使用請注冊！");

return;

}

}

count++;//如果使用次數未到則次數加1

prop.setProperty("time", count+"");//配置新的鍵值對

FileWriter fos = new FileWriter(file);

prop.store(fos, "這是應用程序使用次數的配置文件");//將新的鍵值對寫入文件

fis.close();

fos.close();

}

10、IO中的其他流：

(1)打印流：

**PrintWriter:字符打印流

****構造方法：

PrintWriter(String fileName)?

創建具有指定文件名稱且不帶自動行刷新的新 PrintWriter。

PrintWriter(File file)?

使用指定文件創建不具有自動行刷新的新 PrintWriter。

PrintWriter(Writer out)?

創建不帶自動行刷新的新 PrintWriter。?

PrintWriter(Writer out, boolean autoFlush)?

自動刷新

PrintWriter(OutputStream out)?

根據現有的 OutputStream 創建不帶自動行刷新的新 PrintWriter。?

PrintWriter(OutputStream out, boolean autoFlush)?

自動刷新

****方法摘要：

PrintWriter append(char c)?

將指定字符添加到此 writer。?

void close()?

關閉該流并釋放與之關聯的所有系統資源。?

void flush()?

刷新該流的緩沖。?

void print(Object obj)?

打印對象。?

void print(String s)?

打印字符串。

void println()?

通過寫入行分隔符字符串終止當前行。?

**PrintStream:字節打印流

****構造方法：

PrintStream(String fileName)?

創建具有指定文件名稱且不帶自動行刷新的新打印流。

PrintStream(File file)?

創建具有指定文件且不帶自動行刷新的新打印流。

PrintStream(OutputStream out)?

創建新的打印流。?

PrintStream(OutputStream out, boolean autoFlush)?

創建新的打印流。?

****方法摘要：

PrintWriter append(char c)?

將指定字符添加到此 writer。?

void close()?

關閉該流并釋放與之關聯的所有系統資源。?

void flush()?

刷新該流的緩沖。?

void print(Object obj)?

打印對象。?

void print(String s)?

打印字符串。

void println()?

通過寫入行分隔符字符串終止當前行。

(2)對象系列化：

**對象實體化：找一個介質，能長期的存儲對象。

**對象的屬性在Java程序中，都是存在于對內存中，隨著對象的消失而消失，

?而ObjectOutputStream可以將對象實體化

**Serializable接口沒有一個方法，也就是說其是一個標記接口。比如蓋章的豬肉才是安全的。

**只有實現Serializable接口的子類才能被ObjectOutputStream系列化寫入流，當某個

?類實現該接口后，會被Java自動分配UID號，以便編譯器識別，區分不同對象。

**用ObjectOutputStream系列化的對象存儲到文件后，該文件是亂碼，也就是不可讀的

?的用ObjectInputStream讀取該類對象的屬性。

**由于對象是有Java給對象分配相應的UID號，而UID號是根據對象的屬性不同而分配的。

?當一個類對象被系列化到文件后，如果該類改動了對象的屬性，比如將某個成員變量變成私有

?則該對象再用ObjectInputStream讀取時會報異常，也就是說該系列化到文件的對象不能再被使用了

?那么，要想繼續使用屬性被改動后的對象，我們可以自定義給對象分配UID號，讓UID號不隨對象的屬性

?變化而變化。

?自定義對象分配UID方法如下：

public static final long serialVersion UID = 43L;

**注意：

靜態不能被系列化，因為靜態成員變量實在內存的方法區，而ObjectOutputStream只能

對對內存里面的數據進行系列化

被transient修飾的非靜態成員變量也不能被系列化

被系列化的對象存儲到文件中，該文件是不可讀的，所以該文件的擴展名一般

不寫成.txt，通常后綴名寫.object

**ObjectOutputStream

**ObjectInputStream

(3)管道流：

PipedInputStream

PipedOutputStream

(4)隨機訪問文件：RandomAccess(重要！！！)

**自身具備讀寫方法(很牛逼！又可以讀又可以寫)

**通過skipByte(int x)和seek(int x)來達到隨機訪問文件

**該類不是IO體系子類，而是直接繼承Object，但它是IO包中的成員，因為它具備讀寫方法

**該類內部封裝了數組，而且通過指針對數組的元素進行操作，可以通過getFilePoint獲取指針位置

?同時可以通過seek改變指針位置

**該類完成讀寫的原理是內部封裝了字節輸入輸出流

**通過該類的構造看出，該類只能操作文件，而且操作的文件只能有固定模式：

"r":只讀

"rw":讀寫

"rws":

"red":

**構造方法：

RandomAccessFile(File file, String mode)?

創建從中讀取和向其中寫入（可選）的隨機訪問文件流，該文件由 File 參數指定。?

RandomAccessFile(String name, String mode)?

創建從中讀取和向其中寫入（可選）的隨機訪問文件流，該文件具有指定名稱。?

**方法摘要：

void write(byte[] b)?

將 b.length 個字節從指定 byte 數組寫入到此文件，并從當前文件指針開始。?

void write(byte[] b, int off, int len)?

將 len 個字節從指定 byte 數組寫入到此文件，并從偏移量 off 處開始。?

void write(int b)?

向此文件寫入指定的字節。?

int read()?

從此文件中讀取一個數據字節。?

int read(byte[] b)?

將最多 b.length 個數據字節從此文件讀入 byte 數組。?

int read(byte[] b, int off, int len)?

將最多 len 個數據字節從此文件讀入 byte 數組。

String readLine()?

從此文件讀取文本的下一行。?

long getFilePointer()?

返回此文件中的當前偏移量。?

long length()?

返回此文件的長度。?

void seek(long pos)?

設置到此文件開頭測量到的文件指針偏移量，在該位置發生下一個讀取或寫入操作。

(4)操作基本數據類型的流對象：DateStream

(5)操作字節數組流：

ByteArrayInputStream

ByteArrayOutputStream

11、IO流轉換流的字符編碼

(1)字符流的出現為了方便操作字符，更重要的是加入了編碼轉換

(2)通過子類轉換流來完成

InputStreamReander

OutputStreamWriter

(3)在兩個子類對象進行構造的時候可以加入編碼表

(4)編碼表：

將各個國家的文字用二進制數字表示并一一對應，形成一張表，這就是編碼表

(5)常見的編碼表：

**ASCII：美國標準信息交換碼，用一個字節的七位表示

**ISO8859-1：拉丁碼表，歐洲碼表，用一個字節的八位表示

**GB2312：中文編碼表，用兩個字節表示

**GBK：中文編碼表升級，融合錄入更多的中文字符，用兩個字節表示，為避免和老美重復

? ? ? 兩字節的最高位都是1，即漢字都是用負數表示

**Unicode：國際標準碼，融合了多種文字，所有文字都用兩個字節表示

**UTF-8：用一個字節到三個字節表示。

注：Unicode能識別中文，UTF-8也能識別中文，但兩種編碼表示一個漢字所用的字節數不同

Unicode用兩個字節，UTF-8用三個字節，故涉及到編碼轉換。

(6)在流中涉及編碼表的轉換只有轉換流：

InputStreamReander

OutputStreamWriter

(7)代碼示例：

public static void write() throws IOException

{

OutputStreamWriter osw1 = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"GBK");

osw1.write("你好");

osw1.close();

OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("utf-8.txt"),"UTF-8");

osw2.write("你好");

osw2.close();

}

public static void read() throws IOException

{

InputStreamReader isr = new InputStreamReader(new FileInputStream("gbk.txt"),"GBK");

byte[] buf = new byte[1024];

int len = isr.read(buf);

sop(new String(buf,0,len));

}

(8)編碼解碼

編碼：字符串變成字節數組：String-->getBytes()-->byte[]()

解碼：字節數組變成字符串：byte[]-->new String(byte[],0,len)-->String

(9)代碼示例：

public static void main(String[] args)

{

//編碼解碼1：默認編碼

String str1 = "你好";

byte[] buf1 = str1.getBytes();//默認解碼：Unicode，四個字節

//編碼解碼2：指定編碼

String str2 = "你好";

byte[] buf2 = str2.getBytes("UTF-8");//指定解碼：UTF-8,六個字節

//編碼解碼3：編碼正確解碼錯誤

String str3 = "你好";

byte[] buf3 = str3.getBytes("GBK");//指定編碼：GBK,四個字節

String str3 = new String(buf3,"ISO8859-1");//錯誤解碼

//編碼解碼4：錯誤編碼正確解碼

String str4 = "你好";

byte[] buf4 = str4.getBytes("ISO8859-1");//錯誤編碼

String str4 = new String(buf4,"GBK");//正確解碼，讀不出來

//編碼解碼5：編碼對了，但是解碼錯誤了，怎么辦呢？

//此時可以將錯誤的解碼再錯編回去，載用正確編碼解碼

String str5 = "你好";

byte[] buf5 = str5.getBytes("GBK");//正確編碼

String str6 = new String(buf5,"ISO8859-1");//錯誤解碼，讀不出來

byte[] buf6 = str6.getBytes("ISO8859-1");//再錯誤編碼

String str7 = new String(buf6,"GBK");//再正確解碼，這樣就可以讀出來了

}

六、網絡編程：

1、網絡編程概述

(1)網絡模型

OSI參考模型

TCP/IP參考模型

(2)網絡通訊要素

IP地址

端口號

傳輸協議

(3)網絡通訊前提：

**找到對方IP

**數據要發送到指定端口。為了標示不同的應用程序，所以給這些網絡應用程序都用數字進行標示

?。這個表示就叫端口。

**定義通信規則。這個規則稱為通信協議，國際組織定義了通用協議TCP/IP

(4)計算機網絡：

是指將地理位置不同的具有獨立功能的多臺計算機及其外部設備，

通過通信線路連接起來，在網絡操作系統，網絡管理軟件及網絡通信協議的管理和協調下，

實現資源共享和信息傳遞的計算機系統。

(5)IP地址：

IP地址 = 網絡號碼+主機地址

A類IP地址:第一段號碼為網絡號碼，剩下的三段號碼為本地計算機的號碼

B類IP地址:前二段號碼為網絡號碼，剩下的二段號碼為本地計算機的號碼

C類IP地址:前三段號碼為網絡號碼，剩下的一段號碼為本地計算機的號碼

特殊地址:

127.0.0.1 回環地址,可用于測試本機的網絡是否有問題. ping 127.0.0.1 ??

ipconfig:查看本機IP地址

xxx.xxx.xxx.0 網絡地址

xxx.xxx.xxx.255 廣播地址

A類 1.0.0.1---127.255.255.254 10.X.X.X是私有地址(私有地址就是在互聯網上不使用，而被用在局域網絡中的地址) (2)127.X.X.X是保留地址，用做循環測試用的。

B類 128.0.0.1---191.255.255.254 172.16.0.0---172.31.255.255是私有地址。169.254.X.X是保留地址。

C類 192.0.0.1---223.255.255.254 192.168.X.X是私有地址

D類 224.0.0.1---239.255.255.254

E類 240.0.0.1---247.255.255.254

(6)各種網絡分類方式

A:按網絡覆蓋范圍劃分

　　局域網(幾米至10公里以內) 　　城域網(10~100公里) 　　廣域網(幾百公里到幾千公里) 　　國際互聯網

B:按網絡拓撲結構劃分

　　總線型網絡 　　星形網絡 　　環型網絡 　　樹狀網絡 　　混合型網絡

C:按傳輸介質劃分

　　有線網 　　無線網

D:按網絡使用性質劃分

　　公用網 　　專用網

(7)虛擬專用網絡（Virtual Private Network ，簡稱)指的是在公用網絡上建立專用網絡的技術。

其之所以稱為虛擬網，主要是因為整個網絡的任意兩個節點之間的連接并沒有傳統專網

所需的端到端的物理鏈路，而是架構在公用網絡服務商所提供的網絡平臺，如Internet、

ATM(異步傳輸模式〉、Frame Relay （幀中繼）等之上的邏輯網絡，

用戶數據在邏輯鏈路中傳輸。它涵蓋了跨共享網絡或公共網絡的封裝、

加密和身份驗證鏈接的專用網絡的擴展。主要采用了隧道技術、加解密技術、

密鑰管理技術和使用者與設備身份認證技術。

(8)網絡模型：

****OSI模型

應用層

表示層

會話層

傳輸層

網絡層

數據連接層

物理層

****TCP/IP模型

應用層

傳輸層

網際層

主機至網絡層

2、TCP和UDP

(1)UDP和TCP的區別：

UDP

將數據及源和目的封裝成數據包中，不需要建立連接

每個數據報的大小在限制在64k內

因無連接，是不可靠協議

不需要建立連接，速度快

TCP

建立連接，形成傳輸數據的通道。

在連接中進行大數據量傳輸

通過三次握手完成連接，是可靠協議

必須建立連接，效率會稍低

注：三次握手：

第一次：我問你在么？

第二次：你回答在。

第三次：我反饋哦我知道你在。

3、Socket(UDP傳輸)

**Socket就是為網絡服務提供的一種機制。

**通信的兩端都有Socket。

**網絡通信其實就是Socket間的通信。

**數據在兩個Socket間通過IO傳輸。

**玩Socket主要就是記住流程，代碼查文檔就行

(1)UDP傳輸：DatagramSocket與DatagramPacket

**發送端：

建立DatagramSocket服務；

提供數據，并將數據封裝到字節數組中；

創建DatagramPacket數據包，并把數據封裝到包中，同時指定IP和接收端口

通過Socket服務，利用send方法將數據包發送出去；

關閉DatagramSocket和DatagramPacket服務。

**接收端：

建立DatagramSocket服務，并監聽一個端口；

定義一個字節數組和一個數據包，同時將數組封裝進數據包；

通過DatagramPacket的receive方法，將接收的數據存入定義好的數據包；

通過DatagramPacke關閉t的方法，獲取發送數據包中的信息；

關閉DatagramSocket和DatagramPacket服務。

DatagramSocket與DatagramPacket方法摘要：

*****DatagramSocket

構造方法：

DatagramSocket()?

構造數據報套接字并將其綁定到本地主機上任何可用的端口。

DatagramSocket(int port)?

創建數據報套接字并將其綁定到本地主機上的指定端口。?

DatagramSocket(int port, InetAddress laddr)?

創建數據報套接字，將其綁定到指定的本地地址。?

方法摘要:

void close()?

關閉此數據報套接字。

InetAddress getInetAddress()?

返回此套接字連接的地址。?

InetAddress getLocalAddress()?

獲取套接字綁定的本地地址。

int getPort()?

返回此套接字的端口。?

void receive(DatagramPacket p)?

從此套接字接收數據報包。?

void send(DatagramPacket p)?

從此套接字發送數據報包。

****DatagramPacket

構造方法：

DatagramPacket(byte[] buf, int length)?

構造 DatagramPacket，用來接收長度為 length 的數據包。

DatagramPacket(byte[] buf, int length, InetAddress address, int port)?

構造數據報包，用來將長度為 length 的包發送到指定主機上的指定端口號。

InetAddress getAddress()?

返回某臺機器的 IP 地址，此數據報將要發往該機器或者是從該機器接收到的。?

byte[] getData()?

返回數據緩沖區。?

int getLength()?

返回將要發送或接收到的數據的長度。

int getPort()?

返回某臺遠程主機的端口號，此數據報將要發往該主機或者是從該主機接收到的。

代碼示例：

****發送端：

class UDPSend

{

public static void main(String[] args) throws Exception

{

DatagramSocket ds = new DatagramSocket();

byte[] buf = "這是UDP發送端".getBytes();

DatagramPacket dp = new DatagramPacket(

buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);

ds.send(dp);

ds.close();

}

}

****接收端

class UDPRece

{

public static void main(String[] args) throws Exception

{

DatagramSocket ds = new DatagramSocket(10000);

byte[] buf = new byte[1024];

DatagramPacket dp = new DatagramPacket(buf,buf.length);

ds.receive(dp);//將發送端發送的數據包接收到接收端的數據包中

String ip = dp.getAddress().getHosyAddress();//獲取發送端的ip

String data = new String(dp.getData(),0,dp.getLength());//獲取數據

int port = dp.getPort();//獲取發送端的端口號

sop(ip+":"+data+":"+port);

ds.close();

}

}

需求1：UDP鍵盤錄入數據，并發送給接收端

發送端：

class UDPSend

{

public static void main(String[] args) throws Exception

{

DatagramSocket ds = new DatagramSocket();

BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

String line = null;

while((line = bufr.readLine())!=null)

{

if("886".equals(line))

break;

byte[] buf = line.getBytes();

DatagramPacket dp = new DatagramPacket(

buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);

ds.send(dp);

}

ds.close();

}

}

接收端：

class UDPRece

{

public static void main(String[] args) throws Exception

{

DatagramSocket ds = new DatagramSocket(10000);

while(true)

{

byte[] buf = new byte[1024];

DatagramPacket dp = new DatagramPacket(buf,buf.length);

ds.receive(dp);//將發送端發送的數據包接收到接收端的數據包中

String ip = dp.getAddress().getHosyAddress();//獲取發送端的ip

String data = new String(dp.getData(),0,dp.getLength());//獲取數據

int port = dp.getPort();//獲取發送端的端口號

sop(ip+":"+data+":"+port);

ds.close();

}

}

}

需求2：編寫簡單的聊天工具

思路：

使用多線程技術

發送端：

class UDPSend implements Runnable

{

private DatagramSocket ds;

public UDPSend(){}

public UDPSend(DatagramSocket ds)

{

this.ds=ds;

}

public void run()

{

try

{

BufferedReader bufr = new BufferedReader(

new InputStreamReader(System.in));

String line = null;

while((line = bufr.readLine())!=null)

{

if("886".equals(line))

break;

byte[] buff = line.getBytes();

DatagramPacket dp = new DatagramPacket(

buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);

ds.send(dp);

}

}

catch(Exception e)

{

throw new RuntimeException("發送失敗");

}

}

}

接收端：

class UDPRece implements Runnable

{

private DatagramSocket ds;

public UDPSend(){}

public UDPSend(DatagramSocket ds)

{

this.ds=ds;

}

public void run()

{

try

{

while(true)

{

byte[] buf = new byte[1024];

DatagramPacket dp = new DatagramPacket(buf,buf.length);

ds.receive(dp);//將發送端發送的數據包接收到接收端的數據包中

String ip = dp.getAddress().getHosyAddress();//獲取發送端的ip

String data = new String(dp.getData(),0,dp.getLength());//獲取數據

int port = dp.getPort();//獲取發送端的端口號

sop(ip+":"+data+":"+port);

}

}

catch(Exception e)

{

throw new RuntimeException("接收失敗");

}

}

}

測試類：

class UDPTest

{

public static void main(String[] args)

{

DatagramSocket sendSocket = new DatagramSocket();

DatagramSocket receSocket = new DatagramSocket(10000);

new Thread(new UDPSend(sendSocket)).start();

new Thread(new UDPRece(receSocket)).start();

}

}

(2)TCP傳輸

Socket和ServerSocket

建立客戶端和服務器端

建立連接后，通過Socket中的IO流進行數據的傳輸

關閉socket

同樣，客戶端與服務器端是兩個獨立的應用程序。

****Socket

**構造方法：

Socket()?

通過系統默認類型的 SocketImpl 創建未連接套接字

Socket(InetAddress address, int port)?

創建一個流套接字并將其連接到指定 IP 地址的指定端口號。

Socket(String host, int port)?

創建一個流套接字并將其連接到指定主機上的指定端口號。

**方法摘要：

void close()?

關閉此套接字。

InetAddress getInetAddress()?

返回套接字連接的地址。

InputStream getInputStream()?

返回此套接字的輸入流。

OutputStream getOutputStream()?

返回此套接字的輸出流。?

int getPort()?

返回此套接字連接到的遠程端口。

void shutdownInput()?

此套接字的輸入流置于“流的末尾”。?

void shutdownOutput()?

禁用此套接字的輸出流。?

String toString()?

將此套接字轉換為 String。

****ServerSocket

**構造方法：

ServerSocket()?

創建非綁定服務器套接字。?

ServerSocket(int port)?

創建綁定到特定端口的服務器套接字。

方法摘要：

Socket accept()?

偵聽并接受到此套接字的連接。

void close()?

關閉此套接字。?

InetAddress getInetAddress()?

返回此服務器套接字的本地地址。

****TCP傳輸流程：

**客戶端：

建立Socket服務，并制定要連接的主機和端口；

獲取Socket流中的輸出流OutputStream，將數據寫入流中，通過網絡發送給服務端；

獲取Socket流中的輸出流InputStream，獲取服務端的反饋信息；

關閉資源。

**服務端：

建立ServerSocket服務，并監聽一個端口；

通過ServerSocket服務的accept方法，獲取Socket服務對象；

使用客戶端對象的讀取流獲取客戶端發送過來的數據；

通過客戶端對象的寫入流反饋信息給客戶端；

關閉資源；

****代碼示例：

客戶端：

class TCPClient

{

public static void main(String[] args)

{

Socket s = new Socket("192.168.1.253",10000);

OutputStream os = s.getOutputStream();

out.write("這是TCP發送的數據".getBytes());

s.close();

}

}

服務端：

class TCPServer

{

public static void main(String[] args)

{

ServerSocket ss = new ServerSocket(10000);

Socket s = ss.accept();

String ip = s.getInetAddress().getHostAddress();

sop(ip);

InputStream is = s.getInputStream();

byte[] buf = new byte[1024];

int len = is.read(buf);

sop(new String(buf,0,len));

s.close();

ss.close();

}

}

TCP需求1：客戶端給服務端發送數據，服務端接收到后反饋信息給客戶端

客戶端：

class TCPClient

{

public static void main(String[] args)

{

Socket s = new Socket("192.168.1.253",10000);

OutputStream os = s.getOutputStream();

out.write("這是TCP發送的數據".getBytes());

InputStream is = s.getInputStream();

byte[] buf = new byte[1024];

int len = is.read(buf);

sop(new String(buf,0,len));

s.close();

}

}

服務端：

class TCPServer

{

public static void main(String[] args)

{

ServerSocket ss = new ServerSocket(10000);

Socket s = ss.accept();

String ip = s.getInetAddress().getHostAddress();

sop(ip);

InputStream is = s.getInputStream();

byte[] buf = new byte[1024];

int len = is.read(buf);

sop(new String(buf,0,len));

OutputStream os = s.getOutputStream();

out.write("這是TCP發送的數據".getBytes());

s.close();

ss.close();

}

}

TCP需求2：建立一個文本轉換服務端，客戶給服務端發送文本，服務端將數據轉換成大寫后返回給客戶端

?當客戶端輸入over時，轉換結束

客戶端：

class TCPClient

{

public static void main(String[] args)

{

Socket s = new Socket("192.168.1.253",10000);

BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(

s.getOutputStream()));

BufferedReader bufIn = new BufferedReader(new InputStreamReader(

s.getInputStream()));

String line = null;

while((line = bufr.readLine())!=null)

{

if("over".equals(line))

break;

bufOut.write(line);

bufOut.newLine();

bufOut.flush();

String retVal = bufIn.readLine();

sop("server:"+retVal);

}

bufr.close();

s.close();

}

}

服務端：

class TCPServer

{

public static void main(String[] args)

{

ServerSocket ss = new ServerSocket(10000);

Socket s = ss.accept();

String ip = s.getInetAddress().getHostAddress();

sop(ip);

BufferedReader bufIn = new BufferedReader(new InputStreamReader(

s.getInputStream()));

BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(

s.getOutputStream()));

while((line = bufIn.readLine())!=null)

{

bufOut.write(line.toUpperCase());

bufOut.newLine();

bufOut.flush();

}

s.close();

ss.close();

}

}

**需求3：拷貝文件

客戶端：

class TCPClient

{

public static void main(String[] args)

{

Socket s = new Socket("192.168.1.253",10000);

BufferedReader bufr = new BufferedReader(new FileReader("g:\\demo.txt"));

PrintWriter pw = new PrintWriter(s.getOutputStream(),true);

String line = null;

while((line = bufr.readLine())!=null)

{

pw.println();

}

s.shutDownOutput();

BufferedReader bufIn = new BufferedReader(new InputStreamReader(

s.getInputStream()));

String retVal = bufIn.readLine();

sop(retVal);

bufr.close();

s.close();

}

}

服務端：

class TCPServer

{

public static void main(String[] args)

{

ServerSocket ss = new ServerSocket(10000);

Socket s = ss.accept();

String ip = s.getInetAddress().getHostAddress();

sop(ip);

BufferedReader bufIn = new BufferedReader(new InputStreamReader(

s.getInputStream()));

PrintWriter out = new PrintWriter(new FileWriter"copy.txt",true);

String line =null;

while((line = bufIn.readLine())!=null)

{

out.write(line);

}

PrintWriter pw = new PrintWriter(s.getOutputStream(),true);

pw.println("上傳成功");

out.close();

s.close();

ss.close();

}

}

需求4：上傳圖片

客戶端：

class TCPClient

{

public static void main(String[] args)

{

Socket s = new Socket("192.168.1.253",10000);

FileInputStream fis = new FileInputStream("g:\\1.bmp");

OutputStream out = s.getOutputStream();

byte[] buf = new byte[1024];

int len = 0;

while((len = bufr.read())!=-1)

{

out.write(buf,0,len);

}

s.shutDownOutput();

InputStream in = s.getInputStream();

byte[] bufIn = new byte[1024];

int lenIn = in.read(bufIn);

sop(new String(bufIn,0,lenIn);

fis.close();

s.close();

}

}

服務端：

class TCPServer

{

public static void main(String[] args)

{

ServerSocket ss = new ServerSocket(10000);

Socket s = ss.accept();

String ip = s.getInetAddress().getHostAddress();

sop(ip);

FileOutputStream fos = new FileOutputStream("g:\\copy.bmp");

InputStream in = s.getInputStream();

byte[] bufIn = new byte[1024];

int lenIn = 0;

while((lenIn=bufIn.read())!=-1)

{

fos.write(bufIn,0,lenIn)

}

OutputStream outIn = s.getOutputStream();

outIn.write("上傳成功".getBytes());

fos.close();

s.close();

ss.close();

}

}

需求5：客戶端并發登陸

客戶端通過鍵盤錄入用戶名，服務端對這個用戶名進行校驗

如果用戶存在，在服務端現實xxx已登錄，并在客戶端現實歡迎xxx

如果用戶不存在，在服務端現實xxx正在嘗試登陸，并在客戶端現實xxx用戶不存在

最多登陸三次。

校驗端：

class User implements Runnable

(

private Socket s;

public User(){}

public User(Socket s)

{

this.s=s;

}

public void run()

{

try

{

BufferedReader bufrIn = new BufferedReader(

new InputStream(s.getInputStream()))

String name = bufrIn.readLine();

if(name==null)

{

sop("用戶名為空");

break;

}

BufferedReader bufr = new BufferedReader(

new FileReader("user.txt"));

PrintWriter pw = new PrintWriter(s.getOutputStream(),true);

String line = null;

boolean flag = false;

while((line = bufr.reanLine())!=null)

{

if(line.equals(name))

{

flag = true;

break;

}

if(flag)

{

sop(name+"已登陸");

pw.println("歡迎"+name);

break;

}

else

{

sop(name+"正嘗試登陸");

pw.println(name+"用戶不存在");

}

}

s.close();

}

catch(Exception e)

{

throw new RuntimeException("用戶校驗失敗");

}

}

)

客戶端：

class LoginClient

{

public static void main(String[] args)

{

Socket s = new Socket("192.168.1.253",10000);

BufferedReader bufr = new BufferedReader(

new InputStreamReader(System.in)));

PrintWriter out = new PrintWriter(s.getOutputStream(),true);

BufferedReader bufIn = new BufferedReader(

new InputStreamReader(s.getInputStream()));

for(int i=0;i<3;i++)

{

String line = bufr.readLine();

if(line == null)

{

sop("用戶名不能為空！");

break;

}

out.write(line);

String retVal = bufIn.readLine();

sop(retVal);

}

bufr.close();

s.close();

}

}

服務端：

class LoginServer

{

public static void main(String[] args)

{

ServerSocket ss = new ServerSocket(10000);

while(true)

{

Socket s = ss.accept();

new Thread(new User()).start();

}

}

}

========完結========