Java的输入输出流（FileInput/OutputStream）操作文件

偏执的太偏执、 2022-02-13 08:51 350阅读 0赞

**目录直通车**

1、流的分类

2、IO流的体系

3、 JDK1.8中FileInput/OutputStream的方法

（1）FileInputStream

① 使用read()的实例

② \* 使用read（byte\[ \]）的实例

（2）FileOutputStream

（3）标准输出流使用的四部曲

（4）总结实例

--------------------

# 1、流的分类 #

（1）按照数据流向的不同，输入流（把文件的内容读取到程序中）、输出流。

（2）按照处理数据的单位的不同。字节流 字符流（处理文本文件）。

（3）按照角色的不同，节点流（8 bit, 直接作用于文件上的）处理流(16 bit)。

# 2、IO流的体系 #

在JDK6中就已经有了从Input/Output中派生出来的40多个类了，所以学习FileInput/OutputStream才是核心。

<table style="width:613px;"> 
 <tbody> 
  <tr> 
   <td> <p><strong>抽象基类</strong></p> </td> 
   <td> <p><strong>节点流（文件流）</strong></p> </td> 
  </tr> 
  <tr> 
   <td> <p>InputStream</p> </td> 
   <td> <p>FileInputStream</p> </td> 
  </tr> 
  <tr> 
   <td> <p>OutputStream</p> </td> 
   <td> <p>FileOutputStream</p> </td> 
  </tr> 
  <tr> 
   <td> <p>Reader</p> </td> 
   <td> <p>FileReader</p> </td> 
  </tr> 
  <tr> 
   <td> <p>Writer</p> </td> 
   <td> <p>FileWriter</p> </td> 
  </tr> 
 </tbody> 
</table>

#  3、 JDK1.8中FileInput/OutputStream的方法 #

## （1）FileInputStream ##

read()方法在开发中的执行效率有点低，所以在开发中常用的是**read(byte \[ \] )**这个数组

<table style="width:671px;"> 
 <tbody> 
  <tr> 
   <th style="width:132px;">修饰类型</th> 
   <th style="width:366px;">方法与描述</th> 
  </tr> 
  <tr> 
   <td style="width:132px;"><code>int</code></td> 
   <td style="width:366px;"><code><a rel="nofollow">available</a>()</code> <p>返回从该输入流中可以读取（或跳过）的字节数的估计值，而不会被下一次调用此输入流的方法阻塞。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:132px;"><code>void</code></td> 
   <td style="width:366px;"><code><a rel="nofollow">close</a>()</code> <p>关闭此输入流并释放与流相关联的任何系统资源。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:132px;"><code>void</code></td> 
   <td style="width:366px;"><code><a rel="nofollow">mark</a>(int&nbsp;readlimit)</code> <p>标记此输入流中的当前位置。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:132px;"><code>boolean</code></td> 
   <td style="width:366px;"><code><a rel="nofollow">markSupported</a>()</code> <p>测试这个输入流是否支持 <code>mark</code>和 <code>reset</code>方法。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:132px;"><code>abstract int</code></td> 
   <td style="width:366px;"><code><a rel="nofollow">read</a>()</code> <p>从输入流读取数据的下一个字节。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:132px;"><code>int</code></td> 
   <td style="width:366px;"><code><a rel="nofollow">read</a>(byte[]&nbsp;b)</code> <p>从输入流读取一些字节数，并将它们存储到缓冲区 <code>b</code> 。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:132px;"><code>int</code></td> 
   <td style="width:366px;"><code><a rel="nofollow">read</a>(byte[]&nbsp;b, int&nbsp;off, int&nbsp;len)</code> <p>从输入流读取最多 <code>len</code>字节的数据到一个字节数组。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:132px;"><code>void</code></td> 
   <td style="width:366px;"><code><a rel="nofollow">reset</a>()</code> <p>将此流重新定位到上次在此输入流上调用 <code>mark</code>方法时的位置。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:132px;"><code>long</code></td> 
   <td style="width:366px;"><code><a rel="nofollow">skip</a>(long&nbsp;n)</code> <p>跳过并丢弃来自此输入流的 <code>n</code>字节数据。</p> </td> 
  </tr> 
 </tbody> 
</table>

# #

### ① 使用read()的实例 ###

读取HelloWorld.txt中的HelloWorld字符串。初学者要注意我在代码中关闭流的方式！

