java-输入输出流

最新推荐文章于 2023-08-22 08:00:00 发布
最新推荐文章于 2023-08-22 08:00:00 发布
阅读量193 收藏
点赞数
分类专栏： 后端 文章标签： java stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37146193/article/details/114367202
版权

输入就是将数据从各种输入设备（包括文件、键盘等）中读取到内存中，输出则正好相反，是将数据写入到各种输出设备（比如文件、显示器、磁盘等）。

数据流是 Java 进行 I/O 操作的对象，它按照不同的标准可以分为不同的类别。

  • 按照流的方向主要分为输入流和输出流两大类。
  • 数据流按照数据单位的不同分为字节流和字符流。
  • 按照功能可以划分为节点流和处理流。

输入流

Java 流相关的类都封装在 java.io 包中，而且每个数据流都是一个对象。所有输入流类都是 InputStream 抽象类（字节输入流）和 Reader 抽象类（字符输入流）的子类。其中 InputStream 类是字节输入流的抽象类，是所有字节输入流的父类
在这里插入图片描述

名称作用
int read()从输入流读入一个 8 字节的数据，将它转换成一个 0~ 255 的整数，返回一个整数，如果遇到输入流的结尾返回 -1
int read(byte[] b)从输入流读取若干字节的数据保存到参数 b 指定的字节数组中，返回的字节数表示读取的字节数，如果遇到输入流的结尾返回 -1
int read(byte[] b,int off,int len)从输入流读取若干字节的数据保存到参数 b 指定的字节数组中，其中 off 是指在数组中开始保存数据位置的起始下标，len 是指读取字节的位数。返回的是实际读取的字节数，如果遇到输入流的结尾则返回 -1
void close()关闭数据流，当完成对数据流的操作之后需要关闭数据流
int available()返回可以从数据源读取的数据流的位数。
skip(long n)从输入流跳过参数 n 指定的字节数目
boolean markSupported()判断输入流是否可以重复读取，如果可以就返回 true
void mark(int readLimit)如果输入流可以被重复读取，从流的当前位置开始设置标记，readLimit 指定可以设置标记的字节数
void reset()使输入流重新定位到刚才被标记的位置，这样可以重新读取标记过的数据

输出流

在 Java 中所有输出流类都是 OutputStream 抽象类（字节输出流）和 Writer 抽象类（字符输出流）的子类。其中 OutputStream 类是字节输出流的抽象类，是所有字节输出流的父类
在这里插入图片描述

名称作用
int write(b)将指定字节的数据写入到输出流
int write (byte[] b)将指定字节数组的内容写入输出流
int write (byte[] b,int off,int len)将指定字节数组从 off 位置开始的 len 字节的内容写入输出流
close()关闭数据流，当完成对数据流的操作之后需要关闭数据流
flush()刷新输出流，强行将缓冲区的内容写入输出流

Java系统流

每个 Java 程序运行时都带有一个系统流，系统流对应的类为 java.lang.System。Sytem 类封装了 Java 程序运行时的 3 个系统流，分别通过 in、out 和 err 变量来引用。这 3 个系统流如下所示：

  • System.in：标准输入流，默认设备是键盘。
  • System.out：标准输出流，默认设备是控制台。
  • System.err：标准错误流，默认设备是控制台。

System.in 是 InputStream 类的一个对象,System.out 和 System.error 是 PrintStream 类的对象.

public class Test01 {
    public static void main(String[] args) {
        byte[] byteData = new byte[100]; // 声明一个字节数组
        System.out.println("请输入英文：");
        try {
            System.in.read(byteData);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("您输入的内容如下：");
        for (int i = 0; i < byteData.length; i++) {
            System.out.print((char) byteData[i]);
        }
    }
}

java File类

File 类是 java.io 包中唯一代表磁盘文件本身的对象，也就是说，如果希望在程序中操作文件和目录，则都可以通过 File 类来完成。File 类定义了一些方法来操作文件，如新建、删除、重命名文件和目录等。

File 类不能访问文件内容本身，如果需要访问文件内容本身，则需要使用输入/输出流。

File 类提供了如下三种形式构造方法。

