java io常用類總結
讀寫資料是java開發過程中經常需要做的，本篇文章將我們平時常用的java io處理類做個總結，同時給出相關demo。
可以看得出來，JAVA IO主要有這四個類InputStream、OutputStream、Reader、Writer來處理，要處理位元組流的就用InputStream、OutputStream，要處理字元流，就用Reader、Writer，現實中根據需要，我們選擇他們的相關子類進行資料的讀寫。給出類圖：
根據處理媒介的不同進行劃分
下面給出常用的IO處理demo
/**
* 專案名稱(中文)
* 專案名稱(英文)
* Copyright (c) 2018 ChinaPay Ltd. All Rights Reserved.
*/
package com.figo.study.test;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Serializable;
import java.io.StringWriter;
import java.io.Writer;
/**
* IO操作總結 IO按讀寫劃分可以分為輸入流和輸出流 IO，
* 按處理媒介來劃分可以分為位元組流和字元流
* 另外為了處理不同的資料型別，輸入輸出流可以層層包裝
* 比如處理檔案資料的FileInputStream,FileOutputStream.
* 另外處理網路的IO一般使用Socket，jdk1.4及以上版本又推出了NIO， NIO non-blocking
* io非阻塞的開源專案比如MINA,NETTY，本demo討論io
*
* @author figo
* @version 1.0 2018-6-12 改訂
* @since 1.0
*/
public class TestIO {
/**
* .
*
* @param args
*/
public static void main(String[] args) {
// testInputStreamAndOutputStream();
// testReaderAndWriter();
// testBufferReaderAndWriter();
testObjectInputStreamAndObjectOutputStream();
}
/**
* 位元組流輸入FileInputStream輸出FileOutputStream 檔案超大有可能會OOM
*/
public static void testInputStreamAndOutputStream() {
try {
// 寫入資料
String hello = new String("hello world!");
byte[] byteArray = hello.getBytes();
File file = new File("E:\\學習資料\\java學習\\testIO\\iostream.txt");
// 因為是用位元組流來寫媒介，所以對應的是OutputStream
// 又因為媒介物件是檔案，所以用到子類是FileOutputStream
OutputStream os = new FileOutputStream(file);
os.write(byteArray);
os.close();
// 讀取資料
byte[] byteArrayNew = new byte[(int) file.length()];
// 因為是用位元組流來讀媒介，所以對應的是InputStream
// 又因為媒介物件是檔案，所以用到子類是FileInputStream
InputStream is = new FileInputStream(file);
int size = is.read(byteArrayNew);
System.out.println("大小:" + size + ";內容:" + new String(byteArray));
is.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 字元流輸入FileReader輸出FileWriter 檔案超大有可能會OOM
*/
public static void testReaderAndWriter() {
try {
// 寫入資料
String hello = new String("hello worLd!");
File file = new File(
"E:\\學習資料\\java學習\\testIO\\readerAndwriter.txt");
// 因為是用字元流來讀媒介，所以對應的是Writer，又因為媒介物件是檔案，所以用到子類是FileWriter
Writer os = new FileWriter(file);
os.write(hello);
os.close();
// 讀取資料
// 因為是用字元流來讀媒介，所以對應的是Reader
// 又因為媒介物件是檔案，所以用到子類是FileReader
Reader reader = new FileReader(file);
char[] byteArray = new char[(int) file.length()];
int size = reader.read(byteArray);
System.out.println("大小:" + size + ";內容:" + new String(byteArray));
reader.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 快取字元輸入BufferedReader和輸出BufferedWriter 快取一定大小字元流後再一次性輸入輸出
* 每次一個字元一個字元的讀寫肯定影響效能的 每次讀寫快取大小的資料量，一般不會OOM，批量讀寫明顯會提高效率
*/
public static void testBufferReaderAndWriter() {
try {
// 寫入資料
String hello = new String("hello worLd!");
File file = new File(
"E:\\學習資料\\java學習\\testIO\\bufferReaderAndWriter.txt");
// 因為是用字元流來讀媒介，所以對應的是Writer，又因為媒介物件是檔案，所以用到子類是FileWriter
Writer os = new FileWriter(file);
// 外部再包裝一層buffer 不設定緩衝大小，預設8k，也可以自己通過這個建構函式指定
// BufferedWriter(Writer paramWriter, int paramInt)
BufferedWriter bw = new BufferedWriter(os);
bw.write(hello);
// 寫一行換一行
bw.newLine();
bw.close();
os.close();
// 讀取資料
// 因為是用字元流來讀媒介，所以對應的是Reader
// 又因為媒介物件是檔案，所以用到子類是FileReader
Reader reader = new FileReader(file);
// 外部再包裝一層buffer 不設定緩衝大小，預設8k，也可以自己通過這個建構函式指定
// BufferedReader(Reader paramReader, int paramInt)
BufferedReader bufferReader = new BufferedReader(reader);
String tempString = null;
while ((tempString = bufferReader.readLine()) != null) {
// 顯示行號
System.out.println(tempString);
}
bufferReader.close();
reader.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 物件讀寫到檔案ObjectInputStream和ObjectOutputStream .
*/
public static void testObjectInputStreamAndObjectOutputStream() {
try {
//定義一個物件
Student student=new Student();
student.setName("abc");
student.setSex("男");
student.setGrade("一年級");
student.setAddress("上海");
student.setMobile("15812345678");
//物件寫入檔案
FileOutputStream fos=new FileOutputStream("E:\\學習資料\\java學習\\testIO\\Student.txt");
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(student);
oos.flush();
oos.close();
//從檔案讀取物件
FileInputStream fis=new FileInputStream("E:\\學習資料\\java學習\\testIO\\Student.txt");
ObjectInputStream ois=new ObjectInputStream(fis);
Student studentNew=(Student)ois.readObject();
System.out.println(studentNew.toString());
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 一定記得實現Serializable，否則無法序列化成位元組流
* @author figo
* .
*/
public static class Student implements Serializable{
/**
* .
*/
private static final long serialVersionUID = 1L;
String name;
String sex;
String grade;
String address;
String mobile;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getGrade() {
return grade;
}
public void setGrade(String grade) {
this.grade = grade;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getMobile() {
return mobile;
}
public void setMobile(String mobile) {
this.mobile = mobile;
}
@Override
public String toString() {
return "Student [name=" + name + ", sex=" + sex + ", grade="
+ grade + ", address=" + address + ", mobile=" + mobile
+ "]";
}
}
}
/**
*
* 字元轉位元組流InputStreamReader和OutputStreamWriter .
* 這兩個類的好處是可以指定讀取和寫入的字元編碼
*/
public static void testInputStreamReaderAndOutputStreamWriter() {
try {
//寫檔案
String filePathAndName = "E:\\學習資料\\java學習\\testIO\\InputStreamReaderWriter.txt";
File fileWrite = new File(filePathAndName);
if (!fileWrite.exists()) {
fileWrite.createNewFile();
}
OutputStreamWriter write = new OutputStreamWriter(new FileOutputStream(fileWrite), "UTF-8");
BufferedWriter writer = new BufferedWriter(write);
String fileContent = "hello,world，你好世界！";
writer.write(fileContent);
writer.close();
//讀檔案
File fileRead = new File(filePathAndName);
if (fileRead.isFile() && fileRead.exists()) {
InputStreamReader read = new InputStreamReader(
new FileInputStream(fileRead), "UTF-8");
BufferedReader reader = new BufferedReader(read);
String line;
StringBuffer sringBuffer=new StringBuffer();
while ((line = reader.readLine()) != null) {
//這樣也可以指定編碼，但是會new很多的String物件
// String newLine=new String(line.getBytes("UTF-8"));
sringBuffer.append(line);
}
System.out.println(fileContent);
read.close();
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
另外我們在處理檔案讀寫經常用到java.io.File，這個類比較簡單，給出常用方法大家看看就會了：
好了，大家可以自己動手試一下。
參考文章
Java IO
https://blog.csdn.net/suifeng3051/article/details/48344587
Java的IO操作---File類
https://www.cnblogs.com/alsf/p/5746480.html