2. 程式人生 > >Java基礎----位元組流

Java基礎----位元組流

阿新 • • 發佈：2018-11-03
package cn.itcast.input;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;


/*
 File類：用於描述一個檔案或者資料夾
 
 通過File物件我們可以讀取檔案或者資料夾的屬性資料，如果我們需要讀取檔案的內容資料，那麼我們需要使用IO流技術。
 
 IO流(Input  Output)
 
 IO流解決的問題：解決裝置與裝置之間的資料傳輸問題。  記憶體---->硬碟   硬碟----》記憶體
 
 IO流技術
 
 
 IO流分類：
     如果是按照資料的流向劃分：   （判斷使用輸入流還是輸出流的依據：以當前程式作為參照物，觀察資料是流入還是流出，如果流出則使用輸出流，如果資料是流入，則使用輸入流）
        輸入流
       
         輸出流
         
  如果按照處理的單位劃分：
  
  位元組流：位元組流讀取得都是檔案中二進位制資料，讀取到二進位制資料不會經過任何處理。
  
  字元流：字元流讀取的資料是以字元為單位。字元流也是讀取檔案中的二進位制資料，不過會把這些二進位制資料轉換成我們能識別的字元。
  1111000100----->字元
  
  字元流 = 位元組流 + 解碼
  
輸入位元組流：


-------|InputStream 所有輸入位元組流的基類 抽象類
----------|FileInputStream  讀取檔案資料的輸入位元組流


使用FileInputStream 讀取檔案資料的步驟：
1.找到目標檔案
2.建立資料輸入的通道
3.讀取檔案中的資料
4.關閉資源，實際上就是釋放資源。
  
  
 */
public class Demo1 {


public static void main(String[] args) throws IOException {
readTest1();
readTest2();
readTest3();
readTest4();



}
//方式四：使用緩衝陣列配合迴圈一起讀取資料

public static void readTest4() throws IOException{
long startTime = System.currentTimeMillis();
//找到目標檔案
    File file = new File("F:\\a.txt");
   
//建立資料的輸入通道
        FileInputStream fileInputStream = new FileInputStream(file);
//建立緩衝陣列配合迴圈讀取檔案資料
        int length = 0;//儲存 每次讀取到的位元組數。
        byte[] buf = new byte[256];//儲存讀取到的資料      緩衝陣列 的長度一般是1024的倍數，因為與計算機的處理單位。  理論上緩衝陣列越大，效率越高
        
        while((length = fileInputStream.read(buf))!=-1){//read方法如果讀取到了檔案的末尾，那麼會返回-1表示。
       
System.out.println(new String(buf,0,length));
        }
      //關閉資源
      fileInputStream.close();
      long endTime = System.currentTimeMillis();
      System.out.println("讀取的時間4是："+ (endTime-startTime));
}

//方式三：使用緩衝陣列讀取.缺點：無法讀取到完整一個檔案的資料
    public static void readTest3() throws IOException{
    //找到目標檔案
    File file = new File("F:\\a.txt");
    //建立資料的輸入通道
        FileInputStream fileInputStream = new FileInputStream(file);
    //建立緩衝位元組陣列，讀取檔案的資料。
        byte[] buf = new byte[1024];//相當於超市裡面的購物車。
        int length = fileInputStream.read(buf);//如果使用read讀取資料傳入位元組陣列，那麼資料是儲存到位元組陣列中的，而這時候read方法的返回值是表示的是本次讀取了幾個位元組資料到位元組陣列中。
        System.out.println("length："+length);
        //使用位元組陣列構建字串
        String content = new String(buf,0,length);
        System.out.println("內容是："+content);
        //關閉資源
        
        fileInputStream.close();
    }
//方式二：使用迴圈讀取檔案的資料
public static void readTest2() throws IOException  {
long startTime = System.currentTimeMillis();
//找到目標檔案
File file = new File("F:\\a.txt");
//建立資料的輸入通道
FileInputStream fileInputStream = new FileInputStream(file);

//讀取檔案中的資料
int content = 0;//宣告該變數用於儲存讀取到的資料
while((content = fileInputStream.read())!=-1){
System.out.println((char)content);
}

//關閉資源
fileInputStream.close();
long endTime = System.currentTimeMillis();
System.out.println("讀取的時間是："+ (endTime-startTime));
}
//讀取方式一：無法讀取完整一個檔案的資料
public static void readTest1() throws IOException{
//1.找到目標檔案
File file = new File("F:\\a.txt");
//建立資料輸入的通道

        FileInputStream fileInputStream = new FileInputStream(file);
        
//讀取檔案中的資料
int content = fileInputStream.read();//read() 讀取一個位元組的資料，把讀取的資料返回。
System.out.println("讀取到的內容："+(char)content);
//關閉資源，實際上就是釋放資源。
fileInputStream.close();

}


}


