Java进阶第八章——I/O流:常用流

发布时间:2024年01月19日

I/O流

1.I/O流概述

  • 输入流:从硬盘读到内存中,或者叫输入,读(Read)、输入(Input)、输入流(InputStream)。

    输出流:从内存写到硬盘中,或者叫输出,写(Write)、输出(Output)、输出流(OutputStream)。

  • 字节流:按照字节读取数据,一次读取1个字节Byte,等同于一次读取8个二进制。这种流是万能的,什么类型文件都可以读取。包括:文本文件、图片、声音文件等。

    字符流:按照字符读取数据,一次读取一个字符,这种流方便读取普通文本。只能读取纯文本文件,无法读取word文件,因为word文件有格式。

  • Java中所有流都在:java.io.*;

  • Java中的IO流(都是抽象类):

    字节输入流(万能的):java.io.InputStream

    字节输出流(万能的):java.io.OutputStream

    字符输入流(只能处理纯文本文件):java.io.Reader

    字符输出流(只能处理纯文本文件):java.io.Writer

    类名以“Stream”结尾是字节流,以“Reader/Writer”结尾是字符流。

  • Java中所有流都实现了java.io.Closeable接口,都是可关闭的,都有close()方法。流是内存和硬盘之间的通道,用完之后要关闭,否则会占用资源。

    所有的输出流都实现了java.io.Flushable接口,都是可刷新的,都有flush()方法。输出流在最终输出后,一定要用flush()刷新一下,清空管道。如果没有flush可能会丢失数据。

  • 常用java.io包下的16个流:

    文件专属:java.io.FileInputStream、java.io.FileOutputStream、java.io.FileReader、java.io.FileWriter

    转换流(字节流转换成字符流):java.io.InputStreamReader、java.io.OutputStreamWriter

    缓冲流专属:java.io.BufferedReader、java.io.BufferedWriter、java.io.BufferedInputStream、java.io.BufferedOutputStream

    数据流专属:java.io.DataInputStream、java.io.DataOutputStream

    标准输出流:java.io.PrintWriter、java.io.PrintStream

    对象专属流:java.io.ObjectInputStream、java.io.ObjectOutputStream

2.文件专属FileInputStream

  • FileInputStream:文件字节输入流,万能的,任何类型的文件都可以采用这个流来读。

  • 字节方式:从硬盘到内存完成输入操作,完成读操作。

  • 在D/study路径下创建了temp.txt文件,文件中内容:abcdef

