JAVA(IO流-字符流)day 7.30

ok了家人们今天继续学习IO流，

一.字符集

使用字节流输出中文可能有乱码。

因为每次读取的字节没有完全读取一个字的字节。

二.字符流

2.1 字符输出流【Writer】（抽象类）

Writer是所有字符流的超类（父类）

字符输出流 Writer 类的常用方法

public void write(int c)：写出一个字符
。
public void write(char[] cbuf)：将 b.length字符从指定的字符
数组写出此输出流。

public abstract void write(char[] b, int off, int len)：从指定的
字符数组写出 len字符，从偏移量 off开始输出到此输出流。
 
public void write(String str) ：写出一个字符串
。
public void write(String str,int off,int len)：写出一个字符串的
一部分。

public abstract void close()：关闭流，释放资源，但是在关闭
之前会先刷新流。一旦关闭，就不能再写数据。

public abstract void flush()：刷新流，还可以继续写数据。

2.2 FileWriter类

FileWriter类是Writer的子类，默认使用UTF-8，和字节缓冲区。

FileWriter类的构造方法

FileWriter(File file)：创建一个新的 FileWriter，给定要读取的File对
象。
 
FileWriter(String fileName)：创建一个新的 FileWriter，给定要读
取的文件的名称。 

FileWriter(File file,boolean append)： 创建一个新的 FileWriter，
追加写入。 

FileWriter(String fileName,boolean append)： 创建一个新的
FileWriter，追加写入。

FileWriter fw = new FileWriter("文件路径");

fw.write(int/String);
fw.write("\r\n");//换行符

char[] chars = {内容};
fw.write(chars);

fw.close();

//续写
FileWriter fw = new FileWriter("文件路径",true);

fw.write(内容);

fw.close();

flush ：刷新缓冲区，流对象可以继续使用。

//刷新流
FileWriter fw = new FileWriter("文件路径",true);

fw.write(内容);

fw.flush();

fw.wirte(内容);

fw.close();

2.3 字符输入流【Reader】(抽象类)

Reader是读取字符流的所有超类（父类）

字符输入流Reader类的常用方法

public int read()：每次可以读取一个字符的数据，读取到文件末
尾，返回-1。 返回字符数据的编码值。

public int read(char[] cbuf)：一次最多读取cbuf.length个字符数
据，并把读取的字符数据存储到cbuf数组中。返回实际读取到的字
符数据个数。 读取到文件末尾返回：-1

2.4  FileReader类

FileReader是Reader的子类，用于读取字符文件，默认使用UTF-8和字符缓冲区。

FileReader(File file)： 创建一个新的 FileReader ，给定要读取的
File对象。 

FileReader(String fileName)： 创建一个新的 FileReader ，给定要
读取的文件的名称。

FileReader fr = new FileReader("文件路径");

fr.read();

int len;
while((len=fr.read())!=-1){
    System.out.println((char)len);
}

fr.close

char数组

FileReader fr = new FileReader("文件路径");

char[] chars = new char[];

int len;

while((len=fr.read())!=-1){
    String str = new String(chars,0,len)
    System.out.println(str);
}

fr.close();

三.字符缓冲流

3.1 字符缓冲流概述

只具备缓冲区

字符缓冲流的构造方法

public BufferedReader(Reader in)：创建一个 新的缓冲输入
流。
public BufferedWriter(Writer out)： 创建一个新的缓冲输出
流。

String src = "文件路径";
String dest = "文件路径";
BufferedReader br = new BufferedReader(new FileReader(src));

BufferedWriter bw = new BufferedWriter(new FileWirter(dest));

 char[] cbuf=new char[1024];

       int len;
       while( (len=br.read(cbuf))!=-1){
           bw.write(cbuf,0,len);
      }

       //关闭流
       br.close();
       bw.close();

3.2 字符缓冲流复制纯文本文件

需求：将 ‘ 斗罗大陆 .txt’ 复制到当前模块下 ‘copy.txt’

import java.io.*;

public class dm02 {
    public static void main(String[] args) throws Exception {
        String src = "java_0729\\dldl.txt";
        BufferedReader br = new BufferedReader(new FileReader(src));

        String str = "java_0729\\copy.txt";
        BufferedWriter bw = new BufferedWriter(new FileWriter(str));

        char[] chars = new char[1024];
        int len;
        while ((len=br.read(chars))!=-1){
            bw.write(chars,0,len);
        }
        br.close();
        bw.close();
    }
}

3.3 字符缓冲流特有功能

BufferedReader：public String readLine(): 读取文件一行数据,
不包含换行符号 , 读到文件的末尾返回null。
BufferedWriter：public void newLine(): 写一个行分隔符，会
根据操作系统的不同,写入不同的行分隔符。

import java.io.*;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;

public class dm03 {
    public static void main(String[] args) throws Exception {

        String src = "java_0729\\a.txt";
        BufferedReader br = new BufferedReader(new FileReader(src));

        String dest = "java_0729\\b.txt";
        BufferedWriter bw = new BufferedWriter(new FileWriter(dest));

        String str = br.readLine();
        //33,23,44,55,09,98,77,31,52,10
        System.out.println(str);

        String[] strs = str.split(",");
        //[33, 23, 44, 55, 09, 98, 77, 31, 52, 10]
        System.out.println(Arrays.toString(strs));

        int[] arr = new int[strs.length];
        for (int i = 0; i < strs.length; i++) {
            String s = strs[i];
            int num = Integer.parseInt(s);
            arr[i] = num;
        }
        //排序
        Arrays.sort(arr);
        //[9, 10, 23, 31, 33, 44, 52, 55, 77, 98]
        System.out.println(Arrays.toString(arr));

        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            bw.write(arr[i]+" ");
            count++;

            if (count%5==0){
                bw.newLine();
            }
        }
        br.close();
        bw.close();
    }
}