import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    
    
    public class TestFileInputOutputStream {
        private static final String pathname = "./src/IOStream/HelloWorld.txt";
    
        
        public static void TestFileInputStream() {
            // 1. 创建一个File类的对象
            File inputFile = new File(pathname);
            FileInputStream is = null;
            try {
                if (!inputFile.exists()) {
                    inputFile.createNewFile();
                }
                // 2. 创建一个FileInputStream
                is = new FileInputStream(inputFile);
                // read()读取文件的一个字节
                // 3. 读取文件的流
                int readByte;
                // 读到文件结尾的时候就直接返回-1
                while ((readByte = is.read()) != -1) {
                    System.out.println(readByte);
                    // 不能读取中文
                    System.out.println((char) readByte);
                    readByte = is.read();
                }
                System.out.println(readByte);
    //            is.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    // 4.关闭流
                    // 写在finally里面处理的原因是因为 流 是一种稀有资源，是非常占用内存的
                    // 如果不关闭会造成资源浪费，如果写在上面的try catch里面，一旦read()发生
                    // 异常，程序就停止了，不会再往下执行到上面我注释的close()了。
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) {
            TestFileInputStream();
        }
    }

### ② \* 使用read（byte\[ \]）的实例 ###

import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    public class TestFileInputOutputStream {
        private static final String pathname = "./src/IOStream/HelloWorld.txt";
    
    
      
    
        public static void TestFileInputStream2() {
            File file = new File(pathname);
            FileInputStream fis;
            try {
                fis = new FileInputStream(file);
                byte[] bytes = new byte[20];
                try {
                    // len表示读取字符串的长度
                    // 这里切记不能使用 bytes.length，尝试一波你就会发现结果不对了
                    int len;
                    while ((len = fis.read(bytes)) != -1) {
                        System.out.println("length: " + len);
                        // 第一种遍历方式
                        for (byte o : bytes) {
                            System.out.print((char) o);
                        }
                        // 第二种遍历方式
                        // 将byte数组转换成字符串，第二个参数是从哪里开始，第三个参数是len
                        String str = new String(bytes,0,len);
                        System.out.println(str);
                    }
    
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    if (fis != null)
                    try {
                        // 预防空指针异常
                            fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
    
        }
    
        public static void main(String[] args) {
            TestFileInputStream2();
        }
    }

## （2）FileOutputStream ##

<table style="width:683px;"> 
 <tbody> 
  <tr> 
   <th style="width:132px;">修饰类型</th> 
   <th style="width:366px;">方法与描述</th> 
  </tr> 
  <tr> 
   <td><code>void</code></td> 
   <td><code><a rel="nofollow">close</a>()</code> <p>关闭此输出流并释放与此流相关联的任何系统资源。</p> </td> 
  </tr> 
  <tr> 
   <td><code>void</code></td> 
   <td><code><a rel="nofollow">flush</a>()</code> <p>刷新此输出流并强制任何缓冲的输出字节被写出。</p> </td> 
  </tr> 
  <tr> 
   <td><code>void</code></td> 
   <td><code><a rel="nofollow">write</a>(byte[]&nbsp;b)</code> <p>将 <code>b.length</code>字节从指定的字节数组写入此输出流。</p> </td> 
  </tr> 
  <tr> 
   <td><code>void</code></td> 
   <td><code><a rel="nofollow">write</a>(byte[]&nbsp;b, int&nbsp;off, int&nbsp;len)</code> <p>从指定的字节数组写入 <code>len</code>个字节，从偏移 <code>off</code>开始输出到此输出流。</p> </td> 
  </tr> 
  <tr> 
   <td><code>abstract void</code></td> 
   <td><code><a rel="nofollow">write</a>(int&nbsp;b)</code> <p>将指定的字节写入此输出流。</p> </td> 
  </tr> 
 </tbody> 
</table>

### 标准输出流使用的四部曲 ###

private static final String pathname = "./src/IOStream/HelloWorld.txt";
    public static void testFileOutputStream() {
            // 1.表明写入的文件
            File file = new File(pathname);
            // 2.创建FileOutputStream对象，将file传给构造器
            FileOutputStream fos = null;
            byte[] bytes = new byte[20];
            try {
                String writeStr = "Auh!Today is good day!";
                // 字符串转 byte[]
                bytes = writeStr.getBytes();
                // 构造器1：默认覆盖全部写入文件中的全部字符串
    //            fos = new FileOutputStream(file);
                // 构造器2：如果第二个参数是true ，则字节将被写入文件的末尾而不是开头
                 fos = new FileOutputStream(file,true);
                try {
                    // 3.写入文件
                    fos.write(bytes);
                    System.out.println("写入成功！");
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } finally {
                if (fos != null)
                    try {
                        // 4.关闭输出流
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
            }
        }

## 总结实例 ##

从一个文件里面读取，输出到另一个文件。

private static final String pathname = "./src/IOStream/HelloWorld.txt";
    private static final String newPathName = "./src/IOStream/newFile.txt";
    public static void testFileOutputStream2(){
    
            File file1 = new File(pathname);
            File file2 = new File(newPathName);
    
            FileInputStream fis = null;
            FileOutputStream fos = null;
    
            byte[] readStr = new byte[20];
            try {
                fis= new FileInputStream(file1);
                fos= new FileOutputStream(file2);
                int len;
                try {
                   while((len = fis.read(readStr)) != -1){
                       // 错误写法
                       // fos.write(readStr,0,readStr.length;
                        fos.write(readStr,0,len);
                   }
    
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    // 先关输出的流
                    if ( fos != null){
                        try {
                            fos.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    // 出现异常下面输入流仍然能够关闭
                    if (fis != null){
                        try {
                            fis.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    
                    System.out.println("Complete!");
                }
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

我在使用的过程中最关注的是：

1、 一定要关闭流，流是稀有资源是很占内存的！

2、 定义byte数组的大小一定要根据文件的大小来定（1 kb = 1024 byte）。