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

    2013-07-14 20:36:26
    字节流与和字符流的使用非常相似,两者除了操作代码上的不同...下面以两个写文件的操作为主进行比较,但是在操作时字节流和字符流的操作完成之后都不关闭输出流。 范例:使用字节流不关闭执行 Java代码
    字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢?

    实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操作文件,如图12-6所示。

    下面以两个写文件的操作为主进行比较,但是在操作时字节流和字符流的操作完成之后都不关闭输出流。

    范例:使用字节流不关闭执行
    Java代码  收藏代码
    1. package org.lxh.demo12.byteiodemo;    
    2. import java.io.File;    
    3. import java.io.FileOutputStream;    
    4. import java.io.OutputStream;    
    5. public class OutputStreamDemo05 {    
    6. public static void main(String[] args) throws Exception {   // 异常抛出,  不处理    
    7. // 第1步:使用File类找到一个文件    
    8.      File f = new File("d:" + File.separator + "test.txt"); // 声明File  对象    
    9. // 第2步:通过子类实例化父类对象    
    10.      OutputStream out = null;            
    11. // 准备好一个输出的对象    
    12.      out = new FileOutputStream(f);      
    13. // 通过对象多态性进行实例化    
    14. // 第3步:进行写操作    
    15.      String str = "Hello World!!!";      
    16. // 准备一个字符串    
    17.      byte b[] = str.getBytes();          
    18. // 字符串转byte数组    
    19.      out.write(b);                      
    20. // 将内容输出    
    21.  // 第4步:关闭输出流    
    22.     // out.close();                  
    23. // 此时没有关闭    
    24.         }    
    25.     }   

    程序运行结果:

    此时没有关闭字节流操作,但是文件中也依然存在了输出的内容,证明字节流是直接操作文件本身的。而下面继续使用字符流完成,再观察效果。

    范例:使用字符流不关闭执行
    Java代码  收藏代码
    1. package org.lxh.demo12.chariodemo;    
    2. import java.io.File;    
    3. import java.io.FileWriter;    
    4. import java.io.Writer;    
    5. public class WriterDemo03 {    
    6.     public static void main(String[] args) throws Exception { // 异常抛出,  不处理    
    7.         // 第1步:使用File类找到一个文件    
    8.         File f = new File("d:" + File.separator + "test.txt");// 声明File 对象    
    9.         // 第2步:通过子类实例化父类对象    
    10.         Writer out = null;                 
    11. // 准备好一个输出的对象    
    12.         out = new FileWriter(f);            
    13. // 通过对象多态性进行实例化    
    14.         // 第3步:进行写操作    
    15.         String str = "Hello World!!!";      
    16. // 准备一个字符串    
    17.         out.write(str);                    
    18. // 将内容输出    
    19.         // 第4步:关闭输出流    
    20.         // out.close();                   
    21. // 此时没有关闭    
    22.     }    
    23. }   

    程序运行结果:




    程序运行后会发现文件中没有任何内容,这是因为字符流操作时使用了缓冲区,而   在关闭字符流时会强制性地将缓冲区中的内容进行输出,但是如果程序没有关闭,则缓冲区中的内容是无法输出的,所以得出结论:字符流使用了缓冲区,而字节流没有使用缓冲区。

    提问:什么叫缓冲区?

    在很多地方都碰到缓冲区这个名词,那么到底什么是缓冲区?又有什么作用呢?

    回答:缓冲区可以简单地理解为一段内存区域。

    可以简单地把缓冲区理解为一段特殊的内存。

    某些情况下,如果一个程序频繁地操作一个资源(如文件或数据库),则性能会很低,此时为了提升性能,就可以将一部分数据暂时读入到内存的一块区域之中,以后直接从此区域中读取数据即可,因为读取内存速度会比较快,这样可以提升程序的性能。

    在字符流的操作中,所有的字符都是在内存中形成的,在输出前会将所有的内容暂时保存在内存之中,所以使用了缓冲区暂存数据。

    如果想在不关闭时也可以将字符流的内容全部输出,则可以使用Writer类中的flush()方法完成。

    范例:强制性清空缓冲区

    Java代码  收藏代码
    1. package org.lxh.demo12.chariodemo;    
    2. import java.io.File;    
    3. import java.io.FileWriter;    
    4. import java.io.Writer;    
    5. public class WriterDemo04 {    
    6.     public static void main(String[] args) throws Exception { // 异常抛出不处理    
    7.         // 第1步:使用File类找到一个文件    
    8.         File f = new File("d:" + File.separator + "test.txt");// 声明File    
    9. 对象    
    10.         // 第2步:通过子类实例化父类对象    
    11.         Writer out = null;                   
    12. // 准备好一个输出的对象    
    13.         out = new FileWriter(f);             
    14. // 通过对象多态性进行实例化    
    15.         // 第3步:进行写操作    
    16.         String str = "Hello World!!!";      
    17. // 准备一个字符串    
    18.         out.write(str);                    
    19. // 将内容输出    
    20.         out.flush();                       
    21. // 强制性清空缓冲区中的内容    
    22.         // 第4步:关闭输出流    
    23.         // out.close();                
    24. // 此时没有关闭    
    25.     }    
    26. }   


    程序运行结果:

    此时,文件中已经存在了内容,更进一步证明内容是保存在缓冲区的。这一点在读者日后的开发中要特别引起注意。

    提问:使用字节流好还是字符流好?

    学习完字节流和字符流的基本操作后,已经大概地明白了操作流程的各个区别,那么在开发中是使用字节流好还是字符流好呢?

    回答:使用字节流更好。

    在回答之前,先为读者讲解这样的一个概念,所有的文件在硬盘或在传输时都是以字节的方式进行的,包括图片等都是按字节的方式存储的,而字符是只有在内存中才会形成,所以在开发中,字节流使用较为广泛。


    字节流与字符流主要的区别是他们的的处理方式

    流分类:
    1.Java的字节流
       InputStream是所有字节输入流的祖先,而OutputStream是所有字节输出流的祖先。
    2.Java的字符流
      Reader是所有读取字符串输入流的祖先,而writer是所有输出字符串的祖先。
    InputStream,OutputStream,Reader,writer都是抽象类。所以不能直接new 



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

    在从字节流转化为字符流时,实际上就是byte[]转化为String时,
    public String(byte bytes[], String charsetName)
    有一个关键的参数字符集编码,通常我们都省略了,那系统就用操作系统的lang
    而在字符流转化为字节流时,实际上是String转化为byte[]时,
    byte[]    String.getBytes(String charsetName)
    也是一样的道理

    至于java.io中还出现了许多其他的流,按主要是为了提高性能和使用方便,
    如BufferedInputStream,PipedInputStream等
    展开全文
  • 字节流与和字符流的使用非常相似,两者除了操作代码上...下面以两个写文件的操作为主进行比较,但是在操作时字节流和字符流的操作完成之后都不关闭输出流。范例:使用字节流不关闭执行Java代码 packageorg.lxh.demo1...

    字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢?

    实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操作文件,如图12-6所示。

    65a35238bd213d6ee30a0a2acae887d8.png

    下面以两个写文件的操作为主进行比较,但是在操作时字节流和字符流的操作完成之后都不关闭输出流。

    范例:使用字节流不关闭执行

    Java代码  007919e8dab533a3c48403be43b8cc7e.png

    package org.lxh.demo12.byteiodemo;

    import java.io.File;

    import java.io.FileOutputStream;

    import java.io.OutputStream;

    public class OutputStreamDemo05 {

    public static void main(String[] args) throws Exception {   // 异常抛出,  不处理

    // 第1步:使用File类找到一个文件

    File f = new File("d:" + File.separator + "test.txt"); // 声明File  对象

    // 第2步:通过子类实例化父类对象

    OutputStream out = null;

    // 准备好一个输出的对象

    out = new FileOutputStream(f);

    // 通过对象多态性进行实例化

    // 第3步:进行写操作

    String str = "Hello World!!!";

    // 准备一个字符串

    byte b[] = str.getBytes();

    // 字符串转byte数组

    out.write(b);

    // 将内容输出

    // 第4步:关闭输出流

    // out.close();

    // 此时没有关闭

    }

    }

    程序运行结果:

    acada23cd5cd436e872948ccaf5c3453.png

    此时没有关闭字节流操作,但是文件中也依然存在了输出的内容,证明字节流是直接操作文件本身的。而下面继续使用字符流完成,再观察效果。

    范例:使用字符流不关闭执行

    Java代码  007919e8dab533a3c48403be43b8cc7e.png

    package org.lxh.demo12.chariodemo;

    import java.io.File;

    import java.io.FileWriter;

    import java.io.Writer;

    public class WriterDemo03 {

    public static void main(String[] args) throws Exception { // 异常抛出,  不处理

    // 第1步:使用File类找到一个文件

    File f = new File("d:" + File.separator + "test.txt");// 声明File 对象

    // 第2步:通过子类实例化父类对象

    Writer out = null;

    // 准备好一个输出的对象

    out = new FileWriter(f);

    // 通过对象多态性进行实例化

    // 第3步:进行写操作

    String str = "Hello World!!!";

    // 准备一个字符串

    out.write(str);

    // 将内容输出

    // 第4步:关闭输出流

    // out.close();

    // 此时没有关闭

    }

    }

    程序运行结果:

    d51c6fa2e1dd70a6303f4c91de398f96.png

    程序运行后会发现文件中没有任何内容,这是因为字符流操作时使用了缓冲区,而在关闭字符流时会强制性地将缓冲区中的内容进行输出,但是如果程序没有关闭,则缓冲区中的内容是无法输出的,所以得出结论:字符流使用了缓冲区,而字节流没有使用缓冲区。

    提问:什么叫缓冲区?在很多地方都碰到缓冲区这个名词,那么到底什么是缓冲区?又有什么作用呢?

    回答:缓冲区可以简单地理解为一段内存区域。可以简单地把缓冲区理解为一段特殊的内存。某些情况下,如果一个程序频繁地操作一个资源(如文件或数据库),则性能会很低,此时为了提升性能,就可以将一部分数据暂时读入到内存的一块区域之中,以后直接从此区域中读取数据即可,因为读取内存速度会比较快,这样可以提升程序的性能。在字符流的操作中,所有的字符都是在内存中形成的,在输出前会将所有的内容暂时保存在内存之中,所以使用了缓冲区暂存数据。如果想在不关闭时也可以将字符流的内容全部输出,则可以使用Writer类中的flush()方法完成。

    范例:强制性清空缓冲区

    Java代码  007919e8dab533a3c48403be43b8cc7e.png

    package org.lxh.demo12.chariodemo;

    import java.io.File;

    import java.io.FileWriter;

    import java.io.Writer;

    public class WriterDemo04 {

    public static void main(String[] args) throws Exception { // 异常抛出不处理

    // 第1步:使用File类找到一个文件

    File f = new File("d:" + File.separator + "test.txt");// 声明File

    对象

    // 第2步:通过子类实例化父类对象

    Writer out = null;

    // 准备好一个输出的对象

    out = new FileWriter(f);

    // 通过对象多态性进行实例化

    // 第3步:进行写操作

    String str = "Hello World!!!";

    // 准备一个字符串

    out.write(str);

    // 将内容输出

    out.flush();

    // 强制性清空缓冲区中的内容

    // 第4步:关闭输出流

    // out.close();

    // 此时没有关闭

    }

    }

    程序运行结果:

    ced7a878a1a7ad1551c9577ed17ae48f.png

    此时,文件中已经存在了内容,更进一步证明内容是保存在缓冲区的。这一点在读者日后的开发中要特别引起注意。

    提问:使用字节流好还是字符流好?学习完字节流和字符流的基本操作后,已经大概地明白了操作流程的各个区别,那么在开发中是使用字节流好还是字符流好呢?

    回答:使用字节流更好。

    在回答之前,先为读者讲解这样的一个概念,所有的文件在硬盘或在传输时都是以字节的方式进行的,包括图片等都是按字节的方式存储的,而字符是只有在内存中才会形成,所以在开发中,字节流使用较为广泛。

    字节流与字符流主要的区别是他们的的处理方式

    流分类:

    1.Java的字节流

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

    2.Java的字符流

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

    InputStream,OutputStream,Reader,writer都是抽象类。所以不能直接new

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

    在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的。

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

    public String(byte bytes[], String charsetName)

    有一个关键的参数字符集编码,通常我们都省略了,那系统就用操作系统的lang

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

    byte[]    String.getBytes(String charsetName)

    也是一样的道理

    至于java.io中还出现了许多其他的流,按主要是为了提高性能和使用方便,

    如BufferedInputStream,PipedInputStream等

    展开全文
  • 1、位:数据存储的最小单位。每个二进制数字0或者1就是1个位;2、字节:8个位构成一个字节;即:1 byte (字节)= 8 bit(位);1 KB = 1024 B(字节) 1 MB = 1024 KB;... (2^30 B)3、字符:a、A、中、+、*...

    1、位:

    数据存储的最小单位。每个二进制数字0或者1就是1个位;

    2、字节:

    8个位构成一个字节;即:1 byte (字节)= 8 bit(位);

    1 KB = 1024 B(字节)                1 MB = 1024 KB;   (2^10 B)

    1 GB = 1024 MB;  (2^20 B)      1 TB = 1024 GB;   (2^30 B)

    3、字符:

    a、A、中、+、*、の......均表示一个字符;

    一般 utf-8 编码下,一个汉字 字符 占用 3 个 字节;

    一般 gbk 编码下,一个汉字  字符  占用 2 个 字节;

    4、字符集:

    即各种各个字符的集合,也就是说哪些汉字,字母(A、b、c)和符号(空格、引号..)会被收入标准中;

    5、编码:

    utf-8       jbk

    字节流和字符流比较

    字节流                                        字符流

    缓冲区                        有                                                          无

    类型          InputStream,OutputStream                         Reader,writer

    处理                 二进制数据                                               文本数据

    对象                  序列化 反序列化

    关联           InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]和String来关联。

    字节流和字符流转化

    01.//创建字节流

    02.FileOutputStream fos = new FileOutputStream(new File("F:\\testSource\\newFile2.txt"));

    03.//转换流包装输出流(将字节流转换成字符流)

    04.OutputStreamWriter osw = new OutputStreamWriter(fos);

    05.//向流中写入字符

    06.osw.write("this ");

    07.osw.write("is ");

    08.osw.write("OutputStreamWriter");

    09.//将流刷入文件

    10.osw.flush();

    11.//流关闭

    12.fos.close();

    字符流不能被转换成字节流

    字节流和字符流扩展

    文件,数组,管道,缓存,对象,字符串,

    6f2535c077f4

    展开全文
  • 菜鸟举例理解字节流和字符流区别 按照uft8编码方式存储文档 文档存储路径在D盘下 /** * 按照utf8格式存储文档 */ public static void storeDataByUTF8(){ String path = "D:" + File.separator + "textutf8....

    参考链接: Java中的字符流与字节流 Character Stream对比Byte Stream

    菜鸟举例理解字节流和字符流区别 

     按照uft8编码方式存储文档 

     文档存储路径在D盘下 

    /**

    * 按照utf8格式存储文档

    */

    public static void storeDataByUTF8(){

        String path = "D:" + File.separator + "textutf8.txt";

        File file = new File(path);

        try {

            PrintWriter pw = new PrintWriter(file,"utf-8");

            for(int i=0;i<5;i++){

                pw.write(i+":"+"字节流与字符流!!!"+"\r\n");

            }

            pw.flush();

            pw.close();

        } catch (FileNotFoundException | UnsupportedEncodingException e) {

            e.printStackTrace();

        }

     对比使用BufferedReader和FileInputStream按照byte读取文档(按照字节流方式读取) 

     使用BufferedReader按照byte读取文档代码如下: 

    public static void readDataWithArray(){

        String path = "D:" + File.separator + "textutf8.txt";

        File file = new File(path);

        try{

            FileInputStream fis = new FileInputStream(file);

              InputStreamReader isr = new InputStreamReader(fis,"utf-8");

            BufferedReader in = new BufferedReader(isr);

            byte[] b = new byte[2048];

            int temp = 0;

            int len = 0;

            

            while((temp=in.read())!=-1){  // -1是结束符

                b[len] = (byte)temp;

                if(len<2047)

                    len++;

                else

                    break;

            }

            in.close();

            System.out.println(new String(b,0,len,"utf-8"));

            

        }catch(Exception e){

            e.printStackTrace();

            System.out.println("While reading the data, the program threw out exceptions");

        }

     

     输出结果发生了乱码: 

    0:W?AW&A

    1:W?AW&A

    2:W?AW&A

    3:W?AW&A

    4:W?AW&A 

     FileInputStream按照byte读取文档代码如下: 

    public static void readDataWithArray(){

        String path = "D:" + File.separator + "textutf8.txt";

        File file = new File(path);

        try{

            FileInputStream in = new FileInputStream(file);

            //InputStreamReader isr = new InputStreamReader(fis,"utf-8");

            //BufferedReader in = new BufferedReader(isr);

            

            byte[] b = new byte[2048];

            int temp = 0;

            int len = 0;

            

            while((temp=in.read())!=-1){  // -1是结束符

                b[len] = (byte)temp;

                if(len<2047)

                    len++;

                else

                    break;

            }

            in.close();

            System.out.println(new String(b,0,len,"utf-8"));

            

        }catch(Exception e){

            e.printStackTrace();

            System.out.println("While reading the data, the program threw out exceptions");

        }

     

     输出结果正常: 

    0:字节流与字符流!!!

    1:字节流与字符流!!!

    2:字节流与字符流!!!

    3:字节流与字符流!!!

    4:字节流与字符流!!! 

     以上两段代码不同之处只是读取文本的流不同,其他代码相同。要回答这个问题,首先来理解一下为什么要编码? 

     为什么要编码 

     不知道大家有没有想过一个问题,那就是为什么要编码?我们能不能不编码?要回答这个问题必须要回到计算机是如何表示我们人类能够理解的符号的,这些符号也就是我们人类使用的语言。由于人类的语言有太多,因而表示这些语言的符号太多,无法用计算机中一个基本的存储单元—— byte 来表示,因而必须要经过拆分或一些翻译工作,才能让计算机能理解。我们可以把计算机能够理解的语言假定为英语,其它语言要能够在计算机中使用必须经过一次翻译,把它翻译成英语。这个翻译的过程就是编码。所以可以想象只要不是说英语的国家要能够使用计算机就必须要经过编码。 所以总的来说,编码的原因可以总结为: 

    计算机中存储信息的最小单元是一个字节即 8 个 bit,所以能表示的字符范围是 0~255 个人类要表示的符号太多,无法用一个字节来完全表示要解决这个矛盾必须需要一个新的数据结构 char,从 char 到 byte 必须编码 

     为什么两者的结果那么不同呢? 

     在Java中byte是1个字节(8个bit),char是2个字节; 最基础的流InputStream和OutputStream是按照字节读取的(byte)。 

    /**

     * Reads a byte of data from this input stream. This method blocks

     * if no input is yet available.

     *

     * @return     the next byte of data, or <code>-1</code> if the end of the

     *             file is reached.

     * @exception  IOException  if an I/O error occurs.

     */

    public int read() throws IOException {

        return read0();

     但是BufferedReader类的read()方法返回的是char。所以没有处理好编码原因的第三个原因。 

    public class BufferedReader extends Reader {

        private char cb[];  // char数组的缓存

        private int nChars, nextChar;

        ...

            /**

         * Reads a single character.

         *

         * @return The character read, as an integer in the range

         *         0 to 65535 (<tt>0x00-0xffff</tt>), or -1 if the

         *         end of the stream has been reached

         * @exception  IOException  If an I/O error occurs

         */

        public int read() throws IOException {

            synchronized (lock) {

                ensureOpen();

                for (;;) {

                    if (nextChar >= nChars) {

                        fill();

                        if (nextChar >= nChars)

                            return -1;

                    }

                    if (skipLF) {

                        skipLF = false;

                        if (cb[nextChar] == '\n') {

                            nextChar++;

                            continue;

                        }

                    }

                    return cb[nextChar++];

                }

            }

        }

        

     举个详细的例子: 按照 ISO-8859-1 编码字符串“I am 君山”用 ISO-8859-1 编码,下面是编码结果:  

     从上图看出7个char 字符经过ISO-8859-1 编码转变成7个byte 数组,ISO-8859-1是单字节编码,中文“君山”被转化成值是3f的byte。3f也就是“?”字符,所以经常会出现中文变成“?”很可能就是错误的使用了 ISO-8859-1这个编码导致的。中文字符经过 ISO-8859-1编码会丢失信息,通常我们称之为“黑洞”,它会把不认识的字符吸收掉。由于现在大部分基础的 Java 框架或系统默认的字符集编码都是 ISO-8859-1,所以很容易出现乱码问题。 

     以上总结只是举例了一个简单的例子,希望能通过这个例子使得你对Java字节流和字符流的区别有个感性的认识。如果需要了解两者的区别,强烈建议大家看看另一篇博客《深入分析 Java 中的中文编码问题》。 

     如果博客写得有什么问题,请各请各位大神指出。

    展开全文
  • 3、字节流处理单元为1个字节,操作字节字节数组。 字符流 1、而字符流在操作的时候会用到缓冲区 2、而字符流只能处理字符或者字符串 3、字符流处理的单元为2个字节的Unicode字符,操作字符、字符数组或字符串, ...
  • 字节流类InputStream 和 OutputStream 类均为抽象类,代表了基本的输入字节流和输出字节流。 Java 中的字符流处理的最基本的单元是 Unicode 代码单元(大小2字节),通常用来处理文本数据。 区别: 字节流操作的...
  • 字节流--传输过程中,传输数据的最基本单位是字节的流。 什么是字符流字符流--传输过程中,传输数据的最基本单位是字符的流。 字符编码方式不同,有时候一个字符使用的字节数也不一样,比如ASCLL方式编码的...
  • 菜鸟举例理解字节流和字符流区别

    千次阅读 2016-10-14 21:01:59
    菜鸟举例理解字节流和字符流区别 按照uft8编码方式存储文档 文档存储路径在D盘下 /** * 按照utf8格式存储文档 */ public static void storeDataByUTF8(){ String path = "D:" + File.separator + "textutf8....
  •  字节流和字符流使用是非常相似的,那么除了操作代码的不同之外,还有哪些不同呢?  字节流在操作的时候本身是不会用到缓冲区(内存)的,是与文件本身直接操作的,而字符流在操作的时候是使用到缓冲区的  字节...
  • 流的概念和作用 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的...字节流和字符流区别: (1)读写单位不同:字节流以字节为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。 (2)处
  • 2.字符流:通过缓冲区来操作文件。 所有的文件在硬盘或在传输时都是以字节的方式进行的,包括图片等都是按字节的方式存储的,而字符是只有在内存中才会形成,所以在开发中,字节流使用较为广泛。 转载于:...
  • 一个字符就是一个字节啊,反正都是ASCII码都是一个字节的,为什么还要分开呢
  • 分为字节流和字符流,字节流又分为字节输入流和字节输出流,字符流又分为字符输入流和字符输出流 输入和输出分别是指的什么? 输入流,指的是将硬盘、键盘中数据输入到内存中。 输出流,指的是将内存中的数据输出...
  • 字节流与和字符流的使用非常相似,两者除了操作代码上...下面以两个写文件的操作为主进行比较,但是在操作时字节流和字符流的操作完成之后都不关闭输出流。范例:使用字节流不关闭执行Java代码 packageorg.lxh.demo1...
  • 字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的字符流在操作时使用了缓冲区,通过缓冲区再操作文件下面以两个写文件的操作为主进行比较,但是在操作时字节流和字符流的操作完成之后都不关闭输出流。...
  • 1、InputStream ReaderInputStream Reader 是所有输入的抽象基类,本身并不能创建实例来执行输入,但它们将成为所有输入的模板,所以它们的方法是所有输入都可使用的方法。在 InputStream 里包含如下三...
  • 字节流和字符流介绍: 字符流:字符流是字节可以读写字符的IO流,字符流读取字符,先读取字节数据,然后转换为字符,想写出字符,把字符转换为字节写出; 字节流:以字节为单位读写数据,又分为字节输入流和字节...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,340
精华内容 936
关键字:

字节流和字符流区别