JavaSE-19 【IO流】

已于 2023-08-18 09:33:30 修改
阅读量547 收藏 2
点赞数 3
分类专栏： JavaSE 文章标签： java
于 2021-07-23 13:55:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/allurelover/article/details/119025946
版权

文章目录

IO 流的继承体系结构

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

第一章 File文件类

1.1 File类介绍

java.io.File类

  • 该类的每一个实例用于表示硬盘上的一个文件或目录
  • 文件系统：是操作系统中有一个子系统称为，文件系统是用来管理硬盘的，它将数据保存在文件中，并使用目录来归类，、、
  • File类就是用来访问文件系统中的文件和目录的

1.2 File的主要功能

File可以：

  • 1、访问其表示的文件或目录的属性信息，比如：名字，大小，修改时间等
  • 2、可以创建或删除文件和目录
  • 3、可以访问目录中的一个子项
  • 4、但是不能访问文件数据（java中有其他API可以做这个事情）

1.3 入门案例

/**
 * File类
 */
public class FileDemo001 {
    public static void main(String[] args) {
        /*
            1.访问当前项目下的001test.txt文件,
               参数可以是绝对路径，也可以是相对路径
               一般使用相对路径
        * */
        File file = new File("./001test.txt");
        //获取文件名称
        String name = file.getName();
        //获取文件大小，单位是字节，表示单个文件的字节量
        long length = file.length();

        System.out.println("文件名称是："+name);
        System.out.println("文件字节量是"+length+"个字节");

        //文件是否是可读，是否是可写, 是否隐藏
        boolean canRead = file.canRead();
        boolean canWrite = file.canWrite();
        boolean hidden = file.isHidden();

        System.out.println("可读"+canRead);
        System.out.println("可写"+canWrite);
        System.out.println("是否隐藏"+hidden);

        //获取文件的绝对路径
        String absolutePath = file.getAbsolutePath();
        System.out.println(absolutePath);
    }
}

在这里插入图片描述

在这里插入图片描述

1.4 File 创建文件案例

/**
 * 使用File创建一个文件
 */
public class FileDemo002 {
    public static void main(String[] args) throws IOException {
        //在当前目录下创建文件002demo.txt
        File file = new File("./002demo.txt");
        /*
            boolean exisit()
            判断当前File表示的文件目录是否已经存在
        */
        if (file.exists()){
            System.out.println("改文件已经存在");
        }else {
            file.createNewFile();
            System.out.println("改文件创建成功");
        }
    }
}
  • 第一次运行
  • 在这里插入图片描述

在这里插入图片描述

  • 再次运行
  • 在这里插入图片描述

1.5 File 删除一个文件

1、创建文件

  • 在项目根目录下创建003demo.txt文件
  • 在这里插入图片描述

2、编写代码

/**
 * 删除一个文件
 */
public class FileDemo003 {
    public static void main(String[] args) {
        //将当前目录下的003demo.txt文件删除
        //相对路径中的“./”可以忽略不写，默认就是从“./”开始的
        //File file = new File("./003demo.txt");
        File file = new File("003demo.txt");
        if (file.exists()){
            //删除文件
            file.delete();
            System.out.println("文件删除成功");
        }else {
            System.out.println("文件不存在");
        }
    }
}

3、运行查看结果

  • 在这里插入图片描述

在这里插入图片描述

1.6 File 批量创建文件

  • 在当前目录下创建10个文件，分别命名为 004test1.txt 004test2.txt ----- 004test10.txt
/**
 *  在当前目录下创建10个文件
 *  分别命名为 004test1.txt 004test2.txt ----- 004test10.txt
 */
public class FileDemo004 {
    public static void main(String[] args) throws IOException {
        for (int i=1;i<=10;i++){
            //创建文件
            File file = new File("004test"+i+".txt");
            //判断文件是否存在
            if (!file.exists()){
                //创建文件
                file.createNewFile();
                System.out.println("文件创建成功");
            }
        }
    }
}
  • 运行查看结果
  • 在这里插入图片描述

在这里插入图片描述

1.7 File 创建单级目录

  • 代码编写
/**
 * File 创建目录
 */
public class FileDemo005 {
    public static void main(String[] args) {
        //在当前项目目录下创建一个新的目录005dir
        File dir = new File("./005dir");
        //判断文件夹是否存在
        if (dir.exists()){
            System.out.println("该目录已经存在");
        }else {
            //创建文件夹
            dir.mkdir();
            System.out.println("该目录创建成功");
        }
    }
}
  • 运行查看结果
  • 在这里插入图片描述
    在这里插入图片描述

1.8 File 创建多级目录

  • 代码编写
/**
 * File 创建目录
 */
public class FileDemo006 {
    public static void main(String[] args) {
        //在当前项目目录下创建一个新的目录006dirs/a/b/c/d/e/f
        File dir = new File("./006dirs/a/b/c/d/e/f");
        //判断文件夹是否存在
        if (dir.exists()){
            System.out.println("该目录已经存在");
        }else {
            //创建文件夹
            dir.mkdirs();
            System.out.println("该目录创建成功");
        }
    }
}
  • 运行查看结果
  • 在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

