增强day10-IO流（二）

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量15 收藏
点赞数
分类专栏： Java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57288751/article/details/134121731
版权
  1. 字符和字节的区别
    1. 字符是文本数据的最小单位，字节是二进制数据的最小单位，一个字符可能有多个字节。
    2. 字符可以通过不同的编码方式，比如ASCII，Unicode等来表示，字节通常以二进制形式直接表示
    3. 字符主要表示文本数据，字节用于处理二进制数据，比如文本，音频等
  2. FileReader类（字符输入流）
FileReader读取文件的步骤如下：
第一步：创建FileReader对象与要读取的源文件接通
第二步：调用read()方法读取文件中的字符
第三步：调用close()方法关闭流

/**
 * 目标：掌握文件字符输入流。
 */
public class FileReaderTest1 {
    public static void main(String[] args)  {
        try (
                // 1、创建一个文件字符输入流管道与源文件接通
                Reader fr = new FileReader("io-app2\\src\\itheima01.txt");
                ){
            // 2、一个字符一个字符的读（性能较差）
            // 每次读取一个字符的形式，性能肯定是比较差的。

            // 3、每次读取多个字符。（性能是比较不错的！）
            char[] buffer = new char[3];
            int len; // 记住每次读取了多少个字符。
            while ((len = fr.read(buffer)) != -1){
                // 读取多少倒出多少
                System.out.print(new String(buffer, 0, len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. FileWriter类（字符输出流）
FileWriter往文件中写字符数据的步骤如下：
第一步：创建FileWirter对象与要读取的目标文件接通
第二步：调用write(字符数据/字符数组/字符串)方法读取文件中的字符
第三步：调用close()方法关闭流

/**
 * 目标：掌握文件字符输出流：写字符数据出去
 */
public class FileWriterTest2 {
    public static void main(String[] args) {
        try (
                // 0、创建一个文件字符输出流管道与目标文件接通。
                // 覆盖管道
                // Writer fw = new FileWriter("io-app2/src/itheima02out.txt");
                // 追加数据的管道
                Writer fw = new FileWriter("io-app2/src/itheima02out.txt", true);
                ){
            // 1、public void write(int c):写一个字符出去
            fw.write('a');
            fw.write(97);
            //fw.write('磊'); // 写一个字符出去
            fw.write("\r\n"); // 换行

            // 2、public void write(String c)写一个字符串出去
            fw.write("我爱你中国abc");
            fw.write("\r\n");

            // 3、public void write(String c ,int pos ,int len):写字符串的一部分出去
            fw.write("我爱你中国abc", 0, 5);
            fw.write("\r\n");

            // 4、public void write(char[] buffer):写一个字符数组出去
            char[] buffer = {'黑', '马', 'a', 'b', 'c'};
            fw.write(buffer);
            fw.write("\r\n");

            // 5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
            fw.write(buffer, 0, 2);
            fw.write("\r\n");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. FileWriter注意事项
    1. FileWriter写完数据之后必须刷新或者关闭，写出去数据才能生效
比如：下面的代码只调用了写数据的方法，没有关流的方法。当你打开目标文件时，是看不到任何数据的。

//1.创建FileWriter对象
Writer fw = new FileWriter("io-app2/src/itheima03out.txt");

//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');


而下面的代码，加上了flush()方法之后，数据就会立即到目标文件中去。

//1.创建FileWriter对象
Writer fw = new FileWriter("io-app2/src/itheima03out.txt");

//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');

//3.刷新
fw.flush(); 

下面的代码，调用了close()方法，数据也会立即到文件中去。
因为close()方法在关闭流之前，会将内存中缓存的数据先刷新到文件，再关流。

//1.创建FileWriter对象
Writer fw = new FileWriter("io-app2/src/itheima03out.txt");

//2.写字符数据出去
fw.write('a');
fw.write('b');
fw.write('c');

//3.关闭流
fw.close(); //会先刷新，再关流
  1. 缓冲流

image.png

  • 作用：可以对原始流进行包装，提高原始流读写数据的性能。
  • 底层提高性能原理：是因为在缓冲流的底层自己封装了一个长度为8KB（8129byte）的字节数组，但是缓冲流不能单独使用，它需要依赖于原始流。
  • 字节缓冲流
public class BufferedInputStreamTest1 {
    public static void main(String[] args) {
        try (
                InputStream is = new FileInputStream("io-app2/src/itheima01.txt");
                // 1、定义一个字节缓冲输入流包装原始的字节输入流
                InputStream bis = new BufferedInputStream(is);

                OutputStream os = new FileOutputStream("io-app2/src/itheima01_bak.txt");
                // 2、定义一个字节缓冲输出流包装原始的字节输出流
                OutputStream bos = new BufferedOutputStream(os);
        ){

            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();
        }
    }
}
  • 字符缓冲流
public class BufferedReaderTest2 {
    public static void main(String[] args)  {
        try (
                Reader fr = new FileReader("io-app2\\src\\itheima04.txt");
                // 创建一个字符缓冲输入流包装原始的字符输入流
                BufferedReader br = new BufferedReader(fr);
        ){
//            char[] buffer = new char[3];
//            int len;
//            while ((len = br.read(buffer)) != -1){
//                System.out.print(new String(buffer, 0, len));
//            }
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());
//            System.out.println(br.readLine());

            String line; // 记住每次读取的一行数据
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}



public class BufferedWriterTest3 {
    public static void main(String[] args) {
        try (
                Writer fw = new FileWriter("io-app2/src/itheima05out.txt", true);
                // 创建一个字符缓冲输出流管道包装原始的字符输出流
                BufferedWriter bw = new BufferedWriter(fw);
        ){

            bw.write('a');
            bw.write(97);
            bw.write('磊');
            bw.newLine();

            bw.write("我爱你中国abc");
            bw.newLine();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • 缓冲流性能结论：**缓冲流的性能不一定比低级流高，其实低级流自己加一个数组，性能其实是不差。**只不过缓冲流帮你加了一个相对而言大小比较合理的数组 。
  1. 转换流
  • InputStreamReader
public class InputStreamReaderTest2 {
    public static void main(String[] args) {
        try (
                // 1、得到文件的原始字节流（GBK的字节流形式）
                InputStream is = new FileInputStream("io-app2/src/itheima06.txt");
                // 2、把原始的字节输入流按照指定的字符集编码转换成字符输入流
                Reader isr = new InputStreamReader(is, "GBK");
                // 3、把字符输入流包装成缓冲字符输入流
                BufferedReader br = new BufferedReader(isr);
                ){
            String line;
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }


        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • OutputStreamWriter
public class OutputStreamWriterTest3 {
    public static void main(String[] args) {
        // 指定写出去的字符编码。
        try (
                // 1、创建一个文件字节输出流
                OutputStream os = new FileOutputStream("io-app2/src/itheima07out.txt");
                // 2、把原始的字节输出流，按照指定的字符集编码转换成字符输出转换流。
                Writer osw = new OutputStreamWriter(os, "GBK");
                // 3、把字符输出流包装成缓冲字符输出流
                BufferedWriter bw = new BufferedWriter(osw);
                ){
            bw.write("我是中国人abc");
            bw.write("我爱你中国123");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. 打印流

image.png

  • 打印流和普通write的区别：
    • 打印流能将各种数据类型转换为字符串
    • 打印流提供了便捷的方法用于打印各种数据类型
    • 普通的write输出：需要手动将数据转换为字节数组，并将字节数组写入输出流。这意味着你需要显式地处理数据的格式化和字节转换。
OutputStream os = System.out;
try {
    byte[] data = "Hello, World!\n".getBytes();
    os.write(data);
    data = "42\n".getBytes();
    os.write(data);
} catch (IOException e) {
    e.printStackTrace();
}
  • 文件中的应用
public class PrintTest1 {
    public static void main(String[] args) {
        try (
                // 1、创建一个打印流管道
//                PrintStream ps =
//                        new PrintStream("io-app2/src/itheima08.txt", Charset.forName("GBK"));
//                PrintStream ps =
//                        new PrintStream("io-app2/src/itheima08.txt");
                PrintWriter ps =
                        new PrintWriter(new FileOutputStream("io-app2/src/itheima08.txt", true));
                ){
                ps.print(97);	//文件中显示的就是:97
                ps.print('a'); //文件中显示的就是:a
                ps.println("我爱你中国abc");	//文件中显示的就是:我爱你中国abc
                ps.println(true);//文件中显示的就是:true
                ps.println(99.5);//文件中显示的就是99.5

                ps.write(97); //文件中显示a，发现和前面println方法的区别了吗？

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • 重定向输出语句
为什么System.out.println() 能够在控制台打印语句呢？
因为System里面有一个静态变量叫out，out的数据类型就是PrintStream，
它就是一个打印流，而且这个打印流的默认输出目的地是控制台，
所以我们调用`System.out.pirnln()`就可以往控制台打印输出任意类型的数据，而且打印啥就输出啥。
而且System还提供了一个方法，可以修改底层的打印流，
这样我们就可以重定向打印语句的输出目的地了。我们玩一下, 直接上代码。

public class PrintTest2 {
    public static void main(String[] args) {
        System.out.println("老骥伏枥");
        System.out.println("志在千里");

        try ( PrintStream ps = new PrintStream("io-app2/src/itheima09.txt"); ){
            // 把系统默认的打印流对象改成自己设置的打印流
            System.setOut(ps);

            System.out.println("烈士暮年");	
            System.out.println("壮心不已");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

此时打印语句，将往文件中打印数据，而不在控制台。
  1. 数据流
  • 作用：可以把数据和数据类型一并写到文件中，读取的时候也可以将数据和数据类型一并读出来。
  • image.png
  • DataOutputStream类
往文件中写整数、小数、布尔类型数据、字符串数据

public class DataOutputStreamTest1 {
    public static void main(String[] args) {
        try (
                // 1、创建一个数据输出流包装低级的字节输出流
                DataOutputStream dos =
                        new DataOutputStream(new FileOutputStream("io-app2/src/itheima10out.txt"));
                ){
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("黑马程序员666！");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • DataInputSteram类
读取文件中特定类型的数据（整数、小数、字符串等）

public class DataInputStreamTest2 {
    public static void main(String[] args) {
        try (
                DataInputStream dis =
                        new DataInputStream(new FileInputStream("io-app2/src/itheima10out.txt"));
                ){
            int i = dis.readInt();
            System.out.println(i);

            double d = dis.readDouble();
            System.out.println(d);

            boolean b = dis.readBoolean();
            System.out.println(b);

            String rs = dis.readUTF();
            System.out.println(rs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. 序列化流

image.png

  • 序列化：意思就是把对象写到文件或者网络中去。（简单记：写对象）
  • 反序列化：意思就是把对象从文件或者网络中读取出来。（简单记：读对象）
  • 对象流是以对象为单位来读写数据。也就是把对象当做一个整体，可以写一个对象到文件，也可以从文件中把对象读取出来。
  • ObjectOutputStream
第一步：先准备一个User类，必须让其实现Serializable接口。


// 注意：对象如果需要序列化，必须实现序列化接口。
public class User implements Serializable {
    private String loginName;
    private String userName;
    private int age;
    // transient 这个成员变量将不参与序列化。
    private transient String passWord;

    public User() {
    }

    public User(String loginName, String userName, int age, String passWord) {
        this.loginName = loginName;
        this.userName = userName;
        this.age = age;
        this.passWord = passWord;
    }

    @Override
    public String toString() {
        return "User{" +
                "loginName='" + loginName + '\'' +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", passWord='" + passWord + '\'' +
                '}';
    }
}


第二步：再创建ObjectOutputStream流对象，调用writeObject方法对象到文件。


public class Test1ObjectOutputStream {
    public static void main(String[] args) {
        try (
                // 2、创建一个对象字节输出流包装原始的字节 输出流。
                ObjectOutputStream oos =
                        new ObjectOutputStream(new FileOutputStream("io-app2/src/itheima11out.txt"));
                ){
            // 1、创建一个Java对象。
            User u = new User("admin", "张三", 32, "666888xyz");

            // 3、序列化对象到文件中去
            oos.writeObject(u);
            System.out.println("序列化对象成功！！");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  • ObjectInputStream
public class Test2ObjectInputStream {
    public static void main(String[] args) {
        try (
            // 1、创建一个对象字节输入流管道，包装 低级的字节输入流与源文件接通
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("io-app2/src/itheima11out.txt"));
        ){
            User u = (User) ois.readObject();
            System.out.println(u);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
秦川Code
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
day10-IO流&Properties
06-10
day10-IO流&Properties
day10-IO流&Properties集合1
08-04
1.IO流案例 1. 定义学生类 2. 创建TreeSet集合，通过比较器排序进行排序 3. 键盘录入学生数据 4. 创建学生对象，把键盘录入的数据对应赋值给学
Day-10-IO流
流苏树的博客
03-02 92
Day-10-IO流 File类 【1】对文件进行操作： //将文件封装为一个File类的对象： File f = new File("E:\\test.txt"); File f2 = new File("E:/test.txt"); //File.separator属性帮我们获取当前操作系统的路径拼接符号 File f3 = new File("E:"+File.separator+"test.txt"); //建议使用这种 //常用方法： System.out.println("文件是否可读"+f.
Day09-IO流
欢迎来到Liu_zimo的博客
08-05 144
title: Day09-IO流 date: 2020-06-17 19:21:10 author: 子陌 IO（Input/Output）流 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的对象都在IO包中 流按操作数据分为两种：字节流于字符流 流按流向分为：输入流和输出流 字符流由来就是：早期的字节流 + 编码表，为了更便于操作文字数据 IO流常用基类 所属包：java.io 字节流的抽象基类（二进制） InputStream OutputStre.
java----IO流(重要)
sunyingboaini的博客
08-23 338
java中io流的使用
Java-day09-IO和序列化
so1125so的博客
08-05 191
一：IO流 io流（input/output） 作用：实现两个设备之间数据的通信 设备：磁盘（硬盘），内存，键盘，文件，网络，控制台 网络：当前主机之外的网上资源 分类： 根据操作的方式：输入流和输出流； 根据数据的类型：字节流和字符流 字节流：传输的是字节，可以操作任意类型的文件 ----音...
Day19-1.IO流概述 、字节流
Aaphasia的博客
08-30 140
Day191 IO概述2 字节流2.1 InputStream2.2 FileInputStream代码2.3 OutPutStream2.4 FileOutputStream代码2.5 文件的拷贝代码2.6 文件拷贝效率的提升代码2.7 高效缓冲字节流代码2.8 close和flush的区别 1 IO概述 概述：IO是Input和Output的缩写。 输入、输出。数据的输入和数据的输出。 输入输出的概念： 数据的输入和输出相对于运行内存来说，数据从其他设备进入到运行内存就是输入，数 据从运行内存到其他设
Java笔记---IO流
weixin_65440201的博客
07-12 292
目录1.缓冲流1.1缓冲流概述1.2字节缓冲流字节缓冲流性能优化原理：1.3字节缓冲流的性能分析分别使用不同的方式复制大视频观察性能情况1.4字符缓冲流字符缓冲输入流字符缓冲输出流案例：2.转换流2.1问题引出：不同编码读取乱码问题2.2字符输入转换流2.3字符输出转换流3.1对象反序列化4.打印流4.1 PrintStream、PrintWriterPrintStreamPrintWriter补充知识：Properties补充知识：IO框架缓冲流概述缓冲流也称为高效流、或者高级流。之前学习的字节流可以称为
JAVA基础学习day20--IO流二-缓冲流、字节流
weixin_34055787的博客
09-30 52
一、缓冲流 1.1、字符流的缓冲区 缓冲区的出现是为了提高IO的读写效率 对应类 BufferedReader BufferedWriter 缓冲区要结合流才可以使用 在流的基础上对流的功能进行了增强 1.2、BufferedReader、BufferedWriter   public class BufferedWriterextends Writer   构造方...
Day 28 学习分享 - IO流和递归
WrathPudge的博客
05-25 115
1. IO流的概念和应用场景 1.1 什么是流? 流, 本身是一个非常抽象的概念, 以现实生活中水为例, 我们通过管道把A池子的水放到B池子中这个过程就会产生水流, 而主体是水. 1.2 什么是IO流? IO流 -- 输入(Input)输出(Output)流 IO流可以看做不同储存设备之间的数据交换产生的 数据流 根据流向分类: 输入流: 把数据从其他设备上读取到内存中的流 输出流: 把数据存内存中写出到其他设备上的流 根据数据类型分类: 字节流: 以字节为单位读写数据的流 字符流: 以字符为
day12-13 IO流.md
11-16
day12-13 IO流.md
day019-io笔记和代码.rar
03-13
IO流： Input Output 输入输出流 自己去扩展： 1. 对象序列化和反序列化生成一个 2. 流的种类： io包下 扩展nio包下 1. IO分类： 输入流 输出流 字节流 InputStream（抽象类） ...
day10-final、接口、多态.pdf
11-02
day10-final、接口、多态.pdf
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 890
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 893
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1205
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 491
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
day--和--day区别
04-18
"day--"和"day"是两种不同的操作符，它们在编程中有着不同的含义和用法。 1. "day--"是一个后缀自减操作符，用于将变量的值减1，并返回减1之前的值。例如，如果有一个变量day的值为5，执行day--操作后，day的值将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值