Java IO 流操作详解

最新推荐文章于 2024-05-01 19:10:24 发布

格林希尔

最新推荐文章于 2024-05-01 19:10:24 发布

阅读量1.7k

点赞数 7

分类专栏： Java实践文章标签： java jvm 数据结构架构分布式

本文链接：https://blog.csdn.net/u010349629/article/details/130877700

版权

Java实践专栏收录该内容

75 篇文章 6 订阅

订阅专栏

Java IO 流操作详解

一、简介
二、Java IO流的输入操作
三、Java IO流的输出操作
四、Java IO流的常用方法解析
五、Java NIO模块

一、简介

Java IO流提供了一种可以对数据进行输入输出的机制。可以把它比作是一条河流从源头流向目标地，由源文件输入到程序再由程序输出到目标文件。

1. 什么是IO流

IO即Input/Output顾名思义就是数据的输入输出，在Java中指的是java.io包中的类库，提供了一系列操作数据输入与输出的类和接口。

2. IO流的分类

Java IO流按照其功能可以分为4种类型：

字节流（Byte Streams）：从字节流中读入或输出8位字节数据。InputStream 和 OutputStream 都是针对字节的流。
字符流（Character Streams）：从字符流中读入或输出16位Unicode字符。Reader 和 Writer 都是针对字符的流。
节点流（Node Streams）：Advanced 系列流，如 FileInputStream、FileOutputStream。
处理流（Filter Streams）：Decorator 系列流，如 BufferedInputStream、BufferedOutputStream、ObjectInputStream、ObjectOutputStream。

3. IO流的作用

在Java中IO流的主要作用是将数据从一个地方传输到另一个地方。我们可以使用Java的IO流来实现从文件、控制台甚至是网络传输数据等功能。对于不同的需求，可以灵活选择不同的IO流类型。

二、Java IO流的输入操作

Java IO流提供了多种输入操作的类和接口下面将分别介绍其中的四种。

1. 文件输入流

用于从文件中读取数据可以使用 java.io.FileInputStream 类来实现。

try {
    FileInputStream fis = new FileInputStream("file.txt");   // 指定文件路径
    int c;
    while ((c = fis.read()) != -1) {    // 从文件中读取数据
        System.out.print((char)c);     // 输出数据到控制台
    }
    fis.close();                        // 关闭文件流
} catch (IOException e) {
    e.printStackTrace();
}

2. 字节输入流

用于从数据源中读取字节数据可以使用 java.io.InputStream 类来实现。

try {
    InputStream is = new FileInputStream("file.txt");    // 指定数据源
    int c;
    while ((c = is.read()) != -1) {     // 从数据源读取数据
        System.out.print((char)c);      // 输出数据到控制台
    }
    is.close();                         // 关闭数据流
} catch (IOException e) {
    e.printStackTrace();
}

3. 缓冲输入流

提供了对 IO 字节输入流的缓存机制可以使用 java.io.BufferedInputStream 类来实现

try {
    InputStream is = new FileInputStream("file.txt");    // 指定数据源
    BufferedInputStream bis = new BufferedInputStream(is);    // 使用缓冲输入流读取数据
    int c;
    while ((c = bis.read()) != -1) {    // 从缓冲输入流中读取数据
        System.out.print((char)c);      // 输出数据到控制台
    }
    is.close();                         // 关闭数据流
} catch (IOException e) {
    e.printStackTrace();
}

4. 对象输入流

用于读取对象的相关信息可以使用 java.io.ObjectInputStream 类来实现

try {
    InputStream is = new FileInputStream("file.txt");     // 指定数据源
    ObjectInputStream ois = new ObjectInputStream(is);     // 使用对象输入流读取对象相关信息
    Object obj = ois.readObject();      // 从对象输入流中读取对象相关信息并实例化为一个对象
    System.out.println(obj);            // 输出读取到的对象
    is.close();                         // 关闭数据流
} catch (IOException | ClassNotFoundException e) {
    e.printStackTrace();
}

三、Java IO流的输出操作

Java IO流提供了多种输出操作的类和接口，下面将分别介绍其中的四种。

