Java 笔记（01）之 FileReader FileInputStream InputStreamReader BufferedReader 作用与区别

最新推荐文章于 2024-08-26 14:14:00 发布
最新推荐文章于 2024-08-26 14:14:00 发布
阅读量2.2k 收藏 15
点赞数 3
分类专栏： Java学习线索 文章标签： 字符流 java string class
ava.io下面有两个抽象类：InputStream和Reader
InputStream是表示字节输入流的所有类的超类
Reader是用于读取字符流的抽象类
InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。
即用Reader读取出来的是char数组或者String ，使用InputStream读取出来的是byte数组。
弄清了两个超类的根本区别，再来看他们底下子类的使用，这里只对最常用的几个说明

InputStream 
   | __FileInputStream 


FileInputStream 从文件系统中的某个文件中获得输入字节。
构造方法摘要  
FileInputStream (File  file) 
          通过打开一个到实际文件的连接来创建一个 FileInputStream ，该文件通过文件系统中的 File 对象 file 指定。 
FileInputStream (FileDescriptor  fdObj) 
          通过使用文件描述符 fdObj 创建一个 FileInputStream ，该文件描述符表示到文件系统中某个实际文件的现有连接。 
FileInputStream (String  name) 
          通过打开一个到实际文件的连接来创建一个 FileInputStream ，该文件通过文件系统中的路径名 name 指定。 
 
 
Reader

   |——BufferedReader 
   |___InputStreamReader 
         |__FileReader 


BufferedReader : 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
 
构造方法摘要  
BufferedReader (Reader  in) 
          创建一个使用默认大小输入缓冲区的缓冲字符输入流。 
BufferedReader (Reader  in, int sz) 
          创建一个使用指定大小输入缓冲区的缓冲字符输入流。 
BufferedReader (Java Platform SE 6) 
BufferedReader的最大特点就是缓冲区的设置。通常Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求， 如果没有缓冲，则每次调用 read() 或 readLine() 都会导致从文件中读取字节，并将其转换为字符后返回，而这是极其低效的。  
使用BufferedReader可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。 
因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和InputStreamReader）。例如， 
 BufferedReader in
   = new BufferedReader(new FileReader("foo.in"));
 将缓冲指定文件的输入。 
InputStreamReader (Java Platform SE 6) 
InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。 
 
构造方法摘要  
InputStreamReader (InputStream  in) 
          创建一个使用默认字符集的 InputStreamReader。 
InputStreamReader (InputStream  in, Charset  cs) 
          创建使用给定字符集的 InputStreamReader。 
InputStreamReader (InputStream  in, CharsetDecoder  dec) 
          创建使用给定字符集解码器的 InputStreamReader。 
InputStreamReader (InputStream  in, String  charsetName) 
          创建使用指定字符集的 InputStreamReader。 
 
每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。 
为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader。例如： 
 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
InputStreamReader最大的特点是可以指转换的定编码格式
，这是其他类所不能的，从构造方法就可看出，
这一点在读取中文字符时非常有用

FileReader
1）FileReader类介绍：
InputStreamReader类的子类，所有方法（read（）等）都从父类InputStreamReader中继承而来；
2）与InputStreamReader类的区别：
构造方法摘要  
FileReader (File  file) 
          在给定从中读取数据的 File 的情况下创建一个新 FileReader 。 
FileReader (FileDescriptor  fd) 
          在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader 。 
FileReader (String  fileName) 
          在给定从中读取数据的文件名的情况下创建一个新 FileReader  

