14 Java IO流-阿里云开发者社区

IO(Input Output)流

IO流用来处理设备之间的数据传输

Java对数据的操作时通过流的方式

Java用于操作流的对象都在IO包中

流按操作数据分为两种: 字节流和字符流

流按类型分为: 输入流, 输出流

IO流常用基类

字节流的抽象基类对象: InputStream, OutputStream

字符流的抽象基类对象: Reader, Writer
注:有这四个类派生出来的子类名称都是由其父类名作为子类名的后缀.
如: InputStream 的子类 FileInputStream
如: Reade r的子类 FileReader

完整的流家族

输入流与输出流的层次结构

Reader 和 Writer 的层次结构

FileReader和FileWriter流

创建一个 FileWriter 对象,该文件会在指定目录下创建.

如果同名则覆盖, 除非构造方法第二个参数append 为 true; 由此可得默认为false.

/**
     * 
     * @param  str
     *         String to be written
     *         
     * @throws IOException
     */
    public static void createFile(String str) throws IOException{
        //在D盘下创建abc.txt. 如果同名则覆盖,除非构造方法第二个参数append为true;        
        File file = new File("D:" + File.separator + "abc.txt");        
        FileWriter fw = new FileWriter(file, false);             
        fw.write(str);                      
        fw.flush(); //关闭流对象,之前会flash一次缓冲中的数据.      
        fw.close(); //与flush的区别: flush刷新后流可以继续使用,close却将流关闭,不可再写入       
    }

IO异常的标准处理方式一(以FileWriter为例)

String fileName = "D:" + File.separatorChar + "abc.txt";
        FileWriter fw = null;       
        try {
            fw = new FileWriter(fileName);
            fw.write("balabala...");
            fw.flush();
        } catch (IOException e) {
            //检查异常转为非检查异常
            throw new RuntimeException("产生IO异常");
        } finally {
            if (fw != null)
                try {
                    fw.close();
                } catch (IOException e) {
                    throw new RuntimeException("流关闭异常");
                }
        }

IO异常的标准处理方式二(SE 7 try-with-resources方式)

String fileName = "D:" + File.separatorChar + "abc.txt";
        try (FileWriter fw = new FileWriter(fileName)) {
            fw.write("balabala...");
            fw.flush();
        } catch (IOException e) {
            //检查异常转为非检查异常
            throw new RuntimeException("产生IO异常");
        }

使用FileReader读取文本文件方式一

int ch = 0;
     while((ch=fr.read())!=-1){
          //relevant operation
     }

使用FileReader读取文本文件方式二(较方法一好,推荐使用)

int len= 0;
     char[] buf = new char[1024];
     while((len=fr.read(buf))!=-1){
          //relevant operation
     }

拷贝文件(建议使用方式二)

//relevant operation --> fileWriter.write(buf,0,len);

字符流的缓冲流BufferedReader与BufferedWriter

提高了对数据的读写效率

对应类:BufferedReader和BufferedWriter

缓冲区要结合流才可以使用

在流的基础上对流的功能进行了增强

BufferedWriter

为提高字符写入流的效率,只要将需要提高效率的流对象作为参数传递到BufferedWriter的构造方法.

BufferedWriter有自己特有的readLine()方法, 这是不包含行结束符的

如果需要每次换行则bfr.newLine(), 并且还要flush()一下.最后不要忘记close流.
//我的理解是BufferedWriter和BufferedReader都是基于原流,且衷于原流.提供了每行的写与读,而不参杂多余的行终止符.所以要每次自己换行.

BufferedReader

读取数据

String line = null;
        while((line=bfr.readLine())!=null){
            //relevant operation
        }

使用BufferedWriter, BufferedReader拷贝文件关键代码

String line = null;
         while((line=bfr.readLine())!=null){
              bfr.write(line);
              bfr.newLine();
              bfr.flush();
         }

牵扯到装饰设计模式

当先要对已有对象进行功能增强时,可以定义类,将已有对象传入,基于已有的功能,并提供加强功能.

装饰类通常会通过构造方法接收被装饰的对象,并基于被装饰的对象的功能,提供更强的功能.

装饰模式比继承要灵活,避免了继承体系臃肿.而且降低了类与类之间的关系,装饰类因为增强已有对象,具备的功能和已有的是相同的,只不过提供了更强功能.所以装饰类和比装饰类通常是都属于一个体系中.

LineNumberReader

BufferedReader()的子类,只是多了标号而已.

通过setLineNumber设置初始行号, 和输出可以getLineNumber获取每行的行号

字节流FileOutputStream和FileInputStream

可以进行二进制形式进行图片, 音乐等文件的读写.