1. 文件输出流

用于向文件中写入数据可以使用 java.io.FileOutputStream 类来实现

try {
    FileOutputStream fos = new FileOutputStream("file.txt");     // 指定输出文件路径
    String s = "Hello, World!";         // 要写入文件的内容
    byte[] bytes = s.getBytes();        // 将要写入的字符串转化为字节数组
    fos.write(bytes);                   // 向文件中写入字节数据
    fos.close();                        // 关闭文件流
} catch (IOException e) {
    e.printStackTrace();
}

2. 字节输出流

用于向数据源中输出字节数据可以使用 java.io.OutputStream 类来实现

try {
    OutputStream os = new FileOutputStream("file.txt");   // 指定数据源
    String s = "Hello, World!";         // 要写入数据源的内容
    byte[] bytes = s.getBytes();        // 将要写入的字符串转化为字节数组
    os.write(bytes);                    // 向数据源中写入字节数据
    os.close();                         // 关闭数据流
} catch (IOException e) {
    e.printStackTrace();
}

3. 缓冲输出流

提供了对 IO 字节输出流的缓存机制可以使用 java.io.BufferedOutputStream 类来实现

try {
    OutputStream os = new FileOutputStream("file.txt");   // 指定数据源
    BufferedOutputStream bos = new BufferedOutputStream(os);     // 使用缓冲输出流写入数据源
    String s = "Hello, World!";         // 要写入数据源的内容
    byte[] bytes = s.getBytes();        // 将要写入的字符串转化为字节数组
    bos.write(bytes);                   // 向缓冲输出流中写入字节数据
    bos.flush();                        // 刷新流数据到文件，清空缓存
    os.close();                         // 关闭数据流
} catch (IOException e) {
    e.printStackTrace();
}

4. 对象输出流

用于将对象信息写入输出源可以使用 java.io.ObjectOutputStream 类来实现

try {
    OutputStream os = new FileOutputStream("file.txt");     // 指定数据源
    ObjectOutputStream oos = new ObjectOutputStream(os);   // 创建对象输出流
    Object obj = new Object();          // 要写入数据源的对象
    oos.writeObject(obj);               // 将对象信息写入输出源
    oos.flush();                        // 刷新流数据到文件，清空缓存
    os.close();                         // 关闭数据流
} catch (IOException e) {
    e.printStackTrace();
}

四、Java IO流的常用方法解析

1. 字节读写操作

1.1 FileInputStream和FileOutputStream

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

