深入探讨Java IO流

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量822 收藏 27
点赞数 28
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fudaihb/article/details/139480224
版权

目录

  1. Java IO 概述
  2. 流的基本概念
  3. 流的分类
  4. InputStream 和 OutputStream
  5. Reader 和 Writer
  6. 文件操作
  7. 缓冲流
  8. 对象流
  9. 序列化和反序列化
  10. 文件压缩与解压缩
  11. 常见问题与解决方法
  12. 总结

1. Java IO 概述

Java IO 流是Java平台提供的一个重要API，用于处理文件系统、网络通信等相关的输入输出操作。它抽象了数据传输操作的细节，为开发者提供了一系列便捷的方法。一旦学会使用Java IO流，开发者可以轻松处理字符、字节流，从而读写文件、网络传输数据等。

2. 流的基本概念

在Java中，流是字节顺序传输的抽象，它可以代表任何有实际数据传输的过程，比如读写文件、网络数据传输等。流抽象出来的一个好处就是，让数据传输变得一致和方便。

  • 输入流 (InputStream/Reader)：用于读取数据。
  • 输出流 (OutputStream/Writer)：用于写出数据。

3. 流的分类

按数据处理类型分类

字节流 (Byte Stream)
  • InputStream/OutputStream
  • 用于处理8-bit 字节数据。适合处理所有类型的I/O数据，比如图像、视频、音乐等。
字符流 (Character Stream)
  • Reader/Writer
  • 用于处理16-bit字符数据，适用于文本数据。

按数据流向分类

输入流 (Input Stream)
  • 读取数据字节，如FileInputStream, ByteArrayInputStream等。
输出流 (Output Stream)
  • 写入数据字节，如FileOutputStream, ByteArrayOutputStream等。

4. InputStream 和 OutputStream

这两个类是所有字节输入输出流的基类。

InputStream

下面是一些常用的子类：

  • FileInputStream: 从文件中读取字节信息。
  • ByteArrayInputStream: 从内存中的字节数组读取字节。
  • FilterInputStream: 用于修饰其他输入流，提供额外功能的流。
