IoUtil (hutool 6.0.0-M20 API)

java.lang.Object
- org.dromara.hutool.core.io.NioUtil
- - org.dromara.hutool.core.io.IoUtil

```
public class IoUtil
extends NioUtil
```
IO工具类
IO工具类只是辅助流的读写，并不负责关闭流。原因是流可能被多次读写，读写关闭后容易造成问题。

Author:

Looly

Field Summary
- Fields inherited from class org.dromara.hutool.core.io.NioUtil
  DEFAULT_BUFFER_SIZE, DEFAULT_LARGE_BUFFER_SIZE, DEFAULT_MIDDLE_BUFFER_SIZE, DEFAULT_SMALL_BUFFER_SIZE, EOF

Constructor Summary

Constructors
Constructor and Description

IoUtil()

Constructors
Constructor and Description
`IoUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`closeIfPossible(Object obj)` 尝试关闭指定对象判断对象如果实现了`AutoCloseable`，则调用之
`static void`	`closeQuietly(AutoCloseable... closeables)` 按照给定顺序连续关闭一系列对象这些对象必须按照顺序关闭，否则会出错。
`static boolean`	`contentEquals(InputStream input1, InputStream input2)` 对比两个流内容是否相同内部会转换流为 `BufferedInputStream`
`static boolean`	`contentEquals(Reader input1, Reader input2)` 对比两个Reader的内容是否一致内部会转换流为 `BufferedInputStream`
`static boolean`	`contentEqualsIgnoreEOL(Reader input1, Reader input2)` 对比两个流内容是否相同，忽略EOL字符内部会转换流为 `BufferedInputStream`
`static long`	`copy(FileInputStream in, FileOutputStream out)` 拷贝文件流，使用NIO
`static long`	`copy(InputStream in, OutputStream out)` 拷贝流，使用默认Buffer大小，拷贝后不关闭流
`static long`	`copy(InputStream in, OutputStream out, int bufferSize)` 拷贝流，拷贝后不关闭流
`static long`	`copy(InputStream in, OutputStream out, int bufferSize, long count, StreamProgress streamProgress)` 拷贝流，拷贝后不关闭流
`static long`	`copy(InputStream in, OutputStream out, int bufferSize, StreamProgress streamProgress)` 拷贝流，拷贝后不关闭流
`static long`	`copy(Reader reader, Writer writer)` 将Reader中的内容复制到Writer中使用默认缓存大小，拷贝后不关闭Reader
`static long`	`copy(Reader reader, Writer writer, int bufferSize)` 将Reader中的内容复制到Writer中，拷贝后不关闭Reader
`static long`	`copy(Reader reader, Writer writer, int bufferSize, long count, StreamProgress streamProgress)` 将Reader中的内容复制到Writer中，拷贝后不关闭Reader
`static long`	`copy(Reader reader, Writer writer, int bufferSize, StreamProgress streamProgress)` 将Reader中的内容复制到Writer中，拷贝后不关闭Reader
`static void`	`flush(Flushable flushable)` 从缓存中刷出数据
`static int`	`length(InputStream in)` 获取流长度，对于文件流，会调用`FileInputStream.available()`方法，对于其他流，返回-1 对于网络流，available可能为分段大小，所以返回-1
`static LineIter`	`lineIter(InputStream in, Charset charset)` 返回行遍历器 LineIterator it = null; try { it = IoUtil.lineIter(in, CharsetUtil.CHARSET_UTF_8); while (it.hasNext()) { String line = it.nextLine(); // do something with line } } finally { it.close(); }
`static LineIter`	`lineIter(Reader reader)` 返回行遍历器 LineIterator it = null; try { it = IoUtil.lineIter(reader); while (it.hasNext()) { String line = it.nextLine(); // do something with line } } finally { it.close(); }
`static void`	`nullSafeClose(Closeable closeable)` 关闭关闭失败抛出`IOException`异常
`static FastByteArrayOutputStream`	`read(InputStream in)` 从流中读取内容，读到输出流中，读取完毕后关闭流
`static FastByteArrayOutputStream`	`read(InputStream in, boolean isClose)` 从流中读取内容，读到输出流中，读取完毕后可选是否关闭流
`static String`	`read(InputStream in, Charset charset)` 从流中读取内容，读取完毕后关闭流
`static String`	`read(Reader reader)` 从Reader中读取String，读取完毕后关闭Reader
`static String`	`read(Reader reader, boolean isClose)` 从`Reader`中读取String
`static byte[]`	`readBytes(InputStream in)` 从流中读取bytes，读取完毕后关闭流
`static byte[]`	`readBytes(InputStream in, boolean isClose)` 从流中读取bytes
`static byte[]`	`readBytes(InputStream in, int length)` 读取指定长度的byte数组，不关闭流
`static String`	`readHex(InputStream in, int length, boolean toLowerCase)` 读取16进制字符串
`static void`	`readLines(InputStream in, Charset charset, SerConsumer<String> lineHandler)` 按行读取数据，针对每行的数据做处理
`static <T extends Collection<String>> T`	`readLines(InputStream in, Charset charset, T collection)` 从流中读取内容
`static void`	`readLines(Reader reader, SerConsumer<String> lineHandler)` 按行读取数据，针对每行的数据做处理 `Reader`自带编码定义，因此读取数据的编码跟随其编码。
`static <T extends Collection<String>> T`	`readLines(Reader reader, T collection)` 从Reader中读取内容
`static <T> T`	`readObj(InputStream in, Class<?>... acceptClasses)` 从流中读取对象，即对象的反序列化，读取后不关闭流注意！！！
`static FastByteArrayOutputStream`	`readTo(InputStream in, Predicate<Integer> predicate)` 从流中读取内容，直到遇到给定token满足`Predicate.test(Object)`
`static FastByteArrayOutputStream`	`readToToken(InputStream in, int token)` 从流中读取内容，直到遇到给定token
`static String`	`readUtf8(InputStream in)` 从流中读取UTF8编码的内容
`static void`	`readUtf8Lines(InputStream in, SerConsumer<String> lineHandler)` 按行读取UTF-8编码数据，针对每行的数据做处理
`static <T extends Collection<String>> T`	`readUtf8Lines(InputStream in, T collection)` 从流中读取内容，使用UTF-8编码
`static InputStream`	`toAvailableStream(InputStream in)` 将指定`InputStream` 转换为`InputStream.available()`方法可用的流。
`static BomReader`	`toBomReader(InputStream in)` 从`InputStream`中获取`BomReader`
`static BufferedInputStream`	`toBuffered(InputStream in)` 转换为`BufferedInputStream`
`static BufferedInputStream`	`toBuffered(InputStream in, int bufferSize)` 转换为`BufferedInputStream`
`static BufferedOutputStream`	`toBuffered(OutputStream out)` 转换为`BufferedOutputStream`
`static BufferedOutputStream`	`toBuffered(OutputStream out, int bufferSize)` 转换为`BufferedOutputStream`
`static BufferedReader`	`toBuffered(Reader reader)` 转换为`BufferedReader`
`static BufferedReader`	`toBuffered(Reader reader, int bufferSize)` 转换为`BufferedReader`
`static BufferedWriter`	`toBuffered(Writer writer)` 转换为`BufferedWriter`
`static BufferedWriter`	`toBuffered(Writer writer, int bufferSize)` 转换为`BufferedWriter`
`static InputStream`	`toMarkSupport(InputStream in)` 将`InputStream`转换为支持mark标记的流若原流支持mark标记，则返回原流，否则使用`BufferedInputStream` 包装之
`static Reader`	`toMarkSupport(Reader reader)` 将`Reader`转换为支持mark标记的Reader 若原Reader支持mark标记，则返回原Reader，否则使用`BufferedReader` 包装之
`static PushbackReader`	`toPushBackReader(Reader reader, int pushBackSize)` 获得`PushbackReader` 如果是`PushbackReader`强转返回，否则新建
`static PushbackInputStream`	`toPushbackStream(InputStream in, int pushBackSize)` 转换为`PushbackInputStream` 如果传入的输入流已经是`PushbackInputStream`，强转返回，否则新建一个
`static BufferedReader`	`toReader(InputStream in, Charset charset)` 获得一个Reader
`static String`	`toStr(ByteArrayOutputStream out, Charset charset)` `ByteArrayOutputStream` 转换为String
`static ByteArrayInputStream`	`toStream(byte[] content)` byte[] 转为`ByteArrayInputStream`
`static ByteArrayInputStream`	`toStream(ByteArrayOutputStream out)` `ByteArrayOutputStream`转为`ByteArrayInputStream`
`static ByteArrayInputStream`	`toStream(FastByteArrayOutputStream out)` `FastByteArrayOutputStream`转为`ByteArrayInputStream`
`static InputStream`	`toStream(File file)` 文件转为`InputStream`
`static InputStream`	`toStream(Path path)` 文件转为`InputStream`
`static ByteArrayInputStream`	`toStream(String content, Charset charset)` String 转为流
`static BufferedReader`	`toUtf8Reader(InputStream in)` 获得一个文件读取器，默认使用 UTF-8 编码
`static ByteArrayInputStream`	`toUtf8Stream(String content)` String 转为UTF-8编码的字节流流
`static OutputStreamWriter`	`toUtf8Writer(OutputStream out)` 获得一个Writer，默认编码UTF-8
`static OutputStreamWriter`	`toWriter(OutputStream out, Charset charset)` 获得一个Writer
`static void`	`write(OutputStream out, boolean isCloseOut, byte[] content)` 将byte[]写到流中
`static void`	`write(OutputStream out, byte[] content)` 将byte[]写到流中，并关闭目标流
`static void`	`writeClose(OutputStream out, byte[] content)` 将byte[]写到流中，并关闭目标流
`static void`	`writeObjects(OutputStream out, boolean isCloseOut, Object... contents)` 将多部分内容写到流中
`static void`	`writeStrs(OutputStream out, Charset charset, boolean isCloseOut, CharSequence... contents)` 将多部分内容写到流中，自动转换为字符串
`static void`	`writeUtf8(OutputStream out, boolean isCloseOut, CharSequence... contents)` 将多部分内容写到流中，自动转换为UTF-8字符串

Methods inherited from class org.dromara.hutool.core.io.NioUtil
copy, copy, copy, copy, copyByNIO, copyByNIO, read, read, read, readUtf8

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - IoUtil
```
public IoUtil()
```
- Method Detail
  - copy
```
public static long copy(Reader reader,
                        Writer writer)
                 throws IORuntimeException
