第18章 java I/O系统（2）

18.2 输入和输出

18.2.1 InputStream类型

InputStream的作用是用来表示那些从不同数据源产生输入的类。这些数据源包括：

1）字节数组。2）String对象。3）文件。4）“管道”，工作方式与实际管道相似，即，从一段输入，从另一端输出。5）一个由其他中类的数据流组成的序列，以便我们可以将他们手机合并到一个流内。6）其他数据源。

每种数据源都有相应的InputStream子类。另外，FilterInputStream也属于一种InputStream，为“装饰器”（decorator）类提供基类，其中，“装饰器”类可以把属性或有用的接口与输入流连接在一起。

InputStream类型：

（1）ByteArrayInputStream：功能：允许将内存的缓冲区当做InputStream。用法：缓冲区，直接将从中取出；作为一种数据源：将其与FilterInputStream对象相连以提供有用接口。

（2）StringBufferInputStream：功能：将String转换成InputStream。用法：字符串。底层实现实际使用StringBuffer；作为一种数据源：将其与FilterInputStream对象相连以提供有用接口。

（3）FileInputStream：功能：用于文件中读取信息。用法：字符串，表示文件名，文件或FileDecriptor对象。作为一种数据源：将其与FilterInputStream对象相连以提供有用接口。

（4）PiledInputStream：功能：产生用于写入相关PiledOutputStream的数据。实现“管道化”概念。用法：PileOutputStream；作为多线程中数据源：将其与FilterInputStream对象相连以提供有用接口。

（5）SequenceInputStream：功能：将两个或多个InputStream对象转换成一个InputStream。用法：两个InputStream对象或一个容纳InputStream对象的容器Enumeration；作为一种数据源：将其与FilterInputStream对象相连以提供有用接口。

（6）FIlerInputStream：功能：抽象类，作为“装饰器”的接口。其中，“装饰器”为其他的InputStream类提供有用功能。

18.2.1 OutputStream类型

该类别的类决定了输出所要去往的目标：字节数组，文件或管道。

（1）ByteArrayOutputStream：功能：在内存中创建缓冲区。所有送往“流”的数据都要防止在此缓冲区。用法：缓冲区初始化尺寸（可选）；用于指定数据的目的地：将与FilterOutputStream对象相连以提供有用的接口。

（2）FileOutputStream：功能：用于将信息写至文件。用法：字符串，表示文件名，文件或FIleDescriptor对象。用于指定数据的目的地：将与FilterOutputStream对象相连以提供有用的接口。

（3）PipedOutputStream：功能：任何写入其中的信息都会自动作为相关PipledInputStream的输出，实现“管道化”概念。用法：PipledInputStream；指定用于多线程的数据目的地：将其与FilterOutputStream对象相连以提供有用接口。

（4）FilterOutputStream：用法：抽象类，作为“装饰器”的接口，其中，“装饰器”为其他OutputStream提欧共有用功能。

18.3 添加属性和有用的接口

FilterInputStream类型：

（1）DataInputStream：功能：与DataOutputStream搭配使用，因此我们可以按照可移植方式从流读取基本数据类型（int，char，long）。用法：InputStream包含用于读取基本类型数据的去阿奴接口。

（2）BufferedInputStream：功能：使用它可以防止每次读取时都得进行实际写操作。代表“使用缓冲区”。用法：InputStream，可以指定缓冲区大小；本子上不提供接口，只不过是向进程中添加缓冲区所必需的。与接口对象搭配。

（3）LineNumberInputStream：功能：跟中输入流中的行号，可调用getLineNumber（）和setLineNumber(int)。用法：InputStream；仅增加了行号，因此可能也要与接口对象搭配使用。

（4）PushbackInputStream：功能：具有“能弹出一个字节的缓冲区”。因此可以将读到的最后一个字符回退。用法：InputStream；通常作为编译器的扫描器，之所以包含在内是因为Java编译器的需求，我们可能永远不会用到。

FilterOutputStream类型：

（1）DataOutStream：功能：与DataInputStream搭配使用，因此可以按照可一直方式向流中些人基本类型数据。用法：OutputStream，包含用于写入基本类型数据的全部接口。

