2022-08-09 java之字节流、字符流

北北~~

已于 2022-08-09 21:23:40 修改

阅读量157

点赞数

文章标签： java jvm 开发语言

于 2022-08-09 20:45:04 首次发布

本文链接：https://blog.csdn.net/m0_46672267/article/details/126240679

版权

一、IO概述

1.IO概念&分类

IO流(Input Output Stream，输入输出流)，表示数据在程序内存和磁盘之间的传输。按照数据流的流向不同分为输入、输出流，输入流表示程序从磁盘读入数据，输出流表示程序往磁盘写数据。按照数据读取、写的方式不同分为字节流和字符流，字节流(类名以Stream结尾)表示程序按字节读取数据，什么文件都可以读取；字符流表示程序按照字符方式读取，方便读取各种编码的文本文件，但是无法读取图片、音频及视频等文件。所有的流都实现了java.io.Closeable接口，都有close方法。所有的输出流都实现了java.io.Flushable接口，都有flush方法，字符流需要手动使用flush方法才会把数据写入磁盘。
在这里插入图片描述
输入：把硬盘里的数据，读取到内存中使用
输出：把内存中的数据，写到硬盘中保存

3.输入流和输出流的类层次图

在这里插入图片描述

二、字节流

1.一切即为字节

一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

2.FileInputStream

该流用于从文件读取数据，它的对象可以用关键字 new 来创建。
有多种构造方法可用来创建对象。
可以使用字符串类型的文件名来创建一个输入流对象来读取文件：

InputStream f = new FileInputStream("C:/java/hello");

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：

File f = new File("C:/java/hello");
InputStream in = new FileInputStream(f);

在这里插入图片描述

3.FileOutputStream

该类用来创建一个文件并向文件中写数据。
如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。
有两个构造方法可以用来创建 FileOutputStream 对象。

使用字符串类型的文件名来创建一个输出流对象：

OutputStream f = new FileOutputStream("C:/java/hello")

也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：

File f = new File("C:/java/hello");
OutputStream fOut = new FileOutputStream(f);

在这里插入图片描述

三、字符流

1.FileReader

FileReader相关方法：

（1）new FileReader(File/String)

（2）read：每次读取单个字符，返回该字符，如果到文件末尾返回-1

（3）read( char[] )：将char[]转成String

2.2.FileWriter

FileWriter常用方法

（1）new FileWriter(File/String)：覆盖模式，相当于流的指针在首端

（2）new FileWriter(File/String，true)：追加模式，相当于流的指针在尾端

（3）writer(int)：写入单个字符

（4）writer(chat[])：写入指定数组

（5）writer(char[],off,len)：写入指定数组的指定部分

（6）writer(String)：写入整个字符串

（7）writer(String，off，len)：写入字符串的指定部分

四、节点流和处理流

1.基本介绍

1.节点流可以从一个特定的数据源读写数据，如FileReader，FlieWriter
2.处理流（也叫包装流）是连接在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，如BufferedReader、BufferedWriter

2.节点流和处理流的区别和联系

1.节点流是底层流/低级流，直接跟数据源相连接

2.处理流包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出

3.处理流（也叫包装流）对节点流进行包装，使用修饰器模式，不会直接与数据源相连

处理流的功能主要体现在以下两个方面：

性能的提高：主要以增加缓冲的方式来提高输入输出的效率
操作的便捷：处理流可能提供一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便

3.BufferedReader

使用BufferedReader，读取d盘中的文件

代码演示：

package com.shangma.java.reader_;
 
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
 
/**
 *  演示BufferedReader使用
 */
