s-day10-序列化流保存对象(ObjectOutputStream)

s-day10/src/com/inmind/buffered01/Demo01.java

@@ -0,0 +1,79 @@
+package com.inmind.buffered01;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+
+/*
+1.缓冲流的介绍
+缓冲流：基于字节字符流，本身本身没有读写功能，底层封装了一8192长度的缓冲区（数组），提高读写效率，也叫高效流
+
+字节缓冲流： BufferedInputStream BufferedOutputStream
+字符缓冲流： BufferedReader   BufferedWriter
+------------------------------------------------------------------------------------
+字节缓冲流的基本使用以及使用缓冲流复制文件（一次读写一个字节）
+  字节缓冲输入流：BufferedInputStream
+    构造方法：
+    BufferedInputStream(InputStream in) 创建一个 BufferedInputStream并保存其参数，输入流 in供以后使用。
+    常用方法：
+    int read()  ：读取一个字节数据
+    int read(byte[] bytes) ： 读取一个字节数组
+
+ 字节缓冲输出流：BufferedOutputStream
+    构造方法：
+    BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
+    常用方法：
+    void write(int b) 将指定的字节写入缓冲的输出流。
+    public void write(byte[] b)
+    void write(byte[] b, int off, int len) 从偏移量 off开始的指定字节数组写入 len字节到缓冲输出流。
+
+ */
+public class Demo01 {
+    public static void main(String[] args) throws Exception {
+        //使用缓冲流复制文件
+        //创建字节缓冲输入流
+        FileInputStream fis = new FileInputStream("1.jpg");
+        BufferedInputStream bis = new BufferedInputStream(fis);
+        //创建字节缓冲输出流
+        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("2.jpg"));
+        long start = System.currentTimeMillis();
+        //缓冲流一次读写一个字节,使用43ms
+        int c ;//保存读取的一个字节数据
+        //缓冲流不停读写
+        while ((c = bis.read()) != -1) {
+            bos.write(c);
+        }
+        long end = System.currentTimeMillis();
+        System.out.println("复制所需的毫秒值："+(end-start));
+
+        bis.close();
+        bos.close();
+
+    }
+
+
+
+
+
+
+    //使用字节输入输出流进行一次读写一个字节，复制文件  6477ms
+    public static void method(String[] args)throws Exception {
+        //1.创建字节输入流
+        FileInputStream fis = new FileInputStream("D:\\io_test\\upload\\1.jpg");
+        //2.创建字节输出流
+        FileOutputStream fos = new FileOutputStream("1.jpg");
+        //3.不停地读写到另一个文件中（边读边写）
+        long start = System.currentTimeMillis();
+        //方式一：一次读写一个字节
+        int c;//用来记录读取的字节数据
+        while ((c = fis.read()) != -1) {
+            fos.write(c);
+        }
+        long end = System.currentTimeMillis();
+        System.out.println("复制所需的毫秒值："+(end-start));
+        //4.资源释放
+        fis.close();
+        fos.close();
+    }
+}

s-day10/src/com/inmind/buffered01/Demo02.java

@@ -0,0 +1,29 @@
+package com.inmind.buffered01;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+
+/*
+字节缓冲流一次读写一个字节数组的方式复制文件
+ */
+public class Demo02 {
+    public static void main(String[] args) throws Exception {
+        //创建字节缓冲输入输出流
+        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("2.jpg"));
+        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("3.jpg"));
+        //一次读写一个字节数组,
+        byte[] bytes = new byte[1024];
+        long start = System.currentTimeMillis();
+        int len;
+        while ((len = bis.read(bytes)) != -1) {
+            bos.write(bytes, 0, len);
+        }
+        long end = System.currentTimeMillis();
+        System.out.println("复制所用时间："+(end - start));//3ms
+
+        bis.close();
+        bos.close();
+    }
+}

s-day10/src/com/inmind/buffered01/Demo03.java

