Java中的IO流之輸入流|樂字節

elliott_hu 發布于2019-08-19 10:16 / 2080人閱讀

摘要：上一篇寫到了流，這篇文章著重談談輸入流，再下次再說輸出流。一輸入流字節流和字符流的操作方式幾乎完全一樣，只是操作的數據單元不同而已。返回結果為時表明到了輸入流的結束點。

親愛的樂字節的小伙伴們，小樂又來分享Java技術文章了。上一篇寫到了IO流，這篇文章著重談談輸入流，再下次再說輸出流。

一、輸入流

字節流和字符流的操作方式幾乎完全一樣，只是操作的數據單元不同而已。字節流可

以操作所有文件，字符流僅操作純文本。

1、抽象類:InputStream 和 Reader

InputStream和Reader是所有輸入流的基類，它們是兩個抽象類，是所有輸入流的模版，其中定義的方法在所有輸入流中都可以使用。

在InputStream里包含如下三個方法：

在Reader中包含如下三個方法：

對比InputStream和Reader 所提供的方法，可以看出這兩個基類的功能基本相似。返回結果為-1 時表明到了輸入流的結束點。 InputStream 和 Reade 都是抽象的，不能直接創建它們的實例，可以使用它們的子類。

2、文件節點類: FileInputStream 和 FileReader

FileInputStream 和 FileReader，它們都是節點流，直接和指定文件關聯。操作方式

基本一致。

1)、單個字節讀取

以FileInputStream為例：