package cn.itcast.input;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;


/*
 問題1：讀取玩一個檔案資料的時候，我不關閉資源有什麼影響？
 答案：資原始檔一旦使用完畢
 
 
 */
public class Demo2 {


public static void main(String[] args) throws IOException {
//找到目標檔案
File file = new File("F:\\a.txt");

//建立資料的輸入通道
FileInputStream fileInputStream = new FileInputStream(file);


//建立緩衝位元組陣列讀取檔案
byte[] buf = new byte[8];
int length = 0;

while ((length = fileInputStream.read(buf))!=-1){
System.out.println(new String(buf,0,length));//
//System.out.println(Arrays.toString(buf));
}
//釋放檔案資源
fileInputStream.close();

}


}


package cn.itcast.output;
/*
 --------|OutputStream  是所有輸出位元組流的父類。抽象類
 ------------|FileOutputStream  向檔案輸出資料的輸出位元組流
 
 FileOutputStream如何使用：
 1.找到目標檔案
 2.建立資料的輸出通道。
 3.把資料轉換成位元組陣列寫出。
 4.關閉資源
 
 FileOutputStream要注意的細節：
 1.使用FileOutputStream的時候，如果目標檔案不存在，那麼會自動建立目標檔案物件。
 2.使用FileOutputStream寫資料的時候，如果目標檔案已經存在，那麼會先清空目標檔案中的資料，然後再寫入資料。
 3.使用FileOutputStream寫資料的時候，如果目標檔案已經存在，需要在原資料基礎上追加資料的時候應該使用new FileOutputStream(file,true)建構函式
 4使用FileOutputStream的write方法寫資料的時候，雖然接收的是一個int型別的資料，但是真正寫出的只是一個位元組的資料。只是把低八位的二進位制資料寫出，其他二十四位資料全部丟失。
 
 00000000-00000000-00000000-00000001-11111111
 */
import java.io.File;


import java.io.FileOutputStream;
import java.io.IOException;


public class Demo1 {


public static void main(String[] args) throws IOException {
writeTest1();
writeTest2();
writeTest3();


}

//使用位元組陣列把資料寫出
public static void writeTest3() throws IOException{
//找到目標檔案
File file = new File("F:\\b.txt");
//建立資料的輸出通道
FileOutputStream fileOutputStream = new FileOutputStream(file,true);
//把資料寫出
String data= "abc";
byte[] buf = data.getBytes();
fileOutputStream.write(buf,0,2);//0：從位元組陣列的指定索引值開始寫， 2：寫出兩個位元組


//關閉資源
fileOutputStream.close();
}
//使用位元組陣列把資料寫出
public static void writeTest2() throws IOException{
//找到目標檔案
File file = new File("F:\\b.txt");
//建立資料的輸出通道
FileOutputStream fileOutputStream = new FileOutputStream(file,true);
//把資料寫出
String data= "\r\n hello world";
fileOutputStream.write(data.getBytes());


//關閉資源
fileOutputStream.close();
}


//每次只能寫一個位元組的資料出去
public static void writeTest1() throws IOException{
//找到目標檔案
File file = new File("F:\\b.txt");
//建立資料的輸出通道
FileOutputStream fileOutputStream = new FileOutputStream(file);
//把資料寫出
fileOutputStream.write('h');
fileOutputStream.write('e');
fileOutputStream.write('l');
fileOutputStream.write('l');
fileOutputStream.write('o');

//關閉資源
fileOutputStream.close();
}


}



/*4使用FileOutputStream的write方法寫資料的時候，雖然接收的是一個int型別的資料，但是真正寫出的只是一個位元組的資料。只是把低八位的二進位制資料寫出，其他二十四位資料全部丟失。
 
 00000000-00000000-00000000-00000001-11111111
 */


package cn.itcast.output;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;


