Java基础汇总（九）——JavaIO流、多线程

蔚落 2024-04-06 11:39 20阅读 0赞

**一、JavaIO流**

**1.定义**

一种连续的数据流，从数据源流向目标媒介；流通常与数据源、数据流向目的地相关联。

*  **可以从流中读取数据，也可以往流中写数据**
 *   **流不能通过索引读写数据**
 *  **在流中，不能像数组那样前后移动读取数据（使用 RandomAccessFile处理文件除外）**
 *  **PushbackInputStream流允许将数据重新推回到流中，以便重新读取（但只能把有限的数据推回流中，并不能像操作数组那样随意读取）**
 *  **流中的数据只能顺序读取**

**2.分类**

**字节流：以字节为单位进行读写**，通常以“stream”命名，在一个操作时间内只能读取或写入一个原始字节（**DataInputStream和DataOutputStream除外，其能够读写int, long, float和double类型的值**）

**字符流：以字符为单位进行读写**，通常以“Reader”或者“Writer”命名

**组合流：**

将流整合起来以便实现更高级的输入和输出操作。如**可以把InputStream包装到BufferedInputStream中以实现缓冲，即从磁盘中一次读取一大块数据**

例1：

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

**Java中流类的超类：**

*  **java.io.InputStream**
 *  **java.io.OutputStream**
 *  **java.io.Reader**
 *  **java.io.Writer**

**3.JavaIO 文件**

文件是一种常用的数据源或者存储数据的媒介

**JavaIO 读文件：**

**FileInputStream（二进制型数据）：按顺序地读取文件中的字节，每次读取一个字节**

**FileReader（字符型数据）：按顺序地读取文件中的字符，每次读取一个字符**

**JavaIO 写文件：**

**FileOutputStream（二进制型数据）：每次写入一个字节，数据按照写入顺序存储在文件当中**

**FileWriter（字符型数据）：每次写入一个字符，数据按照写入顺序存储在文件当中**

**RandomAccessFile：对文件进行随机存取（随机存取并不意味着你可以在真正随机的位置进行读写操作，它只是意味着你可以跳过文件中某些部分进行操作，并且支持同时读写，不要求特定的存取顺序）**

例2：

