자바 프로그래밍 사고 학습 수업(5) 18장 - 자바 IO 시스템

1 파일 클래스

                                                                                                                        이름(File) 클래스는 다소 오해의 소지가 있지만 실제로는 그렇지 않습니다. 특정 파일의 File（文件）类这个名字有一定的误导性；我们可能会认为它指代的是文件，实际上却并非如此。它既能代表一个特定文件的名称，又能代表一个目录下的一组文件的名称。实际上，FilePath（文件路径）对这个类来说是更好的名字。

  如果它指的是一个文件集，我们就可以对此集合调用list()方法，这个方法会返回一个字符串数组。

2 输入和输出（Input an output）

  编程语言的I/O类库常使用流这个抽象概念，它代表任何有能力产出数据的数据源对象或者是有能力接收数据的接收对象。“流”屏蔽了实际的I/O设备中处理数据的细节。

我们很少使用单一的类来创建流对象，而是通过叠合多个对象来提供所期望的功能（这是装饰器设计模式）。实际上，Java中的“流”类库让人迷惑的主要原因就在于：创建单一的结果流，却需要创建多个对象。

  在Java 1.0中，类库的设计者首先限定与输入有关的所有类都应该从InputStream继承，而与输出有关的所有类都应该从OutputStream继承。

  InputStream或Reader中的read()用于读取单个字节或者字节数组，OutputStream或Writer用于写单个字节或者字节数组。

2.1 InputStream类型

  InputStream的作用是用来表示那些从不同数据源产生输入数据的类。每一种数据源都有相应的InputStream子类。这些数据源包括：

• 字节数组。An array of bbytes.

• String对象。A String object.

• 文件。A file.

• “管道”（A pipe），工作方式与实际管道相似，即，从一端输入，从另一端输出。

• 一个由其他种类的流组成的序列，以便我们可以将它们收集合并到一个流内。A sequence of other streams.

• 其他数据源，如Internet连接等。Other sources.

2.2 OutputStream类型

  OutputStream类决定了输出所要去往的目标：

• 字节数组

• 文件

• 管道

3 添加属性和有用接口

  FilterInputStream 和 FilterOutputStream 是用来提供装饰器类接口以控制特定输入流（InputStream）和输出流（OutputStream）的两个类，它们的名字并不直观。这两个类是装饰器的必要条件（以便能为所有正在被修饰的对象提供通用接口）。

4 Reader 和 Writer

• InputStream和OutputStream面向字节形式的I/O提供功能

• Reader和Writer面向字符（兼容Unicode）形式的I/O功能

设计Reader和Writer继承层次结构主要是为了国际化。老的I/O流继承层次结构仅支持8位字节流，并且不能很好地处理16位的Unicode字符。由于Unicode用于字符国际化（Java本身的char也是16位的Unicode），所以添加Reader和Writer继承层次结构就是为了在所有的I/O操作中都支持Unicode。另外新类库的设计使得它的操作比旧类库更快。

5 自我独立的类：RandomAccessFile

RandomAccessFile适用于由大小已知的记录组成的文件，所以我们可以使用seek()

🎜이름🎜🎜뿐만 아니라 디렉터리에 있는 🎜파일 집합의 🎜🎜🎜이름🎜🎜도 나타낼 수 있습니다. 실제로 이 클래스에는 🎜FilePath🎜(🎜🎜file path🎜🎜)가 더 나은 이름입니다. 🎜

🎜  파일 모음을 참조하는 경우 이 모음에 대해 🎜list()🎜 메서드를 호출하면 문자열 배열이 반환됩니다. 🎜

2 입력 및 출력(입력 및 출력)

