IO流总结

File类：文件和目录路径名的抽象表示形式。
无论是抽象路径名还是路径名字符串，都可以是绝对路径名或相对路径名。
绝对路径名是完整的路径名，不需要任何其他信息就可以定位它所表示的文件。相反，相对路径名必须使用取自其他路径名的信息进行解释。默认情况下，java.io 包中的类总是根据当前用户目录来解析相对路径名。此目录由系统属性 user.dir 指定，通常是 Java 虚拟机的调用目录。
关于File实际用法：http://blog.csdn.net/qq_36330228/article/details/77856289

---

重点：文件过滤器FilenameFilter接口
用于抽象路径名的过滤器。
唯一方法：
boolean accept(File pathname)
测试指定抽象路径名是否应该包含在某个路径名列表中。
||| 建议使用匿名内部类方法来实现该接口
用法可参考：http://blog.csdn.net/qq_36330228/article/details/77856361

---

IO流分类：
输入流和输出流：输入流只能从中读取数据，而不能写入数据；输出流只能向其写入数据，而不能从中读取数据；
字节流和字符流：字节流操作的数据单元是8位的字节，而字符流操作的数据单元是16位的字符；
节点流和处理流：节点流可以从/向一个特定的IO设备读/写数据的流；处理流则用于对一个已存在的流进行连接或封装；
Java的IO流的40多个类是从4个抽象基类派生的。
InputStream /Reader:所有输入流的基类,它们把输入设备抽象成一个“水管”，水管里的每个“水滴”依次排列，输入流使用隐式的记录指针来表示当前正准备从哪个“水滴”开始读取，每当程序从输入流取出一个或多个水滴，记录指针自动向后移动；
OutputStream /Writer:所有输出流的基类，原理与输入流相同；

---

字节流：

---

FileInputStream**和**FileOutputStream
FileInputStream 从文件系统中的某个文件中获得输入字节。
FileOutputStream 用于写入诸如图像数据之类的原始字节的流。

package com.wql.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 字节流读取文件FileInputStream
 * 字节流写入文件FileOutputStream
 * @author wql
 *
 */
public class FileStreamDemo {

    public static void main(String[] args) throws FileNotFoundException,
            IOException {

        //相对路径：./src/com/wql/io/hello.txt，提前在该路径下建立hello.txt
        try (FileInputStream fis = new FileInputStream(
                "./src/com/wql/io/hello.txt");) {
            byte[] buffer = new byte[1024];
            int hasRead = 0;
            System.out.println(fis.available());//返回字节数。

            //read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。 
            while ((hasRead = fis.read(buffer)) != -1) {            
                System.out.println(new String(buffer, 0, hasRead));
            }
            fis.close();
        }

        try(FileOutputStream fos=new FileOutputStream("./src/com/wql/io/hello2.txt");){
            String str="Hello IO";
            byte[] b=str.getBytes();    //将字符串str转为字节数组
            fos.write(b);       //写入字节数组
            fos.write(32);      //写入指定字节
            fos.flush();        //刷新
            fos.close();
        }
    }

}

---

ByteArrayInputStream和ByteArrayOutputStream
ByteArrayInputStream和ByteArrayOutputStream是以字节数组为节点的节点流；
ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。
ByteArrayOutputStream类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。

package com.wql.io;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
 * @author wql
 *
 */
public class ByteArrayStream {

    public static void main(String[] args) throws IOException {
        // TODO 自动生成的方法存根
        byte[] buf = { 'A', 'B', 'C' };// 在内存缓冲中中写一个数组
        try (ByteArrayInputStream bis = new ByteArrayInputStream(buf);
                ByteArrayOutputStream bos = new ByteArrayOutputStream();) {
            byte[] b = new byte[1024];
            int hasRead;
            while ((hasRead = bis.read(b)) != -1) {
                System.out.println(new String(b, 0, hasRead));
            }

            bos.write(buf);// 写入一个字节数组
            System.out.println(bos.toString());

            System.out.println(bos.size());// 获取当前缓冲区大小
            bos.flush();
            bis.close();
            bos.close();
        }
    }

}

---

DataInputStream和DataOutputStream特殊字节处理流
DataInputStream和DataOutputStream允许应用程序以与机器无关方式从底层输入流中读取或写入基本Java数据类型。

package com.wql.io;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 
 * @author wql
 *
 */
public class DataStream {

    public static void main(String[] args) throws FileNotFoundException,
            IOException {
        // TODO 自动生成的方法存根
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("./data.txt"));
                DataInputStream dis = new DataInputStream(new FileInputStream("./data.txt"));) {
            dos.writeBoolean(true);//写一个布尔类型
            dos.writeChar('A'); //写一个字符
            dos.writeFloat(10.23f);//写一个float类型
            dos.writeLong(500000L);//写一个long类型

            //****************读出********************
            byte[] buf=new byte[1024];
            int hasRead=0;
            while((hasRead=dis.read(buf))!=-1){
                System.out.println(new String(buf,0,hasRead));
            }
        }
    }

}

---

---

字符流

---

