字節流

阿新 • • 發佈：2017-06-22

緩沖並且定量 pri 列表用兩個 true spa 第一個

IO流:
I:input,輸入,讀取到內存
O:Output,輸出,寫入文件
流:數據流(字符,字節)
分類:
流向:
輸入:字節輸入流(FileInputStream),字符輸入流(FileReader)
輸出:字節輸出流(FileOutputStream),字符輸入流(FileWriter)
種類:
字符,字節

java.io.OutputStream:字節輸出流,是所有字節輸出流的父類

公共的成員方法:
abstract void write(int b) 寫入一個字節
void write(byte[] b) 寫入字節數組
void write(byte[] b, int off, int len) 寫入字節數組,off是開始的索引,len寫幾個
void close() 關閉此輸出流並釋放與此流有關的所有系統資源。

java.io.FileOutputStream:文件字節輸出流
作用:把內存中的數據,以字節的方式,寫入到文件中

構造方法:

FileOutputStream(File file) 創建一個向指定 File 對象表示的文件中寫入數據的文件輸出流。
FileOutputStream(String name) 創建一個向具有指定名稱的文件中寫入數據的輸出文件流。
構造方法的參數:
file:文件
name:文件的路徑
都是寫入數據的目的地

特點:

如果構造方法中指定的文件或者文件的路徑所指向的文件不存在,構造方法就會創建一個文件
如果,沒有打開追加寫的開關,文件已經存在,則會覆蓋

使用步驟:
1.創建一個字節輸出流對象FileOutputStream,綁定數據的目的地
2.使用FileOutputStream中的write方法,把數據寫入到文件中
3.釋放資源

流寫入數據的時候,會找到JVM,JVM會調用系統本地的方法完成寫,使用完流要使用和系統有關的資源(釋放內存)

void write(byte[] b) 寫入字節數組
void write(byte[] b, int off, int len) 寫入字節數組,off是開始的索引,len寫幾個

 1 public static void main(String[] args) throws IOException {
 2         File file = new File("b.txt");
 3         FileOutputStream fos = new FileOutputStream(file);
 4         //寫入100到文件中,100是3個字節
 5         fos.write(49);
 6         fos.write(48);
 7         fos.write(48);
 8         
 9         /*
10          * void write(byte[] b) 寫入字節數組
11          * 寫入數據的時候,如果一次寫多個字節
12          * 寫入的字節是正數:會查詢ASC||表
13          * 寫入的字節是,第一個字節是負數,第二個字節可以是正數,也可以是負數,查詢的時候就會把兩個字節組成一個中文,查詢GBK編碼表
14          */
15         byte[] bytes = {65,66,67,68,69};//ABCDE
16         //byte[] bytes = {-65,-66,-67,68,88};//烤紻
17         
18         fos.write(bytes);
19         
20         //void write(byte[] b, int off, int len) 寫入字節數組,off是開始的索引,len寫幾個
21         fos.write(bytes, 1, 2);
22         
23         /*
24          * 快速寫入字節數組的方法
25          * String類中有一個方法
26          * byte[] getBytes(String charsetName) :把字符串轉換為字節數組 
27          */
28         byte[] bytes2 = "你好".getBytes();
29         System.out.println(Arrays.toString(bytes2));//[-60, -29, -70, -61]
30         fos.write(bytes2);
31         
32         fos.close();
33     }

void write(byte[] b) 寫入字節數組
寫入數據的時候,如果一次寫多個字節
寫入的字節是正數:會查詢ASC||表
寫入的字節是,第一個字節是負數,第二個字節可以是正數,也可以是負數,查詢的時候就會把兩個字節組成一個中文,查詢GBK編碼表

快速寫入字節數組的方法
String類中有一個方法
byte[] getBytes(String charsetName) :把字符串轉換為字節數組

文件的續寫和換行:
換行:
windows:\r\n
linux:\n
mac:\r
追加寫:使用兩個參數的構造方法
FileOutputStream(File file, boolean append)
FileOutputStream(String name, boolean append)
參數:
File file,String name:寫入數據的目的地
boolean append:追加寫的開關,true:可以追加寫(往之前的文件,繼續寫內容),fasle:不能追加寫(覆蓋之前的文件)

java.io.InputStream:字節輸入流,是所有字節輸入流的父類