（2）PrintStream：功能：用于产生格式化输出。其中DataOutputStream处理数据的存储，PrintStream处理显示。用法：OutputStream，可以用boolean值只是是否每次换行时清空缓冲区，（可选的）应该是对OutputStream对象的final封装。坑你会经常使用它。

（3）BufferedOutputStream：功能：使用它以避免每次发送数据时都要进行实际的写操作。代表“使用缓冲区”。可以调用flush（）清空缓冲区。用法：OutputStream，可以指定缓冲区的大小。本质上并不提供接口，只不过是向进程中添加缓冲区所必需的，与接口对象搭配使用。

 18.4 Reader和Writer

有时我们必需把来自与“字节”层次接口中的类和“字符”层次结构中的类结合起来使用。为了实现这个目的，要用到“适配器”（adapter）类：InputStreamReader可以把InputStream转换为Reader，而OutputWriter可以把OutputStream转换成Writer。

 18.5 自我独立的类：RandomAccessFile

这是个独立的类：后面再研究

 18.6 I/O流的典型使用方式

18.6.1 缓冲输入文件

package com.thinkinjava.chapter18.part6;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedInputFile {

    public static void main(String[] args) throws IOException {
        
        String str = read("src/com/thinkinjava/chapter18/part6/BufferedInputFile.java");
        System.out.println(str);
    }

    /** 
    * @Title: read 
    * @Description:  缓冲输入文件
    * @param @param filename
    * @param @return 
    * @param @throws IOException    
    * @return String    
    * @throws 
    */
    public static String read(String filename) throws IOException {
        BufferedReader in = new BufferedReader(new FileReader(filename));//字符缓冲流
        String s ;
        StringBuilder sb = new StringBuilder();
        while((s = in.readLine()) !=null){
            sb.append(s+"
");
        }
        in.close();
        return sb.toString();
        
    }

}

18.6.2 从内存输入

package com.thinkinjava.chapter18.part6;

import java.io.IOException;
import java.io.StringReader;

public class MemoryInput {
    
    
    /** 
    * @Title: main 
    * @Description:  从内存中输入
    * @param @param args
    * @param @throws IOException    
    * @return void    
    * @throws 
    */
    public static void main(String[] args) throws IOException {
        
        
        StringReader in = new StringReader(BufferedInputFile.read("src/com/thinkinjava/chapter18/part6/MemoryInput.java"));
        int c;
        while((c = in.read()) != -1){//read()是以int形式返回下一个字节，因此必须类型转换成char才能正确打印
            System.out.print((char) c);
        }
    }
    
}    

18.6.3 格式化的内存输入

package com.thinkinjava.chapter18.part6;

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;

public class FormattedMemoryInput {
    
    
    /** 
    * @Title: main 
    * @Description:  读取格式化数据，使用DataInputStream,他是一个面向字节的I/O类
    * DataInputStream用readByte()一次一个字节地读取字符，那么任何字节的值都是合法的结果，
    * 因此返回值不能用啦检测输入是否结束。相反，我们可以使用available方法差看还有多少可供存取的字符。
    * 
    * @param @param args
    * @param @throws IOException    
    * @return void    
    * @throws 
    */
    public static void main(String[] args) throws IOException {
        
        
        try {
            DataInputStream in = new DataInputStream(new ByteArrayInputStream(BufferedInputFile.read("src/com/thinkinjava/chapter18/part6/FormattedMemoryInput.java").getBytes()));
            while(true){
                System.out.print((char)in.readByte());
            }
        } catch (EOFException e) {
            e.printStackTrace();
            System.out.println("End of stream");
        }
    }
    
    
}

18.6.4 基本文件输出

package com.thinkinjava.chapter18.part6;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;

public class BasicFileOutput {
    
    /** 
    * @Title: main 
    * @Description:  
    * 首先：创建一个与指定文件链接的FileWriter。实际上，我们通常会用BufferedWriter将其包装起来用以缓冲输出。
    * @param @param args
    * @param @throws IOException    
    * @return void    
    * @throws 
    */
    public static void main(String[] args) throws IOException {
        
        String file = "src/com/thinkinjava/chapter18/part6/BasicFileOutput.txt";
        
        BufferedReader in = new BufferedReader(new StringReader(BufferedInputFile.read("src/com/thinkinjava/chapter18/part6/BasicFileOutput.java")));
        
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(file)));
        
        int lineCount = 1;
        String s;
        while((s = in.readLine()) != null){
            out.println(lineCount++ +"："+s);
        }
        out.close();
        System.out.println(BufferedInputFile.read(file));
    }
    
}

