字符流解决中文乱码问题、字符缓冲流提高读写效率、IO流小结、转换流、对象操作流、Properties集合与IO流集合的方法

  • 时间:
  • 浏览:
  • 来源:互联网

1. 为什么字节流读取纯文本文件,可能会出现乱码?

  • 计算机中储存的信息都是用二进制数表示的
  • 按照某种规则,将字符存储到计算机中,称为编码
  • 按照同样的规则,将存储在计算机中的二进制数解析显示出来,称为解码
  • 编码和解码的方式必须一致,否则会导致乱码。

 ASCII(美国信息交换标准代码):包括了数字,大小写字符和一些常见的标点符号, ASCII码表中没有中文

GBK:window系统默认的码表,兼容ASCII码表,也包含了21003个汉字,一个中文以两个字节的形式存储

Unicode码表:由国际组织ISO 制定,是统一的万国码,IDEA默认使用UnicodeUTF-8编解码格式。以UTF-8编码后一个中文以三个字节的形式存储

因为字节流一次读一个字节,而不管GBK还是UTF-8一个中文都是多个字节,用字节流每次只能读其中的一部分,所以就会出现乱码问题。

2. 字符串中的编码解码问题

方法名说明
byte[] getBytes()使用平台的默认字符集将该 String编码为一系列字节
byte[] getBytes(String charsetName)使用指定的字符集将该 String编码为一系列字节
String(byte[] bytes)使用平台的默认字符集解码指定的字节数组来创建字符串
String(byte[] bytes, String charsetName)通过指定的字符集解码指定的字节数组来创建字符串
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String str = "落霞与孤鹜齐飞,秋水共长天一色";
        //解码
        byte[] bytes1 = str.getBytes("utf-8");
        byte[] bytes2 = str.getBytes("gbk");
        System.out.println("utf-8:"+ Arrays.toString(bytes1));
        System.out.println("gbk:"+ Arrays.toString(bytes2));
        //编码
        String s1 = new String(bytes1, "utf-8");
        String s2 = new String(bytes2, "gbk");
        System.out.println(s1);
        System.out.println(s2);
    }
}

3. 字符流

字符流在读取纯文本文件时,当遇到中文时会根据码表,读取对应2个字节或者3个字节

  • 对文件进行拷贝,一律使用字节流或者字节缓冲流
  • 把文件中的数据读到内存中打印或者读到内存中运算,使用字符输入流。
  • 把集合,数组,键盘录入等数据写到文件中,使用字符输出流

3.1 字符输出流写数据

Writer: 用于写入字符流的抽象父类

FileWriter: 用于写入字符流的常用子类

构造方法:

方法名说明
FileWriter(File file)根据给定的 File 对象构造一个 FileWriter 对象
FileWriter(String fileName)根据给定的文件名构造一个 FileWriter 对象

成员方法:

方法名说明
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)写一个字符串的一部分

刷新和关闭的方法:

方法名说明
flush()刷新流,之后还可以继续写数据
close()关闭流,释放资源,但是在关闭之前会先刷新流。一旦关闭,就不能再写数据
import java.io.FileWriter;
import java.io.IOException;

public class Demo02 {
    public static void main(String[] args) throws IOException {
        //字符输出流对象
        FileWriter fileWriter = new FileWriter("day12_exercise\\aaa.txt");
        //一次写一个字符
        int a = 97;
        fileWriter.write(a);//将97对应字符写到aaa.txt
        //一次写一个字符数组的一部分
        char[] chars = {97, 98, 99, 100};
        fileWriter.write(chars,0,2);
        //写一个字符串
        String line = "落霞与孤鹜齐飞";
        fileWriter.write(line);//直接将字符串写到aaa.txt
        //刷新
        fileWriter.flush();
        //释放资源
        fileWriter.close();
    }
}

3.2 字符输入流读数据

Reader: 用于读取字符流的抽象父类

FileReader: 用于读取字符流的常用子类

构造方法:

方法名说明
FileReader(File file)在给定从中读取数据的 File 的情况下创建一个新 FileReader
FileReader(String fileName)在给定从中读取数据的文件名的情况下创建一个新 FileReader