public class FileInputStreamTest {
    public static void main(String[] args) {
        FileInputStream fis = null;
        //创建文件字节输入流对象
        try {
            //采用绝对路径方式
             fis = new FileInputStream("D:\\study\\temp.txt");
            //FileInputStream有抛出异常,所以要try/catch
            //FileInputStream fis = new FileInputStream("D:/study/temp");  写成"/"也可以
            int readData = -1;
            while ((readData = fis.read()) != -1){
                //读取一次指针指向下一个字符
                System.out.printf(readData + " "); //97 98 99 100 101 102
            }
            System.out.println();
            System.out.println(fis.read());  //读取不到字符返回-1
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //在finally语句块中,确保流一定关闭
            if (fis != null) {
                //流是null时没必要关闭。
                try {
                    fis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}
  • 为了减少硬盘和内存的交互,提高程序的执行效率,在byte[]数组当中读:int read(byte[] b)
public class FileInputStreamTest {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("D:\\study\\temp.txt");

            //开始读,采取byte数组,一次读取多个字节,最多读取“数组.length”个字节
            byte[] bytes = new byte[4];//准备一个4个长度的byte数组
            //int read(byte[] b) 返回的是读取到的字节数量,不是字节本身。
            int readCount = fis.read(bytes);
            System.out.println(readCount);  //第一次读到了4个字节,返回:4
            //String(byte[] bytes) 能够将byte数组转成字符串
            System.out.println(new String(bytes));  //abcd
            //String(byte[] bytes,int offset,int length)  能够将byte数组中起始位置为offset,长度为length转为字符串
            System.out.println(new String(bytes,0,readCount));  //abcd

            readCount = fis.read(bytes);
            System.out.println(readCount);  //第二次继续读,只读到2个字节,返回:2
            //第二次读取的时候,读取到两个字节,只覆盖了前面两个字节
            System.out.println(new String(bytes));  //efcd
            System.out.println(new String(bytes,0,readCount));//ef

            readCount = fis.read(bytes);
            System.out.println(readCount);  //第三次继续读,没读到字节,返回:-1
            //第三次读取的时候,没有覆盖任何字节
            System.out.println(new String(bytes));  //efcd

        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}
  • 一次性读取所有字符
public class FileInputStreamTest {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("D:\\study\\temp.txt");
            //开始读,采取byte数组,一次读取多个字节,最多读取“数组.length”个字节
            byte[] bytes = new byte[4];//准备一个4个长度的byte数组
            int readCount = 0;
            while ((readCount= fis.read(bytes)) != -1){
                System.out.print(new String(bytes,0,readCount));  //abcdef
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}
  • FileInputStream其他常用方法:

    返回流当中剩余还没读到的字节数:int avaiable()

    跳过几个字节不读:long skip(long n)

public class FileInputStreamTest03 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("D:\\study\\study4\\study4\\tempfile");
            //总字节数量
            System.out.println("总字节数量:" + fis.available());  //总字节数量:6
            //读一个字节
            //int readCount = fis.read();
            //System.out.println("剩下多少个字节没有读:" + fis.available()); 剩下多少个字节没有读:5

            //byte[] bytes = new byte[fis.available()]; //这种方式不适用于大文件,因为byte数组不能太大。
            //int readCount = fis.read(bytes);//6
            //System.out.println(new String(bytes));  //abcdef

            fis.skip(3);  //跳过3个字节
            System.out.println(fis.read());  //100
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

3.文件专属FileOutputStream

  • 文件字节输出流,负责写,从内存到硬盘。
  • 使用write写入文件,并且在new文件时会清空文件。
public class FileOutputStreamTest {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //temptest文件不存在时会新建,有文件时会清空文件重新写。
            fos = new FileOutputStream("D:\\study\\study4\\study4\\temptest");
            //开始写
            byte[] bytes = {97,98,99,100};
            //将byte数组全部写出
            fos.write(bytes);  //abcd
            fos.write(bytes,0,2); //在写入ab

            //写完之后一定要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}
  • 若不想清空文件想直接在文件结尾插入,在new文件时候需要加true。并且需要加入String字符串时,需要将String字符串转成byte数组。
public class FileOutputStreamTest01 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //在路径后面加true表示在文件末尾写入数据
            fos = new FileOutputStream("D:\\study\\study4\\study4\\temptest",true);
            //开始写
            //写入一个String字符串
            String s = "来杯冰美式";
            byte[] bs = s.getBytes();
            fos.write(bs);

            //写完之后一定要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

4.字节输入/输出流实现文件复制

  • 文件复制:一个文件复制到另一个路径,需要经过内存。内存通过输入流读入数据,通过输出流输出数据。
public class CopyTest {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //新建一个字节输入流
            fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\谢沛民\\JAVA零基础\\2面向对象—匿名内部类.md");
            //新建一个字节输出流
            fos = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\2面向对象—匿名内部类.md");

            //核心的一边读一边写
            byte[] bytes = new byte[1024 * 1024];  //1024字节=1KB  1024*1024字节=1MB
            int readCount = 0;
            while ((readCount= fis.read(bytes)) != -1){
                fos.write(bytes,0,readCount);
            }

            //输出流最后要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //两个try/catch分开,否则有一个出现异常会影响另一个流关闭
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

5.文件专属FileReader

  • 文件字符输入流,只能读取普通文本,读取文本内容时,比较方便快捷。无法读取其他文件格式,包括word文件。
  • FileReader调用方法与FileInputStream类似,只需要将byte数组换成char数组。
public class FileReaderTest01 {
    public static void main(String[] args) {
        FileReader reader = null;
        try {
            //创建文件字符输入流
            reader = new FileReader("D:\\study\\study4\\study4\\tempfile");
            //开始读
            char[] chars = new char[4]; //一次读取4个字符
            int readCount = 0;
            while((readCount=reader.read(chars)) !=-1){
                System.out.printf(new String(chars,0,readCount) + " ");   //abcd ef 
            }

        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

6.文件专属FileWriter

  • 文件字符输出流,只能写出普通文本,写出文本内容时,比较方便快捷。无法读取其他文件格式,包括word文件。
  • FileReader调用方法与FileOutputStream类似,只需要将byte数组换成char数组。
public class FileWriterTest {
    public static void main(String[] args) {
        FileWriter out = null;
        try {
            //创建文件字符输出流对象
            out = new FileWriter("D:\\study\\study4\\study4\\file");
            //开始写
            char[] chars = {'来','杯','冰','美','式'};
            out.write(chars);
            out.write(chars,2,3);
            out.write("\n"); //这是插入一个换行符“\n”
            out.write("这是咖啡加点ice的学习笔记");

            out.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

7.纯文本的文件拷贝

  • 纯文件复制:一个文件复制到另一个路径,需要经过内存。内存通过字符输入流读入数据,通过字符输出流输出数据。
public class CopyTest {
    public static void main(String[] args) {
        FileReader frer = null;
        FileWriter fwer = null;
        try {
            frer = new FileReader("D:\\study\\study4\\study4\\file");
            fwer = new FileWriter("C:\\Users\\Administrator\\Desktop\\file");

            int readCount = 0;
            char[] chars = new char[1024];
            while((readCount= frer.read(chars))!=-1){
                fwer.write(chars,0,readCount);
            }

            fwer.flush();
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (frer != null) {
                try {
                    frer.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (fwer != null){
                try {
                    fwer.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }

        }
    }
}

8.缓冲流专属BufferedReader

  • BufferedReader:带有缓冲区的字符输入流。使用这个流不需要自定义char数组或byte数组,自带缓冲。

  • BufferedReader构造方法:BufferedReader(Reader in)

    这个构造方法需要一个流,被传递进来的流叫做:节点流。

    外部负责包装的流叫做:包装流/处理流。

  • 读一行方法(不带换行符):readLine()

public class BufferedReaderTest {
    public static void main(String[] args) throws IOException {
        //这里的FileReader作为一个节点流
        FileReader reader = new FileReader("D:\\study\\study4\\study4\\file");
        //BufferedReader作为包装流/处理流
        BufferedReader br = new BufferedReader(reader);

        //读一行方法(不带换行符):readLine()
        String s = null;
        while ((s=br.readLine()) != null){
            System.out.println(s);
        }
        
        //关闭流只需要关闭外边的包装流,里边的节点流会自动关闭
        br.close();
    }
}
  • BufferedReader只能传入一个字符流,不能传入一个字节流。需要用到java.io.InputStreamReader进行流转换。
public class BufferedReaderTest {
    public static void main(String[] args) throws IOException {
        //字节流
        //FileInputStream in = new FileInputStream("D:\\study\\study4\\study4\\file");
        //通过转换流将字符流转换为字符流
        // InputStreamReader reader = new InputStreamReader(in);
        //BufferedReader只能传一个字符流,不能传字节流。
        // BufferedReader br = new BufferedReader(reader);

        //将以上合并
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\study\\study4\\study4\\file")));

        String line = null;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }

        //只需要关闭最外层
        br.close();
    }
}

9.缓冲流专属BufferedWriter

  • BufferedWriter:带有缓冲区的字符输出流。
public class BufferedWriterTest {
    public static void main(String[] args) throws IOException {
        //BufferedWriter out = new BufferedWriter(new FileWriter("D:\\study\\study4\\study4\\file"));
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\study\\study4\\study4\\file")));
        out.write("咖啡哪有生活苦");
        out.write("\n");
        out.write("来杯冰美式");
        out.write("\n");
        out.write("这是咖啡加点ice的学习笔记");
        //刷新
        out.flush();
        //关闭最外层流
        out.close();
    }
}

10.数据流专属DataOutputStream

  • DataOutputStream:数据专属得流,这个流可以将数据连同数据类型一并写入文件。

    注意:这个文件不是普通的文本文档,用记事本打不开

public class DataOutputStreamTest {
    public static void main(String[] args) throws Exception{
        //创建数据专属字节输出流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("D:\\study\\study4\\study4\\dataout"));
        //写数据
        byte b = 100;
        short s = 200;
        int i = 300;
        long l = 400l;
        float f = 3.0f;
        double d = 3.14;
        boolean sex = false;
        char c = 'a';
        //写入
        dos.writeByte(b);  //把数据以及数据的类型一并写入文件当中
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(l);
        dos.writeFloat(f);
        dos.writeDouble(d);
        dos.writeBoolean(sex);
        dos.writeChar(c);
        //刷新
        dos.flush();
        //关闭流
        dos.close();
    }
}

11.数据流专属DataInputStream

  • 通过DataOutputStream写入的文件,只能使用DataInputStream读,并且需要知道写入的顺序,读的顺序需要与写入顺序一致才能正常取出数据。
public class DataInputStreamTest {
    public static void main(String[] args) throws Exception{
        DataInputStream dis = new DataInputStream(new FileInputStream("D:\\study\\study4\\study4\\dataout"));
        //开始读
        //如果读的顺序不一样,会发生乱码
        System.out.println(dis.readByte());
        System.out.println(dis.readShort());
        System.out.println(dis.readInt() + 1000);
        System.out.println(dis.readLong());
        System.out.println(dis.readFloat());
        System.out.println(dis.readDouble());
        System.out.println(dis.readBoolean());
        System.out.println(dis.readChar());
    }
}

12.标准流PrintStream

  • PrintStream:标准的字节输出流,默认输出到控制台。
public class PrintStreamTest {
    public static void main(String[] args) throws Exception{
        //联合起来写
        System.out.println("咖啡加ice");  //咖啡加ice
        //分开写
        PrintStream ps = System.out;
        ps.println("生活哪有咖啡苦");  //生活哪有咖啡苦

        //标准输出流不需要手动close关闭
        //改变标准输出流的输出方向
        //标准输出流不再指向控制台,指向log文件,修改输出方向为log文件。
        System.setOut(new PrintStream(new FileOutputStream("log",true)));
        System.out.println("来杯冰美式");
        System.out.println("咖啡哪有生活苦");
    }
}
  • 编写日志工具类
public class logger {
    public static void log(String msg){

        try {
            PrintStream out = new PrintStream(new FileOutputStream("log.txt",true));
            //改变输出方向
            System.setOut(out);
            //设置日期
            Date now = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
            String strTime = sdf.format(now);
            //打印日志
            System.out.println(strTime + ":" +msg);

        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}
  • 测试日志工具类
public class LogTest {
    public static void main(String[] args) {
        logger.log("测试一下打印日志工具类");
    }
}

//log.txt文件下内容:
//2024-01-18 11:00:05 644:测试一下打印日志工具类

——本章节为个人学习笔记。学习视频为动力节点Java零基础教程视频:动力节点—JAVA零基础教程视频

文章来源:https://blog.csdn.net/weixin_46016581/article/details/135690268
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。