文本文件输出的快捷方式

package com.thinkinjava.chapter18.part6;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;

public class FileOutputShortcut {

    public static void main(String[] args) throws IOException {

        String file = "src/com/thinkinjava/chapter18/part6/FileOutputShortcut.txt";
        BufferedReader in = new BufferedReader(new StringReader(BufferedInputFile.read("src/com/thinkinjava/chapter18/part6/FileOutputShortcut.java")));
        PrintWriter out = new PrintWriter(file);
        int lineCount = 1;
        String s ;
        while((s = in.readLine()) != null)
            out.println(lineCount++ +":"+s);
        out.close();
        System.out.println(BufferedInputFile.read(file));
        
    }

}

18.6.5 存储和恢复数据

package com.thinkinjava.chapter18.part6;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class StoringAndRecoveringData {

    public static void main(String[] args) throws IOException {
        
        String file = "src/com/thinkinjava/chapter18/part6/StoringAndRecoveringData.txt";
        
        DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
        
        out.writeDouble(3.141592);
        out.writeUTF("Htat was pi");
        out.writeDouble(1.41413);
        out.writeUTF("Square root of 2");
        out.close();
        
        DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
        
        System.out.println(in.readDouble());
        System.out.println(in.readUTF());
        System.out.println(in.readDouble());
        System.out.println(in.readUTF());
        
        
        
        
        
        
        
        
    }

}

18.6.6 存储和恢复数据

package com.thinkinjava.chapter18.part6;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class UsingRandomAccessFile {
    
    public static void main(String[] args) throws IOException {
        
        String file= "src/com/thinkinjava/chapter18/part6/UsingRandomAccessFile.txt";
        RandomAccessFile rf = new RandomAccessFile(file, "rw");
        
        for (int i = 0; i < 7; i++) {
            rf.writeDouble(i*1.414);
        }
        rf.writeUTF("The end of the file");
        rf.close();
        
        rf = new RandomAccessFile(file, "rw");
        
        rf.seek(5*8);
        rf.writeDouble(47.0001);
        rf.close();
        display();
    }

    public static void display() throws IOException {
        
        String file= "src/com/thinkinjava/chapter18/part6/UsingRandomAccessFile.txt";
        RandomAccessFile rf = new RandomAccessFile(file, "r");
        
        for (int i = 0; i < 7; i++) {
            System.out.println("Value"+i+":"+rf.readDouble());
        }
        System.out.println(rf.readUTF());
        rf.close();
    }
    
    
}

 18.7 文件读写的使用工具

package com.thinkinjava.chapter18.part7;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.TreeSet;

@SuppressWarnings("serial")
public class TextFile extends ArrayList<String>{
    
