谈谈Java中的IO流

Dear 丶 2024-03-24 09:07 73阅读 0赞

## Java中的File类 ##

在Java中，`File`类是对文件和文件夹的抽象，因此可以用一个`File`实例来表示一个文件或者文件夹。如在`E:\java-io-file\cat.txt`文件夹中存在`cat.txt`文件。，

![format_png][]

如下代码就能看见Java对文件和文件夹的抽象，便可以使用封装好的API得到一些文件信息。

public static void main(String[] args) {
        File diction = new File("E:\java-io-file");
        System.out.println(diction.isDirectory()); // true
        File file = new File("E:\java-io-file\cat.txt");
        System.out.println(file.isDirectory()); // false
        System.out.println(file.isFile()); // true
    }
    复制代码

### `File`类常见的api ###

> //获取类功能
> 
>  *  public String getAbsolutePath(); //获取绝对路径
>  *  public String getPath(); //获取相对路径
>  *  public String getName(); //获取文件名
>  *  public String getParent(); //获取上级目录
>  *  public int length(); //长度 字节
>  *  public long lastModeified(); //最后一次修改的时间 //以下适用于文件目录
>  *  public String \[\] list(); //获取指定路径下的文件或者文件目录的目录名称数组
>  *  public File\[\] listFiles();//获取指定目录下的所有文件或文件目录的File数组  
>     //file1.renameTo(file2) file1必须存在，file2不能存在 才能返回true
>  *  public boolean renameTo(); //File 类 判断
>  *  public boolean isDirectory();
>  *  public boolean isFile();
>  *  public boolean exists();
>  *  public boolean canRead();
>  *  public boolean canWrite();
>  *  public boolean isHidden(); //File 创建
>  *  public boolean createNewFile(); //创建文件
>  *  public boolean mkdir(); //创建文件目录 如果上级目录不存在 则不创建
>  *  public boolean mkdirs(); //创建文件目录 如果上级目录不存在，则一起创建。
>  *  public boolean delete();//删除 不走回收站

### 递归访问文件和文件夹的实现 ###

在有了上述基本的认识之后，就可以利用这些知识做到递归访问文件

// recursiveVisitedFiles("E:\springboot-websocket");
    public void recursiveVisitedFiles(String path){
        File root = new File(path);
        if (root.isDirectory()){
            System.out.println("directoryName = "+root.getName());
            File[] subFiles = root.listFiles();
            for (File file : subFiles){
                recursiveVisitedFiles(file.getAbsolutePath());
            }
        }else {
            System.out.println("fileName = " + root.getName());
        }
    }
    复制代码

得到如下输出

![format_png 1][]

`File`类中值得注意的是

> `delete()`: 由于Java是把文件和文件夹都抽象为一个File实例，因此在调用该方法删除文件夹时，需要保证文件夹为为空时，才能正确删除，否则返回`false`.

## 传统的流式IO ##

在`Java1.4`以前，Java中设计的IO比较复杂。Java的IO流设计屏蔽了实际的i/o设备中处理的细节，其原则如下

>  *  字节流对应原生的二进制数据。
>  *  字符流对应字符数据，自动处理与本地字符集之间的转换。
>  *  缓冲流可以提高读写性能，通过减少底层`API`的次数来优化IO。

### 设计原则 ###

在JDK1.0时，所有与输入有关系的类都继承于`InputStream` , 所有与输出相关的类都继承自`OutputStream`。Java1.1 对基本的IO流类库做了很多的修改，添加了很多以`Reader/writer`为基类的衍生类，`Reader和Writer`的继承体系主要是为了国际化。旧的IO继承体系仅支持8bit的字节流，不能够很好的处理16bit的Unicode字符。

所有`InputStream/reader`派生而来的类都含有`read()`方法，用来读取单个字节或者字节数组。

所有`OutputStream/Writer`派生而来的类都含有`write()`方法，用来写单个字节或者字节数组。

字节流可以操作所有类型的文件。

>  *  read()方法可以读取单个字节(字符)也可以读取多个字节(字符)，读取单个字节(字符)时，返回的是当前字节，
>  *  read(array)时，返回的是读取的字节(字符)数
>  *  \-1 都表示读到文件末尾, 读完了整个文件。

### 输入流和输出流 ###

> `InputStream/OutputStream`基于字节流的。

`InputStream`作为输入流，是从`外部`获取数据到内存中，因此输入流类型有

