Java—IO流字節流

時間 2019-12-11

標籤 java 節流欄目 Java 简体版

原文原文鏈接

　　IO流（輸入流、輸出流），又分爲字節流、字符流。java

　　流是磁盤或其它外圍設備中存儲的數據的源點或終點。數組

　　輸入流：程序從輸入流讀取數據源。數據源包括外界(鍵盤、文件、網絡…)，便是將數據源讀入到程序的通訊通道。網絡

　　輸出流：程序向輸出流寫入數據。將程序中的數據輸出到外界（顯示器、打印機、文件、網絡…）的通訊通道。性能

字節流

　　1.InputStream、OutputStream測試

　　InputStream抽象了應用程序讀取數據的方式spa

　　OutputStream抽象了應用程序寫出數據的方式code

　　2.讀到文件結尾，稱爲EOF = end，讀到-1就讀到結尾blog

　　3.輸入流基本方法get

　　int b = in.read();讀取一個字節，無符號填充到int的低八位.-1是EOFit

　　int.read(byte[] buf)讀取數據填充到字節數組buf

　　int.read(byte[] buf, int start, int size)讀取數據填充到字節數組buf，從buf的start位置開始存儲size長度的數據

　　4.輸出流基本方法

　　out.write(int b);寫出一個byte到流，b的低八位

　　out.write(byte[] buf);將buf字節數組都寫入到流

　　out.write(byte[] buf, int start, int size);字節數組buf從start位置開始寫size長度的字節到流

　　5.FileInputStream是InputStream的子類，具體實現了在文件上讀取數據

　 6.FileOutputStream是OutputStream的子類，實現了向文件中寫出字節數據的方法

　　FileInputStream的demo：

package com.test.io;

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

public class IOUtils {
    /**
     * 讀取指定文件內容，按照十六進制輸出到控制檯
     * 而且每輸出10個byte換行
     * @param fileName
     * @throws IOException
     */
    public static void printHex(String fileName) throws IOException {
        //把文件做爲字節流進行讀操做
        FileInputStream in = new FileInputStream(fileName);
        int b;
        int i = 1;
        while ((b = in.read()) != -1) {
            if (b <= 0xf) {
                System.out.print("0");
            }
            System.out.print(Integer.toHexString(b) + "  ");
            if (i % 10 == 0) {
                System.out.println("");
            }
            i++;
        }
        in.close();
    }

    public static void printHexByByteArray(String fileName) throws IOException {
        FileInputStream in = new FileInputStream(fileName);
        byte[] buf = new byte[20*1024];
        
        //若是字節數組夠大，能夠一次性讀完
        //從in中批量讀取字節，放入到buf這個字節數組中，從第0個位置開始放，最多放buf.length個，返回的是讀到的字節的個數
        /* int bytes = in.read(buf, 0, buf.length);
        int j = 1;
        for(int i = 0;i < bytes; i++) {
            if (buf[i] <= 0xf) {
                System.out.print("0");
            }
            System.out.print(Integer.toHexString(buf[i] & 0xff) + "  ");
            if (j % 10 == 0) {
                System.out.println("");
            }
            j++;
        } */
        
        //若是字節數組不夠大，不能一次性讀完
        int bytes = 0;
        int j = 1;
        while ((bytes = in.read(buf, 0, buf.length)) != -1) {
            for (int i = 0; i <bytes; i++) {
                if (buf[i] <= 0xf) {
                    System.out.print("0");
                }
                System.out.print(Integer.toHexString(buf[i] & 0xff) + "  ");
                if (j % 10 == 0) {
                    System.out.println("");
                }
                j++;
            }
        }
    }

}

　　FileOutputStream的demo：

package com.test.io;

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

public class FileOutputDemo {

    public static void main(String[] args) throws IOException {
        //若是該文件不存在，則直接建立，若是存在，刪除後建立。（若是第二個參數爲 true，則將字節寫入文件末尾處，而不是寫入文件開始處。）
        FileOutputStream out = new FileOutputStream("F:\\javaio\\out.dat");
        out.write('A');//寫入了‘A’的低八位（一次只寫入一個字節）
        int a = 10;
        out.write(a >>> 24);
        out.write(a >>> 16);
        out.write(a >>> 8);
        out.write(a);
        
        byte[] b = "10".getBytes();
        out.write(b);
        
        out.close();
        
        IOUtils.printHex("F:\\javaio\\out.dat");        
    }
}

　　7.DataOutputStream和DataInputStream，對流功能的擴展，能夠更加方便的讀取int，long，字符等類型數據。

package com.test.io;

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

public class DataOutputDemo {

