IO流

最新推荐文章于 2024-05-07 16:51:38 发布
最新推荐文章于 2024-05-07 16:51:38 发布
阅读量123 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52284319/article/details/111242531
版权

IO概述

什么是IO?
在这里插入图片描述
​ Java中I/O的操作主要是靠java.io包下面的类和接口来实现的，进行输入和输出操作。输入也可以叫做读取数据，输出也可以叫做写入数据。

IO分类

根据数据的流向分为：输入流和输出流

  • 输入流：把数据从其他设备上读取到内存当中的流。
  • 输出流：把数据从内存当中写入到其他设备上的流。

根据数据类型分为：字节流和字符流

  • 字节流：以字节为单位，读取数据的流。
  • 字符类：以字符为单位，读写数据的流。

IO流的顶级父类

输入流输出流
字节流字节输入流：InputStream字节输出流：OutputStream
字符流字符输入流：Reader(读)字符输出流：Writer(写)

字节流

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

字节输出流(OutputStream)

java.io.OutputStream此抽象类是表示输出字节流的所有类的超类，将指定的字节信息写入到目的地。它定义了字节输出流的基本共性的API方法：

返回值方法
publicvoidclose() : 关闭此输出流并释放与此相关的其他任何系统资源
publicvoidflush() : 刷新此输出流并强制任何缓冲的输出字节信息被写入
publicvoidwrite(byte[] b) : 将b.length字节从指定的字节数组写入到此输出流中
publicvoidwrite(byte[] b,int off,int len) : 从指定的字节数组写入len个字节，从偏移量off开始输出到此输出流中
public staticvoidwriter(int b) : 将指定的字节输出到此输出流中

备注：close()方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

java.io.FileOutputStream类是文件字节输出类，用于将数据写入到文件中

构造方法
方法
publicFileOutputStream(File file) : 创建一个向指定 File 对象表示的文件中，写入数据的文件输出流(目的地是一个文件)
publicFileOutputStream(String name) : 创建文件输出流以指定的文件名称，写入文件中。(目的地是一个文件的路径)

当你创建一个流对象时，必须先传递一个文件路径，该路径下，如果没有这个文件，会创建该文件，如果有这个文件，会清空这个文件当中的数据。

构造方法的作用：
  1. 创建一个FileOutputStream类对象
  2. 会根据构造方法中的文件/文件路径(路径上的文件不存在)，创建一个空的文件
  3. 会把FileOutputStream对象指向创建好的文件。
字节输出流的使用步骤：
  1. 创建一个FileOutputStream类对象，构造方法中传递写入数据的目的地
  2. 调用FileOutputStream对象的方法write，把数据写入到文件中
  3. 释放资源
public static void main(String[] args) throws IOException{
    //1. 创建一个FileOutputStream类对象，构造方法中传递写入数据的目的地
    FileOutputStream fos = new FileOutputStream("day28_IO\\a.txt");//相对路径
    //2. 调用FileOutputStream对象的方法write，把数据写入到文件中
    fos.write(97);
    fos.close();
}
//a

​ 写数据的时候，会把十进制的正数转换成二进制的正数97(1100001)，任意的文本编辑器，在打开文件的时候，首先会查询编码表，把字节转换成字符表示，查询ASCII表(0-127) 1100001->97->a，如果是其他值，查询系统的编码表(中文GBK)。
在这里插入图片描述

数据的追加续写

如何在保留目标文件数据，还能继续添加新的数据到目标文件中？

方法
publicFileOutputStream(File file,boolean append) : 创建文件输出流，以写入有指定的File对象表示的文件中。
publicFileOutputStream(String name,boolean append) : 创建文件输出流，已指定的名称写入文件中。

这两个构造方法，参数中都需要传入一个boolean类型的值，true表示追加数据，false表示清空原有数据。这样的情况创建输出流对象，就可以指定是否需要在文件末尾追加

代码演示：

public static void main(String[] args) throws IOException {
    //1.
    FileOutputStream fos = new FileOutputStream("day28_IO\\c.txt", true);
    //调用write方法
    fos.write("Hello World".getBytes());
    //3.关流
    fos.close();
}
写入换行

Windows系统里，换行符号是\r\n。把以指定是否需要追加续写换行。

Linux系统中，换行符号是/n

mac系统里，换行符号是/r

Unix系统里，每行结尾只有换行，即/n

回车符\r和换行符\n

  • 回车符：回到一行的开头
  • 换行符：下一行(newLine)。

系统中的换行：

  • Windows系统中，每行结尾是回车+换行。即\r\n
  • Unix系统中，每行的结尾只有换行。即/n
  • Max系统中，每行的结尾是回车。即/r

示例代码：

public static void main(String[] args) throws IOException {
    FileOutputStream fos = new FileOutputStream("day28_IO\\c.txt", true);
    //调用write方法
    fos.write("\r\n".getBytes());
    fos.write("java".getBytes());
    //3.关流
    fos.close();
}
//HelloWorld
//java

字节输入流(InputStream)

java.io.InputStream此抽象类是表示字节输入流的所有类的超类。可读取字节信息到内存中，它定义了字节输入流的基本共性的API方法：