    /** 
    * @Title: read 
    * @Description:  将文件的内容通过字符缓冲流读取到字符串中
    * @param @param fileName
    * @param @return    
    * @return String    
    * @throws 
    */
    public static String read(String fileName){
        
        StringBuilder sb = new StringBuilder();
        
        try {
            
            BufferedReader in = new BufferedReader(new FileReader(new File(fileName).getAbsoluteFile()));
            try{
                String s;
                while((s = in.readLine()) != null){
                    sb.append(s);
                    sb.append("
");
                }
            }finally{
                in.close();
            }
        
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return sb.toString();
    }
    
    
    
    /** 
    * @Title: write 
    * @Description:  将字符输出到指定文件中
    * @param @param fileName
    * @param @param text    
    * @return void    
    * @throws 
    */
    public static void write(String fileName,String text){
        
        try {
            PrintWriter out = new PrintWriter(new File(fileName).getAbsoluteFile());
            
            try{
                out.print(text);
            }finally{
                out.close();
            }
            
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        
    }
    
    public TextFile(String fileName,String splitter) {
        super(Arrays.asList(read(fileName).split(splitter)));
        if(get(0).equals(""))
            remove(0);
    }
    
    public TextFile(String fileName){
        this(fileName,"
");
    }
    
    /** 
    * @Title: write 
    * @Description:  将list的字符输出到指定文件中
    * @param @param fileName    
    * @return void    
    * @throws 
    */
    public void write(String fileName){
        
        try {
            PrintWriter out = new PrintWriter(new File(fileName).getAbsoluteFile());
            try{
                for(String item : this)
                    out.println(item);
            }finally{
                out.close();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    
    
    
    public static void main(String[] args) {
        
//        String file = read("src/com/thinkinjava/chapter18/part7/TextFile.java");
//        String outFile = "src/com/thinkinjava/chapter18/part7/text.txt";
//        write(outFile , file);
        
//        String outFile2 = "src/com/thinkinjava/chapter18/part7/text2.txt";
//        TextFile text = new TextFile(outFile);
//        text.write(outFile2);
        
        TreeSet<String> words = new TreeSet<String>(new TextFile("src/com/thinkinjava/chapter18/part7/TextFile.java","\W+"));
        
        System.out.println(words.headSet("a"));
        
        
    }
    
    
    
}

将文件读入到字节数组中

package com.thinkinjava.chapter18.part7;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class BinaryFile {
    
    
    /** 
    * @Title: read 
    * @Description:  
    * 将文件读入到字节数组中
    * @param @param bFile
    * @param @return
    * @param @throws IOException    
    * @return byte[]    
    * @throws 
    */
    public static byte[] read(File bFile) throws IOException{
        
        BufferedInputStream bf = new BufferedInputStream(new FileInputStream(bFile));
        try{
            byte[] data =new byte[bf.available()];
            bf.read(data);
            return data;
        }finally{
            bf.close();
        }
    }
    
    
    /** 
    * @Title: read 
    * @Description:  根据文件路径 将文件读入字节数组中
    * @param @param bFile
    * @param @return
    * @param @throws IOException    
    * @return byte[]    
    * @throws 
    */
    public static byte[] read(String bFile) throws IOException{
        return read(new File(bFile).getAbsoluteFile());
    }
    
    public static void main(String[] args) throws IOException {
        byte[] read = read("src/com/thinkinjava/chapter18/part7/text.txt");
        System.out.println(read);
        for (byte b : read) {
            System.out.print((char)b);
        }
        
    }
    
}

 18.8 标准I/O

package com.thinkinjava.chapter18.part8;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/** 
 * @ClassName: Echo 
 * @Description:从标准输入中读取 
 * @author 
 * @date 2018年3月24日 下午2:46:57 
 * @version 1.0 
 */
public class Echo {
    
    /** 
    * @Title: main 
    * @Description:标准I/O
    * 从控制台输入然后输出  
    * @param @param args
    * @param @throws IOException    
    * @return void    
    * @throws 
    */
    public static void main(String[] args) throws IOException{
        
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
        String s;
        while((s = stdin.readLine()) != null && s.length() != 0)
            System.out.println(s);
        
        
    }
    
    
}

package com.thinkinjava.chapter18.part8;

import java.io.PrintWriter;

public class ChangeSystemOut {
    
    /** 
    * @Title: main 
    * @Description:将System.out转换成PrintWriter  
    * @param @param args    
    * @return void    
    * @throws 
    */
    public static void main(String[] args) {
        
        //第二个参数设为true，以便开启自动清空功能，否则，你可能看不到输出
        PrintWriter out = new PrintWriter(System.out,true);
        out.println("hello, world");
    }
    
}

package com.thinkinjava.chapter18.part8;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;

public class Redirecting {
    
    /** 
    * @Title: main 
    * @Description:  
    * 将标准输入附接到文件上，并将标准输出和标准错误重定向到另一个文件。
    * @param @param args
    * @param @throws IOException    
    * @return void    
    * @throws 
    */
    public static void main(String[] args) throws IOException {
        
        PrintStream console = System.out;
        
        BufferedInputStream in = new BufferedInputStream(new FileInputStream("src/com/thinkinjava/chapter18/part8/Redirecting.java"));
        
        PrintStream out = new PrintStream(new BufferedOutputStream(new FileOutputStream("src/com/thinkinjava/chapter18/part8/test.txt")));
        
        System.setIn(in);
        System.setOut(out);
        System.setErr(out);
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        String s;
        
        while((s = br.readLine()) != null)
            System.out.println(s);
        
        out.close();
        System.setOut(console);
        
        
    }
    
}