java中数据流的简单介绍

1. java中的I/O操作主要是基于数据流进行操作的，数据流表示了字符或者字节的流动序列。

   java.io是数据流操作的主要软件包

   java.nio是对块传输进行的支持

2. 数据流基本概念

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

   在电脑上的数据有三种存储方式，一种是外存（硬盘，磁盘，优盘），一种是内存，一种是缓存；对于内存和外存的理解，我们可以简单的理解为容器，即外存是一个容器，内存又是另外一个容器，数据流的作用就是将两个容器连接起来

   java中io部分包括标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流等等，java中将输入输出抽象称为流，将数据从外存中读取到内存中的称为输入流，将数据从内存写入外存中的称为输出流。

   1. 数据流：  一组有序，有起点和终点的字节的数据序列。包括输入流和输出流。
   2. 输入流(Input Stream) : 程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…)，即是将数据源读入到程序的通信通道
   3. 输出流（Output Stream）:  程序向输出流写入数据。将程序中的数据输出到外界（显示器、打印机、文件、网络…）的通信通道。
   采用数据流的目的就是使得输出输入独立于设备。

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

3. 标准I/O

   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] + ">");  
              }  
          }  
      }

      
      javac TestArgs.java 编译、
      java TestArgs aaa bbb
      运行结果 :
      arg[0] is <aaa >
      arg[1] is <bbb >
   2. 标准输入输出数据流
      系统自带的标准数据流 java.lang.System;
      

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

      1. 标准输出流  System.out
         

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

      2. 标准输入流 System.in
         

         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());  
                 }  
             }  
         }

         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 退出"  
                         + "
         Windows系统: 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();  
                 }  
             }  
         }

      3. 标准错误流 System.err
         System.err输出标准错误，其数据类型为PrintStream。System.err.print();System.err.println();
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（随机文件操作）：它的功能丰富，可以从文件的任意位置进行存取（输入输出）操作。

非流式文件类--File类

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

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

1. public class   File   extends Object  
2. implements Serializable,Comparable 
3. {} 

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( ); 创建目录

例子：

package com.iotest;

import java.io.File;
import java.io.IOException;

public class Mytest {
    public static void main(String[] args) throws IOException {
        File dir = new File("D:\root");
        File f1 = new File(dir, "file1.txt");
        File f2 = new File(dir, "file2.txt");
        // 上面只是定义了File在，物理上不一定存在
        if (!dir.exists()) {
            System.out.println(11);
            dir.mkdir();// 创建目录(单目录)
            System.out.println(22);
        }
        if (!f1.exists()) {
            f1.createNewFile(); // 创建文件
        }
        if (!f2.exists()) {
            f2.createNewFile();
        }
        System.out.println("f1 absolutePath=" + f1.getAbsolutePath()); // 绝对路径
        System.out.println("f1 Canread=" + f1.canRead());// 是否可读
        System.out.println("f1 length=" + f1.length());// 文件长度long
        String[] list = dir.list(); // 目录中所有文件的文件名
        for (int i = 0; i < list.length; i++) {
            System.out.println(list[i]);
        }
    }
}

4.   Io流类库

                                                                                                 基本数据流

输出/输入	字节流	字符流
输入	InputStream	Reader
输出	OutputStream	writer

java中io流的详细使用