public class SingleFileRead {
    public static void main(String[] args) {
        // 1、建立聯系 File對象
        File file = new File("f:/IO/test.txt");
        // 2、選擇流
        InputStream in = null;// 提升作用域
        try {
            in = new FileInputStream(file);
            // 3、操作 單個字節讀取
        long fileLength = file.length(); // 接收實際讀取的字節數
            // 計數器
            System.out.println(fileLength);
            long num = 0;
            // 循環讀取
            while (num < fileLength) {
                char ch = (char) in.read();
                System.out.println(ch);
                num++;
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("文件不存在,不能進行下一步操作");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("讀取文件失敗");
        } finally {
            try {
                // 4、釋放資料
                if (in != null) {
                    in.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.out.println("關閉文件輸入流失敗");
            }
        }
    }
}

2)、批量讀取(字節|字符重點)

public class ReadFile {
    public static void main(String[] args) {
        //1、字節讀取：建立聯系    File對象
        File file=new File("f:/IO/test.txt");
        //2、選擇流
        InputStream in=null;//提升作用域
        try {
            in=new FileInputStream(file);
            //3、操作   不斷讀取   緩沖數組
            byte[]car=new byte[1024];
            int len=0;    //接收實際讀取的大小
            //循環讀取
            while(-1!=(len=in.read(car))){
                //輸出，字節數組轉成字符串
                String info=new String(car,0,len);
                System.out.println(info);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("文件不存在");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("讀取文件失敗");
        }finally{
            try {
                //4、釋放資料
                if(in!=null){
                    in.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.out.println("關閉文件輸入流失敗");
            }
        }
    }
}
//字符讀取1、創建源
        File src=new File("f:/char.txt");
        //2、選擇流
        Reader reader=new FileReader(src);
             //3、讀取操作
        char[] flush=new char[1024];
        int len=0;
        while(-1!=(len=reader.read(flush))){
            //字符數組轉換為字符串
            String str=new String(flush,0,len);
            System.out.println(str);
        }
//4、釋放資源 
          reader.close();
樂字節原創

3、緩沖處理類:BufferedInputStream和 BufferedReader(重點)

緩沖提高性能：字節流直接套上即可；字符緩沖流 +新增方法(不能使用多態)

//1、創建源，建立聯系   
File src =new File("test.txt"); 
//2、選擇緩沖流   
    InputStream is =new BufferedInputStream(new FileInputStream(src));   //3、操作  :  多個讀取        
    byte[] car =new byte[2]; 
    int len =0;       
while(-1!=(len=is.read(car))){          
//獲取數組的內容   字節數組轉字符串  new String(字節數組,0,length) 
      System.out.println(new String(car,0,len));           
    } 
    //4、釋放資源 
    is.close(); 
//創建源:   
    File src =new File("test.txt"); 
//使用字符緩沖流  提高性能讀取文件  +新增方法(不能使用多態) 
    BufferedReader br =new BufferedReader(new FileReader(src)); 
//操作  行讀取
String line=null; 
while(null!=(line=br.readLine())){ 
        System.out.println(line); 
} 
//釋放資源     
br.close();

4、轉換處理流: InputStreamReader

轉換流：將字節流轉為字符流處理亂碼(編碼集、解碼集)。

//讀取文件 
    File src =new File("test.txt"); 
//轉換流 
    BufferedReader br =new BufferedReader( 
          new InputStreamReader( 
                new BufferedInputStream( 
                      new FileInputStream( 
                            src 
                          )             
       
                    ),"utf-8" 
              )         
        ); 
//行讀取 
    String msg =null; 
    while(null!=(msg =br.readLine())){ 
      System.out.println(msg); 
    } 
    br.close();

5、字節數組節點類: ByteArrayInputStream

操作的節點為字節數組，數組在jvm 內存中，由垃圾回收機制管理，不需要手動關閉

//1、創建源 
    byte[] src ="io 學習入門".getBytes(); 
//2、選擇流 
InputStream is = new ByteArrayInputStream(src);
//3、操作 與文件一致 
  byte[] flush =new byte[10]; 
  int len =0; 
  while(-1!=(len =is.read(flush))){ 
    System.out.println(new String(flush,0,len)); 
  } 
//4、釋放  
  is.close();

6、數據處理流:DataInputStream

可以處理基本類型+String，保留數據的類型。前提是讀取順序與寫出順序一致，否則讀取數據不正確

/**
     * 數據+類型    輸出到文件
     * @param destPath
     * @throws IOException 
     */
    public static void write(String destPath) throws IOException{
        int point=2;
        long num=100L;
        String str="數據類型";
        //創建源
        File dest=new File(destPath);
        //選擇流
        DataOutputStream dos=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(dest)));
        //操作    寫出的順序         為讀取作準備
        dos.writeInt(point);
        dos.writeLong(num);
        dos.writeUTF(str);
        dos.flush();
        //釋放資源
        dos.close();
    }

7、對象處理流(反序列化):ObjectInputStream

/**
     * 反序列化：
     * 1、先寫入再讀取
     * 2、讀取對象需要知道具體類型，依次讀取
     * 注意：
     * 1)不是所有的對象都可以序列化    Serializable
     * 2)不是所有的屬性都需要序列化    transient    
     */    
public static void read(String srcPath) throws FileNotFoundException, IOException, ClassNotFoundException{
        //創建源
        File src=new File(srcPath);
        //選擇流    OjbectInputStream
        ObjectInputStream dis=new ObjectInputStream(
                new BufferedInputStream(
                        new FileInputStream(src)
                        )
                );
        //操作    讀取的順序與寫出的順序一致        必須存在才能讀取
        Object obj=dis.readObject();
        if(obj instanceof Employee){
            Employee emp=(Employee)obj;
            System.out.println(emp.getName());
            System.out.println(emp.getSalary());
        }
        obj=dis.readObject();
        int[]arr=(int[])obj;
        System.out.println(Arrays.toString(arr));
        //釋放資源
        dis.close();
    }

Java中的IO流-輸入流就介紹到這里了，下次再說輸出流。

樂字節原創，更多Java技術干貨持續更新，歡迎關注。

云服務器 GPU云服務器 java中的io流 io輸入輸出流 io流java java文件io流

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/75722.html

Java中的IO流之輸出流|樂字節

摘要：大家好，樂字節小樂又來了。上一篇給大家帶來的是中的流之輸入流樂字節，本文將繼續講述流之輸出流。一輸出流抽象類和和也非常相似。從上述的字節數組中，讀取字符串。大家好，樂字節小樂又來了。上一篇給大家帶來的是：Java中的IO流之輸入流|樂字節，本文將繼續講述IO流之輸出流。showImg(https://segmentfault.com/img/bVbvQx1?w=600&h=338);...

CoderStudy 2019-08-19 10:16 評論0 收藏0
Java網絡編程探究|樂字節

摘要：換句話說，套接字起到通信端點的作用。單個套接字是一個端點，而一對套接字則構成一個雙向通信信道，使非關聯進程可以在本地或通過網絡進行數據交換。大家好，我是樂字節小樂，上次給大家講述了Java中的IO流之輸出流|樂字節，本文將會給大家講述網絡編程。主要內容如下：網絡網絡分層列表項目 IP位置端口port 網絡編程 showImg(https://segmentfault.c...

Kahn 2019-08-19 10:21 評論0 收藏0
樂字節Java之file、IO流基礎知識和操作步驟

摘要：流分類由此可見，流很龐大從不同角度進行分類數據分類按處理數據單位分為字節流和字符流。處理數據是音頻視頻文本等一切為字節流，僅能處理文本的為字符流。功能分類節點流和處理流。從向一個特定的設備磁盤網絡等讀寫數據的流稱為節點流，也常被稱為低級流。嗨嘍，小樂又來了，今天要給大家送上的技術文章是Java重點知識-IO流。先來看看IO流的思維導圖吧。showImg(https://segmen...

pkhope 2019-08-19 10:14 評論0 收藏0
Java編程基礎23——IO(其他流)&Properties

摘要：但它融合了和的功能。支持對隨機訪問文件的讀取和寫入。的概述和作為集合的使用了解的概述類表示了一個持久的屬性集。可保存在流中或從流中加載。屬性列表中每個鍵及其對應值都是一個字符串。 1_序列流(了解) 1.什么是序列流序列流可以把多個字節輸入流整合成一個, 從序列流中讀取數據時, 將從被整合的第一個流開始讀, 讀完一個之后繼續讀第二個, 以此類推. 2.使用方式整合兩個: S...

vvpale 2019-08-19 11:16 評論0 收藏0
樂字節-Java8新特性之Stream流（上）

摘要：需要注意的是很多流操作本身就會返回一個流，所以多個操作可以直接連接起來，如下圖這樣，操作可以進行鏈式調用，并且并行流還可以實現數據流并行處理操作。為集合創建并行流。上一篇文章，小樂給大家介紹了《Java8新特性之方法引用》，下面接下來小樂將會給大家介紹Java8新特性之Stream，稱之為流，本篇文章為上半部分。 1、什么是流? Java Se中對于流的操作有輸入輸出IO流,而Jav...

dingda 2019-08-19 11:35 評論0 收藏0