JavaIO 字符流的使用

1.使用StringReader将字符转为大写

public class FilterStreamReaderTest {
    static class UppercaseFilterReader extends FilterReader {
        protected UppercaseFilterReader(Reader in) {
            super(in);
        }

        @Override
        public int read() throws IOException {
            int c = super.read();
            if (c != -1) {
                // 将读取的字符转换为大写
                return Character.toUpperCase((char) c);
            }
            return -1;
        }
    }

    public static void main(String[] args) {
        try (
                StringReader fileReader = new StringReader("abcdefg");
                UppercaseFilterReader uppercaseFilterReader = new UppercaseFilterReader(fileReader)
        ) {
            uppercaseFilterReader.skip(1);
            int data;
            while ((data = uppercaseFilterReader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.InputStreamReader的使用

  try (
             InputStream fileInputStream = InputStreamReaderTest.class.getClassLoader().getResourceAsStream("inputStream.txt");
             InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream)) {
            int data;
            while ((data = inputStreamReader.read()) != -1) {
                char character = (char) data;
                System.out.print(character);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

3.使用BufferWriter写入内容到文件

    public static void main(String[] args) {
        try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("output.txt"))) {
            // 写入文本数据到文件
            bufferedWriter.write("Hello, World!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

4.PipedWriter的使用

public class PipedWriterTest {
        public static void main(String[] args) {
            try {
                // 创建PipedWriter和对应的PipedReader
                PipedWriter pipedWriter = new PipedWriter();
                PipedReader pipedReader = new PipedReader(pipedWriter);

                // 创建一个线程来写入数据到PipedWriter
                Thread writerThread = new Thread(() -> {
                    try {
                        pipedWriter.write("Hello, PipedWriter!");
                        Thread.sleep(2000);
                        pipedWriter.write("after sleep");

                        pipedWriter.close(); // 关闭PipedWriter
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                });

                // 创建一个线程来读取数据从PipedReader
                Thread readerThread = new Thread(() -> {
                    try {
                        int data;
                        while ((data = pipedReader.read()) != -1) {
                            System.out.print((char) data);
                        }
                        pipedReader.close(); // 关闭PipedReader
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                });

                // 启动线程
                writerThread.start();
                readerThread.start();

            } catch (IOException e) {
                e.printStackTrace();
            }
        }

}

5.源码分析

Reader read(char[] cbuf, int off, int len)

   public int read(char[] cbuf, int offset, int length) throws IOException {
        int off = offset;
        int len = length;
        synchronized (lock) {
            ensureOpen();
            if ((off < 0) || (off > cbuf.length) || (len < 0) ||
                ((off + len) > cbuf.length) || ((off + len) < 0)) {
                throw new IndexOutOfBoundsException();
            }
            //没有可读字符
            if (len == 0)
                return 0;

            int n = 0;

            if (haveLeftoverChar) {
                // Copy the leftover char into the buffer
                cbuf[off] = leftoverChar;
                off++; len--;
                haveLeftoverChar = false;
                n = 1;
                if ((len == 0) || !implReady())
                    // Return now if this is all we can produce w/o blocking
                    return n;
            }

            if (len == 1) {
                // Treat single-character array reads just like read()
                int c = read0();
                if (c == -1)
                    return (n == 0) ? -1 : n;
                cbuf[off] = (char)c;
                return n + 1;
            }

            return n + implRead(cbuf, off, off + len);
        }
    }