成员方法:

方法名说明
int read()一次读一个字符数据
int read(char[] cbuf)一次读一个字符数组数据
import java.io.FileReader;
import java.io.IOException;

public class Demo03 {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("day12_exercise\\aaa.txt");
        //一次读取一个字符
        int cha;
        while ((cha = fileReader.read()) != -1){
            System.out.println((char) cha);
        }
        fileReader.close();
        System.out.println("========================");
        FileReader fileReader1 = new FileReader("day12_exercise\\aaa.txt");
        //一次读取一个字符数组
        int len;
        char[] chars = new char[1024];
        while ((len = fileReader1.read(chars)) != -1){
            String s = new String(chars, 0, len);
            System.out.println(s);
        }
        fileReader1.close();
    }
}

3.3 字符缓冲流

BufferedWriter:将文本写入字符输出流,缓冲字符,以提供单个字符,数组和字符串的高效写入。

BufferedReader:从字符输入流读取文本,缓冲字符,以提供字符,数组和行的高效读取。

构造方法:

方法名说明
BufferedWriter(Writer out)创建字符缓冲输出流对象
BufferedReader(Reader in)创建字符缓冲输入流对象

方法介绍:

BufferedWriter:void newLine() 写一行行分隔符,行分隔符字符串由系统属性定义(换行)

BufferedReader:String readLine() 读一行文字。 结果包含一行的内容,不包括任何行终止字符如果流的结尾已经到达,则为返回null

案例:使用字符缓冲流读取文件中的数据,排序后再次写到本地文件

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

public class Demo02 {
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(
                new FileReader("day12_exercise\\bbb.txt"));
        //读取一行数据
        String line = br.readLine();
        String[] strArr = line.split(" ");
        int[] intArr = new int[strArr.length];
        for (int i = 0; i < strArr.length; i++) {
            intArr[i] = Integer.parseInt(strArr[i]);
        }
        //排序
        Arrays.sort(intArr);
        //重新写回本地文件
        BufferedWriter bw = new BufferedWriter(
                new FileWriter("day12_exercise\\bbb.txt"));
        for (int i = 0; i < intArr.length; i++) {
            bw.write(intArr[i]+" ");
        }
        bw.flush();
        bw.close();
        br.close();
    }
}

4. IO流小结

5. 转换流

  • InputStreamReader:是从字节流到字符流的桥梁,父类是Reader。它读取字节,并使用指定的编码将其解码为字符,它使用的字符集可以指定,或者接受平台的默认字符集

  • OutputStreamWriter:是从字符流到字节流的桥梁,父类是Writer。它使用指定的编码将写入的字符编码为字节,它使用的字符集可以指定,或者接受平台的默认字符集

构造方法:

方法名说明
InputStreamReader(InputStream in)使用默认字符编码创建InputStreamReader对象
InputStreamReader(InputStream in,String chatset)使用指定的字符编码创建InputStreamReader对象
OutputStreamWriter(OutputStream out)使用默认字符编码创建OutputStreamWriter对象
OutputStreamWriter(OutputStream out,String charset)使用指定的字符编码创建OutputStreamWriter对象
import java.io.*;
import java.nio.charset.Charset;

public class Demo {
    public static void main(String[] args) throws IOException {
        //文件是什么码表,就指定一样的码表去读取
        //字节输入流对象作为参数传入转换流对象
        FileInputStream fis = new FileInputStream("day12_exercise\\dddcopy.txt");
        InputStreamReader isr = new InputStreamReader(fis, "utf-8");
        int ch;
        while ((ch = isr.read()) != -1) {
            System.out.println((char) ch);
        }
        isr.close();

        //使用转换流,指定码表向文件写数据
        //字节输出流对象作为参数传入装换流
        FileOutputStream fos = new FileOutputStream("day12_exercise\\dddcopy.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
        osw.write("秋水共长天一色");
        osw.close();

        //JDK11之后字符流推出了一个新的构造方法,可以指定码表
        FileReader fileReader = new FileReader(
                "day12_exercise\\dddcopy.txt",
                Charset.forName("utf-8"));
        int c;
        while ((c = fileReader.read()) != -1) {
            System.out.println((char) c);
        }
        fileReader.close();
    }
}

6. 对象操作流

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

