java IO流之输入输出流

Java流的概念：什么是输入/输出流

ava 程序通过流来完成输入/输出，所有的输入/输出以流的形式处理。因此要了解 I/O 系统，首先要理解输入/输出流的概念。

输入就是将数据从各种输入设备（包括文件、键盘等）中读取到内存中，输出则正好相反，是将数据写入到各种输出设备（比如文件、显示器、磁盘等）。例如键盘就是一个标准的输入设备，而显示器就是一个标准的输出设备，但是文件既可以作为输入设备，又可以作为输出设备。

数据流是 Java 进行 I/O 操作的对象，它按照不同的标准可以分为不同的类别。
按照流的方向主要分为输入流和输出流两大类。
数据流按照数据单位的不同分为字节流和字符流。
按照功能可以划分为节点流和处理流。

输入流

Java 流功能相关的类都封装在 java.io 包中，而且每个数据流都是一个对象。所有输入流类都是 InputStream 抽象类（字节输入流）和 Reader 抽象类（字符输入流）的子类。其中 InputStream 类是字节输入流的抽象类，是所有字节输入流的父类，其层次结构如图 3 所示。

输出流

在 Java 中所有输出流类都是 OutputStream 抽象类（字节输出流）和 Writer 抽象类（字符输出流）的子类。其中 OutputStream 类是字节输出流的抽象类，是所有字节输出流的父类
OutputStream 类是所有字节输出流的超类，用于以二进制的形式将数据写入目标设备，该类是抽象类，不能被实例化。OutputStream 类提供了一系列跟数据输出有关的方法，如下所示。

• int write (b)：将指定字节的数据写入到输出流。
• int write (byte[] b)：将指定字节数组的内容写入输出流。
• int write (byte[] b,int off,int len)：将指定字节数组从 off 位置开始的 len 字芳的内容写入输出流。
• close()：关闭数据流，当完成对数据流的操作之后需要关闭数据流。
• flush()：刷新输出流，强行将缓冲区的内容写入输出流。

字节输入流

InputStream 类及其子类的对象表示一个字节输入流。

InputStream 类的常用子类如下。

• ByteArrayInputStream 类：将字节数组转换为字节输入流，从中读取字节。
• FileInputStream 类：从文件中读取数据。
• PipedInputStream 类：连接到一个 PipedOutputStream（管道输出流）。
• SequenceInputStream 类：将多个字节输入流串联成一个字节输入流。
• ObjectInputStream 类：将对象反序列化。

注意：使用 InputStream 类的方法可以从流中读取一个或一批字节。

int read() 从输入流中读取一个 8 位的字节，并把它转换为 0~255 的整数，最后返 回整数。如果返回 -1，则表示已经到了输入流的末尾。为了提高 I/O 操作的效率，建议尽量使用 read() 方法的另外两种形式
int read(byte[] b) 从输入流中读取若干字节，并把它们保存到参数 b 指定的字节数组中。 该方法返回读取的字节数。如果返回 -1，则表示已经到了输入流的末尾
int read(byte[] b, int off, int len) 从输入流中读取若干字节，并把它们保存到参数b指定的字节数组中。其中，off 指定在字节数组中开始保存数据的起始下标；len 指定读取的字节数。该方法返回实际读取的字节数。如果返回 -1，则表示已经到了输入流的末尾
void close() 关闭输入流。在读操作完成后，应该关闭输入流，系统将会释放与这个输入流相关的资源。注意，InputStream 类本身的 close() 方法不执行任何 操作，但是它的许多子类重写了 close() 方法
int available() 返回可以从输入流中读取的字节数
long skip(long n) 从输入流中跳过参数n指定数目的字节。该方法返回跳过的字节数
void mark(int readLimit) 在输入流的当前位置开始设置标记，参数 readLimit 则指定了最多被设置 标记的字节数
boolean markSupported() 判断当前输入流是否允许设置标记，是则返回 true，否则返回 false
void reset() 将输入流的指针返回到设置标记的起始处

字节输出流

OutputStream 类及其子类的对象表示一个字节输出流。OutputStream 类的常用子类如下。

• ByteArrayOutputStream 类：向内存缓冲区的字节数组中写数据。
• FileOutputStream 类：向文件中写数据。
• PipedOutputStream 类：连接到一个 PipedlntputStream（管道输入流）。
• ObjectOutputStream 类：将对象序列化。

利用 OutputStream 类的方法可以从流中写入一个或一批字节。

