Streams (Nutz 1.r.63 API)

java.lang.Object
- org.nutz.lang.Streams

```
public abstract class Streams
extends Object
```
提供了一组创建 Reader/Writer/InputStream/OutputStream 的便利函数

Author:

zozoh(zozohtnt@gmail.com), Wendal(wendal1985@gmail.com), bonyfish(mc02cxj@gmail.com)

Constructor Summary

Constructors
Constructor and Description

Streams()

Constructors
Constructor and Description
`Streams()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`protected static InputStream`	`_input(File file)` 获取File对象输入流,即使在Jar文件中一样工作良好!! 强烈推荐
`static void`	`appendWriteAndClose(File f, String text)`
`static BufferedInputStream`	`buff(InputStream ins)` 为一个输入流包裹一个缓冲流。如果这个输入流本身就是缓冲流，则直接返回
`static BufferedOutputStream`	`buff(OutputStream ops)` 为一个输出流包裹一个缓冲流。如果这个输出流本身就是缓冲流，则直接返回
`static BufferedReader`	`buffr(Reader reader)` 为一个文本输入流包裹一个缓冲流。如果这个输入流本身就是缓冲流，则直接返回
`static BufferedWriter`	`buffw(Writer ops)` 为一个文本输出流包裹一个缓冲流。如果这个文本输出流本身就是缓冲流，则直接返回
`static int`	`eachLine(Reader r, Each<String> callback)` 对一个文本输入流迭代每一行，并将其关闭
`static boolean`	`equals(InputStream sA, InputStream sB)` 判断两个输入流是否严格相等
`static InputStream`	`fileIn(File file)` 根据一个文件路径建立一个输入流
`static InputStream`	`fileIn(String path)` 根据一个文件路径建立一个输入流
`static Reader`	`fileInr(File file)` 根据一个文件路径建立一个 UTF-8 文本输入流警告!! 本方法会预先读取3个字节以判断该文件是否存在BOM头警告!! 如果存在BOM头,则自动跳过
`static Reader`	`fileInr(String path)` 根据一个文件路径建立一个 UTF-8文本输入流警告!! 本方法会预先读取3个字节以判断该文件是否存在BOM头警告!! 如果存在BOM头,则自动跳过
`static OutputStream`	`fileOut(File file)` 根据一个文件建立一个输出流
`static OutputStream`	`fileOut(String path)` 根据一个文件路径建立一个输出流
`static Writer`	`fileOutw(File file)` 根据一个文件建立一个 UTF-8 文本输出流
`static Writer`	`fileOutw(String path)` 根据一个文件路径建立一个 UTF-8 文本输出流
`static String`	`nextLineTrim(BufferedReader br)`
`static InputStream`	`nullInputStream()`
`static StringBuilder`	`read(Reader reader)` 从一个文本流中读取全部内容并返回
`static int`	`read(Reader reader, StringBuilder sb)` 从一个文本流中读取全部内容并写入缓冲
`static int`	`readAndClose(InputStreamReader reader, StringBuilder sb)` 从一个文本流中读取全部内容并写入缓冲
`static String`	`readAndClose(Reader reader)` 从一个文本流中读取全部内容并返回
`static byte[]`	`readBytes(InputStream ins)` 读取一个输入流中所有的字节
`static byte[]`	`readBytesAndClose(InputStream ins)` 读取一个输入流中所有的字节，并关闭输入流
`static boolean`	`safeClose(Closeable cb)` 关闭一个可关闭对象，可以接受 null。如果成功关闭，返回 true，发生异常返回 false
`static void`	`safeFlush(Flushable fa)` 安全刷新一个可刷新的对象，可接受 null
`static InputStream`	`utf8filte(InputStream in)` 判断并移除UTF-8的BOM头
`static Reader`	`utf8r(InputStream is)`
`static Writer`	`utf8w(OutputStream os)`
`static InputStream`	`wrap(byte[] bytes)`
`static void`	`write(OutputStream ops, byte[] bytes)` 将一个字节数组写入一个输出流。
`static long`	`write(OutputStream ops, InputStream ins)` 将输入流写入一个输出流。块大小为 8192
`static long`	`write(OutputStream ops, InputStream ins, int bufferSize)` 将输入流写入一个输出流。
`static void`	`write(Writer writer, CharSequence cs)` 将一段文本全部写入一个writer。
`static long`	`write(Writer writer, Reader reader)` 将文本输入流写入一个文本输出流。块大小为 8192
`static void`	`writeAndClose(OutputStream ops, byte[] bytes)` 将一个字节数组写入一个输出流。
`static long`	`writeAndClose(OutputStream ops, InputStream ins)` 将输入流写入一个输出流。块大小为 8192
`static long`	`writeAndClose(OutputStream ops, InputStream ins, int buf)`
`static void`	`writeAndClose(Writer writer, CharSequence cs)` 将一段文本全部写入一个writer。
`static long`	`writeAndClose(Writer writer, Reader reader)` 将文本输入流写入一个文本输出流。块大小为 8192

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

- Constructor Detail
  - Streams
```
public Streams()
```
- Method Detail
  - equals
```
public static boolean equals(InputStream sA,
                             InputStream sB)
                      throws IOException