FileReader和FileWriter
字符流读取文件FileReader 字符流写入文件FileWriter
重点说下这个方法
write(byte[] b, int off, int len);是将数组 b 中的 len 个字节按顺序写入输出流。 所以如果 b 为 null，则抛出 NullPointerException。如果 off 为负，或 len 为负，又或者 off+len 大于数组 b 的长度， 则抛出 IndexOutOfBoundsException。如果 len 为零，则不写入字节。否则，首先写入字节b[off]，然后写入字节 b[off+1]， 依此类推；最后一个写入字节是 b[off+len-1].

package com.wql.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReaderWriter {

    public static void main(String[] args) throws FileNotFoundException,
            IOException {
        // TODO 自动生成的方法存根
        try (FileReader fr = new FileReader("./src/com/wql/io/hello.txt");
                FileWriter fw = new FileWriter(
                        "./src/com/wql/io/copy_hello.txt");) {
            char[] buffer = new char[1024];
            int hasRead = 0;
            while ((hasRead = fr.read(buffer)) != -1) {
                System.out.println(new String(buffer, 0, hasRead));
                fw.write(buffer);
                fw.flush();
            }
            System.out.println(fw.getEncoding()); // 获取输出流当前编码
            String str = "xyz";
            fw.write(str, 0, 2);// 将str字符串里从off位置开始，长度为len的字符输出到指定输出流中；
            fw.flush();
            fr.close();
            fw.close();
        }
    }

}

---

CharArrayReader和CharArrayWriter
CharArrayReader类实现一个可用作字符输入流的字符缓冲区。
CharArrayWriter类实现一个可用作 Writer 的字符缓冲区。缓冲区会随向流中写入数据而自动增长。可使用 toCharArray() 和 toString() 获取数据。

package com.wql.io;

import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.IOException;

/**
 * 
 * @author wql
 *
 */
public class CharReaderWirter {

    public static void main(String[] args) throws IOException {
        // TODO 自动生成的方法存根
        char[] buf = { 'A', 'B', 'C' };// 在内存缓冲中写一个字符数组
        try (CharArrayReader car = new CharArrayReader(buf);
                CharArrayWriter caw = new CharArrayWriter();) {
            char[] c = new char[1024];
            int hasRead;
            while ((hasRead = car.read(c)) != -1) {
                System.out.println(new String(c, 0, hasRead));
            }

            caw.write(buf);// 写入一个数组
            System.out.println(caw.toString());
            String str = "DEF";
            caw.write(str);// 写入一个字符串
            System.out.println(caw.toString());
            char ch = 'W';
            caw.append(ch);// 将指定字符添加到此 writer
            System.out.println(caw.toString());
            caw.flush();
            car.close();
            caw.close();
        }

    }

}

---

StringReader和StringWriter
StringReader和StringWriter使用字符串作为物理节点，用户实现从字符串读取内容，或将内容写入字符串。

package com.wql.io;

import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;

/**
 * 
 * @author wql
 *
 */
public class StringReaderWriter {

    public static void main(String[] args) throws IOException {
        // TODO 自动生成的方法存根
        String str = "abcde
sss";
        try (StringReader sr = new StringReader(str);
                StringWriter sw = new StringWriter();) {
            char[] buf = new char[1024];
            int hasRead = 0;
            while ((hasRead = sr.read(buf)) != -1) {
                System.out.println(new String(buf, 0, hasRead));
            }

            // *************输出操作**************
            sw.write(str);
            System.out.println(sw.toString());
            sw.append('G');// 添加一个字符
            System.out.println(sw.toString());
            sw.flush();
            sw.close();
            sr.close();
        }
    }

}

---

BufferedReader和BufferedWriter
BufferedReader和BufferedWriter创建一个使用默认大小输入/输出缓冲区的缓冲字符输入/输出流；
BufferedReader 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
*BufferedWriter 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

package com.wql.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 字符处理流，需要底层的字符节点流
 * 
 * @author wql
 *
 */
public class BufferReaderWriter {

    public static void main(String[] args) throws IOException {
        // TODO 自动生成的方法存根
        // 读取当前文件BufferReaderWriter.java文件，然后写入到buffered.txt中

        try (BufferedReader br = new BufferedReader(new FileReader(
                "./src/com/wql/io/BufferReaderWriter.java"));
                BufferedWriter bw = new BufferedWriter(new FileWriter(
                        "./buffered.txt"));) {
            String str = null;
            while ((str = br.readLine()) != null) {
                System.out.println(str);// 在控制台打印下
                bw.write(str);
                bw.newLine();// 换行，不然会写在一行
                bw.flush();// 刷新
            }
            bw.close();
            br.close();
        }
    }
}

---

InputStreamReader和OutputStreamWriter
InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。
为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader。

OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。可以指定此缓冲区的大小，不过，默认的缓冲区对多数用途来说已足够大。注意，传递给 write() 方法的字符没有缓冲。
为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器
EG：
OutputStream out = new FileOutputStream(“temp01.txt”);
Writer w = new OutputStreamWriter(out);
InputStream in = new FileInputStream(“temp01.txt”);
Reader r = new InputStreamReader(in);

---

---

重点说下节点流和处理流：
区别：节点流可以从/向一个特定的IO设备读/写数据的流；处理流则用于对一个已存在的流进行连接或封装；
处理流可以隐藏底层设备上节点流的差异，并对外提供更加方便的输入/输出方法，因此使用处理流是的思路是：使用处理流来包装节点流，程序通过处理流执行输入/输出功能，让节点流与底层的I/O设备、文件交互。