Java IO中几个主要类介绍和使用

1. I/O流可以有三种分类方法.

第一, 输入流,输出流 .
第二, 字节流,字符流 . 
第三, 节点流(真正直接处理数据的) ,处理流(装饰加工节点流的) .

2. 字节流

抽象类 <– 面向字节的文件流 .  
InputStream <– FileInputStream  
OutputStream <– FileOutputStream  

常用方法 
InputStream  int read(byte [] c,int off, int len)  
OutputStream voidwrite(byte [] c,int off, int len) .

3. 字符流

抽象类 <– 面向字符文件流 .
Reader <– FileReader 
Writer <— FileWriter 

常用方法 
FileReader int read(char [] c,int off, int len)   
FileWriter voidwrite(char [] c,int off, int len) .

4. 节点流和处理流

类
BufferdReader 可以称作字符、输入、处理流 .

方法
String readLine()

BufferdReader构造函数接受的是 Reader 类型的参数

4. Java中io类是典型的装饰者模式

5. 示例

import java.io.*;
public class Filerw{
    public static void main (String args[]){
        Filerw filerw=new Filerw();
        //filerw.readAndWrite();
        filerw.bufferReader();
    }
        /**
        *   1.使用输入输出流操作文件
        */
        public void readAndWriteStream(){
            FileInputStream inStream=null;
            FileOutputStream outStream=null;
            try{
                //生成一个输入流的对象  
                inStream=new FileInputStream(“e:/javapro/FileDemo/from.txt”);  
                //生成一个输入流的对象  
                outStream=new FileOutputStream(“e:/javapro/FileDemo/to.txt”);  
                byte[] buffer=new byte[1024];
                int len=0;
                //读取文件
                len=inStream.read(buffer,0,buffer.length);
                for(int i=0; i<len; i++){
                    System.out.print(buffer[i]);
                }
                //写入到文件
                outStream.write(buffer,0,len);
            }catch (Exception  e){
                System.out.print(e);
            }finally{
                try{
                    inStream.close();
                    outStream.close();
                }catch (Exception e){
                    System.out.print(e);
                }
            }
        }
        /**
        *   2.使用字节流操作文件
        */
        public void readAndWrite(){
            FileReader reader=null;
            FileWriter writer=null;
            try{
                //生成一个字符输入流的对象  
                reader=new FileReader(“e:/javapro/FileDemo/from.txt”);  
                //生成一个字符输入流的对象  
                writer=new FileWriter(“e:/javapro/FileDemo/to.txt”);  
                char[] buffer=new char[1024];
                int len=0;
                //读取文件
                len=reader.read(buffer,0,buffer.length);
                for(int i=0; i<len; i++){
                    System.out.print(buffer[i]);
                }
                //写入到文件
                writer.write(buffer,0,len);
            }catch (Exception  e){
                System.out.print(e);
            }finally{
                try{
                    reader.close();
                    writer.close();
                }catch (Exception e){
                    System.out.print(e);
                }
            }
        }
        /**
        *   3.使用节点流和处理流操作文件
        */
        public void bufferReader(){
            FileReader reader=null;  
            BufferedReader bufferedReader=null;  
            try{
                reader=new FileReader(“e:/javapro/FileDemo/fromlinetext.txt”);
                bufferedReader=new BufferedReader(reader);
                String line=null;
                while((line=bufferedReader.readLine())!=null){  
                    //line=bufferedReader.readLine();  
                    System.out.println(line);  
                }
            }catch (Exception e){
                System.out.print(e);
            }finally{
                try{
                    reader.close();
                    bufferedReader.close();
                }catch (Exception e){
                    System.out.print(e);
                }
            }
        }
}
梦想还是要有的,万一实现了呢?