Java基础（二十七）Java IO（4）字符流（Character Stream）

　　字符流用于处理字符数据的读取和写入，它以字符为单位。

　　一、Reader类与Writer类

　　1.Reader类是所有字符输入流的父类，它定义了操作字符输入流的各种方法。

　　

　　2.Writer类是所有字符输出流的父类，它定义了操作输出流的各种方法。

　　

　　二、InputStreamReader类与OutputStreamWriter类

　　1.InputStreamReader是字节流通向字符流的桥梁。它可以根据指定的编码方式，将字节输入流转换为字符输入流。

　　（1）构造方法有两种：

• InputStreamReader(InputStream in)：使用默认编码方式创建对象
• InputStreamReader(InputStream in , String cname)：使用指定的编码方式cname创建对象

　　（2）常用方法

　　

　　（3）示例

package jun.iplab.inputstreamreader;

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

public class InputStreamReaderTest {

    public static void main(String[] args) {
        try {
            File file = new File("D:\\JavaIOTest\\InputStreamReaderTest.txt");
            FileInputStream fis = new FileInputStream(file);
            InputStreamReader isr = new InputStreamReader(fis);
            int rs;
            // 顺序读取文件里的内容并赋值给变量rs，通过强制类型转换可以将字节类型转换成字符类型
            while ((rs = isr.read())!= -1) {
                System.out.print((char)rs + "(" + rs + ")");
            }
            isr.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出：
Y(89)o(111)u(117) (32)a(97)r(114)e(101) (32)b(98)e(101)a(97)u(117)t(116)i(105)f(102)u(117)l(108) (32)t(116)o(111)n(110)i(105)g(103)h(104)t(116).(46)

　　2.OutputStreamWriter是字节流通向字符流的桥梁。写出字节，并根据指定的编码方式，将之转换为字符流。

　　（1）常用构造方法

• OutputStreamWriter(OutputStream out)
• OutputStreamWriter(OutputStream out, String cname)

　　（2）常用方法

　　

　　（3）示例代码

package jun.iplab.outputstreamwriter;

import java.io.*;

public class OutputStreamWriterTest {

    public static void main(String[] args) {
        File file_in = new File("D:\\JavaIOTest\\InputStreamReaderTest.txt");
        File file_out = new File("D:\\JavaIOTest\\OutputStreamWriterTest.txt");
        try {

            if (!file_in.exists()) {
                file_in.createNewFile();
            }
            if (!file_out.exists()) {
                file_out.createNewFile();
            }

            // 从file_in读出内容，以字节流的形式
            FileInputStream fis = new FileInputStream(file_in);
            // 将输入字节流转换成输入字符流
            InputStreamReader in = new InputStreamReader(fis);

            // 以覆盖方式向file_out中输出字节流
            FileOutputStream fos = new FileOutputStream(file_out, false);
            // 将输出字符流转换成输出字节流并输出到FileOutputStream对象中
            OutputStreamWriter out = new OutputStreamWriter(fos);

            int is;
            while ((is = in.read())!=-1) {
                out.write(is);
            }
            in.close();
            out.close();
            fis.close();
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

　　三、FileReader类与FileWriter类

　　1.FileReader类是Reader类的子类，它实现了从文件中读出字符数据，是文件字符输入流。

　　（1）两种构造方法

• FileReader(String filepath)
• FileReader(File file)

　　（2）示例

package jun.iplab.filereader;

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

public class FileReaderTest {

    public static void main(String[] args) {
        try {
            File file = new File("D:\\JavaIOTest\\OutputStreamWriterTest.txt");
            FileReader fr = new FileReader(file);
            char[] data = new char[512];
            int rs = 0;
            // 从文件中读出字符数据并保存在字符数组data中，并且返回实际读到的字符个数
            while ((rs = fr.read(data))>0) {
                System.out.println(rs);
                for (int i = 0; i < rs; i++) {
                    System.out.print(data[i] + " ");
                }
                System.out.println();
                String str = new String(data, 0, rs);
                System.out.println(str);
            }
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出：
26
Y o u   a r e   b e a u t i f u l   t o n i g h t .
You are beautiful tonight.

　　2.FileWriter类是Writer类的子类，它实现了将字符数据写入文件中，是文件字符输出流。

　　（1）构造方法

• FileWriter(String filepath)
• FileWriter(File file)

　　（2）示例　

package jun.iplab.filewriter;

import java.io.*;

public class FileWriterTest {

    public static void main(String[] args) {
        try {
            File file_out = new File("D:\\JavaIOTest\\FileWriterTest.txt");
            if (!file_out.exists()) {
                file_out.createNewFile();
            }
            FileReader fr = new FileReader("D:\\JavaIOTest\\OutputStreamWriterTest.txt");
            FileWriter fw = new FileWriter(file_out,false);
            int is;
            while ((is=fr.read())!= -1) {
                System.out.print(is + " ");
                fw.write(is);
            }
            fr.close();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出：
89 111 117 32 97 114 101 32 98 101 97 117 116 105 102 117 108 32 116 111 110 105 103 104 116 46 

　　四、BufferedReader类与BufferedWriter类

　　1.BufferedReader类是Reader类的子类，该类可以以行为单位读取数据。

　　（1）构造方法为

• BufferedReader(Reader in)

　　（2）BufferedReader类中提供了一个ReaderLine()方法，可以以行为单位读取数据

　　（3）示例

package jun.iplab.bufferreader;

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

public class BufferedReaderTest {

    public static void main(String[] args) {
        try {
            FileReader fr = new FileReader("D:\\JavaIOTest\\OutputStreamWriterTest.txt");
            BufferedReader br = new BufferedReader(fr);
            String aline;
            while ((aline=br.readLine())!=null) {
                System.out.println(aline);
            }
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出：
You are beautiful tonight.
I am your solider.

　　2.BufferedWriter类是Writer类的子类，该类可以以行为单位写入数据。

　　（1）构造方法为

• BufferedWriter(Writer out)

　　（2）BufferedWriter类提供了一个newLine()方法，Writer类中没有此方法，该方法时换行标记。

　　（3）示例代码

package jun.iplab.bufferedwriter;

import java.io.*;

public class BufferedWriterTest {

    public static void main(String[] args) {
        try {
            File file = new File("D:\\JavaIOTest\\BufferedWriterTest.txt");
            FileWriter fw = new FileWriter(file, true);
            BufferedWriter bw = new BufferedWriter(fw);
            bw.newLine();
            bw.write("hello");
            bw.newLine();
            bw.write("23333");
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

　　五、PrintStream类与PrintWriter类

　　1.PrintStream是打印输出流，它可以直接输出各种类型的数据。

　　（1）构造方法为：PrintStream(OutputStream out)

　　（2）常用方法为：

　　

　　（3）示例代码：

package jun.iplab.printstream;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Random;

public class PrintStreamTest {

    public static void main(String[] args) {
        PrintStream ps;
        try {
            File file = new File("D:\\JavaIOTest\\PrintStreamTest.txt");
            if (!file.exists()) {
                file.createNewFile();
            }
            // 创建PrintStream对象
            ps = new PrintStream(new FileOutputStream(file));
            Random r = new Random();
            int rs;
            for (int i = 0; i < 5; i++) {
                rs = r.nextInt(100);
                // 调用println方法向PrintStreamTest.tx中写入随机数加换行符
                ps.println(rs + "\t");
            }
            ps.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

PrintStreamTest.txt中的内容：
73
57
24
30
78    

　　2.PrintWriter是打印输出流，该流把Java语言的内构类型以字符表示形式传送到相应的输出流中，可以以文本的形式浏览。

　　（1）构造方法：

• PrintWriter(Writer out)
• PrintWriter(OutputStream out)

　　（2）常用方法：

　　

　　（3）示例代码：

package jun.iplab.printwriter;

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

public class PrintWriterTest {

    public static void main(String[] args) {
        File file_in = new File("D:\\JavaIOTest\\OutputStreamWriterTest.txt");
        File file_out = new File("D:\\JavaIOTest\\PrintWriterTest.txt");
        try {
            // 创建一个BufferedReader对象
            BufferedReader br = new BufferedReader(new FileReader(file_in));
            // 创建一个PrintWriter对象
            PrintWriter pw = new PrintWriter(new FileWriter(file_out));
            String aline;
            // 读出file_in中的数据并且打印输出到file_out中
            while ((aline=br.readLine())!=null) {
                System.out.println(String.valueOf(aline));
                pw.println(aline);
            }
            br.close();
            pw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出：
You are beautiful tonight.
I am your solider.

　　六、System.in获取用户输入

　　System类是final类，该类不能被继承，也不能创建System类的实例对象。

　　Java中实现键盘输入的一般过程是：

InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
try {
        String str = br.readLine();
        对str的一些操作
　　　　　br.close();    
        } catch (IOException e) {
            e.printStackTrace();
        }

　　将键盘输入的内容存储到文件中：

package jun.iplab.systemin;

import java.io.*;

public class SystemInTest {

    public static void main(String[] args) {
        File file = new File("D:\\JavaIOTest\\SystemInTest.txt");
        try {
            if (!file.exists())
                file.createNewFile();
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);

            String str = br.readLine();
            System.out.println("输入的内容是: " + str);

            FileWriter fw = new FileWriter(file,true);
            BufferedWriter bw = new BufferedWriter(fw);

            bw.write(str);

            br.close();
            bw.close();
            fw.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

输出：
You are beautiful tonight.
输入的内容是: You are beautiful tonight.

　　七、Scanner类

　　Scanner类是java.util包中的类，该类用来实现用户的输入，是一种只要有控制台就能实现输入操作的类。

　　1.构造方法

1.Scanner(InputStream in):
2.Scanner(File file)
...

　　2.Scanner类的主要方法

next();     // 不可以读入空格，读到空白符（空格、回车、tab...）就结束，一般放到最后一个
nextLine(); // 可以读入空格，读到回车符就结束
nextInt();
close();

　　3.代码示例

package integer.jun.iplab;

import java.util.Scanner;

public class ScannerTest {

    public static void main(String[] args) {

        String name;
        int age;
        String address;
        // 创建Scanner对象
        Scanner sc = new Scanner(System.in);
        name = sc.nextLine();
        age = sc.nextInt();
        address = sc.next();
        System.out.println(name + " " + age + " " + address );
    }
}

控制台：
尼古拉斯 赵四
18
象牙山
尼古拉斯 赵四 18 象牙山