(day21)缓冲流、转换流、序列化流

        缓冲流、转换流、序列化流
第一章 缓冲流        
    1.1 概述
        缓冲流也叫高效流, 是对4个基本的FileXxx流的增强, 所以也是4个流
        按照数据分类:
        字节缓冲流:
            BufferedInputStream,   BufferedOutputStream
        字符缓冲流:
            BufferedReader,     BufferedWriter
    1.2 字节缓冲流
        构造方法:
        public BufferInputStream(InputStream in):创建一个新的缓冲输入流
        public BufferedOutputStream(OutputStream out): 创建一个新的缓冲输出流
        
        字节缓冲输出流方法:
            writer(int b); 写一个字节
            writer(byte[] bytes);  写一个字节数组
            writer(byte[] bytes, int start, int length); 写字节数组的一部分
            close();  关闭资源
        代码演示:
        public static void main(String[] args) throws IOException {
            OutputStream out = new BufferedOutputStream(new FileOutputStream("D:\\2development\\abc\\1.txt"));
            //一次写一个字节
            out.write("ancs".getBytes());
            out.write("asdf".getBytes());
            out.close();
        }
        
        字节缓冲输入流方法:
            int read();  读一个字节
            int read(byte[] bytes);  读取一个字节数组
            close(); 关闭资源
        代码演示:
        public static void main(String[] args) throws IOException {
            InputStream in = new BufferedInputStream(new FileInputStream("D:\\2development\\abc\\1.txt"));
            //一次读取一个字节
            int date = 0;
            while((date = in.read()) != -1){
                System.out.println((char)date);
            }
            in.close();
            //一次读取一个字节数组
            byte[] bytes = new byte[1024];
            int len = 9;
            while((len = in.read(bytes)) != -1){
                System.out.println(new String(bytes,0,len));
            }
            in.close();
        }
            
    注意: (缓冲流是高效流)使用缓冲流读取速度要更快
    
    1.3 字符缓冲流    
        构造方法
        public BufferedReader(Reader in) :创建一个 新的缓冲输入流。 
        public BufferedWriter(Writer out) : 创建一个新的缓冲输出流。
        代码演示:
            // 创建字符缓冲输入流
            BufferedReader br = new BufferedReader(new FileReader("br.txt"));
            // 创建字符缓冲输出流
            BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
        
        特有方法(字符缓冲流的基本方法与普通字符流调用方式一致,不再阐述):
            BufferedReader: public String readLine(): 读一行文字, 返回值为读取到的数据  如果没有数据 返回null值(不读取\r\n) 
            BufferedWriter: public void newLine(): 写一行行分隔符,写换行, 由系统属性定义符号。
        代码演示(Reader):
        public static void main(String[] args) throws IOException {
            BufferedReader r = new BufferedReader(new FileReader("D:\\2development\\abc\\1.txt"));
            //一次读取一个字符
//            String line = r.readLine();
//            System.out.println(line);
//            line = r.readLine();
//            System.out.println(line);
            String line1 = null;
            while((line1 = r.readLine()) != null){
                System.out.println(line1);
            }
            r.close();
        }
        练习:
        // 将出师表恢复顺序
        代码演示:
        public static void main(String[] args) throws IOException {
            BufferedReader r = new BufferedReader(new FileReader("day21\\Test\\2.txt"));
            TreeSet<String> set = new TreeSet<>(new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    String num1 = o1.split("\\.")[0];
                    String num2 = o2.split("\\.")[0];

                    return Integer.parseInt(num1) - Integer.parseInt(num2);
                }
            });
            //获取每一行记录  将数据存储到set集合中
            String line = null;
            while((line = r.readLine())!= null){
                set.add(line);
            }
            r.close();
        
            BufferedWriter w = new BufferedWriter(new FileWriter("day21\\Test\\2.txt"));
            //遍历 依次获取每条记录 已经是排序后的
            for (String s : set) {
                w.write(s);
                w.newLine();
                w.flush();
            }
            w.close();
        }
        