🎜  프로그래밍 언어의 I/O 라이브러리는 종종 🎜🎜stream🎜🎜이라는 추상적 개념을 사용하는데, 이는 데이터를 생성하는 모든 능력을 나타냅니다의 🎜데이터 소스 개체🎜 또는 데이터 수신 기능이 있는 🎜수신 개체🎜입니다. "스트림"은 실제 I/O 장치에서 데이터 처리 세부 사항을 마스킹합니다. 🎜🎜🎜플로우 객체를 생성하기 위해 단일 클래스를 거의 사용하지 않지만, 여러 객체를 오버레이하여 원하는 기능을 제공합니다(이것이 데코레이터 디자인 패턴입니다). 실제로 Java의 "스트림" 라이브러리가 혼란스러운 주된 이유는 단일 결과 스트림을 생성하려면 여러 객체를 생성해야 하기 때문입니다. 🎜🎜  Java 1.0에서 클래스 라이브러리 디자이너는 먼저 🎜input🎜에 관련된 모든 클래스가 🎜InputStream🎜에서 상속되어야 하고 🎜output🎜에 관련된 모든 클래스가 모두 상속되어야 한다고 제한했습니다. 🎜OutputStream🎜에서 상속받습니다. InputStream 또는 Reader의 🎜🎜  read()는 단일 🎜바이트🎜 또는 🎜바이트 배열🎜을 읽는 데 사용되며, OutputStream 또는 Writer는 단일 바이트 또는 바이트 배열을 쓰는 데 사용됩니다. 🎜

2.1 InputStream 유형

🎜  InputStream은 다양한 🎜데이터 소스🎜에서 입력 데이터를 생성하는 클래스를 나타내는 데 사용됩니다. 🎜각 데이터 소스에는 해당하는 InputStream 하위 클래스🎜가 있습니다. 이러한 데이터 소스에는 🎜

• 🎜바이트 배열이 포함됩니다. 바이트 배열.🎜
• 🎜String 객체. 문자열 객체.🎜
• 🎜 파일. 파일.🎜
• 🎜 "파이프"(파이프)는 실제 파이프처럼 작동합니다. 즉, 입력은 한쪽 끝에서, 출력은 반대쪽 끝에서 이루어집니다. 🎜
• 🎜다른 종류의 스트림을 하나의 스트림으로 수집할 수 있도록 구성된 시퀀스입니다. 일련의 다른 스트림.🎜
• 🎜인터넷 연결 등 기타 데이터 소스 기타 소스.🎜

2.2 OutputStream 유형

🎜 — OutputStream 클래스는 출력이 전달되는 대상을 결정합니다. 🎜

• 🎜byte array🎜
• 🎜file🎜
• 🎜pipe🎜

3 속성 및 유용한 인터페이스 추가

🎜 FilterInputStream 및 FilterOutputStream은 🎜데코레이터 클래스 인터페이스🎜를 제공하여 🎜🎜특정 🎜🎜🎜입력 스트림🎜(InputStream) 및 🎜출력 스트림🎜을 제어하는 ​​데 사용됩니다. (OutputStream) 두 클래스, 이름이 직관적이지 않습니다. 이 두 클래스는 데코레이터에 필요합니다(데코레이션되는 모든 객체에 🎜공통 인터페이스🎜를 제공하기 위해). 🎜

4 리더 및 라이터

• 🎜InputStream 및 OutputStream🎜🎜바이트 중심 🎜🎜 I/O 형식은 기능을 제공합니다. 🎜
• 🎜Reader 및 Writer🎜🎜문자 중심 🎜🎜(유니코드 호환) 형식의 I/O 기능 🎜

🎜🎜 Reader 및 Writer 상속 계층 구조의 설계는 주로 🎜🎜국제화🎜🎜를 위한 것입니다. 이전 I/O 스트림 상속 계층 구조는 🎜8🎜비트 바이트 스트림🎜🎜만 지원하고 🎜16🎜비트 유니코드 문자🎜🎜를 제대로 처리하지 못했습니다. 🎜🎜유니코드는 문자 국제화에 사용되므로 🎜🎜(Java 자체 문자도 16비트 유니코드임) 따라서 🎜Reader 및 Writer 상속 계층 구조를 추가하면 모든 유니코드🎜는 모든 I/O 작업에서 지원됩니다. 또한 새로운 클래스 라이브러리의 디자인으로 인해 기존 클래스 라이브러리보다 작동 속도가 빨라졌습니다. 🎜

5 자체 포함 클래스: RandomAccessFile

🎜🎜RandomAccessFile은 알려진 크기의 레코드로 구성된 파일에 적합하므로 seek( )를 사용할 수 있습니다. 기록을 한 곳에서 다른 곳으로 이동한 다음 기록을 읽거나 수정합니다. 🎜

