1. 什么是 IO

Java 中 I/O 操作主要是指使用 Java 进行输入，输出操作. Java 所有的 I/O 机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java 的 I/O 流提供了读写数据的标准方法。任何 Java 中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。  

      Java.io 是大多数面向数据流的输入 / 输出类的主要软件包。此外，Java 也对块传输提供支持，在核心库 java.nio 中采用的便是块 IO。

　　流 IO 的好处是简单易用，缺点是效率较低。块 IO 效率很高，但编程比较复杂。 
      Java IO 模型  :
      Java 的 IO 模型设计非常优秀，它使用 Decorator 模式，按功能划分 Stream，您可以动态装配这些 Stream，以便获得您需要的功能。例如，您需要一个具有缓冲的文件输入流，则应当组合使用 FileInputStream 和 BufferedInputStream。 

2. 数据流的基本概念

数据流是一串连续不断的数据的集合，就象水管里的水流，在水管的一端一点一点地供水，而在水管的另一端看到的是一股连续不断的水流。数据写入程序可以是一段、一段地向数据流管道中写入数据，这些数据段会按先后顺序形成一个长的数据流。对数据读取程序来说，看不到数据流在写入时的分段情况，每次可以读取其中的任意长度的数据，但只能先读取前面的数据后，再读取后面的数据。不管写入时是将数据分多次写入，还是作为一个整体一次写入，读取时的效果都是完全一样的。 

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

    在电脑上的数据有三种存储方式，一种是外存，一种是内存，一种是缓存。比如电脑上的硬盘，磁盘，U 盘等都是外存，在电脑上有内存条，缓存是在 CPU 里面的。外存的存储量最大，其次是内存，最后是缓存，但是外存的数据的读取最慢，其次是内存，缓存最快。这里总结从外存读取数据到内存以及将数据从内存写到外存中。对于内存和外存的理解，我们可以简单的理解为容器，即外存是一个容器，内存又是另外一个容器。那又怎样把放在外存这个容器内的数据读取到内存这个容器以及怎么把内存这个容器里的数据存到外存中呢？

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

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

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

      总结的基本概念如下：

数据流：

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

输入流（Input  Stream）：

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

输出流：

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

 

采用数据流的目的就是使得输出输入独立于设备。

Input  Stream 不关心数据源来自何种设备（键盘，文件，网络）
Output  Stream 不关心数据的目的是何种设备（键盘，文件，网络）

数据流分类：

流序列中的数据既可以是未经加工的原始二进制数据，也可以是经一定编码处理后符合某种格式规定的特定数据。因此 Java 中的流分为两种：

•  字节流：数据流中最小的数据单元是字节
•  字符流：数据流中最小的数据单元是字符， Java 中的字符是 Unicode 编码，一个字符占用两个字节。

3. 标准 I/O

 Java 程序可通过命令行参数与外界进行简短的信息交换，同时，也规定了与标准输入、输出设备，如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。

1：命令行参数

public class TestArgs {  
    public static void main(String[] args) {  
        for (int i = 0; i < args.length; i++) {  
            System.out.println("args[" + i + "] is <" + args[i] + ">");  
        }  
    }  
}

运行结果：

rgs[0] is <Java>

args[1] is <C>

args[2] is <VB>

2：标准输入，输出数据流

java 系统自带的标准数据流：java.lang.System:

java.lang.System   
public final class System  extends Object{   
   static  PrintStream  err;//标准错误流（输出）  
   static  InputStream  in;//标准输入(键盘输入流)  
   static  PrintStream  out;//标准输出流(显示器输出流)  
}

注意：
（1）System 类不能创建对象，只能直接使用它的三个静态成员。
（2）每当 main 方法被执行时，就自动生成上述三个对象。
 

1）标准输出流 System.out

   System.out 向标准输出设备输出数据，其数据类型为 PrintStream。方法：

      Void print(参数)      Void println(参数)

2）标准输入流 System.in

    System.in 读取标准输入设备数据（从标准输入获取数据，一般是键盘），其数 据类型为 InputStream。方法：

        int read()  // 返回 ASCII 码。若，返回值 =-1，说明没有读取到任何字节读取工作结束。         int read(byte[] b)// 读入多个字节到缓冲区 b 中返回值是读入的字节数例如：

import java.io.*;  
public class StandardInputOutput {  
    public static void main(String args[]) {  
        int b;  
        try {  
            System.out.println("please Input:");  
            while ((b = System.in.read()) != -1) {  
                System.out.print((char) b);  
            }  
        } catch (IOException e) {  
            System.out.println(e.toString());  
        }  
    }  
}

等待键盘输入，键盘输入什么，就打印出什么

3）标准错误流

   System.err 输出标准错误，其数据类型为 PrintStream。可查阅 API 获得详细说明。

    标准输出通过 System.out 调用 println 方法输出参数并换行，而 print 方法输出参数但不换行。println 或 print 方法都通 过重载实现了输出基本数据类型的多个方法，包括输出参数类型为 boolean、char、int、long、float 和 double。同时，也重载实现 了输出参数类型为 char []、String 和 Object 的方法。其中，print（Object）和 println（Object）方法在运行时将调 用参数 Object 的 toString 方法。

