Java IO之字节流

Java IO之字节流

一、Java字节流简介：

　　在Java中，字节流一般适用于处理字节数据(诸如图片、视频),字符流适用于处理字符数据(诸如文本文件)，但二者并没有严格的功能划分，因为有转换流的存在，使得对于数据的处理变得更加灵活。
　　InputStream和OutputStream分别是字节输入流与字节输出流的抽象基类，它们的子类都是字节流，主要用在按字节来处理二进制数据

　　InputStream抽象了应用程序读取数据的方式，OutputStream抽象了应用程序写出数据的方式

　　FileInputStream--->具体实现了在文件上读取数据，FileOutputStream 实现了向文件中写出byte数据的方法

　　DataOutputStream和DataInputStream是对"流"功能的扩展，可以更加方面的读取int,long，字符等类型数据

　　BufferedInputStream和BufferedOutputStream，这两个流类为IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能

　　性能比较：从应用程序中把输入放入文件，相当于将一缸水倒入到另一个缸中:，其中：

　　　　FileOutputStream--->write()方法相当于一滴一滴地把水“转移”过去

　　　　DataOutputStream-->writeXxx()方法会方便一些，相当于一瓢一瓢把水“转移”过去

　　　　BufferedOutputStream--->write方法更方便，相当于一飘一瓢先放入桶中，再从桶中倒入到另一个缸中，性能提高了

　　文件读取：EOF = End   读到-1就读到结尾

　　本篇从字节流开始。主要包含以下内容：

• InputStream/OutPutStream - - -字节流基类
• FileInputStream/FileOutputStream - - - - -处理文件类型
• ByteArrayInputStream/ByteArrayOutputStream - - - -字节数组类型
• DataInputStream/DataOutputStream - - - -装饰类
• BufferedInputStream/BufferedOutputStream - - - -缓冲流

　　常用字节流继承结构图：

常用方法说明：

输入流基本方法

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

in.read(byte[] buf)

in.read(byte[] buf,int start,int size)
输出流基本方法

out.write(int b)  写出一个byte到流，b的低8位

out.write(byte[] buf)将buf字节数组都写入到流

out.write(byte[] buf,int start,int size)

二、实例分析：

这里我们就基于字节流写个工具类分析分析吧

package me.io;  2 
import java.io.BufferedInputStream;  4 import java.io.BufferedOutputStream;  5 import java.io.File;  6 import java.io.FileInputStream;  7 import java.io.FileOutputStream;  8 import java.io.IOException;  9 
public class IOUtils {  11 
    /**
 * 读取指定文件内容，按照16进制输出到控制台 并且每输出10个byte换行  14  *  15  * @param fileName  16  * @throws IOException  17      */
    public static void printHex(String fileName) throws IOException {  19     // 把文件作为字节流进行读操作
    FileInputStream fis = new FileInputStream(fileName);  21     int b = 0;  22     int i = 1;  23     while ((b = fis.read()) != -1) {  24         if (b <= 0xf) {  25         // 单位数前面补0
        System.out.print('0');  27  }  28         System.out.print(Integer.toHexString(b) + "  ");  29         if (i++ % 10 == 0) {  30  System.out.println();  31  }  32  }  33  fis.close();  34  }  35 
    /**
 * 读取文件放入到字节数组中，再遍历打印到控制台  38  *  39  * @param fileName  40  * @throws IOException  41      */
    public static void printHexByByteArray(String fileName) throws IOException {  43     FileInputStream fis = new FileInputStream(fileName);  44     byte[] buf = new byte[20 * 1024];  45 
    /**
 * 从fis中批量读取字节，放入到buf这个字节数组中 从第零个位置开始放，最多放buf.length个字节 返回的是读到的字节个数  48  * 一次性读完，说明字节数组足够大  49      */

    /*
 int bytes = fis.read(buf, 0, buf.length);  53  int j = 1;  54  for (int i = 0; i < bytes; i++) {  55  if (buf[i] <= 0xf && buf[i] >= 0x0) {  56  System.out.print('0');  57  }  58  System.out.print(Integer.toHexString(buf[i]) + " ");  59  if (j++ % 10 == 0) {  60  System.out.println();  61  }  62  }*/

    int j = 1;  65     int bytes = 0;  66     while ((bytes = fis.read(buf, 0, buf.length)) != -1) {  67         for (int i = 0; i < bytes; i++) {  68         System.out.print(Integer.toHexString(buf[i] & 0xff) + "  ");  69         if (j++ % 10 == 0)  70  System.out.println();  71  }  72  }  73  fis.close();  74  }  75 
    /**
 * 文件拷贝，字节批量读取  78  *  79  * @param srcFile  80  * @param destFile  81  * @throws IOException  82      */
    public static void copyFile(File srcFile, File destFile) throws IOException {  84     if (!srcFile.exists())  85         throw new IllegalArgumentException("文件" + srcFile + "不存在！");  86     if (!srcFile.isFile())  87         throw new IllegalArgumentException(srcFile + "不是文件！");  88     FileInputStream fis = new FileInputStream(srcFile);  89     FileOutputStream fos = new FileOutputStream(destFile);  90     byte[] buf = new byte[8 * 1024];  91     int b = 0;  92     while ((b = fis.read(buf, 0, buf.length)) != -1) {  93         fos.write(buf, 0, b);  94         fos.flush();// 最好加上
 }  96  fis.close();  97  fos.close();  98  }  99 
    /**
 * 使用带缓冲区的字节流进行文件拷贝 102  * 103  * @param srcFile 104  * @param destFile 105  * @throws IOException 106      */
    public static void copyFileByBuffer(File srcFile, File destFile) throws IOException { 108     if (!srcFile.exists()) 109         throw new IllegalArgumentException("文件" + srcFile + "不存在！"); 110     if (!srcFile.isFile()) 111         throw new IllegalArgumentException(srcFile + "不是文件！"); 112 
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)); 114     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile)); 115     int c = 0; 116     while ((c = bis.read()) != -1) { 117  bos.write(c); 118         bos.flush();// 刷新缓冲区
 } 120  bis.close(); 121  bos.close(); 122  } 123 
    /**
 * 单字节不带缓冲区拷贝文件 126  * 127  * @param srcFile 128  * @param destFile 129  * @throws IOException 130      */
    public static void copyFileByByte(File srcFile, File destFile) throws IOException { 132     if (!srcFile.exists()) 133         throw new IllegalArgumentException("文件" + srcFile + "不存在！"); 134     if (!srcFile.isFile()) 135         throw new IllegalArgumentException(srcFile + "不是文件！"); 136     FileInputStream fis = new FileInputStream(srcFile); 137     FileOutputStream fos = new FileOutputStream(destFile); 138     int c = 0; 139     while ((c = fis.read()) != -1) { 140  fos.write(c); 141         fos.flush();// 刷新缓冲区
 } 143  fis.close(); 144  fos.close(); 145  } 146 
    /**
 * 带缓冲区批量拷贝文件 149  * 150  * @param srcFile 151  * @param destFile 152  * @throws IOException 153      */
    public static void cloneFile(File srcFile, File destFile) throws IOException { 155     if (!srcFile.exists()) 156         throw new IllegalArgumentException("文件" + srcFile + "不存在!"); 157     if (!srcFile.isFile()) 158         throw new IllegalArgumentException(srcFile + "不是文件！"); 159     BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)); 160     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile)); 161     byte[] buf = new byte[8 * 1024]; 162     int bytes = 0; 163     while ((bytes = bis.read(buf, 0, buf.length)) != -1) { 164         bos.write(buf, 0, bytes); 165  bos.flush(); 166  } 167  bis.close(); 168  bos.close(); 169  } 170 }

