字節輸出流與文件字節輸出流
- OutputStream及FileOutputStream
import java.io.FileOutputStream;
import java.io.IOException;
/*
java.io.OutputStream:字節輸出流
此抽象類是表示輸出字節流的所有類的父類
定義了一些子類共性的成員方法：
- public void close():關閉此輸出流並釋放與此流相關聯的任何系統資源
- public void flush():刷新此輸出流並強制任何緩沖的輸出字節被寫出
- public void write(byte[] b):將b.length字節從指定的字節數組寫入此輸出流
- public void write(byte[] b, int off, int len):從指定的字節數組寫入len字節，從偏移量off開始輸出到此輸出流
- public abstract void write(int b):將指定的字節輸出流
java.io.FileOutputStream extends OutputStream
FileOutputStream:文件字節輸出流
作用：把內存中的數據寫入到硬盤的文件中
構造方法：
FileOutputStream(String name)創建一個向具有指定名稱的文件中寫入數據的輸出文件流
FileOutputStream(File file)創建一個向指定File對象表示的文件中寫入數據的文件輸出流
參數：寫入數據的目的
String name:目的地是一個文件的路徑
File file:目的地是一個文件
構造方法的作用：
1.創建一個FileOutputStream對象
2.會根據構造方法中傳遞的文件/文件路徑，創建一個空的文件
3.會把FileOutputStream對象指向創建好的文件
寫入數據的原理（內容-->硬盤）
java程序-->JVM(java虛擬機)-->os(操作系統)-->os調用寫數據的方法-->把數據寫入到文件中
字節輸出流的使用步驟（重點）：
1.創建一個FileOutputStream對象，構造方法中傳遞寫入數據的目的地
2.調用FileOutputStream對象中的方法write，把數據寫入到文件中
3.釋放資源（流使用會占用一定的內存，使用完畢要把內存清空，提高程序的效率）
*/
public class Demo01OutputStream {
public static void main(String[] args) throws IOException {
//1.創建一個FileOutputStream對象，構造方法中傳遞寫入數據的目的地(可以輸入相對路徑，輸入完整路徑可避免錯誤)
FileOutputStream fos = new FileOutputStream("D:\\environment\\java_project\\a.txt");
//2.調用FileOutputStream對象中的方法write，把數據寫入到文件中
//public abstract void write(int b):將指定的字節輸出流
fos.write(97);
//3.釋放資源（流使用會占用一定的內存，使用完畢要把內存清空，提高程序的效率）
fos.close();
}
}
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
/*
一次寫多個字節的方法：
- public void write(byte[] b):將b.length字節從指定的字節數組寫入此輸出流
- public void write(byte[] b, int off, int len):從指定的字節數組寫入len字節，從偏移量off開始輸出到此輸出流
*/
public class Demo02OutputStream {
public static void main(String[] args) throws IOException {
//創建FileOutputStream對象，構造方法中綁定要寫入數據的目的地
FileOutputStream fos = new FileOutputStream("D:\\environment\\java_project\\javase\\b.txt");
//調用FileOutputStream對象中的方法write，把數據寫入到文件中
//在文件中顯示100，寫3個字節
fos.write(49);
fos.write(48);
fos.write(48);
/*
public void write(byte[] b):將b.length字節從指定的字節數組寫入此輸出流
一次寫多個字節：
如果寫的第一個字節是正數（0-127），那么顯示的時候會查詢ASCII表
如果寫的第一個字節是負數，那第一個字節會和第二個字節，兩個字節組成一個中文顯示，查詢系統默認碼表（GBK）
*/
byte[] btes = {65,66,67,68,69};//ABCDE
//byte[] btes1 = {-65,-66,-67,68,69};//烤紻E
fos.write(btes);
//fos.write(btes1);
/*
public void write(byte[] b, int off, int len):把字節數組的一部分寫入到文件中
int off:數組的開始索引
int len:寫幾個字節
*/
fos.write(btes,1,2);//BC
/*
寫入字符串的方法：可以使用String類中的方法把字符串，轉換為字節數組
byte[] getBytes() 把字符串轉換為字節數組
*/
byte[] bytes2 = "你好".getBytes();
System.out.println(Arrays.toString(bytes2));//[-28, -67, -96, -27, -91, -67]
fos.write(bytes2);
//釋放資源
fos.close();
}
}
import java.io.FileOutputStream;
import java.io.IOException;
/*
追加寫/續寫：使用兩個參數的構造方法
FileOutputStream(String name, boolean append)創建一個向具有指定name的文件中寫入數據的輸出文件流
FileOutputStream(File file, boolean append)創建一個向指定File對象表示的文件中寫入數據的文件輸出流
參數：
String name，File file:寫入數據的目的地
boolean append:追加寫開關
true:創建對象不會覆蓋原文件，繼續在文件的末尾追加寫數據
false:創建一個新文件，覆蓋原文件
寫換行：寫換行符號
windows:\r\n
linux:/n
mac:/r
*/
public class Demo03OutputStream {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("D:\\environment\\java_project\\javase\\c.txt",true);
for (int i = 0; i < 10; i++) {
fos.write("你好".getBytes());
fos.write("\r\n".getBytes());
}
fos.close();
}
}
字節輸入流與文字字節輸入流
import java.io.FileInputStream;
import java.io.IOException;
/*
java.io.InputStream:字節輸入流
此抽象類是表示字節輸入流的所有類的超類
定義了所有子類共性的方法：
int read()從輸入流中讀取數據的下一個字節
int read(byte[] b)從輸入流中讀取一定數量的字節，並將其存儲在緩沖區數組b中
void close()關閉此輸入流並釋放與該流關聯的所有系統資源
java.io.FileInputStream extends InputStream
FileInputStream:文件字節輸入流
作用：把硬盤文件中的數據，讀取到內存中使用
構造方法：
FileInputStream(String name)
FileInputStream(File file)
參數：讀取文件的數據源
String name：文件的路徑
File file：文件
構造方法的作用：
1.會創建一個FileInputStream
2.會把FileInputStream對象指定構造方法中要讀取的文件
讀取數據的原理（硬盤-->內存）
java程序-->JVM-->OS讀取數據的方法-->讀取文件
字節輸入流的使用步驟（重點）：
1.創建FileInputStream對象，構造方法中綁定要讀取的數據源
2.使用FileInputStream對象中的方法read，讀取文件
3.釋放資源
*/
public class Demo01InputStream {
public static void main(String[] args) throws IOException {
//1.創建FileInputStream對象，構造方法中綁定要讀取的數據源
FileInputStream fis = new FileInputStream("D:\\environment\\java_project\\javase\\a.txt");
//2.使用FileInputStream對象中的方法read，讀取文件
//int read()讀取文件中的一個字節並返回，讀取到文件的末尾返回-1
/*int len = fis.read();
System.out.println(len);//97 a
len = fis.read();
System.out.println(len);//98 b
len = fis.read();
System.out.println(len);//99 c
len = fis.read();
System.out.println(len);//-1
len = fis.read();
System.out.println(len);//-1*/
/*
發現以上讀取文件是一個重復的過程，所以可以使用循環優化
不知道文件中有多少字節，使用while循環
while循環結束條件，讀取到-1的時候結束
布爾表達式(len = fis.read())!=-1
1.fis.read():讀取一個字節
2.len = fis.read():把讀取到的字節賦值給變量len
3.(len = fis.read())!=-1:判斷變量len是否不等於-1
*/
int len = 0;//記錄讀取到的字節
while ((len = fis.read())!=-1){
System.out.print((char)len);//abc，將數字再轉換成字符
}
/*
while (fis.read()!=-1){
System.out.print(fis.read());//將每次跳過一個字符讀取下一個
}
*/
//3.釋放資源
fis.close();
}
}
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
/*
字節輸入流一次讀取多個字節的方法：
int read(byte[] b)從輸入流中讀取一定數量的字節，並將其存儲在緩沖區數組b中
明確兩件事情：
1.方法的參數byte[]的作用？
起到緩沖作用，存儲每次讀取到的多個字節
數組的長度一般定義為1024（1kb）或者1024的整數倍
2.方法的返回值int是什么？
每次讀取的有效字節個數
String類的構造方法
String(byte[] bytes):把字節數組轉換為字符串
String(byte[] bytes, int offset, int length):把字節數組的一部分轉換為字符串 offset：數組的開始索引 length：轉換的字節個數
*/
public class Demo02InputStream {
public static void main(String[] args) throws IOException {
//創建FileInputStream對象，構造方法中綁定要讀取的數據源
FileInputStream fis = new FileInputStream("D:\\environment\\java_project\\javase\\b.txt");
//使用FileInputStream對象中的方法read讀取文件
//int read(byte[] b)從輸入流中讀取一定數量的字節，並將其存儲在緩沖區數組b中
/*byte[] bytes = new byte[2];
int len = fis.read(bytes);
System.out.println(len);//2
System.out.println(Arrays.toString(bytes));//[65, 66]
System.out.println(new String(bytes));//AB
len = fis.read(bytes);
System.out.println(len);//2
System.out.println(new String(bytes));//CD
len = fis.read(bytes);
System.out.println(len);//1
System.out.println(new String(bytes));//ED
len = fis.read(bytes);
System.out.println(len);//-1
System.out.println(new String(bytes));//ED*/
/*
發現以上讀取是一個重復的過程，可以使用循環優化
不知道文件中有多少字節，所以使用while循環
while循環結束的條件，讀取到-1結束
*/
byte[] bytes = new byte[1024];//存儲讀取到的多個字節
int len = 0;//記錄每次讀取到的有效字節個數
while ((len = fis.read(bytes))!=-1){
//String(byte[] bytes, int offset, int length):把字節數組的一部分轉換為字符串 offset：數組的開始索引 length：轉換的字節個數
System.out.println(new String(bytes,0,len));
}
//釋放資源
fis.close();
}
}
文件復制
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
文件復制練習：一讀一寫
明確：
數據流：c:\\1.jpg
數據的目的地：d:\\1.jpg
文件復制的步驟：
1.創建一個字節輸入流對象，構造方法中綁定要讀取的數據流
2.創建一個字節輸出流對象，構造方法中綁定要寫入的目的地
3.使用字節輸入流對象中的方法read讀取文件
4.使用字節輸出流中的方法write，把讀取到的字節寫入到目的地的文件中
5.釋放資源
*/
public class Demo01CopyFile {
public static void main(String[] args) throws IOException {
long s = System.currentTimeMillis();
//1.創建一個字節輸入流對象，構造方法中綁定要讀取的數據流
FileInputStream fis = new FileInputStream("D:\\environment\\java_project\\javase\\c.txt");
//2.創建一個字節輸出流對象，構造方法中綁定要寫入的目的地
FileOutputStream fos = new FileOutputStream("D:\\environment\\java_project\\javase\\d.txt");
//一次讀取一個字節寫入一個字節的方式
//3.使用字節輸入流對象中的方法read讀取文件
/*int len = 0;
while ((len = fis.read())!=-1){
//4.使用字節輸出流中的方法write，把讀取到的字節寫入到目的地的文件中
fos.write(len);
}*/
//使用數組緩沖讀取多個字節，寫入多個字節
byte[] bytes = new byte[1024];
//3.使用字節輸入流對象中的方法read讀取文件
int len = 0;
while ((len = fis.read(bytes))!=-1){
//4.使用字節輸出流中的方法write，把讀取到的字節寫入到目的地的文件中
fos.write(bytes,0,len);
}
//5.釋放資源（先關寫的，后關閉讀的；如果寫完了，肯定讀完了）
fos.close();
fis.close();
long e = System.currentTimeMillis();
//使用System類的方法currentTimeMillis()計算程序運行共耗時多久
System.out.println("復制文件共耗時："+(e-s)+"毫秒");
}
}
