Java 如何关闭IOs？

当我管理IO时，我发现了一个问题。我过去常常这样关闭它：

try {
        // my code
    } catch (Exception e) {
        // my code
    } finally{
        if (is != null) {
            is.close();
        }
    }

try {
    // my code
} catch (Exception e) {
    // my code
} finally{
    if (is1 != null) {
        is1.close();
    }
    if(is2 != null{
        is2.close();
    }
    // many IOs
}

但是close方法也会抛出异常。如果我有多个IO，我必须关闭所有IO。所以代码可能是这样的：

try {
        // my code
    } catch (Exception e) {
        // my code
    } finally{
        if (is != null) {
            is.close();
        }
    }

try {
    // my code
} catch (Exception e) {
    // my code
} finally{
    if (is1 != null) {
        is1.close();
    }
    if(is2 != null{
        is2.close();
    }
    // many IOs
}

---

如果is1.close（）抛出异常，则is2、is3不会自行关闭。因此，我必须输入许多尝试捕捉最终控制他们。有其他方法解决这个问题吗？

我使用这个小小的静态实用程序类，其原理是，如果你真的必须在处理错误时做一些（任何）详细的事情，或者最终阻塞，那么至少把它撕下来并实现一次，而不是把你的应用程序代码从手头的任务中分散注意力：

package krc.utilz.io;

import java.io.Closeable;
import krc.utilz.reflectionz.Invoker;

public abstract class Clozer
{
  /**
   * close these "streams"
   * @param Closeable... "streams" to close.
   */
  public static void close(Closeable... streams) {
    Exception x = null;
    for(Closeable stream : streams) {
      if(stream==null) continue;
      try {
        stream.close();
      } catch (Exception e) {
        if(x!=null)x.printStackTrace();
        x = e;
      }
    }
    if(x!=null) throw new RuntimeIOException(x.getMessage(), x);
  }

  /**
   * Close all the given objects, regardless of any errors.
   * <ul>
   * <li>If a given object exposes a close method then it will be called. 
   * <li>If a given object does NOT expose a close method then a warning is 
   *   printed to stderr, and that object is otherwise ignored.
   * <li>If any invocation of object.close() throws an IOException then
   *     <ul>
   *     <li>we immediately printStackTrace
   *     <li>we continue to close all given objects
   *     <li>then at the end we throw an unchecked RuntimeIOException
   *     </ul>
   * </ul>
   * @param Object... objects to close.
   */
  public static void close(Object... objects) {
    Exception x = null;
    for(Object object : objects) {
      if(object==null) continue;
      try {
        Invoker.invoke(object, "close", new Object[]{} );
      } catch (NoSuchMethodException eaten) {
        // do nothing
      } catch (Exception e) {
        e.printStackTrace();
        x = e;
      }
    }
    if(x!=null) throw new RuntimeIOException(x.getMessage(), x);
  }

}

包krc.utilz.io；
导入java.io.Closeable；
导入krc.utilz.reflectionz.Invoker；
公共抽象类Clozer
{
/**
*关闭这些“流”
*@param Closeable…“streams”关闭。
*/
公共静态无效关闭（可关闭…流）{
异常x=null；
用于（可关闭流：流）{
如果（stream==null）继续；
试一试{
stream.close（）；
}捕获（例外e）{
如果（x！=null）x.printStackTrace（）；
x=e；
}
}
如果（x！=null）抛出新的RuntimeIOException（x.getMessage（），x）；
}
/**
*关闭所有给定的对象，而不考虑任何错误。
*

*
如果给定对象公开close方法，则将调用它。
*
如果给定对象未公开close方法，则会发出警告
*打印到stderr，否则将忽略该对象。
*
如果对object.close（）的任何调用引发IOException，则
*

*
我们立即打印StackTrace
*
我们继续关闭所有给定对象
*
然后在最后抛出一个未经检查的RuntimeIOException
*
*
*@param Object…要关闭的对象。
*/
公共静态无效关闭（对象…对象）{
异常x=null；
用于（对象：对象）{
如果（object==null）继续；
试一试{
Invoker.invoke（对象，“关闭”，新对象[]{}）；
}渔获物（无食用）{
//无所事事
}捕获（例外e）{
e、 printStackTrace（）；
x=e；
}
}
如果（x！=null）抛出新的RuntimeIOException（x.getMessage（），x）；
}
}

请注意，与常见的

try{stream1.close（）；}catch{}try{stream2.close（）；}catch{}

cop out不同，最后一个close异常（如果有）仍然被抛出

---

干杯。Keith.

您可以使用Apache中的

closequity（…）

方法，而不是重新发明轮子。这些方法挤压从

close（）

发出的任何

IOException

，并处理参数为

null

的情况

---

您应该注意的唯一一点是，您不会在包含未刷新数据的输出流上调用它。如果你这么做了，冲水失败了，你就不会知道了。如果您正在写入的数据很重要，不知道刷新失败将是一件坏事。

引发了什么异常？可能重复的

for（Closeable stream:streams）

----streams是一个IOs数组？如果是的话！如何声明IOs数组？