  • File(String path)：如果 path 是实际存在的路径，则该 File 对象表示的是目录；如果 path 是文件名，则该 File 对象表示的是文件。
  • File(String path, String name)：path 是路径名，name 是文件名。
  • File(File dir, String name)：dir 是路径对象，name 是文件名。
方法名称说明
boolean canRead()测试应用程序是否能从指定的文件中进行读取
boolean canWrite()测试应用程序是否能写当前文件
boolean delete()删除当前对象指定的文件
boolean exists()测试当前 File 是否存在
String getAbsolutePath()返回由该对象表示的文件的绝对路径名
String getName()返回表示当前对象的文件名或路径名（如果是路径，则返回最后一级子路径名）
String getParent()返回当前 File 对象所对应目录（最后一级子目录）的父目录名
boolean isAbsolute()测试当前 File 对象表示的文件是否为一个绝对路径名。该方法消除了不同平台的差异，可以直接判断 file 对象是否为绝对路径。在 UNIX/Linux/BSD 等系统上，如果路径名开头是一条斜线/，则表明该 File 对象对应一个绝对路径；在 Windows 等系统上，如果路径开头是盘符，则说明它是一个绝对路径。
boolean isDirectory()测试当前 File 对象表示的文件是否为一个路径
boolean isFile()测试当前 File 对象表示的文件是否为一个“普通”文件
long lastModified()返回当前 File 对象表示的文件最后修改的时间
long length()返回当前 File 对象表示的文件长度
String[] list()返回当前 File 对象指定的路径文件列表
String[] list(FilenameFilter)返回当前 File 对象指定的目录中满足指定过滤器的文件列表
boolean mkdir()创建一个目录，它的路径名由当前 File 对象指定
boolean mkdirs()创建一个目录，它的路径名由当前 File 对象指定
boolean renameTo(File)将当前 File 对象指定的文件更名为给定参数 File 指定的路径名

File 类中有以下两个常用常量：

  • public static final String pathSeparator：指的是分隔连续多个路径字符串的分隔符，Windows 下指;。例如 java -cp test.jar;abc.jar HelloWorld。
  • public static final String separator：用来分隔同一个路径字符串中的目录的，Windows 下指/。例如 C:/Program Files/Common Files。

获取文件属性

public class Test02 {
    public static void main(String[] args) {
        String path = "C:/windows/"; // 指定文件所在的目录
        File f = new File(path, "notepad.exe"); // 建立File变量,并设定由f变量引用
        System.out.println("C:\\windows\\notepad.exe文件信息如下：");
        System.out.println("============================================");
        System.out.println("文件长度：" + f.length() + "字节");
        System.out.println("文件或者目录：" + (f.isFile() ? "是文件" : "不是文件"));
        System.out.println("文件或者目录：" + (f.isDirectory() ? "是目录" : "不是目录"));
        System.out.println("是否可读：" + (f.canRead() ? "可读取" : "不可读取"));
        System.out.println("是否可写：" + (f.canWrite() ? "可写入" : "不可写入"));
        System.out.println("是否隐藏：" + (f.isHidden() ? "是隐藏文件" : "不是隐藏文件"));
        System.out.println("最后修改日期：" + new Date(f.lastModified()));
        System.out.println("文件名称：" + f.getName());
        System.out.println("文件路径：" + f.getPath());
        System.out.println("绝对路径：" + f.getAbsolutePath());
    }
}

创建和删除文件

public static void main(String[] args) throws IOException {
    String path = "C:" + File.separator + "test.txt"; // 拼凑出可以适应操作系统的路径
    File f = new File(path);
    if (f.exists()) // 判断文件是否存在
    {
        f.delete(); // 存在则先删除
    }
    f.createNewFile(); // 再创建
}

创建和删除目录

public class Test04 {
    public static void main(String[] args) {
        String path = "C:/config/"; // 指定目录位置
        File f = new File(path); // 创建File对象
        if (f.exists()) {
            f.delete();
        }
        f.mkdir(); // 创建目录
    }
}

遍历目录

public class Test05 {
    public static void main(String[] args) {
        File f = new File("C:/"); // 建立File变量,并设定由f变量变数引用
        System.out.println("文件名称\t\t文件类型\t\t文件大小");
        System.out.println("===================================================");
        String fileList[] = f.list(); // 调用不带参数的list()方法
        for (int i = 0; i < fileList.length; i++) { // 遍历返回的字符数组
            System.out.print(fileList[i] + "\t\t");
            System.out.print((new File("C:/", fileList[i])).isFile() ? "文件" + "\t\t" : "文件夹" + "\t\t");
            System.out.println((new File("C:/", fileList[i])).length() + "字节");
        }
    }
}

文件List过滤器

public class ImageFilter implements FilenameFilter {
    // 实现 FilenameFilter 接口
    @Override
    public boolean accept(File dir, String name) {
        // 指定允许的文件类型
        return name.endsWith(".sys") || name.endsWith(".txt") || name.endsWith(".bak");
    }
}

String fileList[] = f.list(new ImageFilter());

字节流

如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点.

所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列.

  • 字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串；

  • 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以

字节输入流

InputStream 类及其子类的对象表示字节输入流，InputStream 类的常用子类如下。

