Java.io是大多数面向数据流的输入/输出类的主要软件包。

此外，Java也对块传输提供支持，在核心库 java.nio中采用的便是块IO。
JDK1.4版本开始引入了新I/O类库，它位于java.nio包中，新I/O类库利用通道和缓冲区等来提高I/O操作的效率。

流IO简单易用但效率较低。

块IO效率很高但编程比较复杂。

“流是磁盘或其它外围设备中存储的数据的源点或终点。”

在电脑上的数据有三种存储方式，一种是外存，一种是内存，一种是缓存。

比如电脑上的硬盘，磁盘，U盘等都是外存，在电脑上有内存条，缓存是在CPU里面的。

存储量（依次递减）：    外存-->内存-->缓存

读取速度（依次递减）： 缓存-->内存-->外存

对于内存和外存的理解，我们可以简单的理解为容器，即外存是一个容器，内存又是另外一个容器。

在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:

标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流等等，java中将输入输出抽象称为流，就好像水管，将两个容器连接起来。将数据冲外存中读取到内存中的称为输入流，将数据从内存写入外存中的称为输出流。

流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。

一组有序，有起点和终点的字节的数据序列。包括输入流和输出流。

 程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…)，
即是将数据源读入到程序的通信通道。

 程序向输出流写入数据。
将程序中的数据输出到外界（显示器、打印机、文件、网络…）的通信通道。

FileInputStream（字节输入流），
FileOutputStream（字节输出流），
FileReader（字符输入流），
FileWriter（字符输出流）

PipedInputStream（字节输入流）,
PipedOutStream（字节输出流），
PipedReader（字符输入流），
PipedWriter（字符输出流）

ByteArrayInputStream，ByteArrayOutputStream，CharArrayReader，
CharArrayWriter是在内存中开辟了一个字节或字符数组。

BufferedInputStream，BufferedOutputStream，BufferedReader,BufferedWriter,
是带缓冲区的处理流，缓冲区的作用的主要目的是：避免每次和硬盘打交道，
提高数据访问的效率。

InputStreamReader/OutputStreamWriter，把字节转化成字符。

DataInputStream，DataOutputStream。

因为平时若是我们输出一个8个字节的long类型或4个字节的float类型，那怎么办呢？

可以一个字节一个字节输出，也可以把转换成字符串输出，但是这样转换费时间，若是直接输出该多好啊，因此这个数据流就解决了我们输出数据类型的困难。

数据流可以直接输出float类型或long类型，提高了数据读写的效率。

printStream，printWriter，一般是打印到控制台，可以进行控制打印的地方。

ObjectInputStream，ObjectOutputStream，
把封装的对象直接输出，而不是一个个在转换成字符串再输出。

SequenceInputStream。

对象序列化：把对象直接转换成二进制，写入介质中。

例:File  f1=new File("FileTest1.txt");
 //创建文件对象f1，f1所指的文件是在当前目录下创建的FileTest1.txt