@@ -0,0 +1,64 @@
+package com.inmind.buffered01;
+
+import java.io.*;
+
+/*
+字符缓冲流的基本使用
+    字符缓冲流： BufferedReader ， BufferedWriter
+    字符缓冲输入流：BufferedReader
+    构造方法
+    BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
+
+    常用方法：
+    int read() 读一个字符
+    int read(char[] cbuf) 将字符读入数组。
+
+
+    字符缓冲输出流：BufferedWriter
+    构造方法：
+    BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
+
+    常用方法：
+    void write(int c) 写一个字符
+    void write(char[] cbuf) 写入字符数组的一部分。
+    void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
+    void write(String s) 写一个字符串的一部分。
+    void write(String s, int off, int len) 写一个字符串的一部分。
+
+    注意：
+    	1.字符缓冲流的基本使用与昨天的字符流一模一样
+    	2.字符缓冲流就是底层封装了一个8192的字符数组，提高字符流的读写效率
+ */
+public class Demo03 {
+
+    //字符缓冲输出流写字符的基本操作，与字符流一模一样
+    public static void main(String[] args) throws Exception {
+        BufferedWriter bw = new BufferedWriter(new FileWriter("source2.txt"));
+        bw.write('我');
+        char[] chars = {'爱', '中', '国'};
+        bw.write(chars);
+        bw.write(chars,1,2);
+        bw.write("外面又在下暴雨了");
+        bw.flush();
+        bw.close();
+    }
+
+
+    //字符缓冲输入流读取字符的基本操作，与字符流一模一样
+    public static void method(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new FileReader("source1.txt"));
+        //一次读取一个字符
+        /*int ch;//保存读取的字符数据
+        while ((ch = br.read()) != -1) {
+            System.out.println((char) ch);
+        }*/
+        //一次读取一个字符数组
+        char[] chars = new char[1024];
+        int len;
+        while ((len = br.read(chars)) != -1) {
+            System.out.println(new String(chars,0,len));
+        }
+
+        br.close();
+    }
+}

s-day10/src/com/inmind/buffered01/Demo04.java

@@ -0,0 +1,50 @@
+package com.inmind.buffered01;
+
+import java.io.*;
+
+/*
+字符缓冲流中特有的功能
+    BufferedWriter: newLine 它能够进行多个系统之间的换行的兼容
+
+    BufferedReader: readLine 它能够将文件中的内容按一行文本来读取
+ */
+public class Demo04 {
+    public static void main(String[] args) throws Exception {
+        /*
+        字符缓冲输入流,一次读取一行文本
+        String readLine() 读一行文字。
+         */
+//        BufferedReader br = new BufferedReader(new FileReader("source2.txt"));
+        BufferedReader br = new BufferedReader(new FileReader("s-day10\\src\\com\\inmind\\buffered01\\Demo01.java"));
+        /*String line = br.readLine();
+        System.out.println(line);
+
+        line = br.readLine();
+        System.out.println(line);
+
+        line = br.readLine();
+        System.out.println(line);
+
+        line = br.readLine();
+        System.out.println(line);*/
+        String line;//用来保存读取一行的文本
+        while ((line = br.readLine()) != null) {
+            System.out.println(line);
+        }
+
+        br.close();
+
+    }
+
+    //BufferedWriter: newLine 它能够进行多个系统之间的换行的兼容
+    public static void method(String[] args) throws Exception {
+        //使用字符缓冲输出流,输出我是谁我在哪我干嘛
+        BufferedWriter bw = new BufferedWriter(new FileWriter("source2.txt"));
+        bw.write("我是谁");
+        bw.newLine();
+        bw.write("我在哪");
+        bw.newLine();
+        bw.write("我在干嘛");
+        bw.close();//调用flush输出内容
+    }
+}

s-day10/src/com/inmind/buffered01/Test05.java