1.9 File 删除项目目录下指定目录

  • 在当前项目下创建007dir目录
    在这里插入图片描述

  • 编写代码

/**
 * File 删除目录
 */
public class FileDemo007 {
    public static void main(String[] args) {
        //将当前项目目录下的007dir删除
        File dir = new File("./007dir");
        //判断吗目录是否存在
        if (dir.exists()){
            //删除目录操作
            dir.delete();
            System.out.println("目录删除成功");
        }else {
            System.out.println("目录不存在");
        }

    }
}
  • 运行查看结果

在这里插入图片描述

  • 注意事项：
    使用delete方法删除目录时，
    要求该目录必须是一个空目录，才可以将其删除

1.10 File 获取目录中的所有子项

  • 获取当前目录中的所有子项,其中 ”.“ 就表示当前目录

  • 编写代码

/**
 * File 获取一个目录中的所有子项
 */
public class FileDemo008 {
    public static void main(String[] args) {
        //获取当前目录中的所有子项,其中 ”.“ 就表示当前目录
        /*
            //用来判断当前File是否是一个文件
            boolean isFile()
            //用来判断当前File是否是一个文件夹
            boolean isDirtory()
        */

        File dir = new File(".");
        //判断是否是一个文件夹
        if (dir.isDirectory()){
            //获取当前目录下的所有文件目录
            /*
                 File[] listFiles
                 将当前File表示的目录中所有子项返回
                 每个子项（文件或目录）都以一个File对象形式存入数组
                 并最终将数组返回
             */
            File[] listFiles = dir.listFiles();
            //输出文件数组长度
            System.out.println(listFiles.length);
            //遍历文件数组
            for (int i=0;i<listFiles.length;i++){
                //获取文件数组中每个元素的名称
                System.out.println(listFiles[i].getName());
            }
        }
    }
}
  • 运行获取结果
    在这里插入图片描述

1.1 FileFilter 过滤文件获取指定后缀名的文件

  • 过滤所有文件获取当前目录下的所有文本文件（.txt文件）
  • 编写代码
/**
 * File 重载的ListFiles方法
 * File [] listFiles(FileFilter filter)
 * 该方法需要我们传入一个文件过滤器，然后将该目录中满足这个过滤器要求的的子项返回
 */
public class FileDemo009 {
    public static void main(String[] args) {
        //获取当前目录下的所有文本文件（.txt文件）
        File dir = new File(".");
        //判断是否是一个文件夹
        if (dir.isDirectory()) {
            //创建过滤器对象
            MyFilter myFilter = new MyFilter();
            //获取当前目录下的所有文件目录，并进行过滤操作
            File[] listFiles = dir.listFiles(myFilter);
            //输出文件数组长度
            System.out.println(listFiles.length);
            //遍历文件数组
            for (int i = 0; i < listFiles.length; i++) {
                //获取文件数组中每个元素的名称
                System.out.println(listFiles[i].getName());
            }
        }
    }
}
class MyFilter implements FileFilter{

    @Override
    public boolean accept(File file) {//所有的子项进行过滤
        //获取子项的名称
        String name = file.getName();
        System.out.println("正在过滤的文件名称是"+name);
        //获取以为.txt接吻的文件名称
        return name.endsWith(".txt");
    }
}
  • 运行查看结果
    在这里插入图片描述

第二章 文件流

文件流属于节点流，是低级流

2.1 IO字节流简介

 Java IO 输入与输出
 IO是用来完成我们的程序与外界交换数据的方式
 将输入和输出按照方向分为读与写的操作 
 其中，以程序为参照物
 输入负责读取read，是外界到程序的方向
 输出负责写出write。是程序向外界的方向


Java中定义的输入流和输出流，可以看做是连接程序与外界设备的“管道”
管道中，存在着向着同一个方向顺序移动的字节数据

实际开发中，读写不同的设备会使用专门的输入流与输出流
如读取文件使用：文件输入流和文件输出流


 Java中定义了输入流和输出流的超类，用于规范输入与输出的读写操作
 java.io.InputStream是输入流的超类，所有字节输入流都继承自它
 java.io.OutputStream是输出流的超类，所有字节输出流都继承自它

2.2 FOS FIS 文件字节流介绍

  • 文件流：
  • java.io.FileInputStream 文件输入流
  • java.io.FileOutputStream 文件输出流
  • 它们是用来读写文件数据的流，是连接程序与文件之间的管道

在这里插入图片描述

在这里插入图片描述

2.3 文件字节流–创建文件写入文件内容

向当前目录下的文件005fos.txt中写入文件,如果文件不存在，就会自动创建 IO_001_FileOutputStream

  • 编写代码
