IO流的分类

一、节点流(或文件流)

读取文件

1. 建立一个流对象，将已存在的一个文件加载进流。
   FileReader fr = new FileReader(new File(“Test.txt”));
2. 创建一个临时存放数据的数组。
   char[] ch = new char[1024];
3. 调用流对象的读取方法将流中的数据读入到数组中。
   fr.read(ch);
4. 关闭资源。
   fr.close();

FileReader fr = null;
try {
    fr = new FileReader(new File("c:\\test.txt"));
    char[] buf = new char[1024];
    int len;
    while ((len = fr.read(buf)) != -1) {
        System.out.print(new String(buf, 0, len));
    }
} catch (IOException e) {
    System.out.println("read-Exception :" + e.getMessage());
} finally {
    if (fr != null) {
        try {
            fr.close();
        } catch (IOException e) {
            System.out.println("close-Exception :" + e.getMessage());
        }
    }
}

写入文件

1. 创建流对象，建立数据存放文件
   FileWriter fw = new FileWriter(new File(“Test.txt”));
2. 调用流对象的写入方法，将数据写入流
   fw.write(“zhongguo-beijing”);
3. 关闭流资源，并将流中的数据清空到文件中。
   fw.close();

FileWriter fw = null;
try {
    fw = new FileWriter(new File("Test.txt"));
    fw.write("atguigu-songhongkang");
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fw != null){
        try {
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 定义文件路径时，注意：可以用“/”或者“\”。
• 在写入一个文件时，如果使用构造器FileOutputStream(file)，则目录下有同名文件将被覆盖。
• 在读取文件时，必须保证该文件已存在，否则报异常。

二、缓冲流（处理流之一）

• 为了提高数据读写的速度， Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。
• 缓冲流要“套接”在相应的节点流之上，根据数据操作单位可以把缓冲流分为：
  BufferedInputStream 和 BufferedOutputStream
  BufferedReader 和 BufferedWriter
• 使用方法flush()可以强制将缓冲区的内容全部写入输出流
  

BufferedReader br = null;
BufferedWriter bw = null;
try {
        // 创建缓冲流对象：它是处理流，是对节点流的包装
        br = new BufferedReader(new FileReader("d:\\IOTest\\source.txt"));
        bw = new BufferedWriter(new FileWriter("d:\\IOTest\\dest.txt"));
        String str;
        while ((str = br.readLine()) != null) { // 一次读取字符文本文件的一行字符
             bw.write(str); // 一次写入一行字符串
            bw.newLine(); // 写入行分隔符
        }
        bw.flush(); // 刷新缓冲区
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
    // 关闭IO流对象
    try {
        if (bw != null) {
            bw.close(); // 关闭过滤流时,会自动关闭它所包装的底层节点流
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    try {
        if (br != null) {
            br.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

三、转换流

• 转换流提供了在字节流和字符流之间的转换
• Java API提供了两个转换流：
  InputStreamReader：将InputStream转换为Reader
  OutputStreamWriter：将Writer转换为OutputStream
• 字节流中的数据都是字符时，转成字符流操作更高效。

InputStreamReader

实现将字节的输入流按指定字符集转换为字符的输入流。

OutputStreamWriter

实现将字符的输出流按指定字符集转换为字节的输出流。

public void testMyInput() throws Exception {
    FileInputStream fis = new FileInputStream("dbcp.txt");
    FileOutputStream fos = new FileOutputStream("dbcp5.txt");
    InputStreamReader isr = new InputStreamReader(fis, "GBK");
    OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");
    BufferedReader br = new BufferedReader(isr);
    BufferedWriter bw = new BufferedWriter(osw);
    String str = null;
    while ((str = br.readLine()) != null) {
        bw.write(str);
        bw.newLine();
        bw.flush();
    }
    bw.close();
    br.close();
}

四、标准输入、输出流

• System.in和System.out分别代表了系统标准的输入和输出设备
• 默认输入设备是： 键盘， 输出设备是：显示器

System.out.println("请输入信息(退出输入e或exit):");
// 把"标准"输入流(键盘输入)这个字节流包装成字符流,再包装成缓冲流
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = null;
try {
    while ((s = br.readLine()) != null) { // 读取用户输入的一行数据 --> 阻塞程序
        if ("e".equalsIgnoreCase(s) || "exit".equalsIgnoreCase(s)) {
            System.out.println("安全退出!!");
            break;
        }
        // 将读取到的整行字符串转成大写输出
        System.out.println("-->:" + s.toUpperCase());
        System.out.println("继续输入信息");
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if (br != null) {
            br.close(); // 关闭过滤流时,会自动关闭它包装的底层节点流
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

五、打印流

• 实现将基本数据类型的数据格式转化为字符串输出
• 打印流： PrintStream和PrintWriter
• PrintStream和PrintWriter有自动flush功能

PrintStream ps = null;
try {
    FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));
    // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
    ps = new PrintStream(fos, true);
    if (ps != null) {// 把标准输出流(控制台输出)改成文件
        System.setOut(ps);
    }
    for (int i = 0; i <= 255; i++) { // 输出ASCII字符
        System.out.print((char) i);
        if (i % 50 == 0) { // 每50个数据一行
            System.out.println(); // 换行
        }
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
} finally {
    if (ps != null) {
        ps.close();
    }
}

六、数据流

• 为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流。
• 要用DataInputStream 读取一个文件，这个文件必须是由DataOutputStream 写出的，否则会出现EOFException，因为DataOutputStream 在写出的时候会做一些特殊标记，只有DataInputStream 才能成功的读取。

DataOutputStream dos = null;
try { // 创建连接到指定文件的数据输出流对象
    dos = new DataOutputStream(new FileOutputStream("destData.dat"));
    dos.writeUTF("我爱北京天安门"); // 写UTF字符串
    dos.writeBoolean(false); // 写入布尔值
    dos.writeLong(1234567890L); // 写入长整数
    System.out.println("写文件成功!");
} catch (IOException e) {
    e.printStackTrace();
} finally { // 关闭流对象
    try {
        if (dos != null) {
            // 关闭过滤流时,会自动关闭它包装的底层节点流
            dos.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

DataInputStream dis = null;
try {
    dis = new DataInputStream(new FileInputStream("destData.dat"));
    String info = dis.readUTF();
    boolean flag = dis.readBoolean();
    long time = dis.readLong();
    System.out.println(info);
    System.out.println(flag);
    System.out.println(time);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    if (dis != null) {
        try {
            dis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

七、对象流

• ObjectInputStream和OjbectOutputSteam
  用于存储和读取基本数据类型数据或对象的处理流。
• 序列化： 用ObjectOutputStream类保存基本类型数据或对象的机制

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(“data.txt"));
Person p = new Person("韩梅梅", 18, "中华大街", new Pet());
oos.writeObject(p);
oos.flush();
oos.close();

• 反序列化： 用ObjectInputStream类读取基本类型数据或对象的机制

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(“data.txt"));
Person p1 = (Person)ois.readObject();
System.out.println(p1.toString());
ois.close();

八、随机存取文件流

RandomAccessFile 类

• RandomAccessFile 声明在java.io包下，但直接继承于java.lang.Object类。 并且它实现了DataInput、 DataOutput这两个接口，也就意味着这个类既可以读也可以写。
• RandomAccessFile 类支持 “随机访问” 的方式，程序可以直接跳到文件的任意地方来读、写文件
  支持只访问文件的部分内容
  可以向已存在的文件后追加内容

读取文件内容

RandomAccessFile raf = new RandomAccessFile(“test.txt”, “rw”） ;
raf.seek(5);
byte [] b = new byte[1024];
int off = 0;
int len = 5;
raf.read(b, off, len);
String str = new String(b, 0, len);
System.out.println(str);
raf.close();

写入文件内容

RandomAccessFile raf = new RandomAccessFile("test.txt", "rw");
raf.seek(5);
//先读出来
String temp = raf.readLine();
raf.seek(5);
raf.write("xyz".getBytes());
raf.write(temp.getBytes());
raf.close();