@Test
        //文件流范例，打开一个文件的输入流，读取到字节数组，再写入另一个文件的输出流
        public void test1() {
            try {
                FileInputStream fileInputStream = new FileInputStream(new File("a.txt"));
                FileOutputStream fileOutputStream = new FileOutputStream(new File("b.txt"));
                byte []buffer = new byte[128];
                while (fileInputStream.read(buffer) != -1) {
                    fileOutputStream.write(buffer);
                }
                //随机读写，通过mode参数来决定读或者写
                RandomAccessFile randomAccessFile = new RandomAccessFile(new File("c.txt"), "rw");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

例3（JavaIO reader）：

Reader reader = new FileReader("c:\\data\\myfile.txt");
    
    int data = reader.read();
    
    while(data != -1){
    
        char dataChar = (char) data;
    
        data = reader.read();
    
    }

**通常使用Reader的子类，而不会直接使用Reader。**Reader的子类包括InputStreamReader，CharArrayReader，FileReader等。

**从InputStream输入流读取字符：可以通过InputStream包装到InputStreamReader中方法实现**

例4：

Reader reader = new InputStreamReader(inputStream);

**Writer类和Reader类基本相同**，通常使用Writer子类，OutputStream和OutputStreamReader的整合方法也相同。

例5（JavaIO writer）：

Writer writer = new FileWriter("c:\\data\\file-output.txt"); 
    
    writer.write("Hello World Writer"); 
    
    writer.close();

例6：

Writer writer = new OutputStreamWriter(outputStream);

**Writer的write(int c)方法，会将传入参数的低16位写入到Writer中，忽略高16位的数据**

**4.JavaIO 管道：**

**Java IO中的管道为运行在同一个JVM中的两个线程提供通信的能力**，所以管道也可以作为数据源以及目标媒介。

**不同的JVM中线程不能利用管道进行通信（即不同进程间不能用管道进行通信）**

**管道创建：**

*  **通过Java IO中的PipedOutputStream和PipedInputStream创建管道**
 *  **一个PipedInputStream流应该和一个PipedOutputStream流相关联**
 *  **一个线程通过PipedOutputStream写入的数据可以被另一个线程通过相关联的PipedInputStream读取出来**

例7：

//使用管道来完成两个线程间的数据点对点传递
        @Test
        public void test2() throws IOException {
            PipedInputStream pipedInputStream = new PipedInputStream();
            PipedOutputStream pipedOutputStream = new PipedOutputStream(pipedInputStream);
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        pipedOutputStream.write("hello input".getBytes());
                        pipedOutputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        byte []arr = new byte[128];
                        while (pipedInputStream.read(arr) != -1) {
                            System.out.println(Arrays.toString(arr));
                        }
                        pipedInputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();

**当使用两个相关联的管道流时，务必将它们分配给不同的线程**

**read()方法和write()方法调用时会导致流阻塞**，这意味着在一个线程中同时进行读和写，可能会导致线程死锁

**5.JavaIO 网络：**

Java网络API用来在不同进程之间建立网络连接，而J**ava IO则用来在建立了连接之后的进程之间交换数据**

JavaIO 网络中的数据交换和JavaIO 文件中的读写操作一致，即用InputStream替代FileInputStream完成读操作，用OutputStream替代FileOutputStream完成写操作。

例8：

//从网络中读取字节流也可以直接使用OutputStream
    public void test3() {
        //读取网络进程的输出流
        OutputStream outputStream = new OutputStream() {
            @Override
            public void write(int b) throws IOException {
            }
        };
    }
    public void process(OutputStream ouput) throws IOException {
        //处理网络信息
        //do something with the OutputStream
    }

**6.JavaIO 字节和字符数组：**

字符数组或字节数组不仅可以用来做缓存数据的临时存储空间，同时也可以作为数据来源或者写入目的

例9：

//字符数组和字节数组在io过程中的作用
        public void test4() {
            //arr和brr分别作为数据源
            char []arr = {'a','c','d'};
            CharArrayReader charArrayReader = new CharArrayReader(arr);
            byte []brr = {1,2,3,4,5};
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(brr);
        }

**7.System.in, System.out, System.err**

**System.in：**

*  连接控制台程序和键盘输入的InputStream流

**System.out：**

*  一个PrintStream流
 *  一般会把你写到其中的数据输出到控制台上
 *  通常仅用在类似命令行工具的控制台程序上
 *  也经常用于打印程序的调试信息(尽管它可能并不是获取程序调试信息的最佳方式)

**System.err：**

*  一个PrintStream流
 *  System.err与System.out的运行方式类似，但它更多的是用于打印错误文本（一些类似Eclipse的程序，为了让错误信息更加显眼，**会将错误信息以红色文本的形式通过System.err输出到控制台上**）

例10：

//测试System.in, System.out, System.err    
        public static void main(String[] args) {
            int in = new Scanner(System.in).nextInt();
            System.out.println(in);
            System.out.println("out");
            System.err.println("err");
            //输入10，结果是
    //        err（红色）
    //        10
    //        out
        }

**8.字符流的Buffered**

**BufferedReader：为字符输入流提供缓冲区，可以提高许多IO处理的速度**

**BufferedInputStream：为原始字节输入流提供缓冲区，可以提高许多IO处理的速度**

**BufferedReader缓冲区默认为8KB（但可以具体指定）**

例11：

Reader input = new BufferedReader(new FileReader("c:\\data\\input-file.txt"), 8 * 1024);

**最好把缓冲区大小设置成1024字节的整数倍**，这样能更高效地利用内置缓冲区的磁盘

**BufferedReader还有一个readLine()方法，可以方便地一次性读取一整行字符**

BufferedWriter为输出流提供缓冲区，与BufferedReader完全一致（也有writeline()方法，值得注意是，**需要手动flush()方法确保写入到此输出流的数据真正写入到磁盘或者网络中**）

**9.总结**

**IO流定义：**

**它是一种数据的流从源头流到目的地。比如文件拷贝，输入流和输出流都包括了。输入流从文件中读取数据存储到进程(process)中，输出流从进程中读取数据然后写入到目标文件。**

**字节流和字符流的区别：**

**字节流用于操作包含ASCII字符的文件；字符流用于读取包含Unicode字符的文件；对于英文字符文件，字节流和字符流都可以用**

**FileInputStream和FileOutputStream（适用于小文件）：**

**进行文件拷贝操作所用的类，对于大文件，建议应用BufferedInputStream (或 BufferedReader) 和 BufferedOutputStream (或 BufferedWriter)**

**Filter流（FilterInputStream, FilterOutputStream, FilterReader and FilterWriter）：**

**Filter Stream是一种IO流主要作用是用来对存在的流增加一些额外的功能，像给目标文件增加源文件中不存在的行数，或者增加拷贝的性能**

**File类：**

**不属于 IO流，也不是用于文件操作的，它主要用于知道一个文件的属性，读写权限，大小等信息**

**RandomAccessFile：**

*  **java.io包中是一个特殊的类，既不是输入流也不是输出流，它两者都可以做到**
 *  **Object的直接子类**
 *  **RandomAccessFile既可以读文件，也可以写文件**

**二、多线程**

**参考文章：**

[https://github.com/h2pl/Java-Tutorial/blob/master/docs/java/basic/17%E3%80%81%E5%A4%9A%E7%BA%BF%E7%A8%8B.md][https_github.com_h2pl_Java-Tutorial_blob_master_docs_java_basic_17_E3_80_81_E5_A4_9A_E7_BA_BF_E7_A8_8B.md]

时间太紧，不整理了，本人多线程看的就是这篇文章

[https_github.com_h2pl_Java-Tutorial_blob_master_docs_java_basic_17_E3_80_81_E5_A4_9A_E7_BA_BF_E7_A8_8B.md]: https://github.com/h2pl/Java-Tutorial/blob/master/docs/java/basic/17%E3%80%81%E5%A4%9A%E7%BA%BF%E7%A8%8B.md