Ⅰ java的幾種IO流讀取文件方式
一、超類：
位元組流： InputStream（讀入流） OutputStream(寫出流）
字元流： Reader（字元 讀入流） Writer （字元寫出流）
二、文件操作流
位元組流： FileInputStream ，FileOutputStream
字元流： FileReader, FileWriter(用法與位元組流基本相同，不寫）
//1.指定要讀 的文件目錄及名稱
File file =new File("文件路徑");
//2.創建文件讀入流對象
FileInputStream fis =new FileInputStream(file);
//3.定義結束標志,可用位元組數組讀取
int i =0 ;
while((i = fis.read())!=-1){
//i 就是從文件中讀取的位元組，讀完後返回-1
}
//4.關閉流
fis.close();
//5.處理異常
//1.指定要寫到的文件目錄及名稱
File file =new File("文件路徑");
//2.創建文件讀入流對象
FileOutputStream fos =new FileOutputStream(file);
//3.定義結束標志
fos.write(要寫出的位元組或者位元組數組);
//4.刷新和關閉流
fos.flush();
fos.close();
//5.處理異常
三、緩沖流：
位元組緩沖流： BufferedInputStream,BufferedOutputStream
字元緩沖流：BufferedReader ,BufferedWriter
緩沖流是對流的操作的功能的加強，提高了數據的讀寫效率。既然緩沖流是對流的功能和讀寫效率的加強和提高，所以在創建緩沖流的對象時應該要傳入要加強的流對象。
//1.指定要讀 的文件目錄及名稱
File file =new File("文件路徑");
//2.創建文件讀入流對象
FileInputStream fis =new FileInputStream(file);
//3.創建緩沖流對象加強fis功能
BufferedInputStream bis =new BufferedInputStream(fis);
//4.定義結束標志,可用位元組數組讀取
int i =0 ;
while((i = bis.read())!=-1){
//i 就是從文件中讀取的位元組，讀完後返回-1
}
//5.關閉流
bis.close();
//6.處理異常
//1.指定要寫到的文件目錄及名稱
File file =new File("文件路徑");
//2.創建文件讀入流對象
FileOutputStream fos =new FileOutputStream(file);
//3.創建緩沖流對象加強fos功能
BufferedOutputStream bos=new BufferedOutputStream(fos);
//4.向流中寫入數據
bos.write(要寫出的位元組或者位元組數組);
//5.刷新和關閉流
bos.flush();
bos.close();
//6.處理異常
四、對象流
ObjectInputStream ,ObjectOutputStream
不同於以上兩種類型的流這里只能用位元組對對象進行操作原因可以看上篇的編碼表比照原理
ObjectOutputStream對象的序列化：
將java程序中的對象寫到本地磁碟里用ObjectOutputStream
eg：將Person類的對象序列化到磁碟
創建Person類
注1：此類要實現Serializable介面，此介面為標志性介面
注2：此類要有無參的構造函數
注3：一旦序列化此類不能再修改
class Person implements Serializable{
public Person(){}
}
2.創建對象流對象
註：要增強功能可以將傳入文件緩沖流
ObjectOutputStream oos =new ObjectOutputStream(
new FileOutputStream(new File("文件路徑")));
3.寫入對象 ，一般會將對象用集合存儲起來然後直接將集合寫入文件
List<Person> list =new ArrayList<>();
list.add(new Person());
...(可以添加多個）
oos.writeObject(list);
4.關閉流，處理異常
oos.flush();
oos.close();
五、轉換流：
這類流是用於將字元轉換為位元組輸入輸出，用於操作字元文件，屬於字元流的子類，所以後綴為reader，writer；前綴inputstream，outputstream；
注 ：要傳入位元組流作為參賽
InputStreamReader: 字元轉換輸出流
OutputStreamWriter：字元轉換輸入流
//1.獲取鍵盤輸入的位元組流對象
inInputStream in =Stream.in;
/*2.用轉換流將位元組流對象轉換為字元流對象，方便調用字元緩沖流的readeLine()方法*/
InputStreamReader isr =new InputStreamReader(in);
/*5.創建字元轉換輸出流對象osw，方便把輸入的字元流轉換為位元組輸出到本地文件。*/
OutputStreamWriter osw =new OutputStreamWriter(new
FileOutputStream(new File("文件名")));
/*3.現在isr是字元流，可以作為參數傳入字元緩沖流中*/
BufferedReader br =new BufferedReader(isr);
/*4.可以調用字元緩沖流br的readLine()方法度一行輸入文本*/
String line =null;
while((line =br.readLine()){
osw.write(line);//osw是字元流對象，可以直接操作字元串
}
註：InputStreamReader isr =new InputStreamReader(new "各種類型的位元組輸入流都行即是：後綴為InputStream就行");
OutputStreamWriter osw =new OutputStreamWriter(new
"後綴為OutputStream就行");
六、區別記憶
1.對象流是可以讀寫幾乎所有類型的只要是對象就行，而位元組字元流，只能讀寫單個位元組字元或者位元組字元數組，以上沒有讀寫位元組字元數組的；注意對象流只有位元組流！
2.字元和位元組循環讀入的結束條件int i=0; (i =fis.read())!=-1
用字元數組復制文件(fr 讀入流 ，fw寫出流）,位元組流也是相同的用法
int i = 0; char[] c = new char[1024];
while((i = fr.reade()) !=-1)）{
fw.write(c,0,i);
}
123456
3.對象流裡面套緩沖流的情景：
new ObjectInputStream(new BufferedInputStream(new FileInputStream(new File(「文件路徑」))));
4.記憶流及其功能的方法：
前綴表示功能，後綴表示流的類型；
比如說FileInputStream 前綴：File,表示操作的磁碟，後綴：intputstream,表示是位元組輸入流。
同理 FileReader：表示操作文件的字元流
ObjectInputStream ：操作對象的位元組輸入流
5.拓展：獲取鍵盤輸入的字元的緩沖流的寫法：
new BufferedReader(new InputStreamReader(System.in)));
將位元組以字元形式輸出到控制台的字元緩沖流的寫法：
new BufferedWriter（ new OutputStreamWriter（System.out))
Ⅱ java 中簡述使用流進行讀寫文本文件的步驟
InputStream
三個基本的讀方法
abstract int read() ： 讀取一個位元組數據，並返回讀到的數據，如果返回-1，表示讀到了輸入流的末尾。
int read(byte[] b) ： 將數據讀入一個位元組數組，同時返回實際讀取的位元組數。如果返回-1，表示讀到了輸入流的末尾。
int read(byte[] b, int off, int len) ：將數據讀入一個位元組數組，同時返回實際讀取的位元組數。如果返回-1，表示讀到了輸入流的末尾。off指定在數組b中存放數據的起始偏移位置；len指定讀取的最大位元組數。
OutputStream
三個基本的寫方法
abstract void write(int b) ：往輸出流中寫入一個位元組。
void write(byte[] b) ：往輸出流中寫入數組b中的所有位元組。
void write(byte[] b, int off, int len) ：往輸出流中寫入數組b中從偏移量off開始的len個位元組的數據。
其它方法
void flush() ：刷新輸出流，強制緩沖區中的輸出位元組被寫出。
void close() ：關閉輸出流，釋放和這個流相關的系統資源。
Ⅲ Java中對文件進行讀寫操作的基本類是什麼
Java.io包中包括許多類提供許多有關文件的各個方面操作。x0dx0a1 輸入輸出抽象基類InputStream/OutputStream ，實現文件內容操作的基本功能函數read()、 write()、close()、skip()等；一般都是創建出其派生類對象（完成指定的特殊功能）來實現文件讀寫。在文件讀寫的編程過程中主要應該注意異常處理的技術。 x0dx0a2 FileInputStream/FileOutputStream： x0dx0a用於本地文件讀寫（二進制格式讀寫並且是順序讀寫，讀和寫要分別創建出不同的文件流對象）； x0dx0a本地文件讀寫編程的基本過程為： x0dx0a① 生成文件流對象（對文件讀操作時應該為FileInputStream類，而文件寫應該為FileOutputStream類）； x0dx0a② 調用FileInputStream或FileOutputStream類中的功能函數如read()、write(int b)等）讀寫文件內容； x0dx0a③ 關閉文件（close()）。 x0dx0a3 PipedInputStream/PipedOutputStream： x0dx0a用於管道輸入輸出（將一個程序或一個線程的輸出結果直接連接到另一個程序或一個線程的輸入埠，實現兩者數據直接傳送。操作時需要連結）； x0dx0a4管道的連接： x0dx0a方法之一是通過構造函數直接將某一個程序的輸出作為另一個程序的輸入，在定義對象時指明目標管道對象 x0dx0aPipedInputStream pInput=new PipedInputStream(); x0dx0aPipedOutputStream pOutput= new PipedOutputStream(pInput); x0dx0a方法之二是利用雙方類中的任一個成員函數 connect()相連接 x0dx0aPipedInputStream pInput=new PipedInputStream(); x0dx0aPipedOutputStream pOutput= new PipedOutputStream(); x0dx0apinput.connect(pOutput); x0dx0a5 管道的輸入與輸出： x0dx0a輸出管道對象調用write()成員函數輸出數據（即向管道的輸入端發送數據）；而輸入管道對象調用read()成員函數可以讀起數據（即從輸出管道中獲得數據）。這主要是藉助系統所提供的緩沖機制來實現的。 x0dx0a6隨機文件讀寫： x0dx0aRandomAccessFile類（它直接繼承於Object類而非InputStream/OutputStream類），從而可以實現讀寫文件中任何位置中的數據（只需要改變文件的讀寫位置的指針）。 x0dx0a隨機文件讀寫編程的基本過程為： x0dx0a① 生成流對象並且指明讀寫類型； x0dx0a② 移動讀寫位置； x0dx0a③ 讀寫文件內容； x0dx0a④ 關閉文件。x0dx0ax0dx0a七里河團隊答疑助人,希望我的回答對你有所幫助
Ⅳ java怎麼實現讀取一個文件，拿到二進制流
Java讀取二進制文件，以位元組為單位進行讀取，還可讀取圖片、音樂文件、視頻文件等，
在Java中，提供了四種類來對文件進行操作，分別是InputStream OutputStream Reader Writer ，前兩種是對位元組流的操作，後兩種則是對字元流的操作。
示例代碼如下：
public static void readFileByBytes(String fileName){
File file = new File(fileName);
InputStream in = null;
try {
System.out.println("一次讀一個");
// 一次讀一個位元組
in = new FileInputStream(file);
int tempbyte;
while ((tempbyte = in.read()) != -1) {
System.out.write(tempbyte);
}
in.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
Ⅳ java中,文件輸入操作由下面哪個
Java 操作文件包括了兩個層面：
在文件系統的層面上來操作文件，包括創建文件、刪除文件、創建目錄、拷貝文件等等。
操作文件里保存的數據，包括讀文件、寫文件。
1. 在文件系統層面操作文件
1.1 File 類介紹
Java 中通過 java.io.File 類來對一個文件（包括目錄）進行抽象的描述。不過有 File 對象，並不代表對應的文件真實存在。
1.2 File 常見屬性
屬性 修飾符及類型 說明
pathSeparator static String 依賴於系統的路徑分隔符，String 類型的表示
pathSeparator static char 依賴於系統的路徑分隔符，char 類型的表示
1.3 File 構造方法
構造方法 說明
File(File parent, String child) 根據父目錄+孩子文件路徑，創建一個新的 File 實例
File(String pathname) 根據文件路徑創建一個新的 File 實例，路徑可以是絕對路徑或者相對路徑
File(String parent, String child) 根據父目錄路徑+孩子文件路徑，創建一個新的 File 實例
1.4 File 常用方法
方法 返回值類型 說明 注意
getParent() String 返回 File 對象的父目錄文件路徑
getName() String 返回 File 對象的純文件名稱
getPath() String 返回 File 對象的文件路徑
getAbsolutePath() String 返回 File 對象的絕對路徑
getCanonicalPath() String 返回 File 對象的修飾過的絕對路徑 如果絕對路徑的值為：d:/././test.txt，那麼修飾過的絕對路徑就為：d:/test.txt。
exists() boolean 判斷 File 對象描述的文件是否真實存在
isDirectory() boolean 判斷 File 對象代表的文件是否是一個目錄
isFile() boolean 判斷 File 對象代表的文件是否是一個普通文件
createNewFile() boolean 根據 File 對象，自動創建一個空文件。成功創建後返回 true 如果文件路徑不正確或者沒有許可權，則可能創建失敗。
delete() boolean 根據 File 對象，刪除該文件。成功刪除後返回 true 如果文件路徑不正確或者沒有許可權，則可能刪除失敗。
deleteOnExit() void 根據 File 對象，標注文件將被刪除，刪除動作會到 JVM 運行結束時才會進行
list() String[] 返回 File 對象代表的目錄下的所有文件名
listFiles() File[] 返回 File 對象代表的目錄下的所有文件，以 File 對象表示
mkdir() boolean 創建 File 對象代表的目錄
mkdirs() boolean 創建 File 對象代表的目錄，如果必要，會創建中間目錄
renameTo(File dext) boolean 重命名文件或移動文件，當目錄為空時也可以重命名目錄
canRead() boolean 判斷用戶是否對文件有可讀許可權
canWrite() boolean 判斷用戶是否對文件有可寫許可權
2. 操作文件里的數據
文件內容的操作包括讀文件和寫文件，而對於這兩種操作 Java 又提供了兩種不同的類：
讀類 寫類 說明
InputStream OutputStream 位元組流，針對二進制文件進行讀寫，操作基本單位是位元組
Reader Writer 字元流，針對文本文件進行讀寫，操作基本單位是字元
位元組流： 它處理單元為1個位元組，操作位元組和位元組數組，存儲的是二進制文件，如果是音頻文件、圖片、歌曲，就用位元組流。
字元流： 它處理的單元為2個位元組的 Unicode 字元，分別操作字元、字元數組或字元串，字元流是由 Java 虛擬機將位元組轉化為2個位元組的 Unicode 字元為單位的字元而成的，如果是關繫到中文（文本）的，用字元流更好。
所有文件都是以位元組的形式儲存，在磁碟上保留的並不是文件的字元而是先把字元編碼成位元組，再儲存這些位元組到磁碟。在讀取文件（特別是文本文件）時，也是一個位元組一個位元組地讀取以形成位元組序列。
位元組流可用於任何類型的對象，包括二進制對象，而字元流只能處理字元或者字元串。
位元組流提供了處理任何類型的 IO 操作的功能，但它不能直接處理 Unicode 字元，而字元流就可以。
位元組流在操作的時候本身不會用到緩沖區的，是與文件本身直接操作的；而字元流在操作的時候會使用到緩沖區的。
其中 InputStream/OutputStream 和 Reader/Writer 都實現了 Closeable 介面，所以可以不主動通過 close 方法去關閉該資源，而是通過代碼可讀性更高的 try-with-resource 操作在 try 中的內容結束後，無論是否有異常都關閉該資源。
使用 OutputStream 或 writer 打開文件默認會清空之前的文件內容
2.1 操作位元組流數據
2.1.1 InputStream
InputStream 是一個抽象類，使用時需要使用具體的實現類。InputStream 的實現類很多，針對不同的輸入設備都可以對應一個實現類，其中針對文件讀取的實現類是 FileInputStream。
FileInputStream 構造方法：
構造方法 說明
FileInputStream(File file) 利用 File 構造對應文件輸入流
FileInputStream(String name) 利用文件路徑構造對應文件輸入流
InputStream 核心方法：
方法 返回值類型 說明
read() int 一次讀取一個位元組的數據，如果返回 -1 表示文件讀完了
read(byte[] b) int 一次最多讀取 b.length 位元組的數據到 b 中，返回值為實際讀到的位元組數量，如果返回 -1 表示文件讀完了
read(byte[] b, int off, int len) int 一次最多讀取 len 個位元組到 b 中，並從 off 的位置開始存放，返回值為實際讀到的位元組數量，如果返回 -1 表示文件讀完了
close() void 關閉位元組流
為什麼 read 方法的返回值是 Int 類型？
對於 read 方法的返回值，當讀取的是數字和英文時，返回值是對應的 ascii 碼；當讀取的是漢字時，返回的是漢字的機內碼，比如使用的是 GBK 編碼方式，返回的就是 GBK 的內部編碼。read 方法每次從 inputstream 中讀取一個位元組，而一個位元組是8位，但當最高位是1的時候，二進制對應的 ascii 碼值就是復數，而 ascii 是沒有負數的，所以用 byte 類型表示不了。並且 11111111 對應的十進制值是 -1，而返回 -1 表示文件讀取完畢了，則後面的數據就不會讀了，因此 byte 類型不適合，int 類型則可以解決這個問題。
示例代碼： 使用 read() 方法讀取文件內容
public class Demo1 {
public static void main(String[] args) throws IOException {
File file = new File("./test.txt");
StringBuilder sb = new StringBuilder();
try (InputStream inputStream = new FileInputStream(file)){
while(true) {
int b = inputStream.read();
if(b == -1){
break;
}
sb.append((char) b);
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(sb.toString());
}
}
登錄後復制
示例代碼： 使用 read(byte[] b) 方法讀取文件內容
public class Demo1 {
public static void main(String[] args) throws IOException {
File file = new File("./test.txt");
byte[] buffer = new byte[1024];
try (InputStream inputStream = new FileInputStream(file)){
while(true) {
int len = inputStream.read(buffer);
if(len == -1){
break;
}
String s = new String(buffer, 0, len, "utf-8");
System.out.println(s);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
登錄後復制
2.1.2 OutputStream
OutputStream 是一個抽象類，使用時需要使用具體的實現類。OutputStream 的實現類很多，針對不同的輸出設備都可以對應一個實現類，其中針對文件讀取的實現類是 FileOutputStream。
FileOutputStream 構造方法：
構造方法 說明
FileOutputStream(File file) 利用 File 構造對應文件輸出流
FileOutputStream(String name) 利用文件路徑構造對應文件輸出流
FileOutputStream(File file, boolean append) append 表示是否追加數據到文件的末尾，為 true 表示追加，為 false 表示情空之前的內容重新加入
FileOutputStream(String name, boolean append) append 表示是否追加數據到文件的末尾，為 true 表示追加，為 false 表示情空之前的內容重新加入
OutputStream 核心方法：
方法 返回值類型 說明
write() int 一次寫入一個位元組的數據
write(byte[] b) int 一次最多寫入 b.length 位元組的數據到 b 中，返回值為實際寫入的位元組數量
write(byte[] b, int off, int len) int 一次最多寫入 len 個位元組到 b 中，並從 off 的位置開始存放，返回值為實際寫入到的位元組數量
close() void 關閉位元組流
示例代碼：
public class Demo1{
public static void main(String[] args) throws IOException {
File in = new File("./in.txt");
File out = new File("./out.txt");
byte[] buffer = new byte[1024];
try (InputStream inputStream = new FileInputStream(in);
OutputStream outputStream = new FileOutputStream(out)) {
while (true) {
int len = inputStream.read(buffer);
if (len == -1) {
break;
}
outputStream.write(buffer, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
登錄後復制
2.1.3 BufferedInputStream
BufferedInputStream 也是 InputStream 的具體實現類，相比於 FileInputStream 優化了系統調用，即通俗解釋為：將數據保存了緩存區，但是減少磁碟 IO 並不是 BufferedInputStream 來做的，而是 OS 來做的。OS 根據局部性原理，會預讀部分的數據到內存緩存區，這樣下次 IO 如果讀取數據在緩存命中了，就不需要等待磁碟的定址，而是直接返回數據，效率就會快很多。
2.1.4 BufferedOutputStream
BufferedOutPutStream 也是 OutputStream 的具體實現類，相比於 FileOutputStream 優化了系統調優，即每次寫數據的時候，都會將數據放入緩存區中，等緩存區滿了之後，才會一次性寫入到磁碟中，大大提高了效率。
2.2 操作字元流數據
2.2.1 Reader
Reader 是實現字元輸入流的一種類型，其本身屬於一個抽象類，使用時需要使用具體的實現類。Reader 的實現類很多，針對不同的輸入設備都可以對應一個實現類，其中針對文件讀取的實現類是 FileReader。Reader 的使用方式和 InputStream 相仿。
示例代碼：
public class Demo2 {
public static void main(String[] args) throws FileNotFoundException {
File file = new File("./test.txt");
StringBuilder sb = new StringBuilder();
try (Reader reader = new FileReader(file)) {
while (true) {
int read = reader.read();
if (read == -1) {
break;
}
sb.append((char) read);
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(sb.toString());
}
}
登錄後復制
2.2.2 Writer
Writer 是實現字元輸出流的一種類型，其本身屬於一個抽象類，使用時需要使用具體的實現類。Writer 的實現類很多，針對不同的輸出設備都可以對應一個實現類，其中針對文件讀取的實現類是 FileWriter。Writer 的使用方式和 OutputStream 相仿。
FileWriter 構造方法：
構造方法 說明
FileWriter(File file) 利用 File 構造對應文件輸出流
FileWriter(String name) 利用文件路徑構造對應文件輸出流
FileWriter(File file, boolean append) append 表示是否追加數據到文件的末尾，為 true 表示追加，為 false 表示情空之前的內容重新加入
FileWriter(String name, boolean append) append 表示是否追加數據到文件的末尾，為 true 表示追加，為 false 表示情空之前的內容重新加入
示例代碼：
public class Demo2 {
public static void main(String[] args) throws FileNotFoundException {
File in = new File("./in.txt");
File out = new File("./out.txt");
try (Reader reader = new FileReader(in);
Writer writer = new FileWriter(out)) {
while (true) {
int read = reader.read();
if (read == -1) {
break;
}
writer.write(read);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
登錄後復制
2.2.3 BufferedReader
BufferedReader 也是 Reader 的具體實現類，相比於 Reader 優化了系統調用，即通俗解釋為：將數據保存了緩存區，但是減少磁碟 IO 並不是 BufferedReader 來做的，而是 OS 來做的。OS 根據局部性原理，會預讀部分的數據到內存緩存區，這樣下次 IO 如果讀取數據在緩存命中了，就不需要等待磁碟的定址，而是直接返回數據，效率就會快很多。
2.2.4 BufferedWriter
BufferedWriter 也是 Writer 的具體實現類，相比於 Writer 優化了系統調優，即每次寫數據的時候，都會將數據放入緩存區中，等緩存區滿了之後，才會一次性寫入到磁碟中，大大提高了效率。
2.3 Scanner 和 PrintWriter
Java 標准庫中提供的 Scanner 和 PrintWriter 類能夠像文件中讀取文本數據和寫入文本數據。
2.3.1 Scanner
java.util.Scanner 類常用來從控制台中讀取字元串和基本類型的數值。Scanner 可以將輸入的值以空白字元分割標記。
Scanner 的構造方法：
構造方法 說明
Scanner(Readable source) 創建一個 Scanner，從指定的可讀資源中掃描標記，包括文件、文件路徑、字元串等。
Scanner(InputStream source) 創建一個 Scanner，從指定的位元組輸入流中掃把標記。
Scanner 常用方法：
方法 返回值類型 說明
hasNext() boolean 如果 Scanner 還要更多的數據可讀取，則返回 true
next() String 從 Scanner 中讀取下一個標記作為字元串返回
nextLine() String 從 Scanner 中讀取一行，以換行符結束
close() void 關閉 Scanner
System.in 為系統自帶的標准輸入流，該流是一直打開並准備提供輸入數據。通常，這個流對應於鍵盤輸入或由主機環境或用戶指定的另一個輸入源。
使用 Scanner 沒有必要關閉輸入文件，但是關閉能夠釋放文件佔有的資源。
示例代碼：
public class Demo3 {
public static void main(String[] args) {
try (Scanner scanner = new Scanner(new File("./test.txt"))) {
while (scanner.hasNext()) {
String s = scanner.next();
System.out.println(s);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
登錄後復制
2.3.2 PrintWriter
java.io.PrintWriter 類可用來創建一個文件並向文本文件中寫入數據。通常使用 System.out.println 向控制台輸入文本。
PrintWriter 構造方法：
構造方法 說明
PrintWriter(Writer out) 為指定的字元輸入流創建一個 PrintWriter。
PrintWriter(Writer out, boolean autoFlush) 為指定的字元輸入流創建一個 PrintWriter，如果 autoFlush 為 true，則 println、printf 或 format 方法將刷新輸出緩沖區。
PrintWriter(OutputStream out) 為指定的位元組輸入流創建一個 PrintWriter。
PrintWriter(OutputStream out, boolean autoFlush) 為指定的位元組輸入流創建一個 PrintWriter，如果 autoFlush 為 true，則 println、printf 或 format 方法將刷新輸出緩沖區。
PrintWriter(String fileName) 為指定的文件路徑創建一個 PrintWriter
PrintWriter(String fileName, String csn) 為指定的文件路徑創建一個 PrintWriter，並且通過指定的字元集對字元進行編碼。
PrintWriter(File file) 為指定的文件對象創建一個 PrintWriter。
PrintWriter(File file, String scn) 為指定的文件對象創建一個 PrintWriter，並且通過指定的字元集對字元進行編碼。
PrintWriter 常用方法：
方法 返回值類型 說明
print(String s) void 將字元串寫入文件中
println(String s) void 將字元串寫入文件中，多列印一個換行
printf(String s) void 將字元串寫入文件中，按照指定格式寫文件中
System.out 為系統自帶的 printStream，表示控制台的標准 Java 對象，通過它能夠向控制台輸入數據。
使用 PrintWriter 必須使用 close 方法關閉文件，或者使用 try-with-resources 自動關閉資源，狗則數據就不能正確地保存在文件中。
示例代碼：
Ⅵ java 文件讀寫流
讀寫是兩個不同的分支，通常都是分開單獨使用的。
可以通過BufferedReader 流的形式進行流緩存，之後通過readLine方法獲取到緩存的內容。
BufferedReader bre = null;
try {
String file = "D:/test/test.txt";
bre = new BufferedReader(new FileReader(file));//此時獲取到的bre就是整個文件的緩存流
while ((str = bre.readLine())!= null) // 判斷最後一行不存在，為空結束循環
{
System.out.println(str);//原樣輸出讀到的內容
}；
備註： 流用完之後必須close掉，如上面的就應該是：bre.close()，否則bre流會一直存在，直到程序運行結束。
可以通過「FileOutputStream」創建文件實例，之後過「OutputStreamWriter」流的形式進行存儲，舉例：
OutputStreamWriter pw = null;//定義一個流
pw = new OutputStreamWriter(new FileOutputStream(「D:/test.txt」),"GBK");//確認流的輸出文件和編碼格式，此過程創建了「test.txt」實例
pw.write("我是要寫入到記事本文件的內容");//將要寫入文件的內容，可以多次write
pw.close();//關閉流
備註：文件流用完之後必須及時通過close方法關閉，否則會一直處於打開狀態，直至程序停止，增加系統負擔。
Ⅶ java 中簡述使用流進行讀寫文本文件的步驟
一、Java IO學習基礎之讀寫文本文件
Java的IO操作都是基於流進行操作的，為了提高讀寫效率一般需要進行緩沖。
簡單的示常式序如下：
/**
* 讀出1.txt中的內容，寫入2.txt中
*
*/
import java.io.*;
public class ReadWriteFile{
public static void main(String[] args){
try{
File read = new File("c:\\1.txt");
File write = new File("c:\\2.txt");
BufferedReader br = new BufferedReader(
new FileReader(read));
BufferedWriter bw = new BufferedWriter(
new FileWriter(write));
String temp = null;
temp = br.readLine();
while(temp != null){
//寫文件
bw.write(temp + "\r\n"); //只適用Windows系統
//繼續讀文件
temp = br.readLine();
}
bw.close();
br.close();
}catch(FileNotFoundException e){ //文件未找到
System.out.println (e);
}catch(IOException e){
System.out.println (e);
}
}
}
以上是一個比較簡單的基礎示例。本文上下兩部分都是從網上摘抄，合並在一起，方便下自己以後查找。
二、Java IO學習筆記+代碼
文件對象的生成和文件的創建
/*
* ProcessFileName.java
*
* Created on 2006年8月22日, 下午3:10
*
* 文件對象的生成和文件的創建
*/
package study.iostudy;
import java.io.*;
public class GenerateFile
{
public static void main(String[] args)
{
File dirObject = new File("d:\\mydir");
File fileObject1 = new File("oneFirst.txt");
File fileObject2 = new File("d:\\mydir", "firstFile.txt");
System.out.println(fileObject2);
try
{
dirObject.mkdir();
}catch(SecurityException e)
{
e.printStackTrace();
}
try
{
fileObject2.createNewFile();
fileObject1.createNewFile();
}catch(IOException e)
{
e.printStackTrace();
}
}
}
文件名的處理
/*
* ProcessFileName.java
*
* Created on 2006年8月22日, 下午3:29
*
* 文件名的處理
*/
package study.iostudy;
import java.io.*;
/*
* 文件名的處理
* String getName(); 獲得文件的名稱，不包含文件所在的路徑。
* String getPath(); 獲得文件的路徑。
* String getAbsolutePath(); 獲得文件的絕對路徑。
* String getParent(); 獲得文件的上一級目錄的名稱。
* String renameTo(File newName); 按參數中給定的完整路徑更改當前的文件名。
* int compareTo(File pathName); 按照字典順序比較兩個文件對象的路徑。
* boolean isAbsolute(); 測試文件對象的路徑是不是絕對路徑。
*/
public class ProcesserFileName
{
public static void main(String[] args)
{
File fileObject1 = new File("d:\\mydir\\firstFile.txt");
File fileObject2 = new File("d:\\firstFile.txt");
boolean pathAbsolute = fileObject1.isAbsolute();
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ");
System.out.println("There are some information of fileObject1's file name:");
System.out.println("fileObject1: " + fileObject1);
System.out.println("fileObject2: " + fileObject2);
System.out.println("file name: " + fileObject1.getName());
System.out.println("file path: " + fileObject1.getPath());
System.out.println("file absolute path: " + fileObject1.getAbsolutePath());
System.out.println("file's parent directory: " + fileObject1.getParent());
System.out.println("file's absoulte path: " + pathAbsolute);
int sameName = fileObject1.compareTo(fileObject2);
System.out.println("fileObject1 compare to fileObject2: " + sameName);
fileObject1.renameTo(fileObject2);
System.out.println("file's new name: " + fileObject1.getName());
}
}
測試和設置文件屬性
/*
* SetterFileAttribute.java
*
* Created on 2006年8月22日, 下午3:51
*
* 測試和設置文件屬性
*/
package study.iostudy;
import java.io.*;
public class SetterFileAttribute
{
/*
* File類中提供的有關文件屬性測試方面的方法有以下幾種：
* boolean exists(); 測試當前文件對象指示的文件是否存在。
* boolean isFile(); 測試當前文件對象是不是文件。
* boolean isDirectory(); 測試當前文件對象是不是目錄。
* boolean canRead(); 測試當前文件對象是否可讀。
* boolean canWrite(); 測試當前文件對象是否可寫。
* boolean setReadOnly(); 將當前文件對象設置為只讀。
* long length(); 獲得當前文件對象的長度。
*/
public static void main(String[] args)
{
File dirObject = new File("d:\\mydir");
File fileObject = new File("d:\\mydir\\firstFile.txt");
try
{
dirObject.mkdir();
fileObject.createNewFile();
}catch(IOException e)
{
e.printStackTrace();
}
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ");
System.out.println("there are some information about property of file object:");
System.out.println("file object : " + fileObject);
System.out.println("file exist? " + fileObject.exists());
System.out.println("Is a file? " + fileObject.isFile());
System.out.println("Is a directory?" + fileObject.isDirectory());
System.out.println("Can read this file? " + fileObject.canRead());
System.out.println("Can write this fie? " + fileObject.canWrite());
long fileLen = fileObject.length();
System.out.println("file length: " +fileLen);
boolean fileRead = fileObject.setReadOnly();
System.out.println(fileRead);
System.out.println("Can read this file? " + fileObject.canRead());
System.out.println("Can write this fie? " + fileObject.canWrite());
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ");
}
}
文件操作方法
/*
* FileOperation.java
*
* Created on 2006年8月22日, 下午4:25
*
* 文件操作方法
*/
package study.iostudy;
import java.io.*;
/*
* 有關文件操作方面的方法有如下幾種:
* boolean createNewFile(); 根據當前的文件對象創建一個新的文件。
* boolean mkdir(); 根據當前的文件對象生成一目錄，也就是指定路徑下的文件夾。
* boolean mkdirs(); 也是根據當前的文件對象生成一個目錄，
* 不同的地方在於該方法即使創建目錄失敗，
* 也會成功參數中指定的所有父目錄。
* boolean delete(); 刪除當前的文件。
* void deleteOnExit(); 當前Java虛擬機終止時刪除當前的文件。
* String list(); 列出當前目錄下的文件。
*/
public class FileOperation
* 找出一個目錄下所有的文件
package study.iostudy;
import java.io.*;
public class SearchFile
{
public static void main(String[] args)
{
File dirObject = new File("D:\\aa");
Filter1 filterObj1 = new Filter1("HTML");
Filter2 filterObj2 = new Filter2("Applet");
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println("list HTML files in directory: " + dirObject);
String[] filesObj1 = dirObject.list(filterObj1);
for (int i = 0; i < filesObj1.length; i++)
{
File fileObject = new File(dirObject, filesObj1[i]);
System.out.println(((fileObject.isFile())
? "HTML file: " : "sub directory: ") + fileObject);
}
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
String[] filesObj2 = dirObject.list(filterObj2);
for (int i = 0; i < filesObj2.length; i++)
{
File fileObject = new File(dirObject, filesObj2[i]);
System.out.println(((fileObject.isFile())
? "htm file: " : "sub directory: ") + fileObject);
}
}
}
class Filter1 implements FilenameFilter
{
String fileExtent;
Filter1(String extentObj)
{
fileExtent = extentObj;
}
public boolean accept(File dir, String name)
{
return name.endsWith("." + fileExtent);
}
}
class Filter2 implements FilenameFilter
{
String fileName;
Filter2(String fileName)
{
this.fileName = fileName;
字元流處理
* ProcesserCharacterStream.java
* 字元流處理
*
* java.io包中加入了專門用於字元流處理的類，這些類都是Reader和Writer類的子類，
* Reader和Writer是兩個抽象類，只提供了一系列用於字元流處理的介面，不能生成這
* 兩個類的實例。
* java.io包中用於字元流處理的最基本的類是InputStreamReader和OutputStreamWriter，
* 用來在位元組流和字元流之間作為中介。
*
* 下面是InputStreamReader類和OutputStreamWriter類的常用方法：
*
* public InputStreamReader(InputStream in)
* 根據當前平台預設的編碼規范，基於位元組流in生成一個輸入字元流。
* public InputStreamReader(InputStream in, String sysCode)throws UnSupportedEncodingException
* 按照參數sysCode指定的編碼規范，基於位元組流in構造輸入字元流，如果不支持參數sysCode中指定的編碼規范，就會產生異常。
* public OutputStreamWriter(OutputStream out)
* 根據當前平台預設的編碼規范，基於位元組流out生成一個輸入字元流。
* public OutputStreamWriter(OutputStream out, String sysCode) throws UnsupportedEncodingException
* 按照參數sysCode指定的編碼規范，基於位元組流out構造輸入字元流，如果不支持參數sysCode中指定的編碼規范，就會產生異常。
* public String getEncoding()
* 獲得當前字元流使用的編碼方式。
* public void close() throws IOException
* 用於關閉流。
* public int read() throws IOException
* 用於讀取一個字元。
* public int read(char[] cbuf, int off, int len)
* 用於讀取len個字元到數組cbuf的索引off處。
* public void write(char[] cbuf, int off, int len) throws IOException
* 將字元數組cbuf中從索引off處開始的len個字元寫入輸出流。
* public void write(int c) throws IOException
* 將單個字元寫入輸入流。
* public void write(String str, int off, int len) throws IOException
* 將字元串str中從索引off位置開始的ltn個字元寫入輸出流。
*
* 此外，為了提高字元流處理的效率，在Java語言中，引入了BufferedReader和BufferWriter類，這兩個類對字元流進行塊處理。
* 兩個類的常用方法如下：
* public BufferedReader(Reader in)
* 用於基於普通字元輸入流in生成相應的緩沖流。
* public BufferedReader(Reader in, int bufSize)
* 用於基於普通字元輸入流in生成相應的緩沖流，緩沖區大小為參數bufSize指定。
* public BufferedWriter(Writer out)
* 用於基於普通字元輸入流out生成相應的緩沖流。
* public BufferedWriter(Writer out, int bufSize)
* 用於基於普通字元輸入流out生在相應緩沖流，緩沖流大小為參數bufSize指定。
* public String readLine() throws IOException
* 用於從輸入流中讀取一行字元。
* public void newLine() throws IOException
* 用於向字元輸入流中寫入一行結束標記，值得注意的是，該標記不是簡單的換行符"\n"，而是系統定義的屬性line.separator。
在上面的程序中，我們首先聲明了FileInputStream類對象inStream和
* FileOutputStream類的對象outStream，接著聲明了BufferInputStream
* 類對象bufObj、BufferedOutputStream類對象bufOutObj、
* DataInputStream類對象dataInObj以及PushbackInputStream類對象pushObj，
* 在try代碼塊中對上面這些對象進行初始化，程序的目的是通過BufferedInputStream
* 類對象bufInObj和BufferedOutputStream類對象bufOutObj將secondFile.txt
* 文件中內容輸出到屏幕，並將該文件的內容寫入thirdFile.txt文件中，值得注意的是，
* 將secondFile.txt文件中的內容輸出之前，程序中使用
* "System.out.println(dataInObj.readBoolean());" 語句根據readBoolean()結果
* 輸出了true，而secondFile.txt文件開始內容為「Modify」，和一個字元為M，
* 因此輸出的文件內容沒有「M」字元，thirdFile.txt文件中也比secondFile.txt
* 文件少第一個字元「M」。隨後，通過PushbackInputStream類對象pushObj讀取
* thirdFile.txt文件中的內容，輸出讀到的字元，當讀到的不是字元，輸出回車，將字元
* 數組pushByte寫回到thirdFile.txt文件中，也就是「ok」寫迴文件中。
* 對象串列化
* 對象通過寫出描述自己狀態的數值來記錄自己，這個過程叫做對象串列化。對象的壽命通
* 常是隨著生成該對象的程序的終止而終止，在有些情況下，需要將對象的狀態保存下來，然後
* 在必要的時候將對象恢復，值得注意的是，如果變數是另一個對象的引用，則引用的對象也要
* 串列化，串列化是一個遞歸的過程，可能會涉及到一個復雜樹結構的串列化，比如包括原有對
* 象，對象的對象等。
* 在java.io包中，介面Serializable是實現對象串列化的工具,只有實現了Serializable
* 的對象才可以被串列化。Serializable介面中沒有任何的方法，當一個類聲明實現Seriali-
* zable介面時，只是表明該類遵循串列化協議，而不需要實現任何特殊的方法。
* 在進行對象串列化時，需要注意將串列化的對象和輸入、輸出流聯系起來，首先通過對
* 象輸出流將對象狀態保存下來，然後通過對象輸入流將對象狀態恢復。
Ⅷ Java字元流和位元組流對文件操作的區別
Java字元流是處理字元（Char）對象用的，位元組流是處理位元組（Byte）對象用的。處理的目標對象不同，處理方法也就不一樣了。
字元流處理的基本單位是字元（Java中的字元是16位的），輸入流以Reader為基礎，輸出流以Writer為基礎；
位元組流的基本單位是位元組（Java中的位元組是8位的），輸入流以 InputStream為基礎，輸出流以 OutputStream為基礎；
字元流在輸入時可以按字元讀取，也可以按行讀取，會去掉回車換行，常用於讀取字元數據；
而位元組流按位元組讀取，不作任何處理，常用於讀取二進制數據。
Java中的字元在內部都是使用Unicode進行表示的，因此，要正確讀取字元數據，需要知道字元的編碼字元集，字元流提供編碼字元集的指定，如果不指定使用系統默認的方式對字元數據進行編碼轉換，這個編碼字元集不正確，會造成讀進來的地字元出現亂碼。
位元組流雖然是讀取二進制數據用的，但也可以讀取字元文件，按位元組進行處理，讀進來之後可以根據編碼字元集進行轉換，也可以變成字元串。
Ⅸ Java字元流和位元組流對文件操作的區別
一、java的IO流分兩種流 :
1、位元組流 InputStream OutputStream
2、字元流 Reader Writer
他們都是抽象類
二、他們的區別：
1、字元流處理的單元為2個位元組的Unicode字元，分別操作字元、字元數組或字元串，而位元組流處理單元為1個位元組，操作位元組和位元組數組。所以字元流是由Java虛擬機將位元組轉化為2個位元組的Unicode字元為單位的字元而成的，所以它對多國語言支持性比較好！如果是音頻文件、圖片、歌曲，就用位元組流好點，如果是關繫到中文（文本）的，用字元流好點.
所有文件的儲存是都是位元組（byte）的儲存，在磁碟上保留的並不是文件的字元而是先把字元編碼成位元組，再儲存這些位元組到磁碟。在讀取文件（特別是文本文件）時，也是一個位元組一個位元組地讀取以形成位元組序列.
2、位元組流可用於任何類型的對象，包括二進制對象，而字元流只能處理字元或者字元串； 位元組流提供了處理任何類型的IO操作的功能，但它不能直接處理Unicode字元，而字元流就可以。
位元組流轉換成字元流可以用 InputSteamReader OutputStreamWriter
//位元組流轉換成InputStreamReader
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
//InputStreamReader 轉換成帶緩存的bufferedReader
BufferedReader bufferedReader = new BufferedReader(inputSteamReader);
Ⅹ Java 文件流操作
利用讀取流讀取到數據然後輸出流輸出就可以了
BufferedReader bufr = new BufferedReader(new FileReader("D:\\test.txt"));
PrintWriter pw = new PrintWriter(new FileWriter("D:\\test1.txt",true);
String line = null;
while((line = bufr.readLine)!=null){
pw.println(line);
}
bufr.close;
pw.close;