该类与它的父类InputStreamReader的主要不同在于构造函数，主要区别也就在于构造函数！
从InputStreamReader的构造函数中看到，参数为InputStream和编码方式，可以看出，
当要指定编码方式时，必须使用InputStreamReader
类；而FileReader构造函数的参数与FileInputStream同，为File对象或表示path的String，可以看出，当要根据File对象或者String读取一个文件时，用FileReader；
我想FileReader子类的作用也就在于这个小分工吧。该类与它的父类InputStreamReader
的主要不同在于构造函数，主要区别也就在于构造函数！
从InputStreamReader
的构造函数中看到，参数为InputStream和编码方式，可以看出，
当要指定编码方式时，必须使用InputStreamReader
类；而FileReader构造函数的参数与FileInputStream
同，为File对象或表示path的String，可以看出，当要根据File对象或者String读取一个文件时，用FileReader；
我想FileReader子类的作用也就在于这个小分工吧。
二 联系与区别 
（1）字符与字节： 
FileInputStream 类以二进制输入/输出，I/O速度快且效率搞，但是它的read（）方法读到的是一个字节（二进制数据），很不利于人们阅读，而且无法直接对文件中的字符进行操作，比如替换，查找（必须以字节形式操作）；
而Reader类弥补了这个缺陷，可以以文本格式输入/输出，非常方便；比如可以使用while((ch = filereader.read())!=-1 )循环来读取文件；可以使用BufferedReader的readLine()方法一行一行的读取文本。
（2）编码
InputStreamReader ，它是字节转换为字符的桥梁。 你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如GBK等。 
FileReader与InputStreamReader 涉及编码转换(指定编码方式或者采用os默认编码)，可能在不同的平台上出现乱码现象！而FileInputStream 以二进制方式处理，不会出现乱码现象. 
因此要指定编码方式时，必须使用InputStreamReader 类，所以说它是字节转换为字符的桥梁；
(3) 缓存区
    BufferReader类用来包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和InputStreamReader）。
（4）规范用法
总结以上内容，得出比较好的规范用法： 
1） File file = new File ("hello.txt"); 
FileInputStream in=new FileInputStream (file); 
2） File file = new File ("hello.txt"); 
FileInputStream in=new FileInputStream (file); 
InputStreamReader inReader=new InputStreamReader (in,"UTF-8"); 
BufferedReader bufReader=new BufferedReader(inReader); 
3） File file = new File ("hello.txt"); 
FileReader fileReader=new FileReader(file); 

BufferedReader bufReader=new BufferedReader(fileReader);


一、BufferedReader类

. 所属类库：

         java.lang.Object  

              java.io.Reader  

                         java.io.BufferedReader

. 基本概念 ：

           public class BufferedReader    extends Reader

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值足够大。

通常， Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader ）。

BufferedReader 流能够读取文本行 , 通过向 BufferedReader 传递一个 Reader 对象, 来创建一个 BufferedReader 对象 , 之所以这样做是因为 FileReader 没有提供读取文本行的功能 .

. Demo ：

通过 Bufferedreader 捕获所输入的语句 ：

import java.io.*;
class BufferedReaderDemo{
  public static void main(String[] args)throws IOException { 
    BufferedReader bufferedReader =new BufferedReader(
        new InputStreamReader(System.in));
 
    System.out.print("请输入一系列文字，可包括空格："); 
    String text =bufferedReader.readLine(); 
    System.out.println("请输入文字："+text);
  } 
}
  
注解：

throws IOException   抛出异常

InputStreamReader 是字节流通向字符流的桥梁

二、InputStreamReader类

InputStreamReader 将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码，如：GBK。 
构造方法 ： 
    InputStreamReader isr = new InputStreamReader(InputStream in);//构造一个默认编码集的InputStreamReader类 
    InputStreamReader isr = new InputStreamReader(InputStream in,String charsetName);//构造一个指定编码集的InputStreamReader类。 
    
    参数 in对象通过 InputStream in = System.in;获得。//读取键盘上的数据。 
    或者 InputStream in = new FileInputStream(String fileName);//读取文件中的数据。可以看出 FileInputStream 为InputStream的子类。 
主要方法 ：int read();//读取单个字符。 
                 int read(char []cbuf);//将读取到的字符存到数组中。返回读取的字符数。

. Demo ：

