Java输入/输出（学习总结）

1、流的概念
流：从源到目的地的字节的有序序列；流中的字节依据先进先出，具有严格顺序，因此，I/O是一种顺序存取方式。
输入流：程序可以打开一个从某种数据源到程序的一个流，从这个流中读取数据。只能从输入流中读取，不能向它写数据。
输出流：程序可以打开到外界某种目的地的流，把数据顺序写到该流中，以把程序中的数据保存在外界。只能写，不能读。

2、流的分类

• 按流相对于程序的另一个端点的不同，分为节点流和过滤流。

节点流：以特定源如磁盘文件、内存某区域、线程之间的管道为端点构造的输入输出流，它是一种最基本的流。
过滤流：以其他已经存在的流为端点构造的输入输出流，称为过滤流或处理流，它要对其他相连的另一种流进行某种转换。

• 按根据流中的数据单位不同，分为字节流和字符流。

字节流：流中数据以8位字节为单位进行读写，以InputStream和OutputStream为基础类。
字符流：流中数据以16位字符为单位进行读写，以Reader和Writer为基础类。

3、常用的输入输出流
【1】文件流（属节点流）
对文件系统中的文件进行读写。
（字节流）
FileInputStream
FileOutputStream
（字符流）
FileReader
FileWriteer

字节流示例：

package zyf.file;

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

public class CopyBytes {
    /*
     * 通过文件字节流实现文件的复制*/

    public static void main(String[] args) throws IOException{
        //创建两个File类对象
        File inputFile=new File("A.txt");
        if(!inputFile.exists()){
            inputFile.createNewFile();
        }
        File outputFile=new File("B.txt");
        if(!outputFile.exists()){
            outputFile.createNewFile();
        }

        //创建文件输入输出字节流
        FileInputStream fis=new FileInputStream(inputFile);
        FileOutputStream fos=new FileOutputStream(outputFile);

        int c;
        //读写文件流中的数据
        while((c=fis.read())!=-1){
            fos.write(c);
            System.out.print(c+" ");

        }
        //关闭流
        fis.close();
        fos.close();
    }

}

字符流示例：

package zyf.file;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Copy {

    /**
     * 通过文件字符流实现文件的复制*/
    public static void main(String[] args) throws IOException {
               //创建两个File类对象
                File inputFile=new File("A.txt");
                if(!inputFile.exists()){
                    inputFile.createNewFile();
                }
                File outputFile=new File("B.txt");
                if(!outputFile.exists()){
                    outputFile.createNewFile();
                }

                //创建文件字符输入输出流
                FileReader fr=new FileReader(inputFile);
                FileWriter fw=new FileWriter(outputFile);
                int c;
                //读写数据
                while((c=fr.read())!=-1){
                    fw.write(c);    
                    System.out.print(c+" ");
                }

                //关闭流
                fr.close();
                fw.close();
    }

}

【2】缓存流（属过滤流）
这种流把数据从原始流成块读入或者把数据累积到一个大数据块再成批写出；通过减少系统资源的读写次数来加快程序的执行。
BufferedOutputStream和BufferedWriter类仅在缓冲区满或者调用flush()方法时才将数据写到目的地。
BufferedInputStream / BufferedOutputStream
bufferedReader / BufferedWriter

【3】管道流
可以实现线程间数据的直接传输。线程A可以通过它的输出管道发送数据，另一个线程B把它的输入管道接到A的输出管道上即可接收A发送到数据。
PipedReader / PipedWriter
PipedInputStream / PipedOutputStream

示例：

package zyf.pipe;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.PrintWriter;
import java.io.Reader;

public class RhymingWords {
    /**
     * 使用管道流，实现单词处理程序。
     * 该程序从文件中读入一组单词，先将每个单词逆序，再将所有单词排序，
     * 然后将这些词逆序输出
     * 最后输出的单词列表能够押韵
     * @throws IOException */
    public static void main(String[] args) throws IOException {
        File file=new File("words.txt");
        if(!file.exists()){
            file.createNewFile();
        }
        FileReader words=new FileReader(file);
        //进行单词的逆序、排序、再逆序还原
        Reader rhtmedWords=reverse(sort(reverse(words)));
        //将处理后的单词列表输出显示
        BufferedReader in=new BufferedReader(rhtmedWords);
        String input;
        while((input=in.readLine())!=null){
            System.out.println(input);
        }
        in.close();
    }