```
    将Reader中的内容复制到Writer中使用默认缓存大小，拷贝后不关闭Reader
    
    Parameters:
    
    reader - Reader
    
    writer - Writer
    
    Returns:
    
    拷贝的字节数
    
    Throws:
    
    IORuntimeException - IO异常
  - copy
```
public static long copy(Reader reader,
                        Writer writer,
                        int bufferSize)
                 throws IORuntimeException
```
    将Reader中的内容复制到Writer中，拷贝后不关闭Reader
    
    Parameters:
    
    reader - Reader
    
    writer - Writer
    
    bufferSize - 缓存大小
    
    Returns:
    
    传输的byte数
    
    Throws:
    
    IORuntimeException - IO异常
  - copy
```
public static long copy(Reader reader,
                        Writer writer,
                        int bufferSize,
                        StreamProgress streamProgress)
                 throws IORuntimeException
```
    将Reader中的内容复制到Writer中，拷贝后不关闭Reader
    
    Parameters:
    
    reader - Reader
    
    writer - Writer
    
    bufferSize - 缓存大小
    
    streamProgress - 进度处理器
    
    Returns:
    
    传输的byte数
    
    Throws:
    
    IORuntimeException - IO异常
  - copy
```
public static long copy(Reader reader,
                        Writer writer,
                        int bufferSize,
                        long count,
                        StreamProgress streamProgress)
                 throws IORuntimeException
