Java研学-IO流(三)

最新推荐文章于 2024-11-08 23:31:31 发布
最新推荐文章于 2024-11-08 23:31:31 发布
阅读量1.1k 收藏 18
点赞数 25
分类专栏： # Java研学 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhlyxx/article/details/134719223
版权

六 字节流 – 字节输出流系列 OutPutStream体系

1 OutPutStream系列 – 字节输出流

// 表示字节输出流所有类的超类，输出流接受输出字节并将其发送到某个接收器
public abstract class OutputStream

FileOutputStream/BufferedOutputStream

2 FileOutputStream类设计

// 用于写入如图像数据的原始字节流，可实例化OutPutStream对象
public class FileOutputStream

// 当前路径下创建指定名字的文件
public FileOutputStream(String name)

// 例子
public class Test {
    public static void main(String[] args) {
        FileOutputStream fo=null;
        try {
            fo=new FileOutputStream("play2.txt");
            // public void write(byte[] bs)  写入字节数组
            // public void write(int b)  写入一个字节
            // public void write(byte[] bs,int start,int len)  写入字节数组，自指定位置始写指定长度
            fo.write(97);  // a
            fo.write("\r\n".getBytes());  // 换行
            fo.write("这里是一段文字通过字符串转换".getBytes(),0,12);
            // 这里是一 2字节1汉字
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fo!=null){
                try {
                    fo.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

  由于计算机中底层操作的都是字节数据,而OutputStream正好也是字节流,因此可以直接将数据写入到指定文件中,不需flush

3 BufferedOutputStream类设计 需flush

// 该类实现缓冲输出流，可直接向底层输入流写入字节
public class BufferedOutputStream

// 通过传递OutputStream实现类对象完成对文件的操作
public BufferedOutputStream(OutputStream out)

// 例子
public class Test {
    public static void main(String[] args) {
        BufferedOutputStream bo=null;
        try {
            bo=new BufferedOutputStream(new FileOutputStream("play.txt"));
            bo.write(66);
            bo.write("\r\n".getBytes());
            bo.write("烤鸡翅膀我最爱吃".getBytes(),0,12);
            // 烤鸡翅膀  1汉字2字节
            bo.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bo!=null){
                try {
                    bo.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

  BufferedOutputStream不能直接将数据写入到指定文件中，因为其操作的是缓存区，需要将数据刷新到指定的文件中:,建议使用BufferedOutputStream操作字节流可降低内存资源的消耗

七 字节流 – 字节输入流系列 InputStream体系

1 InputStream系列 – 字节输入流

// InputStream 类设计
Class InputStream

FileInputStream/BufferedInputStream

2 FileInputStream类设计

// 用于读取图像等数据的原始字节流
public class FileInputStream

// 打开与实际文件的链接创建FileInputStream文件，由name命名读取文件中的数据，可实例化 InputStream类对象
public FileInputStream(String name)

// 例子
public class Test {
    public static void main(String[] args) {
        FileInputStream fi=null;
        try {
            fi=new FileInputStream("play.txt");
            int data=0;
            byte[] bs=new byte[1024*5];
            while ((data=fi.read(bs))!=-1){
                System.out.println(new String(bs,0,data));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fi.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

  一个汉字（包括数字）在UTF-8编码下占用3个字节，在GBK编码下占用2个字节。因此，如果4个汉字存储需要12个字节，那么可以推断出这些汉字是在UTF-8编码下存储的。具体存储方式是将每个汉字转换为UTF-8编码下的3个字节，共计12个字节存储。

3 BufferedInputStream类设计

// 直接操作缓存区降低内存消耗
public class BufferedInputStream

// 读取InputStream 参数实现类指定的文件，创建一个BufferedInputStream并保存其参数，内部缓冲区数组创建并存在buf
public BufferedInputStream(InputStream in)

// 例子
public class Test {
    public static void main(String[] args) {
        BufferedInputStream bi=null;
        try {
            bi=new BufferedInputStream(new FileInputStream("play.txt"));
            int data=0;
            byte[] bs=new byte[1024*5];
            while ((data=bi.read(bs))!=-1){
                System.out.println(new String(bs,0,data));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(bi!=null){
                    bi.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字节流小结

  字节流高效流(带有Buffered缓存技术的流),没有像字符流那样提供高效的方法(newLine()和readLine());定义字节高效流的原因,就是操作缓存区代替直接操作系统底层,降低系统资源消耗;

八 例子

将指定盘符下的指定文件,复制粘贴到指定的盘符

public class FC {
    // 实现盘符下文件的读写操作,startName原文件名，endName目标文件名
    public void copy(String startName,String endName){
        // 分别定义两个字符高效流对象
        BufferedReader start=null;
        BufferedWriter end=null;
        try {
            // 分别实例化对象
            start=new BufferedReader(new FileReader(startName));
            end=new BufferedWriter(new FileWriter(endName));
            String data=null;
            while ((data=start.readLine())!=null){
                // 读一行写一行
                end.write(data);
                end.newLine();
                end.flush();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 防止start.close();出现异常导致end.close();无法关闭
            // 关闭多个异常时需要分别关，关闭资源操作是没有顺序的
            if (start!=null){
                try {
                    start.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (end!=null){
                try {
                    end.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

九 序列化

1 流转换

在这里插入图片描述
开发中可使用更高效的替代品

InputStreamReader – System.in — Scanner

OutPutStreamWriter – System.out.print()

2 序列化与反序列化

① 序列化：指使用指定的技术(OutputStream流，ObjectOutputStream类)，将对象中的数据(通过对象调用方法获取的结果)，存储到指定的文件中(也就是写的过程)，或通过网络上传的过程

② 反序列化：将指定文件中或网络上的对象中的数据获取到(也就是读操作InputStream流，ObjectInputStream类)

// 创建序列化对象
public class Dog implements Serializable {
	// 将序列化号固定为常量
    private static final long serialVersionUID=1L;
    // Serializable接口是一个声明接口，他没有任何抽象方法，但想实现序列化反序列化操作必须实现它
    private String name;
    private int kg;
    public  Dog(){
        super();
    }

    public Dog(String name, int kg) {
        super();
        this.name = name;
        this.kg = kg;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getKg() {
        return kg;
    }

    public void setKg(int kg) {
        this.kg = kg;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", kg='" + kg + '\'' +
                '}';
    }
}

// 序列化
public class DXTest {
    public static void main(String[] args) {
        // 声明序列化操作流对象
        ObjectOutputStream oo=null;
        try {
            oo=new ObjectOutputStream(new FileOutputStream("play.txt"));
            // 实例化需序列化的对象
            Dog yellow = new Dog("大黄",24);
            // public void writeObject(Object obj) 将序列化对象写入流中(需要flush)
            oo.writeObject(yellow);
            oo.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(oo!=null){
                try {
                    oo.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("成功上传");
        }
    }
}

// 反序列化
public class DFTest {
    public static void main(String[] args) {
        // 声明反序列化对象
        ObjectInputStream oi=null;
        try {
            oi=new ObjectInputStream(new FileInputStream("play.txt"));
            // public Object readObject() 将文件中的对象读出来 序列化对象接收是Object因此需要强转
            Dog yellow= (Dog) oi.readObject();
            System.out.println(yellow.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(oi!=null){
                try {
                    oi.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

  上传数据(序列化),是将数据以字节码的形式存储到指定的文件中，打开文件之后,无法直接阅读,需要下载(反序列化)后才能阅读
  在类的序列化过程中,如果添加新的属性,需要再次进行序列化和反序列化,这样同步操作才能不报错,如果一个没做,就会出现类无效异常 java.io.InvalidClassException

// 其中 stream classdesc serialVersionUID = 4216129340136042751 是本地读取类的序列化号
// local class serialVersionUID = 8800134341386811038 是本次已经存在的序列化号
java.io.InvalidClassException: com.Test.Dog; local class incompatible: stream classdesc serialVersionUID = 4216129340136042751, local class serialVersionUID = 8800134341386811038

  读取就是反序列化操作;而已存在就是序列化操作,两个版本号不同就会出现异常
  为了避免异常的出现,序列化后版本号进行固定;一般在实现序列化接口后,在类中(Dog类)将序列化号直接定义为常量

Java研学-IO流(二)
zhlyxx的博客
11-30 1148
在流中定义操作数据的多种方法实质上都是调用计算机操作系统的写一个或者读一个的方法:① Writer系列写一个的方法(append(char ch)/write(int ch))写一堆(write(String data)/write(char[] cbuf))② Reader系列读一个(read())读一组/行(read(char[] cbuf)/readLine())
Java研学-IO流(一)
zhlyxx的博客
11-28 644
/ 文件和目录路径名的抽象表示。
Java研学-配置文件
zhlyxx的博客
12-02 1197
标签名> – 没有特殊要求都是双标签 – 单标签,当且仅当标签之间没有编写文本内容,可以使用单标签> < Water >
Java研学-POI导入导出(一)
zhlyxx的博客
09-26 370
POI简介（Apache POI），是Apache软件基金会的开放源码函式库，POI提供API给Java程序对Microsoft Office格式档案读和写的功能。本文以Excel为例。
Java研学-Stream
zhlyxx的博客
12-08 588
JDK8的特性之一，并不是传统意义上的IO流，而是一个用于数据传输的"管道"，他的作用是提供一组高效的操作数据的方法 – 针对集合中的数据。
【Java SE基础 六】Java的IO流实现
MaoLin Tian's Blog
01-24 827
今天来继续总结一下文件io流，这块儿内容是研一的时候学的，大概时间是2016年1月13日到2016年1月14日学的，现在有些忘记，还好之前的笔记还在，重新梳理一下吧。希望能快速上手。首先io的意思就是输入输出嘛，主要包括内存，文件等地的输入输出。下边详细介绍。在介绍之前，先说一下java的编码吧。编码和编码格式编码编码就是一个编号(数字)到字符的一种映射关系，就仅仅是一种一对一的映射而已，可以理解成
Java研学-常用类(一)
zhlyxx的博客
11-21 151
作用：java为了适应不同的操作系统（Windows、Linux、Max OS）创建// 从键盘录入数据System.in// 从系统输出System.out// 将指定数组从指定位置开始，复制到目标数组的指定位置arraycopy(原数组,原数组起始位置,目标数组,目标数组起始位置,复制长度)
Java研学-Web 组件交互与作用域
zhlyxx的博客
12-26 1019
利用 JSP, Servlet 完成 web 组件的跳转，从一个组件跳到另一个组件。
11 Java文件处理之写入、读取：IO流（上）：基本流：字节流（FileOutputStream和FileInputStream）、字符流（FileReader和FileWriter）
smalltorch的博客
09-12 1161
本节我们先来介绍IO流的基本体系，并且先来学习基本流IO流：文件的读写和存储解决方案IO流的分类：根据流的方向分为输入流（读取）、输出流（写出）根据操作文件的类型分为字节流（以字节为基本单位进行数据的传输）、字符流（以字符char为单位进行数据的传输）；字节流(8 bit)，字符流(16 bit)字节流：可以操作所有类型的文件（视频、音频、纯文本等）字符流：只能操作纯文本文件（txt文件和md文件、xml文件等）什么是文件？文件就是保存数据的地方。
11 Java文件处理之写入、读取：IO流（中）：高级流（缓冲流、转换流、序列化流和反序列化流、打印流）
smalltorch的博客
09-17 423
前面学FileReader和FileWriter字符流：对于中文只能处理当前平台的编码方式进行编码和解码，不能指定编码格式进行编码解码。这个指定编码的功能，在本节的高级流（转换流）上就会得到处理。另外，高级流都是在上节的四中基本流上面进一步封装而来的，可以说前面基本流是他们的爸爸。缓冲流（提供缓冲区，加快读取写入速度，减少和硬盘交互次数）转换流（可以指定编码格式）基本流—>缓冲流转换流（都是字符流）序列化流和反序列化流（都是字节流）打印流（不能读，只能写，只有输出流）
【高效日志管理方案】：Commons-IO与日志框架的无缝整合
[Commons-IO库入门介绍与使用](https://journaldev.nyc3.cdn.digitaloceanspaces.com/2017/12/java-io-vs-nio.png) # 1. 日志管理的基本概念 日志管理是信息技术领域的一个基础而重要的环节，其涉及到信息系统的...
Java全栈学习路线、学习资源和面试题一条龙
uuqaz的博客
08-03 432
肝了一个月，终于把Java学习路线、面试题资源和电子书资源都整理好了。Java从基础到微服务的学习路线，其中还包括科班知识、学习建议、后续的学习引导和相应的学习资源（视频、书籍、网站），还整理了Java面试题，资源都在文末。写这一篇文章的目的很明确，在个人能力的基础上给小伙伴一个循环渐进的Java全栈学习路线。为小伙伴布好道路，让学习的路途尽可能的通畅。在这里点缀下个人对编程的三个层次的理解从学会使用（知其表）到深入架构设计原理（知其理）再到自研技术（思想铸造）......
JAVA架构师学习路线图（绝对详细）
M11223344555的博客
03-28 4279
JAVA架构师学习路线图（绝对详细） 性能调优 Jvm性能调优 JVM类加载机制详解 JVM内存模型 垃圾收集机制详解 十种垃圾收集器详解 JVM调优工具详解 GC日志详细分析 JVM调优实战 Mysql性能调优 SQL执行原理详解 索引底层剖析 执行计划与SQL优化 Mysql锁机制与事务隔离级别详解 Tomcat调优 整体认知Tomcat项目架构 生产环境配置 掌握Tomcat 线程模型背后原理 Nginx调优 Nginx快速掌握 熟练掌握Nginx核心配置 掌握Nginx负载算法配置 并发编程 操作系
spring循环依赖解决方式
qq_36400213的博客
11-04 889
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
JAVA-01-变量
LJH_laura_li的博客
11-08 158
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 38
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
JAVA学习接口案例实例
最新发布
shangan_3的博客
11-08 98
【代码】JAVA学习接口案例实例。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 417
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 362
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
java高级特性 - io流
05-24
Java中的IO流指的是输入输出流，是用于读写数据的机制。在Java中，IO流分为两种：字节流和字符流。字节流以字节为单位进行操作，而字符流以字符为单位进行操作。 Java中提供了丰富的IO流类，包括File、InputStream...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

泰勒疯狂展开

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值