/**
 * Java IO 输入与输出
 * IO是用来完成我们的程序与外界交换数据的方式
 * 将输入和输出按照方向分为读与写的操作
 * 其中，以程序为参照物
 * 输入负责读取read，是外界到程序的方向
 * 输出负责写出write。是程序向外界的方向
 *
 * Java中定义的输入流和输出流，可以看做是连接程序与外界设备的“管道”
 * 管道中，存在着向着同一个方向顺序移动的字节数据
 *
 * 实际开发中，读写不同的设备会使用专门的输入流与输出流
 * 如读取文件使用：文件输入流和文件输出流
 *
 * Java中定义了输入流和输出流的超类，用于规范输入与输出的读写操作
 * java.io.InputStream是输入流的超类，所有字节输入流都继承自它
 * java.io.OutputStream是输出流的超类，所有字节输出流都继承自它
 *
 * 文件流：
 * java.io.FileInputStream  文件输入流
 * java.io.FileOutputStream 文件输出流
 * 它们是用来读写文件数据的流，是连接程序与文件之间的管道
 *
 */
public class IO_001_FileOutputStream {
    public static void main(String[] args) throws IOException {
        //向当前目录下的文件005fos.txt中写入文件,如果文件不存在，就会自动创建
        /*
            文件字节流常见的构造方法
            FileOutputStream(String path)
            FileOutputStream(File file)  ---- > File file = new File("./005fos.dat");
         */
        //创建文件输出流对象，指定文件名称、路径
        FileOutputStream fos = new FileOutputStream("./005fos.dat");
        /*
            void write(int d)
            此方法是向文件中写入1个字节，写入的内容是给定的int值对应的2进制的低八位

            fos.write(1);
            int型的1对应的2进制：          这八位
            00000000 00000000 00000000 00000001
            对应到 ：005fos.dat中：
            00000001

            fos.write(2);
            int型的1对应的2进制：          这八位
            00000000 00000000 00000000 00000010
            对应到 ：005fos.dat中：
            00000001 00000010
         */
        fos.write(1);
        fos.write(2);
        System.out.println("写出完毕");
        //关闭资源
        fos.close();
    }
}
  • 运行查看结果
    在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2.4 文件字节流–读取文件内容

  • 编写代码
/**
 *  文件输入流，用于从文件中读取字节数据到程序中
 */
public class IO_002_FileInputStream {
    public static void main(String[] args) throws IOException {
        //读取005fos.dat中的内容到程序中
        FileInputStream fis = new FileInputStream("./005fos.dat");
        /*
            005fos.dat文件中存放的二进制数1,2的二进制的低八位：
            00000001 00000010
         */
        //读取一个字节
        int read = fis.read();//第一次读取
        System.out.println(read);

        read = fis.read();//第二次读取
        System.out.println(read);

        read = fis.read();//第三次读取
        System.out.println(read);

        /*
            int read();
            从文件中读取一个字节，返回的int的值的二进制最低八位就是读取到的字节数据
            如果返回的int的值为-1，则表示读取到了文件的末尾
         */
    }
}
  • 运行结果
    在这里插入图片描述

2.5 文件字节流–文件复制

  • 复制006.jpg文件
  • 编写代码
/**
 *  文件输入流，输出流进行文件赋值
 */
public class IO_003_FileInputOutputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("006.jpg");
        FileOutputStream fos = new FileOutputStream("007.jpg");
        //记录每次读取的字节
        int d;
        //判断是否读取到文件的末尾
        while ((d=fis.read())!=-1){
            //江都区到的字节写出去
            fos.write(d);
        }
        System.out.println("复制成功");
        fis.close();
        fos.close();
    }
}
  • 运行查看结果
    在这里插入图片描述

在这里插入图片描述

  • 文件赋值原理图
    在这里插入图片描述

2.6 文件字节流–块读写复制

  • 块读写操作复制008.txt文件
  • 代码编写
/**
 * 高效的读写
 * 通过提高每次读写的数据量，减少实际读写的次数可以提高读写效率
 * 一次读写一个字节的形式是随机读写形式
 * 一次读写一组字节的形式是块读写形式
 */
public class IO_004_FileInputOutputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("008.txt");
        FileOutputStream fos = new FileOutputStream("008_1.txt");
        /*
            块读：
            int read (byte[] data)
            一次性读取给定的字节数组总长度的字节量并存入到该数组
            返回值为实际读取到的字节量
            若返回值为-1，则表示读取到了文件的末尾

            块写：
            void write（byte[] data）
            一次性将给定的字节数组中所有的字节写出
         */
        // 11110000 8位二进制---1byte也就是1字节
        //创建一个长度为10kb的字节数组
        byte[] data = new byte[1024*10]; //10kb
        //每次读取到的字节量
        int len;
        //循环判断读取数据
        long start = System.currentTimeMillis();
        while ((len = fis.read(data))!=-1){
            //将读取到的文件写出去
            fos.write(data);
        }
        long end = System.currentTimeMillis();
        System.out.println("复制完毕,耗时"+(end-start));
        fis.close();
        fos.close();
    }
}
  • 运行结果
    在这里插入图片描述

在这里插入图片描述

  • 问题点：复制后的文件比原文件大，读取到了垃圾数据
    在这里插入图片描述
    在这里插入图片描述

  • 解决方案
    在这里插入图片描述

在这里插入图片描述

2.7 文件字节流–向文件中写入字符串数据

  • 编写代码