public class BufferedReader_ {
    public static void main(String[] args) {
 
        String filePath = "d:\\story.txt";
        BufferedReader bufferedReader = null;
        try {
            bufferedReader = new BufferedReader(new FileReader(filePath));
 
            String line;
            while ((line =  bufferedReader.readLine())!=null){
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bufferedReader != null){
                try {
                    //关闭流，这里注意，只需要关闭BufferedReader，因为底层会自动的去关闭节点流
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

4.BufferedWriter

使用BufferedWriter，向d盘中写入文字

代码演示：

/**
 *  演示BufferedWriter的使用
 */
public class BufferedWriter_ {
    public static void main(String[] args) {
 
        String filePath = "d:\\hello.txt";
        BufferedWriter bufferedWriter = null;
        String str = "救赎之道，就在其中~";
        try {
            bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));
            bufferedWriter.write(str);
            bufferedWriter.newLine();//插入一个换行符
            bufferedWriter.write(str);
            bufferedWriter.write(str);
            System.out.println("写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bufferedWriter != null){
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

4.使用BufferedReader和BufferedWriter完成文件拷贝
综合使用BufferedReader和BufferedWriter完成文件拷贝，注意编码格式

代码演示：


/**
 *  演示使用BufferedReader和BufferedWriter完成文件拷贝
 */
public class BufferedCopy_ {
    public static void main(String[] args) {
 
        //注意
        //1.BufferedReader和BufferedWriter是按照字符操作的
        //2.不要去操作二进制文件，可能造成文件损坏
 
        String sourceFilePath = "d:\\story.txt";//源文件路径
        String destFilePath = "d:\\dest.txt";//目的地文件路径
 
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
 
        try {
            bufferedReader = new BufferedReader(new FileReader(sourceFilePath));
            bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
            String line;
            while ((line = bufferedReader.readLine()) != null){
                //每读入一行，就写入一行
                bufferedWriter.write(line);
                //换行
                bufferedWriter.newLine();
            }
            System.out.println("文件拷贝成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭输入输出流
            try {
                if (bufferedReader != null){
                    bufferedReader.close();
                }
                if (bufferedWriter != null){
                    bufferedWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

5.BufferedInputStream

BufferedInputStream是字节流，在创建BufferedInputStream时，会创建一个内部缓冲数组

6.BufferedOutputStream

BufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统

7.使用BufferedInputStream和BufferedOutputStream完成图片/音乐的拷贝

要求：编程完成图片/音乐的拷贝

代码演示：

/**
 *  演示BufferedInputStream和BufferedOutputStream的使用
 */
public class BufferedCopy02_ {
    public static void main(String[] args) {
 
        String sourceFilePath = "d:\\picture.jpg";
        String destFilePath = "d:\\picture02.jpg";
 
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
 
        try {
            bufferedInputStream = new BufferedInputStream(new FileInputStream(sourceFilePath));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFilePath));
 
            //循环读取文件，并写入到destFilePath
            byte[] buf = new byte[1024];
            int readLength = 0;
            //当返回-1，就表示文件读取完毕
            while((readLength = bufferedInputStream.read(buf)) != -1){
                bufferedOutputStream.write(buf);
            }
            System.out.println("拷贝完毕~~~");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (bufferedInputStream != null){
                    bufferedInputStream.close();
                }
                if (bufferedOutputStream != null){
                    bufferedOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

五、对象流

1.序列化与反序列化
看一个需求：

1.将int num = 100，这个int数据保存到文件中，注意不是数字，而是int 100，并且，能够从文件中直接恢复int 100

2.将Dog dog = new Dog(”小黄“,3)，这个dog对象保存到文件中，并且能够从文件恢复

3.上面的要求，就是能够将基本数据类型或者对象进行序列化和反序列化操作

序列化和反序列化

1.序列化就是在保存数据时，保存数据的值和数据类型

2.反序列化就是在恢复数据时，恢复数据的值和数据类型

3.需要让某个对象支持序列化机制，则必须让其类时可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：
Serializable：这是一个标记接口，没有方法

Externalizable：该接口有方法需要实现，因此我们一般实现上面的Serializable接口

2.对象流介绍

1.功能：提供了对基本类型或对象类型的序列化和反序列化

2.ObjectOutStream提供了序列化功能

3.ObjectInputStream提供了反序列化功能

3.ObjectOutStream

     使用ObjectOutStream序列化基本数据类型和一个Dog对象(name,age)，并保存到data.dat文件中

代码演示：

/**
 *  演示ObjectOutputStream的使用，完成数据的序列化
 */
public class ObjectOutputStream_ {
    public static void main(String[] args) {
        //序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存
        String destFilePath = "d:\\data.dat";
 
        ObjectOutputStream objectOutputStream = null;
 
        try {
            objectOutputStream = new ObjectOutputStream(new FileOutputStream(destFilePath));
            //序列化数据到 e：\\data.dat
            objectOutputStream.writeInt(100);//int -> Integer(实现了 Serializable接口)
            objectOutputStream.writeBoolean(true);//boolean -> Boolean(实现了 Serializable接口)
            objectOutputStream.writeChar('a');//char -> Character(实现了 Serializable接口)
            objectOutputStream.writeDouble(9.5);//double -> Double(实现了 Serializable接口)
            objectOutputStream.writeUTF("哈哈");//String(实现了 Serializable接口)
 
            //保存一个dog对象
            objectOutputStream.writeObject(new Dog("旺财",12));
 
            System.out.println("数据保存完毕(序列化形式)");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (objectOutputStream != null){
                try {
                    objectOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
 
//如果需要序列化某个类的对象，实现Serializable接口
class Dog implements Serializable{
    private String name;
    private int age;
 
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

4.ObjectInputStream

    使用ObjectInputStream读取data.dat，并反序列化恢复数据

代码演示：

/**
 *  演示ObjectInputStream的使用，对数据反序列化
 */
public class ObjectInputStream_ {
    public static void main(String[] args) {
 
        String filePath = "d:\\data.dat";
        ObjectInputStream objectInputStream = null;
 
 
        try {
            objectInputStream = new ObjectInputStream(new FileInputStream(filePath));
 
            //读取
            //1.读取（反序列化）的顺序需要和你保存数据（序列化）的顺序一样
            //2.否则就会出现异常
            System.out.println(objectInputStream.readInt());
            System.out.println(objectInputStream.readBoolean());
            System.out.println(objectInputStream.readChar());
            System.out.println(objectInputStream.readDouble());
            System.out.println(objectInputStream.readUTF());
            System.out.println(objectInputStream.readObject());
 
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

5.对象处理流使用细节

1.读写顺序要一致

2.要求实现序列化或反序列化

3.序列化的类中建议添加SerialVersionUID，为了提高版本的兼容性

4.序列化对象时，默认将里边的所有属性进行序列化，但除了static或transient修饰的成员

5.序列化对象时，要求里边属性的类型也需要序列化接口

6.序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化

六、Properties类

1.基本介绍

专门用于读写配置文件的集合类
配置文件的格式：键=值
注意：键值对不需要有空格，值不需要用引号引起来。默认类型String
Properties的常见方法：

load：加载配置文件的键值对到Properties对象
list：将数据显示到指定设备
getProperty(key)：根据键获取值
setProperty(key,value)：设置键值对到Properties对象
store：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为Unicode码

2.应用案例

1.使用Properties类完成对mysql.properties的读取

/**
 *  使用Properties类来读取mysql.properties文件
 */
public class Properties01 {
    public static void main(String[] args) throws IOException {
 
        //1.创建Properties对象
        Properties properties = new Properties();
        //2.加载指定配置文件
        properties.load(new FileReader("mysql.properties"));
        //3.把k-v显示控制台
        properties.list(System.out);
        //4.根据key获取对应的值
        String username = properties.getProperty("username");
        
    }
}

2.使用Properties类添加key-val到新文件mysql02.properties中


/**
 *  使用Properties类来创建配置文件，修改文件内容
 */
public class Properties01 {
    public static void main(String[] args) throws IOException {
 
        Properties properties = new Properties();
 
        //创建
        //1.如果该文件没有key，就是创建
        //2.如果该文件有key，就是修改
        /**
         * Properties父类是Hashtable，底层就是Hashtable核心方法
         */
        properties.setProperty("username","汤姆");
        properties.setProperty("password","123456");
 
        //将k-v储存文件即可
        //如果使用的是字节流是unicode编码
        //properties.store(new FileOutputStream("src\\mysql02.properties"),null);//unicode编码
 
        properties.store(new FileWriter("src\\mysql02.properties"),"mysqlPropertiesFile");//中文
        System.out.println("保存配置文件成功~");
    }
}

北北~~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2022-08-09 java之字节流、字符流

输入：把硬盘里的数据，读取到内存中使用输出：把内存中的数据，写到硬盘中保存1.节点流可以从一个特定的数据源读写数据，如FileReader，FlieWriter2.处理流（也叫包装流）是连接在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，如BufferedReader、BufferedWriter1.功能：提供了对基本类型或对象类型的序列化和反序列化2.ObjectOutStream提供了序列化功能3.ObjectInputStream提供了反序列化功能。.........
复制链接

扫一扫