在java中字符的输入输出流

一：前言

首先要明确 输入输出 是对谁而言的？这里是相对程序而言的，什么是程序，就是你在编写的东西。

所以输入，就是程序从外部读取数据，用InputStream、Reader 里的read、readLin等方法进行读。

输出，就是程序向外部写出数据，用OutputStream、Writer 里的writer、print等方法进行写。

字符流的读取和写入java.io.Reader 和 java.io.InputStream 组成了 Java 输入类。Reader 用于读入16位字符，也就是 Unicode 编码的字符；而 InputStream 用于读入 ASCII 字符和二进制数据。

二：字符流的基本概念

●字符输出流的父类是：Writer类，其包括多个子类。

其中需要着重了解的有：BufferedWriter（缓冲字符输出流），OutputStreamWriter（字节流和字符流的转换流）；FileWriter（文件输出流）
Writer类体系结构

(1) FileWrite将字符类型数据写入文件，使用缺省字符编码和缓冲器大小。

Public FileWrite(file f);

(2)chararrayWrite()

将字符缓冲器用作输出。

Public CharArrayWrite();

(3)PrintWrite

生成格式化输出

public PrintWriter(outputstream os);

(4)    filterWriter用于写入过滤字符流

protected FilterWriter(Writer w);

FilterOutputStream的种类

类功能构造函数的参数用法

DataOutputStream与DataInputStream配合使用，这样你就可以用一种\"可携带的方式(portable fashion)\"往流里写primitive了(int, char, long,等)

OutputStream包括写入primitive数据的全套接口。

PrintStream负责生成带格式的输出(formatted output)。DataOutputStrem负责数据的存储，而PrintStream负责数据的显示。

一个OutputStream以及一个可选的boolean值。这个boolean值表示，要不要清空换行符后面的缓冲区。应该是OutputStream对象的最终包覆层。用的机会很多。

BufferedOutputStream

用 这个类解决\"每次往流里写数据，都要进行物理操作\"的问题。也就是说\"用缓冲区\"。用flush( )清空缓冲区。

OutputStream， 以及一个可选的缓冲区大小本身并不提供接口，只是加了一个缓冲区。需要链接一个有接口的对象。

DataInputStream类对象可以读取各种类型的数据。

DataOutputStream类对象可以写各种类型的数据；

创建这两类对象时，必须使新建立的对象指向构造函数中的参数对象。例如：FileInputStream in=new FileInputStream("d:/abc.txt");

DataInputStream din=new DataInputStream(in);

2.BufferInputStream和bufferOutputStream

允许程序在不降低系统性能的情况下一次一个字节的从流中读取数据。

BufferInputstream定义了两种构造函数

(1) BufferInputStream b= new BufferInputstream(in);(2) BufferInputStream b=new BufferInputStream(in,size)；

第二个参数表示指定缓冲器的大小。

同样BufferOutputStream也有两种构造函数。一次一个字节的向流中写数据。

package com.huanxiao.test07;

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

public class WriterTest {
    public static void main(String[] args) throws IOException {
        File f2=new File("D:/d.txt");
        //判断是否存在
        if(f2.exists()){
            f2.createNewFile();
        }

        //定义字符输出流
        Writer w=new FileWriter(f2);
        w.write(97);
        w.write((int)'我');
        char[] c={'你','是','我','的','心','上','人'};
        w.write(c,0,7);

        w.flush();//字符流必须刷新缓冲区，才会出现文件
        //关闭资源
        w.close();
    }


}

 Reader 体系结构

(1)FileReader

FileReader主要用来读取字符文件，使用缺省的字符编码，有三种构造函数：

--将文件名作为字符串

FileReader f=new FileReader(“c:/temp.txt”);

--构造函数将File对象作为其参数。File f=new file(“c:/temp.txt”);

FileReader f1=new FileReader(f);

--构造函数将FileDescriptor对象作为参数FileDescriptor() fd=new FileDescriptor()

FileReader f2=new FileReader(fd);

(2) charArrayReader\n\n将字符数组作为输入流,构造函数为：public CharArrayReader(char[] ch);

(3) StringReader读取字符串，构造函数如下：public StringReader(String s);

(4) InputStreamReader从输入流读取字节，在将它们转换成字符。Public inputstreamReader(inputstream is);

(5)FilterReader允许过滤字符流protected filterReader(Reader r);

(6)    BufferReader接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行。Public BufferReader(Reader r);

代码段演示：

package com.huanxiao.test07;

import org.omg.CORBA.portable.InputStream;

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

public class ReaderTest {
    public static void main(String[] args) throws IOException {
        File f1=new File("D:/a.txt");
        Reader in=new FileReader(f1);
        //每次读写缓冲区
        char[] c=new char[10];
        int n=in.read(c);//每次至多读取数组多个字符，把读取的字符存入数组，返回实际字符数；
        String s=new String(c,0,n);//读取数组，从第0个索引，截取读取有效字符数长度；
        System.out.println(s);
        //关闭资源
        in.close();
    }


}

Buffered代码演示用法：

package com.huanxiao.test07;

import java.io.*;

public class BufferedTest {
    public static void main(String[] args) throws IOException {
        File f1 = new File("D:/a.txt");
        File f2 = new File("D:/d.txt");
        if (!f2.exists()) {
            f2.createNewFile();
        }
        FileReader r = new FileReader(f1);
        FileWriter w = new FileWriter(f2);
        //缓冲区有内置的缓冲区
        BufferedReader br = new BufferedReader(r);
        BufferedWriter bw = new BufferedWriter(w);

        long start = System.currentTimeMillis();
       //使用了内置的缓冲区
        int n;
        while ((n = r.read()) != -1) {
            w.write(n);
        }
        w.close();
        r.close();
//        char[] c = new char[10];
//        int n;
//        while ((n = r.read(c)) != -1) {
//            w.write(c, 0, n);
//        }
//        r.close();
//        w.close();

        long stop = System.currentTimeMillis();
        System.out.println(stop - start);

    }

}