/**
 * 向文件中写入文本数据
 * String提供了将字符串转换为一组字节的方法
 * byte[] getBytes(“charsetName”)
 * 按照指定的字符集将当前字符串转换为一组字节，
 * 字符集的名称不区分大小写
 */
public class IO_005_FileOutputStreamTXTString {
    public static void main(String[] args) throws IOException {
        /*
            文件默认的创建方式称为覆盖模式
            即：如果指定的文件存在，则创建文件流时
                会将改文件原有的数据全部抹掉，
                然后将写入的数据全部保存到文件中

            文件流支持一个重载的构造器，允许我们再传入一个boolean的值作为参数
            如果这个值为true，
            则当前文件流为追加默认
            创建文件流时，若指定的文件存在，则原数据保留，
            新写入的数据都会顺序追加到文件末尾
            new FileOutputStream(String path, boolean append)
            new FileOutputStream(File file, boolean append)
         */

        FileOutputStream fos = new FileOutputStream("009fos.txt");
        //将文本数据转换为二进制，写入到硬盘中 ,转码 UTF-8 GBK
        String line = "我今天去输液了，输的什么液，输的是想你的夜";
        /*
        将字符串转换为字节,用UTF-8进行编码
         */
        //方式一：标准编码常量值
        //line.getBytes(StandardCharsets.UTF_8);
        //方式二
        byte[] bytes = line.getBytes("UTF-8");//大小写没区别
        //将转换后的字节数组写出
        fos.write(bytes);
        System.out.println("写出完毕");
        fos.close();
    }
}

  • 运行结果
    在这里插入图片描述
    在这里插入图片描述

  • 文件数据的追加效果

文件默认的创建方式称为覆盖模式
即：如果指定的文件存在，则创建文件流时
会将改文件原有的数据全部抹掉，
然后将写入的数据全部保存到文件中

文件流支持一个重载的构造器，允许我们再传入一个boolean的值作为参数
如果这个值为true，
则当前文件流为追加默认
创建文件流时，若指定的文件存在，则原数据保留，
新写入的数据都会顺序追加到文件末尾
new FileOutputStream(String path, boolean append)
new FileOutputStream(File file, boolean append)

在这里插入图片描述

在这里插入图片描述

2.8 文件字节流–从文件中读取字符串数据

  • 代码编写
/**
 * 实现简易记事本的工具
 * 程序启动后在控制台输入的每一行字符串都能顺序的写入文件010fos.txt
 * 当单独输入exit时程序退出
 */
public class IO_007_TestFOS {
    public static void main(String[] args) throws IOException {
        //创建文件输出流，设置为追加默认
        FileOutputStream fos = new FileOutputStream("010fos.txt",true);
        //创建scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请开始输入内容，单独输入exit时退出");
        while (true){
            //键盘输入字符串
            String line = scanner.nextLine();
            //判断是否要退出
            if ("exit".equals(line)){
                break;
            }
            //将字符串转换为utf-8字符集编码的字节
            byte[] bytes = line.getBytes(StandardCharsets.UTF_8);
            //执行块写出操作
            fos.write(bytes);
        }
        System.out.println("再见");
        //关闭资源
        fos.close();
    }
}
  • 运行结果
    在这里插入图片描述

在这里插入图片描述

2.9 图解低级流（节点流）和高级流（处理流）

  • Java IO 输入与输出

    • IO是用来完成我们的程序与外界交换数据的方式
    • 将输入和输出按照方向分为读与写的操作
    • 其中，以程序为参照物
    • 输入负责读取read，是外界到程序的方向
    • 输出负责写出write。是程序向外界的方向

  • Java中定义的输入流和输出流，可以看做是连接程序与外界设备的“管道”

    • 管道中，存在着向着同一个方向顺序移动的字节数据

    • 实际开发中，读写不同的设备会使用专门的输入流与输出流

    • 如读取文件使用：文件输入流和文件输出流

  • Java中定义了输入流和输出流的超类，用于规范输入与输出的读写操作

    • java.io.InputStream是输入流的超类，所有字节输入流都继承自它
    • java.io.OutputStream是输出流的超类，所有字节输出流都继承自它

  • 文件流：

    • java.io.FileInputStream 文件输入流
    • java.io.FileOutputStream 文件输出流
    • 它们是用来读写文件数据的流，是连接程序与文件之间的管道

  • Java将流分为两类:节点流和处理流

    • 节点流：也称为低级流，是真实连接程序与另一端 ” 管道 “，负责实际读写数据的流， IO操作是基于某个节点流基础上进行的

    • 处理流：也称为高级流，它不能独立存在，必须连接在其他流上，目的是当数据流经当前流时对其进行加工操作，使得我们读写数据得以简化

    • 实际开发中，我们经常会串联一组高级流到某个低级流上，

    • 读写数据以流水线式的加工处理，这也称为“流的链接”

  • 文件流是一对低级流

    • java.io.FileInputStream/FileOutputStream
    • 他们是用来读写文件数据的流，是连接程序与文件之间的“管道"

在这里插入图片描述

第三章 缓冲流

缓冲流是处理流，属于高级流

