Java知识点_IO操作那些事

最新推荐文章于 2024-04-28 10:20:58 发布
最新推荐文章于 2024-04-28 10:20:58 发布
阅读量138 收藏
点赞数
分类专栏： Java知识 文章标签： java IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FDoubleman/article/details/115486079
版权
前言：

在刚接触Java的时候对于IO的相关知识点整体掌握的还是比较牢靠的，在从事android相关的工作开发后，对于java IO的相关知识逐渐的模糊起来。其一应该是android中直接使用IO相关的功能比较少，大多数都是封装好的第三方类库。其二即使使用到了IO操作封装成为一个工具类之后，后期回头看的次数相对较少。总之对于Java IO 的相关知识使用的少，缺少总结。
为此这篇文章主要介绍IO类之间的关系，针对在android开发中常用到的IO 操作类给出实例代码参考。

"输入"和"输出"在刚接触java IO的时候这两个概念给我带来了一丝的疑惑。输入的对象是谁？又输出到哪里？

输入流可以理解为向内存[程序内存]输入，输出流可以理解为从内存[程序内存]输出。

Java的IO包主要关注的是从原始数据源的读取以及输出原始数据到目标媒介。
一个程序需要InputStream或者Reader从数据源读取数据，需要OutputStream或者Writer将数据写入到目标媒介中
在这里插入图片描述
能够理解 IO 输入和输出 概念，对java IO的学习有重要的帮助。

IO类概述表

Java的IO包主要关注的是从原始数据源的读取以及输出原始数据到目标媒介。
一个程序需要InputStream或者Reader从数据源读取数据，需要OutputStream或者Writer将数据写入到目标媒介中：

在这里插入图片描述
根据类的关系又可以划分：

在这里插入图片描述

  • OutputStream、InputStream是操作字节流的抽象类无法直接使用。需要根据操作对象选择合适的子类操作。
  • FileOutputStream、FileInputStream对 文件操作
  • ObjectInputStream 和ObjectOutputStream 对 java对象操作
  • DataInputStream 和DataOutputStream 对 java基本类型和字符串操作
  • BufferedInputStream和BufferedOutputStream 组合流：将流整合起来以便实现更高级的输入和输出操作。比如，一次读取一个字节是很慢的，所以可以从磁盘中一次读取一大块数据，然后从读到的数据块中获取字节。为了实现缓冲，可以把InputStream包装到BufferedInputStream中。代码示例：
InputStream input = new BufferedInputStream(new FileInputStream("c:\\data\\input-file.txt"));
  • Reader、Writer是操作字符的抽象类无法直接使用。需要根据操作对象选择合适的子类操作。
  • InputStreamReader、OutputStreamWriter 这两个类把字节流转换成字符流，中间做了数据的转换，类似适配器模式的思想。
  • InputStream的read()方法返回一个字节，意味着这个返回值的范围在0到255之间(当达到流末尾时，返回-1)，
  • Reader的read()方法返回一个字符，意味着这个返回值的范围在0到65535之间(当达到流末尾时，同样返回-1)。
字节流常用类：
一、FileInputStream和FileOutputStream