返回值方法
publicvoidclose() : 关闭此输入流并释放与此流相关的其他的任何系统资源
publicabstract intread() : 从输入流中读取数据的下一个字节
publicintread(byte[] b) : 从输入流中读取一些字节数，并将它们存储到字节数组b当中

备注：close方法，当完成流的相关操作后，需要调用此方法关闭输入流

FileInputStream类

java.io.FileInputStream类是文件输入流，从文件中读取字节。

构造方法
方法
publicFileInputStream(File file) : 通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的FIle对象file命名。(File file ： 文件)
publicFileInputStream(String name) ： 通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名name命名。(String name ： 文件的路径)

当你创建一个流对象时，必须传入一个文件路径，该路径下如果没有该文件，会抛出文件找不到异常，FileNotFoundException。

构造方法作用：
  1. 会创建一个FileInputStream类对象
  2. 会把FileInputStream类对象指定构造方法要读取的文件
使用步骤：
  1. 创建一个FileInputStream类对象，构造方法中指定要读取的文件
  2. 使用FileInputStream类对象中的方法read()，读取文件中的数据(如果文件遍历完，返回-1)
  3. 释放资源，关闭流对象
代码示例：
public static void main(String[] args) throws IOException {
    FileInputStream fis = new FileInputStream("day28_IO\\c.txt");
    int read = fis.read();
    System.out.println(read);
    int len = 0;
    while ((len = fis.read()) != -1){
        System.out.println((char)len + " ");
    }
    fis.close();
}

读取数据的原理

Java–>JVM–>OS–>OS调用系统中读取数据的方法–>读取文件中的数据。

​ 可以使用字节数组类读取数据：read(byte[] b) 从输入流中读取一些字节数，并将它们存储到字节数组b当中。当读取到文件的末尾时，返回一个-1

public static void main(String[] args) throws IOException {
    FileInputStream fis = new FileInputStream("day28_IO\\c.txt");
    int len = 0;
    byte[] bytes2 = new byte[1024];
    while ((len = fis.read(bytes2)) != -1){ 
        System.out.println(new String(bytes2,0,len));  
    }
}

备注：使用数组读取，每次可以读取到多个字节，减少了系统间的IO操作次数，从而提高了读取的效率，建议使用，

​ 例题：通过字节流实现复制图片，从桌面的复制到D盘目录下

public static void main(String[] args) throws IOException {
    //创建字节输入流对象,
    FileInputStream fis = new FileInputStream("C:\\Users\\zzzz\\Desktop\\0001.png");
    //创建字节输出流对象,
    FileOutputStream fos = new FileOutputStream("D:\\codes\\java31\\day28_IO\\0001.png");
    int len = 0;
    byte[] bytes = new byte[1024];
    //使用read方法读取文件
    while ((len = fis.read(bytes)) != -1){
        fos.write(bytes);
    }
    fos.close();
    fis.close();
}

备注：流的关闭顺序：先开后关，后开先关；

字符流

​ 当使用字节流读取文本文件的时候，可能会引发一些小问题，如果你遇到了中文字符时，可能不会显示完整的字符。那就是因为一个中文字符可能占据多个字节存储。所以Java就提供了一些字符流类，以字符为单位读写数据，专门用来处理文本文档文件。

字符输入流(Reader)

java.io.Reader 抽象类表示用于读取字符流的所有类的超类，可以读取字符信息到内存当中，它定义了字符输入流的基本共性的API方法

返回值方法
publicvoidclose() : 关闭此输入流并释放与此流相关的其他的任何系统资源
publicintread() : 从输入流中读取一个字符
publicintread(char[] cbuf) : 从输入流中一次读取多个字符，并将他们存储到字符数组chuf当中

FileReader类

java.io.FileReader类主要是用于读取字符文件的便捷性，构造方法使用默认的编码字符集和默认的字节缓冲区

备注：

  1. 字符编码：字节与字符的对应的规则，Windows系统中的中文编码字符集默认是GBK，idea中采用UTF-8
  2. 字节缓冲区：一个字节数组，用来临时存储字节数据
构造方法
方法
publicFileReader(File file) : 创建一个新的FileReader对象，指定需要读取的file对象
publicFileReader(String Filename) : 创建一个新的FileReader对象，指定需要读取的文件名称

当你创建一个流对象是，必须传入一个文件路径。类似于FileInputStream。

​ 使用字符数组读取数据：read(char[] cbuf)，每次读取cbuf的长度个字符到数组当中，返回读取到的有效的字符的个数，当它读取到末尾时，返回-1

代码示例

public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("day28_IO\\c.txt");
        char[] cbuf = new char[1024];
        int len = 0;
        while ((len = fr.read(cbuf)) != -1){
            //字符数组转换成字符串
            //String static valueOf()
            System.out.println(String.valueOf(cbuf,0,len));
        }
        fr.close();
    }

字符输出流(Writer)

java.io.Writer抽象类时表示用于输出字符流的所有类的超类，将指定那个的字符写入到目的地中，它定义了字符输出流的基本的共性API方法：

