26--字符流与字节流

发布时间:2023年12月21日

1、IO流概述

1.1 什么是IO流

Java中I/O操作主要是指使用java.io包下的内容,进行输入、输出操作。输入也叫做读取数据,输出也叫做作写出数据。我们把这种数据的传输,可以看做是一种数据的流动,按照流动的方向,以内存为基准,分为输入input 和输出output ,即流向内存是输入流,流出内存的输出流。

1.2 Java IO原理

Java程序中,对于数据的输入/输出操作以“流(stream)” 的方式进行,可以看做是一种数据的流动。

I/O流中的I/O是Input/Output的缩写, I/O技术是非常实用的技术,用于处理设备之间的数据传输。如读/写文件,网络通讯等。

输入input:读取外部数据(磁盘、光盘等存储设备的数据)到程序(内存)中。

输出output:将程序(内存)数据输出到磁盘、光盘等存储设备中。

1.3 IO的分类

java.io包下提供了各种“流”类和接口,用以获取不同种类的数据,并通过标准的方法输入或输出数据。

按数据的流向不同分为:输入流输出流

  • 输入流 :把数据从其他设备上读取到内存中的流。 以InputStream、Reader结尾
  • 输出流 :把数据从内存 中写出到其他设备上的流。以OutputStream、Writer结尾

按操作数据单位的不同分为:字节流(8bit)字符流(16bit)

  • 字节流 :以字节为单位,读写数据的流。以InputStream、OutputStream结尾
  • 字符流 :以字符为单位,读写数据的流。以Reader、Writer结尾

根据IO流的角色不同分为:节点流处理流

  • 节点流:直接从数据源或目的地读写数据

  • 处理流:不直接连接到数据源或目的地,而是“连接”在已存在的流(节点流或处理流)之上,通过对数据的处理为程序提供更为强大的读写功能。

小结:图解

1.4 流的API

Java的IO流共涉及40多个类,实际上非常规则,都是从如下4个抽象基类派生的。

(抽象基类)

输入流

输出流

字节流

InputStream

OutputStream

字符流

Reader

Writer

由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

常用的节点流:

文件流: FileInputStream、FileOutputStrean、FileReader、FileWriter

字节/字符数组流: ByteArrayInputStream、ByteArrayOutputStream、CharArrayReader、CharArrayWriter

????????对数组进行处理的节点流(对应的不再是文件,而是内存中的一个数组)。

常用处理流:

缓冲流:BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

????????作用:增加缓冲功能,避免频繁读写硬盘,进而提升读写效率。

转换流:InputStreamReader、OutputStreamReader

????????作用:实现字节流和字符流之间的转换。

对象流:ObjectInputStream、ObjectOutputStream

????????作用:提供直接读写Java对象功能

2、字符流 FileReader\FileWriter

2.1 Reader与Writer

Java提供一些字符流类,以字符为单位读写数据,专门用于处理文本文件。不能操作图片,视频等非文本文件。

常见的文本文件有如下的格式:.txt、.java、.c、.cpp、.py等

注意:.doc、.xls、.ppt这些都不是文本文件。

2.1.1 字符输入流:Reader

java.io.Reader抽象类是表示用于读取字符流的所有类的父类,可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

  • public int read(): 从输入流读取一个字符。 虽然读取了一个字符,但是会自动提升为int类型。返回该字符的Unicode编码值。如果已经到达流末尾了,则返回-1。
  • public int read(char[] cbuf): 从输入流中读取一些字符,并将它们存储到字符数组 cbuf中 。每次最多读取cbuf.length个字符。返回实际读取的字符个数。如果已经到达流末尾,没有数据可读,则返回-1。
  • public int read(char[] cbuf,int off,int len):从输入流中读取一些字符,并将它们存储到字符数组 cbuf中,从cbuf[off]开始的位置存储。每次最多读取len个字符。返回实际读取的字符个数。如果已经到达流末尾,没有数据可读,则返回-1。
  • public void close() :关闭此流并释放与此流相关联的任何系统资源。

注意:当完成流的操作时,必须调用close()方法,释放系统资源,否则会造成内存泄漏。

2.1.2 字符输出流:Writer

