java-编码解码-流的操作规律

一 编码解码

字符串：String 字节数组：byte[]
字符串--编码(getBytes())-->字节数组
字节数组--解码(new String(byte[]))-->字符串

public class EncodingDemo {

    /**
     * @param args
     * @throws UnsupportedEncodingException
     */
    public static void main(String[] args) throws UnsupportedEncodingException {
        /*
        字符串：String  字节数组：byte[]
        字符串--编码(getBytes())-->字节数组
        字节数组--解码(new String(byte[]))-->字符串

        "你好"：
        GBK编码 -60 -29 -70 -61
        UTF-8编码：-28 -67 -96 -27 -91 -67

        */

        String str = "你好";

        //对字符串编码。--->字节数组。
        byte[] buf1 = str.getBytes("utf-8");

//        for(byte b : buf1){
//            System.out.print(b);
//        }

        //对字节数组解码 。--->字符串。
        String s1 = new String(buf1,"utf-8");
        System.out.println(s1);

    }

}

二 按照字节解决字符串

public static void main(String[] args) throws UnsupportedEncodingException {

        /*
        1，对字符串按照字节数截取(默认码表)，"abc你好" 有5个字符，有7个字节。
        按照3个字节截取 abc ，按照四个字节截取 abc和你字的一半，如果出现中文一半舍弃。
        请定义一个功能解决这个问题。
        你好的gbk：-60 -29 -70 -61
        思路：
        1，一个中文gbk两个字节，都是负数。
        2，在截取时，先看最后一位是负数吗？不是，直接截取就哦了。
            如果是，不要直接舍弃，最好在看一下该负数之前连续出现了几个负数。
        3，因为中文两个字节，出现的负数个数是偶数，不需要舍弃的，是奇数，就舍弃最后一个。哦耶。

        */

        String str = "abc你好cd谢谢";

        str = "abc琲琲cd琲琲";

        byte[] buf = str.getBytes("GBK");
        for (int i = 0; i < buf.length; i++) {
            String s = cutString(str,i+1);
            System.out.println(str+",截取"+(i+1)+"个结果是:"+s);

        }
    }

    public static String cutString(String str,int len) throws UnsupportedEncodingException {

        //1,将字符串编码成字节数组。
        byte[] buf = str.getBytes("GBK");
        int count = 0;
        //2,对数组进行遍历。从截取位开始遍历。往回遍历。
        for(int i = len - 1; i >=0 ; i--){
            //判断最后截取位上是否是负数
            if(buf[i]<0){
                count++;
            }else{
                break;
            }
        }
        //判断奇偶数。
        if(count%2==0){
            return new String(buf,0,len);
        }else{
            return new String(buf,0,len-1);//舍弃最后一个。
        }

    }

三 联通的编码

联通这两个字写入记事本时出现了乱码,以下是详细原理过程.

在把联通两个字写到记事本时,记事本按照了utf-8的解码方式.

详细见,这个连接里面讲解了utf-8的详细编码过程

