I/O学习之小结

学习了java的I/O，写个小结供大家参考。

一、什么是I/O？
IO（Input/Output）是计算机输出/输出的接口。Java的核心库java.io提供了全面的IO接口，包括：文件读写，标准设备输出等等。Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。Java中输入和输出组织不同于大多数其他语言，它是建立在流(stream)上。Java把不同类型的输入、输出源抽象为流，用统一接口来表示，从而使程序简单明了。

二、了解“流”
Java中定义了两种类型的流：字节型，和字符型。
字节流：处理字节的输入和输出。包括读写二进制数据等方面的内容。

 
字节流类 功能简单介绍   
DataInputStream 包含了读取Java标准数据类型的输入流   
DataOutputStream 包含了写Java标准数据类型的输出流   
ByteArrayInputStream 从字节数组读取的输入流   
ByteArrayOutputStream 写入字节数组的输出流   
FileInputStream 从文件读入的输入流   
FileOutputStream 写入文件的输出流   
PrintStream 包含最常见的Print（）和Println（）的输出流   
PushbackInputStream 返回一个字节到输入流，主要用于编译器的实现   
PipedInputStream 输出管道   
PipedOutputStream 输入管道   
SequenceInputStream 将n个输入流联合起来，一个接一个按一定顺序读取   
RandomAccessFile 随机访问文件   
BufferInputStream 缓冲输入流   
BufferOutputStream 缓冲输出流   
FilterInputStream 实现了InputStream Interface   
FilterOutputStream 实现了OutputStream Interface   
InputStream 抽象类，描述流的输入   
OutputStream 抽象类，描述流的输入 

字符流：处理字符的输入和输出。他采用的是Unicode编码，可以实现国际化。使用字符流的另外一个好处就是：字符流比字节流更有效率。

 
字符流类 功能简单介绍   
Reader 抽象类，描述字符流的输入   
Writer 抽象类，描述字符流的输入   
StingReader 从字符串读取的输入流   
StringWriter 写入字符串的输出流   
FileReader 从文件读入的输入流   
FileWriter 写入文件的输出流   
PrintWriter 包含最常见的Print（）和Println（）的输出流   
PushbackReader 返回一个字符到输入流，主要用于编译器的实现   
PipedReader 输出管道   
PipedWriter 输入管道   
CharArrayReader 从字符数组读取的输入流   
CharArrayWriter 写入字符数组的输出流   
BufferReader 缓冲输入流   
BufferWriter 缓冲输出流   
FilterReader 实现了InputStream Interface   
FilterWriter 实现了OutputStream Interface   
InputStreamReader 将字节转换为字符的输入流   
OutputStreamWriter 将字节转换为字符的输出流 

三、I/O流的层次
1．字节流：
　　从InputStream和OutputStream派生出来的一系列类。这类流以字节(byte)为基本处理单位。
　　◇ InputStream、OutputStream
　　◇ FileInputStream、FileOutputStream
　　◇ PipedInputStream、PipedOutputStream
　　◇ ByteArrayInputStream、ByteArrayOutputStream
　　◇ FilterInputStream、FilterOutputStream
　　◇ DataInputStream、DataOutputStream
　　◇ BufferedInputStream、BufferedOutputStream
2．字符流：
　　从Reader和Writer派生出的一系列类，这类流以16位的Unicode码表示的字符为基本处理单位。
　　  ◇ Reader、Writer
　　 ◇ InputStreamReader、OutputStreamWriter
　　 ◇ FileReader、FileWriter
　　 ◇ CharArrayReader、CharArrayWriter
　　 ◇ PipedReader、PipedWriter
　　 ◇ FilterReader、FilterWriter
　　 ◇ BufferedReader、BufferedWriter
　　 ◇ StringReader、StringWriter
　　3．对象流
　　◇ ObjectInputStream、ObjectOutputStream
　　4．其它
　　◇ 文件处理： File、RandomAccessFile；
◇ 接口：DataInput、DataOutput、ObjectInput、ObjectOutput；

四、InputStream 和OutputStream
 InputStream 和OutputStream是所有字符流的祖先,read和write是它们最基本的方法,读写单位是字节。