第二章 转换流
    2.1 编码引出的问题
        在IDEA中,使用 FileReader 读取项目中的文本文件。
        由于IDEA的设置,都是默认的 UTF-8 编码,所以没有任何问题。
        但是,当读取Windows系统中创建的文本文件时,由于Windows系统的默认是GBK编码,就会出现乱码。
    
    2.2 InputStream类
        java.io.InputStream  可以使用Reader的read方法
        构造方法:
            InputStream(InputStream in);  使用平台默认编码 
            InputStream(InputStream in, String charsetName);  指定编码
                                            String CharsetName:  指定字符集  不区分大小写  不能乱写
                                            
        构造举例,代码如下:
        InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
        InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");
        
        (指定编码读取)代码演示:
        public static void main(String[] args) throws IOException {
            InputStreamReader r = new InputStreamReader(new FileInputStream("D:\\2development\\abc\\1.txt"),"GBK");

            char[] chs = new char[1024];
            int line = r.read(chs);
            System.out.println(new String(chs,0,line));

            r.close();
        }
    
    2.3 OutputStreamWriter
        java.io.OutputStreamWriter   继承自Writer
        构造方法:
            public OutputStreamWriter(OutputStream out);  创建一个使用默认字符集的字符流
            public OutputStreamWriter(OutputStream out, String charsetName);   创建一个指定字符集的字符流
        构造举例,代码如下:
            OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
            OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");
        (指定编码写出)代码演示:
        public static void main(String[] args) throws IOException {
            Writer w = new OutputStreamWriter(new FileOutputStream("D:\\2development\\abc\\1.txt"),"GBK");

            w.write("你好 世界");
            w.close();
        }
    
        (文件编码转换)练习
        //将GBK编码的文本文件  转化为UTF-8编码的文本文件
        代码演示:
        public static void main(String[] args) throws IOException {
            Reader r = new InputStreamReader(new FileInputStream("D:\\2development\\abc\\gbk.txt"),"GBK");
            Writer w = new OutputStreamWriter(new FileOutputStream("D:\\2development\\abc\\utf.txt"),"UTF-8");

            char[] chs = new char[1024];
            int len = 0;
            while((len = r.read(chs))!= -1){
                w.write(chs,0,len);
            }

            w.close();
            r.close();
        }
        
第三章 序列化
    3.1 概述
    Java提供了一种对象序列化的机制。
    用一个字节序列可以表示一个对象,该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。
    字节序列写出到文件之后,相当于文件中持久保存了一个对象的信息。    
    反之,该字节序列还可以从文件中读取回来,重构对象,对它进行反序列化。    
    3.2 ObjectOutputStream类
        java.io.ObjectOutputStream  序列化流
            构造方法:
                public ObjectOutputStream(OutputStream out) : 创建一个指定OutputStream的ObjectOutputStream。
            构造举例,代码如下:
                FileOutputStream fileOut = new FileOutputStream("employee.txt");
                ObjectOutputStream out = new ObjectOutputStream(fileOut);
            方法:
                writeObject(Object obj)  写对象
    3.3 ObjectInputStream类
        java.io.ObjectInputStream 反序列化流
            ObjectInputStream反序列化流,将之前使用ObjectOutputStream序列化的原始数据恢复为对象。
            构造方法:
                public ObjectInputStream(InputStream in);   创建一个指定InputStream的ObjectInputStream。
            方法:
                public final Object readObject();   读对象
        
        代码演示:
        public class Person implements Serializable {
            private static final long serialVersionUID = 10L;

            private String name;
            public int age;

            public Person() {
                System.out.println("空参");
            }

            public Person(String name, int age) {
                this.name = name;
                this.age = age;
                System.out.println("带参");
            }

            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 "Person{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        '}';
            }
        }
        
        public class Test01 {
            public static void main(String[] args) throws IOException, ClassNotFoundException {
                //writeObj();

                readObj();
            }
            public static void writeObj() throws IOException {
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day21//Test//Person.txt"));
                Person p = new Person("柳岩",38);
                oos.writeObject(p);

                oos.close();
            }
            public static void readObj() throws IOException, ClassNotFoundException {
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day21//Test//Person.txt"));

                Object obj = ois.readObject();  //new Person(柳岩,38)
                System.out.println(obj);

                ois.close();
            }
        }
        
        //集合序列化
        public class Test02 {
            public static void main(String[] args) throws IOException, ClassNotFoundException {

                // writeList();
                readList();
            }
            public static void writeList() throws IOException {
                List<Person> list = new ArrayList<>();
                list.add(new Person("柳岩",38));
                list.add(new Person("唐嫣",28));
                list.add(new Person("金莲",18));
                list.add(new Person("杨幂",58));

                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day21\\Test\\list.txt"));
                oos.writeObject(list);
                oos.close();
            }
            public static void readList() throws IOException, ClassNotFoundException {
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day21\\Test\\list.txt"));

                Object obj = ois.readObject();
                List<Person> list = (List<Person>)obj;
                for (Person person : list) {
                    System.out.println(person);
                }
                ois.close();
            }
        }
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值