public static void main(String[] args) {

        String str = "联通";
        /*
        11000001
        10101010
        11001101
        10101000
        联通的gbk编码二进制正好符合了utf-8的编码规律。所以记事本在解析这段二进制时，
        就启动了utf-8的码表来解析这个数据。出现乱码。

        */

        byte[] buf = str.getBytes();
        for(byte b : buf){
            System.out.println(Integer.toBinaryString(b&255));
        }

四 字符缓冲区和readline

4.1 read()方法

知道原理后,下面是自己实现reader方法里面的逻辑

private Reader r;

    // 定义一个字符数组,作为缓冲区。
    private char[] buf = new char[1024];
    // 定义了一个索引，用于操作数组中的元素。
    private int index = 0;
    // 定义了一个变量，用于记录读取字符的个数。
    private int count = 0;

    // 需要一初始化就具备一个流对象。
    public MyBufferedReader(Reader r) {// 可以对Reader的所有子类进行高效读取。
        this.r = r;
    }

    /**
     * 提供一个可以从缓冲区中读取一个字符的方法。
     * 高效方法。
     * @throws IOException
     *
     */
    public int read() throws IOException {

        /*
         * 1，需要先通过流对象从底层设备上获取一定数据的数据到缓冲区数组中。 使用流对象read(char[]);
         */
        //如果count记录字符个数的变量为0，说明缓冲区已经没有字符数据。
        if(count==0){
            //需要从设备上获取一定数量的数据存储到缓冲区中，并用count记录存储字符的个数。
            count = r.read(buf);
            //每取一次新的数据，就需要将角标归0.
            index = 0;
        }
        //如果count小于0，说明到-1，没有数据了，程序直接返回-1.
        if(count<0){
            return -1;
        }
        //从缓冲区中取出一个字符。
        char ch = buf[index];
        //角标自增。
        index ++;
        //计数器要自减。
        count --;

        return ch;
    }

4.2 readline()方法

/**
     *  基于高效的read方法，建立一个一次可以读取一行的数据的方法。
     *  将行终止符前的数据转成字符串返回。
     * @return
     * @throws IOException
     */
    public String readLine() throws IOException{

        /*
         * 思路；
         *
         * 从缓冲区中一次获取一个字符，并将这个字符存储到临时容器中。
         * 每获取一个字符都要进行判断，只要不是行终止符都进行存储。
         * 一旦读取到行终止符，就将临时容器中的数据转成字符串返回。
         *
         */
        //1,定义一个临时容器。
        StringBuilder sb = new StringBuilder();

        //2,调用本类中的read方法，从缓冲区中读取一个字符，存储到临时容器中。
        //存的时候要注意：必须判断，如果是行终止符就不要存储了。就将临时容器中的
        //字符转成字符串返回。

        int ch = ;
        while((ch=this.read())!=-){
            if(ch=='\r'){
                continue;
            }

            if(ch=='\n'){
                return sb.toString();
            }

            sb.append((char)ch);//将读取到的字符数字转成char类型，存储到sb中。

        }

        //万一文本中最后以后没有行终止符，判断一下sb中是否有内容，如果有则返回。
        if(sb.length()!=){
            return sb.toString();
        }

        return null;

    }

五 装饰设计模式

5.1 由来

TextReader:读取文本。
MediaReader:读取媒体数据

抽取共性，形成体系。
Reader
|--TextReader read();
|--MediaReader

需求1；
提高读取文本的效率，使用缓冲技术，提供一个读取文本更高效的读取方法。
覆盖TextReader中的方法。建立高效的read方法。所以建立一个TextReader的子类，用以高效的读取。
Reader
|--TextReader
|--BufferedTextReader
|--MediaReader

需求2：读取媒体数据也想高效，那就同理，也给读取媒体数据的对象派生一个高效子类
Reader
|--TextReader
|--BufferedTextReader
|--MediaReader
|--BufferedMediaReader

发现了一个小问题，如果Reader中还有读取其他数据的子类，如果要高效，那岂不是还要给这个子类添加一个高效子类？
是的。为了给具体的读取数据的对象增加一些功能，是需要通过子类来完成的。
但是这样做，会导致这个继承体系很臃肿！仅仅为了增加一些功能，而进行继承，不建议的。

这些子类无非就是需要高效，而且这些高效的功能实现是一致的。就是提供了一个缓冲区而已。
没有必要每一个对象都存在一个功能重复的子类。

干脆，单独定义一个具备这个缓冲功能的对象,哪个子类需要被缓冲，就将哪个子类传递进来。

class BufferedReader extends Reader{

private [];提供数组。
BufferedReader(Reader r){// 对Reader高效就哦了 。

}
read(){操作的是数组}//高效的读取动作。
}

Reader
|--TextReader
|--MediaReader
|--BufferedReader

发现这种设计方式减少了继承体系的臃肿，增减了功能，比继承更为灵活。
这种设计方式单独定义一个名称：装饰设计模式。
解决问题：给一组类增加功能， 避免继承的臃肿，提高灵活。
注意：装饰类和被装饰类必须所属于同一个体系，通常装饰类都会提供构造函数接收被装饰类对象。
装饰类通常不单独存在。

5.2 形象的例子

房子 居住();
|--毛坯楼房 居住(){简陋}
|--毛坯平房
|--田园风光房。
|--欧式风格房！

class 田园风光房 extends 房子{
田园风光房(房子 ){

}
居住(){
田园风光的居住，惬意！
}

}

class 欧式风格房 extends 房子{
欧式风格房(房子 ){

}
居住(){
欧式风格的居住，高端大气上档次！
}

}

毛坯楼房 x = new 毛坯楼房();
x.居住();普通

//欧式风格房 y = new 欧式风格房(x);

田园风光房 y = new 田园风光房(x);
y.居住();普通惬意

欧式风格房 z = new 欧式风格房(y);
z.居住();普通，惬意，高端大气上档次！

六 键盘录入

回顾

字节流：
FileInputStream FileOutputStream
BufferedInputStream BufferedOutputStream

字符流：
FileReader FileWriter
InputStreamReader OutputStreamWriter
BufferedReader BufferedWriter

所学习的对象都是用于操作文件中数据的对象，可以进行字符编码转换的，有可以提供效率的。

6.1 键盘的录入

读入单个

/*
         * 思路：
         * 1，将数据存储到的文件，没有问题的。
         * 2，怎么获取数据来源呢？键盘录入怎么弄呢？
         * 键盘录入是输入，系统中应该具备的一部分。
         * 在System类找到了标准输入流 属性 in。
         * System.in 对应的类型是InputStream。字节输入流。
         */
        //获取了键盘录入的输入流对象。可以不用关闭。
        InputStream in = System.in;

//        System.out.println((int)'\r');//13
//        System.out.println((int)'\n');//10

//        int ch = in.read();
//        System.out.println(ch);
//        int ch1 = in.read();
//        System.out.println(ch1);
//        int ch2 = in.read();
//        System.out.println(ch2);
//        int ch3 = in.read();
//        System.out.println(ch3);

读取数据更多

public static void main(String[] args) throws IOException {
        //读取的数据更多。
        /*
         * 读取一个字节先不要操作，将其存储起来，转成一个字符串。
         *
         * 能不能一次就读取一行字符串呢？readLine();
         * 可是readLine()是BufferedReader方法。
         * BufferedReader使用时必须接收字符流对象。
         * 键盘录入是字节流。要是将字节流转成字符流是不是就哦了呢？咋转呢？
         * 字节流---桥梁InputStreamReader--->字符流
         *
         */
        // //读取键盘录入的字节输入流。
        // InputStream in = System.in;
        // //通过桥梁，将字节输入流转成字符输入流。
        // InputStreamReader isr = new InputStreamReader(in);
        // //对字符流进行效率提高，而且使用缓冲区对象的特有方法readLine();
        // BufferedReader bufr = new BufferedReader(isr);

        //记住：以后但凡提到了键盘录入就写这句，一行一行的读取，除非要对读取每一个字节操作。
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

        String line = null;
        while((line=bufr.readLine())!=null){//键盘录入记住定义结束标记。强制结束。

            if("over".equals(line)){
                break;
            }
            System.out.println(line);

        }

    }

6.2 键盘录入到文件

public static void main(String[] args) throws IOException {
        // 需求：将键盘录入的数据存储到文件中。
        /*
         * 1，键盘录入。
         * 2，目的是文件。
         * 3，这个示例中既要用到输入流，也要用到输出流。
         * 而且操作的数据都是文本数据，可以使用字符流。
         * 而且目的是文件可以使用操作文件的字符输出流。
         */

        //键盘录入。
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        //目的是文件。
//        FileWriter fw = new FileWriter("tempfile\\key.txt");
//        BufferedWriter bufw = new BufferedWriter(fw);
        BufferedWriter bufw = new BufferedWriter(new FileWriter("tempfile\\key.txt"));

        String line = null;
        while((line=bufr.readLine())!=null){
            if("over".equals(line)){
                break;
            }
            bufw.write(line);
            bufw.newLine();
            bufw.flush();
        }

        bufw.close();
    }

七 io使用规律总结

把IO流进行了规律的总结(四个明确)：
明确一：要操作的数据是数据源还是数据目的。
　　源：InputStream Reader
　　目的：OutputStream Writer
　　先根据需求明确要读，还是要写。

明确二：要操作的设备上的数据是字节还是文本呢？
　　源：
　　字节：InputStream
　　文本：Reader
　　目的：
　　字节：OutputStream
　　文本：Writer
　　已经明确到了具体的体系上。

明确三：明确数据所在的具体设备。
　　源设备：
　　硬盘：文件 File开头。
　　内存：数组，字符串。
　　键盘：System.in;
　　网络：Socket
　　目的设备：
　　硬盘：文件 File开头。
　　内存：数组，字符串。
　　屏幕：System.out
　　网络：Socket
　　完全可以明确具体要使用哪个流对象。

明确四：是否需要额外功能呢？
　　额外功能：
　　转换吗？转换流。InputStreamReader OutputStreamWriter
　　高效吗？缓冲区对象。BufferedXXX
　　有多个源(字节流)吗？序列流。SequenceInputStream
　　对象需要序列化吗？ObjectInputStream，ObjectOutputStream
　　需要保证数据输出的表现形式吗？打印流。PrintStream PrintWriter
　　需要操作基本类型数据保证字节原样性吗？DataOutputStream DataInputStream

八 练习

8.0 将字符串写入到文件中

明确一：有源吗？有目的吗？
源；字符串。String，不用io指定定义String字符串就可以了。
目的：文件。使用IO技术，输出流 OutputStream Writer。

明确二：是文本数据吗？
是！
目的：Writer。

明确三：具体设备是？
目的设备：
硬盘：File开头的对象 Writer体系中的。
明确出来，具体要使用的对象是FileWriter。

FileWriter fw = new FileWriter("a.txt");
fw.write(string);

明确四：需要额外功能吗?
需要，高效。缓冲区对象。BufferedWriter。
BufferedWriter bufw = new BufferedWriter(new FileWriter("a.txt"));
bufw.write(string);
bufw.newLine();
bufw.flush();

代码:

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

        FileWriter fw = new FileWriter("tempfile\\file.txt");
        BufferedWriter bufw = new BufferedWriter(fw);
        fw.write("我的家");
        fw.flush();
    }
}