oid write(int b) 向输出流写入一个字节。这里的参数是 int 类型，但是它允许使用表达式，而不用强制转换成 byte 类型。为了提高 I/O 操作的效率，建议尽量使用write() 方法的另外两种形式
void write(byte[] b) 把参数 b 指定的字节数组中的所有字节写到输出流中
void write(byte[] b,int off,int len) 把参数 b 指定的字节数组中的若干字节写到输出流中。其中，off 指定字节数组中的起始下标，len 表示元素个数
void close() 关闭输出流。写操作完成后，应该关闭输出流。系统将会释放与这个输出流相关的资源。注意，OutputStream 类本身的 close() 方法不执行任何操作，但是它的许多子类重写了 close() 方法
void flush() 为了提高效率，在向输出流中写入数据时，数据一般会先保存到内存缓冲区中，只有当缓冲区中的数据达到一定程度时，缓冲区中的数据才会被写入输出流中。使用 flush() 方法则可以强制将缓冲区中的数据写入输 出流，并清空缓冲区

文件输入流

FileInputStream 是 Java 流中比较常用的一种，它表示从文件系统的某个文件中获取输入字节。通过使用 FileInputStream 可以访问文件中的一个字节、一批字节或整个文件。

在创建 FileInputStream 类的对象时，如果找不到指定的文件将拋出 FileNotFoundException 异常，该异常必须捕获或声明拋出。

FileInputStream 常用的构造方法主要有如下两种重载形式。

• FileInputStream(File file)：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
• FileInputStream(String name)：通过打开一个到实际文件的链接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

public class IODemo04 {

public static void main(String[] args) throws IOException {
FileInputStream input = new FileInputStream("test02.txt");
/*byte[] bys = new byte[1024];
int len = input.read(bys);
System.out.println(len);
System.out.println(new String(bys));*/
//while方式遍历
//    byte[] bys = new byte[10];
//    int len = input.read(bys);
//    while (len != -1) {
//    System.out.print(new String(bys,0,len));
//    len = input.read(bys);
//    }
byte[] bys = new byte[10];
int len = 0;
while ((len = input.read(bys)) != -1) {
System.out.print(new String(bys,0,len));
}




}
}

文件输出流

FileOutputStream 类继承自 OutputStream 类，重写和实现了父类中的所有方法。FileOutputStream 类的对象表示一个文件字节输出流，可以向流中写入一个字节或一批字节。在创建 FileOutputStream 类的对象时，如果指定的文件不存在，则创建一个新文件；如果文件已存在，则清除原文件的内容重新写入。

• FileOutputStream 类的构造方法主要有如下 4 种重载形式。
• FileOutputStream(File file)：创建一个文件输出流，参数 file 指定目标文件。
• FileOutputStream(File file,boolean append)：创建一个文件输出流，参数 file 指定目标文件，append 指定是否将数据添加到目标文件的内容末尾，如果为 true，则在末尾添加；如果为 false，则覆盖原有内容；其默认值为 false。
• FileOutputStream(String name)：创建一个文件输出流，参数 name 指定目标文件的文件路径信息。
• FileOutputStream(String name,boolean append)：创建一个文件输出流，参数 name 和 append 的含义同上。

注意：使用构造方法 FileOutputStream(String name,boolean append) 创建一个文件输出流对象，它将数据附加在现有文件的末尾。该字符串 name 指明了原文件，如果只是为了附加数据而不是重写任何已有的数据，布尔类型参数 append 的值应为 true。

对文件输出流有如下四点说明：

1. 在 FileOutputStream 类的构造方法中指定目标文件时，目标文件可以不存在。
2. 目标文件的名称可以是任意的，例如 F:\abc、F:\abc.de 和 F:\abC.de.fg 等都可以，可以使用记事本等工具打开并浏览这些文件中的内容。
3. 目标文件所在目录必须存在，否则会拋出 java.io.FileNotFoundException 异常。
4. 目标文件的名称不能是已存在的目录。例如F盘下已存在java文件夹，那么就不能使用 java 作为文件名，即不能使用 F:\java，否则抛出 java.io.FileNotFoundException 异常。

    public static void main(String[] args) {
        String path ="test02.txt";
        File file = new File(path);
        //关闭流方法一
        /*FileOutputStream output = null;
        try{
            output = new FileOutputStream(file,true);
            for (int i = 1; i <= 10; i++) {
                //getBytes(): 使用平台的默认字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
                output.write(("hello word" +i).getBytes());
                output.write(("
").getBytes());
                output.flush();
            }
            
        } catch (FileNotFoundException e) {
            
            e.printStackTrace();
        } catch (IOException e1) {
            
            e1.printStackTrace();
        }finally {
            if (output != null) {
                try {
                    output.close();
                } catch (IOException e) {
                    
                    e.printStackTrace();
                }
            }
        }*/
        //关闭流方法二 在try()里面自动关闭
        try(FileOutputStream output = new FileOutputStream(file);){
            for (int i = 1; i <= 10; i++) {
                //getBytes(): 使用平台的默认字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
                output.write(("hello word" +i).getBytes());
                output.write(("
").getBytes());
                //将内存中的数据刷新到文件中去
                output.flush();
            }
        } catch (FileNotFoundException e) {
            
            e.printStackTrace();
        } catch (IOException e1) {
            
            e1.printStackTrace();
        }
    }

}