3.1 缓冲流 BIS BOS

缓冲流

  • java.io.BufferedInputStream和BufferedOutputStream
  • 缓冲流是一对高级流，在流连接中的作用是提高读写字节数据的效率

3.2 使用缓冲流完成文件复制

  • 原理图
    在这里插入图片描述

  • 代码编写

/**
 * 使用缓冲流完成文件的复制
 * 缓冲流
 * java.io.BufferedInputStream和BufferedOutputStream
 * 缓冲流是一对高级流，在流连接中的作用是提高读写字节数据的效率
 */
public class IO_plus_001_BufferedInputStream_BufferedOutputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("011.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        FileOutputStream fos = new FileOutputStream("011_1.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        int d;
        long start = System.currentTimeMillis();
        while ((d = bis.read())!=-1){
            bos.write(d);
        }
        long end = System.currentTimeMillis();
        System.out.println("文件复制完成需要的时间是："+(end-start)+"ms");
        bis.close();
        bos.close();
    }
}
  • 运行结果
    在这里插入图片描述
    在这里插入图片描述

3.3 缓冲流的默认缓存区

BufferedInputStream和BufferedOutputStream缓冲流的默认缓存区的大小是8192字节

  • 案例
/**
 * 缓冲输出流的缓冲区问题
 */
public class IO_plus_002_FlushDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("012.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        String line = "我穿了短的裙子遛弯去了";
        byte[] bytes = line.getBytes(StandardCharsets.UTF_8);
        bos.write(bytes);
        //bos.flush(); 不关闭流，执行flush
        System.out.println("写出完毕");
        //关闭资源
        //bos.close();
    }
}
  • 情况一、不关闭流执行写出操作，会发现，写出成功，但是文件中，没有内容，是因为，缓冲流的默认字节数组的大小是8192个字节，写出的内容小于默认数组的容量，数据不会自动写出，导致文件中数据不存在
    在这里插入图片描述

在这里插入图片描述

  • 情况二、执行输出流的 flush() 方法，将默认缓冲字节数组中的数据，写出到文件中

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 情况三、先清空文件中的内容，不执行缓冲输出流的 flush()方法，直接执行关闭流的操作，数据写出到文件成功。因为关闭流的方法中，再次调用了flush()操作。

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

第四章 对象流

对象流是处理流，属于高级流

4.1 对象流介绍

对象流

  • 对象流是一对高级流
  • 作用是：在流连接中进行对象的序列化和反序列化
  • 对象序列化：是将对象按照其结构转换为一组字节
  • 对象反序列化：是将一组字节还原为java对象

4.2 对象输出流–序列化对象

对象序列化：对象写入到文件中

  • 原理图

在这里插入图片描述

  • 代码
/**
 * 对象流
 * 对象流是一对高级流
 * 作用是：在流连接中进行对象的序列化和反序列化
 * 对象序列化：是将对象按照其结构转换为一组字节
 * 对象反序列化：是将一组字节还原为java对象
 */
public class IO_plus_003_ObjectOutputStream {
    public static void main(String[] args) throws IOException {
        /*
            讲一个Person对象写入文件013per.txt中
         */
        //创建person对象
        Person p = new Person();
        p.setName("海王");
        p.setAge(30);
        p.setGender('女');
        p.setAddr("Canada");
        System.out.println(p);
        //创建文件输出流
        FileOutputStream fos = new FileOutputStream("013per.txt");
        //创建对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //执行写出才操作
        /*
            对象输出流提供的方法
            void writeObject(Object obj)
            该方法会将给定的对象按照其结构转换为一组字节，
            但是要求该对象的类必须实现序列化接口，
            否则会抛出异常
            java.io.NotSerializableException
         */
        oos.writeObject(p);
        System.out.println("写出完毕");
        //关闭字眼
        oos.close();
    }
}
  • 运行查看结果

在这里插入图片描述

  • 查看文件字节数
    在这里插入图片描述为什么写入的数据这么大，是因为除了讲对象本身转化为字节写入文件外，还有将对象的结构也写入到了文件中

4.3 对象输入流–反序列化对象

  • 编写代码
/**
 * 使用对象输入流反序列化对象
 */
public class IO_plus_004_ObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建文件输入流对象
        FileInputStream fis = new FileInputStream("013per.txt");
        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(fis);
        //读取对象
        Object o = ois.readObject();
        //进行强制转换
        Person p = (Person) o;
        //输出对象
        System.out.println(p);
        //关闭资源
        ois.close();
    }
}
  • 运行查看结果
    在这里插入图片描述

第五章 转换流

转换流执行的是字符与字节转换，属于高级流

5.1 转换流介绍