```
    将Reader中的内容复制到Writer中，拷贝后不关闭Reader
    
    Parameters:
    
    reader - Reader，非空
    
    writer - Writer，非空
    
    bufferSize - 缓存大小，-1表示默认
    
    count - 最大长度，-1表示无限制
    
    streamProgress - 进度处理器，null表示无
    
    Returns:
    
    传输的byte数
    
    Throws:
    
    IORuntimeException - IO异常
  - copy
```
public static long copy(InputStream in,
                        OutputStream out)
                 throws IORuntimeException
```
    拷贝流，使用默认Buffer大小，拷贝后不关闭流
    
    Parameters:
    
    in - 输入流
    
    out - 输出流
    
    Returns:
    
    传输的byte数
    
    Throws:
    
    IORuntimeException - IO异常
  - copy
```
public static long copy(InputStream in,
                        OutputStream out,
                        int bufferSize)
                 throws IORuntimeException
```
    拷贝流，拷贝后不关闭流
    
    Parameters:
    
    in - 输入流
    
    out - 输出流
    
    bufferSize - 缓存大小
    
    Returns:
    
    传输的byte数
    
    Throws:
    
    IORuntimeException - IO异常
  - copy
```
public static long copy(InputStream in,
                        OutputStream out,
                        int bufferSize,
                        StreamProgress streamProgress)
                 throws IORuntimeException
```
    拷贝流，拷贝后不关闭流
    
    Parameters:
    
    in - 输入流
    
    out - 输出流
    
    bufferSize - 缓存大小
    
    streamProgress - 进度条
    
    Returns:
    
    传输的byte数
    
    Throws:
    
    IORuntimeException - IO异常
  - copy
```
public static long copy(InputStream in,
                        OutputStream out,
                        int bufferSize,
                        long count,
                        StreamProgress streamProgress)
                 throws IORuntimeException