```
    判断两个输入流是否严格相等
    
    Throws:
    
    IOException
  - write
```
public static void write(Writer writer,
                         CharSequence cs)
                  throws IOException
```
    将一段文本全部写入一个writer。
    注意，它并不会关闭输出流
    
    Parameters:
    
    writer -
    
    cs - 文本
    
    Throws:
    
    IOException
  - writeAndClose
```
public static void writeAndClose(Writer writer,
                                 CharSequence cs)
```
    将一段文本全部写入一个writer。
    注意，它会关闭输出流
    
    Parameters:
    
    writer - 输出流
    
    cs - 文本
  - write
```
public static long write(OutputStream ops,
                         InputStream ins)
                  throws IOException
```
    将输入流写入一个输出流。块大小为 8192
    注意，它并不会关闭输入/出流
    
    Parameters:
    
    ops - 输出流
    
    ins - 输入流
    
    Returns:
    
    写入的字节数
    
    Throws:
    
    IOException
  - write
```
public static long write(OutputStream ops,
                         InputStream ins,
                         int bufferSize)
                  throws IOException
```
    将输入流写入一个输出流。
    注意，它并不会关闭输入/出流
    
    Parameters:
    
    ops - 输出流
    
    ins - 输入流
    
    bufferSize - 缓冲块大小
    
    Returns:
    
    写入的字节数
    
    Throws:
    
    IOException
  - writeAndClose
```
public static long writeAndClose(OutputStream ops,
                                 InputStream ins)
```
    将输入流写入一个输出流。块大小为 8192
    注意，它会关闭输入/出流
    
    Parameters:
    
    ops - 输出流
    
    ins - 输入流
    
    Returns:
    
    写入的字节数
  - write
```
public static long write(Writer writer,
                         Reader reader)
                  throws IOException
```
    将文本输入流写入一个文本输出流。块大小为 8192
    注意，它并不会关闭输入/出流
    
    Parameters:
    
    writer - 输出流
    
    reader - 输入流
    
    Throws:
    
    IOException
  - writeAndClose
```
public static long writeAndClose(Writer writer,
                                 Reader reader)
```
    将文本输入流写入一个文本输出流。块大小为 8192
    注意，它会关闭输入/出流
    
    Parameters:
    
    writer - 输出流
    
    reader - 输入流
  - write
```
public static void write(OutputStream ops,
                         byte[] bytes)
                  throws IOException
```
    将一个字节数组写入一个输出流。
    注意，它并不会关闭输出流
    
    Parameters:
    
    ops - 输出流
    
    bytes - 字节数组
    
    Throws:
    
    IOException
  - writeAndClose
```
public static void writeAndClose(OutputStream ops,
                                 byte[] bytes)
```
    将一个字节数组写入一个输出流。
    注意，它会关闭输出流
    
    Parameters:
    
    ops - 输出流
    
    bytes - 字节数组
  - read
```
public static StringBuilder read(Reader reader)
                          throws IOException
```
    从一个文本流中读取全部内容并返回
    注意，它并不会关闭输出流
    
    Parameters:
    
    reader - 文本输出流
    
    Returns:
    
    文本内容
    
    Throws:
    
    IOException
  - readAndClose
```
public static String readAndClose(Reader reader)
```
    从一个文本流中读取全部内容并返回
    注意，它会关闭输入流
    
    Parameters:
    
    reader - 文本输入流
    
    Returns:
    
    文本内容
    
    Throws:
    
    IOException
  - read
```
public static int read(Reader reader,
                       StringBuilder sb)
                throws IOException
```
    从一个文本流中读取全部内容并写入缓冲
    注意，它并不会关闭输出流
    
    Parameters:
    
    reader - 文本输出流
    
    sb - 输出的文本缓冲
    
    Returns:
    
    读取的字符数量
    
    Throws:
    
    IOException
  - readAndClose
```
public static int readAndClose(InputStreamReader reader,
                               StringBuilder sb)
```
    从一个文本流中读取全部内容并写入缓冲
    注意，它会关闭输出流
    
    Parameters:
    
    reader - 文本输出流
    
    sb - 输出的文本缓冲
    
    Returns:
    
    读取的字符数量
  - readBytes
```
public static byte[] readBytes(InputStream ins)
                        throws IOException