Java.io 将流按照读写数据的单位划分为：字节流和字符流

  • 字节流

    • java.io.InputStream 和 OutputStream 是所有字节流的超类，
    • 比如：文件流，缓冲流，对象流都继承自上述的两个超类，
    • 读写单位最小都是以字节为单位进行的

  • 字符流

    • java.io.Reader 和Write 是所有字符流的超类，
    • 读写单位是最小的char（字符）为单位进行的
    • 字符流底层本质还是要进行字符和字节的转换（因为计算机底层只有2进制）
    • 但是字符流给我们提供的便利是可以让我们直接读写文本数据
    • 因此注意：字符流只适合读写文本数据！

  • 转换流

    • 转换流是一对高级流，实际开发中我们不直接操作这对流，
    • 但是在流链接中它们是非常重要的，
    • 负责衔接其他字符流与下面的字节流
    • 并进行字符和字节的转换工作
    • java.io.OutputStreamWriter 和 InputStreamReader
      • 他们时唯一可以连接在字节流上的字符流，
      • 其他字符流通过连接上它就可以与底下的字节流连接使用了
      • 它们之所以被称为转换流，就相当于起到了“转换器的作用”

5.2 字符转换输出流—将字符数据写入到文本文件

  • 代码编写
/**
 *  Java.io 将流按照读写数据的单位划分为：字节流和字符流
 *
 *  字字节流
 *  java.io.InputStream 和 OutputStream 是所有字节流的超类，
 *  比如：文件流，缓冲流，对象流都继承自上述的两个超类，
 *  读写单位最小都是以字节为单位进行的
 *
 *  字符流
 *  java.io.Reader 和Write 是所有字符流的超类，
 *  读写单位是最小的char（字符）为单位进行的
 *  字符流底层本质还是要进行字符和字节的转换（因为计算机底层只有2进制）
 *  但是字符流给我们提供的便利是可以让我们直接读写文本数据
 *  因此注意：字符流只适合读写文本数据！
 */

/*
 *  转换流
 *  转换流是一对高级流，实际开发中我们不直接操作这对流，
 *  但是在流链接中它们是非常重要的，
 *  负责衔接其他字符流与下面的字节流
 *  并进行字符和字节的转换工作
 *
 *  案例：转换流，将字符转换成字节输出
 */
public class IO_plus_005_OutputStreamWrite {
    public static void main(String[] args) throws IOException {
        //创建字节数出流，true表示可以追加类型
        FileOutputStream fos = new FileOutputStream("014osw.txt",true);
        //创建字符输出流，字符输出流内部会将字符转化为字节，设置字符集编码，交给字节输出流写到指定文件中
        OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
        //执行写出操作
        osw.write("今天你打疫苗了么");
        osw.write("出行需戴口罩");
        //执行完毕
        System.out.println("写出完毕");
        //关闭资源
        osw.close();
    }
}
  • 运行查看结果
    在这里插入图片描述
    在这里插入图片描述

5.3 字符转换输入流—使用转换流读取文本数据

  • 代码编写
/**
 * 使用转换流读取文本数据
 */
public class IO_plus_006_InputStreamReader {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("014osw.txt");
        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
        int d ;
        /*
            字符流的read()方法
            int read()
            读取一个字符，是以int型返回的，因此该int值的二进制“低十六位”有效
            如果返回的int值为-1，则表示读取到了末尾
         */
        while ((d=isr.read())!=-1){
            System.out.println(d);
            System.out.print((char)d);
        }
        isr.close();
    }
}
  • 运行查看结果

在这里插入图片描述

  • 原理图

在这里插入图片描述

第六章 缓冲字符流

6.1 缓冲字符流介绍

  • 缓冲字符流

    • 缓冲字符流是一对高级流

    • 在流连接中的作用是提高读写文本数据的效率

    • 并且可以按行读取字符串

    • java.io.BufferedReader 和 BufferedWriter

    • 实际开发中缓冲字符输出流是我们常用的PrintWriter

    • 具有自动行刷新功能的缓冲字符输出流

    • 其内部总是连接BufferedWriter作为缓冲加速使用

6.2 缓冲字符流—PrintWrite 向文件中写入字符串

  • 编写代码
/**
 * 缓冲字符流
 * 缓冲字符流是一对高级流
 * 在流连接中的作用是提高读写文本数据的效率
 * 并且可以按行读取字符串
 * java.io.BufferedReader 和 BufferedWriter
 *
 * 实际开发中缓冲字符输出流是我们常用的PrintWriter
 * 具有自动行刷新功能的缓冲字符输出流
 * 其内部总是连接BufferedWriter作为缓冲加速使用
 */
public class IO_plus_007_BufferedReader_BufferWriter {
    public static void main(String[] args) throws FileNotFoundException {
        /**
         * PrintWriter 提供了对文件操作的构造方法
         * PrintWriter（String path）
         * PrintWriter (File file)
         */

        //向文件中写入字符串
        PrintWriter pw = new PrintWriter("015pw.txt");
        pw.println("我的梦中情人是张曼玉");
        pw.println("我的梦中情人是邱淑贞");
        pw.println("我的梦中情人是王祖贤");
        pw.println("我的梦中情人是张敏");
        System.out.println("写出完毕");
        pw.close();
    }
}

  • 运行结果
    在这里插入图片描述
    在这里插入图片描述

  • 流耦合原理

在这里插入图片描述

在这里插入图片描述

6.3 PrintWrite 案例

  • 案例1
/**
 * 在流连接中使用PW
 */
