Java IO流使用指南

一、什么是IO流？

IO（Input/Output）即输入与输出，Java中的IO流是用来处理文件与数据流的机制。Java将流定义为一个连续的字符序列和字节序列。在Java中，流是用于读写操作的，数据流向被读取，也可以流向被写入。IO流通常分为字节流和字符流。字节流用于处理二进制数据，例如处理图像和音频文件；字符流则用于处理文本数据，例如处理文本文件。Java中的IO流主要有三个途径：File类、流式传输API、NIO。

public class IOStreamDemo {
    public static void main(String[] args) {
        try {
            File file = new File("test.txt");
            FileInputStream fis = new FileInputStream(file);
            InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
            BufferedReader br = new BufferedReader(isr);
            String line;
            while((line = br.readLine()) != null) {
                System.out.println(line);
            }
            br.close();
            isr.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

二、JAVA IO流的分类

Java的IO流可以根据数据传输方式划分为字节流和字符流，可以根据操作的数据单位划分为节点流和处理流。

1. 字节流和字符流

字节流主要由InputStream和OutputStream构成，其中InputStream是抽象类，可以根据具体数据类型采取相应的输入流，如FileInputStream；OutputStream也是抽象类，可以根据具体数据类型采取相应的输出流，如FileOutputStream。

字符流主要由Reader和Writer构成，其中Reader是抽象类，可以根据具体数据类型采取相应的读取字符流，如FileReader；Writer也是抽象类，可以根据具体数据类型采取相应的写入字符流，如FileWriter。

import java.io.*;

public class ByteStreamDemo {
    public static void main(String[] args) {
        try {
            File file = new File("test.txt");
            FileInputStream fis = new FileInputStream(file);
            byte[] b = new byte[1024];
            int len;
            while ((len = fis.read(b)) != -1) {
                System.out.println(new String(b,0,len, "UTF-8"));
            }
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 节点流和处理流

节点流负责数据的读写，处理流则利用节点流进行数据读写的过程中添加相应的处理方式。节点流可以直接操作文件，但是处理流不能单独存在，它必须依托于其他的节点流的基础之上。常见的例子是BufferedReader和文件的结合。

import java.io.*;

public class ReaderDemo {
    public static void main(String[] args) {
        try {
            File file = new File("test.txt");
            FileInputStream fis = new FileInputStream(file);
            InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
            BufferedReader br = new BufferedReader(isr);
            String line;
            while((line = br.readLine()) != null) {
                System.out.println(line);
            }
            br.close();
            isr.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

三、Java IO流的常用类

1. FileInputStream 和 FileOutputStream类

FileInputStream和FileOutputStream用于读取和输出文件数据。这两个类是字节流的标准类型，它们通过简单的InputStream和OutputStream类进行包装实现。

import java.io.*;

public class FileStreamDemo {
    public static void main(String[] args) {
        File file = new File("test.txt");
        try {
            FileOutputStream fos = new FileOutputStream(file);
            String data = "这是Java IO流的使用指南";
            byte[] b = data.getBytes("UTF-8");
            fos.write(b);
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            FileInputStream fis = new FileInputStream(file);
            byte[] b = new byte[(int) file.length()];
            fis.read(b);
            System.out.println(new String(b, "UTF-8"));
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. Reader和Writer类

Reader和Writer类是用于读取和输出字符数据的类，它提供了直观的读写接口，适合于处理文本类型数据。

import java.io.*;

public class FileWriterDemo {
    public static void main(String[] args) {
        File file = new File("test.txt");
        try {
            FileWriter fw = new FileWriter(file);
            fw.write("这是Java IO流的使用指南");
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            FileReader fr = new FileReader(file);
            char[] b = new char[(int) file.length()];
            fr.read(b);
            System.out.println(new String(b));
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. BufferedReader 和 BufferedWriter类

BufferedReader和BufferedWriter是高效的读取和输出字符数据的类，它们提供了缓冲读写接口，可以提高IO效率。

import java.io.*;

public class BufferedWriterDemo {
    public static void main(String[] args) {
        File file = new File("test.txt");
        try {
            BufferedWriter bw = new BufferedWriter(new FileWriter(file));
            bw.write("这是Java IO流的使用指南");
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            BufferedReader br = new BufferedReader(new FileReader(file));
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

四、Java NIO介绍

NIO（New IO）是JDK1.4版本引入的一组带有新功能的IO API。NIO支持面向缓冲的，基于通道的IO操作。 NIO是一种基于缓存的IO方式，主要是为了解决BIO（Blocking IO）多线程读取数据的问题，在NIO中可以设置一个或多个缓存装满需要传输的内容，然后再操作缓存中的内容。

import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.nio.file.*;

public class NIODemo {
    public static void main(String[] args) {
        try {
            Path path = Paths.get("test.txt");
            String input = "这是Java NIO的使用指南";
            Files.write(path, input.getBytes(), StandardOpenOption.CREATE);

            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            Charset charset = Charset.forName("UTF-8");
            FileChannel fileChannel = FileChannel.open(path);
            int bytesRead = fileChannel.read(byteBuffer);
            while (bytesRead != -1){
                byteBuffer.flip();
                while(byteBuffer.hasRemaining()) {
                    System.out.print(charset.decode(byteBuffer));
                }
                byteBuffer.clear();
                bytesRead = fileChannel.read(byteBuffer);
            }
            fileChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}