  • ByteArrayInputStream 类：将字节数组转换为字节输入流，从中读取字节。
  • FileInputStream 类：从文件中读取数据。
  • PipedInputStream 类：连接到一个 PipedOutputStream（管道输出流）。
  • SequenceInputStream 类：将多个字节输入流串联成一个字节输入流。
  • ObjectInputStream 类：将对象反序列化。
方法名及返回值类型说明
int read()从输入流中读取一个 8 位的字节，并把它转换为 0~255 的整数，最后返回整数。 如果返回 -1，则表示已经到了输入流的末尾。为了提高 I/O 操作的效率，建议尽量 使用 read() 方法的另外两种形式
int read(byte[] b)从输入流中读取若干字节，并把它们保存到参数 b 指定的字节数组中。 该方法返回 读取的字节数。如果返回 -1，则表示已经到了输入流的末尾
int read(byte[] b, int off, int len)从输入流中读取若干字节，并把它们保存到参数 b 指定的字节数组中。其中，off 指 定在字节数组中开始保存数据的起始下标；len 指定读取的字节数。该方法返回实际 读取的字节数。如果返回 -1，则表示已经到了输入流的末尾
void close()关闭输入流。在读操作完成后，应该关闭输入流，系统将会释放与这个输入流相关 的资源。注意，InputStream 类本身的 close() 方法不执行任何操作，但是它的许多 子类重写了 close() 方法
int available()返回可以从输入流中读取的字节数
long skip(long n)从输入流中跳过参数 n 指定数目的字节。该方法返回跳过的字节数
void mark(int readLimit)在输入流的当前位置开始设置标记，参数 readLimit 则指定了最多被设置标记的字 节数
boolean markSupported()判断当前输入流是否允许设置标记，是则返回 true，否则返回 false
void reset()将输入流的指针返回到设置标记的起始处

字节输出流

OutputStream 类及其子类的对象表示一个字节输出流。OutputStream 类的常用子类如下。

  • ByteArrayOutputStream 类：向内存缓冲区的字节数组中写数据。
  • FileOutputStream 类：向文件中写数据。
  • PipedOutputStream 类：连接到一个 PipedlntputStream（管道输入流）。
  • ObjectOutputStream 类：将对象序列化。
方法名及返回值类型说明
void write(int b)向输出流写入一个字节。这里的参数是 int 类型，但是它允许使用表达式， 而不用强制转换成 byte 类型。为了提高 I/O 操作的效率，建议尽量使用 write() 方法的另外两种形式
void write(byte[] b)把参数 b 指定的字节数组中的所有字节写到输出流中
void write(byte[] b,int off,int len)把参数 b 指定的字节数组中的若干字节写到输出流中。其中，off 指定字节 数组中的起始下标，len 表示元素个数
void close()关闭输出流。写操作完成后，应该关闭输出流。系统将会释放与这个输出 流相关的资源。注意，OutputStream 类本身的 close() 方法不执行任何操 作，但是它的许多子类重写了 close() 方法
void flush()为了提高效率，在向输出流中写入数据时，数据一般会先保存到内存缓冲 区中，只有当缓冲区中的数据达到一定程度时，缓冲区中的数据才会被写 入输出流中。使用 flush() 方法则可以强制将缓冲区中的数据写入输出流， 并清空缓冲区

字节数组输入流

ByteArrayInputStream 类可以从内存的字节数组中读取数据，该类有如下两种构造方法重载形式。

  1. ByteArrayInputStream(byte[] buf)：创建一个字节数组输入流，字节数组类型的数据源由参数 buf 指定。
  2. ByteArrayInputStream(byte[] buf,int offse,int length)：创建一个字节数组输入流，其中，参数 buf 指定字节数组类型的数据源，offset 指定在数组中开始读取数据的起始下标位置，length 指定读取的元素个数。
public class test08 {
    public static void main(String[] args) {
        byte[] b = new byte[] { 1, -1, 25, -22, -5, 23 }; // 创建数组
        ByteArrayInputStream bais = new ByteArrayInputStream(b, 0, 6); // 创建字节数组输入流
        int i = bais.read(); // 从输入流中读取下一个字节，并转换成int型数据
        while (i != -1) { // 如果不返回-1，则表示没有到输入流的末尾
            System.out.println("原值=" + (byte) i + "\t\t\t转换为int类型=" + i);
            i = bais.read(); // 读取下一个
        }
    }
}

字节数组输出流

ByteArrayOutputStream 类可以向内存的字节数组中写入数据，该类的构造方法有如下两种重载形式。

  1. ByteArrayOutputStream()：创建一个字节数组输出流，输出流缓冲区的初始容量大小为 32 字节。
  2. ByteArrayOutputStream(int size)：创建一个字节数组输出流，输出流缓冲区的初始容量大小由参数 size 指定。

ByteArrayOutputStream 类中除了有前面介绍的字节输出流中的常用方法以外，还有如下两个方法。