public class Demo2 {


public static void main(String[] args) throws IOException {
writeTest();
readTest();


}


public static void readTest() throws IOException {
//找到目標檔案
File file = new File("F:\\c.txt");
//建立資料的輸出通道
FileInputStream fileInputStream = new FileInputStream(file);
//建立緩衝輸入讀取檔案資料
byte[] buf = new byte[4];
//讀取檔案資料
int length = fileInputStream.read(buf);

System.out.println("位元組陣列的內容："+Arrays.toString(buf));
//關閉資源
fileInputStream.close();
}

public static void writeTest() throws IOException {
//找到目標檔案
File file = new File("F:\\c.txt");
//建立資料的輸出通道
FileOutputStream fileOutputStream = new FileOutputStream(file);
//把資料寫出
fileOutputStream.write(511);
//關閉資源
fileOutputStream.close();
}


}


package cn.itcast.output;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


/*
 
 需求：拷貝一張圖片
 
 */
public class CopyImage {


public static void main(String[] args) throws IOException {
// 找到目標檔案
File inFile = new File("F:\\1.jpg");
File destFile = new File("E:\\1.jpg");

//建立資料的輸入輸出通道
FileInputStream fileInputStream = new FileInputStream(inFile);
//每次建立一個FileOutputStream的時候，預設情況下FileOutputStream的指標是指向了檔案的開始位置。每寫出一次，指向都會出現相應移動
FileOutputStream fileOutputStream = new FileOutputStream(destFile);
//建立緩衝資料邊讀邊寫
byte[] buf = new byte[1024];
int length = 0;
while((length = fileInputStream.read(buf))!=-1){//最後一次只剩下了824個位元組
fileOutputStream.write(buf, 0, length);
}

//關閉資源原則：先開後關，後開先關。
fileOutputStream.close();
fileInputStream.close();



}


}



package cn.itcast.buffered;


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;


/*
 我們清楚讀取檔案資料使用緩衝陣列讀取效率更高，sun也知道使用緩衝陣列讀取效率更高，那麼
這時候sun給我們提供了一個-----緩衝輸入位元組流物件，讓我們可以更高效率的讀取檔案。


 輸入位元組流體系：
 -----|InputStream  輸入位元組流的基類。抽象
 ---------|FileInputStream 讀取檔案資料的輸入位元組流
 ---------|BufferedInputStream緩衝輸入位元組流，緩衝位元組流的出現
 其實該類內部只不過是維護了一個8kb的位元組陣列而已。 


注意： 凡是緩衝流都不具備讀寫檔案的能力。


使用BufferedInputStream的步驟 :
1. 找到目標檔案。
2. 建立資料 的輸入通道
3. 建立緩衝 輸入位元組流流
4. 關閉資源
 */


public class Demo1 {

public static void main(String[] args) throws IOException {
readTest2();
}

public static void readTest2() throws IOException{
//找到目標檔案
File file = new File("F:\\a.txt");
//建立資料的輸入通道
FileInputStream fileInputStream= new FileInputStream(file);
//建立緩衝輸入位元組流
//疑問一：為甚麼建立BufferedInputStream的時候都需要傳遞FileInputStream?BufferedInputStream本身不具備讀檔案的能力，所以需要藉助FileInputStream來讀寫檔案的資料
BufferedInputStream bufferedInputStream= new BufferedInputStream(fileInputStream);
//讀取檔案資料
bufferedInputStream.read();




FileOutputStream fileOutputStream= new FileOutputStream(file);
BufferedOutputStream bufferedOutputStream= new BufferedOutputStream(fileOutputStream);
fileOutputStream.write(null);

//讀取檔案資料
int content = 0 ;
//疑問二：BufferedInputStream出現 的目的是了提高讀取檔案的效率，但是BufferedInputStream的read方法每次讀取一個位元組的資料
//而FileInputStreram每次也是讀取一個位元組的資料，那麼BufferedInputStream效率高從何而來？
while((content = fileInputStream.read())!=-1){
System.out.print((char)content);
}

//關閉資源
bufferedInputStream.close();//呼叫BufferedInputStream的close方法實際上關閉的是FileinputStream.
}




//讀取檔案的時候我們都是使用緩衝陣列讀取。效率會更加高
public static void readTest() throws IOException{
File file = new File("F:\\a.txt");
//建立陣列通道
FileInputStream fileInputStream = new FileInputStream(file);
//建立緩衝陣列讀取資料
byte[] buf = new byte[1024*8];
int length = 0; 
while((length = fileInputStream.read(buf))!=-1){
System.out.print(new String(buf,0,length));
}
//關閉資源
fileInputStream.close();
}


}