返回值方法
voidwriter() : 写入单个字符
voidwriter (char[] cbuf) : 写入字符数组
voidwriter(char[] cbuf,int off,int len) : 写入char数组的一部分，从char数组的起始索引值off开始，len个写入的字符个数
voidwriter(String str) : 写入字符串
voidwriter(String str,int off,int len) : 写入字符串的一部分，从字符串的其实索引off开始，写入len个字符个数
voidflush() : 刷新该流的缓冲。
voidclose() : 关闭此流，但是需要先刷新它。

FileWriter类

java.io.FileWriter类是用于写入字符到文件中，构造方法使用系统默认的字符编码和默认的字节缓冲区。

构造方法
FileWriter(File file) : 创建一个新的FileWriter对象，指定需要读取的file对象
FileWriter(String filename) : 创建一个新的FileWriter对象，指定需要读取的文件名称
字符输出流的使用步骤
  1. 创建一个FileWriter对象，构造方法中绑定需要写入数据的目的地
  2. 使用FileWriter对象中的方法writer，把数据写入到内存缓冲区(字符转换为字节的过程)
  3. 使用FileWriter对象中的方法flush，把内存缓冲区中的数据刷新到文件中
  4. 释放资源(会先把内存缓冲区的数据刷新到文件中)
public static void main(String[] args) throws IOException {
    //1.创建一个FileWriter对象，构造方法中绑定需要写入数据的目的地
    FileWriter fw = new FileWriter("day28_IO\\e.txt");
    //2.使用FileWriter对象中的方法writer，把数据写入到内存缓冲区(字符转换为字节的过程)
    fw.write(122);
    //3.使用FileWriter对象中的方法flush，把内存缓冲区中的数据刷新到文件中
    //fw.flush();
    //4.释放资源(会先把内存缓冲区的数据刷新到文件中)
    fw.close();
}
关闭和刷新

​ 因为内置缓冲区的原因，如果不关闭输出流，无法写入字符到文件中。但是关闭流对象，是无法继续写入数据到文件中。如果既想写入数据到文件中，又想继续使用流对象，那么就需要flush方法。

flush和close方法的区别：

​ flush()：刷新缓冲区，流对象可以继续使用

​ close()：先刷新缓冲区，然后会通知系统释放资源，关闭流对象，流对象不可以再使用。

public static void main(String[] args) throws IOException {
        //1.创建一个FileWriter对象，构造方法中绑定需要写入数据的目的地
        FileWriter fw = new FileWriter("day28_IO\\e.txt");
        //2.使用FileWriter对象中的方法writer，把数据写入到内存缓冲区(字符转换为字节的过程)
        fw.write(97);//a
        //3.刷新
        fw.flush();
        //刷新之后流可以继续使用
        fw.write(98);
        //4.关流
        fw.close();
        //close方法之后,流关闭,已经从内存小时,不能再使用,如果使用会抛出异常 Stream closed
        fw.write(99);
    }
写入字符数组

：write(char[] cbuf)和write(char[] cbuf,int off,int len)，每次可以写入一个字符数组的数据，用法类似于FileOutputStream

    public static void main(String[] args) throws IOException {
        //new
        FileWriter fw = new FileWriter("day28_IO\\g.txt", true);
        //write
        char[] chars = new char[50];
        //fw.write();
        for (int i = 0; i < 50; i++) {
            chars[i] = (char)(20000+i);
            fw.write(chars[i] + "\r\n");
        }
        //刷新
        fw.flush();
        //关流
        fw.close();
    }

备注：字符流只能操作文本文件，不能操作图片，视频等非文本文件。

当我们单纯的就是想操作文本文件，使用字符流，其他情况一律使用字节流

IO异常的处理

JDK1.7之前的处理，使用try…catch…finally 处理流中的异常。

JDK7新特性
在try的后边,可以增加一个(),在括号中定义流对象
那么这个流对象的作用域就在try中有效.
try中的代码执行完毕,会自动把对象释放.不用写finally

JDK7新特性

​ 可以使用try-with-resource语句，该语句确保了每个资源在该语句结束时关闭，所谓的资源(resource)是指在程序完成后，必须要关闭的对象。

​ 格式:

try(定义流对象) {
    可能会出现异常的代码
}catch(异常类型 异常变量名) {
    异常的处理逻辑
}

public static void main(String[] args) {
    try (FileOutputStream fw = new FileOutputStream("day28_IO\\0001.png", true);
          FileInputStream fr = new FileInputStream("C:\\Users\\zzzz\\Desktop\\0001.png");
    ) {
        int len = 0;
        while ((len = fr.read()) != -1) {
            fw.write(len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

  • 属性集(重点)

  • 缓冲流

  • 转换流(字节<–>字符)

  • 序列化流(Object & Seriable)

  • 打印流(PrintStream)

属性集(Properties)

java.util.Properties类继承于Hashtable，用来表示一个持久的属性集，它使用键值结构存储数据，每个键及其对应的值都是一个字符串。

构造方法
方法
publicProperties() : 创建一个空的属性集列表。
共性的API方法
返回值方法
publicObjectsetProperty(String key,String value) : 保存一对属性
publicStringgetProperties(String key) : 使用此属性列表中的指定的键搜索对应的值
publicset()stringPropertiesNames() : 获取所有的键的名称并封装到set集合
public static void main(String[] args) {
    Properties properties = new Properties();
    //添加元素
    properties.setProperty("name", "abc.txt");
    properties.setProperty("size", "12000");
    properties.setProperty("destination", "D:\\abc.txt");
    properties.put("data", "小孙");
    System.out.println(properties);//{destination=D:\abc.txt, name=abc.txt, size=12000, data=小孙}
    //通过键来获取值
    String data = properties.getProperty("data");//小孙
    System.out.println(data);
    String size = properties.getProperty("size");//12000
    System.out.println(size);
    //遍历该属性集
    Set<String> set = properties.stringPropertyNames();
    for (String key : set) {
        //通过key获取value
        String value = properties.getProperty(key);
        System.out.println(key + "=" + value);
    }
}
与流相关的方法
返回值方法
publicvoidload(InputStream input) : 从字节输入流中读取键值对(键和元素对)。
publicvoidload(Reader reader) : 从字符输入流当中,读取文件中的键值对
publicvoidstore(OutputStream out,String comments) : 把集合当中的数据写入到字节输出流中。 (String comments : 注释:解释说明保存的文件用来做什么的，不能使用中文，会出现乱码)
publicvoidstore(Writer writer,String comments) : 把集合当中的数据写入到字符输出流中。

参数中使用了字节输入流，通过流对象，可以关联到某个文件上，这样既可以加载文件中的数据。文件中的数据的格式：key=value

例如：

data=小孙;
size=12000;
name=abc.txt
load()方法示例
public static void show01() throws IOException {
    //构建一个流对象
    FileReader fr = new FileReader("day29_IO\\abc.txt");
    //创建Properties集合
    Properties properties = new Properties();
    //使用Properties集合中的方法load读取保存到输入流当中的数据
    properties.load(fr);
    //遍历集合
    Set<String> set = properties.stringPropertyNames();
    for (String key : set) {
        //通过key获取value值
        String value = properties.getProperty(key);
        System.out.println(key + "=" + value);
    }
    fr.close();
}

注意：

  1. 在存储键值对的文件中，键与值默认的连接符号是"="，可以使用空格(其他符号)。
  2. 存储键值对的文件中，可以使用#进行注释，被注释的键值对不会被读取到。
  3. 存储键值对的文件中，键与值默认是字符串，不用额外的添加双引号。
store()方法示例：

可以使用Properties集合当中的方法store()，把集合当中的临时数据，持久化写入到硬盘文件中。

public static void show02() throws IOException {
    //1. 创建Properties集合对象,添加数据
    Properties properties = new Properties();
    properties.setProperty("四大名著1", "红楼梦");
    properties.setProperty("四大名著2", "西游记");
    properties.setProperty("四大名著3", "水浒传");
    properties.setProperty("四大名著4", "三国演义");
    //2. 创建字节输出流/字符输出流对象,搞糟方法中绑定需要写入数据的目的地
    FileWriter fw = new FileWriter("day29_IO\\abcd.txt",true);
    //3. 使用Properties集合中的方法store,把集合当中的临时数据,持久化写入到硬盘当中存储
    properties.store(fw,"si da ming zhu");
    //4. 释放资源
    fw.close();
}

注意事项：注释不能使用中文，会有中文或有乱码，

缓冲流(Buffered)

​ 缓冲流可以理解为对原来的使用数组方式进行数据传输的一种增强

按照类型分为：

  • 字节缓冲流：BufferedInputStream，BufferedOutputStream
  • 字符缓冲流：BufferedReader，BufferedWriter

缓冲流的基本原理，是在创建流对象的时候，会先创建一个内置的默认大小的缓冲区数组，通过缓冲区来读写数据，减少系统IO操作的次数，较少开销，提高程序读写的效率。

字节缓冲流

构造方法
方法
BufferedInputStream(InputStream input) ： 创建一个新的缓冲输入流(继承InputStream)
publicBufferedInputStream(InputStream input,int size) : 创建一个新的具有指定大小的缓冲输入流
publicBufferedOutputStream(OutputStream output) ： 创建一个新的缓冲输出流(继承OutputStream)
publicBufferedOutputStream(OutputStream output,int size) ： 创建一个新的具有指定大小的缓冲输出流，
BufferedOutputStream(OutputStream output)方法示例
    public static void main(String[] args) throws IOException {
        //1.创建一个FileOutputStream流对象,构造方法中绑定需要写入数据的目的地
        FileOutputStream fos = new FileOutputStream("day29_IO\\one.txt");
        //2.创建BufferedOutputStream对象,构造方法中传递FileOutputStream流对象
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //3.使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区中
        bos.write("HelloWorld_Java".getBytes());
        //4.使用BufferedOutputStream对象中的flush方法,把内存缓冲区的数据刷新到目的地中
        bos.flush();
        //5.释放资源
        bos.close();
    }
BufferedInputStream(InputStream input)方法示例
public static void main(String[] args) throws IOException {
    //1.创建一个FileInputStream流对象,构造方法中绑定需要写入数据的目的地
    final FileInputStream fis = new FileInputStream("day29_IO\\one.txt");
    //2.创建BufferedInputStream对象,构造方法中传递FileInputStream流对象
    final BufferedInputStream bis = new BufferedInputStream(fis);
    //3.使用BufferedInputStream对象中的方法read,把数据写入到内部缓冲区中
    byte[] bytes = new byte[1024];
    int len = 0;
    while ((len = bis.read(bytes)) != -1){
        System.out.println(new String(bytes,0,len));
    }
    //4.释放资源
    fis.close();
}

字符缓冲流

构造方法
方法
publicBufferedWriter(Writer out) ; 创建一个新的字符缓冲流
publicBufferedReader(Reader in) : 创建一个新的字符缓冲输入流
特有方法
返回值BufferedReader方法
publicStringreadLine() : 读取整行的文本信息
返回值BufferedWriter方法
publicvoidnewLine() : 写入一行的行分隔符，由系统属性定义换行符号。
BufferedWriter字符缓冲输出流
    public static void main(String[] args) throws IOException {
        //1.创建一个字符缓冲流对象,构造方法中传递一个字符输出流
        final BufferedWriter bw = new BufferedWriter(new FileWriter("day29_IO\\two.txt"));
        //2.调用字符缓冲流对象的writer方法,把数据写入到缓冲区中.
        bw.write("我今天学习了ps");
        bw.newLine();
        bw.write("3D软件");
        bw.newLine();
        bw.write("c");
        //3.调用字符缓冲区输出流对象中的flush方法,不内存缓冲区的数据刷新到文件
        bw.flush();
        //4.释放资源
        bw.close();
    }
BufferedReader字符缓冲输入流
    public static void main(String[] args) throws IOException {
        //1.创建一个字符缓冲输入流对象,构造方法中传递一个输入流对象
        final BufferedReader br = new BufferedReader(new FileReader("day29_IO\\abc.txt"));
        //2.使用字符缓冲输入流中的read方法或readLine方法,读取信息
        //循环的结束条件 readLine()返回值为null
        String str = null;
        while ((str = br.readLine()) != null){
            System.out.println(str);
        }
        //3.释放资源
        br.close();
    }

示例：文件复制：使用缓冲流和不使用缓冲流，消耗的时间比较

public class Demo05CopyImageFile {
    public static void main(String[] args) throws IOException {
        //show01();
        show02();
    }
    //不使用缓冲流的操作
    public static void show01() throws IOException {
        //获取开始时间
        long time1 = System.currentTimeMillis();
        //构建一个字节输入流对象
        FileInputStream fis = new FileInputStream("C:\\Users\\zzzz\\Desktop\\3.gif");
        //构建一个字节输出流对象
        FileOutputStream fos = new FileOutputStream("day29_IO\\3.gif");
        //3.调用字节输入流的read(byte[] b)方法
        byte[] bytes = new byte[1024];
        int len = 0;//记录读取到的有效字节个数
        while ((len = fis.read(bytes)) != -1){
            //4.把读取到的字节内容写入到目的地文件中,调用write(byte[] b)方法
            fos.write(bytes,0,len);
        }
        //5.释放资源,先开后关
        fos.close();
        fis.close();
        //获取结束时间
        long time2 = System.currentTimeMillis();
        System.out.println("文件读取时间" + (time2 - time1) + "ms");
    }
    //使用缓冲流完成文件复制
    public static  void show02() throws IOException {
        //获取开始时间
        long time1 = System.currentTimeMillis();
        //构建一个字节输入流对象
        final BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\zzzz\\Desktop\\3.gif"));
        //构建一个字节输出流对象
        final BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day29_IO\\3.gif"));
        //使用字节缓冲输入流的方法read来读取文件
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = bis.read(bytes)) != -1){
            //把读取到的字节内容写入到目的地
            bos.write(bytes,0,len);
        }
        //释放资源
        bos.close();
        bis.close();
        //时间
        long time2 = System.currentTimeMillis();
        System.out.println("文件读取时间" + (time2 - time1) + "ms");
    }
}
//不使用缓冲流：文件读取时间454ms
//  使用缓冲流：文件读取时间148ms

转换流(字节流<–>字符流)

字符编码：

​ 按照某种规则，将字符存储到计算机中，成为编码；反之，将存储到计算机中的二进制数按某种规则解析显示出来，称为解码。在进行编码和解码过程中，我们必须采用的是同一种规则，才能数据正常，否则，会导致乱码现象。

  • 字符编码：就是一套自然语言中的字符与二进制数之间的对应规则。

字符集：

  • ​ 字符集：一个系统可支持的所有字符的集合，包括各国文字，标点符号，图形符号，数字等。也叫编码表。

​ 计算机中要准确存储和识别各种文字的字符符号，需要进行字符编码，一套字符集至少有一套字符编码。

​ 常见的字符编码集由ASCII字符集，GBK字符集，Unicode字符集

ASCII字符集：
  • ASCII是基于拉丁字母的一套编码系统。用于显示现代英语。
  • 基本的ASCII字符集，使用7位(bit)表示一个字符，共128个字符。ACSII的扩展字符集，使用8位(bit)表示一个字符，共256个字符。
ISO-8859-1字符集：
  • 拉丁码表，别名–Lantin-1，用于显示欧洲使用的语言，包括荷兰，丹麦，德语，意大利语，西班牙语等。
  • ISO-8859-1使用单字节码表，兼容ASCII编码。
GB字符集：
  • ​ GB2312：称为简体中文码表，里面大概含有7000多个简体汉字，此外一些数学符号，罗马，希腊的字母，日本的假名都编进去了，连在ASCII里的原来就有的数字，表点，字母都统统重新用两个字节编写进去了。
  • GBK：最常用的中文码表，是在原来的GB2312码表的基础上进行扩展。使用双字节编码。共收录了21000多个汉字，完全兼容GB2312标准，同时支持繁体汉字以继日韩文字。
  • GB18030：最新的中文码表，共收录了7万多个汉字，采用多字节编码，每个字可以由1个字节，2个字节或者是4个字节组成，支持国内少数民族的文字，同时也支持繁体字以继日韩汉字等
Unicode字符集
  • Unicode编码系统为表达任意语言的任意字符而设计的，是业界的一种标准，也称为统一码表，标准万国码表
  • 它最多使用四个字节的数字来表示每个字母，符号，或者文字，由三种常见的编码方案，UTF-8，UTF-16，UTF-32。
  • UTF-8编码表，用来表示Unicode标准中的任意字符，编码规则
    1. 128个US-ASCII字符，使用的是一个字节编码
    2. 拉丁字的字母，需要两个字节编码
    3. 大部分常见的汉字，使用的是三个字节编码
    4. 其他极少数的辅助字符，采用的四个字节编码

编码会引发的问题

由于编码规则不一致，导致引发乱码现象。

那么如何来读取GBK编码的文件？

InputStreamReader类

​ 转换流java.io.InputStreamReader，是Reader的子类，它是从字节流到字符流的桥梁，它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，或者可以使用平台默认的字符集。

构造方法
方法
publicInputStreamReader() : 创建一个使用默认的字符集的字符流
publicInputStreamReader(InputStream in,String charsetName) : 创建一个指定字符集的字符流

InputStream in ： 字节输入流，用来读取文件种保存的字节

String charsetName ： 指定编码表名称，UTF-8/utf-8，GBK/gbk，不区分大小写，不指定默认为UTF-8.。

代码演示：
//读取一个使用GBK编码的文件
public static void show01() throws IOException {
    //1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
    InputStreamReader isr = new InputStreamReader(new FileInputStream("day29_IO\\新建文本文档.txt"), "GBK");
    //2.使用InputStreamReader对象中的read方法读取文件中的信息
    int len = 0;
    while ((len = isr.read()) != -1) {
        System.out.print((char) len);
    }
    //3.释放资源
    isr.close();
}

OutputStreamWriter类

​ 转换流java.io.OutputStreamWriter是Writer的子类，它是字符流到字节流的桥梁。使用指定的编码字符集(charsetName)将字符编码为字节。它的字符集可以手动指定，也可以使用平台默认的字符集。

构造方法
方法
publicOutputStreamWriter() : 创建一个使用平台默认的字符集的字符流
publicOutputStreamWriter(OutputStream out,String charsetName) : 创建一个指定的字符集的字符流。

将GBK编码的文件，转换成UTF-8编码的文件。

  1. 将指定GBK编码的转换流，读取文本文件。InputStreamReader
  2. 使用UTF-8编码的转换流，写入到文本文件。OutputStreamReader
public static void main(String[] args) throws IOException {
    //1.1将指定GBK编码的转换流，读取文本文件。InputStreamReader
    InputStreamReader isr = new InputStreamReader(new FileInputStream("day30_IO\\GBK.txt"), "GBK");
    //1.2使用UTF-8编码的转换流，写入到文本文件。OutputStreamReader
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day30_IO\\UTF-8.txt"), "UTF-8");
    //2.使用转换流读取数据文件
    char[] chars = new char[1024];
    int len = 0;
    while ((len = isr.read(chars)) != -1){
        //读取出来的数据要写入到目的地文件
        osw.write(chars,0,len);
    }
    osw.close();
    isr.close();
}

序列化流

​ Java提供了一种对象序列化的机制，用一个字节可以表示一个对象，该字节序列包含该对象的数据，对象的类型和对象中存储的属性信息。字节序列写入到文件中后，就想当于在文件中保存类一个对象信息。

​ 反之，给字节序列还可以从文件读取出来，重构对象，对它进行反序列化。对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。

ObjectOutputStream类

java.io.ObjectOutputStream类，将Java对象的原始数据类型写入到文件中，实现对象的持久化存储。

构造方法
构造方法
ObjectOutputStream(OutputStream out) : 创建一个指定的OutputStream的ObjectOutputStream类对象
特有的方法
返回值方法
voidwriterObject() ： :将指定的对象写入到对象序列化流
public static void main(String[] args) throws IOException {
    //1.创建ObjectOutputStream对象,构造方法中传递只当的字节输出流
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day30_IO\\students.txt"));
    //2.使用ObjectOutputStream对象中的writeObject方法,把对象写入到文件中
    //2.1先创建一个对象
    Student s1 = new Student("小孙",30);
    //2.2写对象到文件中
    oos.writeObject(s1);
    //3.释放资源
    oos.close();
}
序列化操作

  1. 一个对象想要能够序列化和反序列化，必须满足两个条件

    • 该类必须实现java.io.Serializable接口，Serializable接口，是一个标记型接口，如果该类没有实现Serializable接口，或抛出NotSerializableException。

    • 该类的所有属性必须是可以实现序列化或反序列化。如果有一个属性不想让它参与序列化，则该属性必须标明是瞬态的，瞬时的。这个关键字是transient。
      进行序列化时该属性没有值，系统会赋一个默认值

      public class Student implements Serializable {
    private String name;
    private transient Integer age;//不让age属性参与序列化
}

ObjectInputStream类

java.io.ObjectInputStream类是反序列化流，将之前使用ObjectOutputStream序列化流的原始数据恢复过来。

构造方法
构造方法
ObjectInputStream(InputStream in) : 创建一个指定的InputStream的对象反序列化流对象
特有方法
返回值方法
public finalObjectreadObject() : 从反序列化流中读取一个对象。
public static void main(String[] args) throws IOException, ClassNotFoundException {
    //1.创建一个ObjectInputStream流对象,构造方法中传递一个字节输入流对对象
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day30_IO\\students.txt"));
    //2.使用ObjectInputStream流对象中的方法readObject(),读取保存在文件中的对象数据
    Object obj = ois.readObject();
    //3.释放资源
    ois.close();
    //4.查看对象的数据
    System.out.println(obj);
    if (obj instanceof Student){
        Student student = (Student)obj;
        System.out.println(student.getAge() + student.getName());
    }else {
        System.out.println("转换失败");
    }
}

​ 对于JVM来说，能够进行反反序列化的对象，前提条件是必须能够找到class文件的类，如果找不到该class文件，则会抛出一个ClassNotFoundException。

​ 另外，当JVM序列化对象时，能够找到class文件，但是class文件在序列化对象时，发生了修改，那么反序列化操作就会抛出一个invalidClassException异常：原因如下：

  • 该类的序列化版本号与从流中读取出来描述该类的版本号不一致。
  • 该类包含了位置数据类型
  • 该类没有可访问的无参构造方法。

Serializable接口给需要序列化的类，提供了一个序列版本号，serialVersionUID该版本号的目的就是在于验证序列化的对象和对应的类的是否是版本一致的。可以在类中手动定义一个版本号，如：private static final long serialVersionUID = 1l;

练习：存储一些对象，实现序列化和反序列化动作

public static void main(String[] args) throws IOException, ClassNotFoundException {
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day30_IO\\stu.txt"));
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day30_IO\\stu.txt"));
    Student s1 = new Student("小王",20);
    Student s2 = new Student("小李",30);
    Student s3 = new Student("小王",18);
    ArrayList<Student> list = new ArrayList<>();
    list.add(s1);
    list.add(s2);
    list.add(s3);
    //
    oos.writeObject(list);
    Object obj = ois.readObject();
    if (obj instanceof ArrayList) {
        ArrayList<Student> list2 = (ArrayList<Student>) obj;
        System.out.println(list2.get(1).getAge());
    }else {
        System.out.println("转型失败");
    }
    ois.close();
    oos.close();
}

打印流

java.io.PrintStream类继承OutputStream类，除了常规的IO流的操作，还有很方便的打印各种数据值的方式

  1. 只负责数据的输出，不负责数据的读取
  2. 与其他流不同，这个流不会抛出IOException

特有的方法

方法
voidprint(任意类型的值) :
voidprintln(任意类型的值并且含有换行)

构造方法

publicPrintStream(File file) : 输出的目的地是一个文件
publicPrintStream(String filename) : 输出的目的地是一个文件路径
publicPrintStream(OutpotStream out) : 输出的目的地是一个字节输出流

注意事项：

​ 如果使用来自父类当中的方法write()写入数据，那么查看数据的时候会查询编码表

​ 如果使用的是自己特有的方法print/println写入数据，那么写入的数据和输出的数据是一样的。

改变打印流的方向

正常System.out就是PrintStream类型的，数据的流动的位置在控制台中，改变数据的流动位置，通过System.setOut(PrintStream print)来改变方向

PrintStream out = System.out;
out.print(123);//在控制台中输出
//构造方法创建一个打印流对象
PrintStream printStream = new PrintStream("day30_IO\\print.txt");
//改变打印流的方向
System.setOut(printStream);
System.out.println("输出数据的位置");
无；忧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
File 类用法和 InputStream, OutputStream,Reader,Wirter 的用法
哒哒的博客
10-10 2046
File 类用法和 InputStream, OutputStream,Reader,Wirter 的用法
Java 文件IO操作基础，File，FileInputStream，FileOutputStream
weixin_53064820的博客
02-03 883
如下相关的文件io方法。
FileInputStream和Files.newInputStream？
最新发布
ordinary_brony的博客
05-07 739
在上传文件的时候，发现还有一个新的东西叫做Files.newInputStream，就稍微看了一下下。主要应用示例在https://blog.csdn.net/ordinary_brony/article/details/138537356中，也可以看http://hexo.sakebow.cn/2024/05/07/Java/FileInputStream-and-Files.newInputStream/。
java文件操作02--IO读写文件
qq_34955471的博客
06-20 481
前面对文件创建进行了解读，本章对文件读写进行解读 传统的IO操作 读取 FileReader.read(); FileReader reader=new FileReader("F:/text.txt"); int c=0; char[] buf=new char[1024]; while( (c=fr.read(buf))!=-1 ){ sout((new String(buf,0,c))); } BufferedReader.readline(); BufferedReader in=
输入输出流和多线程
BARON88878的博客
11-20 558
/** 利用字节输出流往文件中写东西 * //按照数据处理单元划分----字节流--字节输入流 InputStream基类 // 字节流是8位通用字节流 //抽象类 * * * InputStream （抽象类） * read() * read(byte[] b) * read(byte[],off,len) * close() * * FileInputStream * new FileInputStream(File fi.
Java InputStream转File
myname849的博客
01-29 6298
Java InputStream转File
Java中的IO流
12-22
一、 什么是IO流 一般情况下是按照当前程序使用的内存为参照物来考虑数据的走向问题。 以文件操作为例 从内存中保存数据到硬盘 output 从硬盘中读取数据到内存 input 看视频，缓冲 使用缓冲可以让用户体验提高，相对...
Java IO流 文件传输基础
09-02
Java IO流是Java平台中用于处理输入输出的重要机制，它涉及到数据从源到目标的传输。文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，...
IO流自用模板
12-17
在Java编程中，IO流（Input/Output Stream）是用来处理数据输入和输出的重要工具。它允许程序与外部设备，如硬盘、网络、内存等进行数据交互。IO流分为两大类：字节流（处理字节数据）和字符流（处理字符数据）。...
java IO流文件的读写具体实例
09-04
Java IO流是Java平台中用于处理输入输出的重要机制，它允许程序与各种数据源和目的地进行交互，包括文件、网络连接、系统硬件等。在Java中，IO流分为四个主要类别，分别是字节流（处理二进制数据）、字符流（处理...
IO流的主要流
07-12
Java中的IO流主要负责在不同数据源之间进行数据的传输，包括从文件系统、网络、内存等地方读取数据，以及向这些地方写入数据。IO流被设计为双工通道，既可以进行输入操作，也可以进行输出操作。Java的IO流体系结构...
Java IO流学习总结
weixin_33895516的博客
01-06 1151
Java流操作有关的类或接口： Java流类图结构：   流的概念和作用 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。  IO流的分类 根据处理数据类型的不同分为：字符流和字节流 根据数据流向不同分为：输入流和输出流   字符流...
Java基础5
m0_62550895的博客
11-26 251
Java基础5
okHttp使用中报Could not find method java.nio.file.Files.newOutputStreamo警告问题
技术归档
10-22 8832
最近在使用okHttp过程中总是报下面的警告 I/dalvikvm﹕ Could not find method com.squareup.okhttp.internal.huc.HttpURLConnectionImpl.getContentLengthLong, referenced from method com.squareup.okhttp.internal.huc.HttpsURLC
java实现files创建输入流_Java自学第10期——File类与IO流（输入输出流、处理流、转换流、缓冲流、Properties集合、打印流）...
weixin_39686192的博客
02-25 496
1、IO简介IO(输入输出)通过java.io包下的类和接口来支持，包下包括输入、输出两种IO流，每种输入输出流又可分为字符流和字节流两大类。2、File类File类是io包下与平台无关的文件和目录，File能新建、删除、重命名文件和目录，不能访问文件本身，后者需要使用输入输入流。2.1 构造方法File类的构造方法：File(File parent, String child) 参数：父...
IO流知识点总结
smiling_chang的博客
07-16 149
IO流知识点总结 * 一、IO流概述 * 1.字符流和字节流基类 * 字节流两个基类：InputStream  OutputStream  -操作图片 * 字符流两个基类：Reader           Writer               -操作文字  * 2.字符流和字节流子类 * 字符流: FileReader               FileWriter  *          ...
JAVA基础-IO流概述及常用方法(思维导图+示例代码)
qq_45748269的博客
08-15 1595
目录 1.字节流 1.1 IO流概述和分类 1.2字节流写数据 1.3字节流写数据的三种方式 1.4字节流写数据的两个小问题 1.5字节流写数据加异常处理 1.6字节流读数据(一次读一个字节数据) 1.7字节流复制文件 1.8字节流读数据(一次读一个字节数组数据) 1.9字节流复制文件 2.字节缓冲流 2.1字节缓冲流构造方法 2.2字节缓冲流复制视频 3.字符流 3.1字符串中的编码解码问题 3.2字符流写数据 3.3字符流读数据 4.字符缓冲流 4.1字...
JAVA程序设计----练习题
乔治大哥的博客
05-22 8881
1.已知数组int[] arr = {1,54,3,87,108,77,56,35,20};(10) * 设计一个工具类，完成以下功能： * 1）计算出数组中所有的奇数和、偶数和 * 2）利用冒泡排序方式对数组进行排序（从大到小） import java.util.Arrays; /** * 1.已知数组int[] arr = {1,54,3,87,108,77,56,35,20};(1...
javaio流电子书整理面试必考io流帮助你入职阿里腾讯
03-12
"Java IO流是Java编程中用于处理输入输出操作的重要概念，涉及数据的持久化、存储介质和各种应用场景。本电子书主要讲解了IO流的基础知识，包括流的概念、分类、IO流体系，以及InputStream和OutputStream的使用。书...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值