```
    拷贝流，拷贝后不关闭流
    
    Parameters:
    
    in - 输入流
    
    out - 输出流
    
    bufferSize - 缓存大小
    
    count - 总拷贝长度，-1表示无限制
    
    streamProgress - 进度条
    
    Returns:
    
    传输的byte数
    
    Throws:
    
    IORuntimeException - IO异常
    
    Since:
    
    5.7.8
  - copy
```
public static long copy(FileInputStream in,
                        FileOutputStream out)
                 throws IORuntimeException
```
    拷贝文件流，使用NIO
    
    Parameters:
    
    in - 输入
    
    out - 输出
    
    Returns:
    
    拷贝的字节数
    
    Throws:
    
    IORuntimeException - IO异常
  - toUtf8Reader
```
public static BufferedReader toUtf8Reader(InputStream in)
```
    获得一个文件读取器，默认使用 UTF-8 编码
    
    Parameters:
    
    in - 输入流
    
    Returns:
    
    BufferedReader对象
    
    Since:
    
    5.1.6
  - toBomReader
```
public static BomReader toBomReader(InputStream in)
```
    从InputStream中获取BomReader
    
    Parameters:
    
    in - InputStream
    
    Returns:
    
    BomReader
    
    Since:
    
    5.7.14
  - toReader
```
public static BufferedReader toReader(InputStream in,
                                      Charset charset)
```
    获得一个Reader
    
    Parameters:
    
    in - 输入流
    
    charset - 字符集
    
    Returns:
    
    BufferedReader对象
  - toUtf8Writer
```
public static OutputStreamWriter toUtf8Writer(OutputStream out)
```
    获得一个Writer，默认编码UTF-8
    
    Parameters:
    
    out - 输入流
    
    Returns:
    
    OutputStreamWriter对象
    
    Since:
    
    5.1.6
  - toWriter
```
public static OutputStreamWriter toWriter(OutputStream out,
                                          Charset charset)
```
    获得一个Writer
    
    Parameters:
    
    out - 输入流
    
    charset - 字符集
    
    Returns:
    
    OutputStreamWriter对象
  - readUtf8
```
public static String readUtf8(InputStream in)
                       throws IORuntimeException
```
    从流中读取UTF8编码的内容
    
    Parameters:
    
    in - 输入流
    
    Returns:
    
    内容
    
    Throws:
    
    IORuntimeException - IO异常
    
    Since:
    
    5.4.4
  - read
```
public static String read(InputStream in,
                          Charset charset)
                   throws IORuntimeException
```
    从流中读取内容，读取完毕后关闭流
    
    Parameters:
    
    in - 输入流，读取完毕后关闭流
    
    charset - 字符集
    
    Returns:
    
    内容
    
    Throws:
    
    IORuntimeException - IO异常
  - read
```
public static FastByteArrayOutputStream read(InputStream in)
                                      throws IORuntimeException
```
    从流中读取内容，读到输出流中，读取完毕后关闭流
    
    Parameters:
    
    in - 输入流
    
    Returns:
    
    输出流
    
    Throws:
    
    IORuntimeException - IO异常
  - read
```
public static FastByteArrayOutputStream read(InputStream in,
                                             boolean isClose)
                                      throws IORuntimeException
```
    从流中读取内容，读到输出流中，读取完毕后可选是否关闭流
    
    Parameters:
    
    in - 输入流
    
    isClose - 读取完毕后是否关闭流
    
    Returns:
    
    输出流
    
    Throws:
    
    IORuntimeException - IO异常
    
    Since:
    
    5.5.3
  - read
```
public static String read(Reader reader)
                   throws IORuntimeException
```
    从Reader中读取String，读取完毕后关闭Reader
    
    Parameters:
    
    reader - Reader
    
    Returns:
    
    String
    
    Throws:
    
    IORuntimeException - IO异常
  - read
```
public static String read(Reader reader,
                          boolean isClose)
                   throws IORuntimeException
```
    从Reader中读取String
    
    Parameters:
    
    reader - Reader
    
    isClose - 是否关闭Reader
    
    Returns:
    
    String
    
    Throws:
    
    IORuntimeException - IO异常
  - readBytes
```
public static byte[] readBytes(InputStream in)
                        throws IORuntimeException
```
    从流中读取bytes，读取完毕后关闭流
    
    Parameters:
    
    in - InputStream
    
    Returns:
    
    bytes
    
    Throws:
    
    IORuntimeException - IO异常
  - readBytes
```
public static byte[] readBytes(InputStream in,
                               boolean isClose)
                        throws IORuntimeException
```
    从流中读取bytes
    
    Parameters:
    
    in - InputStream
    
    isClose - 是否关闭输入流
    
    Returns:
    
    bytes
    
    Throws:
    
    IORuntimeException - IO异常
    
    Since:
    
    5.0.4
  - readBytes
```
public static byte[] readBytes(InputStream in,
                               int length)
                        throws IORuntimeException
