黑马程序员--IO流（第二篇）

——- android培训、java培训、期待与您交流！ ———-

从小我们就学着读书、写字，貌似IO流就是在教会计算机读和写；生活有时候就是这么神奇，that’s just life。计算机都会学习了，我们还等什么呢？我热爱我的热爱，并将继续坚持我的热爱，我会是那匹黑马。

IO流–第二篇
一 、转换流

读取转换流：InputStreamReader
写入转换流：OutputStreamReader

读取转换流：InputStreamReader 字节流通向字符流的桥梁
步骤
1.获取键盘录入对象
Inputstream in=System.in
2.将字节流对象转换成字符流对象，使用转换：InputStreamReader
InputStreamReader isr=new InputStreamReader(in);
3.提高效率使用字符流缓冲区 BufferedReader进行读取

    BufferedReader bf=new BufferedReader(is); 
    String line=null; 
    while((line=bf.readLine())!=null) 
    { 
        if(“over”.equals(line)) 
        break; 
        System.out.println(line”); 
    } 
    bufr.close;

写入转换流：OutputStreamReader 字符流通向字节流的桥梁
步骤：
1.获取输出对象
Outputstream out=System.out
2.将字符流对象转换成字节流对象，使用转换：OutputstreamWriter
OutputstreamWriter osw=new OutputstreamWriter(out);
3.提高效率使用字符流缓冲区 BufferedWriter进行写入

BufferedWriter bw=new BufferedWriter(osw); 
String line=null; 
while((line=bf.readLine())!=null) 
{ 
if(“over”.equals(line)) 
break; 
bw.write(line); 
bufw.newLine(); 
} 
bufr.close;

键盘录入：
BufferedReader bufr = new BufferedReader(newInputStreamReader(System.in));
控制台输出：
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
注：转换流可以指定编码格式

二、打印流
该流提供了打印方法，可以将各种数据类型的数据都原样打印。

字节打印流： PrintStream
构造函数可以接收的参数类型：
1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream

字符打印流： PrintWriter
构造函数可以接收的参数类型：
1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream
4，字符输出流，Writer。

import java.io.*;

class  PrintStreamDemo{
    public static void main(String[] args) throws IOException{
        BufferedReader bufr = 
            new BufferedReader(new InputStreamReader(System.in));

        PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);

        String line = null;

        while((line=bufr.readLine())!=null){
            if("over".equals(line))
                break;
            out.println(line.toUpperCase());
            //out.flush();
        }

        out.close();
        bufr.close();

    }   
}

三、对象流
输出对象流：ObjectOutputStream
输入对象流：ObjectInputStream

import java.io.*;  

    class Person implements Serializable{  

    // public static final long serialVersionUID = 42L;  
     // 如果标识唯一标识码，则不会改变  
    private String name;  
    transient int age;  
    // transient 标记不会记录进去  
    static String country = "cn";  
    Person(String name,int age,String country){  
        this.name = name;  
        this.age = age;  
        this.country = country;  
    }  
    public String toString(){  
        return name+":"+age+":"+country;  
    }  
}  

public class ObjectStreamDemo {  
    public static void main(String[] args) throws Exception {  

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\\object.txt"));  
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\object.txt"));  
        oos.writeObject(new Person("nuddles",34,"cn") );  
        Person p = (Person)ois.readObject();  
        sop(p);  
        oos.close();  
        ois.close();  

    }  
    public static void sop(Object obj){  
        System.out.println(obj);  
    }  

}  

四 、合并流
SequenceInputStream

import java.io.*;  
import java.util.*;  