RandomAccessFile은 파일 내에서 앞뒤로 이동할 수 있다는 점에서 다른 I/O 유형과 근본적으로 다른 동작을 가지고 있습니다. 어쨌든 이는 독립적이며 Object에서 직접 파생됩니다. RandomAccessFile拥有和别的I/O类型本质不同的行为，因为我们可以在一个文件 内向前和向后移动。在任何情况下，它都是自我独立的，直接从Object派生而来。

  从本质上说，RandomAccessFile的工作方式类似于把DataInputStream和DataOutputStream组合起来使用，还添加了一些新方法：

• getFilePointer()用于查找当前所处的文件位置，

• seek()用于在文件内移至新的位置，

• length()用于判断文件的最大尺寸。

6 I/O流的典型使用方式（Typical uses of I/O streams）

尽管可以通过不同的方式组合I/O流类，但我们可能也就只用到其中的几种组合。下面的例子可以作为典型的I/O用法的基本参考。

6.1 缓冲输入文件（Buffered input file）

6.2 从内存输入（Input from memory）

6.3 格式化的内存输入（Formatted memory input）

6.4 基本的文件输出（Basic file output）

6.5 存储和恢复数据（Storing and recovering data）

6.6 读写随机访问文件（Reading and writing random-access files）

6.7 管道流（PipedStreams）

7 标准I/O（Standard I/O）

标准I/O这个术语参考的是Unix中“程序所使用的单一信息流”这个概念。

标准I/O的意义在于：我们可以很容易地把程序串联起来，一个程序的标准输出可以成为另一个程序的标准输入。

8 新I/O

速度的提高来自于所使用的结构更接近于操作系统执行I/O的方式：通道和缓冲器。我们可以把它想像成一个煤矿，通道是一个包含煤层（数据）的矿藏，而缓冲器则是派送到矿藏的卡车。卡车载满煤炭而归，我们再从卡车上获得煤炭。也就是说，我们并没法有直接和通道交互，我们只是和缓冲器交互，并把缓冲器派送到通道。通道要么从缓冲器获得数据，要么向缓冲器发送数据。

唯一直接与通道交互的缓冲器是ByteBuffer——也就是说，可以存储未加工字节的缓冲器。当我们查询JDK文档中的java.nio.ByteBuffer时，会发现它是相当基础的类：通过告知分配多少存储空间来创建一个ByteBuffer对象，并且还有一个方法选择集，用于以原始的字节形式或基本数据类型输出和读取数据。但是，没办法输出或读取对象，即使是字符串对象也不行。这种处理虽然很低级，但却正好，因为这是大多数操作系统中更有效的映射方式。

8.1 通道FileChannel

  FileChannel是操纵字节流的。旧I/O类库中有三个类被修改了，用以产生FileChannel:

• FileInputStream.getChannel()

• FileOutputSteam.getChannel()

• RandomAccessFile.getChannel()

package net.mrliuli.io.nio;import java.nio.*;import java.nio.channels.*;import java.io.*;public class GetChannel {
    private static final int BSIZE = 1024;
    public static void main(String[] args) throws Exception {
        // Write a file:
        FileChannel fc = new FileOutputStream("data.txt").getChannel();
        fc.write(ByteBuffer.wrap("Some text ".getBytes()));
        /*
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        fc.read(buffer);                                            // NonReadableChannelException
        System.out.println((char)buffer.get());
        */
        fc.close();
        // Add to the end of the file:
        fc = new RandomAccessFile("data.txt", "rw").getChannel();   // Readable and Writable        
        fc.position(fc.size()); // Move to the end      
        fc.write(ByteBuffer.wrap("some more".getBytes()));
        fc.close();
        // Read the file:
        fc = new FileInputStream("data.txt").getChannel();
        ByteBuffer buff = ByteBuffer.allocate(BSIZE);       
        fc.read(buff);
        //fc.write(ByteBuffer.wrap("again".getBytes()));            //NonWritableChannelException
        buff.flip();
        while(buff.hasRemaining())
            System.out.print((char)buff.get()); // ByteBuffer.get() returns a byte
        System.out.println();
    }
}

8.2 缓冲器ByteBuffer

  将字节存放于缓冲器ByteBuffer的方式：

• 使用put()直接填充，填入一个或多个字节，或基本数据类型的值；

• 使用wrap()将已存在的字节数组包装到ByteBuffer中。

8.3 read(), write(), flip(), write()

  设有一个输入通道in、一个输出通道out和一个缓冲器buffer:

