Java操作IO对象流进行数据的读写

针对Java操作IO（输入/输出）对象流进行数据的读写，一般包括以下的几个步骤：

1. 创建IO对象流（如FileInputStream、FileOutputStream等）以及处理器流（如InputStreamReader、OutputStreamWriter等）
2. 读、写或处理流中读写的数据（如读文本文件、写二进制文件等）
3. 关闭流以释放资源，避免内存泄漏

具体步骤及示例可以参考下面的内容。

1. 创建IO对象流和处理器流

1.1 FileInputStream和FileOutputStream的使用示例

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

public class FileStreamExample {
    public static void main(String[] args) {
        try {
            FileInputStream inputStream = new FileInputStream("input.txt");
            FileOutputStream outputStream = new FileOutputStream("output.txt");

            int c;
            while ((c = inputStream.read()) != -1) { // 从输入文件中读取数据
                outputStream.write(c); // 写入到输出文件中
            }

            inputStream.close(); // 关闭输入流
            outputStream.close(); // 关闭输出流
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

上面的示例中，在try代码块内创建了一个FileInputStream对象和一个FileOutputStream对象，分别用于输入和输出数据。在while循环中，读入input.txt文件的内容，并将其逐字节写入output.txt文件中。注意，这里只是演示了如何逐字节读写数据，并且还需要手动实现例如字符编码转换的操作。在实际应用中，可以使用处理器流来读写带有编码、格式化、缓冲等特性的文件。

1.2 InputStreamReader和OutputStreamWriter的使用示例

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class CharacterStreamExample {
    public static void main(String[] args) {
        try {
            FileInputStream inputStream = new FileInputStream("input.txt");
            FileOutputStream outputStream = new FileOutputStream("output.txt");

            InputStreamReader reader = new InputStreamReader(inputStream, "UTF-8");
            OutputStreamWriter writer = new OutputStreamWriter(outputStream, "UTF-8");

            char[] buffer = new char[4096];
            int length;
            while ((length = reader.read(buffer)) != -1) {
                writer.write(buffer, 0, length); // 将buffer中的字符块写入到输出文件中
            }

            reader.close();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

上面的示例中，通过InputStreamReader和OutputStreamWriter实现了读写操作。可选的第二个参数为字符编码，这里使用UTF-8。读取器和写入器提供了buffer来存放读取或写入的字符。在循环中，按照最大读取长度，读取器从输入文件中读取字符块，并将其存入buffer数组中，然后写入器将buffer中的字符块写入到输出文件中。

2. 读、写或处理流中读写的数据

在实际使用IO对象流进行数据读写时，需要根据具体需要进行一些处理，例如对于文本文件的读写，如果需要将读取到的字节数组转化为字符串，则可以使用Java提供的String类的构造函数：String(byte[] bytes, int offset, int length, Charset charset)，其中bytes为读取到的字节数组，offset为起始偏移量，length为读取的字节数，charset为字符编码。

下面是一个读取文本文件并将读取到的文本进行统计的示例：

import java.io.FileInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

public class TextFileExample {
    public static void main(String[] args) {
        Map<Character, Integer> charCountMap = new HashMap<>();
        try {
            FileInputStream inputStream = new FileInputStream("input.txt");
            byte[] buffer = new byte[4096];
            int length;
            while ((length = inputStream.read(buffer)) != -1) {
                String text = new String(buffer, 0, length, StandardCharsets.UTF_8);
                for (char ch : text.toCharArray()) {
                    if (Character.isLetter(ch)) { // 只统计字母类型字符
                        charCountMap.put(ch, charCountMap.getOrDefault(ch, 0) + 1);
                    }
                }
            }
            System.out.println(charCountMap);
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

上面的示例中，读入输入文件的内容，并转化为字符串；遍历字符串中的各个字符，统计字母类型的字符的出现次数，并将结果存储在一个HashMap中。

3. 关闭流以释放资源

在读写完数据后，需要明确地关闭对应的流以释放资源，避免内存泄漏，可以将相应的代码放在finally块中，以确保一定会被执行。

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

public class FileStreamExample {
    public static void main(String[] args) {
        FileInputStream inputStream = null;
        FileOutputStream outputStream = null;
        try {
            inputStream = new FileInputStream("input.txt");
            outputStream = new FileOutputStream("output.txt");

            int c;
            while ((c = inputStream.read()) != -1) { // 读取输入文件中的数据
                outputStream.write(c); // 将数据写入到输出文件中
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (inputStream != null) {
                    inputStream.close(); // 关闭输入流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (outputStream != null) {
                    outputStream.close(); // 关闭输出流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

上面的示例中，在try块中初始化输入、输出流，并进行处理操作，finally块中关闭流以释放资源。