```
    读取指定长度的byte数组，不关闭流
    
    Parameters:
    
    in - InputStream，为null返回null
    
    length - 长度，小于等于0返回空byte数组
    
    Returns:
    
    bytes
    
    Throws:
    
    IORuntimeException - IO异常
  - readHex
```
public static String readHex(InputStream in,
                             int length,
                             boolean toLowerCase)
                      throws IORuntimeException
```
    读取16进制字符串
    
    Parameters:
    
    in - InputStream
    
    length - 长度
    
    toLowerCase - true 传换成小写格式， false 传换成大写格式
    
    Returns:
    
    16进制字符串
    
    Throws:
    
    IORuntimeException - IO异常
  - readObj
```
public static <T> T readObj(InputStream in,
                            Class<?>... acceptClasses)
                     throws IORuntimeException,
                            HutoolException
```
    从流中读取对象，即对象的反序列化，读取后不关闭流
    注意！！！此方法不会检查反序列化安全，可能存在反序列化漏洞风险！！！
    
    Type Parameters:
    
    T - 读取对象的类型
    
    Parameters:
    
    in - 输入流
    
    acceptClasses - 读取对象类型
    
    Returns:
    
    输出流
    
    Throws:
    
    IORuntimeException - IO异常
    
    HutoolException - ClassNotFoundException包装
  - readUtf8Lines
```
public static <T extends Collection<String>> T readUtf8Lines(InputStream in,
                                                             T collection)
                                                      throws IORuntimeException
```
    从流中读取内容，使用UTF-8编码
    
    Type Parameters:
    
    T - 集合类型
    
    Parameters:
    
    in - 输入流
    
    collection - 返回集合
    
    Returns:
    
    内容
    
    Throws:
    
    IORuntimeException - IO异常
  - readLines
```
public static <T extends Collection<String>> T readLines(InputStream in,
                                                         Charset charset,
                                                         T collection)
                                                  throws IORuntimeException
```
    从流中读取内容
    
    Type Parameters:
    
    T - 集合类型
    
    Parameters:
    
    in - 输入流
    
    charset - 字符集
    
    collection - 返回集合
    
    Returns:
    
    内容
    
    Throws:
    
    IORuntimeException - IO异常
  - readLines
```
public static <T extends Collection<String>> T readLines(Reader reader,
                                                         T collection)
                                                  throws IORuntimeException
```
    从Reader中读取内容
    
    Type Parameters:
    
    T - 集合类型
    
    Parameters:
    
    reader - Reader
    
    collection - 返回集合
    
    Returns:
    
    内容
    
    Throws:
    
    IORuntimeException - IO异常
  - readUtf8Lines
```
public static void readUtf8Lines(InputStream in,
                                 SerConsumer<String> lineHandler)
                          throws IORuntimeException
```
    按行读取UTF-8编码数据，针对每行的数据做处理
    
    Parameters:
    
    in - InputStream
    
    lineHandler - 行处理接口，实现handle方法用于编辑一行的数据后入到指定地方
    
    Throws:
    
    IORuntimeException - IO异常
    
    Since:
    
    3.1.1
  - readLines
```
public static void readLines(InputStream in,
                             Charset charset,
                             SerConsumer<String> lineHandler)
                      throws IORuntimeException
```
    按行读取数据，针对每行的数据做处理
    
    Parameters:
    
    in - InputStream
    
    charset - Charset编码
    
    lineHandler - 行处理接口，实现handle方法用于编辑一行的数据后入到指定地方
    
    Throws:
    
    IORuntimeException - IO异常
    
    Since:
    
    3.0.9
  - readLines
```
public static void readLines(Reader reader,
                             SerConsumer<String> lineHandler)
                      throws IORuntimeException
```
    按行读取数据，针对每行的数据做处理
    Reader自带编码定义，因此读取数据的编码跟随其编码。
    此方法不会关闭流，除非抛出异常
    
    Parameters:
    
    reader - Reader
    
    lineHandler - 行处理接口，实现handle方法用于编辑一行的数据后入到指定地方
    
    Throws:
    
    IORuntimeException - IO异常
  - readToToken
```
public static FastByteArrayOutputStream readToToken(InputStream in,
                                                    int token)
                                             throws IORuntimeException
```
    从流中读取内容，直到遇到给定token
    
    Parameters:
    
    in - 输入流
    
    token - 停止的字符
    
    Returns:
    
    输出流
    
    Throws:
    
    IORuntimeException - IO异常
  - readTo
```
public static FastByteArrayOutputStream readTo(InputStream in,
                                               Predicate<Integer> predicate)