• in.read(buffer); 将fc中的字节输入buffer，此时必须再调buffer.flip();做好让别人从buffer读取字节的准备。

• out.write(buffer)将buffer中的字节输出到out，write()操作之后，信息仍在缓冲器buffer中，须调用buffer.clear();对所有的内部指针重新安排，以便缓冲器在另一个read()

   기본적으로 RandomAccessFile은 DataInputStream과 DataOutputStream을 결합하는 것처럼 작동하며 몇 가지 새로운 메서드가 추가되었습니다. 🎜
  • 🎜< code>getFilePointer()는 현재 파일 위치를 찾는 데 사용됩니다. 🎜
  • 🎜seek()는 파일 내의 새 위치로 이동하는 데 사용됩니다. 🎜
  • 🎜length()는 파일의 최대 크기를 결정하는 데 사용됩니다. 🎜

  6 I/O 스트림의 일반적인 용도

  🎜I/O 스트림 클래스는 다양한 방식으로 결합될 수 있지만 몇 가지 조합만 사용할 수 있습니다. 그들을. 다음 예는 일반적인 I/O 사용에 대한 기본 참조로 사용할 수 있습니다. 🎜

  6.1 버퍼 입력 파일

  6.2 메모리에서 입력

  6.3 포맷된 메모리 입력 )

  6.4 기본 파일 출력(기본 파일 출력 )

  6.5 데이터 저장 및 복구(데이터 저장 및 복구)

  6.6 랜덤 액세스 파일 읽기 및 쓰기( 랜덤 액세스 파일 읽기 및 쓰기)

  6.7 PipedStreams

  7 표준 I/O

  🎜표준 I/O이 용어는 다음을 나타냅니다. Unix의 "프로그램에서 사용하는 단일 정보 스트림"이라는 개념입니다. 🎜🎜표준 I/O의 중요성은 프로그램을 쉽게 연결할 수 있고, 한 프로그램의 표준 출력이 다른 프로그램의 표준 입력이 될 수 있다는 것입니다. 🎜

  8 새로운 I/O

  🎜운영 체제가 I/O를 수행하는 방식에 더 가까운 구조를 사용하면 속도가 향상됩니다. 채널 및 버퍼. 탄광처럼 생각할 수 있는데, 채널은 석탄층(데이터)이 포함된 광상이고, 버퍼는 광상으로 파견되는 트럭입니다. 트럭은 석탄을 싣고 돌아오고 우리는 트럭에서 석탄을 가져옵니다. 즉, 채널과 직접 상호작용하지 않고 단지 버퍼와 상호작용하고 버퍼를 채널에 전달합니다. 채널은 버퍼에서 데이터를 가져오거나 데이터를 버퍼로 보냅니다. 🎜🎜채널과 직접 상호작용하는 유일한 버퍼는 ByteBuffer입니다. 즉, 원시 바이트 버퍼를 저장할 수 있습니다. . java.nio.ByteBuffer에 대한 JDK 문서를 쿼리하면 이것이 상당히 기본적인 클래스라는 것을 알 수 있습니다. 원시 바이트 형식이나 기본 데이터 유형으로 데이터를 출력하고 읽는 방법도 선택할 수 있습니다. 그러나 문자열 객체는 물론 객체를 출력하거나 읽을 수 있는 방법이 없습니다. 이 처리는 낮은 수준이지만 대부분의 운영 체제에서 매핑하는 더 효율적인 방법이기 때문에 딱 맞습니다. 🎜

  8.1 채널 FileChannel

  🎜  FileChannel은 바이트 스트림 조작입니다. . FileChannel을 생성하도록 이전 I/O 클래스 라이브러리의 세 가지 클래스가 수정되었습니다.🎜
  • 🎜FileInputStream.getChannel()🎜< /li >
  • 🎜FileOutputSteam.getChannel()🎜
  • 🎜RandomAccessFile.getChannel()🎜

  package net.mrliuli.io.nio;
  
  import java.io.*;
  import java.nio.*;
  import java.nio.channels.*;public class ChannelCopy {    private static final int BSIZE = 1024;    public static void main(String[] args) throws Exception {        if(args.length != 2){
              System.out.println("arguments : sourcefile destfile");
              System.exit(1);
          }        // 打开一个FileChaanel用于读（输入）
          FileChannel in = new FileInputStream(args[0]).getChannel();        // 打开一个FileChannel用于写（输出）
          FileChannel out = new FileOutputStream(args[1]).getChannel();        // 一个缓冲器，分配了BSIZE个字节
          ByteBuffer buffer = ByteBuffer.allocate(BSIZE);        /*
           * return The number of bytes read, possibly zero, or <tt>-1</tt> if the channel has reached end-of-stream
           * FileChanel.read()
           * */
  
          // -1 一个分界符（源于Unix和C），表示到达了输入的末尾
          while(in.read(buffer) != -1){
  
              buffer.flip(); // Prepare for writing
              out.write(buffer);            // write()操作之后，信息仍在缓冲器中，clear()操作对所有的内部指针重新安排，以便缓冲器在另一个read()操作期间能够做好接受数据的准备。
              buffer.clear(); // Prepare for reading
          }
  
      }
  
  }

  8.2 Buffer ByteBuffer

  🎜 　　　　　저장 방법 버퍼 ByteBuffer의 섹션: 🎜
  • 🎜 put()직접 채우기 , 하나 이상의 바이트 또는 기본 데이터 유형의 값을 입력하세요. 🎜
  • 🎜 wrap() 기존 바이트 배열을 ByteBuffer에 압축합니다. 🎜

  8.3 read(), write(), Flip(), write()

  🎜  입력 채널 in과 출력 채널이 있습니다 out 및 버퍼 buffer:🎜
  • 🎜 in.read(buffer); fc에 있는 바이트를 buffer에 입력합니다. 이때 buffer.flip();다른 사람들이 버퍼에서 바이트를 읽을 수 있도록 준비하세요. 🎜
  • 🎜out.write(buffer) buffer의 바이트를 code>out, write() 작업 후에도 정보는 여전히 buffer 버퍼에 있으며 는 반드시 buffer.clear();이라고 합니다. 다른 read() 작업 중에 버퍼가 데이터를 받아들일 준비가 되도록 모든 내부 포인터를 다시 정렬합니다. 🎜

  package net.mrliuli.io.nio;
  
  import java.io.*;
  import java.nio.*;
  import java.nio.channels.*;public class ChannelCopy {    private static final int BSIZE = 1024;    public static void main(String[] args) throws Exception {        if(args.length != 2){
              System.out.println("arguments : sourcefile destfile");
              System.exit(1);
          }        // 打开一个FileChaanel用于读（输入）
          FileChannel in = new FileInputStream(args[0]).getChannel();        // 打开一个FileChannel用于写（输出）
          FileChannel out = new FileOutputStream(args[1]).getChannel();        // 一个缓冲器，分配了BSIZE个字节
          ByteBuffer buffer = ByteBuffer.allocate(BSIZE);        /*
           * return The number of bytes read, possibly zero, or <tt>-1</tt> if the channel has reached end-of-stream
           * FileChanel.read()
           * */
  
          // -1 一个分界符（源于Unix和C），表示到达了输入的末尾
          while(in.read(buffer) != -1){
  
              buffer.flip(); // Prepare for writing
              out.write(buffer);            // write()操作之后，信息仍在缓冲器中，clear()操作对所有的内部指针重新安排，以便缓冲器在另一个read()操作期间能够做好接受数据的准备。
              buffer.clear(); // Prepare for reading
          }
  
      }
  
  }

  8.4 转换数据

  缓冲器容纳的是普通的字节，为了把它们转换成字符，我们要么在输入它们的时候对其进行编码（这样，它们输出时才具有意义），要么在将其从缓冲器输出时对它们进行解码。可以使用java.nio.charset.Charset类实现这些功能，该类提供子把数据编码成多种不同类型的字符集的工具。The buffer contains plain bytes, and to turn these into characters, we must either encode them as we put them in (so that they will be meaningful when they come out) or decode them as they come out of the buffer. This can be accomplished using the java.nio.charset.Charset class, which provides tools for encoding into many different types of character set.

  8.5 视图缓冲器

    视图缓冲器（view buffer）可以让我们通过某个特定的基本数据类型的视窗查看其底层的ByteBuffer。ByteBuffer依然是实际存储数据的地方，“支持”着前面的视图，因此对视图的任何修改都会映射成为对ByteBuffer中数据的修改。

  8.6 文件加锁

    文件加锁对其他的操作系统进程是可见的，因为Java的文件加锁直接映射到了本地操作系统的加锁工具。

  exclusive lock 独占锁

  Locking portions of a mapped file 对映射文件的部分加锁

  cretical section 临界区

  9 压缩（Compression）

  10 对象序列化（Object serialization）

  Java的对象序列化将那些实现了Serilizable接口的对象转换成一个字节序列，并能够在以后将这个字节序列完全恢复为原来的对象。这一过程甚至可通过网络朝廷这意味着序列化机制能自动弥补不同操作系统之间的差异。

  就其本身来说，对象的序列化是非常有趣的，因为利用它可以实现轻量级持久性（ligthweight persistence）。持久性意味着一个对象的生存周期并不取决于程序是否正在执行，它可以生存于程序的调用之间。

    对象序列化的概念加入到语言中是为了支持两种主要特性：

  • 一是Java的远程方法调用（Remote Method Invocation, RMI），它使存活于其他计算机的对象使用起来就像是存活于本机上一样。当向远程对象发送消息时，需要通过对象序列化来传输参数和返回值。

  • 再者，对Java Beans来说，对象的序列化也是必需的。使用一个Bean时，一般情况下是在设计阶段对它的状态信息进行配置。这种状态信息必须保存下来，并在程序启动时进行后期恢复；这种具体工作就是由对象序列化完成的。

    序列化一个对象和反序列化：

  • 首先要创建一个ObjectOutputStream对象，要通过构造函数含有一个 OutputStream 对象。

  • 然后，只需调用 void writeObject(Object obj)，即可将对象obj序列化，即转换成字节序列输出到第一步所说的Outputstream。

  • 反序列化，即将字节序列还原为一个对象，则只需调用ObjectInputStream的Object readObject()，输入到一个InputStream。

  例：

  Worm.java

  10.1 寻找类

    反序列，即将字节序列还原为对象时，必须保证Java虚拟机能够找到要还原的对象的相关.class文件，否则抛出java.lang.ClassNotFoundException异常。

  10.2 序列化的控制

    如果只希望一个对象的某些信息序列化而某些信息不序列化，即进行序列化控制，可使用Externalizable接口。

  10.2.1 Externalizable接口

    Externalizable接口继承自Serializable接口，有两个方法如下，这两个方法会在序列化和反序列化过程中被自动调用。

  • void writeExternal(ObjectOutput obj)，在该方法内部只对所需部分进行显式序列化。

  • void readExternal(ObjectInput in)

  10.2.2 Externalizable接口与Serializable接口区别

  • Externalizable只序列化writeExternal()中的部分，而Serializable自动地全部序列化。

  • Externalizable在反序列化时（即调用readObject()时），会首先调用所有普通的默认构造器，然后调用readExternal()。

  • Serializable在反序列化时，对象完全以它存储的二进制位为基础来构造，而不用调用构造器。

  例：

  Blips.javaBlip3.java

  10.2.3 transient（瞬时）关键字

  如果我们正操作的是一个Serializable对象，那么所有序列化操作都会自动进行。为了能够予以控制，可以用transient（瞬时）关键字逐个字段地关闭序列化，它的意思是“不用麻烦你保存或恢复数据——我会自己处理的”。

  由于Externalizable对象在默认情况下不保存任何字段，所以transient关键字只能和Serializable对象一起使用。

  10.3 序列化的持久性

  我们可以通过一个字节数组来使用对象序列化，从而实现对任何可Serializable对象的“深度复制”（deep copy）——深度复制意味着我们复制的是整个对象网，而不仅仅是基本对象及其引用。

  • 一个对象被序列化在单一流中，就可以恢复出与我们写出时一样的对象网，并且没有任何意外重复复制出的对象。

  • 一个对象被序列化在不同流中，再从不同流恢复时，得到的对象地址不同。

  例：

  MyWorld.java

  对象序列化的一个重要限制是它只是Java的解决方案：只有Java程序才能反序列化这种对象。一种更具互操作性的解决方案是将数据转换为XML格式，这可以使其被各种各样的平台语言使用。

  相关文章：

  Java编程思想学习课时（三）第15章-泛型

  Java编程思想学习课时（四）第17章-容器深入探讨

  위 내용은 자바 프로그래밍 사고 학습 수업(5) 18장 - 자바 IO 시스템의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!