  • 对象操作输出流(对象序列化流):将对象写到本地文件中,或者在网络中传输对象
  • 对象操作输入流 (对象反序列化流):把写到本地文件中的对象读到内存中,或者接受网络中传输的对象

User类:

import java.io.Serializable;
//如果想要一个类能够被序列化,必须实现接口Serializable
//Serializable是一个标记性接口,没有任何抽象方法
public class User implements Serializable {
    //自定义序列号
    private static final long serialVersionUID = 5586850569152704422L;
    private String name;
    private transient String password;

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

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

    public User() {
    }
}

序列化和反序列化:

import java.io.*;

public class Demo01 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User user = new User("王勃", "twgx");
        //反序列化user对象
        ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("day12_exercise\\ccc.txt"));
        User o = (User)ois.readObject();
        System.out.println(o);
        ois.close();
    }

    //序列化user对象
    private static void writeObject(User user) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("day12_exercise\\ccc.txt"));
        oos.writeObject(user);
        oos.close();
    }
}

若不希望某个成员变量被序列化,可以在变量前加一个瞬态关键字 transient

案例:创建多个学生类对象写到文件中,再次读取到内存中

public class Demo{
    /**
     *  read():
     *      读取到文件末尾返回值是 -1
     *  readLine():
     *      读取到文件的末尾返回值 null
     *  readObject():
     *      读取到文件的末尾 直接抛出异常
     *  如果要序列化的对象有多个,不建议直接将多个对象序列化到文件中,因为反序列化时容易出异常
     *      建议: 将要序列化的多个对象存储到集合中,然后将集合序列化到文件中
     */
    public static void main(String[] args) throws Exception {
        // 序列化
        //1.创建序列化流对象
        ObjectOutputStream oos = new ObjectOutputStream(new                 
                           FileOutputStream("myCode\\oos.txt"));
        ArrayList<Student> arrayList = new ArrayList<>();
        //2.创建多个学生对象
        Student s = new Student("佟丽娅",30);
        Student s01 = new Student("佟丽娅",30);
        //3.将学生对象添加到集合中
        arrayList.add(s);
        arrayList.add(s01);
        //4.将集合对象序列化到文件中
        oos.writeObject(arrayList);
        oos.close();

        // 反序列化
      	//5.创建反序列化流对象
        ObjectInputStream ois = new ObjectInputStream(new 
                          FileInputStream("myCode\\oos.txt"));
      	//6.将文件中的对象数据,读取到内存中
        Object obj = ois.readObject();
        ArrayList<Student> arrayList = (ArrayList<Student>)obj;
        ois.close();
        for (Student s : arrayList) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

7. Properties集合

  • Properties是一个Map体系的集合类
  • Properties有和IO流相关的方法
  • 键及其对应的值通常都用于存储字符串类型

 

Properties作为Map集合的特有方法:

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

Properties 和IO流结合的方法:

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

将properties文件中的键值对,存到properties集合

import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Properties;

public class Demo01 {
    public static void main(String[] args) throws IOException {
        Properties prop = new Properties();
        FileReader fr = new FileReader(
                "day12_exercise\\prop.properties", Charset.forName("utf-8"));
        prop.load(fr);
        fr.close();
        System.out.println(prop);
    }
}

将properties集合中的键值对,存到本地配置文件

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

public class Demo02 {
    public static void main(String[] args) throws IOException {
        Properties prop = new Properties();
        FileWriter fileWriter = new FileWriter("day12_exercise\\prop.properties");
        prop.put("张三","123456");
        prop.put("李四","123456");
        prop.store(fileWriter, "abc");
        fileWriter.close();
    }
}

 

如有错误欢迎留言评论,及时更正。2021年6月11日,羽露风

本文链接http://metronic.net.cn/metronic/show-16440.html