公共的成員方法:
int read():讀取一個字節並返回，沒有字節返回-1.
int read(byte[]): 讀取一定量的字節數，並存儲到字節數組中，返回讀取到的字節數。
void close() 關閉此文件輸入流並釋放與此流有關的所有系統資源。

java.io.FileInputStream:文件字節輸入流
作用:把文件中的數據,以字節的方式讀取到內存中

構造方法:
FileInputStream(String name)
FileInputStream(File file)
參數:讀取的哪個文件(數據源)
String name:字符串的文件路徑
File file:讀取的文件

使用步驟:
1.創建字節輸入流對象FileInputStream,並且綁定數據源
2.使用FileInputStream對象中的方法read,讀取文件
3.釋放資源

int read(byte[]): 讀取一定量的字節數，並存儲到字節數組中，返回讀取到的字節數。
明確:
1.byte數組的作用:起到緩沖作用,一次可以往數組中緩沖多個字節,可以提高讀取效率
byte數組的長度:一般定義為1024(一kb字節)或者1024的整數倍
2.返回值int是什麽:每次讀取的有效字節個數

文件的復制:讀取文件采用一次讀取一個字節的方式,寫入文件采用一次寫一個字節的方式

數據源:c:\\1.jpg
數據目的地:d:\\1.jpg

操作步驟:
1.創建字節輸入流對象FileInputStream,並且綁定數據源
2.創建字節輸出流對象FileOutputStream,並且綁定數據目的地
3.使用FileInputStream中的方法read,一次讀取一個字節
4.使用FileOutputStream中的方法write,一次寫一個字節
5.釋放資源(先關寫,後關讀)

 1 public static void main(String[] args) throws IOException {
 2         long s = System.currentTimeMillis();
 3         //1.創建字節輸入流對象FileInputStream,並且綁定數據源
 4         FileInputStream fis = new FileInputStream("c:\\1.jpg");
 5         //2.創建字節輸出流對象FileOutputStream,並且綁定數據目的地
 6         FileOutputStream fos = new FileOutputStream("d:\\1.jpg");
 7         //3.使用FileInputStream中的方法read,一次讀取一個字節
 8         int len = 0;//接收讀取到的字節
 9         while((len = fis.read())!=-1){
10             //4.使用FileOutputStream中的方法write,一次寫一個字節
11             fos.write(len);
12         }
13         //5.釋放資源(先關寫,後關讀)
14         fos.close();
15         fis.close();
16         long e = System.currentTimeMillis();
17         System.out.println(e-s);
18     }

文件的復制:讀取文件采用字節數組緩沖讀取,寫入數據一次寫入多個字節
*
* 數據源:c:\\1.jpg
* 數據目的地:d:\\1.jpg
*
* 操作步驟:
* 1.創建字節輸入流對象FileInputStream,並且綁定數據源
* 2.創建字節輸出流對象FileOutputStream,並且綁定數據目的地
* 3.使用FileInputStream中的方法read(byte[]),一次讀取多個字節
* 4.使用FileOutputStream中的方法write(byte[],0,len),一次寫多個字節
* 5.釋放資源

 1 public static void main(String[] args) throws Exception {
 2         long s = System.currentTimeMillis();
 3         //1.創建字節輸入流對象FileInputStream,並且綁定數據源
 4         FileInputStream fis =  new FileInputStream("c:\\z.zip");
 5         //2.創建字節輸出流對象FileOutputStream,並且綁定數據目的地
 6         FileOutputStream fos = new FileOutputStream("d:\\z.zip");
 7         //3.使用FileInputStream中的方法read(byte[]),一次讀取多個字節
 8         byte[] bytes = new byte[1024*100];
 9         int len = 0;//讀取的字節有效個數
10         while((len = fis.read(bytes))!=-1){
11             //4.使用FileOutputStream中的方法write(byte[],0,len),一次寫多個字節
12             fos.write(bytes, 0, len);
13         }
14         //5.釋放資源
15         fos.close();
16         fis.close();
17         
18         long e = new Date().getTime();
19         System.out.println(e-s);
20     }