示例代码
FileInputStream fis = null;
try {
    fis = new FileInputStream("example.txt");
    int data;
    while ((data = fis.read()) != -1) {
        System.out.print((char) data);
    }
} catch (IOException ex) {
    ex.printStackTrace();
} finally {
    if (fis != null) {
        try {
            fis.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

OutputStream

下面是一些常用的子类：

  • FileOutputStream: 向文件写入字节数据。
  • ByteArrayOutputStream: 向内存中的字节数组写入字节数据。
  • FilterOutputStream: 用于修饰其他输出流，提供额外功能的流。
示例代码
FileOutputStream fos = null;
try {
    fos = new FileOutputStream("output.txt");
    String data = "Hello, Java IO!";
    fos.write(data.getBytes());
} catch (IOException ex) {
    ex.printStackTrace();
} finally {
    if (fos != null) {
        try {
            fos.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

5. Reader 和 Writer

这两个类是所有字符输入输出流的基类。

Reader

下面是一些常用的子类：

  • FileReader: 从文件中读取字符信息。
  • BufferedReader: 读取效率比较高，可以读取一行字符。
  • InputStreamReader: 将字节输入流转换为字符输入流。
示例代码
BufferedReader br = null;
try {
    br = new BufferedReader(new FileReader("example.txt"));
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException ex) {
    ex.printStackTrace();
} finally {
    if (br != null) {
        try {
            br.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

Writer

下面是一些常用的子类：

  • FileWriter: 向文件写入字符数据。
  • BufferedWriter: 提供高效的字符写入操作。
  • OutputStreamWriter: 将字节输出流转换为字符输出流。
示例代码
BufferedWriter bw = null;
try {
    bw = new BufferedWriter(new FileWriter("output.txt"));
    bw.write("Hello, Java IO!");
} catch (IOException ex) {
    ex.printStackTrace();
} finally {
    if (bw != null) {
        try {
            bw.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

6. 文件操作

文件读取

使用FileInputStream读取文件：

import java.io.FileInputStream;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("example.txt");
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

使用BufferedReader读取文件：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader("example.txt"));
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

文件写入

使用FileOutputStream写入文件：

import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("output.txt");
            String data = "Hello, Java IO!";
            fos.write(data.getBytes());
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

使用BufferedWriter写入文件：

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

public class Main {
    public static void main(String[] args) {
        BufferedWriter bw = null;
        try {
            bw = new BufferedWriter(new FileWriter("output.txt"));
            bw.write("Hello, Java IO!");
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

7. 缓冲流

缓冲流用于提高IO操作的效率。缓冲输入流和输出流分别是：

  • BufferedInputStream
  • BufferedOutputStream
  • BufferedReader
  • BufferedWriter
示例代码

BufferedInputStream

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        BufferedInputStream bis = null;
        try {
            bis = new BufferedInputStream(new FileInputStream("example.txt"));
            int data;
            while ((data = bis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

BufferedOutputStream

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        BufferedOutputStream bos = null;
        try {
            bos = new BufferedOutputStream(new FileOutputStream("output.txt"));
            String data = "Hello, Buffered IO!";
            bos.write(data.getBytes());
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

8. 对象流

Java提供了对象流来进行序列化和反序列化操作，通过ObjectInputStream和ObjectOutputStream实现。

示例代码

对象写入到文件

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Main {
    public static void main(String[] args) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"))) {
            oos.writeObject("Hello, Object IO!");
            oos.writeObject(new Person("John", 30));
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

class Person implements java.io.Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter and setter
}

从文件读取对象

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Main {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"))) {
            String message = (String) ois.readObject();
            Person person = (Person) ois.readObject();
            System.out.println("Message: " + message);
            System.out.println("Person: " + person.getName() + ", " + person.getAge());
        } catch (IOException | ClassNotFoundException ex) {
            ex.printStackTrace();
        }
    }
}

// Person class remains the same

9. 序列化和反序列化

序列化

序列化是将对象的状态转换为字节流的过程，通过实现Serializable接口来实现。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Main {
    public static void main(String[] args) {
        Person person = new Person("John", 30);
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.dat"))) {
            oos.writeObject(person);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

class Person implements java.io.Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter and setter
}

反序列化

反序列化是将字节流转换为对象的过程。

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Main {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.dat"))) {
            Person person = (Person) ois.readObject();
            System.out.println("Person: " + person.getName() + ", " + person.getAge());
        } catch (IOException | ClassNotFoundException ex) {
            ex.printStackTrace();
        }
    }
}

// Person class remains the same

10. 文件压缩与解压缩

Java 提供了java.util.zip包来实现文件的压缩和解压缩。

压缩

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class Main {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("compressed.zip");
             ZipOutputStream zos = new ZipOutputStream(fos)) {
            addToZipFile("example.txt", zos);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    private static void addToZipFile(String fileName, ZipOutputStream zos) throws IOException {
        try (FileInputStream fis = new FileInputStream(fileName)) {
            ZipEntry zipEntry = new ZipEntry(fileName);
            zos.putNextEntry(zipEntry);

            byte[] bytes = new byte[1024];
            int length;
            while ((length = fis.read(bytes)) >= 0) {
                zos.write(bytes, 0, length);
            }
            zos.closeEntry();
        }
    }
}

解压缩

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class Main {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("compressed.zip");
             ZipInputStream zis = new ZipInputStream(fis)) {
            ZipEntry zipEntry = zis.getNextEntry();
            while (zipEntry != null) {
                String fileName = zipEntry.getName();
                try (FileOutputStream fos = new FileOutputStream(fileName)) {
                    byte[] bytes = new byte[1024];
                    int length;
                    while ((length = zis.read(bytes)) >= 0) {
                        fos.write(bytes, 0, length);
                    }
                }
                zipEntry = zis.getNextEntry();
            }
            zis.closeEntry();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

11. 常见问题与解决方法

问题 1：文件找不到

确保文件路径正确且文件存在。

FileInputStream fis = new FileInputStream("path/to/file.txt");

问题 2：权限问题

确保有权限读写文件。

File file = new File("path/to/file.txt");
if (file.canRead() && file.canWrite()) {
    // Read or write
}

问题 3：流未关闭

使用try-with-resources增强型语法，确保流关闭。

try (FileInputStream fis = new FileInputStream("example.txt")) {
    // Read data
} catch (IOException ex) {
    ex.printStackTrace();
}

12. 总结

Java IO流是一个非常强大和灵活的机制，可以处理各种类型的数据输入和输出。掌握其基本使用和高级用法，是每个Java开发者都应该具备的技能。通过这篇博客，我们详细介绍了Java IO流的基本概念、分类、常见操作和一些高级用法，希望能帮助你更好地理解和使用Java IO流。如果你有任何疑问或建议，请在评论区留言。

一休哥助手
关注
  • 28
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java IO流 文件传输基础
09-02
在本文中，我们将深入探讨Java IO流在文件传输中的基础知识，特别是涉及文件编码的概念。 文件的编码是决定文本内容如何存储为字节序列的关键因素。不同的编码方式如UTF-8、GBK等，对字符的表示方式不同。在Java中...
Java基于IO流读取文件的方法
09-03
本文将深入探讨如何使用IO流来读取文件，并通过实例代码详细解释每一个步骤。 首先，要读取一个文件，我们需要获取文件的路径。在给定的示例中，路径是通过`TEST.class.getResource("/simu")`获取的，这通常用于...
深入理解Java IO流：掌握输入输出流的使用与应用
weixin_46608377的博客
12-31 1329
本文深入介绍了Java IO流的使用和应用场景，包括输入流、输出流、字节流、字符流以及高级IO流的使用。在实际开发中，根据需要选择合适的流类型来处理数据，如果处理的是文本数据，通常会使用字符流；，我们可以从网络套接字中读取字节流，适用于一些需要进行网络通信的场景，如客户端与服务器之间的数据传输。，我们可以方便地从字节数组中读取字节流，适用于一些需要处理字节数组数据的场景，如网络传输、文件读取等。，我们可以从文件中读取字节流，适用于一些需要处理文件数据的场景，如文件读取、文件复制等。最后，我们关闭了输入流。
深入理解Java IO流：字节流
zhouxiaozheng213的博客
04-21 784
插曲：取 Output 和 Input 单词首字母不就是 IO 吗？输入：内存 —— Output（将内存中的数据写到硬盘中）> 硬盘。输出：硬盘——Input（将硬盘中的数据读取到内存中）> 内存。如不理解，可以把自己比做内存，当我们吃饭喝水时是输入。
Java IO 深入解析
qq_44664868的博客
04-04 1502
Java IO（输入/输出）是Java编程语言中用于处理数据输入和输出的关键部分。这些操作可能涉及从文件、网络、键盘等读取数据，或向屏幕、文件、网络等写入数据。Java提供了丰富的IO类库，为开发者提供了处理各种IO场景的强大工具。本文将对Java IO进行详细解析，包括其主要分类、主要操作、装饰器模式、与Java NIO的比较等方面，并探讨其在实际应用中的使用。
深入理解Java IO流：字符流
zhouxiaozheng213的博客
04-21 518
如果按照字节读取,每次读取的字节没有构成一个汉字的字节数,就直接输出,汉字是显示不了的。
javaIO流知识大总结
07-28
在这个大总结中，我们将深入探讨Java IO流的基本概念、分类、常用类以及实践应用。 1. **基本概念** - **流（Stream）**：在Java中，流是一个抽象的概念，代表数据的有序序列。它可以是字节流或字符流，流向可以是...
09_IOAndProperties_javaIO流_get9va_
10-04
"get9va"可能是指一个特定的教程或课程系列的一部分，这里的"09_IOAndProperties"标题暗示我们将深入探讨Java IO流以及与属性相关的操作。 在Java中，IO流分为四类：字节流（Byte Streams）、字符流（Character ...
java之io流实例
09-28
本文将深入探讨Java的IO流实例应用，旨在帮助开发者更好地理解和掌握这一关键概念。 IO流在Java中分为两大类：字符流（Character Stream）和字节流（Byte Stream）。字符流处理的是Unicode编码的字符，而字节流则...
Java-Lambda
最新发布
lizhiwei21的博客
07-21 333
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 568
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1186
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1177
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 1079
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 741
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 654
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 515
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 1031
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
Java IO流深入解析：从File类到各种流的运用
本文档深入探讨了Java IO流的各个方面，包括其分类、原理和具体的应用。 首先，让我们了解File类。File类是Java IO体系中的一个重要组成部分，它不直接处理文件内容的读写，而是用于管理和操作文件和目录。File对象...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一休哥助手

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

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

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

打赏作者

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

抵扣说明：

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

余额充值