例:File f2=new  File(“D:\\dir1","FileTest2.txt") 
;//  注意：D:\\dir1目录事先必须存在，否则异常

例:  File  f4=new File("E：\\dir3");
      File  f5=new File(f4,"FileTest5.txt"); 
 //在如果 E：\\dir3目录不存在则需要先使用f4.mkdir()先创建

1）public boolean exists( ) 判断文件或目录是否存在

2）public boolean isFile( ) 判断是文件还是目录

3）public boolean isDirectory( ) 判断是文件还是目录

4）public String getName( ) 返回文件名或目录名

5）public String getPath( ) 返回文件或目录的路径。

6）public long length( ) 获取文件的长度

7）public String[ ] list ( ) 将目录中所有文件名和目录名保存在字符串数组中返回。

8）public File[] listFiles() 返回某个目录下所有文件和目录的绝对路径，返回的是File数组

9）public String getAbsolutePath() 返回文件或目录的绝对路径

....
File类中还定义了一些对文件或目录进行管理、操作的方法，常用的方法有：
1） public boolean renameTo( File newFile ); 重命名文件

2） public void delete( ); 删除文件

3） public boolean mkdir( ); 创建目录

4）public boolean createNewFile(); 创建文件

public class FileUtils {

public static void listDir(String dir) throws IOException {
File file = new File(dir);
//传进来的可能不是一个目录
if (!file.isDirectory()) {
throw new IOException(dir+"不是目录");
}
//传进来的可能是一个错误的路径
if (file == null) {
throw new IOException("没有此路径");
}
File[] files = file.listFiles();
for (File f : files) {
//有可能是一个多级目录，递归调用
if (f.isDirectory()) {
listDir(f.getAbsolutePath());
//是文件就直接输出该文件的绝对路径
}else {
System.out.println(f.getAbsolutePath());
}
}
}
}

public class Main {

public static void main(String[] args) throws IOException {
FileUtils.listDir("E:\\ssh");
}
}

1） FileInputStream：把一个文件作为InputStream，实现对文件的读取操作     

2） ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用

3） StringBufferInputStream：把一个String对象作为InputStream

4） PipedInputStream：实现了pipe的概念，主要在线程中使用

5） SequenceInputStream：把多个InputStream合并为一个InputStrea

1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中 

2) FileOutputStream：把信息存入文件中

3) PipedOutputStream：实现了pipe的概念，主要在线程中使用

4) SequenceOutputStream：把多个OutStream合并为一个OutStream

public class FileInputStreamDemo {

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

FileInputStream fis = new FileInputStream("a.txt");
int a;
while ((a = fis.read()) != -1) {
System.out.print((char)a);
}
}
}

public class FileInputStreamDemo {

public static void main(String[] args) throws IOException {
int a;
while ((a = System.in.read()) != -1) {
System.out.print(a);
}
}
}

public class FileInputStreamDemo {

public static void main(String[] args) throws IOException {
int a;
while ((a = System.in.read()) != -1) {
System.out.print((char)a);
}
}
}

public class FileOutputStreamDemo {

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

FileOutputStream fos = new FileOutputStream("write.txt");
int a;
while ((a = System.in.read()) != -1) {
fos.write(a);
}
}
}

public class FileInputStreamDemo {

public static void main(String[] args) throws IOException {
//哈： 229 147 136 13 10
//哈哈： 229 147 136 229 147 136 13 10
//哈哈哈： 229 147 136 229 147 136 229 147 136 13 10
//哈哈（两行）哈哈：229 147 136 229 147 136 13 10 229 147 136 229 147 136 13 10
FileInputStream fis = new FileInputStream("a.txt");
int a;
while ((a = fis.read()) != -1) {
System.out.print(a+" ");
}
}
}

public class FileInputStreamDemo {

public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("file1.txt")));
String s;
while ((s = br.readLine()).length() > 0) {
bw.write(s, 0, s.length());
}
}
}

void write(char ch);//写入单个字符。

void write(char []cbuf,int off,int len)//写入字符数据的某一部分。
void write(String s,int off,int len)//写入字符串的某一部分。

void newLine()//写入一个行分隔符。

void flush();//刷新该流中的缓冲。将缓冲数据写到目的文件中去。

void close();//关闭此流，再关闭前会先刷新他。

(1) 用指定字符数组作为参数：CharArrayReader(char[]) 

将字符数组作为输入流:CharArrayReader(char[], int, int)
读取字符串，构造函数如下： public StringReader(String s);

2) CharArrayReader：与ByteArrayInputStream对应

3) StringReader : 与StringBufferInputStream对应

4) InputStreamReader
从输入流读取字节，在将它们转换成字符:Public inputstreamReader(inputstream is);

5) FilterReader: 允许过滤字符流
protected filterReader(Reader r);

6) BufferReader :接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行。
Public BufferReader(Reader r);

(1) public int read() throws IOException; //读取一个字符，返回值为读取的字符

　(2) public int read(char cbuf[]) throws IOException; /*读取一系列字符到数组cbuf[]中，返回值为实际读取的字符的数量*/