package me.io;  2 
import java.io.FileOutputStream;  4 import java.io.IOException;  5 
public class FileOutDemo {  7 
    public static void main(String[] args) throws IOException {  9     //若果文件不存在，则直接创建，如果文件存在，则删除后创建,如果要追加内容，则应该传入参数true
    @SuppressWarnings("resource") 11     FileOutputStream fos = new FileOutputStream("demo/out.dat"); 12     
    fos.write('A');//写入A的低八位
    fos.write('B'); 15     
    //写一个int，要写四次
    int i = 0x7fffffff; 18     fos.write(i >>> 24); 19     fos.write(i >>> 16); 20     fos.write(i >>> 8); 21  fos.write(i); 22     IOUtils.printHex("demo/out.dat"); 23  } 24 }

package me.io;  2 
import java.io.DataInputStream;  4 import java.io.FileInputStream;  5 import java.io.IOException;  6 
public class DisDemo {  8 
    public static void main(String[] args) throws IOException { 10     String file = "demo/dos.dat"; 11     DataInputStream dis = new DataInputStream(new FileInputStream(file)); 12  System.out.println(dis.readInt()); 13  System.out.println(dis.readInt()); 14  System.out.println(dis.readDouble()); 15  System.out.println(dis.readLong()); 16  System.out.println(dis.readUTF()); 17  System.out.println(dis.readChar()); 18  } 19 }

package me.io;  2 
import java.io.DataOutputStream;  4 import java.io.FileOutputStream;  5 import java.io.IOException;  6 
/**
 * DataOutputStream测试类  9  * @author Administrator 10  * 11  */
public class DosDemo { 13 
    public static void main(String[] args) throws IOException { 15     String file = "demo/dos.dat"; 16     DataOutputStream dos = new DataOutputStream(new FileOutputStream(file)); 17     dos.writeInt(10); 18     dos.writeInt(-10); 19     dos.writeDouble(10.5); 20     dos.writeLong(10l); 21     
    //采用UTF-8编码写出：
    dos.writeUTF("中国");//三个字节 24     //采用UTF-16be编码写出
    dos.writeChars("中国");//两个字节
 dos.close(); 27     IOUtils.printHex("demo/dos.dat"); 28  } 29 }

package me.io;  2 
import java.io.File;  4 import java.io.IOException;  5 
public class IOUtilsMain {  7 
    public static void main(String[] args) throws IOException {  9     // IOUtils.printHex("src/me/io/IOUtils.java"); 10     // IOUtils.printHexByByteArray("src/me/io/IOUtils.java");
    long start = System.currentTimeMillis(); 12     //IOUtils.copyFile(new File("demo/1.mp3"), new File("demo/4.mp3"));//58 13     //IOUtils.copyFileByBuffer(new File("demo/1.mp3"), new File("demo/2.mp3"));//26631毫秒 14     //IOUtils.copyFileByByte(new File("demo/1.mp3"), new File("demo/3.mp3"));//39722
    IOUtils.cloneFile(new File("demo/1.mp3"), new File("demo/5.mp3"));//77
    long end = System.currentTimeMillis(); 17     System.out.println(end - start);//文件大小为3.2m
 } 19 }

这里从main方法打印结果可以看出：我们在拷贝文件时，建议用字节批量读取，相对较快一点