「挑三揀四」地學一學Java I/O
古人云：「讀書破萬卷，下筆若有神」。也就是說，只有大量的閱讀，寫做的時候才能風生水起——寫做意味着輸出（我的知識傳播給他人），而讀書意味着輸入（從他人的知識中汲取養分）。html
對於Java I/O來講，I意味着Input（輸入），O意味着Output（輸出）。讀書寫做並不是易事，而建立一個好的I/O系統更是一項艱難的任務。java
0一、數據流之字節與字符
Java全部的I/O機制都是基於數據流進行的輸入輸出。數據流可分爲兩種：apache
1）字節流，未經加工的原始二進制數據，最小的數據單元是字節。數組
2）字符流，通過必定編碼處理後符合某種格式規定的數據，最小的數據單元是字符——佔用兩個字節。緩存
OutputStream和InputStream用來處理字節流；Writer和Reader用來處理字符流；OutputStreamWriter能夠把OutputStream轉換爲Writer，InputStreamReader能夠把InputStream轉換爲Reader。服務器
Java的設計者爲此設計了衆多的類，見下圖。微信
看到這麼多類，你必定感受頭暈目眩。反正我已經看得不耐煩了。搞這麼多類，看起來頭真的大——這也從側面說明實際的應用場景各有各的不一樣——你也徹底不用擔憂，由於實際項目當中，根本就不可能全用到（我就沒用過SequenceOutputStream）。網絡
我建議你在學習的時候要掌握一種「挑三揀四」的能力——學習本身感興趣的、必須掌握的、對能力有所提高的知識。切不可囫圇吞棗，強迫本身什麼都學。什麼都學，最後的結果多是什麼都不會。數據結構
字符流是基於字節流的，所以，咱們先來學習一下字節流的兩個最基礎的類——OutputStream和InputStream，它們是必需要掌握的。併發
1）OutputStream
OutputStream提供了4個很是有用的方法，以下。
public void write(byte b[])：將數組b中的字節寫到輸出流。public void write(byte b[], int off, int len)：將數組b的從偏移量off開始的len個字節寫到輸出流。public void flush(): 將數據緩衝區中數據所有輸出，並清空緩衝區。public void close(): 關閉輸出流並釋放與流相關的系統資源。
其子類ByteArrayOutputStream和BufferedOuputStream最爲經常使用（File相關類放在下個小節）。
①、ByteArrayOutputStream一般用於在內存中建立一個字節數組緩衝區，數據被「臨時」放在此緩衝區中，並不會輸出到文件或者網絡套接字中——就好像一箇中轉站，負責把輸入流中的數據讀入到內存緩衝區中，你能夠調用它的toByteArray()方法來獲取字節數組。
來看下例。
public static byte[] readBytes(InputStream in, long length) throws IOException {
ByteArrayOutputStream bo = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int read = 0;
while (read < length) {
int cur = in.read(buffer, 0, (int) Math.min(1024, length - read));
if (cur < 0) {
break;
}
read += cur;
bo.write(buffer, 0, cur);
}
return bo.toByteArray();
}
複製代碼
ByteArrayOutputStream的責任就是把InputStream中的字節流「一字不差」的讀出來——這個工具方法很重要，很重要，很重要——能夠解決粘包的問題。
②、BufferedOuputStream實現了一個緩衝輸出流，能夠將不少小的數據緩存爲一個大塊的數據，而後一次性地輸出到文件或者網絡套接字中——這裏的「緩衝」和ByteArrayOutputStream的「緩衝」有着很大的不一樣——前者是爲了下一次的一次性輸出，後者就是單純的爲了緩衝，不存在輸出。
來看下例。
protected void write(byte[] data) throws IOException {
out.write(intToByte(data.length));
out.write(data);
out.flush();
out.close();
}
public static byte[] intToByte(int num)
{
byte[] data = new byte[4];
for (int i = 0; i < data.length; i++)
{
data[3-i] = (byte)(num % 256);
num = num / 256;
}
return data;
}
複製代碼
使用BufferedOuputStream的時候，必定要記得調用flush()方法將數據從緩衝區中所有輸出。使用完畢後，調用close()方法關閉輸出流，釋放與流相關的系統資源。
2）InputStream
InputStream也提供了4個很是有用的方法，以下。
public int read(byte b[])：讀取b.length個字節的數據放到數組b中，返回值是讀取的字節數。public int read(byte b[], int off, int len)：從輸入流中最多讀取len個字節的數據，存放到偏移量爲off的數組b中。public int available()：返回輸入流中能夠讀取的字節數。public int close()：使用完後，對打開的流進行關閉。
其子類BufferedInputStream（緩衝輸入流）最爲經常使用，效率最高（當咱們不肯定讀入的是大數據仍是小數據）。
無緩衝流上的每一個讀取請求一般會致使對操做系統的調用以讀取所請求的字節數——進行系統調用的開銷很是大。但緩衝輸入流就不同了，它經過對內部緩衝區執行（例如）高達8k字節的大量讀取，而後針對緩衝區的大小再分配字節來減小系統調用的開銷——性能會提升不少。
使用示例以下。
先來看一個輔助方法byteToInt，把字節轉換成int。
public static int byteToInt(byte[] b) {
int num = 0;
for (int i = 0; i < b.length; i++) {
num*=256;
num+=(b[i]+256)%256;
}
return num;
}
複製代碼
再來看如何從輸入流中，根據指定的長度contentLength來讀取數據。readBytes()方法在以前已經提到過。
BufferedInputStream in = new BufferedInputStream(socket.getInputStream());
byte[] tmpByte = new byte[4];
// 讀取四個字節判斷消息長度
in.read(tmpByte, 0, 4);
// 將byte轉爲int
int contentLength = byteToInt(tmpByte);
byte[] buf = null;
if (contentLength > in.available()) {
// 以前提到的方法
buf = readBytes(in, contentLength);
} else {
buf = new byte[contentLength];
in.read(buf, 0, contentLength);
// 發生粘包了
if (in.available() > 0) {
}
}
複製代碼
我敢保證，只要你搞懂了字節流，字符流也就不在話下——因此，咱們在此略過字符流。
0二、File類
前面咱們瞭解到，數據有兩種格式：字節與字符。那麼這些數據從哪裏來，又存往何處呢？
一個主要的方式就是從物理磁盤上進行讀取和存儲，磁盤的惟一最小描述就是文件。也就是說上層應用程序只能經過文件來操做磁盤上的數據，文件也是操做系統和磁盤驅動器交互的一個最小單元。
在Java中，一般用File類來操做文件。固然了，File不止是文件，它也是文件夾（目錄）。File類保存了文件或目錄的各類元數據信息（文件名、文件長度、最後修改時間、是否可讀、當前文件的路徑名等等）。
經過File類以及文件輸入輸出流（FileInputStream、FileOutputStream），能夠輕鬆地建立、刪除、複製文件或者目錄。
這裏，我提供給你一個實用的文件工具類——FileUtils。
package com.cmower.common.util;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.collect.Lists;
/** * 文件操做工具類 * 實現文件的建立、刪除、複製、壓縮、解壓以及目錄的建立、刪除、複製、壓縮解壓等功能 */
public class FileUtils extends org.apache.commons.io.FileUtils {
private static Logger logger = LoggerFactory.getLogger(FileUtils.class);
/** * 複製單個文件，若是目標文件存在，則不覆蓋 * @param srcFileName 待複製的文件名 * @param descFileName 目標文件名 * @return 若是複製成功，則返回true，不然返回false */
public static boolean copyFile(String srcFileName, String descFileName) {
return FileUtils.copyFileCover(srcFileName, descFileName, false);
}
/** * 複製單個文件 * @param srcFileName 待複製的文件名 * @param descFileName 目標文件名 * @param coverlay 若是目標文件已存在，是否覆蓋 * @return 若是複製成功，則返回true，不然返回false */
public static boolean copyFileCover(String srcFileName, String descFileName, boolean coverlay) {
File srcFile = new File(srcFileName);
// 判斷源文件是否存在
if (!srcFile.exists()) {
logger.debug("複製文件失敗，源文件 " + srcFileName + " 不存在!");
return false;
}
// 判斷源文件是不是合法的文件
else if (!srcFile.isFile()) {
logger.debug("複製文件失敗，" + srcFileName + " 不是一個文件!");
return false;
}
File descFile = new File(descFileName);
// 判斷目標文件是否存在
if (descFile.exists()) {
// 若是目標文件存在，而且容許覆蓋
if (coverlay) {
logger.debug("目標文件已存在，準備刪除!");
if (!FileUtils.delFile(descFileName)) {
logger.debug("刪除目標文件 " + descFileName + " 失敗!");
return false;
}
} else {
logger.debug("複製文件失敗，目標文件 " + descFileName + " 已存在!");
return false;
}
} else {
if (!descFile.getParentFile().exists()) {
// 若是目標文件所在的目錄不存在，則建立目錄
logger.debug("目標文件所在的目錄不存在，建立目錄!");
// 建立目標文件所在的目錄
if (!descFile.getParentFile().mkdirs()) {
logger.debug("建立目標文件所在的目錄失敗!");
return false;
}
}
}
// 準備複製文件
// 讀取的位數
int readByte = 0;
InputStream ins = null;
OutputStream outs = null;
try {
// 打開源文件
ins = new FileInputStream(srcFile);
// 打開目標文件的輸出流
outs = new FileOutputStream(descFile);
byte[] buf = new byte[1024];
// 一次讀取1024個字節，當readByte爲-1時表示文件已經讀取完畢
while ((readByte = ins.read(buf)) != -1) {
// 將讀取的字節流寫入到輸出流
outs.write(buf, 0, readByte);
}
logger.debug("複製單個文件 " + srcFileName + " 到" + descFileName
+ "成功!");
return true;
} catch (Exception e) {
logger.debug("複製文件失敗：" + e.getMessage());
return false;
} finally {
// 關閉輸入輸出流，首先關閉輸出流，而後再關閉輸入流
if (outs != null) {
try {
outs.close();
} catch (IOException oute) {
oute.printStackTrace();
}
}
if (ins != null) {
try {
ins.close();
} catch (IOException ine) {
ine.printStackTrace();
}
}
}
}
/** * 複製整個目錄的內容，若是目標目錄存在，則不覆蓋 * @param srcDirName 源目錄名 * @param descDirName 目標目錄名 * @return 若是複製成功返回true，不然返回false */
public static boolean copyDirectory(String srcDirName, String descDirName) {
return FileUtils.copyDirectoryCover(srcDirName, descDirName,
false);
}
/** * 複製整個目錄的內容 * @param srcDirName 源目錄名 * @param descDirName 目標目錄名 * @param coverlay 若是目標目錄存在，是否覆蓋 * @return 若是複製成功返回true，不然返回false */
public static boolean copyDirectoryCover(String srcDirName, String descDirName, boolean coverlay) {
File srcDir = new File(srcDirName);
// 判斷源目錄是否存在
if (!srcDir.exists()) {
logger.debug("複製目錄失敗，源目錄 " + srcDirName + " 不存在!");
return false;
}
// 判斷源目錄是不是目錄
else if (!srcDir.isDirectory()) {
logger.debug("複製目錄失敗，" + srcDirName + " 不是一個目錄!");
return false;
}
// 若是目標文件夾名不以文件分隔符結尾，自動添加文件分隔符
String descDirNames = descDirName;
if (!descDirNames.endsWith(File.separator)) {
descDirNames = descDirNames + File.separator;
}
File descDir = new File(descDirNames);
// 若是目標文件夾存在
if (descDir.exists()) {
if (coverlay) {
// 容許覆蓋目標目錄
logger.debug("目標目錄已存在，準備刪除!");
if (!FileUtils.delFile(descDirNames)) {
logger.debug("刪除目錄 " + descDirNames + " 失敗!");
return false;
}
} else {
logger.debug("目標目錄複製失敗，目標目錄 " + descDirNames + " 已存在!");
return false;
}
} else {
// 建立目標目錄
logger.debug("目標目錄不存在，準備建立!");
if (!descDir.mkdirs()) {
logger.debug("建立目標目錄失敗!");
return false;
}
}
boolean flag = true;
// 列出源目錄下的全部文件名和子目錄名
File[] files = srcDir.listFiles();
for (int i = 0; i < files.length; i++) {
// 若是是一個單個文件，則直接複製
if (files[i].isFile()) {
flag = FileUtils.copyFile(files[i].getAbsolutePath(),
descDirName + files[i].getName());
// 若是拷貝文件失敗，則退出循環
if (!flag) {
break;
}
}
// 若是是子目錄，則繼續複製目錄
if (files[i].isDirectory()) {
flag = FileUtils.copyDirectory(files[i]
.getAbsolutePath(), descDirName + files[i].getName());
// 若是拷貝目錄失敗，則退出循環
if (!flag) {
break;
}
}
}
if (!flag) {
logger.debug("複製目錄 " + srcDirName + " 到 " + descDirName + " 失敗!");
return false;
}
logger.debug("複製目錄 " + srcDirName + " 到 " + descDirName + " 成功!");
return true;
}
/** * * 刪除文件，能夠刪除單個文件或文件夾 * * @param fileName 被刪除的文件名 * @return 若是刪除成功，則返回true，否是返回false */
public static boolean delFile(String fileName) {
File file = new File(fileName);
if (!file.exists()) {
logger.debug(fileName + " 文件不存在!");
return true;
} else {
if (file.isFile()) {
return FileUtils.deleteFile(fileName);
} else {
return FileUtils.deleteDirectory(fileName);
}
}
}
/** * * 刪除單個文件 * * @param fileName 被刪除的文件名 * @return 若是刪除成功，則返回true，不然返回false */
public static boolean deleteFile(String fileName) {
File file = new File(fileName);
if (file.exists() && file.isFile()) {
if (file.delete()) {
logger.debug("刪除文件 " + fileName + " 成功!");
return true;
} else {
logger.debug("刪除文件 " + fileName + " 失敗!");
return false;
}
} else {
logger.debug(fileName + " 文件不存在!");
return true;
}
}
/** * * 刪除目錄及目錄下的文件 * * @param dirName 被刪除的目錄所在的文件路徑 * @return 若是目錄刪除成功，則返回true，不然返回false */
public static boolean deleteDirectory(String dirName) {
String dirNames = dirName;
if (!dirNames.endsWith(File.separator)) {
dirNames = dirNames + File.separator;
}
File dirFile = new File(dirNames);
if (!dirFile.exists() || !dirFile.isDirectory()) {
logger.debug(dirNames + " 目錄不存在!");
return true;
}
boolean flag = true;
// 列出所有文件及子目錄
File[] files = dirFile.listFiles();
for (int i = 0; i < files.length; i++) {
// 刪除子文件
if (files[i].isFile()) {
flag = FileUtils.deleteFile(files[i].getAbsolutePath());
// 若是刪除文件失敗，則退出循環
if (!flag) {
break;
}
}
// 刪除子目錄
else if (files[i].isDirectory()) {
flag = FileUtils.deleteDirectory(files[i]
.getAbsolutePath());
// 若是刪除子目錄失敗，則退出循環
if (!flag) {
break;
}
}
}
if (!flag) {
logger.debug("刪除目錄失敗!");
return false;
}
// 刪除當前目錄
if (dirFile.delete()) {
logger.debug("刪除目錄 " + dirName + " 成功!");
return true;
} else {
logger.debug("刪除目錄 " + dirName + " 失敗!");
return false;
}
}
/** * 建立單個文件 * @param descFileName 文件名，包含路徑 * @return 若是建立成功，則返回true，不然返回false */
public static boolean createFile(String descFileName) {
File file = new File(descFileName);
if (file.exists()) {
logger.debug("文件 " + descFileName + " 已存在!");
return false;
}
if (descFileName.endsWith(File.separator)) {
logger.debug(descFileName + " 爲目錄，不能建立目錄!");
return false;
}
if (!file.getParentFile().exists()) {
// 若是文件所在的目錄不存在，則建立目錄
if (!file.getParentFile().mkdirs()) {
logger.debug("建立文件所在的目錄失敗!");
return false;
}
}
// 建立文件
try {
if (file.createNewFile()) {
logger.debug(descFileName + " 文件建立成功!");
return true;
} else {
logger.debug(descFileName + " 文件建立失敗!");
return false;
}
} catch (Exception e) {
e.printStackTrace();
logger.debug(descFileName + " 文件建立失敗!");
return false;
}
}
/** * 建立目錄 * @param descDirName 目錄名,包含路徑 * @return 若是建立成功，則返回true，不然返回false */
public static boolean createDirectory(String descDirName) {
String descDirNames = descDirName;
if (!descDirNames.endsWith(File.separator)) {
descDirNames = descDirNames + File.separator;
}
File descDir = new File(descDirNames);
if (descDir.exists()) {
logger.debug("目錄 " + descDirNames + " 已存在!");
return false;
}
// 建立目錄
if (descDir.mkdirs()) {
logger.debug("目錄 " + descDirNames + " 建立成功!");
return true;
} else {
logger.debug("目錄 " + descDirNames + " 建立失敗!");
return false;
}
}
/** * 寫入文件 * @param file 要寫入的文件 */
public static void writeToFile(String fileName, String content, boolean append) {
try {
FileUtils.write(new File(fileName), content, "utf-8", append);
logger.debug("文件 " + fileName + " 寫入成功!");
} catch (IOException e) {
logger.debug("文件 " + fileName + " 寫入失敗! " + e.getMessage());
}
}
/** * 寫入文件 * @param file 要寫入的文件 */
public static void writeToFile(String fileName, String content, String encoding, boolean append) {
try {
FileUtils.write(new File(fileName), content, encoding, append);
logger.debug("文件 " + fileName + " 寫入成功!");
} catch (IOException e) {
logger.debug("文件 " + fileName + " 寫入失敗! " + e.getMessage());
}
}
/** * 獲目錄下的文件列表 * @param dir 搜索目錄 * @param searchDirs 是不是搜索目錄 * @return 文件列表 */
public static List<String> findChildrenList(File dir, boolean searchDirs) {
List<String> files = Lists.newArrayList();
for (String subFiles : dir.list()) {
File file = new File(dir + "/" + subFiles);
if (((searchDirs) && (file.isDirectory())) || ((!searchDirs) && (!file.isDirectory()))) {
files.add(file.getName());
}
}
return files;
}
}
複製代碼
public static boolean createFile(String descFileName)：建立文件。public static boolean createDirectory(String descDirName)：建立目錄。public static boolean copyFile(String srcFileName, String descFileName)：複製文件。public static boolean copyDirectory(String srcDirName, String descDirName)：複製目錄。public static boolean deleteFile(String fileName)：刪除文件。public static boolean deleteDirectory(String dirName)：刪除目錄。public static void writeToFile(String fileName, String content, boolean append)：向文件中寫入內容。
0三、網絡套接字——Socket
雖然網絡套接字（Socket）並不在java.io包下，但它和輸入輸出流密切相關。File和Socket是兩組主要的數據傳輸方式。
Socket是描述計算機之間完成相互通訊的一種抽象。能夠把 Socket比做爲兩個城市之間的交通工具，有了交通工具（高鐵、汽車），就能夠在城市之間來回穿梭了。交通工具備多種，每種交通工具也有相應的交通規則。Socket也同樣，也有多種。大部分狀況下，咱們使用的都是基於TCP/IP的套接字——一種穩定的通訊協議。
假設主機A是客戶端，主機B是服務器端。客戶端要與服務器端通訊，客戶端首先要建立一個Socket實例，操做系統將爲這個Socket實例分配一個沒有被使用的本地端口號，並建立一個套接字數據結構，直到這個鏈接關閉。
示例以下。
Socket socket = new Socket(serverIp, serverPort);
BufferedInputStream in = new BufferedInputStream(socket.getInputStream());
BufferedOutputStream out = new BufferedOutputStream(socket.getOutputStream());
複製代碼
與之對應的，服務端須要建立一個ServerSocket實例，以後調用accept()方法進入阻塞狀態，等待客戶端的請求。當一個新的請求到來時，將爲這個鏈接建立一個新的套接字數據結構。
示例以下。
ServerSocket server = new ServerSocket(port);
Socket socket = server.accept();
InputStream in = new BufferedInputStream(socket.getInputStream());
OutputStream out = new BufferedOutputStream(socket.getOutputStream());
複製代碼
Socket一旦打通，就能夠經過InputStream和OutputStream進行數據傳輸了。
0四、壓縮
Java I/O 支持壓縮格式的數據流。在Socket通訊中，我經常使用GZIPOutputStream和GZIPInputStream來對數據流進行簡單地壓縮和解壓。
壓縮的好處就在於可以減少網絡傳輸中數據的體積。代碼以下。
package com.cmower.common.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
/** * 壓縮解壓 */
public class CompressionUtil {
public static byte[] compress(byte[] data) throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] result = null;
GZIPOutputStream zos = new GZIPOutputStream(bos);
zos.write(data);
zos.finish();
zos.flush();
result = bos.toByteArray();
zos.close();
bos.close();
return result;
}
public static byte[] deCompress(byte[] in) throws IOException {
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
GZIPInputStream inStream = new GZIPInputStream(new ByteArrayInputStream(in));
byte[] buf = new byte[1024];
while (true) {
try {
int size = inStream.read(buf);
if (size <= 0)
break;
outStream.write(buf, 0, size);
} catch (Exception e) {
e.printStackTrace();
break;
}
}
inStream.close();
outStream.close();
return outStream.toByteArray();
}
}
複製代碼
上一篇：Java註解（Annotation）：請不要小看我！
下一篇：Java：併發不易，先學會用
微信搜索「沉默王二」公衆號，關注後回覆「免費視頻」獲取 500G 高質量教學視頻（已分門別類）。
相關文章
- 1. 「挑三揀四」地學一學Java I/O
- 2. Java IO學習總結（四）
- 3. Java IO學習筆記一
- 4. IO流學習(Java)(一)
- 5. Java IO學習一：File類
- 6. Java Netty 學習(一)- IO學習筆記
- 7. JAVA IO學習
- 8. java學習——IO
- 9. java io 學習
- 10. Java io流學習總結(三)
- 更多相關文章...
- • 您已經學習了 XML Schema，下一步學習什麼呢？ - XML Schema 教程
- • 我們已經學習了 SQL，下一步學習什麼呢？ - SQL 教程
- • Kotlin學習（一）基本語法
- • Tomcat學習筆記（史上最全tomcat學習筆記）
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 「挑三揀四」地學一學Java I/O
- 2. Java IO學習總結（四）
- 3. Java IO學習筆記一
- 4. IO流學習(Java)(一)
- 5. Java IO學習一：File類
- 6. Java Netty 學習(一)- IO學習筆記
- 7. JAVA IO學習
- 8. java學習——IO
- 9. java io 學習
- 10. Java io流學習總結(三)