A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© Anlai 中级黑马   /  2015-8-24 13:42  /  368 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

因为一个中文字符等于两个字节,如果使用字节流来操作的话,比较麻烦,所有就出现了字符流 .
       
        编码表:
                ASCII                                        '0' - 48 , 'a' - 97 , 'A' - 65
                GB2312
                GBK
                ISO8859-1
                UNICODE(USC-2 , USC-4)
                UTF-8

        字符串中的编解码问题:
                编码:        把看的懂的转换成看不懂的                String --- byte[]
                解码:        把看不懂的转换成看的懂的                byte[] --- String

                编码的方法:
                        public byte[] getBytes() ;                                                        // 按照默认的编码表: GBK
                        public byte[] getBytes(String charsetName) ;                // 按照指定的编码表
                解码的方法:
                        public String(byte[] bytes) ;                                                // 按照默认的编码表: GBK
                        public String(byte[] bytes , String charsetName);        // 按照指定的编码表


        字符流:  
                转换流:可以指定编码表
                转换输入流:        InputStreamReader
                        构造方法:
                                public InputStreamReader(InputStream in) ;                // 按照默认的编码表: GBK
                                public InputStreamReader(InputStream in , String charsetName) ;                // 按照指定的编码表
                转换输出流:        OutputStreamWriter
                        构造方法:
                                public OutputStreamWriter(OutputStream out) ;                // 按照默认的编码表: GBK
                                public OutputStreamWriter(OutputStream out , String charsetName) ;                // 按照指定的编码表
               
                字符流写数据的方法: 字符流在写数据的时候需要刷新(flush), close之前自动进行刷新

                        // 创建对象
                        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt")) ;

                        // public void write(int ch) : 一次写一个字符
                        // public void write(char[] ch) : 一次写一个字符数组
                        // public void write(char[] ch , int offset , int length) : 一次写一个字符数组中的一部分
                        // public void write(String str) : 一次写一个字符串
                        // public void write(String str , int offset , int length) : 一次写一个字符串中的一部分
                        osw.write("我爱您") ;
                        osw.close() ;

                 字符流读取的方法:
                       
                        // 创建对象
                        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt")) ;
               
                        // 一次读取一个字符
                        // int ch = 0 ;
                        // while((ch = isr.read()) != -1){
                        //                System.out.print((char)ch);
                        // }

                        // 一次读取一个字符数组
                        char[] chs = new char[1024] ;
                        int len = 0 ;
                        while((len = isr.read(chs)) != -1){
                                System.out.print(new String(chs , 0 , len));
                        }
                       
                        isr.close() ;


        复制文件:
                        a: 创建字符输入流和字符输出流对象
                        b: 频繁的读写操作
                        c: 释放资源
                               
                        // 一次读取一个字符复制文件
                        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt")) ;
                        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt")) ;
                       
                        int ch = 0 ;
                        while((ch = isr.read()) != -1){
                                osw.write(ch) ;
                        }
                       
                        osw.close() ;
                        isr.close() ;

                        // 一次读取一个字符数组复制文件
                        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt")) ;
                        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt")) ;

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

                        osw.close() ;
                        isr.close() ;

便捷类:
                由于转换流的名称太长,并且在一般的情况下我们也不需要使用编码表,于是java就给我们提供了转换流对应的便捷类

                转换流                                                                便捷类
                转换输入流: InputStreamReader                        输入流:                FileReader
                转换输出流:        OutputStreamWriter                        输出流:                FileWriter

                使用便捷类复制文件:

                        // 一次读取一个字符复制文件
                        FileReader fr = new FileReader("a.txt") ;
                        FileWriter fw = new FileWriter("b.txt") ;
                       
                        int ch = 0 ;
                        while((ch = fr.read()) != -1 ){
                                fw.write(ch) ;
                        }
                       
                        fw.close() ;
                        fr.close() ;

                        // 一次读取一个字符数组复制文件
                        FileReader fr = new FileReader("a.txt") ;
                        FileWriter fw = new FileWriter("b.txt") ;
                       
                        char[] chs = new char[1024] ;
                        int len = 0 ;
                        while((len = fr.read(chs)) != -1){
                                fw.write(chs, 0, len) ;
                        }

                        fw.close() ;
                        fr.close() ;

高效的字符输入流和高效的字符输出流:
        高效的字符输入流: BufferedReader
                特有的功能:
                                public String readLine() ;                        // 一次读取一个文本行
        高效的字符输出流: BufferedWriter       
                                public void newLine() ;                                // 写入一个换行符

                复制文件:
                        BufferedReader br = new BufferedReader(new FileReader("a.txt")) ;
                        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt")) ;
                       
                        String line = null ;
                        while((line = br.readLine()) != null){
                                bw.write(line) ;
                                bw.newLine() ;
                                bw.flush() ;
                        }

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

                使用Reader自定义类,模拟BufferedReader的readLine()功能并测试

                public class MyBufferedReader {
               
                        private Reader r ;
                        public MyBufferedReader(Reader r) {
                                this.r = r ;
                        }
                       
                        public String readLine() {
                       
                                StringBuilder sb = new StringBuilder() ;
                                int ch = 0 ;

                                while((ch = r.read()) != -1){

                                        if(ch == '\r'){
                                                continue ;
                                        }

                                        if(ch == '\n'){
                                                return sb.toString() ;
                                        }else {
                                                sb.append((char)ch) ;
                                        }
                                }
                       
                                // 防止数据的丢失
                                if(sb.length() > 0) {
                                        return sb.toString() ;
                                }

                                return null ;
                        }

                        public void close() {
                                r.close() ;
                        }
               
                }

数据输入和输出流(了解)
        DataInputStream
        DataOutputStream

        可以完成基本数据类型的读和写
               
                DataOutputStream dos = new DataOutputStream(new FileOutputStream("a.txt")) ;
               
                dos.writeByte(27) ;
                dos.writeBoolean(true) ;
                dos.writeUTF("中国") ;
               
                dos.close() ;
               
                System.out.println("------------------------------------------") ;

                DataInputStream dis = new DataInputStream(new FileInputStream("a.txt")) ;
                byte b = dis.readByte() ;
                boolean r = dis.readBoolean() ;
                String str = dis.readUTF() ;
               
                System.out.println(b);
                System.out.println(r);
                System.out.println(str);
               
                dis.close() ;

0 个回复

您需要登录后才可以回帖 登录 | 加入黑马