IO流（输入流、输出流）

一、字节流

InputStream抽象了应用程序读取数据的方式
OutputStream抽象了应用程序写出数据的方式
EOF=End 读到-1就读到结尾
输入流基本方法
(1) int b=in.read();读取一个字节无符号填充到int低八位。-1是EOF
(2) int.read(byte[] buf) 读取数据填充到字节数组buf
(3) int.read(byte[] buf,int start,int size)
输出流基本方法
(1) out.write(int b)写出一个byte到流，b的低八位
(2) out.write(byte[] buf)将buf字节数组都写入到流
(3) out.write(byte[] buf,int start,int size) 字节数组buf从start位置开始写size长度的字节到流
(1) FileInputStream 子类，具体实现了在文件上读取数据，继承了InputStream类
(2) FileOutputStream 子类，具体实现向文件中写出byte数据的方法，继承了OutputStream类
(3) DataInputStream&DataOutputStream，对流功能的扩展，可以更方便的读取int,long,字符等类型的数据
(4) BufferedInputStream& BufferedOutputStream ,这两个流类为IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能，从应用程序中把输入放入文件，相当于一缸水倒入到另外一缸水。
FileOutputStream使用write()方法相当于一滴一滴的把水转移过去。
DataOutputStream使用writeXXX()方法方便一些，相当于一瓢一瓢把水转移过去。
BufferedOutputStream使用writeXXX()方法更方便一些，相当于一瓢一瓢把水放在一个桶中，再用桶倒入到另外一缸中。

FileInputStream 子类

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

public class IOUtil {
    
    

    /*
    读取指定文件内容，按照16进制输出到控制台
    并且每输出10个byte换行
    * */
    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) {
    
    
                //单位数前面补0
                System.out.print("0");
            }
            System.out.print(Integer.toHexString(b) + " "); //将整型b转换为16进制表示的字符串
            if (i++ % 10 == 0) {
    
    
                System.out.println();
            }
        }
        in.close();
    }

    public static void printHexByByteArray(String fileName) throws IOException {
    
    
        FileInputStream in = new FileInputStream(fileName);
        byte[] buf = new byte[20 * 1024];
        /*
        从int中批量读取字节，放入到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])+" ");
            if(j++%10==0){
                System.out.println();
            }
        }*/


        //当字节数组一次未必能容纳下的时候
        int bytes=0;
        int j=1;
        while ((bytes=in.read(buf,0,buf.length))!=-1){
    
    
            for (int i = 0; i < bytes; i++) {
    
    
                System.out.print(Integer.toHexString(buf[i]&0xff)+" ");//buf[i]&0xff  byte类型8位，int类型32位
                if(j++%10==0){
    
                                                //为了避免数据转换错误，通过&0xff将高24位清零
                    System.out.println();
                }
            }
        }
    }

/*==========================================================*/
public class IOUtilTest1 {
    
    
    public static void main(String[] args) {
    
    
        try {
    
    
            IOUtil.printHex("D:\\code\\IO\\demo\\新建文本文档.txt");
            System.out.println();
            System.out.println("============================================");
            IOUtil.printHexByByteArray("D:\\code\\IO\\demo\\新建文本文档.txt");
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
    }
}
/*输出：
30 20 31 20 32 20 33 20 34 20 
35 20 36 20 37 20 38 20 39 20 
31 30 20 31 31 20 31 32 20 31 
33 20 31 34 20 31 35 20 
============================================
30 20 31 20 32 20 33 20 34 20 
35 20 36 20 37 20 38 20 39 20 
31 30 20 31 31 20 31 32 20 31 
33 20 31 34 20 31 35 20 
Process finished with exit code 0
*/

FileOutputStream子类

public class FileOutDemo1 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //如果该文件不存在，则直接创建，如果存在，删除后创建
        FileOutputStream out=new FileOutputStream("D:\\code\\IO\\demo\\新建文本文档1.txt");
        out.write('A'); //写出了A的低八位
        out.write('B'); //写出了B的低八位
        int a=10;//write 只能写八位，那么写一个int需要写4次   每次8位
        out.write(a>>>24);
        out.write(a>>>16);
        out.write(a>>>8);
        out.write(a);
        byte[] gbk="中国".getBytes("gbk");
        out.write(gbk);
        out.close();

        IOUtil.printHex("D:\\code\\IO\\demo\\新建文本文档1.txt");
    }
}

编译运行后：
在这里插入图片描述

public class IOUtil {
    
    
    /*
    读取指定文件内容，按照16进制输出到控制台
    并且每输出10个byte换行
    * */
    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) {
    
    
                //单位数前面补0
                System.out.print("0");
            }
            System.out.print(Integer.toHexString(b) + " "); //将整型b转换为16进制表示的字符串
            if (i++ % 10 == 0) {
    
    
                System.out.println();
            }
        }
        in.close();
    }

    //复制方法
    public static void copyFile(File scrFile, File desFile) throws IOException{
    
    
        if(!scrFile.exists()){
    
    
            throw new IllegalArgumentException("文件"+scrFile+"不存在");
        }
        if(!scrFile.isFile()){
    
    
            throw new IllegalArgumentException(scrFile+"不是文件");
        }
        FileInputStream in=new FileInputStream(scrFile);
        FileOutputStream out=new FileOutputStream(desFile);
        byte[] buf=new byte[8*1024];
        int b;
        while ((b=in.read(buf,0,buf.length))!=-1){
    
    
            out.write(buf,0,b);
            out.close();
        }
        in.close();
        out.close();
    }

    public static void printHexByByteArray(String fileName) throws IOException {
    
    
        FileInputStream in = new FileInputStream(fileName);
        byte[] buf = new byte[20 * 1024];
        /*
        从int中批量读取字节，放入到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])+" ");
            if(j++%10==0){
                System.out.println();
            }
        }*/

        //当字节数组一次未必能容纳下的时候
        int bytes=0;
        int j=1;
        while ((bytes=in.read(buf,0,buf.length))!=-1){
    
    
            for (int i = 0; i < bytes; i++) {
    
    
                System.out.print(Integer.toHexString(buf[i]&0xff)+" ");//buf[i]&0xff  byte类型8位，int类型32位
                if(j++%10==0){
    
                                                //为了避免数据转换错误，通过&0xff将高24位清零
                    System.out.println();
                }
            }
        }
    }
}