文件的復制:讀取文件使用緩沖流+數組,寫入數據使用緩沖流一次寫入多個
*
* 數據源:c:\\1.jpg
* 數據目的地:d:\\1.jpg
*
* 操作步驟:
* 1.創建FileInputStream對象,綁定數據源
* 2.創建BufferedInputStream對象,構造方法中傳入FileInputStream,提高FileInputStream的讀取效率
* 3.創建FileOutputStream對象,綁定數據目的地
* 4.創建BufferedOutputStream對象,構造方法中傳遞FileOutputStream,提高FileOutputStream效率
* 5.使用BufferedInputStream中的方法read(byte[]),讀取文件
* 6.使用BufferedOutputStream中的方法write(byte[],0,len),寫入數據到緩沖區
* 7.使用BufferedOutputStream中的方法flush把緩沖區的數據,刷新到文件中
* 8.釋放資源

 1 public static void main(String[] args) throws Exception {
 2         long s = System.currentTimeMillis();
 3         //1.創建FileInputStream對象,綁定數據源
 4         FileInputStream fis = new FileInputStream("c:\\z.zip");
 5         //2.創建BufferedInputStream對象,構造方法中傳入FileInputStream
 6         BufferedInputStream bis = new BufferedInputStream(fis);
 7         //3.創建FileOutputStream對象,綁定數據目的地
 8         FileOutputStream fos = new FileOutputStream("d:\\z.zip");
 9         //4.創建BufferedOutputStream對象,構造方法中傳遞FileOutputStream,提高FileOutputStream效率
10         BufferedOutputStream bos = new BufferedOutputStream(fos);
11         //5.使用BufferedInputStream中的方法read(byte[]),讀取文件
12         /*int len = 0;
13         while((len = bis.read())!=-1){
14             //6.使用BufferedOutputStream中的方法write(byte[],0,len),寫入數據到緩沖區
15             bos.write(len);
16         }*/
17         byte[] bytes = new byte[1024*100];
18         int len = 0;
19         while((len = bis.read(bytes))!=-1){
20             fos.write(bytes, 0, len);
21             fos.flush();
22         }
23         
24         //8.釋放資源
25         bos.close();
26         bis.close();
27         
28         long e = new Date().getTime();
29         System.out.println(e-s);
30     }

java.io.BufferedOutputStream:字節緩沖輸出流 extends OutputStream
* 字節緩沖輸出流作用:給基本流增加一個緩沖區,提高基本流的效率
*
* 繼承自父類的公共的成員方法
* abstract void write(int b) 寫入一個字節
* void write(byte[] b) 寫入字節數組
* void write(byte[] b, int off, int len) 寫入字節數組,off是開始的索引,len寫幾個
* void close() 關閉此輸出流並釋放與此流有關的所有系統資源。
*
* 構造方法:
* BufferedOutputStream(OutputStream out) 創建一個新的緩沖輸出流，以將數據寫入指定的底層輸出流。
* 參數:
* OutputStream out:字節輸出流,可以使用FileOutputStream
* 參數傳遞時哪個字節輸出流,就會給哪個字節輸出流增加一個緩沖區,提高這個流的效率
* 使用步驟:
* 1.創建FileOutputStream對象,綁定數據目的地
* 2.創建BufferedOutputStream對象,構造方法中傳遞FileOutputStream,提高FileOutputStream效率
* 3.使用BufferedOutputStream中的方法write,把數據寫入到緩沖區中
* 4.使用BufferedOutputStream中的方法flush,把緩沖區中的數據,刷新到文件中
* 5.釋放資源

 1  public static void main(String[] args) throws IOException {
 2         //1.創建FileOutputStream對象,綁定數據目的地
 3         FileOutputStream fos = new FileOutputStream("buffered.txt");
 4         //2.創建BufferedOutputStream對象,構造方法中傳遞FileOutputStream
 5         BufferedOutputStream bos = new BufferedOutputStream(fos);
 6         //3.使用BufferedOutputStream中的方法write,把數據寫入到緩沖區中
 7         bos.write(97);
 8         
 9         bos.write("我是緩沖流".getBytes());
10         //4.使用BufferedOutputStream中的方法flush,把緩沖區中的數據,刷新到文件中
11         bos.flush();
12         //5.釋放資源
13         bos.close();
14     }