读取文件内容和写入文件内容

    /**
     * 测试 输入流和输出流
     * 目标:读取 atext.txt 中的内容   写到 btext.txt中
     * 读取 apic.jpeg 中的内容   写到 bpic.jpeg中
     */
    private static void testInputAndOutputStream1() {
        InputStream is = null;
        OutputStream os = null;
        // 操作文件
//        File inFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/atext.txt");
//        File outFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/btext.txt");

        // 操作图片 apic.jpeg
        File inFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/apic.jpeg");
        File outFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/bpic.jpeg");
        if (outFile.exists()) {
            outFile.delete();
            Utils.printLog("testInputAndOutputStream ", "outFile 已存在 删除！");
        }

        try {
            is = new FileInputStream(inFile);
            os = new FileOutputStream(outFile);// 如果文件不存在 会自动创建

            int temp = is.read();
            while (temp != -1) {
                os.write(temp);
                temp = is.read();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        	// 关流 模板代码 后续样例省略
            try {
                if (is != null) {
                    is.close();
                }
                if (os != null) {
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

int read() ：每次只读一个字节，如果文件特别大，这样操作会有效率问题
int read(byte b[]) ：一次性读取一个字节数组的方式，比一次性读取一个字节的方式快的多，所以，尽可能使用这两个方法代替read()方法。

    /**
     * 测试 输入流和输出流
     * 目标:  is.read() 每次只读一个字节，如果文件特别大，这样操作会有效率问题
     * Java I/O默认是不缓冲流的，所谓“缓冲”就是先把从流中得到的一块字节序列暂存在一个被称为buffer的内部字节数组里，
     * 然后你可以一下子取到这一整块的字节数据，没有缓冲的流只能一个字节一个字节读，效率孰高孰低一目了然。
     *
     * 有两个特殊的输入流实现了缓冲功能，一个是我们常用的BufferedInputStream
     */
    private static void testInputAndOutputStream2() {
        InputStream is = null;
        OutputStream os = null;
        byte[] bufferRead = new byte[512];
        int numberRead = 0; // numberRead的目的在于防止最后一次读取的字节小于buffer长度，
        // 操作文件

        File inFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/atext.txt");
        File outFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/btext.txt");

        // 操作图片 apic.jpeg
//        File inFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/apic.jpeg");
//        File outFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/bpic.jpeg");

        if (outFile.exists()) {
            outFile.delete();
            Utils.printLog("testInputAndOutputStream ", "outFile 已存在 删除！");
        }
        try {
            is = new FileInputStream(inFile);
            os = new FileOutputStream(outFile);

            while ((numberRead = is.read(bufferRead)) != -1) {
                os.write(bufferRead, 0, numberRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关流
        }
    }

有两个特殊的输入流实现了缓冲功能，一个是我们常用的BufferedInputStream、BufferedOutputStream

二、BufferedInputStream和BufferedOutputStream

BufferedInputStream BufferedInputStream能为输入流提供缓冲区，能提高很多IO的速度。你可以一次读取一大块的数据，而不需要每次从网络或者磁盘中一次读取一个字节。特别是在访问大量磁盘数据时，缓冲通常会让IO快上许多。 为了给你的输入流加上缓冲，你需要把输入流包装到BufferedInputStream中，代码如下：

InputStream input = new BufferedInputStream(new FileInputStream("c:\\data\\input-file.txt"));

你可以给BufferedInputStream的构造函数传递一个值，设置内部使用的缓冲区设置大小(译者注：默认缓冲区大小8 * 1024B)，就像这样：

InputStream input = new BufferedInputStream(new FileInputStream("c:\\data\\input-file.txt"), 8 * 1024);

    /**
     * 测试 输入流和输出流
     * 目标:  is.read() 每次只读一个字节，如果文件特别大，这样操作会有效率问题
     *       使用 BufferedInputStream
     *
     * 有两个特殊的输入流实现了缓冲功能，一个是我们常用的BufferedInputStream
     */
    private static void testInputAndOutputStream3() {
        InputStream is = null;
        OutputStream os = null;
        byte[] bufferRead = new byte[512];
        int numberRead = 0; // numberRead的目的在于防止最后一次读取的字节小于buffer长度，
        // 操作文件

        File inFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/atext.txt");
        File outFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/btext.txt");

        // 操作图片 apic.jpeg
//        File inFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/apic.jpeg");
//        File outFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/bpic.jpeg");

        if (outFile.exists()) {
            outFile.delete();
            Utils.printLog("testInputAndOutputStream ", "outFile 已存在 删除！");
        }

        try {
            is = new BufferedInputStream(new FileInputStream(inFile));
            os = new BufferedOutputStream(new FileOutputStream(outFile));

            while ((numberRead = is.read(bufferRead)) != -1) {
                os.write(bufferRead, 0, numberRead);
                os.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关流
        }
    }
三、DataInputStream 和DataOutputStream
   /**
     * 写入基本变量和字符串至文件
     * 从文件中读取基本变量和字符串 
     */
    private static void testDataOutputStream() {
        File file = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/datatext.txt");

        DataOutputStream dos = null;
        DataInputStream dis = null;
        if (file.exists()) {
            file.delete();
        }

        try {
            dos = new DataOutputStream(new FileOutputStream(file));
            dis = new DataInputStream(new FileInputStream(file));

            dos.writeUTF("小米");
            dos.writeInt(10);
            dos.writeDouble(1.10);

            // 有用吗？？？
            dos.flush();
            
            // 注意：写入数据和读取数据 顺序保持一致
            // 否则：java.io.EOFException 错误
            String name = dis.readUTF();
            int age = dis.readInt();
            double color = dis.readDouble();
            Utils.printLog("", "name:" + name + " age:" + age + " color:" + color);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关流
        }
    }
四、ObjectInputStream 和ObjectOutputStream

如果你希望类能够序列化和反序列化，必须实现Serializable接口，就像所展示的ObjectInputStream和ObjectOutputStream例子一样。
ObjectInputStream能够让你从输入流中读取Java对象，而不需要每次读取一个字节。你可以把InputStream包装到ObjectInputStream中，然后就可以从中读取对象了。代码如下：

   /**
     * 将对象写入 文件
     * 从文件中读取 对象
     */
    private static void testObjectStream() {
        File inFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/aotext.txt");
        File outFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/botext.txt");
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        if (inFile.exists()) {
            inFile.delete();
        }
        try {
            // 写入
            oos = new ObjectOutputStream(new FileOutputStream(outFile));
            oos.writeObject(new Dog("aa", "10", "red"));
            oos.writeObject(new Dog("bb", "11", "green"));
            oos.writeObject(new Dog("cc", "12", "red"));
            oos.writeObject(new Dog("dd", "13", "yellow"));
            //插入null是用来判断是否读取到结尾
            //写入结束标志方便读取（非常重要，如果不写入，在读取的时候无法定位读取结束）；
            //读取的时候就会报  java.io.EOFException  异常
            oos.writeObject(null);


            // 读取
            ois = new ObjectInputStream(new FileInputStream(outFile));
            Object obj = null;
            while ((obj = ois.readObject()) != null) {
                Dog dog = (Dog) obj;

                Utils.printLog("testObjectStream", dog.toString());
            }

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            // // 关流
        }

    }

写入数组、读取数组

 private static void testObjectArrStream() {
        File inFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/aotext.txt");
        File outFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/botext.txt");
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        if (inFile.exists()) {
            inFile.delete();
        }
        try {
            // 写入 数组
            Dog[] dogArr = new Dog[10];
            for (int i = 0; i < dogArr.length; i++) {
                Dog dog = new Dog("aa"+i, "" + (10 + i), "red");
                dogArr[i]=dog;
            }
            oos = new ObjectOutputStream(new FileOutputStream(outFile));

            oos.writeObject(dogArr);

            // 读取 数组
            ois = new ObjectInputStream(new FileInputStream(outFile));
            Dog[] dogs = (Dog[]) ois.readObject();

            for (Dog dog : dogs) {
                Utils.printLog("testObjectStream", dog.toString());
            }

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
           // 关流
        }

    }

public class Dog implements Serializable {

    private String name;

    private String age;

    private String color;

    public Dog(String name, String age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}
字符流常用类
一、BufferedRead 和 BufferedWriter

整合Reader和Writer 和字节流一样，Reader和Writer可以相互结合实现更多更有趣的IO，工作原理和把Reader与InputStream或者Writer与OutputStream相结合类似。举个栗子，可以通过将Reader包装到BufferedReader、Writer包装到BufferedWriter中实现缓冲。以下是例子：

Reader reader = new BufferedReader(new FileReader(...));
Writer writer = new BufferedWriter(new FileWriter(...));

  /**
     * 使用 inputStreamReader 和 outputStreamWriter
     */
    private static void testReadAndWriter1() {
        Reader reader = null;
        Writer writer = null;


        File readFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/reader.txt");
        File writerFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/writer.txt");


        try {
            reader = new InputStreamReader(new FileInputStream(readFile));
            writer = new OutputStreamWriter(new FileOutputStream(writerFile));
            char[] chars = new char[512];
            int line = 0;
            while ((line = reader.read(chars)) != -1) {
                writer.write(chars, 0, line);
                writer.flush();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关流
        }

    }
二、InputStreamReader和OutputStreamWriter

整合Reader与InputStream 一个Reader可以和一个InputStream相结合。如果你有一个InputStream输入流，并且想从其中读取字符，可以把这个InputStream包装到InputStreamReader中。把InputStream传递到InputStreamReader的构造函数中：

Reader reader = new InputStreamReader(inputStream);

  /**
     * 使用 bufferedRead
     */
    private static void testReadAndWriter2() {
        Reader reader = null;
        Writer writer = null;


        File readFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/reader.txt");
        File writerFile = new File("/Users/fumm/work/my_project/my_lib/CustomView/java_lib/src/main/res/writer.txt");
        if (writerFile.exists()) {
            writerFile.delete();
        }

        try {
//            reader = new InputStreamReader(new FileInputStream(readFile));
//            writer = new OutputStreamWriter(new FileOutputStream(writerFile));
            reader = new BufferedReader(new FileReader(readFile));
            writer = new BufferedWriter(new FileWriter(writerFile));


            char[] chars = new char[512];
            int line = 0;
            while ((line = reader.read(chars)) != -1) {
                writer.write(chars, 0, line);
                writer.flush();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关流
        }
    }
总结：

本文主要梳理Java IO类之间的操作和转换。并通过实例代码加深对IO的理解。对android开发中常见的IO 操作类进行实践。内容比较基础大致对Java IO 知识做了基础的回顾。

参考：
Java IO教程
Java IO最详解

FDoubleman
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IO操作大全
萧海的博客
09-09 816
一、文件基本知识 “文件是指一组相关数据的有序集合”，这个数据集的名称就是文件名。所有文件都是通过流的形式进行输入输出操作的。流是一个数据字节的序列。流入程序的流称为输入流，流出程序的流称为输出流。 流可分为两大类：文本流和二进制流 （1）文本刘是一种字符序列，仅包含字符。 （2）二进制流是一种二进制序列，与外设中的字节序列一一对应，不对字节中的内容进行转换，如遇到换行符也不会执行换行操作。 文本又可以分为文本文件和二进制文本文件两大类。 （1）文本文件又称ASCII文件，也称字符文件。这种文件保存时，每个
I/O操作
m0_72674204的博客
08-28 521
IO操作基础
IO操作
JV_YAN的博客
09-11 308
I/O 输入流：源——（读取）——>数据程序 输出流：程序数据——（写入）——>目标 java流 流概念 数据流向某个对象的数据序列， 并且到达这个对象的过程。 流与源数据和程序之间的关系 输入流：数据源数据流向计算机内存的过程 源数据流——（读取）————>程序 流与目标数据源和程序之间的关系 输出流：把数据从程序流向目标数据源的过程 程序————（
java_IO操作
11-19
以下是对标题和描述中涉及的Java IO操作知识点的详细说明： 1. **读取文件内容**： - **按字节读取**：使用`FileInputStream`类，通过`read()`方法逐个读取字节。适用于二进制文件，如图片、音频或视频。 - **按...
Java-IO.rar_java IO
09-24
这两个知识点都是Java IO编程的基础，也是开发过程中常见的操作。熟悉并掌握它们对于任何Java开发者来说都是非常重要的。通过不断实践和理解这些基本概念，可以为更高级的IO操作和复杂的数据处理奠定坚实的基础。
Java中IO流知识点总结
12-22
一、流的分类 　1、按功能分 　读取流：InputStream Reader 　写出流：OutPutStream Writer 　2、按流的类型分类 　字节流：InputStream OutputStream 　字符流：Reader Writer 　二、流功能分析 ...
Java文件IO操作教程之DirectIO的意义
08-26
Java 文件 IO 操作教程之 DirectIO 的意义 Java 文件 IO 操作教程之 DirectIO 的意义是指在 Java 中使用 DirectIO 机制来实现文件 IO 操作的教程。DirectIO 是一种低级别的 IO 机制，可以绕过操作系统的 PageCache...
浅析Java IO相关知识点
08-27
理解Java IO的工作原理和相关知识点对于开发者来说至关重要，尤其是在进行系统级编程和高性能应用开发时。下面将详细阐述Java IO的一些核心概念和模型。 1. **用户空间与系统空间** 在Linux系统中，每个进程被划分...
IO流操作
最新发布
zgjknb的博客
04-28 1620
i代表：input：输入，对应的是读操作o代表：output：输出对应的是写操作本地磁盘-------->计算机内存读（输入）操作计算机内存----->本地磁盘 写（输出）操作。
Linux——IO操作
一个小孩
03-16 347
1，C库IO函数中，FILE* ptr是不可避免的会使用到文件指针，文件指针实际上是一个结构体，里面包括三部分内容。其一：文件描述符，作用是所用到对应的磁盘文件；其二：文件读写位置指针（读写操作的时候只有一个这样的指针），其作用是，帮助进行读写，可以使用fseek函数对文件读写位置指针进行重置；其三：IO缓冲区，其作用是通过指针可以找到对应的内存块，默认大小是8kb，是为了减少对硬盘操作的次数才引...
什么是IO操作
热门推荐
春风化雨
11-30 1万+
1、IO流 I：就是input 、O：就是output ；称为：输入输出流。 IO操作，就是将数据写入内存或从内存输出的过程，也指应用程序和外部设备之间的数据传递，常见的外部设备包括文件、管道、网络连接。 常见IO流操作，一般指内存与磁盘间的输入输出流操作。 2、目的 持久化数据到硬盘，确保数据永久保存。 文件操作流程：打开文件、读写数据、关闭文件。 读入写出，是站在内存角度界定的。 3、数据流分类 3.1、根据数据流动方向 read：输入流，也称写入流。 write：输出流，也称读出
IO的基本操作
qq_34116958的博客
03-09 239
在c++中有输入输出流可分为三种，从控制台读取或输出（iostream）,从文件中读取或输出(fstream),c从字符串中输入或输出(sstream)。 文章目录iostreamfstreamsstream iostream iostream库中包含两个类型，istream(从控制台输入)和osream(从控制台输出),cin是一个istream对象，从标准输入读取数据，cout是一个ostre...
基本IO操作
LuckyMeizai的博客
05-24 431
基本IO操作：1、 IS与OS2、 文件流3、 缓冲流扩展性强，可以一下读取很多字节，比如读取照片，指针是单向的。IS与OS：1、 流式API非常适合扩展，java提供了非常丰富的扩展。2、输入与输出：    输入：是一个从外界进入到程序的方向，通常我们需要“读取”外界的数据时，使用输入。所以输入是用来读取数据的。    输出：是一个从程序发送到外界的方向，通常我们需要“写出”数据到外界时，使用输...
Java异常处理，IO操作知识点
04-13
好的，关于Java异常处理，一般来说我们可以使用try-catch-finally语句来捕获可能会出现的异常，以便我们可以在程序运行时及时进行处理及反馈。在关于IO操作方面，...这些知识点在Java编程中都是非常重要的基础知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值