  1. intsize()：返回缓冲区中的当前字节数。
  2. byte[] toByteArray()：以字节数组的形式返回输出流中的当前内容。
public class Test09 {
    public static void main(String[] args) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] b = new byte[] { 1, -1, 25, -22, -5, 23 }; // 创建数组
        baos.write(b, 0, 6); // 将字节数组b中的前4个字节元素写到输出流中
        System.out.println("数组中一共包含：" + baos.size() + "字节"); // 输出缓冲区中的字节数
        byte[] newByteArray = baos.toByteArray(); // 将输出流中的当前内容转换成字节数组
        System.out.println(Arrays.toString(newByteArray)); // 输出数组中的内容
    }
}

文件输入流

FileInputStream 是 Java 流中比较常用的一种，它表示从文件系统的某个文件中获取输入字节。通过使用 FileInputStream 可以访问文件中的一个字节、一批字节或整个文件。

在创建 FileInputStream 类的对象时，如果找不到指定的文件将拋出 FileNotFoundException 异常，该异常必须捕获或声明拋出。

FileInputStream 常用的构造方法主要有如下两种重载形式。

  1. FileInputStream(File file)：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
  2. FileInputStream(String name)：通过打开一个到实际文件的链接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

注意：FileInputStream 类重写了父类 InputStream 中的 read() 方法、skip() 方法、available() 方法和 close() 方法，不支持 mark() 方法和 reset() 方法。

try {
    // 以File对象作为参数创建FileInputStream对象
    FileInputStream fis1 = new FileInputStream(new File("F:/mxl.txt"));
    // 以字符串值作为参数创建FilelnputStream对象
    FileInputStream fis2 = new FileInputStream("F:/mxl.txt");
} catch(FileNotFoundException e) {
    System.out.println("指定的文件找不到!");
}