1．InputStream
　　◇ 从流中读取数据：
　　int read( ); //读取一个字节，返回值为所读的字节
　　int read( byte b[ ] ); //读取多个字节，放置到字节数组b中，通常
　　　　　　　　　　//读取的字节数量为b的长度，返回值为实际
　　　　　　　　　　//读取的字节的数量
　　int read( byte b[ ], int off, int len ); //读取len个字节，放置
　　　　　　　　　　　　　　　　//到以下标off开始字节
　　　　　　　　　　　　　　　　//数组b中，返回值为实
　　　　　　　　　　　　　　　　//际读取的字节的数量
　　int available( ); 　　//返回值为流中尚未读取的字节的数量
　　long skip( long n )； //读指针跳过n个字节不读，返回值为实际
　　　　　　　　　　　//跳过的字节数量
　　◇ 关闭流：
　　close( ); //流操作完毕后必须关闭
　　◇ 使用输入流中的标记：
　　void mark( int readlimit ); //记录当前读指针所在位置，readlimit
　　 　　　　　　　　　　//表示读指针读出readlimit个字节后
　　　　　　　　　　　　 //所标记的指针位置才失效
　　void reset( ); 　　　    //把读指针重新指向用mark方法所记录的位置
　　boolean markSupported( );　//当前的流是否支持读指针的记录功能

2．OutputStream
　　◇ 输出数据：
　　void write( int b ); 　　//往流中写一个字节b
　　void write( byte b[ ] );  //往流中写一个字节数组b
　　void write( byte b[ ], int off, int len ); //把字节数组b中从
　　　　　　　　　　　　　　      //下标off开始，长度为len的字节写入流中
◇ flush( ) 　　　　　//刷空输出流，并输出所有被缓存的字节 。由于某些流
//支持缓存功能，该方法将把缓存中所有内容强制输出到流中。
　　◇ 关闭流：
　　 close( ); 　　　　　　//流操作完毕后必须关闭

五、文件处理
I/O处理中，最常见的是对文件的操作，java.io包中有关文件处理的类有：File、FileInputStream、FileOutputStream、RamdomAccessFile和FileDescriptor；接口有：FilenameFilter。

1、File
◇ 文件或目录的生成
　　public File(String path)；//如果path是实际存在的路径，则该File对象表示的是
//目录；如果path是文件名，则该File对象表示的是文件。
　　public File(String path,String name)；//path是路径名，name是文件名
　　public File(File dir,String name)；//dir是路径名，name是文件名
◇ 文件名的处理
　　String getName( )； //得到一个文件的名称（不包括路径）
　　String getPath( )； //得到一个文件的路径名
　　String getAbsolutePath( )；//得到一个文件的绝对路径名
　　String getParent( )； //得到一个文件的上一级目录名
　　String renameTo(File newName); //将当前文件名更名为给定文件的
　　　　　　　　　　　　　　　　　 　完整路径
◇ 文件属性测试
　　boolean exists( )； //测试当前File对象所指示的文件是否存在
　　boolean canWrite( )；//测试当前文件是否可写
　　boolean canRead( )；//测试当前文件是否可读
　　boolean isFile( )； //测试当前文件是否是文件（不是目录）
　　boolean isDirectory( )； //测试当前文件是否是目录
◇ 普通文件信息和工具
　　long lastModified( );//得到文件最近一次修改的时间
　　long length( ); //得到文件的长度，以字节为单位
　　boolean delete( ); //删除当前文件
◇ 目录操作
　　boolean mkdir( ); //根据当前对象生成一个由该对象指定的路径
　　String list( ); //列出当前目录下的文件

示例：获取当前目录下所有文件和文件的尺寸
 import java.io.*;
 public class file_size{
  public static void main(String args[]) {
   File files=new File(“.”);    
   String file_list[]=files.list();
   for(int i=0;i<file_list.length;i++){
    File current_file=new File(file_list[i]);
     System.out.println(file_list[i]+ current_file.length());
   }
  }
 }

