Java学习笔记day21-字符流及其它流-CFANZ编程社区

字符流

字符串中的编码解码问题

编码

byte[] getBytes():使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中；
byte[] getBytes(String charsetName)：使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中；

解码

String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的String；
String(byte[] bytes,String charsetName)：通过指定的字符集解码指定的字节数组来构造新的String；

字符流写数据

方法名	说明
void write(int c)	写一个字符
void write(char[] cbuf)	写一个字符数组
void write(char[] cbuf,int off,int len)	写出字符数组的一部分
void write(String str)	写一个字符串
void write(String str,int off,int len)	写一个字符串的一部分

import java.io.FileWriter;
import java.io.IOException;

public class CharStreamTest {
    public static void main(String[] args) throws IOException {
       //创建字符输出流对象
        //FileWriter fw = new FileWriter(new File("day21\\src\\a.txt"));
        FileWriter fw = new FileWriter("day21\\src\\a.txt");
        //一次写一个字符
        fw.write(97);
        fw.write(98);
        fw.write(99);
        //一次写一个字符数组
        char[] arr = {97,98,99,100,101};
        fw.write(arr);
        //一次写一个字符数组的一部分
        fw.write(arr,1,3);
        //一次写一个字符串
        String s = "一次写一个字符串";
        fw.write(s);
        //一次写一个字符串的一部分
        fw.write(s,5,3);
        fw.close();
    }
}

注意

如果文件不存在，就创建，但是要保证父级路径存在；如果文件存在就清空；
写出int类型的整数，实际写出的是整数在码表上的对应的字母；
写出字符串数据，是把字符串本身原样写出；

flush和close方法

方法名	说明
flush()	刷新流，还可以继续写数据
close()	关闭流，释放资源，但是在关闭之前会先刷新流，一旦关闭，就不能再写数据

字符流读数据

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

public class ReaderTest {
    public static void main(String[] args) throws IOException {
        //创建字符输入流对象
        FileReader fr = new FileReader("day21\\src\\a.txt");
        //读数据
        //一次读一个字符
        int ch;
        while((ch = fr.read()) != -1){
            System.out.println((char)ch);
        }
        
        //一次读一个字符数组
        //创建一个数组
        char[] chars = new char[1024];
        int len;
        //read方法还是读取，但是一次读取多个字符
        //他把读到的字符都存入到chars数组
        //返回值：表示本次读到了多少个字符
        while ((len = fr.read(chars))!=-1){
            System.out.println(new String(chars,0,len));
        }
        //释放资源
        fr.close();
    }
}

案例：保存键盘录入的数据

将用户键盘录入的用户名和密码保存到本地实现永久化存储；要求用户名和密码各自独占一行。

import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class Anli {
    public static void main(String[] args) throws IOException {
        //实现键盘录入，把用户名和密码录入进来
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入用户名：");
        String username = sc.next();
        System.out.println("请录入密码：");
        String password = sc.next();
        //分别把用户名和密码写到本地文件
        FileWriter fw = new FileWriter("day21\\src\\a.txt");
        //将用户名和密码写到文件中
        fw.write(username);
        fw.write("\r\n");
        fw.write(password);
        //刷新流
        fw.flush();
        //释放资源
        fw.close();
    }
}

字符缓冲流：

BufferedWriter：可以将数据高效的写出；
BufferedReader：可以将数据高效的读取到内存；

构造方法：

BufferedWriter(Writer out)
BufferedReader(Reader in)

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

public class BufferedReaderTest {
    public static void main(String[] args) throws IOException {
        //字符缓冲输入流
        BufferedReader br = new BufferedReader(new FileReader("day21\\src\\a.txt"));
        //读取数据
        char[] chars = new char[1024];
        int len;
        while ((len = br.read(chars)) != -1){
            System.out.println(new String(chars,0,len));
        }
        br.close();
    }
}

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterTest {
    public static void main(String[] args) throws IOException {
        //字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("day21\\src\\a.txt"));
        //写数据
        bw.write(97);
        bw.write("\r\n");
        char[] chars = {97,98,99,100,101};
        bw.write(chars);
        bw.write("\r\n");
        bw.write(chars,1,3);
        bw.write("\r\n");
        String s = "字符缓冲输出流";
        bw.write(s);
        bw.write("\r\n");
        bw.write(s,2,5);
        bw.close();
    }
}

字符缓冲流特有功能

BufferedWriter:

void newLine()：写一行行分隔符，行分隔符字符串由系统属性定义；

BufferedReader：

public String readLine()：读一行文字。结果包含行的内容的字符串，不包括任何行终止符，如果留的结尾已经到达，则为null；