public class Test10 {
    public static void main(String[] args) {
        File f = new File("D:/myJava/HelloJava.java");
        FileInputStream fis = null;
        try {
            // 因为File没有读写的能力,所以需要有个InputStream
            fis = new FileInputStream(f);
            // 定义一个字节数组
            byte[] bytes = new byte[1024];
            int n = 0; // 得到实际读取到的字节数
            System.out.println("D:\\myJava\\HelloJava.java文件内容如下：");
            // 循环读取
            while ((n = fis.read(bytes)) != -1) {
                String s = new String(bytes, 0, n); // 将数组中从下标0到n的内容给s
                System.out.println(s);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

文件输出流

FileOutputStream 类继承自 OutputStream 类，重写和实现了父类中的所有方法。FileOutputStream 类的对象表示一个文件字节输出流，可以向流中写入一个字节或一批字节。在创建 FileOutputStream 类的对象时，如果指定的文件不存在，则创建一个新文件；如果文件已存在，则清除原文件的内容重新写入。

FileOutputStream 类的构造方法主要有如下 4 种重载形式。

  1. FileOutputStream(File file)：创建一个文件输出流，参数 file 指定目标文件。
  2. FileOutputStream(File file,boolean append)：创建一个文件输出流，参数 file 指定目标文件，append 指定是否将数据添加到目标文件的内容末尾，如果为 true，则在末尾添加；如果为 false，则覆盖原有内容；其默认值为 false。
  3. FileOutputStream(String name)：创建一个文件输出流，参数 name 指定目标文件的文件路径信息。
  4. FileOutputStream(String name,boolean append)：创建一个文件输出流，参数 name 和 append 的含义同上。

注意：使用构造方法 FileOutputStream(String name,boolean append) 创建一个文件输出流对象，它将数据附加在现有文件的末尾。该字符串 name 指明了原文件，如果只是为了附加数据而不是重写任何已有的数据，布尔类型参数 append 的值应为 true。

对文件输出流有如下四点说明：

  1. 在 FileOutputStream 类的构造方法中指定目标文件时，目标文件可以不存在。
  2. 目标文件的名称可以是任意的，例如 D:\abc、D:\abc.de 和 D:\abc.de.fg 等都可以，可以使用记事本等工具打开并浏览这些文件中的内容。
  3. 目标文件所在目录必须存在，否则会拋出 java.io.FileNotFoundException 异常。
  4. 目标文件的名称不能是已存在的目录。例如 D 盘下已存在 Java 文件夹，那么就不能使用 Java 作为文件名，即不能使用 D:\Java，否则抛出 java.io.FileNotFoundException 异常。
public class Test11 {
    public static void main(String[] args) {
        FileInputStream fis = null; // 声明FileInputStream对象fis
        FileOutputStream fos = null; // 声明FileOutputStream对象fos
        try {
            File srcFile = new File("D:/myJava/HelloJava.java");
            fis = new FileInputStream(srcFile); // 实例化FileInputStream对象
            File targetFile = new File("D:/myJava/HelloJava.txt"); // 创建目标文件对象，该文件不存在
            fos = new FileOutputStream(targetFile); // 实例化FileOutputStream对象
            byte[] bytes = new byte[1024]; // 每次读取1024字节
            int i = fis.read(bytes);
            while (i != -1) {
                fos.write(bytes, 0, i); // 向D:\HelloJava.txt文件中写入内容
                i = fis.read(bytes);
            }
            System.out.println("写入结束！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close(); // 关闭FileInputStream对象
                fos.close(); // 关闭FileOutputStream对象
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符流

如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点.

所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列.

  • 字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串；

  • 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以

字符输入流

Reader 类是所有字符流输入类的父类，该类定义了许多方法，这些方法对所有子类都是有效的。

Reader 类的常用子类如下。

  • CharArrayReader 类：将字符数组转换为字符输入流，从中读取字符。
  • StringReader 类：将字符串转换为字符输入流，从中读取字符。
  • BufferedReader 类：为其他字符输入流提供读缓冲区。
  • PipedReader 类：连接到一个 PipedWriter。
  • InputStreamReader 类：将字节输入流转换为字符输入流，可以指定字符编码。

在 Reader 类中也包含 close()、mark()、skip() 和 reset() 等方法，这些方法可以参考 InputStream 类的方法。下面主要介绍 Reader 类中的 read() 方法。

方法名及返回值类型说明
int read()从输入流中读取一个字符，并把它转换为 0~65535 的整数。如果返回 -1， 则表示 已经到了输入流的末尾。为了提高 I/O 操作的效率，建议尽量使用下面两种 read() 方法
int read(char[] cbuf)从输入流中读取若干个字符，并把它们保存到参数 cbuf 指定的字符数组中。 该方 法返回读取的字符数，如果返回 -1，则表示已经到了输入流的末尾
int read(char[] cbuf,int off,int len)从输入流中读取若干个字符，并把它们保存到参数 cbuf 指定的字符数组中。其中， off 指定在字符数组中开始保存数据的起始下标，len 指定读取的字符数。该方法返 回实际读取的字符数，如果返回 -1，则表示已经到了输入流的末尾

字符输出流

Writer 类是所有字符输出流的父类

Writer 类的常用子类如下。

  • CharArrayWriter 类：向内存缓冲区的字符数组写数据。
  • StringWriter 类：向内存缓冲区的字符串（StringBuffer）写数据。
  • BufferedWriter 类：为其他字符输出流提供写缓冲区。
  • PipedWriter 类：连接到一个 PipedReader。
  • OutputStreamReader 类：将字节输出流转换为字符输出流，可以指定字符编码。

与 OutputStream 类相同，Writer 类也包含 close()、flush() 等方法，下面主要介绍 Writer 类中的 write() 方法和 append() 方法

方法名及返回值类型说明
void write(int c)向输出流中写入一个字符
void write(char[] cbuf)把参数 cbuf 指定的字符数组中的所有字符写到输出流中
void write(char[] cbuf,int off,int len)把参数 cbuf 指定的字符数组中的若干字符写到输出流中。其中，off 指定 字符数组中的起始下标，len 表示元素个数
void write(String str)向输出流中写入一个字符串
void write(String str, int off,int len)向输出流中写入一个字符串中的部分字符。其中，off 指定字符串中的起 始偏移量，len 表示字符个数
append(char c)将参数 c 指定的字符添加到输出流中
append(charSequence esq)将参数 esq 指定的字符序列添加到输出流中
append(charSequence esq,int start,int end)将参数 esq 指定的字符序列的子序列添加到输出流中。其中，start 指定 子序列的第一个字符的索引，end 指定子序列中最后一个字符后面的字符 的索引，也就是说子序列的内容包含 start 索引处的字符，但不包括 end 索引处的字符

字符文件输入流

  1. FileReader(File file)：在给定要读取数据的文件的情况下创建一个新的 FileReader 对象。其中，file 表示要从中读取数据的文件。
  2. FileReader(String fileName)：在给定从中读取数据的文件名的情况下创建一个新 FileReader 对象。其中，fileName 表示要从中读取数据的文件的名称，表示的是一个文件的完整路径。

在用该类的构造方法创建 FileReader 读取对象时，默认的字符编码及字节缓冲区大小都是由系统设定的。要自己指定这些值，可以在 FilelnputStream 上构造一个 InputStreamReader。

public class Test12 {
    public static void main(String[] args) {
        FileReader fr = null;
        try {
            fr = new FileReader("D:/myJava/HelloJava.java"); // 创建FileReader对象
            int i = 0;
            System.out.println("D:\\myJava\\HelloJava.java文件内容如下：");
            while ((i = fr.read()) != -1) { // 循环读取
                System.out.print((char) i); // 将读取的内容强制转换为char类型
            }
        } catch (Exception e) {
            System.out.print(e);
        } finally {
            try {
                fr.close(); // 关闭对象
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符文件输出流

  1. FileWriter(File file)：在指定 File 对象的情况下构造一个 FileWriter 对象。其中，file 表示要写入数据的 File 对象。
  2. FileWriter(File file,boolean append)：在指定 File 对象的情况下构造一个 FileWriter 对象，如果 append 的值为 true，则将字节写入文件末尾，而不是写入文件开始处。
  3. FileWriter(String fileName)：在指定文件名的情况下构造一个 FileWriter 对象。其中，fileName 表示要写入字符的文件名，表示的是完整路径。
  4. FileWriter(String fileName,boolean append)：在指定文件名以及要写入文件的位置的情况下构造 FileWriter 对象。其中，append 是一个 boolean 值，如果为 true，则将数据写入文件末尾，而不是文件开始处。

在创建 FileWriter 对象时，默认字符编码和默认字节缓冲区大小都是由系统设定的。要自己指定这些值，可以在 FileOutputStream 上构造一个 OutputStreamWriter 对象。

FileWriter 类的创建不依赖于文件存在与否，如果关联文件不存在，则会自动生成一个新的文件。在创建文件之前，FileWriter 将在创建对象时打开它作为输出。如果试图打开一个只读文件，将引发一个 IOException 异常。

public class Test13 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        FileWriter fw = null;
        try {
            fw = new FileWriter("D:\\myJava\\book.txt"); // 创建FileWriter对象
            for (int i = 0; i < 4; i++) {
                System.out.println("请输入第" + (i + 1) + "个字符串：");
                String name = input.next(); // 读取输入的名称
                fw.write(name + "\r\n"); // 循环写入文件
            }
            System.out.println("录入完成！");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            try {
                fw.close(); // 关闭对象
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符缓冲区输入流

BufferedReader 类主要用于辅助其他字符输入流，它带有缓冲区，可以先将一批数据读到内存缓冲区。接下来的读操作就可以直接从缓冲区中获取数据，而不需要每次都从数据源读取数据并进行字符编码转换，这样就可以提高数据的读取效率。

BufferedReader 类的构造方法有如下两种重载形式。

  1. BufferedReader(Reader in)：创建一个 BufferedReader 来修饰参数 in 指定的字符输入流。
  2. BufferedReader(Reader in,int size)：创建一个 BufferedReader 来修饰参数 in 指定的字符输入流，参数 size 则用于指定缓冲区的大小，单位为字符。
public class Test13 {
    public static void main(String[] args) {
        FileReader fr = null;
        BufferedReader br = null;
        try {
            fr = new FileReader("D:\\myJava\\book.txt"); // 创建 FileReader 对象
            br = new BufferedReader(fr); // 创建 BufferedReader 对象
            System.out.println("D:\\myJava\\book.txt 文件中的内容如下：");
            String strLine = "";
            while ((strLine = br.readLine()) != null) { // 循环读取每行数据
                System.out.println(strLine);
            }
        } catch (FileNotFoundException e1) {
            e1.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fr.close(); // 关闭 FileReader 对象
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符缓冲区输出流

BufferedWriter 类主要用于辅助其他字符输出流，它同样带有缓冲区，可以先将一批数据写入缓冲区，当缓冲区满了以后，再将缓冲区的数据一次性写到字符输出流，其目的是为了提高数据的写效率。

BufferedWriter 类的构造方法有如下两种重载形式。

  1. BufferedWriter(Writer out)：创建一个 BufferedWriter 来修饰参数 out 指定的字符输出流。
  2. BufferedWriter(Writer out,int size)：创建一个 BufferedWriter 来修饰参数 out 指定的字符输出流，参数 size 则用于指定缓冲区的大小，单位为字符。

流转换

public static void main(String[] args) {
    try {
        FileInputStream fis = new FileInputStream("D://java.txt");
        InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
        int b = 0;
        while ((b = isr.read()) != -1) {
            System.out.print((char) b);    // 输出结果为“C语言中文网”
        }
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

Java字节流和字符流的区别

首先我们先大概总结一下前面学习的内容，可分为以下几点：

  1. 以 Stream 结尾都是字节流，Reader 和 Writer 结尾都是字符流。
  2. InputStream 是所有字节输入流的父类，OutputStream 是所有字节输出流的父类。
  3. Reader 是字符输入流的父类，Writer 是字符输出流的父类。
字节流：
  • 文件流：FileOutputStream 和 FileInputStream
  • 缓冲流：BufferedOutputStream 和 BufferedInputStream
  • 对象流：ObjectOutputStream 和 ObjectInputStream
字符流：
  • 转换流：InputStreamReader 和 OutputStreamWriter
  • 缓冲字符流：PrintWriter 和 BufferedReader
区别：
  1. 读写的时候字节流是按字节读写，字符流按字符读写。
  2. 字节流适合所有类型文件的数据传输，因为计算机字节(Byte)是电脑中表示信息含义的最小单位。字符流只能够处理纯文本数据，其他类型数据不行，但是字符流处理文本要比字节流处理文本要方便。
  3. 在读写文件需要对内容按行处理，比如比较特定字符，处理某一行数据的时候一般会选择字符流。
  4. 只是读写文件，和文件内容无关时，一般选择字节流。

对象序列化

序列化

ObjectOutputStream 类继承了 OutputStream 类，同时实现了 ObjectOutput 接口，提供将对象序列化并写入流中的功能

public ObjectOutputStream (OutputStream out)

程序通过以下两个步骤来序列化对象：

// 创建个 ObjectOutputStream 输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
// 将一个 Person 对象输出到输出流中
oos.writerObject(per);

public class WriteObject {
    public static void main(String[] args) throws Exception {
        // 创建一个 ObjectOutputStream 输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        Person per = new Person("C语言中文网", 7);
        // 将 Per对象写入输出流
        oos.writeObject(per);
    }
}

反序列化

ObjectInputStream 类继承了 InputStream 类，同时实现了 ObjectInput 接口，提供了将对象序列化并从流中读取出来的功能。

public ObjectInputStream(InputStream out)

反序列化的步骤如下所示：

// 创建一个ObjectInputStream输入流
ObjectInputStream ois = new ObjectInputStream (new FileInputStream ("object. txt"));
// 从输入流中读取一个Java对象，并将其强制类型转换为Person类
Person P = (Person)ois.readObject();

public class ReadObject {
    public static void main(String[] args) throws Exception {
        // 创建一个ObjectInputStream输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
        // 从输入流中读取一个 Java对象，并将其强制类型转换为Person类
        Person p = (Person) ois.readObject();
        System.out.println("名字为：" + p.getName() + "\n年龄为：" + p.getAge());
    }
}
正在加载数据...
关注
专栏目录
java--输入输出流及序列化与反序列化
小乌龟
06-22 2273
输入输出流 例如文件上传，文件下载； 图片上传，图片下载； 视频上传，视频下载； 我们称之为I/O流 按照方向分为输入输出流 输入输出流的标准是内存。从内存出来是输出流，进入内存是输入流 字节流：每次读写一个字节 字符流：每次读写一个字符 补充：一个字符到底是几个字节根据编码不同而不同 字符流比字节流读写速度快 但是是字符流只适用于字符的读写，而字节流比较通用 音频视频都可以转换为字节流 eclipse debug调试时F5进入 ，F6上一步 I：input 输入 O:output 输出 File类
初学者：java练习题———含答案------输入输出流（6）
basinle的博客
06-13 1963
import java.io.*; public class Keyboard { public static void main(String[] args) throws IOException { InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); FileOutputStream fos = new FileOutputS..
Java输入输出流详解
热门推荐
Java菜鸟
06-09 9万+
通过数据流、序列化和文件系统提供系统输入和输出。 Java把这些不同来源和目标的数据都统一抽象为数据流。Java语言的输入输出功能是十分强大而灵活的，美中不足的是看上去输入输出的代码并不是很简洁，因为你往往需要包装许多不同的对象。 在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流。 1.1、Java流
java回忆录—输入输出流详细讲解（入门经典）
minigeek的博客
08-07 2万+
今天我们开始进入学习 java 中比较让人头疼的事， 那就是 I/O 流、多线程、网络编程。这里对 I/O 流的一个详细讲解。希望对大家有点用吧。（不看后悔哦）一、什么是IOJava中I/O操作主要是指使用Java进行输入，输出操作。 Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源
JAVA中数据类型（变量和运算符）
char_m的博客
03-01 997
数据类型 什么是变量 变量指的是程序运行时可变的量. 相当于开辟一块内存空间来保存一些数据。 变量 1、整数类型 1.1 字节型变量 byte 变量名 = 初始值; 1. 字节类型表示的也是整数. 只占一个字节, 表示范围较小 ( -128 -> +127) 2. 字节类型和字符类型互不相干。 1.2 短整型变量 short 变量名 = 初始值; short 占用 2 个字节, 表示的...
Java中对于unsigned byte类型的转换处理
barret xiong的博客
11-24 3250
问题由来 在阅读google的开源项目zxing时，遇到以下代码： public final String toString() { byte[] row = new byte[width]; StringBuilder result = new StringBuilder(height * (width + 1)); for (int y = 0; y < heigh
【C++STL基础入门】深入浅出string类的比较(compare)、复制(copy)
m0_62599305的博客
08-22 1万+
本系列STL使用VS2022+C++20版本在C++标准库中，string类是一个功能强大的字符串处理类，提供了丰富的操作函数。本文将详细介绍string类的比较、复制、查找字串、返回字串、交换等常用操作。通过深入浅出的解析，让读者对这些操作有更清晰的理解和掌握。本文深入浅出地介绍了string类的比较、复制常用操作。通过对这些操作的解析和示例，读者可以更加清晰地理解和掌握这些功能。熟练使用string类的操作函数，将有助于提高字符串处理的效率和代码质量，更好地应对实际开发需求。
Java学习资料-输入输出流
06-15
Java 输入/输出流是Java程序进行数据传输的关键机制，它允许程序从源（如键盘、文件）接收数据或将数据发送到目的地（如显示器、文件）。Java中的I/O流分为四类：字节流（Byte Streams）和字符流（Character Streams...
实验9 Java输入输出流.doc
05-02
Java输入输出流是Java编程中一个非常重要的概念，主要用于数据的读取和写入操作，包括文本文件和二进制文件。在实验9中，主要目的是理解和掌握I/O流的分类，以及如何进行文本和二进制文件的读写。 I/O流在Java中被...
Java程序设计-Java-08-输入输出-PPT.ppt
最新发布
05-15
### Java程序设计之输入输出详解 #### 一、引言 在Java程序设计中，输入输出（I/O）是一项非常重要的技术。无论是简单的控制台应用还是复杂的企业级系统，都需要处理来自不同来源的数据输入和输出。Java语言通过其...
C++中的Compare()函数
qq_39921748的博客
09-18 5428
#include #include #include using std::cout; using std::endl; using std::cin; using std::string; int main(void){ string str1=“hi,test,hello”; string str2=“hi,test”; //字符串比较 if(str1.compare(str2)>...
【C++】string详解
桺柒郞的小小屋
03-05 1241
【C++】string详解 我们再使用再对字符串操作的时候，可以调用string中的函数实现一些功能，string的头文件是 #include<string> string类是一个模板类，位于名字空间std中，所以还需要 using namespace std; 字符串构造函数 string str; // 构造空的string类对象str string str(“abc...
strcompare（S1，S2）运算
m0_54021503的博客
10-17 1660
仅供参考 如果有疑问，可以联系我。 #include<stdio.h> #include<stdlib.h> typedef struct node { char data; struct node* link; }node; node* init() { return NULL; } node* creat(node* s) { char ch; node* p, * r; s = NULL; r = NULL; while ((ch = getchar()
Scala语言基础整合
修炼之路
11-05 2602
Scala目录Scala数据类型java中有的scala数据类型scala独有的数据类型 Scala数据类型 java中有的scala数据类型 Byte 8bit的有符号数字,范围在-128 – 127 Short 16 bit有符号数字,范围在-32768 – 32767 Int 32 bit有符号数字,范围-2147483648到2147483647 Long 64 bit有符号数字,范围-9...
数据结构（C语言版）--速成笔记【持续更新中。。】
XimpleZ的博客
10-27 3945
【数据结构（C语言版）】速成笔记 持续更新中。。。本篇笔记是小编根据自己老师教的内容所作，希望能帮到大家O^O
C++之string的compare用法
dey8091的博客
11-20 642
compare用于比较两个字符串是否相等。 用法： str1.compare(str2); 如果相等则输出为0，不等则输出为-1。 例子如下： 1 int main() { 2 string str1 = "abc"; 3 if (str1.compare("abc") == 0) { 4 cout << "...
JAVA String类型转int类型判断及验证
sdylag的专栏
02-27 1160
方法一:   while (true) {       Scanner r = new Scanner(System.in);       if (!r.hasNextInt()) {       //通过使用 nextInt() 方法,判断输入值是否是一个 int 值，是则返回 true             System.out.println("请输入一个整数！");         ...
JAVASE
一只蜗牛的旅途
04-25 784
输出输入语句、数据类型、基本运算、字符串、数组、分支结构、循环结构、方法、类、封装、继承、多态
java如何判断一个字符串能否转化为int
依木前行的博客
08-12 1万+
java如何判断一个字符串能否转化为int，用下面的这个方法，如果能返回true 否则返回false NumberUtils.isNumber(str)
Java编程：理解输入输出流-键盘输入示例
"Java实例——从键盘输入字符-java中的输入流与输出流" 在Java编程中，输入流（Input Stream）和输出流（Output Stream）是处理数据传输的基础。Java的`java.io`包提供了丰富的类来支持这些功能。本实例展示了如何...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值