示例：文件拷贝
import java.io.*;
public class FileCopy{
 public static void main(String[] args){
  String s = "";
  String d = "";
  System.out.print("Please input source file name: ");
  try {
   BufferedReader in = new BufferedReader(
new InputStreamReader(System.in));
   s = in.readLine();
  }catch(IOException e){}
  
  File source = new File(s);
  if(source.exists() && source.isFile()){
   if(source.canRead()){
    System.out.print("Please input destination file name: ");
    try {
     BufferedReader in = new BufferedReader(
new InputStreamReader(System.in));
     d = in.readLine();
    }catch(IOException e){}
    File dest = new File(d);
    if(dest.exists()){
     System.out.println();
     System.out.println(dest + " is already exists.");
     System.out.print("Overwrite?[y/n] "); 
     char ch = ' ';
     try {
      ch = (char)System.in.read();
     }catch(IOException e){}
     if(ch == 'n' || ch == 'N'){
      System.exit(0);
     }  
    }
    try {
      FileInputStream fSource = new FileInputStream(s);
      FileOutputStream fDest = new FileOutputStream(d);
      System.out.println();
      System.out.println("Cpoy file from " + s + " to " + d + " .....");
      System.out.println();
      while(fSource.available() > 0){
       int temp = fSource.read();
       fDest.write(temp);
      }
      fSource.close();
      fDest.close();
      System.out.println("File copyed successfully.");
      System.out.println();
     }catch(IOException e){} 
   }
   else{
    System.out.println("Cannot read " + source + ".");
   } 
  }
  else{
   System.out.println(source + " is not exists.");
  }
 }
}

2、RandomAccessFile
创建一个随机文件：
– new RandomAccessFile(“file1.txt”, “r”);
– new RandomAccessFile(“file2.txt”, “rw”);
◇ readXXX()或writeXXX() //读或写
◇ skipBytes();    //将指针乡下移动若干字节
◇ seek():     //将指针调到所需位置
◇ getFilePointer():   //返回指针当前位置
◇ length():     //返回文件长度

示例: 把几个整数写到名为 “1.txt”的文件中,然后利用seek方法,以相反的顺序再读取这些数据
import java.io.*;
public class RandomFile{ 
 public static void main(String args[]){
  int data_arr[]={11, 4, 88, 23, 21, 74, 100};
       try {
        RandomAccessFile randf=new
         RandomAccessFile("1.txt","rw");
        for (int i=0;i<data_arr.length;i++){
         randf.writeInt(data_arr[i]);
        }
          for(int i=data_arr.length-1;i>=0;i--) {   
    randf.seek(i*4);
                System.out.println(randf.readInt()); 
    }
          randf.close();
       }catch (IOException e) {  
   System.out.println("File access error: "+e);
  } 
 }

六、流的高级应用
1、管道流
管道用来把一个程序、线程和代码块的输出连接到另一个程序、线程和代码块的输入java.io中提供了类PipedInputStream和PipedOutputStream作为管道的输入/输出流。
管道输入流作为一个通信管道的接收端，管道输出流则作为发送端。管道流必须是输入输出并用，即在使用管道前，两者必须进行连接。
管道输入/输出流可以用两种方式进行连接：
– 在构造方法中进行连接
◇ PipedInputStream(PipedOutputStream pos);
◇ PipedOutputStream(PipedInputStream pis);
– 通过各自的connect()方法连接
◇ 在类PipedInputStream中，• connect(PipedOutputStream pos)；
◇ 在类PipedOutputStream中，• connect(PipedInputStream pis)；

2、对象流 
对象的持续性（Persistence）：能够纪录自己的状态一边将来再生的能力,叫对象的持续性。
对象的串行化（Serialization）：对象通过写出描述自己状态的的数值来记录自己的过程叫串行化。串行化的主要任务是写出对象实例变量的数值，– 如果变量是另一个对象的引用，– 则引用的对象也要串行化。这个过程是递归的
对象流：能够输入输出对象的流称为对象流。可以将对象串行化后通过对象输入输出流写入文件或传送到其它地方。
在java中，允许可串行化的对象在通过对象流进行传输。只有实现Serializable接口的类才能被串行化， Serializable接口中没有任何方法，当一个类声明实现Serializable接口时，只是表明该类加入对象串行化协议。要串行化一个对象，必须与一定的对象输出/输入流联系起来，通过对象输出流将对象状态保存下来(将对象保存到文件中，或者通过网络传送到其他地方) ，再通过对象输入流将对象状态恢复。类ObjectOutputStream和ObjectInputStream分别继承了接口ObjectOutput和ObjectInput，将数据流功能扩展到可以读写对象，前者用writeObject()方法可以直接将对象保存到输出流中，而后者用readObject()方法可以直接从输入流中读取一个对象。