8.1 复制一个文本

比如将文档中的nba，替换成"美国职业篮球大联盟"写入到目的文件中。

明确一:有源，有目的/
源：InputStream Reader
目的：OutputStream Writer

强调一点：如果仅做复制动作，不需要考虑数据是字节还是文本。直接使用字节流就哦了。
FileInputStream fis = new FileInputStream("a.txt");
FileOutputStream fos = new FileOutputStream("b.txt");

但是如果在复制过程中，需要文本中的字符数据进行操作，必须使用字符流。
明确二：是纯文本数据吗？
是！
源：Reader
目的：Writer

明确三：具体设备：
源设备：
硬盘：File开头对象 FileReader
目的设备：
硬盘：File开头对象 FileWriter

FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");

明确四：需要额外功能吗？
需要，高效。
BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));
String line = bufr.readLine();
line = line.replace("nba","美国职业篮球大联盟");
bufw.write(line);
bufw.flush();
bufw.close();

8.2 键盘录入存储到文件

明确一：有源，有目的。
源：InputStream Reader
目的：OutputStream Writer

明确二：是纯文本数据吗？
是！
源：Reader
目的：Writer
明确三：具体设备：
源设备：键盘。System.in;
目的设备：硬盘。FileWriter
InputStream in = System.in;
FileWriter fw = new FileWriter("a.txt");

