2. 程式人生 > 其它 >J-基礎-I/O流-緩衝流、轉換流、序列化流、列印流

J-基礎-I/O流-緩衝流、轉換流、序列化流、列印流

阿新 • • 發佈：2021-01-29

技術標籤：java

緩衝流

提高讀寫效率。四個基本的流的增強，分為：
位元組緩衝流：BufferedInputStream，BufferedOutputStream
字元緩衝流：BufferedReader，BufferedWriter
原理：
建立流物件時，建立一個內建的預設大小的緩衝區，通過緩衝區讀寫，減少系統IO次數，提高讀寫效率。
1.位元組緩衝流
構造方法：
public BufferedInputStream(InputStream in):建立一個新的緩衝輸入流。
public BufferedOutputStream(OutputStream out):建立一個新的緩衝輸出流。

import java.io.*;

public class Main {

    public static void main(String[] args){

        //普通方法
        copy1();
        //位元組緩衝流
        copy2();
        //帶陣列的位元組緩衝流
        copy3();
    }

    /*1--普通方法*/
    private static void copy1(){
        long start = System.currentTimeMillis();

        try (FileInputStream fis = new FileInputStream("D:\\測試資料夾\\1\\西遊記.txt");
             FileOutputStream fos = new FileOutputStream("D:\\測試資料夾\\1\\西遊記1.txt");
        ){
            int b;
            while ((b = fis.read())!=-1){
                fos.write(b);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("普通流複製時間:"+(end - start)+" 毫秒");
    }

    /*2--位元組緩衝流*/
    private static void copy2() {
        long start = System.currentTimeMillis();

        try (BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\測試資料夾\\1\\西遊記.txt"));
             BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\測試資料夾\\1\\西遊記2.txt"));
        ){
            int b;
            while ((b = fis.read())!=-1){
                fos.write(b);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("位元組緩衝流複製時間:"+(end - start)+" 毫秒");

    }

    /*3--帶資料的位元組緩衝流*/
    private static void copy3() {
        long start = System.currentTimeMillis();

        try (BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\測試資料夾\\1\\西遊記.txt"));
             BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\測試資料夾\\1\\西遊記3.txt"));
        ){
            int b;
            byte[] bytes = new byte[100];
            while ((b = fis.read(bytes))!=-1){
                fos.write(bytes,0,b);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("帶陣列的位元組緩衝流複製時間:"+(end - start)+" 毫秒");
    }
}

2.字元緩衝流
構造方法：
public BufferedReader(Reader in):建立一個閒的緩衝流。
public BufferedWriter（Writer out）：建立一個新的緩衝輸出流。
特有方法：
BufferedReader：public String readLine():讀一行文字。
BufferedWriter：public void newLine():寫一行分隔符，由系統屬性定義符號。

特殊方法：
1.BufferedReader：public String readLine():讀一行文字。
2.BufferedWriter：public void newLine():寫一行行分割符，由系統屬性定義符號。

import java.io.*;

public class Main {

    public static void main(String[] args){

//        //位元組-普通方法
//        copy1();
//        //位元組-緩衝流
//        copy2();
//        //帶陣列的位元組-緩衝流
//        copy3();

        //字元-普通方法
//        copy2_1();
//        copy2_2();
//        copy2_3();

        //特殊
        //BufferedReader： public String readLine() : 讀一行文字。
        //BufferedWriter： public void newLine() : 寫一行行分隔符,由系統屬性定義符號。
        readLine();
    }
    

    /*2--字元-普通方法*/
    private static void copy2_1() {
        long start = System.currentTimeMillis();

        try (FileReader fr = new FileReader("D:\\測試資料夾\\1\\西遊記.txt");
             FileWriter fw = new FileWriter("D:\\測試資料夾\\1\\西遊記4.txt");
        ){
            int b;
            while ((b = fr.read())!=-1){
//                System.out.println("---"+(char)b);
                fw.write(b);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("普通流複製時間:"+(end - start)+" 毫秒");
    }

    /*2--字元-緩衝流*/
    private static void copy2_2() {
        long start = System.currentTimeMillis();

        try (BufferedReader fr = new BufferedReader(new FileReader("D:\\測試資料夾\\1\\西遊記.txt"));
             BufferedWriter fw = new BufferedWriter(new FileWriter("D:\\測試資料夾\\1\\西遊記5.txt"));
        ){
            int b;
            while ((b = fr.read())!=-1){
//                System.out.println("---"+(char)b);
                fw.write(b);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("普通流複製時間:"+(end - start)+" 毫秒");
    }

    /*2--帶陣列的字元-緩衝流*/
    private static void copy2_3() {
        long start = System.currentTimeMillis();

        try (BufferedReader fr = new BufferedReader(new FileReader("D:\\測試資料夾\\1\\西遊記.txt"));
             BufferedWriter fw = new BufferedWriter(new FileWriter("D:\\測試資料夾\\1\\西遊記6.txt"));
        ){
            int b;
            char[] chars = new char[100];
            while ((b = fr.read(chars)) != -1){
//                System.out.println("---"+new String(chars,0,b));
                fw.write(chars,0,b);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("普通流複製時間:"+(end - start)+" 毫秒");
    }

    /*3--readLine-讀取一行,和一行分割符*/
    private static void readLine() {
        long start = System.currentTimeMillis();
        try (BufferedReader fr = new BufferedReader(new FileReader("D:\\測試資料夾\\1\\西遊記.txt"));
             BufferedWriter fw = new BufferedWriter(new FileWriter("D:\\測試資料夾\\1\\西遊記7.txt"));
        ){
            String line = null;
            while ((line = fr.readLine())!= null){
//                System.out.println(line);
                fw.write(line);
                fw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("普通流複製時間:"+(end - start)+" 毫秒");

    }

}

合

import java.io.*;

public class Main {

    public static void main(String[] args){

//        //位元組-普通方法
//        copy1();
//        //位元組-緩衝流
//        copy2();
//        //帶陣列的位元組-緩衝流
//        copy3();

        //字元-普通方法
//        copy2_1();
//        copy2_2();
//        copy2_3();

        //特殊
        //BufferedReader： public String readLine() : 讀一行文字。
        //BufferedWriter： public void newLine() : 寫一行行分隔符,由系統屬性定義符號。
        readLine();
    }


    /*1--位元組-普通方法*/
    private static void copy1(){
        long start = System.currentTimeMillis();

        try (FileInputStream fis = new FileInputStream("D:\\測試資料夾\\1\\西遊記.txt");
             FileOutputStream fos = new FileOutputStream("D:\\測試資料夾\\1\\西遊記1.txt");
        ){
            int b;
            while ((b = fis.read())!=-1){
                fos.write(b);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("普通流複製時間:"+(end - start)+" 毫秒");
    }

    /*2--位元組-緩衝流*/
    private static void copy2() {
        long start = System.currentTimeMillis();

        try (BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\測試資料夾\\1\\西遊記.txt"));
             BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\測試資料夾\\1\\西遊記2.txt"));
        ){
            int b;
            while ((b = fis.read())!=-1){
                fos.write(b);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("位元組緩衝流複製時間:"+(end - start)+" 毫秒");

    }

    /*3--帶陣列的位元組-緩衝流*/
    private static void copy3() {
        long start = System.currentTimeMillis();

        try (BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\測試資料夾\\1\\西遊記.txt"));
             BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\測試資料夾\\1\\西遊記3.txt"));
        ){
            int b;
            byte[] bytes = new byte[100];
            while ((b = fis.read(bytes))!=-1){
                fos.write(bytes,0,b);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("帶陣列的位元組緩衝流複製時間:"+(end - start)+" 毫秒");
    }

    /*2--字元-普通方法*/
    private static void copy2_1() {
        long start = System.currentTimeMillis();

        try (FileReader fr = new FileReader("D:\\測試資料夾\\1\\西遊記.txt");
             FileWriter fw = new FileWriter("D:\\測試資料夾\\1\\西遊記4.txt");
        ){
            int b;
            while ((b = fr.read())!=-1){
//                System.out.println("---"+(char)b);
                fw.write(b);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("普通流複製時間:"+(end - start)+" 毫秒");
    }

    /*2--字元-緩衝流*/
    private static void copy2_2() {
        long start = System.currentTimeMillis();

        try (BufferedReader fr = new BufferedReader(new FileReader("D:\\測試資料夾\\1\\西遊記.txt"));
             BufferedWriter fw = new BufferedWriter(new FileWriter("D:\\測試資料夾\\1\\西遊記5.txt"));
        ){
            int b;
            while ((b = fr.read())!=-1){
//                System.out.println("---"+(char)b);
                fw.write(b);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("普通流複製時間:"+(end - start)+" 毫秒");
    }

    /*2--帶陣列的字元-緩衝流*/
    private static void copy2_3() {
        long start = System.currentTimeMillis();

        try (BufferedReader fr = new BufferedReader(new FileReader("D:\\測試資料夾\\1\\西遊記.txt"));
             BufferedWriter fw = new BufferedWriter(new FileWriter("D:\\測試資料夾\\1\\西遊記6.txt"));
        ){
            int b;
            char[] chars = new char[100];
            while ((b = fr.read(chars)) != -1){
//                System.out.println("---"+new String(chars,0,b));
                fw.write(chars,0,b);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("普通流複製時間:"+(end - start)+" 毫秒");
    }

    /*3--readLine-讀取一行,和一行分割符*/
    private static void readLine() {
        long start = System.currentTimeMillis();
        try (BufferedReader fr = new BufferedReader(new FileReader("D:\\測試資料夾\\1\\西遊記.txt"));
             BufferedWriter fw = new BufferedWriter(new FileWriter("D:\\測試資料夾\\1\\西遊記7.txt"));
        ){
            String line = null;
            while ((line = fr.readLine())!= null){
//                System.out.println(line);
                fw.write(line);
                fw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("普通流複製時間:"+(end - start)+" 毫秒");

    }

}

轉換流

字元編碼
編碼：計算機中儲存的資訊都是用二進位制數表示的，而我們在螢幕上看到的數字、英文、標點符號、漢字等字元是二進位制 數轉換之後的結果。按照某種規則，將字元儲存到計算機中，稱為編碼 。
解碼：將儲存在計算機中的二進位制數按照 某種規則解析顯示出來，稱為解碼 。
字元編碼 Character Encoding : 就是一套自然語言的字元與二進位制數之間的對應規則。
字符集
字符集 Charset ：也叫編碼表。是一個系統支援的所有字元的集合，包括各國家文字、標點符號、圖形符 號、數字等。
計算機要準確的儲存和識別各種字符集符號，需要進行字元編碼，一套字符集必然至少有一套字元編碼。常見字元 集有ASCII字符集、GBK字符集、Unicode字符集等。
InputStreamReader類
轉換流java.io.InputStreamReader ，是Reader的子類，是從位元組流到字元流的橋樑。它讀取位元組，並使用指定 的字符集將其解碼為字元。它的字符集可以由名稱指定，也可以接受平臺的預設字符集。
構造方法：
InputStreamWriter(InputStream in):建立一個使用預設字符集的字元流。
InputStreamReader(InputStream in,String charsetName):建立一個指定字符集的字元流。
OutputStreamWriter類：
轉換流 java.io.OutputStreamWriter ，是Writer的子類，是從字元流到位元組流的橋樑。使用指定的字符集將字元 編碼為位元組。它的字符集可以由名稱指定，也可以接受平臺的預設字符集。
構造方法：
OutputStreamWriter(OutputStream in):建立一個使用預設字符集的字元流。
OutputStreamWriter(OutputStream in,String charsetName):建立一個指定字符集的字元流。

import java.io.*;

public class Main {

    public static void main(String[] args) {

        //輸入轉換流
        inputStreamReader();
        //輸出轉換流
        outputStreamWriter();
    }


    /*輸入轉換流*/
    private static void inputStreamReader() {

        try (InputStreamReader isr1 = new InputStreamReader(new FileInputStream("D:\\測試資料夾\\1\\ff.txt"));
             InputStreamReader isr2 = new InputStreamReader(new FileInputStream("D:\\測試資料夾\\1\\ff.txt"),"GBK");
        ){
            //UTF-8解碼
            int read;
            while ((read = isr1.read())!=-1){
                System.out.println("UTF-8:"+(char)read);
            }
            //GBK解碼
            int read2;
            while ((read2 = isr2.read())!=-1){
                System.out.println("GBK:"+(char)read2);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /*輸出轉換流*/
    private static void outputStreamWriter() {

        try (OutputStreamWriter osr1 = new OutputStreamWriter(new FileOutputStream("D:\\測試資料夾\\1\\轉換流.txt"),"UTF-8");
             OutputStreamWriter osr2 = new OutputStreamWriter(new FileOutputStream("D:\\測試資料夾\\1\\轉換流2.txt"),"GBK");
        ){
            String wenzi = "氨基酸困難111111及納稅登記時看的見女浮動反饋等方面都開了個貸款房管局";

            //UTF-8解碼
            osr1.write(wenzi);

            //GBK解碼
            osr2.write(wenzi);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

序列化

Java 提供了一種物件序列化的機制。用一個位元組序列可以表示一個物件，該位元組序列包含該 物件的資料 、 物件的 型別 和 物件中儲存的屬性 等資訊。位元組序列寫出到檔案之後，相當於檔案中持久儲存了一個物件的資訊。
反之，該位元組序列還可以從檔案中讀取回來，重構物件，對它進行反序列化。 物件的資料 、 物件的型別 和 物件中 儲存的資料 資訊，都可以用來在記憶體中建立物件。看圖理解序列化：
在這裡插入圖片描述
ObjectOutputStream類，序列化
java.io.ObjectOutputStream 類，將Java物件的原始資料型別寫出到檔案,實現物件的持久儲存。
構造方法：
public ObjectOutputStream(OutputStream out):建立一個指定OutputStream的ObjectOutputStream。
條件：
①該類必須實現 java.io.Serializable 介面， Serializable 是一個標記介面，不實現此介面的類將不會使任 何狀態序列化或反序列化，會丟擲 NotSerializableException 。
② 該類的所有屬性必須是可序列化的。如果有一個屬性不需要可序列化的，則該屬性必須註明是瞬態的，使用 transient 關鍵字修飾。
public class Employee implements java.io.Serializable {

}
方法：
public final void writeObject (Object obj)
ObjectInputStream類，反序列化
ObjectInputStream反序列化流，將之前使用ObjectOutputStream序列化的原始資料恢復為物件。
構造方法：
public ObjectInputStream(InputStream in):建立一個指定InputStream的ObjectInputStream。
注：
對於JVM可以反序列化物件，它必須是能夠找到class檔案的類。如果找不到該類的class檔案，則丟擲一個 ClassNotFoundException 異常。

import java.io.*;
import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {

        //序列化
        xulihua();
        //反序列化
        fanxuliehua();
    }

    /*序列化*/
    private static void xulihua() {
        Stu stu = new Stu("張三","nan",20);
        Stu stu2 = new Stu("李四","女",11);
        Stu stu3 = new Stu("王五","男",33);
        Stu stu4 = new Stu("趙六","女",22);

        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:\\測試資料夾\\1\\序列化.txt"))
        ){
            out.writeObject(stu);
//            out.writeObject(stu2);
//            out.writeObject(stu3);
//            out.writeObject(stu4);

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /*反序列化*/
    private static void fanxuliehua() {
//        ArrayList<Stu> stuList = null;
        Stu stu = null;

        try (ObjectInputStream out = new ObjectInputStream(new FileInputStream("D:\\測試資料夾\\1\\序列化.txt"))
        ){

//            ArrayList<Stu> stu = (ArrayList<Stu>) out.readObject();
            stu = (Stu) out.readObject();
            System.out.println("學生："+stu);
            
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

PrintStream類 列印流

構造方法：
public PrintStream(String fileName) ： 使用指定的檔名建立一個新的列印流。

相關推薦

J-基礎-I/O流-緩衝流、轉換流、序列化流、列印流

技術標籤：java 緩衝流 提高讀寫效率。四個基本的流的增強，分為： 位元組緩衝流：BufferedInputStream，BufferedOutputStream 字元緩衝流：BufferedReader，BufferedWriter 原理： 建立流物件時，建立一個內建的

序列化與反序列化話、os模組

一、序列化與反序列化 import json dic={\'k1\':\'v1\',\'k2\':\'v2\',\'k3\':\'v3\'} print(type(dic))

二、DRF框架中序列化和反序列化

資料校驗 比如 將前端傳遞的json格式資料轉化為python中的資料型別（模型類物件）叫做反序列化

Java（7）面向物件——繼承性、方法的重寫、super關鍵字、修飾符小結、子類物件例項化過程、程式碼塊、內部類

技術標籤：java面向物件程式設計類 目錄 繼承性方法的重寫super關鍵字修飾符小結許可權修飾符：static修飾符：final修飾符：

python中的load、loads實現反序列化

load與loads 簡介： 在python自動化中，我們傳遞一些引數是需要從檔案中讀取過來的，讀取過來的字典並非python物件資料型別而是string型別。

9、Django框架--Ajax傳送post請求、Ajax上傳檔案、Ajax上傳json格式資料、Django內建序列化、分頁器的使用

1 ajax傳送post請求 1 大坑 -如果在form表單中，寫button和input是submit型別，會觸發form表單的提交

Django中資料傳輸編碼格式、ajax傳送json資料、ajax傳送檔案、django序列化元件、ajax結合sweetalert做二次彈窗、批量增加資料

目錄 前後端傳輸資料的編碼格式(contentType) 提交post請求的兩種方式: 前後端傳輸資料的編碼格式

Django學習——ajax傳送其他請求、上傳檔案（ajax和form兩種方式）、ajax上傳json格式、 Django內建序列化（瞭解）、分頁器的使用

1 ajax傳送其他請求 1 寫在form表單 submit和button會觸發提交<form action=\"\"> </form>註釋

Java中I/O流實現字元流、位元組流和緩衝流對檔案的輸入輸出

技術標籤：Java學習javastream Java程式中，對於資料的輸入/輸出操作以 “流(stream)” 的方式進行。 java.io包下提供了各種“流”類和介面，用以獲取不同種類的資料，並通過標準的方法輸入或輸出資料。

Hadoop基礎（十）： HDFS客戶端操作（三）HDFS的I/O流操作

2HDFS的I/O流操作 2.1HDFS檔案上傳 1．需求：把本地e盤上的banhua.txt檔案上傳到HDFS根目錄

Java基礎學習01--I/O位元組流基本使用

Java的I/O流可以分為：位元組流和字元流。本文重點介紹位元組流的基本使用。

Java基礎學習02--I/O字元流基本使用

1.FileReader與FileWriter 1 package io.demo.chars; 2 3 import java.io.FileReader; 4 5 //使用FileReader讀取檔案，可讀取英文也可以讀取中文等各種文字

I/O流 基礎day-17

技術標籤：基礎java 1.I/O流 1.1 基本概念I/O就是Input/Output的含義，也就是輸入/輸出的含義。I/O流就是指像流水一樣不間斷地進行輸入輸出的過程。

java基礎筆記(十九)——緩衝流、轉換流、序列化流

第一章 緩衝流 前面學習了基本的一些流，作為IO流的入門，今天我們要見識一些更強大的流。比如能夠高效讀寫的緩衝流，能夠轉換編碼的轉換流，能夠持久化儲存物件的序列化流等等。這些功能更為強大的流，都是在基本的

檔案I/O流、檔案、FileInputStreaam、FileOutputStream、FileReader、FileWriter的介紹和使用

一、檔案：儲存資料的地方 1、檔案流：檔案在程式中是以流的形式類操作的 類比：

C++學習記錄（十一）容器deque、list、stack、set、map，I/O檔案流，多執行緒入口

這是第十一天的學習。 1 #include <iostream> 2 #include <deque> 3 #include <algorithm>

Java使用I/O流讀取檔案內容的方法詳解

本文例項講述了Java使用I/O流讀取檔案內容的方法。分享給大家供大家參考，具體如下：

Python3 io文字及原始流I/O工具用法詳解

io模組在直譯器的內建open()之上實現了一些類來完成基於檔案的輸入和輸出操作。這些類得到了適當的分解，從而可以針對不同的用途重新組合——例如，支援向一個網路套接字寫Unicode資料。

Java【緩衝流、轉換流、序列化流、列印流】學習筆記

【緩衝流、轉換流、序列化流、列印流】 緩衝流 緩衝流，能夠轉換編碼的轉換流，能夠持久化儲存物件的序列化流等等。這些功能更為強大的流，都是在基本的流物件基礎之上建立而來的，就像穿上鎧甲的武士一樣，相當於是

I/O流

基本概念 什麼是 I/O？ 通過I/O 可以完成硬碟檔案的讀和寫。 概念圖：輸入、輸出是相對於記憶體而言的，以記憶體為參照物。