(3) public abstract int read(char cbuf[],int off,int len) throws IOException; /*读取len个字符，从数组cbuf[]的下标off处开始存放，返回值为实际读取的字符数量，该方法必须由子类实现*/

将字符类型数据写入文件，使用缺省字符编码和缓冲器大小。 
　　Public FileWrite(file f);

Public CharArrayWrite();

public PrintWriter(outputstream os);

protected FilterWriter(Writer w); 

(1)  public int read() throws IOException; //读取一个字符，返回值为读取的字符 

　(2) public int read(char cbuf[]) throws IOException; /*读取一系列字符到数组cbuf[]中，返回值为实际读取的字符的数量*/

(3) public abstract int read(char cbuf[],int off,int len) throws IOException; /*读取len个字符，从数组cbuf[]的下标off处开始存放，返回值为实际读取的字符数量，该方法必须由子类实现*/

public class CopyDemo {

public static void main(String[] args) throws IOException {
String source = "a.CHM";
String dict = "copy.chm";
long startTime = System.currentTimeMillis();
method4(source, dict);
long endTime = System.currentTimeMillis();
System.out.println((endTime - startTime)+"毫秒");
}

// 基本字节流每次读一个字节
public static void method1(String source, String dict) throws IOException {
FileInputStream fis = new FileInputStream(source);
FileOutputStream fos = new FileOutputStream(dict);
int a;
while ((a = fis.read()) != -1) {
fos.write(a);
}
fos.close();
fis.close();
}

// 基本字节流每次读一组字节
public static void method2(String source, String dict) throws IOException {
FileInputStream fis = new FileInputStream(source);
FileOutputStream fos = new FileOutputStream(dict);
byte[] b = new byte[1024];
int len;
while ((len = fis.read(b)) != -1) {
fos.write(b, 0, len);
}
fos.close();
fis.close();
}

// 高效字节流每次读一个字节
public static void method3(String source, String dict) throws IOException {
FileInputStream fis = new FileInputStream(source);
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream(dict);
BufferedOutputStream bos = new BufferedOutputStream(fos);
int a;
while ((a = fis.read()) != -1) {
fos.write(a);
}
bos.close();
bis.close();
}

// 基本字节流每次读一组字节
public static void method4(String source, String dict) throws IOException {
FileInputStream fis = new FileInputStream(source);
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream(dict);
BufferedOutputStream bos = new BufferedOutputStream(fos);
byte[] b = new byte[1024];
int len;
while ((len = fis.read(b)) != -1) {
fos.write(b, 0, len);
}
bos.close();
bis.close();
}
}

1 、是文件： FileInputStream, FileOutputStream, ( 字节流 )FileReader, FileWriter( 字符 )

2 、是 byte[] ： ByteArrayInputStream, ByteArrayOutputStream( 字节流 )

3 、是 Char[]: CharArrayReader, CharArrayWriter( 字符流 )

4 、是 String: StringBufferInputStream, StringBufferOuputStream ( 字节流 )StringReader, StringWriter( 字符流 )

1 、要格式化输出： PrintStream, PrintWriter

1 、要缓冲： BufferedInputStream, BufferedOutputStream,
( 字节流 ) BufferedReader, BufferedWriter( 字符流 )

1 、二进制格式（只要不能确定是纯文本的，
比如图片、音频、视频） :
 InputStream, OutputStream 及其所有带 Stream 结尾的子类

2 、纯文本格式（含纯英文与汉字或其他编码方式）； Reader, Writer 及其所有带 Reader, Writer 的子类

1 、输入： Reader, InputStream 类型的子类

2 、输出： Writer, OutputStream 类型的子类

1 、从 Stream 到 Reader,Writer 的转换类： InputStreamReader, OutputStreamWriter

2 、对象输入输出： ObjectInputStream, ObjectOutputStream

3 、进程间通信： PipeInputStream, PipeOutputStream, PipeReader, PipeWriter

4 、合并输入： SequenceInputStream

5 、更特殊的需要： PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader