java-进阶-day10-随堂笔记

原创手机用户9600 2023-07-19

320

课堂知识点

一、字节缓冲流

1.字节缓冲输出流

构造方法：
- BufferedOutputStream(OutputStream out); 创建字节缓冲输出流对象
- BufferedOutputStream(OutputStream out,int size); 创建字节缓冲输出流对象并指定缓冲区大小

示例代码

public class Demo01BufferedOutputStream {
    public static void main(String[] args) throws IOException {
        //2.创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象,提高FileOutputStream对象效率
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("10_IO\\a.txt"));
        //3.使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区中
        bos.write("我把数据写入到内部缓冲区中".getBytes());
        //4.使用BufferedOutputStream对象中的方法flush,把内部缓冲区中的数据,刷新到文件中
        bos.flush();
        //5.释放资源(会先调用flush方法刷新数据,第4部可以省略)
        bos.close();
    }
}

2.字节缓冲输入流

构造方法
- BufferedInputStream(InputStream is); 创建字节缓冲输入流对象
- BufferedInputStream(InputStream is,int size); 创建字节缓冲输入流对象并指定缓冲区大小

示例代码

public class Demo02BufferedInputStream {
    public static void main(String[] args) throws IOException {
        //2.创建BufferedInputStream对象,构造方法中传递FileInputStream对象,提高FileInputStream对象的读取效率
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("10_IO\\a.txt"));
        //3.使用BufferedInputStream对象中的方法read,读取文件
        //int read()从输入流中读取数据的下一个字节。
        /*int len = 0;//记录每次读取到的字节
        while((len = bis.read())!=-1){
            System.out.println(len);
        }*/

        //int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
        byte[] bytes =new byte[1024];//存储每次读取的数据
        int len = 0; //记录每次读取的有效字节个数
        while((len = bis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }

        //4.释放资源
        bis.close();
    }
}

3.字节缓冲流复制文件

public class Test01 {
    public static void main(String[] args) throws IOException{
        long start = System.currentTimeMillis();
        method04();
        long end = System.currentTimeMillis();

        System.out.println(end - start);
    }

    //第四种：字节缓冲流一次读写一个字节数组  【重点掌握】
    public static void method04() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\src\\颈椎操.flv"));

        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("d:\\dest\\copy.flv"));

        byte[] arr = new byte[1024];
        int len;
        while((len = bis.read(arr)) != -1) {
            bos.write(arr,0,len);
        }

        bis.close();
        bos.close();
    }

    //第三种：字节缓冲流一次读写一个字节
    public static void method03() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\src\\颈椎操.flv"));

        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("d:\\dest\\copy.flv"));

        int b;
        while((b = bis.read()) != -1) {
            bos.write(b);
        }

        bis.close();
        bos.close();
    }

    //第二种：普通字节流一次读写一个字节数组
    public static void method02() throws IOException{
        FileInputStream fis = new FileInputStream("d:\\src\\颈椎操.flv");

        FileOutputStream fos = new FileOutputStream("d:\\dest\\copy.flv");

        byte[] arr = new byte[1024];
        int len;
        while((len = fis.read(arr)) != -1) {
            fos.write(arr,0,len);
        }

        fis.close();
        fos.close();
    }

    //第一种：普通字节流一次读写一个字节
    public static void method01() throws IOException{
        FileInputStream fis = new FileInputStream("d:\\src\\颈椎操.flv");

        FileOutputStream fos = new FileOutputStream("d:\\dest\\copy.flv");

        int b;
        while((b = fis.read()) != -1) {
            fos.write(b);
        }

        fis.close();
        fos.close();
    }
}

二、字符缓冲流

1.字符缓冲输出流

构造方法
- BufferedWriter(Writer w); 创建字符缓冲输出流对象
- BufferedWriter(Writer w,int size); 创建字符缓冲输出流对象并指定缓冲区大小
特有的成员方法
- newLine(); 写出一个通用的系统换行符号

示例代码

public class Demo03BufferedWriter {
    public static void main(String[] args) throws IOException {
        //1.创建字符缓冲输出流对象,构造方法中传递字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("10_IO\\c.txt"));
        //2.调用字符缓冲输出流中的方法write,把数据写入到内存缓冲区中
        for (int i = 0; i <10 ; i++) {
            bw.write("传智播客");
            //bw.write("\r\n");
            bw.newLine();
        }
        //3.调用字符缓冲输出流中的方法flush,把内存缓冲区中的数据,刷新到文件中
        bw.flush();
        //4.释放资源
        bw.close();
    }
}

2.字符缓冲输入流

构造方法
- BufferedReader(Reader r); 创建字符缓冲输入流对象
- BufferedReader(Reader r,int size); 创建字符缓冲输入流对象并指定缓冲区大小
特有成员方法
- readLine(); 一次读取一整行数据，以字符串形式返回

示例代码

public class Demo04BufferedReader {
    public static void main(String[] args) throws IOException {
        //1.创建字符缓冲输入流对象,构造方法中传递字符输入流
        BufferedReader br = new BufferedReader(new FileReader("10_IO\\c.txt"));

        //2.使用字符缓冲输入流对象中的方法read/readLine读取文本
        /*
            发下以上读取是一个重复的过程,所以可以使用循环优化
            不知道文件中有多少行数据,所以使用while循环
            while的结束条件,读取到null结束
         */
        String line;
        while((line = br.readLine()) != null){
            System.out.println(line);
        }

        //3.释放资源
        br.close();
    }
}

3.字符缓冲流的案例

使用字符缓冲流复制文本文件

public class Test02 {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new FileReader("my04-code\\a.txt"));

        BufferedWriter bw = new BufferedWriter(new FileWriter("my04-code\\b.txt"));

        String line;
        while((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
        }

        br.close();
        bw.close();
    }
}

对文本中的数据进行排序

public class Test03 {
    public static void main(String[] args) throws IOException{
        //1.使用字符缓冲输入流读取c.txt文件中的内容
        BufferedReader br = new BufferedReader(new FileReader("my04-code\\c.txt"));

        //2.将读取出来的数据保存到一个ArrayList集合中
        ArrayList<Integer> list = new ArrayList<>();

        String line;
        while((line = br.readLine()) != null) {
            list.add(Integer.parseInt(line));
        }

        br.close();

        //3.对集合进行排序。Collections.sort()
        Collections.sort(list);

        //4.使用字符缓冲输出流将集合中的数据写出到c.txt文件中
        BufferedWriter bw = new BufferedWriter(new FileWriter("my04-code\\c.txt"));
        for(int num : list) {
            bw.write(num + "");
            bw.newLine();
        }

        bw.close();
    }
}

三、转换流

1.常见的编码表

ASCII码表。美国通用的码表。包含大小写字母、数字、一些符号~~
ISO-8859-1码表。欧洲各个国家使用的码表。兼容ASCII码表
GB2312码表：最早的中文的编码表
GBK码表。目前使用最多的
GB18032.最新的中文码表
Unicode码表。万国码

2.转换输出流

public class Demo02OutputStreamWriter {
    public static void main(String[] args) throws IOException {
        //write_utf_8();
        write_gbk();
    }

    /*
       使用转换流OutputStreamWriter写GBK格式的文件
    */
    private static void write_gbk() throws IOException {
        //1.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\gbk.txt"),"GBK");
        //2.使用OutputStreamWriter对象中的方法write,把字符转换为字节存储缓冲区中(编码)
        osw.write("你好");
        //3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
        osw.flush();
        //4.释放资源
        osw.close();
    }

    /*
        使用转换流OutputStreamWriter写UTF-8格式的文件
     */
    private static void write_utf_8() throws IOException {
        //1.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称
        //OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\utf_8.txt"),"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\utf_8.txt"));//不指定默认使用UTF-8
        //2.使用OutputStreamWriter对象中的方法write,把字符转换为字节存储缓冲区中(编码)
        osw.write("你好");
        //3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
        osw.flush();
        //4.释放资源
        osw.close();
    }
}

3.转换输入流

public class Demo03InputStreamReader {
    public static void main(String[] args) throws IOException {
        //read_utf_8();
        read_gbk();
    }

    /*
        使用InputStreamReader读取GBK格式的文件
     */
    private static void read_gbk() throws IOException {
        //1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
        //InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\gbk.txt"),"UTF-8");//???
        InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\gbk.txt"),"GBK");//你好

        //2.使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while((len = isr.read())!=-1){
            System.out.println((char)len);
        }
        //3.释放资源
        isr.close();
    }

    /*
        使用InputStreamReader读取UTF-8格式的文件
     */
    private static void read_utf_8() throws IOException {
        //1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
        //InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\utf_8.txt"),"UTF-8");
        InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\utf_8.txt"));//不指定默认使用UTF-8
        //2.使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while((len = isr.read())!=-1){
            System.out.println((char)len);
        }
        //3.释放资源
        isr.close();
    }
}

4.转换流的案例

按照指定编码格式读写文件

public class Test05 {
    public static void main(String[] args) throws IOException{
        //将src文件夹中的gbk编码格式的b.txt复制到dest文件夹中。复制过去后的文件也是gbk编码格式
        //copy1();

        //将src文件夹中的gbk编码格式的b.txt复制到dest文件夹中。复制过去后的文件编码格式为utf-8
        copy2();
    }