案例：读取文件中的数据排序后再次写到本地

读取文件中的数据，排序后再次写到本地文件；

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

public class Anli {
    public static void main(String[] args) throws IOException {
        //把文件中的数据读取近来
        BufferedReader br =new BufferedReader(new FileReader("day21\\src\\a.txt"));
        //输出流一定不能写在这里，因为会清空文件里的数据
        String s = br.readLine();
        System.out.println("读到的数据为："+s);
        br.close();
        //将读到的数据进行切割
        String[] arr = s.split(" ");
        //把字符串数组转换为int数组
        int[] arr1 = new int[arr.length];
        //遍历数组进行类型转换
        for (int i = 0; i < arr.length; i++) {
            arr1[i] = Integer.parseInt(arr[i]);
        }
        //排序
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));
        //把排序后的结果写回到本地
        BufferedWriter bw = new BufferedWriter(new FileWriter("day21\\src\\a.txt",true));
        bw.write("\r\n");
        for (int i = 0; i < arr1.length; i++) {
            bw.write(arr1[i]+" ");
            //bw.flush();
        }
        bw.close();
    }
}

其它流

转换流

输入流：InputStreamReader
输出流：OutputStreamWriter

1645696624281

对象操作流

可以把对象以字节的形式写到本地文件，直接打开文件，是读不懂的，需要再次用对象操作流读到内存中。

对象操作输入流：ObjectInputStream
对象操作输出流：ObjectOutputStream

对象操作流分为两类：对象操作输入流和对象操作输出流

对象操作输出流(对象序列化流)：就是将对象写到本地文件中，或者在网络中传输对象

对象操作输入流(对象反序列化流)：把写到本地文件中的对象读到内存中，或者接收网络中传输的对象

对象序列化流：
import java.io.Serializable;

//如果想要这个类的对象能被序列化，那么这个类必须要实现一个接口Serializable
//Serializable接口的意义
//称之为是一个标记性接口，里面没有任何的抽象方法
//只要一个类实现了这个Serializable接口，那么就表示这个类的对象可以被序列化
public class User implements Serializable {
    private String username;
    private String password;

    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
测试类：
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectStreamTest {
    public static void main(String[] args) throws IOException {
        User user = new User("xiaohua","123456");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day21\\src\\a.txt"));
        oos.writeObject(user);
        oos.close();
    }
}

对象反序列化流
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectStreamTest1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day21\\src\\a.txt"));
        User user = (User) ois.readObject();
        System.out.println(user);
        ois.close();
    }
}

案例：用对象操作流读写多个对象

创建多个Javabean类对象写到文件中，再次读取到内存；

import java.io.Serializable;

public class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

import java.io.*;
import java.util.ArrayList;

public class StudentTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Student st1 = new Student("小花",15);
        Student st2 = new Student("小澜",17);
        Student st3 = new Student("小雅",16);
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day21\\src\\a.txt"));
        oos.writeObject(st1);
        oos.writeObject(st2);
        oos.writeObject(st3);

        //可以将对象存入集合，再将集合写到本地
//        ArrayList<Student> list = new ArrayList<>();
//        list.add(st1);
//        list.add(st2);
//        list.add(st3);
//        oos.writeObject(list);

        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day21\\src\\a.txt"));
        while (true){
            try {
                Object o = ois.readObject();
                System.out.println(o);
            } catch (EOFException e) {
                break;
            }
        }

        //读取集合
//        ArrayList<Student> list1 = (ArrayList<Student>) ois.readObject();
//        for (Student student : list1) {
//            System.out.println(student);
//        }
        ois.close();
    }
}

Properties

概述：

是一个Map体系的集合类
Properties中有跟IO相关的方法
只存字符串

import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class PropertiesTest {
    public static void main(String[] args) {
        Properties prop = new Properties();
        //增
        prop.put("河南","郑州");
        prop.put("河北","石家庄");
        prop.put("山西","太原");
        prop.put("山东","济南");
        System.out.println(prop);
        //删
        prop.remove("山东");
        System.out.println(prop);
        //改
        //put 如果键不存在，那么就添加，如果键存在，那么就覆盖
        prop.put("河南","豫州");
        System.out.println(prop);
        //查
        Object value = prop.get("河北");
        System.out.println(value);
        //遍历
        Set<Object> keys = prop.keySet();
        for (Object key : keys) {
            Object value1 = prop.get(key);
            System.out.println(key+"="+value1);
        }
        System.out.println("------------");
        Set<Map.Entry<Object, Object>> entries = prop.entrySet();
        for (Map.Entry<Object, Object> entry : entries) {
            System.out.println(entry.getKey()+"="+entry.getValue());
        }
    }
}