<table> 
 <thead> 
  <tr> 
   <th>类</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>ByteArrayInputStream</code></td> 
   <td>允许将内存的缓冲区当做<code>InputStream</code></td> 
  </tr> 
  <tr> 
   <td><code>StringBufferInputStream</code></td> 
   <td>将<code>String</code>转化成<code>InputStream</code></td> 
  </tr> 
  <tr> 
   <td><code>FileInputStream</code></td> 
   <td>从文件中读取信息</td> 
  </tr> 
  <tr> 
   <td><code>PipedInputStream</code></td> 
   <td>产生用于写入相关 <code>PipedOutputStream</code> 的数据。</td> 
  </tr> 
  <tr> 
   <td><code>SequenceInputStream</code></td> 
   <td>将两个或多个 <code>InputStream</code> 对象转换成一个 <code>InputStream</code></td> 
  </tr> 
 </tbody> 
</table>

`OutputStream`做为输出流，该类别的类主要决定输出到哪里：文件，字节数组等

<table> 
 <thead> 
  <tr> 
   <th>类</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>ByteArrayOutputStream</code></td> 
   <td>在内存中创建缓冲区，所有送往<code>流</code>的数据都要放置在此缓冲区。</td> 
  </tr> 
  <tr> 
   <td><code>FileOutputStream</code></td> 
   <td>用于将信息写入文件</td> 
  </tr> 
  <tr> 
   <td><code>PipedOutputStream</code></td> 
   <td>任何写入其中的信息都会自动作为相关 <code>PipedInputStream</code> 的输出</td> 
  </tr> 
 </tbody> 
</table>

以字节流演示：复制文件

// String source = "E:\java-io-file\cat.png";
    // String dest1 = "E:\java-io-file\cat1.png";;
    // copyFileWithStream(source,dest1);
    public void copyFileWithStream(String source,String dest){
        File sourceFile = new File(source);
        File destFile = new File(dest);
    
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(sourceFile);
            fos = new FileOutputStream(destFile);
            int len = 0;
            byte[] bytes = new byte[1024];
            while ((len = fis.read(bytes)) != -1){
                fos.write(bytes,0,len);
            }
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        fos.close();
        fis.close();
    }
    复制代码

复制结果如下：

![format_png 2][]

### 字符流Writer和Reader ###

> 字符流主要针对的是**文本**文件，如果使用字符流进行图片的复制，则会导致复制生成的文件打不开!

字符流的引入主要是主要是为了国际化`Unicode`, 旧的IO流不能够很好的处理16bit的字符。新的类库的IO操作比旧类库要快。

除此之外，有时候也可以将面向字节流的操作转换为面向字符流的操作如以下

<table> 
 <thead> 
  <tr> 
   <th>字节流</th> 
   <th>字符流适配</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>InputStream</td> 
   <td>InputStreamReader</td> 
  </tr> 
  <tr> 
   <td>OutputStream</td> 
   <td>OutputStreamWriter</td> 
  </tr> 
  <tr> 
   <td>FileInputStream</td> 
   <td>FileReader</td> 
  </tr> 
  <tr> 
   <td>FileOutputStream</td> 
   <td>FileWriter</td> 
  </tr> 
  <tr> 
   <td>ByteArrayInputStream</td> 
   <td>CharArrayReader</td> 
  </tr> 
  <tr> 
   <td>ByteArrayOutputStream</td> 
   <td>CharArrayWriter</td> 
  </tr> 
 </tbody> 
</table>

> 还有很多其他的列别，未列举全，请参考JDK相关文档

以字符流为例：演示复制文本文件