//拷贝一个图片
     public static void copyFile() throws IOException{
          InputStream fis = new FileInputStream("D:\\source.jpg" );
          OutputStream fos = new FileOutputStream("D:\\dst.jpg" );
           int len = 0;
           byte[] buf = new byte[1024];
           while((len=fis.read(buf))!=-1){
              fos.write(buf, 0, len);
          }
          fis.close();

拷贝一首歌(使用字节流的Buffered缓冲区)

InputStream inputStream = new BufferedInputStream(
          new FileInputStream("D:" + File.separator + "刘涛 - 说不出口.mp3"));        
OutputStream outputStream = new BufferedOutputStream(
          new FileOutputStream("D:" + File.separator + "刘某 - 就不要说.mp3"));

键盘录入(InputStreamReader和OutputStreamWriter转换流)

System.out: 对应的是标准输入设备,控制台

System.in: 对应的是标准输出设备,键盘

练习: 通过键盘录入,当输入一行数据后将改行数据进行打印,如果录入的数据是over,那么停止录入.

//方法一: 传统思考
//要点记住回车的处理方式:  ASCII码 13 '\r', 10 '\n'
public static void method1() throws IOException{        
        final InputStream in = System.in;
        int character ;
        final StringBuilder stringBuilder = new StringBuilder();
        while(true){
            character = in.read();
            switch (character) {
            case '\r':              
                break;
            case '\n':
                final String result = stringBuilder.toString();
                if("over".equals(result)){
                    return;
                }   
                //StringBuilder的清空方式
                stringBuilder.delete(0, stringBuilder.length());
                break;
            default:
                stringBuilder.append((char)character);
                break;
            }
        }   
    }
//方法二: InputStreamReader转换流,将字节流转成字符流的桥梁,然后经缓冲包装提高效率    
public static void method2() throws IOException{        
        final InputStream in = System.in;
        final BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(in));
        String line = null;
        while ((line = bufferedReader.readLine())  != null) {
            if("over".equals(line)){
                break;
            }
        }       
    }
//方法三: Scanner  [5.0]
    public static void method3(String[] args) throws IOException {  
        final InputStream in = System.in;
        String line = null;
        final Scanner scanner = new Scanner(in);
        while(scanner.hasNextLine()){
            line = scanner.nextLine();
            if("over".equals(line)){
                break;
            }           
        }       
    }

OutputStreamWriter转换流

和InputStreamReader类似,是字符流通向字节流的桥梁.只是包装System.out在缓冲后.

OutputStream os = System.out;       
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(os); 
outputStreamWriter.write("cba");    
outputStreamWriter.flush();     
outputStreamWriter.close();

流操作规律

明确源和目的

是否是纯文本(字节流和字符流的选取), 具体使用哪个对象

是否需要提高效率而加入缓冲

这其中涉及到的OutputStream(OutputStream out, String charsetName)就是字符转字节的桥梁,并可以指定自定义编码,例如"UTF-8",这也是转换流出现的原因.

改变标准输入输出设备

System的setIn()方法重新分配“标准”输入流。否则标准输入流一般都是键盘InputStream.

System的setOut()方法重新分配“标准”输出流。否则标准输入流一般都是键盘PrintStream.

可以利用这两个已关联的流进行相关操作

打印流 PrintStream和PrintWriter

该流提供了打印方法,可以将各种类型的数据原样打印.

PrintStream

PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。它还提供其他两项功能。与其他输出流不同，PrintStream 永远不会抛出 IOException；而是，异常情况仅设置可通过 checkError 方法测试的内部标志。另外，为了自动刷新，可以创建一个 PrintStream；这意味着可在写入 byte 数组之后自动调用 flush 方法，可调用其中一个 println 方法，或写入一个换行符或字节 ('\n')。

PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。

PrintWriter

增加了字符输出流Writer

// 设置自动刷新
        PrintWriter pw = new PrintWriter(System.out, true);
        String line = null;
        BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
        while ((line = bfr.readLine()) != null) {
            // 这样写比用BufferedWriter更简洁.PrintWriter更适合打印各种数据.
            pw.println(line);
        }

序列流SequenceInputStream(**表示其他输入流的逻辑串联,没有对应的输出流)

练习: 文件的分割与合并

//切割只用字节流,而不是字符流
     public static void split() throws IOException{
          FileInputStream fis = new FileInputStream("d:\\123.pdf" );
          FileOutputStream fos = null;
           int len = 0;
           //1M=1024KB=1024*1024字节 存储
           byte[] buf = new byte[1024*1024];
           int i=0;
           while((len=fis.read(buf))!=-1){
              fos = new FileOutputStream("d:\\" +(++i)+ ".part");
              fos.write(buf, 0, len);
              fos.flush();
              fos.close();;
          }
          fis.close();       
     }
     //文件合并
     public static void meger() throws IOException{
          Vector<FileInputStream> v = new Vector<FileInputStream> ();
           for(int i=1;i<4;i++)
              v.add( new FileInputStream("d:\\" + i+".part"));
          SequenceInputStream sis = new SequenceInputStream(v.elements());
          FileOutputStream fos = new FileOutputStream("d:\\kk.pdf" );       
           int len = 0;
           byte[] buf = new byte[1024];
           while((len=sis.read(buf))!=-1){
              fos.write(buf, 0, len);
          }
          sis.close();
          fos.close();
     }