import java.io.*;
class InputStreamReaderDemo {
  public static void transReadNoBuf() throws IOException {
    /**
     * 没有缓冲区，只能使用read()方法。
     */
    //读取字节流
    //InputStream in = System.in;//读取键盘的输入。
    InputStream in = new FileInputStream("D:\\demo.txt");//读取文件的数据。
    //将字节流向字符流的转换。要启用从字节到字符的有效转换，
    //可以提前从底层流读取更多的字节.
    InputStreamReader isr = new InputStreamReader(in);//读取
    //综合到一句。
    //InputStreamReader isr = new InputStreamReader(
    //new FileInputStream("D:\\demo.txt"));
      
    char []cha = new char[1024];
    int len = isr.read(cha);
    System.out.println(new String(cha,0,len));
    isr.close();

  }
  public static void transReadByBuf() throws IOException {
    /**
     * 使用缓冲区 可以使用缓冲区对象的 read() 和  readLine()方法。
     */
    //读取字节流
    //InputStream in = System.in;//读取键盘上的数据
    InputStream in = new FileInputStream("D:\\demo.txt");//读取文件上的数据。
    //将字节流向字符流的转换。
    InputStreamReader isr = new InputStreamReader(in);//读取
    //创建字符流缓冲区
    BufferedReader bufr = new BufferedReader(isr);//缓冲
    //BufferedReader bufr = new BufferedReader(
    //new InputStreamReader(new FileInputStream("D:\\demo.txt")));可以综合到一句。
      /*int ch =0;
    ch = bufr.read();
    System.out.println((char)ch);
    */
    String line;
    while((line = bufr.readLine())!=null){
      System.out.println(line);
    }
    isr.close();
  }
}

三、InputStreamReader、BufferedReader真实案例（非编码集）

import java.io.*;
class UtilResource {
  private void initializeResource() {
    try {

      //读取文件，并且以utf-8的形式写出去
      BufferedReader bufread;
      String read;
      bufread = new BufferedReader(new InputStreamReader(ResourceHelper
          .getResourceInputStream("pinyin.txt")));
      while ((read = bufread.readLine()) != null) {
        System.out.println(read);
      }
      bufread.close();
    } catch (FileNotFoundException ex) {
      ex.printStackTrace();
    } catch (IOException ex) {
      ex.printStackTrace();
    }
  }
}