@@ -0,0 +1,54 @@
+package com.inmind.buffered01;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.util.HashMap;
+
+/*
+字符缓冲流的练习(文本排序)【BufferedReader  BufferedWriter】
+    3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
+    8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
+    4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
+    2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
+    1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
+    9.今当远离，临表涕零，不知所言。
+    6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
+    7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
+    5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也
+
+    实现分析:
+        1.创建一个Map对象保存键值对,9---->今当远离，临表涕零，不知所言
+        2.创建字符缓冲输入流对象,读取每行文本（readLine）
+        3.读到每行文本时,按.切割,左边作为key,右边的文本就作为值,保存到map
+        4.根据1~9的顺序,将Map中的文本数据输出到文件中,每行要换行（newLine）
+
+*/
+public class Test05 {
+    public static void main(String[] args) throws Exception {
+        //1.创建一个Map对象保存键值对,9---->今当远离，临表涕零，不知所言
+        HashMap<String, String> maps = new HashMap<>();
+        //2.创建字符缓冲输入流对象,读取每行文本（readLine）
+        BufferedReader br = new BufferedReader(new FileReader("source2.txt"));
+        //3.读到每行文本时,按.切割,左边作为key,右边的文本就作为值,保存到map
+        String line;
+        while ((line = br.readLine()) != null) {
+            //.表示正则中的每个字符，会把所有内容切割掉
+            String[] values = line.split("\\.");
+            maps.put(values[0], values[1]);//9---->今当远离，临表涕零，不知所言
+        }
+        System.out.println(maps.size());
+        System.out.println(maps);
+        //4.根据1~9的顺序,将Map中的文本数据输出到文件中,每行要换行（newLine）
+        BufferedWriter bw = new BufferedWriter(new FileWriter("source1.txt"));
+        for (int i = 1; i <= 9; i++) {
+            String s = maps.get(i+"");
+            bw.write(i+"-"+s);
+            bw.newLine();
+            bw.flush();
+        }
+        br.close();
+        bw.close();
+    }
+}

s-day10/src/com/inmind/object_stream03/Demo09.java

@@ -0,0 +1,26 @@
+package com.inmind.object_stream03;
+
+import java.io.FileOutputStream;
+import java.io.ObjectOutputStream;
+
+/*
+序列化流保存对象(ObjectOutputStream)
+构造方法：
+     ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。
+
+ 常用方法：
+    void writeObject(Object obj) 将指定的对象写入ObjectOutputStream。
+
+
+ */
+public class Demo09 {
+    public static void main(String[] args) throws Exception {
+        Student student = new Student("张三", 18);
+        //获取序列化流对象，写出对象（将对象保存到文件中）
+        FileOutputStream fos = new FileOutputStream("student.txt");
+        ObjectOutputStream oos = new ObjectOutputStream(fos);
+        //注意：如果要序列化对象，对应的类，必须支持序列化操作，也就是实现Serializable，类似一个标记的功能，表示可以序列化
+        oos.writeObject(student);
+        oos.close();
+    }
+}

s-day10/src/com/inmind/object_stream03/Student.java

