JavaSE基础学习——IO流（高级流）

最新推荐文章于 2022-12-21 17:08:32 发布
最新推荐文章于 2022-12-21 17:08:32 发布
阅读量169 收藏
点赞数
文章标签： java idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44018911/article/details/124295264
版权

1. 缓冲流

1.1 缓冲流概述

  • 缓冲流也称为高效流、或者高级流。之前学习的字节流可以称为原始流
  • 作用：缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能
    在这里插入图片描述

1.2 字节缓冲流

1.2.1 字节缓冲流性能优化原理：

  • 字节缓冲输入流和字节缓冲输出流自带了8KB缓冲池
/**
 目标：使用字节缓冲流完成数据的读写操作。
 */
public class ByteBufferDemo {
    public static void main(String[] args) {

        try (
                // 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
                // 1、创建一个字节输入流管道与原视频接通
                InputStream is = new FileInputStream("/Users/lenyoo/Desktop/test/wly.JPG");
                // a.把原始的字节输入流包装成高级的缓冲字节输入流
                InputStream bis = new BufferedInputStream(is);
                // 2、创建一个字节输出流管道与目标文件接通
                OutputStream os = new FileOutputStream("/Users/lenyoo/Desktop/test/wly2.JPG");
                // b.把字节输出流管道包装成高级的缓冲字节输出流管道
                OutputStream bos = new BufferedOutputStream(os);

        ) {

            // 3、定义一个字节数组转移数据
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数。
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer, 0 , len);
            }
            System.out.println("复制完成了！");

        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

1.2.2 字节缓冲流的性能分析

public class ByteBufferTimeDemo {
    private static final String SRC_FILE = "D:\\course\\基础加强\\day08-日志框架、阶段项目\\视频\\14、用户购票功能.avi";
    private static final String DEST_FILE = "D:\\course\\";

    public static void main(String[] args) {
        // copy01(); // 使用低级的字节流按照一个一个字节的形式复制文件：慢的让人简直无法忍受。直接被淘汰。
        copy02(); // 使用低级的字节流按照一个一个字节数组的形式复制文件: 比较慢，但是还是可以忍受的！
        // copy03(); // 缓冲流一个一个字节复制：很慢，不建议使用。
        copy04(); // 缓冲流一个一个字节数组复制：飞快，简直太完美了（推荐使用）
    }