```
    读取一个输入流中所有的字节
    
    Parameters:
    
    ins - 输入流，必须支持 available()
    
    Returns:
    
    一个字节数组
    
    Throws:
    
    IOException
  - readBytesAndClose
```
public static byte[] readBytesAndClose(InputStream ins)
```
    读取一个输入流中所有的字节，并关闭输入流
    
    Parameters:
    
    ins - 输入流，必须支持 available()
    
    Returns:
    
    一个字节数组
    
    Throws:
    
    IOException
  - safeClose
```
public static boolean safeClose(Closeable cb)
```
    关闭一个可关闭对象，可以接受 null。如果成功关闭，返回 true，发生异常返回 false
    
    Parameters:
    
    cb - 可关闭对象
    
    Returns:
    
    是否成功关闭
  - safeFlush
```
public static void safeFlush(Flushable fa)
```
    安全刷新一个可刷新的对象，可接受 null
    
    Parameters:
    
    fa - 可刷新对象
  - buff
```
public static BufferedInputStream buff(InputStream ins)
```
    为一个输入流包裹一个缓冲流。如果这个输入流本身就是缓冲流，则直接返回
    
    Parameters:
    
    ins - 输入流。
    
    Returns:
    
    缓冲输入流
  - buff
```
public static BufferedOutputStream buff(OutputStream ops)
```
    为一个输出流包裹一个缓冲流。如果这个输出流本身就是缓冲流，则直接返回
    
    Parameters:
    
    ops - 输出流。
    
    Returns:
    
    缓冲输出流
  - buffr
```
public static BufferedReader buffr(Reader reader)
```
    为一个文本输入流包裹一个缓冲流。如果这个输入流本身就是缓冲流，则直接返回
    
    Parameters:
    
    reader - 文本输入流。
    
    Returns:
    
    缓冲文本输入流
  - buffw
```
public static BufferedWriter buffw(Writer ops)
```
    为一个文本输出流包裹一个缓冲流。如果这个文本输出流本身就是缓冲流，则直接返回
    
    Parameters:
    
    ops - 文本输出流。
    
    Returns:
    
    缓冲文本输出流
  - fileIn
```
public static InputStream fileIn(String path)
```
    根据一个文件路径建立一个输入流
    
    Parameters:
    
    path - 文件路径
    
    Returns:
    
    输入流
  - fileIn
```
public static InputStream fileIn(File file)
```
    根据一个文件路径建立一个输入流
    
    Parameters:
    
    file - 文件
    
    Returns:
    
    输入流
  - fileInr
```
public static Reader fileInr(String path)
```
    根据一个文件路径建立一个 UTF-8文本输入流 警告!! 本方法会预先读取3个字节以判断该文件是否存在BOM头
    警告!! 如果存在BOM头,则自动跳过
    
    Parameters:
    
    path - 文件路径
    
    Returns:
    
    文本输入流
  - fileInr
```
public static Reader fileInr(File file)
```
    根据一个文件路径建立一个 UTF-8 文本输入流 警告!! 本方法会预先读取3个字节以判断该文件是否存在BOM头
    警告!! 如果存在BOM头,则自动跳过
    
    Parameters:
    
    file - 文件
    
    Returns:
    
    文本输入流
  - utf8filte
```
public static InputStream utf8filte(InputStream in)
```
    判断并移除UTF-8的BOM头
  - fileOut
```
public static OutputStream fileOut(String path)
```
    根据一个文件路径建立一个输出流
    
    Parameters:
    
    path - 文件路径
    
    Returns:
    
    输出流
  - fileOut
```
public static OutputStream fileOut(File file)
```
    根据一个文件建立一个输出流
    
    Parameters:
    
    file - 文件
    
    Returns:
    
    输出流
  - fileOutw
```
public static Writer fileOutw(String path)
```
    根据一个文件路径建立一个 UTF-8 文本输出流
    
    Parameters:
    
    path - 文件路径
    
    Returns:
    
    文本输出流
  - fileOutw
```
public static Writer fileOutw(File file)
```
    根据一个文件建立一个 UTF-8 文本输出流
    
    Parameters:
    
    file - 文件
    
    Returns:
    
    输出流
  - utf8r
```
public static Reader utf8r(InputStream is)
```
  - utf8w
```
public static Writer utf8w(OutputStream os)
```
  - nullInputStream
```
public static InputStream nullInputStream()
```
  - wrap
```
public static InputStream wrap(byte[] bytes)
```
  - eachLine
```
public static int eachLine(Reader r,
                           Each<String> callback)
```
    对一个文本输入流迭代每一行，并将其关闭
    
    Parameters:
    
    r - 文本输入流
    
    callback - 回调
    
    Returns:
    
    迭代的行数
  - _input
```
protected static InputStream _input(File file)
                             throws IOException
```
    获取File对象输入流,即使在Jar文件中一样工作良好!! 强烈推荐
    
    Throws:
    
    IOException
  - appendWriteAndClose
```
public static void appendWriteAndClose(File f,
                                       String text)
```
  - nextLineTrim
```
public static String nextLineTrim(BufferedReader br)
                           throws IOException
```
    Throws:
    
    IOException
  - writeAndClose
```
public static long writeAndClose(OutputStream ops,
                                 InputStream ins,
                                 int buf)
```

Class Streams

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Streams

Method Detail

equals

write

writeAndClose

write

write

writeAndClose

write

writeAndClose

write

writeAndClose

read

readAndClose

read

readAndClose

readBytes

readBytesAndClose

safeClose

safeFlush

buff

buff

buffr

buffw

fileIn

fileIn

fileInr

fileInr

utf8filte

fileOut

fileOut

fileOutw

fileOutw

utf8r

utf8w

nullInputStream

wrap

eachLine

_input

appendWriteAndClose

nextLineTrim

writeAndClose