操作对象的ObjectInputStream与ObjectOutputStream

被操作的对象需要实现Serializable(标记接口)

可序列化类可以通过声明名为 "serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID
ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;
这样生成新的类不会改变UID,而不是使用系统生成的UID.

另外非静态成员变量可以transient修饰不被序列化,同样类(static)变量也不会序列化.

管道流PipedInputStram和PipedOutputStream

输入输出可以直接连接,结合线程使用

PipedInputStream,接收InputStream对象

用于与另一输出管道相连, 读取写入到输出管道中的数据,用于程序中线程的通信

PipedOutputStream, 可以将管道输出流连接到管道输入流来创建通信管道。管道输出流是管道的发送端。通常，数据由某个线程写入 PipedOutputStream 对象，并由其他线程从连接的 PipedInputStream 读取。

public class DemoPipedStream {
    public static void main(String[] args) throws IOException {
        //建立管道读入流
        PipedInputStream pis = new PipedInputStream();
        //建立管道输出流并与读入流关联,也可以写成connect
        PipedOutputStream pos = new PipedOutputStream(pis);
        new Thread(new Write(pos)).start();
        new Thread(new Read(pis)).start();       
    }
}
class Read implements Runnable{
    private PipedInputStream pis;
    public Read(PipedInputStream pis){
        this.pis = pis;
    }
    @Override
    public void run(){   
        byte[] buf = new byte[200];
        try{
            System.out.println("---读取流开始获取信息");
            int len = pis.read(buf);
            System.out.println("--"+new String(buf,0,len));
            System.out.println("---读取流读取流信息完毕");
        }catch(IOException e){
            throw new RuntimeException("流读取异常");
        }
        finally{
            if(pis!=null)
                try{pis.close();}
            catch(IOException e){
                throw new RuntimeException("流关闭异常");
            }
        }
    }  
}
class Write implements Runnable{
    private PipedOutputStream pos;
    public Write(PipedOutputStream pos){
        this.pos = pos;
    }
    public void run(){
        try {
            System.out.println("写入流开始写入流信息,持续3S");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            pos.write("Hello PipedStram".getBytes());
            System.out.println("写入流开始写入完毕");
        } catch (IOException e) {          
            throw new RuntimeException("流写入异常");
        }
        finally{
            if(pos!=null)
                try{pos.close();}
            catch(IOException e){
                throw new RuntimeException("流关闭异常");
            }
        }
    }
}

RandomAccessFile

可以在文件中的任何位置查找或写入数据。磁盘文件都是随机访问的，但是从网络而来的数据流却不是。你可以打开一个随机访问文件，只用于读入或者同

时用于读写.

构造器的第二个参数来指定这个选项。

“ r”表示只读模式；

“ rw”表示读 / 写模式；

“ rws”表示每次更新时，都对数据和元数据的写磁盘操作进行同步的读 / 写模式；

“ rwd”表示每次更新时，只对数据的写磁盘操作进行同步的读 / 写模式

//调整对象中指针
     seek(long pos)
     //尝试跳过输入的 n 个字节以丢弃跳过的字节。
     skipBytes()

操作基本数据类型

以二进制格式读写基本Java类型

DataInputStream与DataOutputstream

操作字节数组

ByteArrayInputStream与ByteArrayOutputStream

操作字符数组

CharArrayReader与CharArrayWriter

操作字符串

StringReader与StringWriter

总结:

以二进制格式写出数据，需要使用 DataOutputStream。

以文本格式写出数据，需要使用 PrintWriter。

PrintWriter printWriter = new PrintWriter("setting.dat", "UTF-8");

字符集

在过去，国际化字符集已经得到了处理，但是处理得很不系统，散布在 Java 类库的各处。在 Java SE 1.4 中引入的 java.nio 包用 Charset 类统一了对字符集的转换（注意 s 是小写的）。

//获取Charset实例
        Charset.defaultCharset(); //默认字符集       
        Charset charset = Charset.forName("UTF-8");//静态获取指定字符集    
        //Returns a set containing this charset's aliases.
        for(String alias: charset.aliases()){
            System.out.println(alias);
        }
        //编码Java字符串
        ByteBuffer bytBuffer = charset.encode("自古中秋月最明, 凉风届候夜弥清");
        byte[] bytes = bytBuffer.array();
        //要想解码字节序列，需要有字节缓冲区
        CharBuffer cbuf = charset.decode(bytBuffer);
        System.out.println(cbuf.toString());

字符编码

//"你好"-->"??"是GBK变utf-8 ; -->"浣犲ソ"是utf-8变GBK

编一次解一次即可.

关闭流

总体可以认为是“先开后关”原则，原因是 IO 流的打开顺序是固定且层层依托的。

然后是closeable关闭的优化

如果new FileOutputStream, 然后上级目录不存在会抛出FileNotFoundException异常, 所以需要先行创建上层文件夹。

14 Java IO流