    private static void copy04() {
        long startTime = System.currentTimeMillis();
        try (
                // 1、创建低级的字节输入流与源文件接通
                InputStream is = new FileInputStream(SRC_FILE);
                // a.把原始的字节输入流包装成高级的缓冲字节输入流
                InputStream bis = new BufferedInputStream(is);
                // 2、创建低级的字节输出流与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "video4.avi");
                // b.把字节输出流管道包装成高级的缓冲字节输出流管道
                OutputStream bos = new BufferedOutputStream(os);
        ) {

            // 3、定义一个字节数组转移数据
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数。
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer, 0 , len);
            }

        } catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用缓冲的字节流按照一个一个字节数组的形式复制文件耗时：" + (endTime - startTime)/1000.0 + "s");
    }



    private static void copy03() {
        long startTime = System.currentTimeMillis();
        try (
                // 1、创建低级的字节输入流与源文件接通
                InputStream is = new FileInputStream(SRC_FILE);
                // a.把原始的字节输入流包装成高级的缓冲字节输入流
                InputStream bis = new BufferedInputStream(is);
                // 2、创建低级的字节输出流与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "video3.avi");
                // b.把字节输出流管道包装成高级的缓冲字节输出流管道
                OutputStream bos = new BufferedOutputStream(os);
        ){

            // 3、定义一个变量记录每次读取的字节（一个一个字节的复制）
            int b;
            while ((b = bis.read()) != -1){
                bos.write(b);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用缓冲的字节流按照一个一个字节的形式复制文件耗时：" + (endTime - startTime)/1000.0 + "s");
    }


    private static void copy02() {
        long startTime = System.currentTimeMillis();
        try (
                // 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
                // 1、创建一个字节输入流管道与原视频接通
                InputStream is = new FileInputStream(SRC_FILE);
                // 2、创建一个字节输出流管道与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "video2.avi")
        ) {

            // 3、定义一个字节数组转移数据
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0 , len);
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用低级的字节流按照一个一个字节数组的形式复制文件耗时：" + (endTime - startTime)/1000.0 + "s");
    }

    /**
     使用低级的字节流按照一个一个字节的形式复制文件
     */
    private static void copy01() {
        long startTime = System.currentTimeMillis();
        try (
                // 1、创建低级的字节输入流与源文件接通
                InputStream is = new FileInputStream(SRC_FILE);
                // 2、创建低级的字节输出流与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "video1.avi")
        ){

            // 3、定义一个变量记录每次读取的字节（一个一个字节的复制）
            int b;
            while ((b = is.read()) != -1){
                os.write(b);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("使用低级的字节流按照一个一个字节的形式复制文件耗时：" + (endTime - startTime)/1000.0 + "s");
    }

}

建议使用字节缓冲输入流、字节缓冲输出流，结合字节数组的方式，目前来看是性能最优的组合

1.3 字符缓冲输入、输出流

  • 字符缓冲输入流：BufferedReader
  • 作用：提高字符输入流读取数据的性能，除此之外多了按照行读取数据的功能
  • 字符缓冲输出流：BufferedWriter
  • 作用：提高字符输出流写取数据的性能，除此之外多了换行功能
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/**
 目标：学会使用缓冲字符输入流提高字符输入流的性能，新增了按照行读取的方法(经典代码)
 */
public class BufferedReaderDemo1 {
    public static void main(String[] args) {
        try (
                // 1、创建一个文件字符输入流与源文件接通。
                Reader fr = new FileReader("io-app2/src/data01.txt");
                // a、把低级的字符输入流包装成高级的缓冲字符输入流。
                BufferedReader br = new BufferedReader(fr);
        ){

            // 2、用循环，每次读取一个字符数组的数据。  1024 + 1024 + 8
//            char[] buffer = new char[1024]; // 1K字符
//            int len;
//            while ((len = br.read(buffer)) != -1) {
//                String rs = new String(buffer, 0, len);
//                System.out.print(rs);
//            }

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

/**
 目标：缓冲字符输出流的使用，学会它多出来的一个功能：newLine();
 */
public class BufferedWriterDemo2 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字符输出流管道与目标文件接通
        //Writer fw = new FileWriter("io-app2/src/out02.txt"); // 覆盖管道，每次启动都会清空文件之前的数据
        Writer fw = new FileWriter("io-app2/src/out02.txt", true); // 追加数据
        BufferedWriter bw = new BufferedWriter(fw);

//      a.public void write(int c):写一个字符出去
        bw.write(98);
        bw.write('a');
        bw.write('徐'); // 不会出问题了
        bw.newLine(); // bw.write("\r\n"); // 换行

//       b.public void write(String c)写一个字符串出去
        bw.write("abc我是中国人");
        bw.newLine(); // bw.write("\r\n"); // 换行


//       c.public void write(char[] buffer):写一个字符数组出去
        char[] chars = "abc我是中国人".toCharArray();
        bw.write(chars);
        bw.newLine(); // bw.write("\r\n"); // 换行


//       d.public void write(String c ,int pos ,int len):写字符串的一部分出去
        bw.write("abc我是中国人", 0, 5);
        bw.newLine(); // bw.write("\r\n"); // 换行

//       e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
        bw.write(chars, 3, 5);
        bw.newLine(); // bw.write("\r\n"); // 换行


        // fw.flush();// 刷新后流可以继续使用
        bw.close(); // 关闭包含刷线，关闭后流不能使用

    }
}

2. 转换流

2.1 字符输入转换流

  • 字符输入转换流：InputStreamReader，可以把原始的字节流按照指定编码转换成字符输入流
public class InputStreamReaderDemo01 {
    public static void main(String[] args) throws Exception {
        // 代码UTF-8   文件 GBK  "D:\\resources\\data.txt"
        // 1、提取GBK文件的原始字节流。   abc 我
        //                            ooo oo
        InputStream is = new FileInputStream("D:\\resources\\data.txt");
        // 2、把原始字节流转换成字符输入流
        // Reader isr = new InputStreamReader(is); // 默认以UTF-8的方式转换成字符流。 还是会乱码的  跟直接使用FileReader是一样的
        Reader isr = new InputStreamReader(is , "GBK"); // 以指定的GBK编码转换成字符输入流  完美的解决了乱码问题

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

2.2 字符输出转换流

  • 字符输出转换流：OutputStreamWriter，可以把字节输出流按照指定编码转换成字符输出流
public class OutputStreamWriterDemo02 {
    public static void main(String[] args) throws Exception {
        // 1、定义一个字节输出流
        OutputStream os = new FileOutputStream("io-app2/src/out03.txt");

        // 2、把原始的字节输出流转换成字符输出流
        // Writer osw = new OutputStreamWriter(os); // 以默认的UTF-8写字符出去 跟直接写FileWriter一样
        Writer osw = new OutputStreamWriter(os , "GBK"); // 指定GBK的方式写字符出去

        // 3、把低级的字符输出流包装成高级的缓冲字符输出流。
        BufferedWriter bw = new BufferedWriter(osw);

        bw.write("我爱中国1~~");
        bw.write("我爱中国2~~");
        bw.write("我爱中国3~~");

        bw.close();
    }
}

3. 序列化对象

3.1 对象序列化

  • 作用：以内存为基准，把内存中的对象存储到磁盘文件中去，称为对象序列化
  • 使用到的流是对象字节输出流：ObjectOutputStream
/**
    目标：学会对象序列化，使用ObjectOutputStream把内存中的对象输入到磁盘文件中
     transient修饰的成员变量不参与序列化了
 */
public class ObjectOutputDemo1 {
    public static void main(String[] args) throws Exception {
        // 1、创建学生对象
        Student s = new Student("陈磊", "chenlei", "1314520", 21);

        // 2、对象序列化，使用对象字节输出流包装字节输出流管道
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("io-app2/src/obj.txt"));

        // 3、直接调用序列化方法
        oos.writeObject(s);

        // 4、释放资源
        oos.close();
        System.out.println("序列化完成了");
    }
}

public class Student implements Serializable {
    private String name;
    private String loginName;
    // transient修饰的成员变量不参与序列化了
    private transient String passWord;
    private int age;

3.2 对象反序列化

  • 作用：以内存为基准，把存储到磁盘文件中去的对象数据恢复成内存中的对象，称为对象反序列化
  • 使用到的流是对象字节输入流：ObjectInputStream
/**
    目标：学会进行对象反序列化，使用对象字节输入流把文件中的对象数据恢复成内存中的Java对象
 */
public class ObjectInputStreamDemo2 {
    public static void main(String[] args) throws Exception {
        // 1、创建对象字节输入流管道包装低级的字节输入流管道
        ObjectInputStream is = new ObjectInputStream(new FileInputStream("io-app2/src/obj.txt"));

        // 2、调用对象字节输入流反序列化方法
        Student s = (Student) is.readObject();

        System.out.println(s);
    }
}

4. 打印流

  • 作用：打印流可以实现方便、高效的打印数据到文件中去。打印流一般是指：PrintStream、PrintWriter两个类
  • 可以实现打印什么数据就是什么数据，例如打印整数97写出去就是97，打印boolean的true，写出去就是true。

4.1 PrintStream、PrintWriter

/**
    目标：学会使用打印流 高效 方便写数据到文件
 */
public class PrintDemo1 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个打印流对象
        PrintStream ps = new PrintStream(new FileOutputStream("io-app2/src/ps.txt"));
        // PrintStream ps = new PrintStream(new FileOutputStream("io-app2/src/ps.txt", true));// 追加数据，在低级管道后面加true
        // PrintStream ps = new PrintStream("io-app2/src/ps.txt");
        // PrintWriter ps = new PrintWriter("io-app2/src/ps.txt"); // 打印功能上与PrintStream的使用没有区别

        ps.println(97);
        ps.println('a');
        ps.println(23.3);
        ps.println(true);
        ps.println("我是打印流输出的，我是啥就打印啥");

        ps.close();
    }
}

PrintStream和PrintWriter的区别

  • 打印数据功能上是一模一样，都是使用方便，性能高效（核心优势）
  • PrintStream继承自字节输出流OutputStream，支持写字节数据的方法。
  • PrintWriter继承自字符输出流Writer，支持写字符数据出去。

4.2 输出语句重定向

  • 属于打印流的一种应用，可以把输出语句的打印位置改到文件
/**
    目标：了解改变输出语句的位置到文件
 */
public class PrintDemo2 {
    public static void main(String[] args) throws Exception {
        System.out.println("锦瑟无端五十弦");
        System.out.println("一弦一柱思华年");

        //改变输出语句的位置
        PrintStream ps = new PrintStream("io-app2/src/log.txt");
        System.setOut(ps); // 把系统打印流改成我们自己的打印流

        System.out.println("庄生晓梦迷蝴蝶");
        System.out.println("望帝春心托杜鹃");
    }
}

5. 补充知识：Properties

5.1 Properties属性集对象

  • 其实就是一个Map集合，但是我们一般不会当集合使用，因为HashMap更好用。

5.2 Properties核心作用：

  • Properties代表的是一个属性文件，可以把自己对象中的键值对信息存入到一个属性文件中去。
  • 属性文件：后缀是.properties结尾的文件，里面的内容都是key=value，后续做系统配置信息的。
public class PropertiesDemo01 {
    public static void main(String[] args) throws Exception {
        // 需求：使用Properties把键值对信息存入到属性文件中去。
        Properties properties = new Properties();
        properties.setProperty("admin", "123456");
        properties.setProperty("dlei", "003197");
        properties.setProperty("heima", "itcast");
        System.out.println(properties);

        /**
         参数一：保存管道 字符输出流管道
         参数二：保存心得
         */
        properties.store(new FileWriter("io-app2/src/users.properties"), "this is users!! i am very happy!");
    }

public class PropertiesDemo02 {
    public static void main(String[] args) throws Exception {
        // 需求：使用Properties读取属性文件中的键值对信息（读取）
        Properties properties = new Properties();
        System.out.println(properties);

        // 加载属性文件中的键值对数据到属性对象properties中去
        properties.load(new FileReader("io-app2/src/users.properties"));

        System.out.println(properties);

        String rs = properties.getProperty("dlei");
        System.out.println(rs);
        String rs1 = properties.getProperty("admin");
        System.out.println(rs1);
    }
}

6. 补充知识：IO框架

6.1 commons-io概述

  • commons-io是apache开源基金组织提供的一组有关IO操作的类库，可以提高IO功能开发的效率
  • commons-io工具包提供了很多有关io操作的类。有两个主要的类FileUtils, IOUtiles
public class CommonsIODemo01 {
    public static void main(String[] args) throws Exception {

        // 1.完成文件复制！
//        IOUtils.copy(new FileInputStream("D:\\resources\\hushui.jpeg"),
//                new FileOutputStream("D:\\resources\\hushui2.jpeg"));


        // 2.完成文件复制到某个文件夹下！
//        FileUtils.copyFileToDirectory(new File("D:\\resources\\hushui.jpeg"), new File("D:/"));


        // 3.完成文件夹复制到某个文件夹下！
//          FileUtils.copyDirectoryToDirectory(new File("D:\\resources") , new File("D:\\new"));

        // 4、删除功能
//           FileUtils.deleteDirectory(new File("D:\\new"));

        // JDK1.7 自己也做了一些一行代码完成复制的操作:New IO的技术
        // Files.copy(Path.of("D:\\resources\\hushui.jpeg"), Path.of("D:\\resources\\hushui3.jpeg"));

        FileUtils.deleteDirectory(new File("D:\\new"));
    }
}
KnightZer0
关注
第一阶段：狂神说——javaSE(基础)
qq_44697268的博客
07-10 647
狂神说java，学习笔记，javaSE第一阶段，打基础基础，
JavaSE基础总结（常见类，集合，Stream，IO）
weixin_43261862的博客
02-05 393
Java常见类 Obeject Object是所有类的父类 方法 说明 Object clone() 创建与该对象的类相同的新对象 boolean equals(Object) 比较两个对象是否相等。默认比较的是地址值。 void finalize() 当垃圾回收器确定不存在对该对象的更多引用时，对象的垃圾回收器调用该方法 Class getClass() 返回一个对象运行时的实例类（.class文件） int hashCode() 返回该对象的散列码值 void not
commons.io
06-29
Java调webservice服务所需依赖包，可查看本博客中调用详情。
缓冲流、转换流、序列化对象、打印流、commons-io概述
weixin_43584531的博客
03-14 542
缓冲流 缓冲流也称为高效流、或者高级流。之前学习的字节流可以称为原始流。 作用：缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能。 字节缓冲流性能优化原理： 字节缓冲输入流自带了8KB缓冲池，以后我们直接从缓冲池读取数据，所以性能较好。 字节缓冲输出流自带了8KB缓冲池，数据就直接写入到缓冲池中去，写数据性能极高了。 推荐使用哪种方式提高字节流读写数据的性能？ 建议使用字节缓冲输入流、字节缓冲输出流，结合字节数组的方式，目前来看是性能最优的组合。 字符输入转换流 字符...
java高级之Io流
weixin_30235225的博客
08-16 202
1.1，什么是io流？ 　　流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。 1.2，流按类型分为两种: 　* 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的 　* 字符流 : 字符流只能操作纯字符数据，比较方便。 1.2....
Java中commons-IO
ONESTARの博客
07-12 5055
目录 一、概述 二、导入 commons-io jar包 1、获取 commons-io jar包 2、导入 commons-io jar 包 三、commons-io 的使用 1、IO 工具类 FilenameUtils 2、IO 工具类 FileUtils 一、概述 commons-IO是apache的一个开源的工具包,封装了IO操作的相关类,使用Commons IO可以很方...
IO流高级
weixin_43502661的博客
05-01 412
一、File类 1.File类的概述和常用功能 1）File类的概述： File类：文件和目录路径名的抽象表示形式，File类的实例是不可变的。 构造方法： File(String pathname) ：将一个指定的路径名转换为File对象； File f = new File("D:\\a\\b.txt"); File(String parent, String child) ：根据指定的父路...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
JavaSE入门详解：从基础到高级特性
"JavaSE学习笔记整理，涵盖了Java基础、数据类型、数组、类和对象、访问权限、面向对象特性、系统类、异常处理、集合框架等核心概念。此外，还涉及了Java命令行工具的使用，如javac、java、javadoc、javap以及环境...
Java学习资料 JavaSE学习练习代码
最新发布
06-25
5. **输入输出流（IO）和NIO**：Java提供了一套丰富的IO API，用于读写文件、网络通信等。学习如何使用InputStream、OutputStream、Reader、Writer等类进行数据传输，以及了解非阻塞I/O（NIO）的使用可以提升程序的...
Java IO commons-io-2.5.jar
04-02
Java IO commons-io-2.5.jar。 commons-io-2.5.jar 是Java IO的增强版，功能很强大。里面封装了很多实用方便的函数，文件操作、目录操作的。 Java IO
commons-io
05-21
项目开发中经常使用的工具包commons-io,收藏、分享！
Commons之Commons-io
热门推荐
一只没有脚的鸟
04-01 1万+
1  概述 Commons IO是针对开发IO流功能的工具类库。 主要包括六个区域： 工具类——使用静态方法执行共同任务 输入——用于InputStream和Reader实现 输出——用于OutputStream和Writer实现 过滤器——各种文件过滤器实现 比较器——各种文件的java.util.Comparator实现 文件监听器—...
io流---高级流
m0_49158934的博客
12-21 158
实际开发中我们还有功能更好用的字符高级流.但是其他的字符高级流都有一个共通点:不能直接连接在字节流上.而实 际操作设备的流都是低级流同时也都是字节流.因此不能直接在流连接中串联起来.转换流是一对可以连接在字节流上 的字符流,其他的高级字符流可以连接在转换流上.在流连接中起到"转换器"的作用(负责字符与字节的实际转换)java.io.InputStream和OutputStream是所有字节流的超类 而java.io.Reader和Writer则是所有字符流的超类,它们和字节流的超类是平级关系.
java之十 高级IO流
张晨光老师的播客
05-24 5443
java.io定义的输入/输出类列于下表： ObjectInputStream.GetField和ObjectOutputStream.PutField是Java2新添的内部类。 java.io包还包含两个不受java2欢迎的类，这两个类没有在上表中列出：LineNumberInputStream和StringBufferInputStream。新代码不应该使用两个类。 下面
【Java】Common-IO
Xerophyte的专栏
07-01 1976
public class Commons_ioDemo { private static final long LEVEL = 20150701;//本码讲版本 /** * 使用commons-io API输出一个目录中所有扩展名为.jar的文件 */ // @Test public void testListFiles() throws IOException { File f
JavaSE——commons-io方法大全
Java
12-27 754
Java commons-io方法大全
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值