public class IO_plus_008_PWDemo {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
        //低级流，文件输出流，作用：向文件中写入数据
        FileOutputStream fos = new FileOutputStream("016pwtest.txt");
        //高级流，转换输出流，作用：衔接其他字符流和字节流，将写出的字符转换成字节
        OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
        //高级流，缓冲字符流，作用：块写文本数据加速
        BufferedWriter bw = new BufferedWriter(osw);
        //高级流，字符输出流，作用：按行写出字符串，并且可以自动行刷新
        PrintWriter pw = new PrintWriter(bw);
        //写出字符串
        pw.write("今天要下雨");
        pw.write("最近每天在下雨");
        pw.write("下雨导致回不了家");
        System.out.println("写出完毕");
        //关闭资源
        pw.close();
    }
}

  • 运行结果
    在这里插入图片描述
    在这里插入图片描述

  • 案例2

/**
 * 实现简易记事本工具
 * 程序启动后，要求输入一个文件名，然后对改文件进行写操作
 * 之后用户输入的每一行字符串都能按行写入到改文件中
 * 当用户单独输入exit时，程序退出
 */
public class IO_plus_009_IODemo {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入文件名");
        String fineName = sc.nextLine();

        FileOutputStream fis = new FileOutputStream(fineName);
        OutputStreamWriter osw = new OutputStreamWriter(fis,"UTF-8");
        BufferedWriter bw = new BufferedWriter(osw);
        PrintWriter pw = new PrintWriter(bw);

        System.out.println("请开始输入内容，单独输入exit时退出");
        while (true){
            String line = sc.nextLine();
            if ("exit".equals(line)){
                break;
            }
            pw.println(line);
            pw.flush();
        }
        System.out.println("再见");
        pw.close();
    }
}
  • 运行结果
    在这里插入图片描述
    在这里插入图片描述