package cn.itcast.buffered;


import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


/*
 輸入位元組流體系：
 -----|OutputStream  所有輸出位元組流的基類。抽象
 ---------|FileOutputStream 讀取檔案資料的輸出位元組流
 ---------|BufferedOutputStream 緩衝輸出位元組流，BufferedOutputStream出現的目的是為了提高內部也是維護一個8kb的位元組陣列而已
 
 使用BufferedOutputStream的步驟：
   1.找到目標檔案
   2.建立資料的輸出通道
   3。建立快取輸出位元組流物件
   4. 把資料寫出
   
   BufferedOutputStream 要注意的細節
1. 使用BufferedOutStream寫資料的時候，它的write方法是是先把資料寫到它內部維護的位元組陣列中。
  2. 使用BufferedOutStream寫資料的時候，它的write方法是是先把資料寫到它內部維護的位元組陣列中，如果需要把資料真正的寫到硬碟上面，需要
  呼叫flush方法或者是close方法、 或者是內部維護的位元組陣列已經填滿資料的時候。
 
 練習：使用緩衝輸入輸出位元組流拷貝一個圖片
 */
public class Demo2 {


public static void main(String[] args) throws IOException {
// 找到目標檔案
File file = new File("F:\\a.txt");
//建立資料的輸出通道
FileOutputStream fileOutputStream = new FileOutputStream(file);
//建立快取輸出位元組流物件
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
//把資料寫出
bufferedOutputStream.write("hello".getBytes());
//把快取陣列中內部的資料寫到硬碟上
//bufferedOutputStream.flush();
bufferedOutputStream.close();

}


}



package cn.itcast.buffered;


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


/*
  練習：使用緩衝輸入輸出位元組流拷貝一個圖片
  
 */
public class copyImage {


public static void main(String[] args) throws IOException {
// 找到目標檔案
File inFile = new File("F:\\1.jpg");
File outFile = new File("E:\\1.jpg");
//建立資料輸入輸出通道
FileInputStream fileInputStream = new FileInputStream(inFile);
FileOutputStream fileOutputStream = new FileOutputStream(outFile);


//建立緩衝輸入輸出流
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
   //邊讀變寫
int content = 0;
//int length = bufferedInputStream.read(buf);/如果傳入了緩衝陣列，內容是儲存到緩衝陣列中，返回值是儲存到緩衝陣列中的位元組個數。
while((content = bufferedInputStream.read())!=-1){//如果使用read方法沒有傳入緩衝陣列，那麼返回值是讀取到的內容。
bufferedOutputStream.write(content);
bufferedOutputStream.flush();
}

//關閉資源
bufferedOutputStream.close();
bufferedOutputStream.close();

}


}




相關推薦

Java基礎----位元組流

package cn.itcast.input; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOExcep

[Java基礎] 位元組流與字元流

流的定義 流是個抽象的概念，是對輸入輸出裝置的抽象，Java程式中，對於資料的輸入/輸出操作都是以“流”的方式進行。裝置可以是檔案，網路，記憶體等。 流具有方向性，至於是輸入流還是輸出流則是

黑馬程式設計師——Java基礎---IO流（字元流、位元組流、轉換流、流操作規律）

三、字元編碼 字元編碼通過轉換流來完成。在兩個物件進行構造的時候，可以加入字符集（即編碼表），可傳入編碼表的有： 轉換流：InuputStreamReader和OutputStreamWriter。列印流：PrintStream和PrintWriter，只有輸出流。轉換流的編碼應用 可以將字元以指定編

[Java基礎]用流進行byte位元組流的讀寫