public class SequenceDemo  {  
    public static void main(String[] args) throws IOException{  
        Vector<InputStream> vector = new Vector<InputStream>();  
        // Vector是一种枚举  
        vector.add(new FileInputStream("d:\\1.txt"));  
        vector.add(new FileInputStream("d:\\2.txt"));  
        vector.add(new FileInputStream("d:\\3.txt"));  
        vector.add(new FileInputStream("d:\\4.txt"));  
        FileOutputStream out = new FileOutputStream("d:\\heihei.txt");  
        marge(vector,out);  
    }  
    public static void marge(Vector<InputStream> vector,OutputStream out) throws IOException{  
        SequenceInputStream sis = new SequenceInputStream(vector.elements());  
        byte[] by = new byte[1024];  
        int len =0;  
        while ((len=sis.read(by))!=-1) {  

            out.write(by,0,len);  
            out.flush();  
        }  
        sis.close();  
        out.close();  

    }  
}  

五、RandomAccessFile

该类不是算是IO体系中子类，而是直接继承自Object。 但是它是IO包中成员，因为它具备读和写功能。 内部封装了一个数组，而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置， 同时可以通过seek改变指针的位置。 其实完成读写的原理就是内部封装了字节输入流和输出流。 通过构造函数可以看出，该类只能操作文件。 而且操作文件还有模式：只读r，，读写rw等。 如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。
如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

import java.io.*;  
import java.util.*;  
public class RandomAccessFileDemo  {  
         public static void main(String[] args) throws IOException{  
                   write();  
         }  
         public static void sop(Object obj){  
                   System.out.println(obj);  
         }  
         public static void write() throws IOException{  
                   RandomAccessFile raf = new RandomAccessFile("d:\\nuddles.txt","rw");  
                   raf.write("this is my file".getBytes());  
                   raf.skipBytes(8);  
                   raf.writeInt(56);  
                   raf.seek(0);  
                   // 读之前要跳回到0指针处  
                   byte[] by = new byte[1024];  
                   raf.read(by);  
                   String s = new String(by);  
                   sop(s);  
                   raf.close();  
         }  
}  

六、其他流
DataInputStream与DataOutputStream
可以用于操作基本数据类型的数据的流对象。 有相应读写各种类型的方法，特殊方法：readUTF/writeUTF

用于操作字节数组的流对象。
ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。
ByteArrayOutputStream： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数

七、对于流操作基本操作规律
两个明确:
1.明确源和目的
源：输入流，InputStream字节流 Reader 字符流
目的：输出流 ，OutPutStream 字节流 Writer 字符流
2.操作的数据是否是纯文本
是，就是字符流 如果设备是键盘 就将字节流转换为字符流 。
不是， 就是 字节流
3.当体系明确后，在明确要是用那个具体的对象
通过设备来区分
源设备： 内存 硬盘 键盘
目的设备： 内存 硬盘 控制台
4.是否需要提高效率
是： BufferedReader BufferedInputStream
否 ：BuffreredWriter BufferedOutputStream
案例分析 ：
1.将一个文本文件中的数据存储到另一个文件中，复制文件

源： InputStream字节流 Reader 字符流
是否是纯文本 是 Reader
设备： 文件 操作文件的对象 就是FileReader
是否需要高效
是 BufferedReader
FileReader fr=new FileReader(“a.txt”);
BufferedReader bufr=new BufferedReader(fr);

目的 ： OutPutStream 字节流 Writer 字符流
是否是纯文本 ：是 Writer
设备: 文件 写入文件的对象 就是 FileWriter
是否需要高效 是 BufferedWriter
FileWriter fw=new FileWriter(“b.txt”);
BufferedWriter bufw=new BufferedWriter(fw);

扩展 ：
想要吧录入的数据按照指定的编码表（utf-8）将数据存到文件中
目的:OutPutStream 字节流 Writer 字符流
是否是存文本：是 Writer
设备 ：文件 fileWriter
默认编码表是 gbk
编码标只有转换流可以指定。所以要使用的对象是写入转换流 OutputStreamWriter
转换流需要接受一个自己输出流，操作字节输出流的是FileOutputStream
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream(“b.txt”),”utf-8”);
BufferedWriter bufw=new BufferedWriter (osw);
通常涉及到字符编码转换的时候，就需要用到转换流。

---

Keep your face to the sunshine, and you cannot see a shadow.