Properties作为集合的特有方法

方法名	说明
Object setProperty(String key,String value)	设置集合的键和值，都是String类型，底层调用Hashtable方法put
String getProperty(String key)	使用此列表中指定的键搜索属性
Set stringPropertyName()	从该属性列表中返回一个可修改的健集，其中键及其对应的值是字符串

示例：

import java.util.Properties;
import java.util.Set;

public class PropertiesTest2 {
    public static void main(String[] args) {
        Properties prop = new Properties();
        prop.setProperty("河南","郑州");
        prop.setProperty("陕西","西安");
        prop.setProperty("海南","海口");
        prop.setProperty("台湾","台北");
        System.out.println(prop);
        String value = prop.getProperty("海南");
        System.out.println(value);
        Set<String> keys = prop.stringPropertyNames();
        for (String key : keys) {
            String value1 = prop.getProperty(key);
            System.out.println(key+"="+value1);
        }
    }
}

Properties和IO流结合的方法：

方法名	说明
void load(InputStream inStream)	从输入字节流读取属性列表(键和元素对)
void load(Reader reader)	从输入字符流读取属性列表(键和元素对)
void store(OutputStream out,String comments)	将此属性列表(键和元素对)写入此Properties表中,以适合于使用load(InoutStream)方法的格式写入输出字节流
void store(Writer writer,String comments)	将此属性列表(键和元素对)写入此Properties表中，以适合使用load(Reader)方法的格式写入输出字符流

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class PropertiesTest3 {
    public static void main(String[] args) throws IOException {
        //读取
        Properties prop = new Properties();
        FileReader fr = new FileReader("day21\\prop.properties");
        //调用完了load方法之后，文件中的键值对数据已经在集合中了
        prop.load(fr);
        fr.close();
        System.out.println(prop);

        prop.put("sansan","123");
        prop.put("sisi","456");
        prop.put("wuwu","789");
        FileWriter fw = new FileWriter("day21\\prop.properties");
        prop.store(fw,null);
        fw.close();
    }
}

练习1

请使用“便捷字符流”配合数组将指定文件（笔者用的是“大地之灯.txt”）的内容打印到控制台,并统计出读文本共使用的时间;

public class Test1 {
    public static void main(String[] args) throws IOException {
        //获取当前时间
        long t1 = System.currentTimeMillis();
        //创建字符输入流对象
        FileReader fr = new FileReader("day21\\src\\大地之灯.txt", Charset.forName("gbk"));
        char[] arr = new char[1024];
        int len = 0;
        //read方法还是读取，但是一次读取多个字符
        //他把读到的字符都存入到arr数组
        //返回值：表示本次读到了多少个字符
        while ((len=fr.read(arr))!=-1){
            String s = new String(arr,0,len);
            System.out.print(s);
        }
        fr.close();
        long t2 = System.currentTimeMillis();
        System.out.println();
        System.out.println(">>>>>>>>>>>>>>>>>>>>");
        System.out.println("读取文件共使用了："+(t2-t1)+"毫秒");
    }
}

结果：

练习2

将下列文件中的学生信息按照年龄升序排序后重新写回原文件;要求：使用字符缓冲流完成;每次循环读取一行信息；写数据的时候换行使用newLine方法。

TXT文件内容：

凯亚，18
白山，19
可莉，17
阿七，22

public class Test2 {
    public static void main(String[] args) throws IOException {
        //创建文件对象和字符缓冲流对象，准备读数据
        File f = new File("day21\\src\\1.txt");
        BufferedReader br = new BufferedReader(new FileReader(f));
        //准备TreeSet集合，用于保存读到的学生对象并排序
        TreeSet<Student> set = new TreeSet<Student>((s1,s2)->s1.getAge()-s2.getAge()==0?s1.getName().compareTo(s2.getName()):s1.getAge()-s2.getAge());
        String s = null;
        while ((s=br.readLine())!=null){
            String[] split1 = s.split(",");
            //把切分出来的数组的第一个值作为name，第二个值作为age，创建学生对象，并按照年龄排序
            Student stu = new Student(split1[0],Integer.parseInt(split1[1]));
            set.add(stu);
        }
        //创建输出流，并把set集合中的学生信息重新写入1.txt文件中；
        BufferedWriter bw = new BufferedWriter(new FileWriter("day21\\src\\1.txt"));
        for(Student stu : set) {
            bw.write(stu.toString());
            bw.newLine();//换行，不用考虑系统问题，比写\r\n更通用
        }
        br.close();
        bw.close();
        System.out.println("排序已完成");
    }
}



public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return name + "," + age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}