注：其中 pinyin.txt 放于项目的根目录下 

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
class ResourceHelper {
  /**
   * @param resourceName
   * @return 
   * @return 
   */
  static BufferedInputStream getResourceInputStream(String resourceName) {
    try {
      return new BufferedInputStream(new FileInputStream(resourceName));
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    return null;
  }
}

.InputStream、OutputStream

处理字节流的抽象类

InputStream 是字节输入流的所有类的超类,一般我们使用它的子类,如FileInputStream等.

OutputStream是字节输出流的所有类的超类,一般我们使用它的子类,如FileOutputStream等.

2.InputStreamReader  OutputStreamWriter

处理字符流的抽象类

InputStreamReader 是字节流通向字符流的桥梁,它将字节流转换为字符流.

OutputStreamWriter是字符流通向字节流的桥梁，它将字符流转换为字节流.

3.BufferedReader BufferedWriter

BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，readLine读取一个文本行，

从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。

BufferedWriter  由Writer 类扩展而来，提供通用的缓冲方式文本写入， newLine使用平台自己的行分隔符，

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

InputStream能从來源处读取一個一個byte,
所以它是最低级的，
例：

[java]  view plain copy
  1. import java.io.*;    
  2. public class Main {    
  3.     public static void main(String[] args) {    
  4.             
  5.         try {    
  6.             FileInputStream fis=new FileInputStream("d://desktop//test.txt");    
  7.             int i;    
  8.                 
  9.             try {    
  10.                 while((i=fis.read()) != -1){    
  11.                     System.out.println(i);    
  12.                 }    
  13.                 /*假設test.txt檔裡頭只有一個文字 "陳" ,且其編碼為 utf8 
  14.                  * 輸出 
  15.                  *  233 
  16.                     153 
  17.                     179 
  18.                  */   
  19.             } catch (IOException e) {    
  20.                 // TODO Auto-generated catch block    
  21.                 e.printStackTrace();    
  22.             }    
  23.                 
  24.                 
  25.         } catch (FileNotFoundException e) {    
  26.             // TODO Auto-generated catch block    
  27.             e.printStackTrace();    
  28.         }    
  29.                     
  30.     }    
  31. }  

[java]  view plain  copy
  1. import java.io.*;     
  2. public class Main {     
  3.     public static void main(String[] args) {     
  4.              
  5.         try {     
  6.             FileInputStream fis=new FileInputStream("d://desktop//test.txt");     
  7.             int i;     
  8.                  
  9.             try {     
  10.                 while((i=fis.read()) != -1){     
  11.                     System.out.println(i);     
  12.                 }     
  13.                 /*假設test.txt檔裡頭只有一個文字 "陳" ,且其編碼為 utf8   
  14.                  * 輸出   
  15.                  *  233   
  16.                     153   
  17.                     179   
  18.                  */    
  19.             } catch (IOException e) {     
  20.                 // TODO Auto-generated catch block     
  21.                 e.printStackTrace();     
  22.             }     
  23.                  
  24.                  
  25.         } catch (FileNotFoundException e) {     
  26.             // TODO Auto-generated catch block     
  27.             e.printStackTrace();     
  28.         }     
  29.                      
  30.     }     
  31. }   

InputStreamReader
InputStreamReader封裝了InputStream在里头,
它以较高级的方式,一次读取一个一个字符,
下例是假设有一个编码为utf8的文档,
其內容只有一个中文字 "陳"

[java]  view plain copy
  1. import java.io.*;    
  2. public class Main {    
  3.     public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {    
  4.                     
  5.             FileInputStream fis=new FileInputStream("d://desktop//test.txt");    
  6.             try {    
  7.                 InputStreamReader isr=new InputStreamReader(fis,"utf8");    
  8.                 int i;    
  9.                 while((i=isr.read()) != -1){    
  10.                     System.out.println((char)i);  //輸出  陳    
  11.                 }    
  12.             } catch (Exception e) {    
  13.                 // TODO Auto-generated catch block    
  14.                 e.printStackTrace();    
  15.             }                                           
  16.                     
  17.     }    
  18. }   

[java]  view plain  copy
  1. import java.io.*;     
  2. public class Main {     
  3.     public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {     
  4.                      
  5.             FileInputStream fis=new FileInputStream("d://desktop//test.txt");     
  6.             try {     
  7.                 InputStreamReader isr=new InputStreamReader(fis,"utf8");     
  8.                 int i;     
  9.                 while((i=isr.read()) != -1){     
  10.                     System.out.println((char)i);  //輸出  陳     
  11.                 }     
  12.             } catch (Exception e) {     
  13.                 // TODO Auto-generated catch block     
  14.                 e.printStackTrace();     
  15.             }                                            
  16.                      
  17.     }     
  18. }    

BufferedReader
BufferedReader则是比InputStreamReader更高级,
它封裝了StreamReader类,
一次读取取一行的字符

[java]  view plain copy print ?
  1. import java.io.*;    
  2. public class Main {    
  3.     public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {    
  4.                     
  5.             FileInputStream fis=new FileInputStream("d://desktop//test.txt");    
  6.                 
  7.             try {    
  8.                 InputStreamReader isr=new InputStreamReader(fis,"utf8");                    
  9.                 BufferedReader br=new BufferedReader(isr);    
  10.                     
  11.                 String line;    
  12.                 while((line=br.readLine()) != null){    
  13.                     System.out.println(line);    
  14.                 }    
  15.             } catch (Exception e) {    
  16.                 // TODO Auto-generated catch block    
  17.                 e.printStackTrace();    
  18.             }                                           
  19.                     
  20.     }    
  21. }   

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

12.4  转换流--OutputStreamWriter类与InputStreamReader类

整个IO包实际上分为字节流和字符流，但是除了这两个流之外，还存在一组字节流-字符流的转换类。

OutputStreamWriter：是Writer的子类，将输出的字符流变为字节流，即将一个字符流的输出对象变为字节流输出对象。

InputStreamReader：是Reader的子类，将输入的字节流变为字符流，即将一个字节流的输入对象变为字符流的输入对象。

如果以文件操作为例，则内存中的字符数据需要通过OutputStreamWriter变为字节流才能保存在文件中，读取时需要将读入的字节流通过InputStreamReader变为字符流，转换步骤如图12-7所示。

 

（点击查看大图）图12-7  转换步骤

从图12-7中可以清楚地发现，不管如何操作，最终全部是以字节的形式保存在文件中。



chenzxapple
关注
专栏目录
InputStreamReader & FileReader
weixin_41908066的博客
04-28 466
public static void main(String[] args) throws IOException { //可以设置编码解码 InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\test\\11\\12.txt"), "gbk"); OutputStreamWriter osw = new OutputStreamWriter(new Fi...
FileIO文件读写相关知识， FileInputStream、InputStreamReader和BufferedReader几种读取文件的区别
cmq591117730的博客
09-08 1024
InputStream、OutputStream 处理字节流的抽象类 InputStream 是字节输入流的所有类的超类,一般我们使用它的子类,如FileInputStream等. OutputStream是字节输出流的所有类的超类,一般我们使用它的子类,如FileOutputStream等. 2.InputStreamReader OutputStreamWriter 处理字符...
JAVA基础篇—文件与流
weixin_30871905的博客
08-19 305
处理字节流的抽象类 InputStream 是字节输入流的所有类的超类,一般我们使用它的子类,如FileInputStream等. OutputStream是字节输出流的所有类的超类,一般我们使用它的子类,如FileOutputStream等. 2.InputStreamReader OutputStreamWriter 处理字符流的抽象类 InputStreamReader 是...
InputStreamReader 和FileReader的区别
iteye_13151的博客
08-07 207
InputStreamReader 和 BufferedReader 。其中最重要的类是 InputStreamReader ，它是字节转换为字符的桥 梁。 你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如 GBK 等。   FileReader 与 InputStreamReader 涉及编码转换 ( 指定编码方式或者采用 os 默认编码 ) ，可 ...
FileReader FileInputStream InputStreamReader BufferedReader 作用与区别
lduzft
01-25 343
转自https://blog.csdn.net/liudsl/article/details/79701774 ava.io下面有两个抽象类：InputStream和Reader InputStream是表示字节输入流的所有类的超类 Reader是用于读取字符流的抽象类 InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。 即用Reader读取出来的是cha...
十七、BufferReader类和FileReader类同时用
qq_41995845的博客
07-31 181
package fileInOut; import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class FileReaderBufferReader { public static void main(String[] args) throws IOException { // TODO
InputStreamReader和BufferedReader用法及实例讲解
09-03
InputStreamReader和BufferedReader是Java IO库中的两个重要类，它们在处理字符输入流时发挥着关键作用。本文将深入解析这两个类的用法，并通过实例来帮助理解它们的工作原理。 一、BufferedReader类 ...
FileInputStream InputStreamReader
08-19
- *2* [Java 之 FileReader FileInputStream InputStreamReader BufferedReader 作用与区别](https://blog.csdn.net/qq_35203425/article/details/84893708)[target="_blank" data-report-click={"spm":"1018.2226....
InputStreamReader 和FileReader的区别及InputStream和Reader的区别
09-03
InputStreamReader 和FileReader都是Java中用于读取输入流的类，但它们在处理数据的方式上存在显著差异。InputStreamReader属于Reader类的子类，主要用于处理字符流，它充当字节流（如InputStream）与字符流之间的...
File类、FileInputStream类、FileOutputStream类、FileReader类、BufferedReader类、FileWriter类和BufferedWriter类详解
weixin_64618449的博客
08-03 975
数据类型和处理字节数据，适合处理二进制文件。FileReader和FileWriter处理字符数据，适合处理文本文件。功能和提供基本的字节级读写操作。FileReader和FileWriter提供字符级的读写操作，并且可以处理字符编码。效率使用缓冲流（如和）可以显著提高读写效率，减少对文件系统的访问次数，特别是在处理大文件时更为明显。异常处理在使用这些类进行文件操作时，都需要注意异常处理和资源释放，特别是在文件操作完成后，要调用close()方法关闭流，避免资源泄漏。
关于BufferedReader 和FileReader
iteye_6812的博客
10-17 353
FileReader是用来读文件的类，而BufferReader是将IO流转换为Buffer以提高程序的处理速度。FileInputStream是进Socket通讯时会用到很多，如将文件流是Stream的方式传向服务器！ BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，读取分行文本很适合，BufferedReader是针...
FileInputStream、FileReader、FileWriter 、File
最新发布
xjdkxnhcoskxbco的博客
08-26 122
其中，FileInputStream、FileReader 和 FileWriter 是用于数据流的处理，而 File 主要用于表示和操作文件路径。File：表示文件或目录的路径，提供操作文件和目录的功能，但不直接用于读取或写入数据。FileInputStream：用于读取文件中的字节数据，适用于处理二进制数据。FileReader：用于读取文件中的字符数据，适合处理文本数据。FileWriter：用于将字符数据写入文件。
FileInputStream及FileReader
tangshuai96的博客
02-12 1007
FileInputStream及Filereader 一些方法： abstract int read() 从输入流读取数据的下一个字节。 int read(byte[] b) 从输入流读取一些字节数，并将它们存储到缓冲区 b void close() 关闭此输入流并释放与流相关联的任何系统资源。 public class FileInputStream extends InputStreamA F...
Java IO流操作(FileReader、BufferedReader)
热门推荐
qq_36511401的博客
10-24 1万+
一、FileReader 1、介绍。 FileReader类从InputStreamReader类继承而来。该类按字符读取流中数据。可以通过以下几种构造方法创建需要的对象：1、在给定从中读取数据的 File 的情况下创建一个新 FileReader，FileReader(File file)。2、在给定从中读取数据的 FileDescriptor 的情况下创建一个新 Fi...
Java 对文件的I/O操作
changlj321的专栏
06-10 924
java.io下面有两个抽象类：InputStream和ReaderInputStream是表示字节输入流的所有类的超类Reader是用于读取字符流的抽象类InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。即用Reader读取出来的是char数组或者String ，使用InputStream读取出来的是byte数组。弄清了两个超类的根本区别，再来看他们底下子
BufferedReader-FileReader-FileInputStream
晴天下的大头娃娃
11-28 347
BufferedReader   由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，读取分行文本很适合，BufferedReader是    针对Reader的，不直接针对文件，也不是只针对文件读取。     FileReader是由java.io.InputStreamReade扩展来的，是针对文件读取的。     实际使用时往往用 Buffe
InputStream和Reader，FileInputStream和 FileReader的区别
weixin_30445169的博客
10-18 542
一、InputStream和Reader的区别 InputStream和Reader都可以用来读数据(从文件中读取数据或从Socket中读取数据)，最主要的区别如下:InputStream用来读取二进制数(字节流)，而Reader用来读取文本数据，即Unicode字符。那么二进制数与文本数据有什么区别呢?从本质上来讲，所有读取的内容都是字节，要想把字节转换为文本，需要指定一个编码方法。而...
Java学习之FileInputStream与FileReader的区别
逸凌Time
08-27 7131
我们对于文件中数据的操作无非就有两种：读出与写入 对于Java来说，对数据的操作有字节流（FileOutputStream、FileInputStream）与字符流（FileWriter、FileReader），这两种方法其实差不多，都是从文件中写入数据或读出数据，他俩的区别就是字节流是以字节为单位进行操作的，而字符流是以字符为单位进行操作的。 我们都知道一个英文字母占一个字节，一个中文汉字占...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值