@@ -0,0 +1,21 @@
+package com.inmind.object_stream03;
+
+import java.io.Serializable;
+
+public class Student implements Serializable {
+    String name;
+    int age;
+
+    @Override
+    public String toString() {
+        return "Student{" +
+                "name='" + name + '\'' +
+                ", age=" + age +
+                '}';
+    }
+
+    public Student(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+}

s-day10/src/com/inmind/transfer_stream02/Demo06.java

@@ -0,0 +1,27 @@
+package com.inmind.transfer_stream02;
+
+import java.io.FileReader;
+
+/*
+    使用字符流,读取电脑中的文件数据到java内存
+
+    出现乱码的原因:中文数据在读写操作的前后的编码方式不一致.
+    注意：
+        1.UTF-8，字母和数字只占1个字节，而一个中文占3个字节，它的前128个字符完全兼容ASCII码表
+        2.GBK，字母和数字只占1个字节，而一个中文占2个字节，它的前128个字符完全兼容ASCII码表
+ */
+public class Demo06 {
+    public static void main(String[] args) throws Exception {
+        //字符输入流
+//        FileReader fr = new FileReader("D:\\io_test\\file_gbk.txt");//gbk编码，utf-8解码出现了乱码
+        FileReader fr = new FileReader("D:\\io_test\\file_utf8.txt");
+        //一次读取一个字符数组的方式
+        char[] chars = new char[1024];
+        int len;
+        while ((len = fr.read(chars)) != -1) {
+            System.out.println(new String(chars,0,len));
+        }
+
+        fr.close();
+    }
+}

s-day10/src/com/inmind/transfer_stream02/Demo07.java

@@ -0,0 +1,81 @@
+package com.inmind.transfer_stream02;
+
+import java.io.FileInputStream;
+import java.io.InputStreamReader;
+
+/*
+9.编码表的介绍
+编码：将字符转换成字节（类似加密）
+解码：将字节转换成字符（类似解密）
+
+编码表：将每个国家的文字和二进制对应起来
+
+ASCII 使用1个字节表示字符（第一位一定是0表示正数），0~127
+ISO-8859-1 使用1个字节表示字符，包扩了ASCII的，表示拉丁，欧洲的语言，不包含中文
+
+gb2312: 使用2个字节表示1个字符，7000个简体中文和符号
+big5:  使用2个字节表示繁体字，片假名
+
+GBK（国标码），使用2个字节表示1个字符，涵盖2万多个中文，繁体字完全兼容ASCII
+
+unicode（万国码） u+0000到U+10FFFF的字符，包含110万字符，包含所有国家的文字
+
+utf-8 :使用1,2,3,4个字节表示字符（3个字节表示1个中文）
+
+utf-16 :使用2 ，4个字节表示字符
+
+utf-32 :使用4个字节表示字符，比较占用内存
+
+注意:
+    1.GBK针对国内的字符进行编解码操作,它前128个字符完全兼容ascii,一个中文占2个字节
+    2.utf-8针对国际的字符进行编解码操作,它前128个字符完全兼容ascii,一个中文占3个字节
+-------------------------------------------------------------------------------
+转换流_指定编码读取(InputStreamReader)
+
+InputStreamReader是从字节流到字符流的桥梁:解码
+
+构造方法：
+    InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader。
+    InputStreamReader(InputStream in, String charsetName) 创建一个使用命名字符集的InputStreamReader。
+
+常用方法：
+    close()
+    int read();
+    int read(char[]  chars)
+
+ 注意:转换流的作用是指定编码方式去读写文件
+
+
+ */
+public class Demo07 {
+    //指定GBK编码方式去读取指定文件
+    public static void main(String[] args) throws Exception {
+        //创建转换输入流，并指定gbk编码
+        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\io_test\\file_gbk.txt"),"GBK");
+        char[] chars = new char[1024];
+        int len;
+        while ((len = isr.read(chars)) != -1) {
+            System.out.println(new String(chars,0,len));
+        }
+
+        isr.close();
+    }
+
+
+    //指定utf-8编码方式去读取指定文件
+    public static void method() throws Exception {
+        /*
+        创建转换输入流
+        InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader。
+         */
+//        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\io_test\\file_utf8.txt"));
+        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\io_test\\file_utf8.txt"),"utf-8");
+        //一次读一个字符或者字符数组
+        int ch ;
+        while ((ch = isr.read())!=-1){
+            System.out.print((char) ch);
+        }
+
+        isr.close();
+    }
+}

s-day10/src/com/inmind/transfer_stream02/Demo08.java

@@ -0,0 +1,43 @@
+package com.inmind.transfer_stream02;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+
+/*
+转换流_按照指定编码写数据(OutputStreamWriter)
+OutputStreamWriter是从字符流到字节流的桥梁: 编码
+
+构造方法：
+    OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。
+    OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter。
+
+常用方法：
+    close
+    flush
+    void write(char[] cbuf) 写入一个字符数组。
+    abstract void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
+    void write(int c) 写一个字符
+    void write(String str) 写一个字符串
+    void write(String str, int off, int len) 写一个字符串的一部分。
+
+
+ */
+public class Demo08 {
+    //使用转换输出流,指定utf-8编码方式输出内容到文件中
+    public static void main(String[] args) throws Exception{
+        FileOutputStream fos = new FileOutputStream("D:\\io_test\\file_utf81.txt");
+//        OutputStreamWriter osw = new OutputStreamWriter(fos);
+        OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
+        osw.write("呵呵，今天不下雨了，abc123");
+        osw.flush();
+        osw.close();
+    }
+    //使用转换输出流,指定GBK编码方式输出内容到文件中
+    public static void method() throws Exception {
+        FileOutputStream fos = new FileOutputStream("D:\\io_test\\file_gbk1.txt");
+        OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");
+        osw.write("呵呵，今天不下雨了，abc123");
+        osw.flush();
+        osw.close();
+    }
+}