    private static Reader sort(Reader source) throws IOException {
        BufferedReader in=new BufferedReader(source);
        PipedWriter pipeOut=new PipedWriter();
        PipedReader pipeIn=new PipedReader(pipeOut);
        PrintWriter out=new PrintWriter(pipeOut);
        new SortThread(out,in).start();
        return pipeIn;
    }

    private static Reader reverse(Reader source) throws IOException {
        BufferedReader in=new BufferedReader(source);
        PipedWriter pipeOut=new PipedWriter();
        PipedReader pipeIn=new PipedReader(pipeOut);
        PrintWriter out=new PrintWriter(pipeOut);
        new ReverseThread(out,in).start();
        return pipeIn;
    }

}

package zyf.pipe;

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

/*
 * 执行逆序的线程类*/
public class ReverseThread extends Thread{
private PrintWriter out=null;
private BufferedReader in=null;
public ReverseThread(PrintWriter out,BufferedReader in){
    this.out=out;
    this.in=in;
}
//处理逆序线程的线程体
public void run(){
    if(out!=null&in!=null){
        try {
            String input;
            while((input=in.readLine())!=null){
                out.println(reverseIt(input));
                out.flush();
            }
            out.close();
        } catch (IOException e) {
            System.err.println("逆序线程的run："+e);
        }
    }
}

//实现单词的逆序算法
private String reverseIt(String source){
    int i,len=source.length();
    StringBuffer dest=new StringBuffer(len);
    for(i=(len-1);i>=0;i--){
        dest.append(source.charAt(i));
    }
    return dest.toString();

}
    public static void main(String[] args) {


    }

}

package zyf.pipe;

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

/*
 * 执行排序的线程类*/
public class SortThread extends Thread{
    private PrintWriter out=null;
    private BufferedReader in=null;
    public SortThread(PrintWriter out,BufferedReader in){
        this.out=out;
        this.in=in;
    }
    //排序线程的线程体
    public void run(){
        int MAXWORDS=50;
        if(out!=null&&in!=null){
            try {
                String[] list=new String[MAXWORDS];
                int numwords=0;
                while((list[numwords]=in.readLine())!=null){
                    numwords++;
                }
                    quickSort(list,0,numwords-1);
                    for(int i=0;i<numwords;i++){
                        out.println(list[i]);
                    }
                    out.close();

            } catch (IOException e) {           
                System.err.println("排序线程的run："+e);
            }
        }
    }

    private void quickSort(String[] list, int lo, int hi) {
        /*
         * l:表示左边的位置
         * r：表示右边的位置
         * lo:表示low
         * hi：表示high**/
        int r=hi;
        int l=lo;
        if(l>=r)
            return;
        String mid=list[(r+l)/2];
        while(l<r){
            while(l<r&&list[l].compareTo(mid)<0)
                l++;
            while(l<r&&list[r].compareTo(mid)>0)
                r--;
            if(l<r){
                //交换位置
                String T=list[l];
                list[l]=list[r];
                list[r]=T;
                l++;
                r--;
            }
        }
        if(r<l){
            int T=r;
            r=l;
            l=T;
        }
        //递归算法
        quickSort(list,lo,l);
        quickSort(list,l==lo?l+1:l,hi);

    }
    public static void main(String[] args) {


    }

}

【4】数据流
允许按java的基本数据类型读写流中的数据。
DataInputStream / DataOutputStream

String readUTF() >>>>>读取以UTF格式保存的字符串
void writeUTF(String str) >>>>>>将字符串以UTF格式写出

【5】标准输入输出
System.in标准输入
read（）方法
System.out标准输出
println（）//换行
print（）//不换行

示例：

package zyf.standard;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class StandardIO {

    public static void main(String[] args) {
        String s;
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入：");
        try {
            s = br.readLine();
            while (!s.equals("bye")) {
                System.out.println("  读取：" + s);
                s = br.readLine();
            }
            System.out.println("结束输入！");
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}