```
    从流中读取内容，直到遇到给定token满足Predicate.test(Object)
    
    Parameters:
    
    in - 输入流
    
    predicate - 读取结束条件, Predicate.test(Object)返回true表示结束
    
    Returns:
    
    输出流
    
    Throws:
    
    IORuntimeException - IO异常
  - toUtf8Stream
```
public static ByteArrayInputStream toUtf8Stream(String content)
```
    String 转为UTF-8编码的字节流流
    
    Parameters:
    
    content - 内容
    
    Returns:
    
    字节流
    
    Since:
    
    4.5.1
  - toStream
```
public static ByteArrayInputStream toStream(String content,
                                            Charset charset)
```
    String 转为流
    
    Parameters:
    
    content - 内容
    
    charset - 编码
    
    Returns:
    
    字节流
  - toStream
```
public static InputStream toStream(File file)
```
    文件转为InputStream
    
    Parameters:
    
    file - 文件，非空
    
    Returns:
    
    InputStream
  - toStream
```
public static InputStream toStream(Path path)
```
    文件转为InputStream
    
    Parameters:
    
    path - Path，非空
    
    Returns:
    
    InputStream
  - toStream
```
public static ByteArrayInputStream toStream(byte[] content)
```
    byte[] 转为ByteArrayInputStream
    
    Parameters:
    
    content - 内容bytes
    
    Returns:
    
    字节流
    
    Since:
    
    4.1.8
  - toStream
```
public static ByteArrayInputStream toStream(ByteArrayOutputStream out)
```
    ByteArrayOutputStream转为ByteArrayInputStream
    
    Parameters:
    
    out - ByteArrayOutputStream
    
    Returns:
    
    字节流
    
    Since:
    
    5.3.6
  - toStream
```
public static ByteArrayInputStream toStream(FastByteArrayOutputStream out)
```
    FastByteArrayOutputStream转为ByteArrayInputStream
    
    Parameters:
    
    out - FastByteArrayOutputStream
    
    Returns:
    
    字节流
  - toBuffered
```
public static BufferedInputStream toBuffered(InputStream in)
```
    转换为BufferedInputStream
    
    Parameters:
    
    in - InputStream
    
    Returns:
    
    BufferedInputStream
    
    Since:
    
    4.0.10
  - toBuffered
```
public static BufferedInputStream toBuffered(InputStream in,
                                             int bufferSize)
```
    转换为BufferedInputStream
    
    Parameters:
    
    in - InputStream
    
    bufferSize - buffer size
    
    Returns:
    
    BufferedInputStream
    
    Since:
    
    5.6.1
  - toBuffered
```
public static BufferedOutputStream toBuffered(OutputStream out)
```
    转换为BufferedOutputStream
    
    Parameters:
    
    out - OutputStream
    
    Returns:
    
    BufferedOutputStream
    
    Since:
    
    4.0.10
  - toBuffered
```
public static BufferedOutputStream toBuffered(OutputStream out,
                                              int bufferSize)
```
    转换为BufferedOutputStream
    
    Parameters:
    
    out - OutputStream
    
    bufferSize - buffer size
    
    Returns:
    
    BufferedOutputStream
    
    Since:
    
    5.6.1
  - toBuffered
```
public static BufferedReader toBuffered(Reader reader)
```
    转换为BufferedReader
    
    Parameters:
    
    reader - Reader
    
    Returns:
    
    BufferedReader
    
    Since:
    
    5.6.1
  - toBuffered
```
public static BufferedReader toBuffered(Reader reader,
                                        int bufferSize)
```
    转换为BufferedReader
    
    Parameters:
    
    reader - Reader
    
    bufferSize - buffer size
    
    Returns:
    
    BufferedReader
    
    Since:
    
    5.6.1
  - toBuffered
```
public static BufferedWriter toBuffered(Writer writer)
```
    转换为BufferedWriter
    
    Parameters:
    
    writer - Writer
    
    Returns:
    
    BufferedWriter
    
    Since:
    
    5.6.1
  - toBuffered
```
public static BufferedWriter toBuffered(Writer writer,
                                        int bufferSize)
```
    转换为BufferedWriter
    
    Parameters:
    
    writer - Writer
    
    bufferSize - buffer size
    
    Returns:
    
    BufferedWriter
    
    Since:
    
    5.6.1
  - toMarkSupport
```
public static InputStream toMarkSupport(InputStream in)
```
    将InputStream转换为支持mark标记的流
    若原流支持mark标记，则返回原流，否则使用BufferedInputStream 包装之
    
    Parameters:
    
    in - 流
    
    Returns:
    
    InputStream
    
    Since:
    
    4.0.9
  - toMarkSupport
```
public static Reader toMarkSupport(Reader reader)
```
    将Reader转换为支持mark标记的Reader
    若原Reader支持mark标记，则返回原Reader，否则使用BufferedReader 包装之
    
    Parameters:
    
    reader - Reader
    
    Returns:
    
    Reader
  - toPushBackReader
```
public static PushbackReader toPushBackReader(Reader reader,
                                              int pushBackSize)