    public static void main(String[] args) throws IOException {
        String file = "F:\\javaio\\b.txt";
        DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
        dos.writeInt(10);
        dos.writeInt(-10);
        dos.writeLong(10l);
        dos.writeDouble(10.5);
        dos.writeUTF("你好");
        dos.writeChars("中國");
        dos.close();
        IOUtils.printHex(file);
    }
}

　　運行結果：

00  00  00  0a  ff  ff  ff  f6  00  00  
00  00  00  00  00  0a  40  25  00  00  
00  00  00  00  00  06  e4  bd  a0  e5  
a5  bd  4e  2d  56  fd

　　其中，00 06兩個字節是「你好」這兩個中文的字節個數。

package com.test.io;

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DataInputDemo {

    public static void main(String[] args) throws IOException {
        String file = "F:\\javaio\\b.txt";
        DataInputStream dis = new DataInputStream(new FileInputStream(file));
        int i = dis.readInt();
        System.out.println(i);
        i = dis.readInt();
        System.out.println(i);
        long l = dis.readLong();
        System.out.println(l);
        double d = dis.readDouble();
        System.out.println(d);
        String s = dis.readUTF();
        System.out.println(s);
        dis.close();
    }

}

　　運行結果：

10
-10
10
10.5
你好

　　8.BufferedInputStream&BufferedOutputStream，這兩個流類爲IO提供了帶緩衝區的操做，通常打開文件進行寫入或讀取操做時，都會加上緩衝，這種流模式提升了IO的性能。

　　文件的拷貝：

package com.test.io;

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

public class IOUtils {/**
     * 拷貝文件,字節批量讀取
     * @param srcFile 源文件
     * @param destFile 目標文件
     * @throws IOException
     */
    public static void copyFile(File srcFile, File destFile) throws IOException {
        if (!srcFile.exists()) {
            throw new IllegalArgumentException("文件" + srcFile + "不存在");
        }
        if (!srcFile.isFile()) {
            throw new IllegalArgumentException(srcFile + "不是文件");
        }
        FileInputStream in = new FileInputStream(srcFile);
        FileOutputStream out = new FileOutputStream(destFile);
        byte[] buf = new byte[10*1024];
        int b;
        while ((b = in.read(buf, 0, buf.length)) != -1) {
            out.write(buf,0,b);
            out.flush();//最好加上，刷新此輸出流並強制寫出全部緩衝的輸出字節。
        }
        in.close();
        out.close();
    }
    /**
     * 拷貝文件，利用帶緩衝的字節流
     * @param srcFile
     * @param destFile
     * @throws IOException
     */
    public static void copyFileByBuffer(File srcFile, File destFile) throws IOException {
        if (!srcFile.exists()) {
            throw new IllegalArgumentException("文件" + srcFile + "不存在");
        }
        if (!srcFile.isFile()) {
            throw new IllegalArgumentException(srcFile + "不是文件");
        }
        FileInputStream in = new FileInputStream(srcFile);
        FileOutputStream out = new FileOutputStream(destFile);
        
        BufferedInputStream bis = new BufferedInputStream(in);
        BufferedOutputStream bos = new BufferedOutputStream(out);
        
        int c;
        while ((c = bis.read()) != -1) {
            bos.write(c);
            bos.flush();
        }
        
        bis.close();
        bos.close();
    }
    /**
     * 拷貝文件，經過單字節讀取
     * @param srcFile
     * @param destFile
     * @throws IOException
     */
    public static void copyFileByByte(File srcFile, File destFile) throws IOException {
        if (!srcFile.exists()) {
            throw new IllegalArgumentException("文件" + srcFile + "不存在");
        }
        if (!srcFile.isFile()) {
            throw new IllegalArgumentException(srcFile + "不是文件");
        }
        FileInputStream in = new FileInputStream(srcFile);
        FileOutputStream out = new FileOutputStream(destFile);
        
        int c;
        while ((c = in.read()) != -1) {
            out.write(c);
            out.flush();
        }
        
        in.close();
        out.close();
    }
}

　　測試文件拷貝：

package com.test.io;

import java.io.File;
import java.io.IOException;

public class IOUtilsTest {

    public static void main(String[] args) {
        //IOUtils.printHex("D:\\javaProgram\\Hello.java");
        try {
            long start = System.currentTimeMillis();
            //IOUtils.copyFile(new File("F:\\javaio\\1.mp3"), new File("F:\\javaio\\2.mp3"));//211ms
            //IOUtils.copyFileByBuffer(new File("F:\\javaio\\1.mp3"), new File("F:\\javaio\\3.mp3"));//18583ms
            IOUtils.copyFileByByte(new File("F:\\javaio\\1.mp3"), new File("F:\\javaio\\4.mp3"));//37822ms
            long end = System.currentTimeMillis();
            System.out.println(end - start);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}