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 + "	");
            }
            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 象牙山