四.转换流

FileReader 类 默认是UTF-8编码表,

由于 Windows 系统的默认是 ANSI编码

可能会出 现乱码。

        

import jdk.internal.util.xml.impl.Input;

import java.io.*;

public class dm04 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("D:/2.txt");
        InputStreamReader isr = new InputStreamReader(fis,"GBK");

        int len;
        while ((len=isr.read())!=-1){
            System.out.print((char)len);//���
            //在InputStreamReader加入"GBK"之后，输出 你好
        }
        fis.close();
        isr.close();
    }
}

4.1 InputStreamReader类

InputStreamReader类是Reader的子类，字符集可以指定，也可以使用IDEA默认UTF-8的字符集。

InputStreamReader 类的构造方法

InputStreamReader(InputStream in): 创建一个使用默认字符集
的字符流。
InputStreamReader(InputStream in, String charsetName): 创
建一个指定字符集的字符流。

InputStreamReader isr01 = new InputStreamReader(new FileInputStream("关联文件"));
InputStreamReader isr02 = new InputStreamReader(new FileInputStream("关联文件") , "GBK");

4.2 OutputStreamWriter类

OutputStreamWriter类是Writer的子类，它的字符集和InputStreamReader类一样，可以指定

也可以使用IDEA默认UTF-8的字符集。

OutputStreamWriter类的构造方法

OutputStreamWriter(OutputStream in): 创建一个使用默认字
符集的字符流。 idea默认的是utf8
OutputStreamWriter(OutputStream in, String charsetName):
创建一个指定字符集的字符流。

OutputStreamWriter isr = new OutputStreamWriter(new
FileOutputStream("关联文件"));
OutputStreamWriter isr2 = new OutputStreamWriter(new
FileOutputStream("关联文件") , "GBK");

4.3 转换流的作用

windows默认的字符集为gbk，idea的字符集为UTF-8，

我们在读取windows文件时，会出现乱码，

这种情况我们就可以用转换流去指定字符集，就可以读取文件内容。

public class DemoTest {
   public static void main(String[] args) throws
IOException {
       //创建输出流，指定关联文件的编码表名字
       String dest="文件路径";
       OutputStreamWriter osw=new
OutputStreamWriter(new
FileOutputStream(dest),"GBK");//指定字符集为”gbk“（默认大小写一样）
       //写入数据
       osw.write("今天晚上要上课");
       //关闭流
       osw.close();
       //创建输入流，指定关联文件的编码表名字
       String src="文件路径";
       InputStreamReader isr = new
InputStreamReader(new FileInputStream(src),"GBK");//指定字符集为”gbk“
       //读数据
       int len;
       while((len=isr.read())!=-1){
           System.out.println((char)len);
      }
       //关闭流
       isr.close();
  }
}

五.对象操作流

5.1 对象操作流概述

        可以把读取的对象以字节的形式读取到文件中

对象操作输入流(ObjectInputStream)

对象操作输出流（对象序列化流）：就是将对象写到本地文件中，

或者在网络中传输对象

操作输出流(ObjectOutputStream)

对象操作输入流（对象反序列化流）：把写到本地文件中的对象读

到内存中，或者接收网络中传输的对象。

5.2 ObjectOutputStream类（序列化流）

将 Java 对象的原始数据类型写出到文件, 实现对象的持久存储。

ObjectOutputStream 类构造方法

public ObjectOutputStream(OutputStream out) ： 创建一个
指定OutputStream的ObjectOutputStream

ObjectOutputStream oos = 
                    new ObjectOutputStream(new FileOutputStream("文件地址"));

FileOutputStream fileOut = 
                    new FileOutputStream("文件地址");
ObjectOutputStream out =
                    new ObjectOutputStream(fileOut);

ObjectOutputStream 类序列化操作

必须实现 .Serializable 接口，它是一个（标记）接口

不实现的话就会报异常  j ava.io.NotSerializableException

public final void writeObject (Object obj) : 将指定的对象写
出。

5.3 ObjectInputStream类（反序列化流）

ObjectInputStream 类的概述

将序列化之后的文件写为对象（恢复为对象）

ObjectInputStream 类构造方法

public ObjectInputStream(InputStream in) ： 创建一个指定
InputStream的

ObjectInputStream ois = 
                      new ObjectInputStream(new FileInputStream("文件路径"));

ObjectInputStream 类反序列化操作

public final Object readObject () : 读取一个对象。

ObjectInputStream ois = 
                      new ObjectInputStream(new FileInputStream("文件路径"));

        User user = (User)ois.readObject();

5.4 序列化集合

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;


public class dm10 {
    public static void main(String[] args) throws Exception {
        String dest = "文件路径";
        ObjectInputStream ois =
                new ObjectInputStream(new FileInputStream(dest));



        ArrayList<User> list  = (ArrayList<User>) ois.readObject();
        for (User user : list) {
            System.out.println(user.getName()+"..."+user.getAge()+"..."+user.getAddress());
        }
        ois.close();
    }
}

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Array;
import java.util.ArrayList;

public class dm09 {
    public static void main(String[] args) throws Exception {


        String src = "文件路径";
        ObjectOutputStream oos =
                new ObjectOutputStream(new FileOutputStream(src));

        ArrayList<User> list = new ArrayList<>();

        User user01 = new User();
        user01.setName("张三");
        user01.setAge(23);
        user01.setAddress("北京");

        User user02 = new User();
        user02.setName("李四");
        user02.setAge(24);
        user02.setAddress("上海");
        list.add(user01);
        list.add(user02);

        oos.writeObject(list);
        oos.close();
    }
}

5.5 序列化和反序列化注意事项

private static final long serialVersionUID = 42L;  

ok了家人们明天见。