精华内容
下载资源
问答
  • 转换流

    千次阅读 2018-07-02 00:29:36
    转换流1.1 字符编码和字符集字符编码计算机中储存的信息都是用二进制数表示的,而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则,将字符存储到计算机中,称为编码 。...

    转换流

    1.1 字符编码和字符集

    字符编码

    计算机中储存的信息都是用二进制数表示的,而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则,将字符存储到计算机中,称为编码 。反之,将存储在计算机中的二进制数按照某种规则解析显示出来,称为解码 。比如说,按照A规则存储,同样按照A规则解析,那么就能显示正确的文本f符号。反之,按照A规则存储,再按照B规则解析,就会导致乱码现象。

    • 字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

    字符集

    • 字符集 Charset:是一个系统支持的所有字符的集合,包括各国家文字、标点符号、图形符号、数字等。

    计算机要准确的存储和识别各种字符集符号,需要进行字符编码,一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。

    可见,当指定了编码,它所对应的字符集自然就指定了,所以编码才是我们最终要关心的。

    • ASCII字符集

      • ASCII(American Standard Code for Information Interchange,美国信息交换标准代码)是基于拉丁字母的一套电脑编码系统,用于显示现代英语,主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)。

      • 基本的ASCII字符集,使用7位(bits)表示一个字符,共128字符。ASCII的扩展字符集使用8位(bits)表示一个字符,共256字符,方便支持欧洲常用字符。

       ASCII码表1个字节表示一个字符: 0xxx xxxx(正数)  规定二进制的最高位是0,其他的7位表示某个字符的编码值。

      生活中的字符 十进制 二进制

    A 65 01000001

    B 66 01000010

    ……………..

    补充:(了解)

    在美式英语中使用的特殊控制字符。其中:

    0~31及127(共33个)是控制字符或通信专用字符(其余为可显示字符),如控制符:LF(换行)、CR(回车)、FF(换页)、DEL(删除)、BS(退格)、BEL(响铃)等;通信专用字符:SOH(文头)、EOT(文尾)、ACK(确认)等;ASCII值为8、9、10 和13 分别转换为退格、制表、换行和回车字符。它们并没有特定的图形显示,但会依不同的应用程序,而对文本显示有不同的影响。

    32表示空格。

    • ISO-8859-1字符集

      • 拉丁码表,别名Latin-1,用于显示欧洲使用的语言,包括荷兰、丹麦、德语、意大利语、西班牙语等。

      • ISO-5559-1使用单字节编码,兼容ASCII编码。

      • ISO-8859-1编码表1个字节表示一个字符:所有的8位都表示数据,xxxx xxxx 全部用来表示字符数据

        补充:

        1、Latin1是ISO-8859-1的别名,有些环境下写作Latin-1。

        2、ISO:International Standards Organization,国际标准化组织。

        3、这张码表中没有未知字符。其他编码表中都有未知字符,未知字符指的是有些二进制对应的字符在编码表中是空的,是没有的,没有就用我们看到的 ? 表示。

    • GBxxx字符集

      • GB就是国标的意思,是为了显示中文而设计的一套字符集。

      • GB2312:简体中文码表。叫做信息交换用汉字编码字符集。它识别六七千的文字,兼容ASCII编码表。2个字节表示一个汉字字符。

      • GBK:叫做汉字编码字符集,也可以叫做国标。是GB2312的升级版,识别2万多个中文字符。2个字节表示一个汉字字符。目前主流的编码表。

      • GB18030:是GBK的升级版,包含了大部分的中文(简体、繁体、甲骨文、象形文等等),还有少数民族的文字,识别更多。2个字节表示一个汉字字符。

    • Unicode字符集

      因为世界上各个国家都开发了属于自己的编码表,造成编码表不统一,世界计算机协会就为编码统一,制定了一张国际通用的编码表:unicode码表

      • Unicode编码系统为表达任意语言的任意字符而设计,是业界的一种标准,也称为统一码、标准万国码。

      • 它最多使用4个字节的数字来表达每个字母、符号,或者文字。有三种编码方案,UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。

      • UTF-8编码,可以用来表示Unicode标准中任何字符,它是电子邮件、网页及其他存储或传送文字的应用中,优先采用的编码。互联网工程工作小组(IETF)要求所有互联网协议都必须支持UTF-8编码。所以,我们开发Web应用,也要使用UTF-8编码。它使用一至四个字节为每个字符编码,编码规则:

        1. 128个US-ASCII字符,只需一个字节编码。

        2. 拉丁文等字符,需要二个字节编码。

        3. 大部分常用字(含中文),使用三个字节编码。

        4. 其他极少使用的Unicode辅助字符,使用四字节编码。

        可以识别汉字的编码表有哪些:

        ​ GB2312、GBK、GB18030、unicode、UTF-8

          在开发中常用的码表:ISO-8859-1、GBK、UTF-8。

    文字--->(数字) :编码: 就是把能看懂内容,转换成看不懂的内容。
    A      65
    (数字)--->文字  : 解码: 就是把看不懂的内容,转换成看懂的内容。
    65    A

    1.2 编码引出的问题

    在IDEA中,使用FileReader 读取项目中的文本文件。由于IDEA的设置,都是默认的UTF-8编码,所以没有任何问题。但是,当读取Windows系统中创建的文本文件时,由于Windows系统的默认是GBK编码,就会出现乱码。

    public class ReaderDemo {
        public static void main(String[] args) throws IOException {
            FileReader fileReader = new FileReader("E:\\File_GBK.txt");
            int read;
            while ((read = fileReader.read()) != -1) {
                System.out.print((char)read);
            }
            fileReader.close();
        }
    }
    输出结果:
    ���

    那么如何读取GBK编码的文件呢?

    1.3 InputStreamReader类

    转换流java.io.InputStreamReader,是Reader的子类,是从字节流到字符流的桥梁。它读取字节,并使用指定的字符集将其解码为字符。它的字符集可以由名称指定,也可以接受平台的默认字符集。

    构造方法

    • InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。

    • InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。

    构造举例,代码如下:

    InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
    InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

    指定编码读取

    public class ReaderDemo2 {
        public static void main(String[] args) throws IOException {
            // 定义文件路径,文件为gbk编码
            String FileName = "E:\\file_gbk.txt";
            // 创建流对象,默认UTF8编码
            InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
            // 创建流对象,指定GBK编码
            InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
            // 定义变量,保存字符
            int read;
            // 使用默认编码字符流读取,乱码
            while ((read = isr.read()) != -1) {
                System.out.print((char)read); // ��Һ�
            }
            isr.close();
          
            // 使用指定编码字符流读取,正常解析
            while ((read = isr2.read()) != -1) {
                System.out.print((char)read);// 大家好
            }
            isr2.close();
        }
    }

    1.4 OutputStreamWriter类

    转换流java.io.OutputStreamWriter ,是Writer的子类,是从字符流到字节流的桥梁。使用指定的字符集讲字符编码为字节。它的字符集可以由名称指定,也可以接受平台的默认字符集。

    构造方法

    • OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。

    • OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。

    构造举例,代码如下:

    OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
    OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

    指定编码写出

    public class OutputDemo {
        public static void main(String[] args) throws IOException {
            // 定义文件路径
            String FileName = "E:\\out.txt";
            // 创建流对象,默认UTF8编码
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
            // 写出数据
            osw.write("你好"); // 保存为6个字节
            osw.close();
            
            // 定义文件路径
            String FileName2 = "E:\\out2.txt";
            // 创建流对象,指定GBK编码
            OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
            // 写出数据
            osw2.write("你好");// 保存为4个字节
            osw2.close();
        }
    }

    转换流理解图解

    转换流是字节与字符间的桥梁!

    1.5 练习:转换文件编码

    将GBK编码的文本文件,转换为UTF-8编码的文本文件。

    案例分析

    1. 指定GBK编码的转换流,读取文本文件。

    2. 使用UTF-8编码的转换流,写出文本文件。

    案例实现

    public class TransDemo {
       public static void main(String[] args) {      
            // 1.定义文件路径
            String srcFile = "file_gbk.txt";
            String destFile = "file_utf8.txt";
            // 2.创建流对象
            // 2.1 转换输入流,指定GBK编码
            InputStreamReader isr = new InputStreamReader(new FileInputStream(srcFile) , "GBK");
            // 2.2 转换输出流,默认utf8编码
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destFile));
            // 3.读写数据
            // 3.1 定义数组
            char[] cbuf = new char[1024];
            // 3.2 定义长度
            int len;
            // 3.3 循环读取
            while ((len = isr.read(cbuf))!=-1) {
                // 循环写出
                osw.write(cbuf,0,len);
            }
            // 4.释放资源
            osw.close();
            isr.close();
        }
    }

    展开全文
  • Java学习日志(二十一)缓冲流原理字节缓冲输出流:BufferedOutputStream字节缓冲输入流:BufferedInputStream字符缓冲输出流:BufferedWriter字符缓冲输入流:BufferedReader文件复制文件排序转换流原理字符转换...
  • Java 转换流

    万次阅读 多人点赞 2019-04-18 09:50:03
    Java IO流中提供了两种用于将字节流转换为字符流的转换流。其中InputStreamReader用于将字节输入流转换为字符输入流,其中OutputStreamWriter用于将字节输出流转换为字符输出流。使用转换流可以在一定程度上避免乱码...

    Java IO流中提供了两种用于将字节流转换为字符流的转换流。其中InputStreamReader用于将字节输入流转换为字符输入流,其中OutputStreamWriter用于将字节输出流转换为字符输出流。使用转换流可以在一定程度上避免乱码,还可以指定输入输出所使用的字符集
    1、OutputStreamWriter,将字节输出流转换为字符输出流。创建使用指定字符集的 OutputStreamWriter,如果不指定字符集就使用默认字符集创建OutputStreamWriter。转换之后可以不用关闭OutputStream,示例如下
    在这里插入图片描述
    OutputStreamWriter含有方法如下:
    1、flsh():刷新该流的缓冲
    2、close():关闭此流,关闭前需要刷新
    3、getEncoding():获取此流使用的字符编码的名称。
    4、write():write(char[] ,int offset ,int length),写入字符数组的某一部分
    write(String ,int offset ,int length),写入字符串的某一部分
    write(String ),写入单个字符

    2、InputStreamReader,将字节输入流转换为字符输入流。创建使用指定字符集的 InputStreamReader,如果不指定字符集就使用默认字符集创建InputStreamReader。转换之后可以不用关闭InputStream,示例如下
    在这里插入图片描述
    InputStreamReader含有方法如下:
    1、close():关闭此流
    2、getEncoding():获取此流使用的字符编码的名称
    3、ready():判断此流是否已经准备好用于读取
    4、read():read(),读取单个字符。
    read(char[],int offset ,int length),将字符读入数组的某一部分

    展开全文
  • Java I/O(字节流、字符流与转换流)

    千次阅读 2019-04-26 12:06:18
    **File类不支持文件内容处理,如果要处理文件内容,必须要通过的操作模式来完成。分为输入和输出。 在java.io包中,分为两种:字节与字符: 字节:InputStream、OutputStream 字符:Reader、...

    **File类不支持文件内容处理,如果要处理文件内容,必须要通过流的操作模式来完成。流分为输入流和输出流。
    在java.io包中,流分为两种:字节流与字符流:

    • 字节流:InputStream、OutputStream
    • 字符流:Reader、Writer**
      在这里插入图片描述
      在这里插入图片描述

    字节流与字符流操作的本质区别只有一个:字节流是原生的操作,而字符流是经过处理后的操作。
    在进行网络数据传输、磁盘数据保存所保存所支持的数据类型只有:字节。

    而所有磁盘中的数据必须先读取到内存后才能进行操作,而内存中会帮助我们把字节变为字符。字符更加适合处理中文。

    不管使用的是字节流还是字符流,其基本的操作流程几乎是一样的,以文件操作为例。
    根据文件路径创建File类对象 ;

    • 根据字节流或字符流的子类实例化父类对象 ;

    • 进行数据的读取或写入操作

    • 关闭流(close())

    对于IO操作属于资源处理,所有的资源处理操作(IO操作、数据库操作、网络)最后必须要进行关闭。

    字节输出流(OutputStream)
    OutputStream类的定义结构

    public abstract class OutputStream implements Closeable, Flushable
    

    OutputStream类实现Closeable, Flushable这两个接口,这两个接口中的方法:

    Closeable: public void close() throws IOException;
    Flushable: public void flush() throws IOException;
    

    OutputStream类中定义的其他方法:

    • 将给定的字节数组内容全部输出:public void write(byte b[]) throws IOException

    • 将部分字节数组内容输出:public void write(byte b[], int off, int len) throws IOException

    • 输出单个字节:public abstract void write(int b) throws IOException

    由于OutputStream是一个抽象类,所以要想为父类实例化,就必须要使用子类。由于方法名称都由父类声明好了,所以我们在此处只需要关系子类的构造方法。如果要进行文件的操作,可以使用FileOutputStream类来处理,这个类的构造方法如下:
    接收File类(覆盖):public FileOutputStream(File file) throws FileNotFoundException
    接收File类(追加):public FileOutputStream(File file, boolean append)

    实现文件的内容输出:

    package com.bittech;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.OutputStream;
    public class Test {
        public static void main(String[] args) throws Exception{
            File file = new File("E:"+File.separator+"1"+File.separator+"test");
            if (!file.getParentFile().exists()) { // 必须保证父目录存在
                file.getParentFile().mkdirs() ; // 创建多级父目录
            }
    // OutputStream是一个抽象类,所以需要通过子类进行实例化,此时只能操作File类
            OutputStream output = new FileOutputStream(file) ;
    // 要求输出到文件的内容
            String msg = "我们都是一家人!" ;
    // 将内容变为字节数组
            output.write(msg.getBytes());
    // 关闭输出
            output.close();
        }
    }
    

    在进行文件输出的时候,所有的文件会自动帮助用户创建,不在需要调用createFile()方法手工创建。
    这个时候程序如果重复执行,并不会出现内容追加的情况而是一直在覆盖。如果需要文件内容追加,则需要调用FileOutputStream提供的另外一种构造方法。

    文件内容的追加:

    package www.bittech;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.OutputStream;
    
    public class Test {
        public static void main(String[] args) throws Exception{
            File files=new File("E:"+File.separator+"1"+File.separator+"test.txt");
            if(!files.getParentFile().exists()){// 必须保证父目录存在
                files.getParentFile().mkdirs();//创建多级父目录
            }
            //OutputStream是一个抽象类,所以需要通过子类进行实例化,此时只能操作File类
            OutputStream out=new FileOutputStream(files,true);
             要求输出到文件的内容
            String msg="快快乐乐的一家人!\n";
            //将内容变为字节数组
            out.write(msg.getBytes());
             关闭输出
            out.close();
        }
    }
    

    1.输出流如果文件不存在,自动创建
    2.FileOutputStream中 append默认是false会覆盖内容,若为true,则字节写入文件的末尾而不是开头。

    AutoCloseable自动关闭支持
    从JDk1.7开始追加了一个AutoCloseable接口,这个接口的主要目的是自动进行关闭处理,但是这种处理一般不好用,因为使用它必须结合try…catch。

    AutoCloseable接口使用:

    package www.bittech;
    
    class Message implements AutoCloseable{
        public Message(){
            System.out.println("创建一条新消息!");
        }
        public void close() throws Exception{
            System.out.println("[AutoCloseable自动关闭方法!]");
        }
        public void print(){
            System.out.println("www.bittech");
        }
    }
    public class Test {
        public static void main(String[] args) {
            try (Message msg=new Message()){//必须在try中定义对象
                msg.print();
            }catch (Exception e){
    
            }
        }
    }
    

    推荐使用close手工关闭!

    字节输入流:InputStream
    利用了OutputStream实现了程序输出内容到文件的处理,下面使用InputStream类在程序中读取文件内容。
    InputStream类的定义如下:

    public abstract class InputStream implements Closeable
    

    InputStream类只实现了Closeable接口,在InputStream类中提供有如下方法:

    • 读取数据到字节数组中,返回数据的读取个数。如果此时开辟的字节数组大小大于读取的数据大小,则返回的就是读取个数;如果要读取的数据大于数组的内容,那么这个时候返回的就是数组长度;如果没有数据了还在读,则返回-1: public int read(byte b[]) throws IOException.最常用方法
    • 读取部分数据到字节数组中,每次只读取传递数组的部分内容,如果读取满了则返回长度(len),如果没有读取满则返回读取的数据个数,如果读取到最后没有数据了返回-1:public int read(byte b[], int off,int len) throws IOException
    • 读取单个字节,每次读取一个字节的内容,直到没有数据了返回-1:public abstract int read() throws IOException;同OutputStream的使用一样,InputStream是一个抽象类,如果要对其实例化,同样也需要使用子类。如果要对文件进行处理,则使用FileInputStream类。

    实现文件信息的读取:

    package www.bittech;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.OutputStream;
    
    public class Test {
        public static void main(String[] args) throws Exception{
            File file=new File("E:"+File.separator+"1"+File.separator+"test");
            if(file.exists()) {
                InputStream input = new FileInputStream(file);
                byte[] date = new byte[1024];//每次可以读取的最大数量
                int len = input.read(date);//此时数据读取到数组中
                String result=new String(date,0,len);//将字节数组转换为String
                System.out.println(result);
                input.close();
            }
        }
    }
    

    字符输出流:Writer
    字符适合于处理中文数据,Writer是字符输出流的处理类,这个类的定义如下:

    public abstract class Writer implements Appendable, Closeable, Flushable
    

    与OutputStream相比多了一个Appendable接口。
    在Writer类里面也提供write()方法,而且该方法接收的类型都是char型,要注意的是,Writer类提供了一个直接输出字符串的方法:

    public void write(String str) throws IOException
    

    通过Writer实现输出:

    package www.bittech;
    
    import java.io.File;
    import java.io.Writer;
    import java.io.FileWriter;
    
    
    public class Test {
        public static void main(String[] args) throws Exception{
            File file=new File("E:"+File.separator+"1"+File.separator+"test.txt");
            if(!file.getParentFile().exists()){//必须保证父目录存在
                file.getParentFile().mkdirs();//创建多级父目录
            }
            Writer out=new FileWriter(file,true);
            out.write("今天天气真好!");
            out.close();
        }
    }
    

    字符输入流:Reader
    Reader依然也是一个抽象类。如果要进行文件读取,同样的,使用FileReader。
    在上面讲到的Writer类中提供有方法直接向目标源写入字符串,而在Reader类中没有方法可以直接读取字符串类型,这个时候只能通过字符数组进行读取操作。

    通过文件读取数据:

    package www.bittech;
    
    import java.io.File;
    import java.io.Reader;
    import java.io.FileReader;
    
    
    public class Test {
        public static void main(String[] args) throws Exception{
             1.定义文件路径
            File file=new File("E:"+File.separator+"1"+File.separator+"test.txt");
             2.必须保证文件存在才能进行处理
            if(file.exists()){
                Reader in=new FileReader(file);
                char[] date=new char[1024];//每次可读取的最大数量
                int len=in.read(date);// 将数据读取到字符数组中
                String result=new String(date,0,len);
                System.out.println(result);
                in.close();
            }
        }
    }
    

    字符流适合处理中文,字节流适合处理一切数据类型(对中文支持不好)。

    字节流vs字符流
    使用字节流和字符流从代码形式上区别不大。但是如果从实际开发来讲,字节流一定是优先考虑的,只有在处理中文时才会考虑字符流。因为所有的字符都需要通过内存缓冲来进行处理。所有字符流的操作,无论是写入还是输出,数据都先保存在缓存中。如果字符流不关闭,数据就有可能保存在缓存中并没有输出到目标源。这种情况下就必须强制刷新才能够得到完整数据。

    字符流刷新操作:

    package www.bittech;
    
    import java.io.File;
    import java.io.Writer;
    import java.io.FileWriter;
    
    
    public class Test {
        public static void main(String[] args) throws Exception{
            File file=new File("E:"+File.separator+"1"+File.separator+"test.txt");
            if(!file.getParentFile().exists()){//必须保证父目录存在
                file.getParentFile().mkdirs();//创建多级父目录
            }
            Writer out=new FileWriter(file,true);
            out.write("今天天气真好!");
            out.flush();//写上此语句表示强制清空缓冲内容,所有内容都输出
        }
    }
    

    在以后进行IO处理的时候,如果处理的是图片、音乐、文字都可以使用字节流,而只有处理中文的时候才会使用字符流。

    转换流
    字节流和字符流是可以进行相互转换的。
    OutputStreamWriter:将字节输出流变为字符输出流(Writer对于文字的输出要比OutputStream方便)
    InputStreamReader:将字节输入流变为字符输入流(InputStream读取的是字节,不方便中文的处理)

    它们的继承关系以及构造方法:

    public class OutputStreamWriter extends Writer
    public OutputStreamWriter(OutputStream out)
    
    
    public class InputStreamReader extends Reader
    public InputStreamReader(InputStream in)
    

    实现字节流与字符流的转换:

    package www.bittech;
    
    import java.io.*;
    
    
    public class Test {
        public static void main(String[] args) throws Exception{
            File file=new File("E:"+File.separator+"1"+File.separator+"test.txt");
            if(!file.getParentFile().exists()){//必须保证父目录存在
                file.getParentFile().mkdirs();//创建多级父目录`在这里插入代码片`
            }
            OutputStream output= new FileOutputStream(file);
            Writer out=new OutputStreamWriter(output);//字节流转为字符流
            out.write("今天是你生日吗?");
            out.close();
        }
    }
    

    FileOutputStream、FileInputStream、FileWriter、FileReader之间的继承关系:
    在这里插入图片描述

    展开全文
  • java之文件流与转换流

    千次阅读 2020-04-23 13:41:38
    输入 输出 文件字节 FileInputStream FileOutputStream 文件字符 FileReader FileWriter 文件字节 FileInputStream:文件字节输入 定义 :public class FileInputStream...
     输入流输出流
    文件字节流FileInputStreamFileOutputStream
    文件字符流FileReaderFileWriter

     

     

     

    文件字节流

    FileInputStream:文件字节输入流

    • 定义  :public class FileInputStream extends InputStream
    • 构造方法:public FileInputStream(String name) throws FileNotFoundException
    •                  public FileInputStream(File file) throws FileNotFoundException

    FileIOutputStream:文件字节输出流

    • 定义:public class FileOutputStream extends OutputStream
    • 构造方法:public FileOutputStream(String name) throws FileNotFoundExceptio
    •                  public FileOutputStream(String name, boolean append)throws FileNotFoundException //标记是否追加,默认fase覆盖
    •                  public FileOutputStream(File file) throws FileNotFoundException
    •                  public FileOutputStream(File file, boolean append)throws FileNotFoundException  //标记是否追加,默认fase覆盖

    文件字符流 

    FileReader:文件字符输入流

    • 定义:public class FileReader extends InputStreamReader  //中间有个转换流
    •           public class InputStreamReader extends Reader
    • 构造方法:public FileReader(String fileName) throws FileNotFoundException
    •                  public FileReader(File file) throws FileNotFoundException

    FileWriter:文件字符输出流

    • 定义: public class FileWriter extends OutputStreamWriter  //中间有个转换流
    •            public class OutputStreamWriter extends Writer
    • 构造方法:public FileWriter(String fileName) throws IOException
    •                  public FileWriter(String fileName, boolean append) throws IOExceptio//标记是否追加,默认fase覆盖
    •                  public FileWriter(File file) throws IOException 
    •                  public FileWriter(File file, boolean append) throws IOException//标记是否追加,默认fase覆盖

    转换流: 

    转换流,是将字节流转为字符流的一种中间流

    字节输入流转为字符输入流:InputStreamReader

    定义:public class InputStreamReader extends Reader

    构造方法:public InputStreamReader(InputStream in)   //字节流构造传入

                      public InputStreamReader(InputStream in, String charsetName)  //增加编码设置

    字节输出流转为字符输出流:OutputStreamWriter

    定义:public class OutputStreamWriter extends Writer

    构造方法:public OutputStreamWriter(OutputStream out) 

                      public OutputStreamWriter(OutputStream out, String charsetName)

     

    编码示例:从文件读取txt文件,将其内容按字节流读出,并转为字符流,在打印台显示;

                    将字符串输出到文件中

    class MyStream{ 
        //读取文件内容并打印在控制台
        public static void printTxt(File file) throws Exception {
            if (file.exists()){
                InputStream in = new FileInputStream(file);
                //转为字符流
                Reader reader = new InputStreamReader(in);
                char[] c = new char[1024];
                int b;
                while ((b = reader.read(c)) != -1){
                    System.out.println(c);
                }
                //注意关闭顺序,先关闭外围,再关闭内围
                reader.close();
                in.close();
            }
        }
        //将字符串输出到文件中保存
        public static void save(File file)throws Exception{
            if(!file.exists()){
                //文件不存在,创建目录和创建文件
                file.getParentFile().mkdirs();
                file.createNewFile();
            }
            FileOutputStream out = new FileOutputStream(file);
            //转为字会输出流
            Writer writer = new OutputStreamWriter(out);
            writer.write("今天日期是:"+ LocalDate.now().getYear()+"-"+LocalDate.now().getMonthValue()+"-"+LocalDate.now().getDayOfMonth());
            //注意关闭顺序,先关闭外围,再关闭内围
            writer.close();
            out.close();
        }
    }

     

    展开全文
  • IO---转换流和缓冲流总结

    千次阅读 2018-04-17 14:54:06
    IO---转换流和缓冲流1、转换流概述OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的字符编码表,将要写入流中的字符编码成字节,将字符串按照指定的编码表转成字节,在使用字节流将这些字节写出去2、转换...
  • 转换流 ​ 前面已经讲过,Java支持字节流和字符流,但有时需要字节流和字符流之间的转换。 ​ InputStreamReader 和OutputStreamWriter,这两个类是将字节流转换为字符流的类,InputStreamReader 可以将一个...
  • 转换流:可以设置编码格式

    千次阅读 2019-05-08 16:31:14
    转换流:可以设置编码格式
  • 转换流和对象流

    千次阅读 2018-07-24 17:55:49
    InputStreamReader类是Reader的子类,可以将一个字节输入流转变成字符输入,在转换时默认使用本地操作系统的字符编码或者指定其他字符编码,常用方法如下: 输出字节——字符:OutputStreamWriter...
  • Java 字节流 字符流 转换流

    万次阅读 2015-05-10 13:55:16
    我们知道Java中的分为字符和字节,其中字符主要针对字符文本进行处理,而字节处理范围更为广泛,毕竟图片、电影等只要是文件都是以二进制的形式存在的,而不是字符。 字符: FileReader FileWriter。 ...
  • 练习:转换文件编码。题目: 将GBK编码的文本文件,转换为UTF-8编码的文本文件。分析:1.创建InputStreamReader对象,构造方法中传递字节输入和指定的编码表名称GBK。2.创建OutputTreamWrite对象,构造方法中传递...
  • JavaIO——转换流、字符编码

    千次阅读 2018-05-15 21:44:02
    1、转换流转换是将字节变成字符。OutputStreamWriter:将字节输出流转换成字符输出。public class OutputStreamWriter extends Writer提供的构造方法: public OutputStreamWriter(OutputStream ...
  • 转换流InputStreamReader的使用

    千次阅读 2018-09-17 23:03:38
    import java.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader; /* InputStreamReader(InputStream is):用默认的编码读取数据 InputStreamReader(InputStream is,St...
  • 学习目标 ...在整个IO包中,实际上就是分为字节和字符,但是除了这两个之外,还存在了一组字节-字符转换类。 OutputStreamWriter:是Writer的子类,将输出的字符流变为字节,即:将一个
  • 20.缓冲流 . 转换流 和 序列化流

    千次阅读 2020-02-22 11:49:20
  • /*IO流-转换流的字符编码转换-ISO-8859-1和utf-8和GBK互转 编码:字符串变成字节数组解码:字节数组变成字符串String-->byte[]: str.getBytes(); byte[] getBytes(Charset charset) 使用给定的 charset 将此 String...
  • JAVA-转换流

    千次阅读 2016-10-08 10:37:11
    所以将转换流称之为字节流和字符流 之间的桥梁。 InputStreamReader 是字节流通向字符流的桥梁 测试InputStreamReader: 第一步: 需要专门新建以GBK编码的文本文件。为了便于标识,我们命名为g
  • public class Demo011 { public static void main(String[] args) { Demo011 de = new Demo011(); de.byteArrayInputStream();// 字节数组输入 de.fileInputStream();...// 文件输入,读
  • 缓冲也就是对4个基本的FileInputStream、FileOutputStream、FileReader、FileWriter的增强   相当于在传输文件时,将资源放入缓冲区数组中 待缓冲区数组满了,或者调用了flush()方法或close()方法关闭的...
  • Java IO流学习总结五:转换流-InputStreamReader、OutputStreamWriter 转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/54894451 本文出自【赵彦军的博客】 类的继承关系Reader |__ ...
  • 在流转换之前,先来看看字节和字符有什么区别? 最大的区别是:字节直接与终端文件进行数据交互(读入、输出),而字符需要将数据经过缓冲区处理才与终端文件进行数据交互。 如在使用字节输出...
  • 编码问题 在IDEA中使用文件字符输入流FileReader读取项目中的文本文件时 由于IDEA的默认设置为UTF-8编码 因此没有任何问题 但当读取Windows系统中...我们需要转换流! 一、InputStreamReader 输入转换流 java.io.Inp...
  • 媒体视频转换方法 mp4creator mp4box
  • java转换流、乱码之编码与解码

    万次阅读 2015-05-19 10:05:49
    * 转换流: 字节转为字符 * 1、输出流 OutputStreamWriter 编码 * 2、输入流 InputStreamReader 解码 * * 确保源不能为乱码 * @author Administrator * */ public class ConverDemo02 { /** * @param ...
  • 字符字符 一个字符一个字符的读 mac系统下,一个中文字符占3个字节 默认使用UTF-8的编码表(通用的编码表) Windows系统下,一个中文字符占2个字节 默认使用的GBK的编码表(简体中文) 注意:只能操作文本(不能写图片、...
  • java为什么需要转换流?

    千次阅读 2012-08-11 11:50:51
    转换流已经完成了编码转换的动作,对于直接操作的文本文件的FileReaer而言,就不用在重新定义了,  只要继承该转换流,获取其方法,就可以直接操作文本文件中的字符数据了。在使用FileReader操作文本数据时,该...
  • 编码转换流 字节流:针对二进制文件 字符流:针对文本文件,读写容易出现乱码的现象,在读写时,最好指定编码集为UTF-8 1 概述 编码转换流(InputStreamReader/OutputStreamWriter)主要进行编码的转换,用来解决字符流读写...
  • 转换流 使用框架 实例 转换流总结 标准的输入输出流 JDK文档解释 使用框架 转换流与标准输入输出流的实例 转换流 转换流(属于处理流)作用在节点流之上 转换流共两种:输入型和输出型 输入型转换流...
  • 这里套用别人的图进行一个形象的关于转换流的表达: 这里结合实例给大家进行一些说明,望详细看代码 /*  * 转换流:InputStreamReader OutputStreamWriter  * 编码:字符串-->字节数组  * 解码:字节...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 798,258
精华内容 319,303
关键字:

转换流