```
    获得PushbackReader
    如果是PushbackReader强转返回，否则新建
    
    Parameters:
    
    reader - 普通Reader
    
    pushBackSize - 推后的byte数
    
    Returns:
    
    PushbackReader
    
    Since:
    
    3.1.0
  - toPushbackStream
```
public static PushbackInputStream toPushbackStream(InputStream in,
                                                   int pushBackSize)
```
    转换为PushbackInputStream
    如果传入的输入流已经是PushbackInputStream，强转返回，否则新建一个
    
    Parameters:
    
    in - InputStream
    
    pushBackSize - 推后的byte数
    
    Returns:
    
    PushbackInputStream
    
    Since:
    
    3.1.0
  - toAvailableStream
```
public static InputStream toAvailableStream(InputStream in)
```
    将指定InputStream 转换为InputStream.available()方法可用的流。
    在Socket通信流中，服务端未返回数据情况下InputStream.available()方法始终为0
    因此，在读取前需要调用InputStream.read()读取一个字节（未返回会阻塞），一旦读取到了，InputStream.available()方法就正常了。
    需要注意的是，在网络流中，是按照块来传输的，所以 InputStream.available() 读取到的并非最终长度，而是此次块的长度。
    此方法返回对象的规则为：
    - FileInputStream 返回原对象，因为文件流的available方法本身可用
    - 其它InputStream 返回PushbackInputStream
    Parameters:
    
    in - 被转换的流
    
    Returns:
    
    转换后的流，可能为PushbackInputStream
    
    Since:
    
    5.5.3
  - writeClose
```
public static void writeClose(OutputStream out,
                              byte[] content)
                       throws IORuntimeException
```
    将byte[]写到流中，并关闭目标流
    
    Parameters:
    
    out - 输出流
    
    content - 写入的内容
    
    Throws:
    
    IORuntimeException - IO异常
  - write
```
public static void write(OutputStream out,
                         byte[] content)
                  throws IORuntimeException
```
    将byte[]写到流中，并关闭目标流
    
    Parameters:
    
    out - 输出流
    
    content - 写入的内容
    
    Throws:
    
    IORuntimeException - IO异常
  - write
```
public static void write(OutputStream out,
                         boolean isCloseOut,
                         byte[] content)
                  throws IORuntimeException
```
    将byte[]写到流中
    
    Parameters:
    
    out - 输出流
    
    isCloseOut - 写入完毕是否关闭输出流
    
    content - 写入的内容
    
    Throws:
    
    IORuntimeException - IO异常
  - writeUtf8
```
public static void writeUtf8(OutputStream out,
                             boolean isCloseOut,
                             CharSequence... contents)
                      throws IORuntimeException
```
    将多部分内容写到流中，自动转换为UTF-8字符串
    
    Parameters:
    
    out - 输出流
    
    isCloseOut - 写入完毕是否关闭输出流
    
    contents - 写入的内容，调用toString()方法，不包括不会自动换行
    
    Throws:
    
    IORuntimeException - IO异常
    
    Since:
    
    3.1.1
  - writeStrs
```
public static void writeStrs(OutputStream out,
                             Charset charset,
                             boolean isCloseOut,
                             CharSequence... contents)
                      throws IORuntimeException
```
    将多部分内容写到流中，自动转换为字符串
    
    Parameters:
    
    out - 输出流
    
    charset - 写出的内容的字符集
    
    isCloseOut - 写入完毕是否关闭输出流
    
    contents - 写入的内容，调用toString()方法，不包括不会自动换行
    
    Throws:
    
    IORuntimeException - IO异常
    
    Since:
    
    3.0.9
  - writeObjects
```
public static void writeObjects(OutputStream out,
                                boolean isCloseOut,
                                Object... contents)
                         throws IORuntimeException
```
    将多部分内容写到流中
    
    Parameters:
    
    out - 输出流
    
    isCloseOut - 写入完毕是否关闭输出流
    
    contents - 写入的内容
    
    Throws:
    
    IORuntimeException - IO异常
  - flush
```
public static void flush(Flushable flushable)
```
    从缓存中刷出数据
    
    Parameters:
    
    flushable - Flushable
    
    Since:
    
    4.2.2
  - closeIfPossible
```
public static void closeIfPossible(Object obj)
```
    尝试关闭指定对象
    判断对象如果实现了AutoCloseable，则调用之
    
    Parameters:
    
    obj - 可关闭对象
    
    Since:
    
    4.3.2
  - closeQuietly
```
public static void closeQuietly(AutoCloseable... closeables)
```
    按照给定顺序连续关闭一系列对象
    这些对象必须按照顺序关闭，否则会出错。
    
    Parameters:
    
    closeables - 需要关闭的对象
  - nullSafeClose
```
public static void nullSafeClose(Closeable closeable)
                          throws IOException