public class ByteStreamExample {
    public static void main(String[] args) {
        File inputFile = new File("input.txt");
        File outputFile = new File("output.txt");
        try (FileInputStream inputStream = new FileInputStream(inputFile);
             FileOutputStream outputStream = new FileOutputStream(outputFile)) {
            byte[] buffer = new byte[1024];
            int length;
            while ((length = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码实现了从input.txt文件读取数据并写入到output.txt文件中。

1.2 DataInputStream和DataOutputStream

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataStreamExample {
    public static void main(String[] args) {
        File inputFile = new File("input.txt");
        File outputFile = new File("output.txt");
        try (DataInputStream inputStream = new DataInputStream(new FileInputStream(inputFile));
             DataOutputStream outputStream = new DataOutputStream(new FileOutputStream(outputFile))) {
            int intValue = inputStream.readInt();
            outputStream.writeInt(intValue);
            boolean boolValue = inputStream.readBoolean();
            outputStream.writeBoolean(boolValue);
            String strValue = inputStream.readUTF();
            outputStream.writeUTF(strValue);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码实现了从input.txt文件中读取整型、布尔型和字符串类型数据，然后将这些数据写入到output.txt文件中。

2. 按字符读写操作

2.1 FileReader和FileWriter

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

public class CharStreamExample {
    public static void main(String[] args) {
        File inputFile = new File("input.txt");
        File outputFile = new File("output.txt");
        try (FileReader reader = new FileReader(inputFile);
             FileWriter writer = new FileWriter(outputFile)) {
            char[] buffer = new char[1024];
            int length;
            while ((length = reader.read(buffer)) != -1) {
                writer.write(buffer, 0, length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码实现了从input.txt文件读取数据并写入到output.txt文件中。

2.2 BufferedReader和BufferedWriter

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

public class BufferCharStreamExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
             BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码实现了从input.txt文件读取数据并写入到output.txt文件中，同时以行的形式进行读写。

3. 随机读写文件操作

3.1 RandomAccessFile

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileExample {
    public static void main(String[] args) {
        File file = new File("file.txt");
        try (RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw")) {
            randomAccessFile.writeBytes("Hello World!");
            randomAccessFile.seek(6);
            randomAccessFile.writeBytes("Java");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码实现了向file.txt文件中写入"Hello World!"，然后从第6个字节开始替换为"Java"。

4. 大文件读写操作

4.1 使用MappedByteBuffer

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class LargeFileExample {
    public static void main(String[] args) {
        File inputFile = new File("input.txt");
        File outputFile = new File("output.txt");
        try (FileInputStream inputStream = new FileInputStream(inputFile);
             FileOutputStream outputStream = new FileOutputStream(outputFile)) {
            FileChannel inputChannel = inputStream.getChannel();
            FileChannel outputChannel = outputStream.getChannel();
            MappedByteBuffer buffer = inputChannel.map(FileChannel.MapMode.READ_ONLY, 0, inputChannel.size());
            outputChannel.write(buffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码实现了将input.txt文件中的数据复制到output.txt文件中，如果读取的文件太大需要使用MappedByteBuffer来减少内存开销。

五、Java NIO模块

1. NIO概述

Java NIO（New IO）是JDK1.4引入的新的IO API，能够以更高效的方式进行文件、网络读写等各种I/O操作。

2. NIO与IO的对比

IO	NIO
面向流	面向缓冲（Buffer）
阻塞IO	非阻塞IO
无	选择器（Selector）

3. NIO模块的核心组件

3.1 Buffer

Buffer是一个对象可以容纳一定数量的数据，并提供了一组方法用于访问这些数据。

3.2 Channel

Channel是用于进行数据读写的对象，它类似于IO流中的“管道”。

3.3 Selector

Selector用于监听多个Channel上的事件（如读、写等），并通过一个线程实现多路复用。

4. NIO模块的使用方式

4.1 读取文件数据

import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.EnumSet;

public class NioExample {
    public static void main(String[] args) {
        Path path = Paths.get("file.txt");
        try (FileChannel channel = (FileChannel) Files.newByteChannel(path, EnumSet.of(StandardOpenOption.READ))) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            while (channel.read(buffer) != -1) {
                buffer.flip();
                while (buffer.hasRemaining()) {
                    System.out.print((char) buffer.get());
                }
                buffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码实现了从file.txt文件中读取数据并输出到控制台。其中FileChannel的read()方法用于读取文件数据，ByteBuffer的flip()方法将缓冲区从写入状态切换到读取状态，clear()方法则用于清空缓冲区。

4.2 写入文件数据

import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.EnumSet;

public class NioExample {
    public static void main(String[] args) {
        Path path = Paths.get("file.txt");
        try (FileChannel channel = (FileChannel) Files.newByteChannel(path, EnumSet.of(StandardOpenOption.WRITE))) {
            ByteBuffer buffer = ByteBuffer.wrap("Hello World!".getBytes());
            channel.write(buffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码实现了向file.txt文件中写入数据“Hello World!”。其中FileChannel的write()方法用于写入文件数据，ByteBuffer的wrap()方法用于把字节数组包装成缓冲区。

格林希尔

关注

7
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
7
评论
Java IO 流操作详解

Java IO流提供了一种可以对数据进行输入输出的机制。可以把它比作是一条河流从源头流向目标地，由源文件输入到程序再由程序输出到目标文件。IO即Input/Output顾名思义就是数据的输入输出，在Java中指的是java.io包中的类库，提供了一系列操作数据输入与输出的类和接口。Java NIO（New IO）是JDK1.4引入的新的IO API，能够以更高效的方式进行文件、网络读写等各种I/O操作。
复制链接

扫一扫