//  copyFileWithChar("E:\java-io-file\cat.txt","E:\java-io-file\cat_.txt");
    public void  copyFileWithChar(String source,String dest){
        try {
            FileReader reader = new FileReader(source);
            FileWriter fileWriter = new FileWriter(dest);
            int len = 0;
            char[] chars = new char[1024];
            while ((len = reader.read(chars)) != -1){
                fileWriter.write(chars,0,len);
            }
            fileWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    复制代码

演示结果如下：

![format_png 3][]

### 缓冲流 ###

为了IO流的操作速度，Java提供了缓冲流。缓冲流作用于已有流的基础上如`FileInputStream/FileReader`

<table> 
 <thead> 
  <tr> 
   <th>缓冲流</th> 
   <th>被缓冲的流</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>BufferedReader</td> 
   <td>FileReader</td> 
  </tr> 
  <tr> 
   <td>BufferefWriter</td> 
   <td>BufferedWriter</td> 
  </tr> 
  <tr> 
   <td>BufferedInputStream</td> 
   <td>FileInputStream</td> 
  </tr> 
  <tr> 
   <td>BufferedOutputStream</td> 
   <td>FileOutputStream</td> 
  </tr> 
 </tbody> 
</table>

同样以复制图片为例、

// String dest3 = "E:\java-io-file\cat3.png";
    // String source = "E:\java-io-file\cat.png";
    // copyFileWithBufferStream(source,dest3);
    public void copyFileWithBufferStream(String source, String dest) {
        try (FileInputStream fis = new FileInputStream(source);
             FileOutputStream fos = new FileOutputStream(dest);
             BufferedInputStream bis = new BufferedInputStream(fis);
             BufferedOutputStream bos = new BufferedOutputStream(fos)) {
            int len = 0;
            byte[] chars = new byte[1024];
    
            while ((len = bis.read(chars)) != -1) {
                bos.write(chars, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    复制代码

![format_png 4][]

### 其他流 ###

**RandomAccessFile类**:

> `RandomAccessFile` 适用于由大小已知的记录组成的文件，所以我们可以使用 `seek()` 将文件指针从一条记录移动到另一条记录，然后对记录进行读取和修改。用得不多。
> 
>  *  直接继承java.lang.Object类 实现了DataInput， DataOutput接口
>  *  即可输入也可输出

**ObjectOutputStream / ObjectInputStream**

> 前者将Java对象序列化到磁盘中或者通过网络传出去，后者将前者转换为Java对象
> 
> 需要说明的是：
> 
>  *  必须实现Serializable接口
>  *  类的所有属性属性必须可序列化，默认情况下基本数据类型是可序列化的。
>  *  提供静态常量 serialVersionUID；

## 标准流 ##

> 程序的所有输入都可以来自于标准输入，程序的所有输出都可以流向标准输出，程序的所有错误都可以发送到标准错误。

Java提供以下标准流

>  *  `System.in`: 标准输入流
>  *  `System.out`: 标准输出流
>  *  `System.err`: 标准错误

标准输出流和标准错误流已经被预先包装为`PrintStream`对象，因此可以直接使用，而标准输入流是原生的`InputStream`，所以在读取标准输入流的内容时，需要将其转换包装为其他流。

// System源码
    public static final InputStream in = null;
    public static final PrintStream out = null;
    public static final PrintStream err = null;
    复制代码

标准输入流结合`Scanner`读取用户输入：

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("准备输入");
        do {
            String next = scanner.next();
            System.out.println("读取用户输入："+next);
        } while (scanner.hasNext());
        scanner.close();
    }
    复制代码

![format_png 5][]

注：`Scanner.next()`默认以空格分隔.

## NIO ##

> NIO是Java1.4引入的，以同步非阻塞的方式重写了老的IO。

在此之前，我们处理IO的方式基本上都是以字节或者字符。如`InputStream/OutputStream`或者`FileReader/FileWriter`体系，在`NIO`中不需要这么底层的操作。通常是和各种Buffer对象，如

>  *  ByteBuffer: 字节缓冲区
>  *  DoubleBuffer
>  *  ShortBuffer
>  *  LongBuffer
>  *  IntBuffer
>  *  FloatBuffer
>  *  CharBuffer

`xxxBuffer`对象都是都相应类型的一个封装，在上面所列举的对象中，主要使用的是`ByteBuffer`对象。

nio中使用了更接近操作系统IO执行方式的结构:`Channel和Buffer`只有上述的这一类型可直接与`Channel`通道交互。

而旧IO中的`FileInputStream、FileOutputStream、RandomAccessFile`被更新成FileChannel。而字符模式的`Writer/Reader`不能生成Channel，但Channel相关的类具有生成Reader和Writer的方法

public void bufferTest() {
        try {
            FileChannel out = new FileOutputStream("data.txt").getChannel();
            FileChannel in = new FileInputStream("data.txt").getChannel();
            out.write(ByteBuffer.wrap("Yierisacat".getBytes())); // 生成data.txt 文件内容是Yierisacat
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            in.read(buffer);
            buffer.flip();
            while (buffer.hasRemaining())
                System.out.write(buffer.get()); // output: Yierisacat
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    复制代码

注：Java NIO 的ByteBuffer API内容较多且设计得比较复杂，这里只是简单提及一下。

## Files和Paths类的使用 ##

通过前文的简单描述，也能够发现在进行文件IO操作时，需要使用到很多的类，创建很多的对象。Java的设计者为了方便相关操作，引入了Files工具类,对常见的文件操作提供了封装方法，如创建、删除、判断文件是否存在，可读可写、遍历等

>  *  Files.createFile()
>  *  Files.createDirectory()
>  *  FIles.createDirectories()
>  *  Files.delete()
>  *  Files.deleteIfExist()
>  *  Files.copy()
>  *  Files.exists()
>  *  Files.walkFileTree()

Files的大多数方法都需要传递一个`Path`对象作为参数，因此在使用之前，需要先把Path对象弄明白。

一个Path对象表示一个文件或者目录的路径，是一个跨操作系统和文件系统的抽象。Java的设计者提供了Paths工具类对相关操作进行了封装。其中提供了一个静态方法用于获取`Path`实例

public static Path get(URI uri) {
        return Path.of(uri);
    }
    public static Path get(String first, String... more) {
        return Path.of(first, more);
    }
    复制代码

`get`方法可以接受一系列`String`字符串或一个统一资源标识符作为参数。返回一个`Path`对象。

`Path`对象封装了对路径的相关操作，如增添，删除部分路径，判断路径以什么开头或者结尾

>  *  getNameCount(),返回路径的个数
>  *  getName(int index): 返回index处的名称
>  *  getRoot()
>  *  getParent()
>  *  startsWith()
>  *  endsWith()

public void testPaths(){
        String p = "E:\java-io-file\cat.png";
        Path path = Paths.get(p);
        System.out.println("getNameCount = "+path.getNameCount());
        System.out.println("getName(1) = "+path.getName(1));
        System.out.println("getRoot = "+ path.getRoot() );
        System.out.println("getParent = "+path.getParent());
        System.out.println("start with [E] ="+ path.startsWith("E"));
        System.out.println("start with [E:] ="+ path.startsWith("E:"));
        System.out.println("start with [E:\] ="+ path.startsWith("E:\"));
        System.out.println("endsWith cat ="+path.endsWith("cat"));
        System.out.println("endsWith .png ="+path.endsWith(".png"));
        System.out.println("endsWith cat.png ="+path.endsWith("cat.png"));
        System.out.println("parent end with [java-o-file] = "+ path.getParent().endsWith("java-o-file"));
        System.out.println("parent end with [java-o-file\] = "+ path.getParent().endsWith("java-io-file\"));
    }
    复制代码

![format_png 6][]

需要说明的是`startWith、endsWith`这两个方法比较的是当前部分路径的全部路径，请注意红色框出的部分。

`Path`接口还提供了`resolve()`方法增添尾路径和`relativize()`将绝对路径转化为相对路径

Path path1 = Paths.get("E:\java-io-file\");
    System.out.println(path1.resolve("gus")); 
    System.out.println("上一级："+path1.resolve("gus").relativize(Paths.get("E:\java-io-file\")));
    System.out.println("同级别："+path1.resolve("gus").relativize(Paths.get("E:\java-io-file\gus\")));
    System.out.println("下一级别："+path1.resolve("gus").relativize(Paths.get("E:\java-io-file\gus\next")));
    复制代码

注：gus文件夹并不存在，`Path`方法很多，其他方法参请看源码。

![format_png 7][]

演示了`Path`的基本API，接下来看一下啊Files循环遍历。

try {
        Files.walkFileTree(Paths.get("E:\BrowserDownLoad\GoogleChromeDownLoad"), new SimpleFileVisitor<>() {
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                System.out.println("进入文件夹 dirName：" + dir.getFileName() + " 之前");
                return super.preVisitDirectory(dir, attrs);
            }
    
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                System.out.println("访问当前文件 fileName = " + file.getFileName());
                return super.visitFile(file, attrs);
            }
    
            @Override
            public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
                System.out.println("访问失败");
                return super.visitFileFailed(file, exc);
            }
    
            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                System.out.println("访问文件夹：" + dir.getFileName() + " 结束");
                return super.postVisitDirectory(dir, exc);
            }
        });
    } catch (IOException e) {
        e.printStackTrace();
    }
    复制代码

部分结果截图如下：

![format_png 8][]

`java.nio.file.SimpleFileVisitor` 提供了所有方法的默认实现。这样，在我们的匿名内部类中，我们只需要重写非标准行为的方法：**visitFile()** 和 **postVisitDirectory()** 实现删除文件和删除目录

## 总结 ##

前文中的传统流式IO也好或者标准IO也罢。在实际工作中都用得不多，毕竟没有那个公司的业务需要你从控制台输入指令或者操作。Java中的文件操作如读取或者删除等操作优先考虑`Files、Paths`相关类的使用。

另外无论是输入流还是输出流，只要明白了输入是从其他地方读入内存，输出是从内存`写`到其他地方。选择什么样的流，或者什么样的API去完成这个过程就简单明了了。

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e3dd5c32035a4a8ba9fb8bbd81d80500.png
[format_png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e4af8f076d574bc2a03a3795ae6d97c9.png
[format_png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/3050dbfc82404270bfaed5d97a3d4a43.png
[format_png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/86198a0e4f2e4e9394e3e75c867ab674.png
[format_png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/c0d5a1b5ee0646699338059c83deb836.png
[format_png 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/b03525a37fea4f489e0ce07fde933eb4.png
[format_png 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/d290817b81c54ef3afc0a7faae5c458d.png
[format_png 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/61827ceb1f41401a84b6ca0d33ae76a0.png
[format_png 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/0d362887bd9d4e4fbf4f404d556d977e.png