```
    关闭
    关闭失败抛出IOException异常
    
    Parameters:
    
    closeable - 被关闭的对象
    
    Throws:
    
    IOException - IO异常
  - contentEquals
```
public static boolean contentEquals(InputStream input1,
                                    InputStream input2)
                             throws IORuntimeException
```
    对比两个流内容是否相同
    内部会转换流为 BufferedInputStream
    
    Parameters:
    
    input1 - 第一个流
    
    input2 - 第二个流
    
    Returns:
    
    两个流的内容一致返回true，否则false
    
    Throws:
    
    IORuntimeException - IO异常
    
    Since:
    
    4.0.6
  - contentEquals
```
public static boolean contentEquals(Reader input1,
                                    Reader input2)
                             throws IORuntimeException
```
    对比两个Reader的内容是否一致
    内部会转换流为 BufferedInputStream
    
    Parameters:
    
    input1 - 第一个reader
    
    input2 - 第二个reader
    
    Returns:
    
    两个流的内容一致返回true，否则false
    
    Throws:
    
    IORuntimeException - IO异常
    
    Since:
    
    4.0.6
  - contentEqualsIgnoreEOL
```
public static boolean contentEqualsIgnoreEOL(Reader input1,
                                             Reader input2)
                                      throws IORuntimeException
```
    对比两个流内容是否相同，忽略EOL字符
    内部会转换流为 BufferedInputStream
    
    Parameters:
    
    input1 - 第一个流
    
    input2 - 第二个流
    
    Returns:
    
    两个流的内容一致返回true，否则false
    
    Throws:
    
    IORuntimeException - IO异常
    
    Since:
    
    4.0.6
  - lineIter
```
public static LineIter lineIter(Reader reader)
```
    返回行遍历器
```
 LineIterator it = null;
 try {
        it = IoUtil.lineIter(reader);
        while (it.hasNext()) {
                String line = it.nextLine();
                // do something with line
    }
 } finally {
                it.close();
 }
 
```
    Parameters:
    
    reader - Reader
    
    Returns:
    
    LineIter
    
    Since:
    
    5.6.1
  - lineIter
```
public static LineIter lineIter(InputStream in,
                                Charset charset)
```
    返回行遍历器
```
 LineIterator it = null;
 try {
        it = IoUtil.lineIter(in, CharsetUtil.CHARSET_UTF_8);
        while (it.hasNext()) {
                String line = it.nextLine();
                // do something with line
    }
 } finally {
                it.close();
 }
 
```
    Parameters:
    
    in - InputStream
    
    charset - 编码
    
    Returns:
    
    LineIter
    
    Since:
    
    5.6.1
  - toStr
```
public static String toStr(ByteArrayOutputStream out,
                           Charset charset)
```
    ByteArrayOutputStream 转换为String
    
    Parameters:
    
    out - ByteArrayOutputStream
    
    charset - 编码
    
    Returns:
    
    字符串
    
    Since:
    
    5.7.17
  - length
```
public static int length(InputStream in)
```
    获取流长度，对于文件流，会调用FileInputStream.available()方法，对于其他流，返回-1
    对于网络流，available可能为分段大小，所以返回-1
    
    Parameters:
    
    in - 流
    
    Returns:
    
    长度，-1表示未知长度

Class IoUtil

Field Summary

Fields inherited from class org.dromara.hutool.core.io.NioUtil

Constructor Summary

Method Summary

Methods inherited from class org.dromara.hutool.core.io.NioUtil

Methods inherited from class java.lang.Object

Constructor Detail

IoUtil

Method Detail

copy

copy

copy

copy

copy

copy

copy

copy

copy

toUtf8Reader

toBomReader

toReader

toUtf8Writer

toWriter

readUtf8

read

read

read

read

read

readBytes

readBytes

readBytes

readHex

readObj

readUtf8Lines

readLines

readLines

readUtf8Lines

readLines

readLines

readToToken

readTo

toUtf8Stream

toStream

toStream

toStream

toStream

toStream

toStream

toBuffered

toBuffered

toBuffered

toBuffered

toBuffered

toBuffered

toBuffered

toBuffered

toMarkSupport

toMarkSupport

toPushBackReader

toPushbackStream

toAvailableStream

writeClose

write

write

writeUtf8

writeStrs

writeObjects

flush

closeIfPossible

closeQuietly

nullSafeClose

contentEquals

contentEquals

contentEqualsIgnoreEOL

lineIter

lineIter

toStr

length