/*====================================================*/
public class IOUtilTest2 {
    
    
    public static void main(String[] args) {
    
    
        try {
    
    
            IOUtil.copyFile(new File("D:\\code\\IO\\demo\\d.txt"),
                     new File("D:\\code\\IO\\demo\\d1.txt"));
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
    }
}

编译运行后：
在这里插入图片描述

DataInputStream/DataOutputStream

public class DosDemo {
    
    
    public static void main(String[] args) throws IOException {
    
    
        String file="D:\\code\\IO\\demo\\Data1.dat";
        DataOutputStream dos=new DataOutputStream(new FileOutputStream(file));
        dos.writeInt(10);  //要是用write()就需要写四次
        dos.writeLong(-10);
        dos.writeLong(10L);
        dos.writeDouble(10.5);
        dos.writeUTF("中国"); //采用utf-8编码
        dos.writeChars("中国");//采用utf-16be编码

        IOUtil.printHex(file);
    }
}
/*输出：
00 00 00 0a ff ff ff ff ff ff 
ff f6 00 00 00 00 00 00 00 0a 
40 25 00 00 00 00 00 00 00 06 
e4 b8 ad e5 9b bd 4e 2d 56 fd 

Process finished with exit code 0
*/

/*==========================================================*/
public class DisDemo {
    
    
    public static void main(String[] args) throws IOException {
    
    
        String file="D:\\code\\IO\\demo\\Data1.dat";
        IOUtil.printHex(file);
        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();
    }
}
/*输出：
00 00 00 0a ff ff ff ff ff ff 
ff f6 00 00 00 00 00 00 00 0a 
40 25 00 00 00 00 00 00 00 06 
e4 b8 ad e5 9b bd 4e 2d 56 fd 
10
-1
-42949672960
2.17516548836E-313


Process finished with exit code 0
*/

BufferedInputStream& BufferedOutputStream

public class IOUtil {
    
    
    /*
    进行文件拷贝，字节批量读取
    * */
    public static void copyFile(File scrFile, File desFile) throws IOException{
    
    
        if(!scrFile.exists()){
    
    
            throw new IllegalArgumentException("文件"+scrFile+"不存在");
        }
        if(!scrFile.isFile()){
    
    
            throw new IllegalArgumentException(scrFile+"不是文件");
        }
        FileInputStream in=new FileInputStream(scrFile);
        FileOutputStream out=new FileOutputStream(desFile);
        byte[] buf=new byte[8*1024];
        int b;
        while ((b=in.read(buf,0,buf.length))!=-1){
    
    
            out.write(buf,0,b);
            out.close();
        }
        in.close();
        out.close();
    }

    /*
    进行文件的拷贝，利用带缓冲的字节流
    * */
    public static void copyFileByBuffer(File scrFile,File destFile) throws IOException{
    
    
        if(!scrFile.exists()){
    
    
            throw new IllegalArgumentException("文件"+scrFile+"不存在");
        }
        if(!scrFile.isFile()){
    
    
            throw new IllegalArgumentException(scrFile+"不是文件");
        }
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream(scrFile));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(destFile));
        int c;
        while ((c=bis.read())!=-1){
    
    
            bos.write(c);
            bos.flush();//刷新缓冲区
        }
        bis.close();
        bos.close();
    }

    /*
    单字节不带缓冲，进行文件拷贝
    * */
    public static void copyFileByByte(File scrFile,File desFile)throws IOException{
    
    
        if(!scrFile.exists()){
    
    
            throw new IllegalArgumentException("文件"+scrFile+"不存在");
        }
        if(!scrFile.isFile()){
    
    
            throw new IllegalArgumentException(scrFile+"不是文件");
        }
        FileInputStream in=new FileInputStream(scrFile);
        FileOutputStream out=new FileOutputStream(desFile);
        int c;
        while ((c=in.read())!=-1){
    
    
            out.write(c);
            out.flush();
        }
        in.close();
        out.close();
    }   
}
/*==========================================================*/

/*
测试类
*/
public class IOUtilTest4 {
    
    
    public static void main(String[] args) {
    
    
        try {
    
    
            long start=System.currentTimeMillis();
            /*IOUtil.copyFileByByte(new File("D:\\code\\IO\\demo\\新建文本文档.txt"),
                    new File("D:\\code\\IO\\demo\\aa.txt")); 81毫秒 */
            /*IOUtil.copyFileByBuffer(new File("D:\\code\\IO\\demo\\新建文本文档.txt"),
                    new File("D:\\code\\IO\\demo\\aa.txt")); 12毫秒*/
            IOUtil.copyFile(new File("D:\\code\\IO\\demo\\新建文本文档.txt"),
                    new File("D:\\code\\IO\\demo\\aa.txt"));//2毫秒
            long end=System.currentTimeMillis();
            System.out.println(end-start);//计算操作的时间
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
    }
}

编译运行后对文件的操作结果：
在这里插入图片描述

IO流（字节流）

IO流（输入流、输出流）

一、字节流

猜你喜欢