byte[] buf = new byte[1024];
int len = in.read(buf);
String str = new String(buf,0,len);
fw.write(str);
这样虽然可以做，但是很麻烦。

明确四：需要额外功能吗？
需要，转换。因为明确源的体系是Reader。可是具体设备System.in 这是字节流，需要字符流，需要转换功能，
将字节流转成字符流。字节-->字符 InputStreamReader
InputStreamReader isr = new InputStreamReader(System.in);
FileWriter fw = new FileWriter("a.txt");

还需要额外功能吗？需要，高效。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new FileWriter("a.txt"));

8.3 读取文本文件打印

明确一：有源，有目的。
源：InputStream Reader
目的：OutputStream Writer

明确二：是纯文本数据吗？
是！
源：Reader
目的：Writer
明确三：具体设备：
源设备：硬盘，FileReader
目的设备：屏幕，System.out

FileReader fr = new FileReader("a.txt");
PrintStream out = System.out;
out.println();

其实这样就已经完成需求的。
PrintStream对象中有N多的print方法。
fr.read();
System.out.println();
明确四：额外功能。
BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

8.4 读取文件数据,

读取文件数据,将数据按照UTF-8的方式存储到文件中去

明确一：有源，有目的。
源：InputStream Reader
目的：OutputStream Writer

明确二：是纯文本数据吗？
是！
源：Reader
目的：Writer
明确三：具体设备：
源设备：硬盘，FileReader
目的设备：硬盘，FileWriter

FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");

但是，不符合题中的要求，对于目的要求必须是UTF-8的编码。
所以必须使用额外功能。
明确四：需要额外功能，转换。
FileReader fr = new FileReader("a.txt");//默认编码。
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"),"utf-8");

还需要其他额外功能吗？需要。缓冲区。
BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("b.txt"),"utf-8"));