AlluzeYu
关注
专栏目录
Java SE 19 虚拟线程
m0_68263709的博客
09-27 442
虚拟线程（Virtual Threads）是在中开发的，并从 Java SE 19 开始作为预览功能引入 JDK。在线程模型下，，而这些线程是很消耗资源的，如果启动的线程过多，会给整个系统的稳定性带来风险。虚拟线程解决了这个问题，从 Java 代码的角度来看，虚拟线程感觉就像普通的线程，但它们不是1:1地映射到操作系统线程上。有一个所谓的载体线程池，一个虚拟线程被临时映射到该池中。一旦虚拟线程遇到阻塞操作，该虚拟线程就会从载体线程中移除，而载体线程可以执行另一个虚拟线程（新的或之前被阻塞的）。
Java基础学习(18)多线程
GUO_NULL192的博客
02-27 257
@TOC 一、基本概念 1.1 程序和进程的概念 程序 - 数据结构 + 算法，主要指存放在硬盘上的可执行文件。 进程 - 主要指运行在内存中的可执行文件。 目前主流的操作系统都支持多进程，为了让操作系统同时可以执行多个任务，但进程是重量级的，也就是新建一个进程会消耗CPU和内存空间等系统资源，因此进程的数量比较局限。 2.1 线程的概念 为了解决上述问题就提出线程的概念，线程就是进程内部的程序流，也就是说操作系统内部支持多进程的，而每个进程的内部又是支持多线程的，线程是轻量的，新建线程会共享所在进程
Javase基础——IO流
涛涛的个人博客
07-15 753
Javase基础——IO流
JavaSE 19
cystart的博客
02-06 190
线程的生命周期： JDK中用Thread.State类定义了线程的几种状态。要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态： ①新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态 ②就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源 ③运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态，
JavaSE高阶篇-IO流
最新发布
qq_48357941的博客
04-17 1309
四大基础类WriterReader作用: 用于将数据以字节形式写入到本地文件中。它是的子类，专门用于文件输出操作。可以用来写入文本、二进制数据（如图像数据）或其他原始字节。特点: 创建对象时，可以选择是否以追加模式打开文件（即在文件末尾添加数据而不覆盖原有内容）。默认情况下，如果不指定追加模式，写入操作会覆盖文件原有的内容。作用: 用于从本地文件中读取字节数据。它是的子类，专用于文件输入操作。能够读取文本、二进制数据或其他原始字节流。特点: 使用。
JavaSE-No.6.2——封装与static
Gujiu的博客
05-11 541
java封装与static详解，一起学习吧~
【零基础学java系列教程】CSDN博客统一入口（javaSE-＞javaEE(Spring+Mybatis+springMvc+SpringBoot+SpringCloud)-＞架构-＞项目实战）
jason的java世界
01-08 1396
为了方便小白更好的学习java，把相关授课的文章整理在此，作为阅读此系列教程的统一入口，方便大家查阅。整个系列课程会带小白从零基础一直到项目实战，敬请期待。谢谢您的关注。
Java-IO 流的Close方法
li_xunhuan的博客
10-24 5071
一、在Java中为何要关闭流 GC运行的时间点是不确定的（因为是一条单独存在的线程），所以很多时候你不能直接控制什么时候发生GC。这个带来的问题有两点，一个是有时候你的内存不足需要立刻回收而GC并不会立刻运行；另外一个是因为GC运行期间会占用大量系统资源所以某些情况下你会希望把它推后，或者干脆关掉以便根据性能需求在合式的时候手动执行。 另外，GC只能回收内存。至于各种stream之类，他们下边一般...
黑马毕向东Java课程笔记（day19-11——19-22）IO字节流:字节流及其读取、字节流缓冲区、自定义字节流（读取）的缓冲区、读取键盘的输入、读取/写入转换流、流操作规律
LKJgdut的博客
09-23 420
1、字节流——File   字节流的介绍 字符流：（一个字符2个字节16位） FileReader FileWriter。 BufferedReader BufferedWriter 字节流：（一个字节8位） InputStream（输入的都是读） OutputStream（输出的都是写）（这里以流为对象，流向内存输出数据，就是写内存；内存数据输入流，对于流，就是将内存的数据...
JavaSE学习总结（十八）IO流之字节流和字符流（下）/数据输入输出流/内存操作流/打印流/随机访问流/序列化流和反序列化流实现深克隆/Properties属性集合/顺序输入流
ZaynFox的博客
03-18 270
一、一些杂七杂八流 （一）数据输入输出流 数据输入流: DataInputStream 数据输出流: DataOutputStream 最大的特点: 可以写基本数据类型，可以读取基本数据类型 1.构造方法 DataOutputStream(OutputStream out)创建一个新的DataOutputStream，将数据写入指定OutputStream。 DataInputStream(InputStream in)使用指定的底层 InputStream 创建一个 DataInputStream。 2.
JAVASE_IO流
天才来源于积累
03-29 589
IO流是用来处理设备之间的数据传输java对数据的操作都是通过流的方式java把处理流的对象都存放在IO包中流按操作数据分为两种：字节流和字符流（字符在生活中用的比较多，因此把字节流从字节流中独立出来(字符流中存在编码表)）字符流基于字节流，读出来的字节数组对应的编码查询转换后就成了一个个码值显示成文字流按流向分：输入流和输出流IO的常用基类：字节流的抽象基类：InputStream，OutpuS
java se 类库_19、【JavaSE】【Java 核心类库（上）】包装类
weixin_42517503的博客
02-12 100
1、概念通常情况下基本数据类型的变量不是对象(基本数据类型的数据一般是在栈中的)，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。包装类所做的实际上就是一种封装。public class Integer {// 封装private int num;······}2、Java 中的包装类与对应的数据类型包装...
JavaSE之IO流
wnxiaobear的博客
05-21 224
大家好，这是我的第一篇博客，目前在校学习，喜欢做一些笔记，只不过一开始用的是语雀来进行记录笔记的，这是我在学习java的过程中所积累的笔记，希望能够帮助到大家，如有错误，欢迎请大佬指出。 一.File类 1.File的构造方法 File file = new File(“文件路径名”); 2.文件的基本操作（文件的一些属性） boolean = file.createNewFile(“文件的路径名”); 文件如果不存自动创建一个新文件，若存在则返回true； Boolean = file.exists();
JavaSE-IO流
apple_59745077的博客
01-22 994
流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。I : Input输入 O : output输出以字节的方式进行文件中的内容的读取操作，要想读取文件需要先找到文件的位置，文件位置可以通过绝对路径或相对路径找到。绝对路径 : 绝对路径是从系统的根目录开始，一级一级指向目标文件或资源的完整路径.
Java SE 19 新增特性
Huangjiazhen711的博客
09-23 365
在 Java 17 中，这些 API 被合并为 “Foreign Function & Memory API”（FFM API），直到 Java 18，它一直处于孵化阶段。如果一个任务由不同的子任务组成，可以并行完成（例如，从数据库访问数据、调用远程 API 和加载文件），我们可以使用 Java 多线程的一些工具类来完成。Java SE 19，构造哈希表的时候，由于有扩容因子 0.75 的设置，所以如果要开辟一个 120 空间的哈希表，需要如下定义。，我们等待所有任务完成–或者至少有一个任务失败或被取消。
JavaSE（六）:IO流
水滴的博客
04-09 281
一、概序    Java IO：通过数据流、序列化和文件系统提供系统输入和输出，即Java 输入输出系统。    流：数据流，从中读到数据，往里面写入数据。流是数据流向的媒介。二、类型数据流的方向不同可以分为：输入流和输出流。数据单位不同可以分为：字节流和字符流。实现功能不同可以分为：节点流和处理流。  Jdk提供的流继承了四大类：InputStream(字节输入流)，OutputStream（字...
【JavaSE】IO流
m0_64098804的博客
03-19 813
【学习记录】Java后端路线，Java核心语法，关于IO的那些事儿。
毕向东老师详解JavaSE：从基础到高级
输入输出流（IO流）用于处理数据的读写，包括字节流、字符流、缓冲流、对象序列化等。 14. GUI编程 Java提供Swing和JavaFX库进行图形用户界面开发，创建窗口、按钮、文本框等组件。 15. 网络编程 Java提供了...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值