用流進行byte位元組流的讀寫 import java.io.ByteArrayInputStream; public class StringByteCount { static Strin

JAVA基礎-IO流（二）

直寫 eno 接口 寫入 print lis ted his ride 一、字節流 字節流是通過字節來進行讀寫操作的，他的使用對象相比於字符流來說更加的廣泛。這主要是因為他們讀寫文件的方式而決定的。字符流讀寫文件時是將讀取到的字節通過默認編碼表轉換成字符，在通

Java基礎-IO流(123

最大 java基礎 作文 寫入 文件中 長度 繼續 寫入文件 style IO流用來處理設備之間的數據傳輸.可以實現文件復制,上傳文件和下載文件. IO流分類 IO流可以吧數據存儲到文件,也可以從文件中讀取數據 輸出流(寫數據用) FileWriter voi

java基礎IO流 復制鍵盤錄入的目錄,復制其中的.java文件到指定目錄,指定目錄中有重名,則改名 對加密文件計算字母個數

tac exceptio lean urn ext java基礎 reader ring 完成 package com.swift.jinji; import java.io.BufferedInputStream; import java.io.BufferedOut

JAVA基礎——IO流字符流

操作 mar OS new 運行 order pre table 資源 字符流 字節流提供了處理任何類型輸入/輸出操作的功能（因為對於計算機而言，一切都是0和1，只需把數據以字節形式表示就夠了），但它們不可以直接操作Unicode字符，因為上一篇文章寫了，一個Unicode

Java基礎-IO流對象之序列化與反序列化

span 作者 創作 style -s 反序列化 ont 對象 io流 　　　　　　　　　　　　　　　　Java基礎-IO流對象之序列化與反序列化 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正傑 版權聲明：原創作品，謝絕轉載！否則將追究

Java基礎-IO流對象之隨機訪問文件（RandomAccessFile）

str 文件的 指向 poi mod 指針 println span www. 　　　　　　　　　　　　Java基礎-IO流對象之隨機訪問文件（RandomAccessFile） 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正傑 版權

java IO 位元組流、字元流操作總結一之File類

這篇文章將介紹有關java IO輸入輸出流的知識。首先說說字元編碼的問題，比較常用的編碼有gbk,utf-8等。 1.gbk 編碼中文佔用2個位元組，英文佔用1個位元組。 2、utf-8編碼中文佔用3個位元組，英文佔用1個位元組。 Java是雙位元組編碼，utf-16be編碼。即char

java IO 位元組流、字元流操作總結二之位元組流

上一篇，主要介紹了檔案類File和RandomAccessFile類的用法。接下來，我覺得還是將IO流分為位元組流和字元流兩部分介紹比較好。這樣不至於搞混亂，同時也便於對比。這一篇主要介紹位元組流。 1、位元組流 首先上一張位元組流的家族圖譜。 位元組流主要分為兩部分：InputS

Java基礎---字元流

package day21; /*   位元組流： 輸入位元組流： -----------|InputStream 輸入位元組流的基類 抽象類 --------------|FileInputStream 讀取檔案資料的輸入位元組流 ----------

Java基礎-----IO流

package cn.itcast.file; import java.io.File; /*  IO流（Input,Output）:    IO技術的主要作用是解決裝置與裝置之間的資料傳輸問題。比如：硬碟--->記憶體 &nb

JAVA基礎之 流和檔案

File類 該類可以獲取檔案資訊，也可以對檔案進行管理，File物件既可以表示檔案也可以表示目錄，利用它可以對檔案和目錄的屬性進行操作。 import java.io.*; import java.util.*; public class FileTest { public stati

Java之位元組流和字元流

一.位元組流 流分為輸入流和輸出流。 用參照物(程式)來判斷是輸出流還是輸入流。 注意：在用流的時候，結束時要記得關掉流。 位元組流 將文字、圖片、音訊等轉成位元組,進行資料傳輸。 程式——>檔案 輸出流 寫檔案 檔案——>程式 輸入流

Java之位元組流操作複製檔案

需求： 將一個資料夾 複製 到另一個資料夾下 import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.i

Java：位元組流、字元流

1、IO概述- IO流概述及分類 1）、IO流： I：Input（輸入）：資料從外部流向程式中。（外部：檔案） O：Ouput（輸出）：資料從程式流向外部。 流：線性的，有方向的 2）、作用： 可以“讀”，“寫”檔案的內容，File類只能獲取檔案/目

Java基礎-IO流相關知識和用法

IO流 分類： 1、流向 A：輸入流：讀取資料 B：輸出流：寫入資料 2、資料型別 A：位元組流 a：位元組輸入流 ：讀取資料 (抽象類的基類：InputStream) b：位元組輸出流 ：寫入資料 (抽象類的基類：OutputStream) B：字元流

Java基礎IO流（五）RandomAccessFile

RandomAccessFile java提供的對檔案內容的訪問，既可以讀檔案也可以寫檔案。RandomAccessFile支援隨機訪問檔案，可以訪問檔案的任意位置(1)java檔案模型：    在硬碟上的檔案是byte byte byte儲存的，是資料的集合(2)開啟檔案：&n