首页 > 代码库 > Java—IO流 字节流

Java—IO流 字节流

  IO流(输入流、输出流),又分为字节流、字符流。

  流是磁盘或其它外围设备中存储的数据的源点或终点。

  输入流:程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…),即是将数据源读入到程序的通信通道。

  输出流:程序向输出流写入数据。将程序中的数据输出到外界(显示器、打印机、文件、网络…)的通信通道。

  • 字节流

  1.InputStream、OutputStream

  InputStream抽象了应用程序读取数据的方式

  OutputStream抽象了应用程序写出数据的方式

  2.读到文件结尾,称为EOF = end,读到-1就读到结尾

  3.输入流基本方法

  int b = in.read();读取一个字节,无符号填充到int的低八位.-1是EOF

  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();
        }
    }
}

  根据以上测试看出,文件拷贝,最快的方式是通过字节的批量读取。

 

Java—IO流 字节流