精华内容
下载资源
问答
  • 字节流和字符流

    2018-12-05 22:15:47
    记录一个老是犯糊涂的问题,关于字节流和字符流的认识,以及在Java和Python中二者如何转换。 字节流和字符流的区别 在Java基础的学习中,有专门的一部分来讲解流。最直观的一直区分就是字节流在操作时本身不会用到...

    记录一个老是犯糊涂的问题,关于字节流和字符流的认识,以及在Java和Python中二者如何转换。

    字节流和字符流的区别

    • 在Java基础的学习中,有专门的一部分来讲解流。最直观的一直区分就是字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的;而字符流在操作时使用了缓冲区,通过缓冲区再操作文件
    • 在Python2时代处理编码问题十分让人头痛,Python 3最重要的新特性大概要算是对文本和二进制数据作了更为清晰的区分。文本总是Unicode,由str类型表示,二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes,正是这使得两者的区分特别清晰。不能拼接字符串和字节包,也无法在字节包里搜索字符串(反之亦然),也不能将字符串传入参数为字节包的函数(反之亦然)。

    Java中的流分类和转换

    1. Java的字节流
      InputStream是所有字节输入流的祖先,而OutputStream是所有字节输出流的祖先。

    主要用在处理二进制数据,它是按字节来处理的,但实际中很多的数据是文本,又提出了字符流的概念,它是按虚拟机的Encode来处理,也就是要进行字符集的转化。这两个之间通过 InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]和String来关联。在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的。

    在从字节流转化为字符流时,实际上就是byte[]转化为String

    public String(byte bytes[], String charsetName)

    1. Java的字符流
      Reader是所有读取字符串输入流的祖先,而writer是所有输出字符串的祖先。

    在字符流转化为字节流时,实际上是String转化为byte[]

    byte[] String.getBytes(String charsetName)

    1. java.io中还出现了许多其他的流,主要是为了提高性能和使用方便,如BufferedInputStream,PipedInputStream等

    Python中的转换

    因为文本总是Unicode,所以创建时不需要指定,而字节型则要指定编码方式

    siteurl= 'www.xumingguo.cn' # 直接生产字符串
    bytes("python", 'ascii') # 字符串,编码
    # 或者用r''方式
    byt = b'bytes'
    

    将字符串转换成bytes[]时用字符串的encode方法或bytes函数

    siteurl_bytes_utf8 = siteurl.encode(encoding="utf-8")
    byt = bytes("siteurl_bytes_utf8 ", 'ascii') # 字符串,编码
    

    再解码成字符串时用decode方法,可默认不填解码方式

    bytes_utf8_str = siteurl_bytes_utf8.decode()
    
    展开全文
  • 详解字节流和字符流

    2020-06-08 22:35:59
    目录一、明确字符和字节的概念二、关于 java中字节流和字符流2.1 字节流,字符流概念2.2 java中的字节流,字符流相关API2.3 字符流,字节流API的使用三、字节流和字符流的区别四、使用场景判断4.1 数据格式4.2 数据...

    一、明确字符和字节的概念

    字节:1 byte = 8 bit
    字符:1 char = 2 byte = 16 bit(java默认)

    在计算机硬件层面,1 bit 是数据最小的单位。但是在大多数情况下,1 bit 存储的信息太少,我们通常把 1 字节作为数据最小的基本单位。

    而字符实际上也是对字节的一种包装,那为什么还需要引入字符?
    对于西方世界,使用英语等语种的国家来说,1字节有 256个符号编码,对于26个英文字母加上常用的标点符号已经够用了。这就是常用的ASCII 码。
    但是对于东方国家,中文,日文等文字,数量太多,1个字节根本没有办法表示所有的字符,所以引入了Unicode —— 统一编码,而这种编码的常规字符集就是使用2个字节,所以引入了字符的概念。

    但是,从根本而言,一切都是字节流,字符流也是字节流的一种形式。

    二、关于 java中字节流和字符流

    2.1 字节流,字符流概念

    Java中,读取数据时,字节流的数据存储单位是字节,会使用字节类型数组 byte[] 来保存数据,可以操作字节,字节数组。
    而 字符流的存储单位是字符,使用字符类数组 char[] 来保存数据,可以操作字符,字符数组或字符串。

    2.2 java中的字节流,字符流相关API

    Java 的I/O库有两个分支:

    • 面向字节流的InputSteam和OutputStream
    • 面向字符的Reader 和 wirter
      图片来自网络
      ByteArrayInputStream – 把内存中的一个缓冲区作为 InputStream 使用 .
      StringBufferInputStream – 把一个 String 对象作为 InputStream .
      FileInputStream – 把一个文件作为 InputStream ,实现对文件的读取操作
      PipedInputStream :实现了 pipe 的概念,主要在线程中使用 . 管道输入流是指一个通讯管道的接收端。
      一个线程通过管道输出流发送数据,而另一个线程通过管道输入流读取数据,这样可实现两个线程间的通讯。
      SequenceInputStream :把多个 InputStream 合并为一个 InputStream . “序列输入流”类允许应用程序把几个输入流连续地合并起来,
      并且使它们像单个输入流一样出现。每个输入流依次被读取,直到到达该流的末尾。
      图片来自网络
      ByteArrayOutputStream : 把信息存入内存中的一个缓冲区中 . 该类实现一个以字节数组形式写入数据的输出流。
      FileOutputStream: 文件输出流是向 File 或 FileDescriptor 输出数据的一个输出流。
      PipedOutputStream: 管道输出流是指一个通讯管道的发送端。 一个线程通过管道输出流发送数据,
      而另一个线程通过管道输入流读取数据,这样可实现两个线程间的通讯。
      图片来自网络
      CharArrayReader :与 ByteArrayInputStream 对应此类实现一个可用作字符输入流的字符缓冲区
      StringReader : 与 StringBufferInputStream 对应其源为一个字符串的字符流。
      FileReader : 与 FileInputStream 对应
      PipedReader :与 PipedInputStream 对应
      图片来着网络
      CharArrayWrite : 与 ByteArrayOutputStream 对应
      StringWrite :无与之对应的以字节为导向的 stream
      FileWrite : 与 FileOutputStream 对应
      PipedWrite :与 PipedOutputStream 对应

    2.3 字符流,字节流API的使用

    字节流示例

    //字节流写文件
    public static void writeFile(){
        String str = "采用数据流方式(字节流)写文件!";
        try{
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D://hello.txt",true));
            //需要转化为字节
            byte[] data = str.getBytes();
            bos.write(data);
            bos.close();
        }catch (FileNotFoundException e){
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //字节流读文件
    public static void readFile(){
        try {
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D://hello.txt"));
            byte[] data = new byte[1024];
            int n = -1;
            while((n=bis.read(data,0,data.length))!=-1){
                String str = new String(data,0,n,"UTF-8");
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    

    字符流示例

    //字符流写文件
    public static void writeFile(){
        File file = new File("D:\\hello.txt");
        String str = " hello, everybody! welcome to the study of Java!";
        try{
            FileWriter fw = new FileWriter(file);
            BufferedWriter bw = new BufferedWriter(fw);
            bw.write(str);
            bw.close();
            fw.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
    //字符流读文件
    public static void readerFile(){
        File file = new File("D:\\hello.txt");
        try{
            BufferedReader br = new BufferedReader(new FileReader(file));
    
            String str = null;
            while( (str = br.readLine()) != null){
                System.out.println(str);
            }
            br.close();
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
    

    三、字节流和字符流的区别

    字节流和字符流的区别:

    • 字节流在操作文件时,本身不会用到缓冲区(内存),是对文件本身直接操作的;而字符流在操作时是使用到缓冲区的。
    • 字节流在操作文件时,即使不关闭资源(close)文件也能输出;字符流如果不是用close方法的话,则不会输出任何内容,说明字符流使用了缓冲区。且可以使用flush方法强制进行刷新缓冲区,此时在不close情况下也能输出内容。
    • Reader类的read()方法返回类型是int,占两个字节,如果到达流的末尾,则返回-1;inputStream的read()方法虽然也返回int,打算面向字节流,占一个字节。因此对于超过一个字节的只能使用字符流来读取,如汉字。
    • 处理方式不同;字节流:处理字节和字节数组成的二进制对象。
      字符流:处理字符,字符数或字符串。

    注:缓冲区是什么??
    缓冲区可以理解为一段特殊的内存。
    在某些情况下,如果程序频繁操作一个资源,则性能会很低,为了提升性能,可以将这部分数据暂时读入内存的一块区域,之后就可以直接从内存中读取数据,提升速度和性能。

    四、使用场景判断

    4.1 数据格式

    • 二进制格式(不能确定是纯文本):字节流,InputStream、OutputStream及其子类。
    • 纯文本格式(含中英文或其他编码方式):字符流,Reader,Writer及其子类。

    4.2 数据来源

    • 文件:字节流 FileInputStream,FileOutputStream;字符流 FileReader,FileWriter
    • byte[]: 字节流 ByteArrayInputStream, ByteArrayOutputStream char[]:字符流
    • CharArrayReader, CharArrayWriter String: 字节
    • StringBufferInputStream, StringBufferOuputStream ;字符流 StringReader,StringWriter
    • 网络数据流:字节流 InputStream, OutputStream;字符流 Reader, Writer

    4.3 是否需要格式化输出

    需要格式化输出的:PrintStream, PrintWriter

    4.4 是否需要缓冲

    需要缓冲:字节流 BufferedInputStream, BufferedOutputStream;字符流 BufferedReader, BufferedWriter

    4.5 输入还是输出

    • 输入:Reader, InputStream 类型的子类
    • 输出:Writer, OutputStream 类型的子类

    4.6 是否有流转化

    • 字节到字符:InputStreamReader
    • 字符到字节:OutputStreamWriter

    4.7 特殊需要

    • 对象输入输出:ObjectInputStream, ObjectOutputStream
    • 进程间通信:PipedInputStream, PipedOutputStream, PipedReader, PipedWriter
    • 合并输入: SequenceInputStream
    展开全文
  • Java字节流和字符流

    2019-12-05 16:17:32
    Java字节流和字符流: Java字节流和字符流的主要区别是编码方式,字节流主要是基于二进制以字节为单位进行输入输出,字符流是Unicode编码的方法以字符为单位进行输入输出。 其实字符流的本质也是字节流 只不过使用...

    Java字节流和字符流:
    Java字节流和字符流的主要区别是编码方式,字节流主要是基于二进制以字节为单位进行输入输出,字符流是Unicode编码的方法以字符为单位进行输入输出。

    其实字符流的本质也是字节流 只不过使用编码规定来约束字符和字节之间的对应关系。

    总而言之,一切都是字节流,其实没有字符流这个东西。字符只是根据编码集对字节流翻译之后的产物。

    https://www.zhihu.com/question/39262026

    展开全文
  • 字节流和字符流详解

    2021-03-29 20:21:21
    1.流的概念 在编程中是一种抽象的概念,就好比“水流”,从一段流向另一端 ...按照传输单位可以分为:字节流和字符流 3.什么是字节流,什么是字符流 字节流: 它处理单元为1个字节(byte),操作字节和

    1.流的概念

    • 在编程中是一种抽象的概念,就好比“水流”,从一段流向另一端
    • 在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成。
    • 程序中的输入输出都是以流的形式保存的,流中保存的实际上全都是字节文件。

    2.流的分类

    按照流向可以分为:输入流(如:键盘,麦克风),输出流(如:显示器,音箱)
    按照传输单位可以分为:字节流和字符流

    3.什么是字节流,什么是字符流

    字节流: 它处理单元为1个字节(byte),操作字节和字节数组,存储的是二进制文件,如果是音频文件、图片、歌曲,就用字节流好点(1byte = 8位);

    字符流: 它处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,如果是关系到中文(文本)的,用字符流好点(1Unicode = 2字节 = 16位);

    所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。在读取文件(特别是文本文件)时,也是一个字节一个字节地读取以形成字节序列。

    字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串; 2. 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以。

    字节流是最基本的,所有的InputStrem和OutputStream的子类都是,主要用在处理二进制数据,它是按字节来处理的 但实际中很多的数据是文本,又提出了字符流的概念,它是按虚拟机的encode来处理,也就是要进行字符集的转化 这两个之间通过 InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]和String来关联 在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的

    最简单的区分字节流和字符流

    万物皆文件,那就将文件在记事本里面打开,如果打开后能看的懂的就是字符流,如果看不懂那就是字节流

    问题:
    1.word.doc 数据字节流还是字符流?
    答:.doc数据字节流。
    2.Excel 数据字节流还是字符流?
    答:要根据保存的格式进行判断,如果是保存为.csv那么他就是字符流,如果是其他的则数据字节流。

    字符和字节操作

    在这里插入图片描述
    如何简单记住字节流和字符流

    • 字符流是以Reader,Writer结尾的
    • 字符节流是以InputStream或OutputStream结尾的

    4.字节流的使用

    字节流主要是操作byte类型数据,以byte数组为准,主要操作类就是OutputStream、InputStream。

    字节输出流:OutputStream,OutputStream是整个IO包中字节输出流的最大父类

    Closeable表示可以关闭的操作

    示例为:图片的复制

    步骤:
    1.读入二进制文件(输入流,FileInputStream)
    2.写入二进制文件(输出流,FileOutputStream)

    前请了解:try-with-resource,这是JDK1.7提供的新方法,让代码的可读性更高,但是并不是所有的对象都可以这样,当调用的类实现了closable接口就可以使用此种方式

    4.1.普通字节流的操作

    代码案例
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /**
     * 复制D:\io_test下的加菲猫文件到D:\io_test这个目录下
     */
    
    public class IoDemo4 {
    
        public static void main(String[] args) throws IOException {
            //输入文件目录
            String srcFilePath = "D:\\io_test\\加菲猫.jpg";
            //输出文件目录(拷贝的路径)
            String destFilePath = "D:\\io_test\\加菲猫2.jpg";
            FileInputStream fileInputStream = null;
            FileOutputStream fileOutputStream = null;
            try {
                //输入流,传入路径
                fileInputStream = new FileInputStream(srcFilePath);
                //输出流
                 fileOutputStream = new FileOutputStream(destFilePath);
                byte[] bytes = new byte[1024];
                try {
                    int count = 0;
                    //如果不等于-1说明还没有读取完成,要继续读取
                    while((count = fileInputStream.read(bytes)) != -1){
                        //还有内容要读取,然后从0开始读取,上面count有读了多少个,那么就写多少个
                        fileOutputStream.write(bytes,0,count);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }finally {
                //用完之后一定要关闭流,但是得判断不是空的时候才需要去关闭流
                if(fileInputStream != null){
                    fileInputStream.close();
                }
                if(fileOutputStream != null){
                    fileOutputStream.close();
                }
            }
        }
    }
    
    

    执行结果
    在这里插入图片描述

    注意:
    1.因为字节流主要操作byte类型数据,注意里面参数的含义,如果是读取的话,比较常用的是第二种
    在这里插入图片描述

    (FileOutputStream)也是一样,读取的时候一般用第一个
    在这里插入图片描述

    2.读取数据的返回结果(FileInputStream)
    在这里插入图片描述

    3.最后一定要关闭流

    • 因为每天计算机打开的文件的数量是有限的,以liunx为例,最大可以打开66533个文件,
    • 但是无论执行结果怎么样他都要关闭流,那么就需要将他放在finally里面,所有上面的声明也得放在外面
    • 如果传入的地址和目标地址都是错的,也就是找不到,如果传入的地址错了,那么还没有初始化就已经被调用关闭流了,所以要进行判断

    4.2.带有缓冲区的字节流的操作

    什么是缓存区?
    定义:缓存区相当于缓存,它是存在内存中的
    写操作:
    没有使用缓存区:CPU读取每个字节之后直接操作磁盘(性能比较底)进行写完,写操作的瓶颈就会出现,因为每个字节都会操作一次磁盘
    使用缓冲区:那么每次会将字符放入缓存区(内存),等缓冲区满了之后,才一次性写入磁盘
    因为内存的操作速度远远大于磁盘,因此带缓冲区的输入流和输出流实现的效率就非常高(比如扔垃圾,一次性扔完和一次次扔肯定消耗的时间是有很大差距的)

    案例实现:复制D:\io_test\下的加菲猫—>D:\io_test\下变成加菲猫3

    代码实现
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    /**
     * 带有缓冲区的字节流操作:图片复制
     *
     */
    public class IoDemo5 {
        public static void main(String[] args) {
            //输入文件目录
            String srcFilePath = "D:\\io_test\\加菲猫.jpg";
            //输出文件目录(拷贝的路径)
            String destFilePath = "D:\\io_test\\加菲猫3.jpg";
            try {
                //因为带有缓存区的是基于原始的类进行操作的
                BufferedInputStream bufferedInputStream =
                        new BufferedInputStream(new FileInputStream(srcFilePath));
                BufferedOutputStream bufferedOutputStream =
                        new BufferedOutputStream(new FileOutputStream(destFilePath));
                {
                            byte[] bytes = new byte[1024];
                            int count = 0;
                            while ((count = bufferedInputStream.read(bytes)) != -1){
                                bufferedOutputStream.write(bytes,0,count);
                            }
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    
    

    执行结果
    在这里插入图片描述

    5.字符流的使用

    5.1.普通的字符流操作

    在程序中一个字符等于两个字节,那么java提供了Reader、Writer两个专门操作字符流的类。

    字符输出流:Writer。
    字符输入流:Reader

    示例一:内容的写入:D:\io_test\1下创建一个text.txt文件,并写入内容“欢迎来到Java~”
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    /**
     * 内容的写入:D:\io_test\1下创建一个text.txt文件,并写入内容
     */
    public class IoDemo7 {
        public static void main(String[] args) throws IOException {
            //定义文件地址
            String filePath = "D:\\io_test\\1\\text.txt";
            //写入内容
            String content = "欢迎来到Java~";
            //因为是写入文件,所以要使用FileWriter方法
            FileWriter fileWriter = null;
            try {
                fileWriter = new FileWriter(filePath);
                fileWriter.write(content);
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
            //关闭流
                fileWriter.close();
            }
        }
    }
    

    **注意:**如果不关闭流,虽然也能创建文件成功,不报错,但是可能存在内容无法写入的情况

    示例二:但是上面这种操作如果是对于多行输入的话那么就回被覆盖
    因为这里的参数append会被默认成false,所以如果是多行写入的话
    需要手动设置成true
    

    在这里插入图片描述
    来看看在刚才那种被覆盖掉的情况
    在这里插入图片描述

    代码实现:那么来看看将append设置成true
    
    public class IoDemo7 {
        public static void main(String[] args) throws IOException {
            //定义文件地址
            String filePath = "D:\\io_test\\1\\text.txt";
            //写入内容
            String content = "欢迎来到java~,";
            //因为是写入文件,所以要使用FileWriter方法
            FileWriter fileWriter = null;
            try {
                fileWriter = new FileWriter(filePath,true);
                fileWriter.write(content);
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                fileWriter.close();
            }
        }
    }
    
    

    执行结果
    在这里插入图片描述

    示例三:文件的读取,比如将文件下的内容读取到控制台
    

    文件下的内容

    import java.io.File;
    import java.io.FileNotFoundException;
    import java.util.Scanner;
    
    /**
     * 读取文件内容
     */
    public class IoDemo8 {
        public static void main(String[] args) throws FileNotFoundException {
            String filePath = "D:\\io_test\\1\\tt.txt";
            Scanner scanner = new Scanner(new File(filePath));
            //因为读取的内容可能不止一条,所以加上while循环
            while (scanner.hasNext()){
                System.out.println(scanner.nextLine());
            }
        }
    }
    
    

    执行效果
    在这里插入图片描述

     示例四:将内容读取到内存中,如:将一个路径下的内容复制到另一个路径下
    

    代码实现

    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /**
     *将一个文件的内容写入到另一个文件下
     * 如:D:\io_test\1\text.txt -> text2.txt
     */
    public class IoDemo9 {
        public static void main(String[] args) throws IOException {
            //读取文件的地址
            String srcFilePath = "D:\\io_test\\1\\text.txt";
            //目标文件的地址
            String destFilePath = "D:\\io_test\\1\\text2.txt";
            FileReader fileReader = null;
            FileWriter fileWriter = null;
            //先读后写
            try{
                 fileReader = new FileReader(srcFilePath);
                 fileWriter = new FileWriter(destFilePath);
                {
                    //读操作
                    char[] chars = new char[1024];
                    while (true){
                        int count = fileReader.read(chars);
                        //判断是否等于-1,如果等于-1,说明已经读取完了,跳出循环
                        if(count == -1){
                            break;
                        }
                        //写操作
                        fileWriter.write(chars,0,count);
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                fileReader.close();
                fileWriter.close();
            }
        }
    }
    
    

    执行结果
    在这里插入图片描述

    5.2.带有缓冲区的字符流操作

    示例:如上述的示例四
    

    代码实现

    import java.io.*;
    
    /**
     * 带有缓冲区的字符流操作
     * 如:内容的复制
     */
    public class IoDemo10 {
        public static void main(String[] args) throws IOException {
            String srcFilePath = "D:\\io_test\\1\\tt.txt";
            String destFilePath = "D:\\io_test\\1\\tt2.txt";
            BufferedReader bufferedReader = null;
            BufferedWriter bufferedWriter = null;
            //先读取,后写入
            try {
                 bufferedReader = new BufferedReader(new FileReader(srcFilePath));
                 bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
                {
                    char[] chars = new char[1024];
                    while (true){
                        int count = bufferedReader.read(chars);
                        if(count == -1){
                            break;
                        }
                        bufferedWriter.write(chars,0,count);
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                bufferedReader.close();
                bufferedWriter.close();
            }
        }
    }
    

    执行结果
    在这里插入图片描述

    6.总结对比字节流和字符流

    • 字节流操作的基本单元是字节;字符流操作的基本单元为Unicode码元。

    • 字节流在操作的时候本身不会用到缓冲区的,是与文件本身直接操作的;而字符流在操作的时候使用到缓冲区的。

    • 所有文件的存储都是字节(byte)的存储,在磁盘上保留的是字节。

    • 在使用字节流操作中,即使没有关闭资源(close方法),也能输出;而字符流不使用close方法的话,不会输出任何内容

    展开全文
  • 字节流和字符流概念 字节流和字符流都有输入和输出方式 字节输入流和输出流的祖先:InputStream和OutputStream 字符输入流和输出流的祖先:Reader和Writer 以上这些类都是abstract修饰的抽象类,不能直接实例化...
  • java字节流和字符流

    2019-07-27 08:51:57
    java字节流和字符流 首先介绍一下什么是流。 [以下来自百度百科解释] JavaIO流,是一种计算机用语。主要是用于处理数据的传输。我们可以把流理解为一种信息传输的媒介。 流的分类 字节传输方式字符传输方式输入输出...
  • 网上说字节流和字符流的区别是: 字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操作文件。 而BufferedInputStream和BufferedOutputStream创建一...
  • 字节流和字符流的区别 以 Stream 结尾都是字节流,Reader 和 Writer 结尾都是字符流。 InputStream 是所有字节输入流的父类,OutputStream 是所有字节输出流的父类。 Reader 是字符输入流的父类,Writer 是字符输出...
  • Java字节流和字符流,是时候总结一下IO流了

    千次阅读 多人点赞 2021-04-12 12:39:41
    字节流和字符流:为什么字符流需要 flush
  • IO概述1 父类们2 文件字节输出流 ...格局数据的类型分为:字节流和字符流。 字节流 :以字节为单位,读写数据的流。 字符流 :以字符为单位,读写数据的流。 1 父类们 输入流 输出流 字节流 ...
  • IO字节流和字符流

    2018-05-15 18:58:51
    字节流和字符流的区别计算机中的一切最终都是以二进制字节形式存在的(计算机的最小存储单位就是字节),对于我们经常操作的字符串,在写入时其实是先得到对应的字节,然后将字节写入到输出流,在读取时其实是先读到...
  • 字节流和字符流的区别? 1.字节流操作的基本单元是字节,字符流操作的基本单元是Unicode码元。 2.字节流默认不使用缓冲区,而字符流使用缓冲区。 3.字节流通常用于处理二进制数据,实际上他可以处理任意类型的...
  • 转换流:字节流和字符流可以相互转换OutputStreamWriter:将字节输出流转换成字符输出流InputStreamReader 将字节流转换成字符输入流转换的意义OutputStraemWriter 是 writer 的子类INputStreamReader 是Reader 的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,613
精华内容 6,645
关键字:

字节流和字符流