IO流--字符流（补充）

编码表：其实就是生活中文件和计算机二进制的对应关系表。
1，ascii： 一个字节中的7位就可以表示。对应的字节都是正数。0-xxxxxxx
2，iso8859-1:拉丁码表 latin，用了一个字节用的8位。1-xxxxxxx 负数。
3，GB2312:简体中文码表。6,7仟的中文和符号。用两个字节表示。两个字节都是开头为1 两个字节都是负数。
GBK:目前最常用的中文码表，2万的中文和符号。用两个字节表示，一部分文字，第一个字节开头是1，第二字节开头是0
GB18030：
4， unicode：国际标准码表:无论是什么文字，都用两个字节存储。Java中的char类型用的就是这个码表。char c = ‘a’;占两个字节。
在Java中，字符串是按照系统默认码表来解析的。简体中文版 字符串默认的码表是GBK。
5，UTF-8:基于unicode，一个字节就可以存储数据，不要用两个字节存储，而且这个码表更加的标准化，在每一个字节头加入了
编码信息(后期到api中查找)。

能识别中文的码表：GBK UTF-8 正因为识别中文码表不唯一，涉及到了编码解码问题。

对于我们开发而言；常见的编码 GBK UTF-8 ISO8859-1
文字—>二进制(数字) ：编码。
二进制(数字)—>文字 : 解码。

---

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

1，对字符串按照字节数截取

“abc你好” 有5个字符，有7个字节。
按照3个字节截取 abc ，按照四个字节截取 abc和你字的一半，如果出现中文一半舍弃。

public class CutStringTest {

    /**
     * @param args
     * @throws UnsupportedEncodingException 
     */
    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);//舍弃最后一个。
        }

    }

}

编码

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 class LianTongTest {

    /**
     * @param args
     */
    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));
        }

    }

}

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

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

需求；
提高读取文本的效率，使用缓冲技术，提供一个读取文本更高效的读取方法。
覆盖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

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

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

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

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

public class BufferedStreamDemo {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {

        /*
         * BufferedReader  ：readLine(); BufferedWriter
         */

        BufferedReader bufr = new BufferedReader(new FileReader("Test25.java"));

        String line = null;
        while((line=bufr.readLine())!=null){
            System.out.println(line);
        }

        bufr.close();
    }

}

/**
 * 自定义一个字符流缓冲区。 用于缓冲字符数据，从而提高操作效率。 
 * 并提供了更多操作缓冲区数据的方法。 需要使用具体的流对象来完成数据的获取。
 * 
 * 分析： 缓冲区应该具备什么? 1，必须要有数组。 2，需要对数组进行操作，对数组操作一定要有角标。
 * 
 * @author Teaching
 * 
 */
public class MyBufferedReader {

    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;
    }

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

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

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

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

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

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

        }

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


        return null;

    }


    // 关闭流资源。
    public void close() throws IOException {
        // 其实内部就是关闭具体的流。
        r.close();
    }

}

public class MyBufferedReaderDemo {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        //验证自定义的缓冲区。
        MyBufferedReader myBufr = new MyBufferedReader(new FileReader("tempfile\\1.txt"));

        String line = null;

        while((line=myBufr.readLine())!=null){
            System.out.println(line);
        }

        myBufr.close();
    }

}

键盘录入

需求：将键盘录入的数据存储到文件中。
System.in.read();//阻塞

public class KeyDataToFileTest {

    /**
     * @param args
     * @throws IOException 
     */
    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();
    }

}

public class ReadKeyDemo {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {


        /*
         * 思路：
         * 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 class ReadKeyDemo2 {

    /**
     * @param args
     * @throws IOException 
     */
    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);

        }



    }

}

public class Test5 {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
//      5，获取一篇文章中 "传智播客" 出现的次数。
        /*
         * 思路：
         * 1，读取这篇文章中的每一行。
         * 2，对每一个计算 关键字符串的次数。
         * 3，对每一行的进行累加。
         */

        File file = new File("Test25.java");
        String key = "设备";
        int count = getKeyCount(file,key);
        System.out.println(key+"::"+count);
    }

    public static int getKeyCount(File file, String key) throws IOException {

        int count = 0;

        BufferedReader bufr = null;
        try{
            bufr = new BufferedReader(new FileReader(file));
            String line = null;
            while((line=bufr.readLine())!=null){
                count += getKeyCountInLine(line,key);
            }
        }finally{
            if(bufr!=null){
                try{
                    bufr.close();
                }catch(IOException e){
                    throw new RuntimeException();
                }
            }
        }

        return count;
    }

    private static int getKeyCountInLine(String line, String key) {

        int count = 0;
        int index = 0;

        while((index=line.indexOf(key, index))!=-1){
            index = index + key.length();
            count++;
        }

        return count;
    }

}