java.io.BufferedInputStream:字節緩沖輸入流 extends InputStream
* 作用:給基本字節輸入流增加一個緩沖區,提高基本字節輸入流的效率
*
* 繼承自父類的公共發的成員方法:
* int read():讀取一個字節並返回，沒有字節返回-1.
* int read(byte[]): 讀取一定量的字節數，並存儲到字節數組中，返回讀取到的字節數。
* void close() 關閉此文件輸入流並釋放與此流有關的所有系統資源。
*
* 構造方法:
* BufferedInputStream(InputStream in) 創建一個 BufferedInputStream 並保存其參數，即輸入流 in，以便將來使用。
* 參數:
* InputStream in:字節輸入流,可以傳遞FileInputStream
* 參數傳遞的是哪個字節輸入流對象,就會給哪個字節輸入流對象增加一個緩沖區,提高該流的效率
*
* 使用步驟:
* 1.創建FileInputStream對象,綁定數據源
* 2.創建BufferedInputStream對象,構造方法中傳入FileInputStream,提高FileInputStream的讀取效率
* 3.使用BufferedInputStream中的方法read,讀取文件
* 4.釋放資源
*
* 總結:
* 字節流:操作的文件是非文本文件,文件的復制
* 字符流:操作的文件都是文本文件,一次讀取一個字符,可以讀取中文
* 文本文件:使用記事本打開,能看懂

 1 public static void main(String[] args) throws IOException {
 2         //1.創建FileInputStream對象,綁定數據源
 3         FileInputStream fis = new FileInputStream("buffered.txt");
 4         //2.創建BufferedInputStream對象,構造方法中傳入FileInputStream
 5         BufferedInputStream bis = new BufferedInputStream(fis);
 6         //3.使用BufferedInputStream中的方法read,讀取文件
 7         //int read():讀取一個字節並返回，沒有字節返回-1.
 8         /*int len = 0;
 9         while((len = bis.read())!=-1){
10             System.out.println((char)len);
11         }*/
12         
13         //int read(byte[]): 讀取一定量的字節數，並存儲到字節數組中，返回讀取到的字節數。
14         byte[] bytes = new byte[1024];
15         int len = 0;
16         while((len = bis.read(bytes))!=-1){
17             System.out.println(new String(bytes,0,len));            
18         }
19         
20         //4.釋放資源
21         bis.close();
22         System.out.println("-------------------");
23         BufferedReader br = new BufferedReader(new FileReader("buffered.txt"));
24         while((len = br.read())!=-1){
25             System.out.println((char)len);
26         }
27     }

復制單層文件夾
*
* 數據源:c:\\demo
* 數據目的地:d:\\
*
* 操作流程:
* 1.判斷d盤有沒有demo文件夾,沒有則創建
* 2.創建一個復制文件的方法
* 返回值類型:void
* 方法名:copyFile
* 參數列表:File src,File dest
* 3.遍歷要復制的文件夾,獲取文件夾中的每一個文件的路徑(要復制文件的數據源)
* 4.使用file類中的方法getName拼接要復制文件的數據目的
* 5.調用copyFile復制的方法進行復制

 1 public static void main(String[] args) throws IOException {
 2         //1.判斷d盤有沒有demo文件夾,沒有則創建
 3         File file = new File("d:\\demo");
 4         if(!file.exists()){
 5             file.mkdirs();
 6         }
 7         //3.遍歷要復制的文件夾,獲取文件夾中的每一個文件的路徑(要復制文件的數據源)
 8         File srcDirectory = new File("c:\\demo");
 9         File[] srcFiles = srcDirectory.listFiles();
10         for (File srcFile : srcFiles) {
11             //4.使用file類中的方法getName拼接要復制文件的數據目的
12             String srcName = srcFile.getName();
13             //使用File類的第三個構造方法創建目的地
14             File destFile = new File(file, srcName);
15             //5.調用copyFile復制的方法進行復制
16             copyFile(srcFile, destFile);
17         }
18     }

字節流

字節流

File字節流

理解Java中字符流與字節流的區別

字節流和字符流

字節流，字符流

字符流和字節流

用IO字節流復制文件-CopyFileByIo

字節流

Java之IO(九)其它字節流

字節流和字符流的區別

文件操作的字節流和字符流

io流輸入輸出流字符字節流

java：FileOutputStream 字節流輸出空文件

javaIO--字節流

Java IO 字節流與字符流（二）

Java IO 字節流與字符流（三）

使用帶緩沖的字節流讀寫數據

Java文件流之字節流

java 核心編程——IO流之字符流和字節流相互轉換（四）

HTTP使用 multipart/form-data 上傳多個字段（包括文件字節流 octet-stream）

java 字節流與字符流的區別（轉）

字節流

相關推薦