import java.io.BufferedReader;  
import java.io.IOException;  
import java.io.InputStreamReader;  
  
public class StandardInputOutput {  
    public static void main(String args[]) {  
        String s;  
        // 创建缓冲区阅读器从键盘逐行读入数据  
        InputStreamReader ir = new InputStreamReader(System.in);  
        BufferedReader in = new BufferedReader(ir);  
        System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"  
                + "\nWindows系统: ctrl-z 退出");  
        try {  
            // 读一行数据，并标准输出至显示器  
            s = in.readLine();  
            // readLine()方法运行时若发生I/O错误，将抛出IOException异常  
            while (s != null) {  
                System.out.println("Read: " + s);  
                s = in.readLine();  
            }  
            // 关闭缓冲阅读器  
            in.close();  
        } catch (IOException e) { // Catch any IO exceptions.  
            e.printStackTrace();  
        }  
    }  
}

4. java.IO 层次体系结构

在整个 Java.io 包中最重要的就是 5 个类和一个接口。5 个类指的是 File、OutputStream、InputStream、Writer、Reader；一个接口指的是 Serializable. 掌握了这些 IO 的核心操作那么对于 Java 中的 IO 体系也就有了一个初步的认识了

      Java I/O 主要包括如下几个层次，包含三个部分：

   1. 流式部分――IO 的主体部分；

   2. 非流式部分――主要包含一些辅助流式部分的类，如：File 类、RandomAccessFile 类和 FileDescriptor 等类；

   3. 其他类 -- 文件读取部分的与安全相关的类，如：SerializablePermission 类，以及与本地操作系统相关的文件系统的类，如：FileSystem 类和 Win32FileSystem 类和 WinNTFileSystem 类。

   主要的类如下：

     1. File（文件特征与管理）：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。

     2. InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。

     3. OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

     Java 中字符是采用 Unicode 标准，一个字符是 16 位，即一个字符使用两个字节来表示。为此，JAVA 中引入了处理字符的流。

     4. Reader（文件格式操作）：抽象类，基于字符的输入操作。

     5. Writer（文件格式操作）：抽象类，基于字符的输出操作。

     6. RandomAccessFile（随机文件操作）：它的功能丰富，可以从文件的任意位置进行存取（输入输出）操作。

     Java 中 IO 流的体系结构如图：

5. 非流式文件类 --File 类

 

在 Java 语言的 java.io 包中，由 File 类提供了描述文件和目录的操作与管理方法。但 File 类不是 InputStream、OutputStream 或 Reader、Writer 的子类，因为它不负责数据的输入输出，而专门用来管理磁盘文件与目录。

作用：File 类主要用于命名文件、查询文件属性和处理文件目录。

public class File extends Object implements Serializable,Comparable  
{

}

File 类共提供了三个不同的构造函数，以不同的参数形式灵活地接收文件和目录名信息。构造函数：
1）File (String   pathname)   

     例：File  f1=new File ("FileTest1.txt"); // 创建文件对象 f1，f1 所指的文件是在当前目录下创建的 FileTest1.txt
2）File (String  parent  ,  String child)

     例：File f2=new  File (“D:\\dir1","FileTest2.txt") ;//  注意：D:\\dir1 目录事先必须存在，否则异常
3）File (File    parent  , String child)
     例：File  f4=new File ("\\dir3");
          File  f5=new File (f4,"FileTest5.txt");  // 在如果 \\dir3 目录不存在使用 f4.mkdir () 先创建

        一个对应于某磁盘文件或目录的 File 对象一经创建， 就可以通过调用它的方法来获得文件或目录的属性。    

       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 ( ) 将目录中所有文件名保存在字符串数组中返回。 

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

例子：

import java.io.File;  
import java.io.IOException;  
public class TestFile {  
    public static void main(String args[]) throws IOException {  
        File dir = new File("\\root");  
        File f1 = new File(dir, "fileOne.txt");  
        File f2 = new File(dir, "fileTwo.java");  
        // 文件对象创建后，指定的文件或目录不一定物理上存在  
        if (!dir.exists())  
            dir.mkdir();  
        if (!f1.exists())  
            f1.createNewFile();  
        if (!f2.exists())  
            f2.createNewFile();  
        System.out.println("f1's AbsolutePath=  " + f1.getAbsolutePath());  
        System.out.println("f1 Canread=" + f1.canRead());  
        System.out.println("f1's len= " + f1.length());  
        String[] FL;  
        int count = 0;  
        FL = dir.list();  
        for (int i = 0; i < FL.length; i++) {  
            count++;  
            System.out.println(FL[i] + "is in \\root");  
        }  
        System.out.println("there are" + count + "file in //root");  
    }  
  
}

说明：File 类的方法:
(1) exists () 测试磁盘中指定的文件或目录是否存在
(2) mkdir () 创建文件对象指定的目录（单层目录）
(3) createNewFile () 创建文件对象指定的文件

(4) list () 返回目录中所有文件名字符串