java.io.Writer抽象类是表示用于写出字符流的所有类的超类,将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

  • public void write(int c) :写出单个字符。
  • public void write(char[] cbuf):写出字符数组。
  • public void write(char[] cbuf, int off, int len):写出字符数组的某一部分。off:数组的开始索引;len:写出的字符个数。
  • public void write(String str):写出字符串。
  • public void write(String str, int off, int len) :写出字符串的某一部分。off:字符串的开始索引;len:写出的字符个数。
  • public void flush():刷新该流的缓冲。
  • public void close() :关闭此流。

注意:当完成流的操作时,必须调用close()方法,释放系统资源,否则会造成内存泄漏。

2.2 FileReader 与 FileWriter

2.2.1 FileReader

java.io.FileReader类用于读取字符文件,构造时使用系统默认的字符编码和默认字节缓冲区。

  • FileReader(File file): 创建一个新的 FileReader ,给定要读取的File对象。
  • FileReader(String fileName): 创建一个新的 FileReader ,给定要读取的文件的名称。

举例:读取hello.txt文件中的字符数据,并显示在控制台上

package com.suyv.test01;

import org.junit.Test;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-19 20:13
*@Description: 读取hello.txt文件中的字符数据,并显示在控制台上
*/
public class FileReader01 {

    //1. 创建File类的对象,对应着物理磁盘上的某个文件
    //2. 创建FileReader流对象,将File类的对象作为参数传递到FileReader的构造器中
    //3. 通过相关流的方法,读取文件中的数据
    //4. 关闭相关的流资源,避免出现内存泄漏


    @Test
    public void Test01() throws IOException {
        //1. 创建File类的对象,对应着物理磁盘上的某个文件
        File file = new File("file\\hello.txt");
        //2. 创建FileReader流对象,将File类的对象作为参数传递到FileReader的构造器中
        FileReader fr = new FileReader(file);
        //3. 通过相关流的方法,读取文件中的数据
        // int data = fr.read(); //每调用一次读取一个字符
        // while (data != -1) {
        //     System.out.print((char) data);
        //     data = fr.read();
        // }
        int data;
        while ((data = fr.read()) != -1) {
            System.out.print((char) data);
        }
        //4. 关闭相关的流资源,避免出现内存泄漏
        fr.close();
    }

    /*
     * 需求:读取hello.txt中的内容,显示在控制台上。
     * 使用try-catch-finally的方式处理异常。确保流一定可以关闭,避免内存泄漏
     * */
    @Test
    public void Test02() {
        FileReader fr = null;
        try {
            //1.创建File类的对象,对应着hello.txt文件
            File file = new File("file\\hello.txt");

            //2.创建输入型的字符流,用于读取数据
            fr = new FileReader(file);

            //3.读取数据,并显示在控制台上
            int data;
            while ((data = fr.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4. 流资源的关闭操作(必须要关闭,否则会内存泄漏)
            try {
                if (fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void test3() throws IOException {
        //1.创建File类的对象,对应着hello.txt文件
        File file = new File("file\\hello.txt");
        //2.创建输入型的字符流,用于读取数据
        FileReader fr = new FileReader(file);

        //3.读取数据,并显示在控制台上
        char[] cbuffer = new char[5];
        int len;
        while ((len = fr.read(cbuffer)) != -1) {
            //遍历数组
            for (int i = 0; i < len; i++) {
                System.out.print(cbuffer[i]);
            }
        }
        //4. 流资源的关闭操作(必须要关闭,否则会内存泄漏)
        fr.close();
    }


}

2.2.2 FileWriter

java.io.FileWriter类用于写出字符到文件,构造时使用系统默认的字符编码和默认字节缓冲区。

  • FileWriter(File file): 创建一个新的 FileWriter,给定要读取的File对象。
  • FileWriter(String fileName): 创建一个新的 FileWriter,给定要读取的文件的名称。
  • FileWriter(File file,boolean append): 创建一个新的 FileWriter,指明是否在现有文件末尾追加内容。

举例:将内存中的数据写出到指定的文件中

package com.suyv.test01;

import org.junit.Test;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-20 13:54
 * @Description: FileWriter的使用--需求:将内存中的数据写出到指定的文件中
 */
public class FileWriter01 {

    //1. 创建File类的对象,对应着物理磁盘上的某个文件
    //2. 创建FileWriter流对象,将File类的对象作为参数传递到FileWriter的构造器中
    //3. 通过相关流的方法,读取文件中的数据
    //4. 关闭相关的流资源,避免出现内存泄漏

    @Test
    public void Test01() throws IOException {

        //1. 创建File类的对象,对应着物理磁盘上的某个文件
        File file = new File("file\\info.txt");

        //2. 创建FileWriter流对象,将File类的对象作为参数传递到FileWriter的构造器中
        FileWriter fw = new FileWriter(file);
        //3. 通过相关流的方法,读取文件中的数据
        fw.write("HelloWorld\n");
        fw.write("中国");
        System.out.println("写入成功");
        //4. 关闭相关的流资源,避免出现内存泄漏
        fw.close();

    }

}

2.2.3 复制文件

package com.suyv.test01;

import org.junit.Test;

import java.io.*;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-20 14:23
 * @Description: 复制一份hello.txt文件,命名为hello_copy.txt
 */
public class FileReaderWriter {
    
    @Test
    public void Test01() throws IOException {
        //1. 创建File类的对象,对应着物理磁盘上的某个文件
        File file1 = new File("file\\hello.txt");
        File file2 = new File("file\\hello_copy.txt");

        //2. 创建FileWriter流和FileReader流对象,将File类的对象作为参数传递到FileWriter的构造器中
        FileReader fr = new FileReader(file1);
        FileWriter fw = new FileWriter(file2);

        //3. 通过相关流的方法,读取文件中的数据
        int len;        // 记录每次读入到cbuffer中的字符的个数
        char[] cbuffer = new char[5];
        while ((len = fr.read(cbuffer)) != -1){
            fw.write(cbuffer,0,len);
        }

        //4. 关闭相关的流资源,避免出现内存泄漏
        fw.close();
        fr.close();

    }
}

2.2.4 小结

① 因为出现流资源的调用,为了避免内存泄漏,需要使用try-catch-finally处理异常

② 对于输入流来说,File类的对象必须在物理磁盘上存在,否则执行就会报FileNotFoundException。如果传入的是一个目录,则会报IOException异常。

对于输出流来说,File类的对象是可以不存在的。

如果File类的对象不存在,则可以在输出的过程中,自动创建File类的对象

如果File类的对象存在,

????????如果调用FileWriter(File file)或FileWriter(File file,false),输出时会新建File文件覆盖已有的文件

????????如果调用FileWriter(File file,true)构造器,则在现有的文件末尾追加写出内容。

2.3 关于flush(刷新)

因为内置缓冲区的原因,如果FileWriter不关闭输出流,无法写出字符到文件中。但是关闭的流对象,是无法继续写出数据的。如果我们既想写出数据,又想继续使用流,就需要flush() 方法了。

  • flush() :刷新缓冲区,流对象可以继续使用。
  • close():先刷新缓冲区,然后通知系统释放资源。流对象不可以再被使用了。

注意:即便是flush()方法写出了数据,操作的最后还是要调用close方法,释放系统资源。

举例:

package com.suyv.test01;

import org.junit.Test;

import java.io.FileWriter;
import java.io.IOException;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-20 14:36
 * @Description: flush的使用
 */
public class FileReaderFlush {

    @Test
    public void Test01() throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("file\\fw.txt");
        // 写出数据,通过flush
        fw.write('刷'); // 写出第1个字符
        fw.flush();
        fw.write('新'); // 继续写出第2个字符,写出成功
        fw.flush();

        // 写出数据,通过close
        fw.write('关'); // 写出第1个字符
        fw.close();
        fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
        fw.close();
    }
}

3、字节流 FileInputStream\FileOutputStream

如果我们读取或写出的数据是非文本文件,则Reader、Writer就无能为力了,必须使用字节流。

3.1 InputStream和OutputStream

3.1.1 字节输入流:InputStream

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

  • public int read(): 从输入流读取一个字节。返回读取的字节值。虽然读取了一个字节,但是会自动提升为int类型。如果已经到达流末尾,没有数据可读,则返回-1。
  • public int read(byte[] b): 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。每次最多读取b.length个字节。返回实际读取的字节个数。如果已经到达流末尾,没有数据可读,则返回-1。
  • public int read(byte[] b,int off,int len):从输入流中读取一些字节数,并将它们存储到字节数组 b中,从b[off]开始存储,每次最多读取len个字节 。返回实际读取的字节个数。如果已经到达流末尾,没有数据可读,则返回-1。
  • public void close() :关闭此输入流并释放与此流相关联的任何系统资源。

说明:close()方法,当完成流的操作时,必须调用此方法,释放系统资源。

3.1.2 字节输出流:OutputStream

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

  • public void write(int b) :将指定的字节输出流。虽然参数为int类型四个字节,但是只会保留一个字节的信息写出。
  • public void write(byte[] b):将 b.length字节从指定的字节数组写入此输出流。
  • public void write(byte[] b, int off, int len) :从指定的字节数组写入 len字节,从偏移量 off开始输出到此输出流。
  • public void flush() :刷新此输出流并强制任何缓冲的输出字节被写出。
  • public void close() :关闭此输出流并释放与此流相关联的任何系统资源。

说明:close()方法,当完成流的操作时,必须调用此方法,释放系统资源。

3.2 FileInputStream 与 FileOutputStream

3.2.1 FileInputStream

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

  • FileInputStream(File file): 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。
  • FileInputStream(String name): 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。

读取操作:

package com.suyv.test02;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-20 15:51
 * @Description: FileInputStream--字节输入流的使用
 */
public class FileInputStream01 {

    // 单个接收--无汉字
    @Test
    public void Test01() throws IOException {
        //1. 创建File类的对象,对应着物理磁盘上的某个文件
        File file = new File("file\\hello.txt");

        //2. 创建FileInputStream流对象
        FileInputStream fis = new FileInputStream(file);

        //3. 通过相关流的方法,读取文件中的数据
        int i;
        while ((i = fis.read()) != -1){
            System.out.print((char) i);     // helloworld111
        }

        //4. 关闭相关的流资源,避免出现内存泄漏
        fis.close();
    }

    // 单个接收--有汉字utf8
    @Test
    public void Test02() throws IOException {
        //1. 创建File类的对象,对应着物理磁盘上的某个文件
        File file = new File("file\\hello1.txt");

        //2. 创建FileInputStream流对象
        FileInputStream fis = new FileInputStream(file);

        //3. 通过相关流的方法,读取文件中的数据
        int i;
        while ((i = fis.read()) != -1){
            // 出现乱码,汉字在gbk中占2个字节,在utf8中占三个字节
            System.out.print((char) i);     // helloworld111??-??
        }

        //4. 关闭相关的流资源,避免出现内存泄漏
        fis.close();
    }

    // 使用byte数组接收
    @Test
    public void Test03() throws IOException {
        // 1.   2. 创建fileInputStream对象
        FileInputStream fis = new FileInputStream("file\\hello.txt");

        // 3. 读取数据
        byte[] buffer = new byte[5];
        int len;
        while ((len = fis.read(buffer)) != -1){
            String str = new String(buffer,0,len);
            System.out.print(str + "\t");       // hello	world	111

            // 错误写法
            // String str = new String(buffer);
            // System.out.print(str + "\t");       // hello	world	111ld
        }

        // 4. 关闭资源
        fis.close();
    }

    // skip(long n) 跳过几个字节
    @Test
    public void Test04() throws IOException {
        // 1.   2. 创建fileInputStream对象
        FileInputStream fis = new FileInputStream("file\\hello.txt");

        // 3. 读取数据
        fis.skip(4);
        System.out.println((char) fis.read());      // o

        // 4. 关闭资源
        fis.close();
    }
}

3.2.2 FileOutputStream

java.io.FileOutputStream类是文件输出流,用于将数据写出到文件。

  • public FileOutputStream(File file):创建文件输出流,写出由指定的 File对象表示的文件。
  • public FileOutputStream(String name): 创建文件输出流,指定的名称为写出文件。
  • public FileOutputStream(File file, boolean append): 创建文件输出流,指明是否在现有文件末尾追加内容。

举例:

package com.suyv.test02;

import org.junit.Test;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-20 16:14
 * @Description: FileOutputStream
 */
public class FileOutputStream01 {

    @Test
    public void Test01() throws IOException {
        // 1.   2. 创建FileOutputStream流对象
        FileOutputStream fos = new FileOutputStream("file\\fos.txt");

        // 3. 执行操作
        fos.write(97);
        fos.write(98);
        fos.write(99);
        System.out.println("写入成功");
        /*当前fos.txt内容为:abc*/

        // 4. 关闭资源
        fos.close();
    }

    @Test
    public void Test02() throws IOException {
        // 1.   2. 创建FileOutputStream流对象
        // 默认为不追加
        FileOutputStream fos = new FileOutputStream("file\\fos.txt");

        // 3. 执行操作
        // 字符串转换为字节数组
        byte[] b = "abcde".getBytes();
        // 写出从索引2开始,2个字节。索引2是c,两个字节,也就是cd。
        fos.write(b,2,2);
        /*当前fos.txt内容为:cd*/

        // 4. 关闭资源
        fos.close();
    }

    @Test
    public void Test03() throws IOException {
        // 1.   2. 创建FileOutputStream流对象
        // 添加第二个参数为true时,为文件追加内容
        FileOutputStream fos = new FileOutputStream("file\\fos.txt",true);

        // 3. 执行操作
        // 字符串转换为字节数组
        byte[] b = "abcde".getBytes();
        fos.write(b);
        /*当前fos.txt内容为:cdabcde*/

        // 4. 关闭资源
        fos.close();
    }


    // 接收控制台输入的内容
    @Test
    public void Test04() throws IOException {
        Scanner scan = new Scanner(System.in);

        // 创建流对象
        FileOutputStream fos = new FileOutputStream("file\\content.txt");

        // 操作流
        String str = scan.nextLine();
        fos.write(str.getBytes());

        /*文件内容为:中国*/

        // 关闭资源
        fos.close();
    }


    // 接收控制台输入的内容
    @Test
    public void Test05() throws IOException {
        Scanner scan = new Scanner(System.in);

        // 创建流对象
        FileOutputStream fos = new FileOutputStream("file\\content.txt");

        while (true) {
            // 操作流
            String str = scan.nextLine();

            // 循环退出条件
            if (str.equals("-1")){
                break;
            }

            fos.write(str.getBytes());
            fos.write('\n');
        }

        // 关闭资源
        fos.close();
    }
}

3.3 练习

3.3.1 复制图片

package com.suyv.test02;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;


/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-20 14:45
 * @Description: 复制图片
 */
public class FileInputOutputStream {

    //1. 创建File类的对象,对应着物理磁盘上的某个文件
    //2. 创建FileReader流对象,将File类的对象作为参数传递到FileReader的构造器中
    //3. 通过相关流的方法,读取文件中的数据
    //4. 关闭相关的流资源,避免出现内存泄漏

    // 复制一份03.png文件,命名为03_copy.png
    @Test
    public void Test01() throws IOException {
        //1. 创建File类的对象,对应着物理磁盘上的某个文件
        File file1 = new File("file\\03.png");
        File file2 = new File("file\\03_copy.png");

        //2. 创建FileInputStream和FileOutputStream流对象
        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        //3. 通过相关流的方法,读取文件中的数据
        byte[] buffer = new byte[1024]; //1kb
        int len;//记录每次读入到buffer中字节的个数
        while ((len = fis.read(buffer)) != -1) {
            fos.write(buffer, 0, len);
        }
        System.out.println("复制成功");

        //4. 关闭相关的流资源,避免出现内存泄漏
        fos.close();
        fis.close();

    }

}

3.3.2 实现图片加密操作

package com.suyv.test02;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-20 16:50
 * @Description: 图片的加密与加密
 */
public class FileInputOutputStream02 {

    // 图片的加密操作
    @Test
    public void Test01() throws IOException {

        //1. 创建File类的对象
        File file1 = new File("file\\girl.jpeg");
        File file2 = new File("file\\girl_secret.jpeg");

        //2. 创建FileInputStream流对象和FileOutputStream流对象
        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        //3. 通过相关流的方法,读取文件中的数据
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1){
            for (int i = 0; i < len; i++) {
                buffer[i] = (byte) (buffer[i] ^ 5);
            }
            fos.write(buffer,0, len);
        }
        System.out.println("加密成功");

        //4. 关闭相关的流资源,避免出现内存泄漏
        fos.close();
        fis.close();

    }


    // 图片的解密操作
    @Test
    public void Test02() throws IOException {
        //1. 创建File类的对象
        File file1 = new File("file\\girl_secret.jpeg");
        File file2 = new File("file\\girl_unsecret.jpeg");

        //2. 创建FileInputStream流对象和FileOutputStream流对象
        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        //3. 通过相关流的方法,读取文件中的数据
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1){
            for (int i = 0; i < len; i++) {
                buffer[i] = (byte) (buffer[i] ^ 5);
            }
            fos.write(buffer,0, len);
        }
        System.out.println("解密成功");

        //4. 关闭相关的流资源,避免出现内存泄漏
        fos.close();
        fis.close();
    }
}
文章来源:https://blog.csdn.net/weixin_46612641/article/details/135138139
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。