    private static void copy2() throws IOException{
        //创建转换字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("d:\\src\\b.txt"),"gbk");
        //通过字符缓冲流进一步对isr进行封装
        BufferedReader br = new BufferedReader(isr);

        //创建转换字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d:\\dest\\bb.txt"),"utf-8");
        //通过字符缓冲输出流进一步对osw进行封装
        BufferedWriter bw = new BufferedWriter(osw);

        String line;
        while((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
        }

        br.close();
        bw.close();
    }

    private static void copy1() throws IOException{
        //创建转换字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("d:\\src\\b.txt"),"gbk");
        //通过字符缓冲流进一步对isr进行封装
        BufferedReader br = new BufferedReader(isr);

        //创建转换字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d:\\dest\\b.txt"),"gbk");
        //通过字符缓冲输出流进一步对osw进行封装
        BufferedWriter bw = new BufferedWriter(osw);

        String line;
        while((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
        }

        br.close();
        bw.close();
    }
}

四、序列化流

1.序列化和反序列化

序列化：将对象写出到文件中
反序列化：将文件中保存的对象读取到程序中

2.ObjectOutputStream类

构造方法
- ObjectOutputStream(OutputStream out);
成员方法
- writeObject(Object obj);

示例代码

注意事项：参与序列化和反序列化的类，必须要实现Serializable接口！

public class Demo01ObjectOutputStream {
    public static void main(String[] args) throws IOException {
        //1.创建ObjectOutputStream对象,构造方法中传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\\person.txt"));
        //2.使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中
        oos.writeObject(new Person("小美女",18));
        //3.释放资源
        oos.close();
    }
}

3.ObjectInputStream类

构造方法
- ObjectInputStream(InputStream in);
成员方法
- Object readObject();

示例代码

public class Demo02ObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建ObjectInputStream对象,构造方法中传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("10_IO\\person.txt"));
        //2.使用ObjectInputStream对象中的方法readObject读取保存对象的文件
        Object o = ois.readObject();        // Object o = new Person("小美女",18);
        //3.释放资源
        ois.close();
        //4.使用读取出来的对象(打印)
        System.out.println(o);
        
        Person p = (Person)o;
        System.out.println(p.getName()+p.getAge());
    }
}

4.transient瞬态关键字

被该关键字修饰的成员，不参与序列化和反序列化

5.序列化号

格式：private static final long serialVersionUID = -5122234326042282749L;

6.序列化的案例

public class Demo03Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.定义一个存储Person对象的ArrayList集合
        ArrayList<Person> list = new ArrayList<>();
        //2.往ArrayList集合中存储Person对象
        list.add(new Person("张三",18));
        list.add(new Person("李四",19));
        list.add(new Person("王五",20));
        //3.创建一个序列化流ObjectOutputStream对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("10_IO\\list.txt"));
        //4.使用ObjectOutputStream对象中的方法writeObject,对集合进行序列化
        oos.writeObject(list);
        oos.close();

        //5.创建一个反序列化ObjectInputStream对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("10_IO\\list.txt"));
        //6.使用ObjectInputStream对象中的方法readObject读取文件中保存的集合
        Object o = ois.readObject();
        //7.把Object类型的集合转换为ArrayList类型
        ArrayList<Person> list2 = (ArrayList<Person>)o;
        //8.遍历ArrayList集合
        for (Person p : list2) {
            System.out.println(p);
        }
        //9.释放资源
        ois.close();
    }
}

五、打印流

1.PrintStream

public class Demo01PrintStream {
    public static void main(String[] args) throws FileNotFoundException {
        //System.out.println("HelloWorld");

        //创建打印流PrintStream对象,构造方法中绑定要输出的目的地
        PrintStream ps = new PrintStream("10_IO\\print.txt");
        //如果使用继承自父类的write方法写数据,那么查看数据的时候会查询编码表 97->a
        ps.write(97);
        //如果使用自己特有的方法print/println方法写数据,写的数据原样输出 97->97
        ps.println(97);
        ps.println(8.8);
        ps.println('a');
        ps.println("HelloWorld");
        ps.println(true);

        //释放资源
        ps.close();
    }
}

「喜欢这篇文章，您的关注和赞赏是给作者最好的鼓励」

关注作者

java-进阶-day10-随堂笔记

课堂知识点

一、字节缓冲流

1.字节缓冲输出流

2.字节缓冲输入流

3.字节缓冲流复制文件

二、字符缓冲流

1.字符缓冲输出流

2.字符缓冲输入流

3.字符缓冲流的案例

三、转换流

1.常见的编码表

2.转换输出流

3.转换输入流

4.转换流的案例

四、序列化流

1.序列化和反序列化

2.ObjectOutputStream类

3.ObjectInputStream类

4.transient瞬态关键字

5.序列化号

6.序列化的案例

五、打印流

1.PrintStream

评论