FileReader FileInputStream InputStreamReader BufferedReader 作用与区别

最新推荐文章于 2024-08-26 14:14:00 发布

fishbaby-

最新推荐文章于 2024-08-26 14:14:00 发布

阅读量1.3k

点赞数 4

文章标签： java

本文链接：https://blog.csdn.net/qq_42005540/article/details/113952576

版权

FileReader FileInputStream InputStreamReader BufferedReader 作用与区别

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 plaincopy
import java.io.*;
public class Main {
public static void main(String[] args) {

    try {    
        FileInputStream fis=new FileInputStream("d://desktop//test.txt");    
        int i;    
            
        try {    
            while((i=fis.read()) != -1){    
                System.out.println(i);    
            }    
            /*假設test.txt檔裡頭只有一個文字 "陳" ,且其編碼為 utf8 
             * 輸出 
             *  233 
                153 
                179 
             */   
        } catch (IOException e) {    
            // TODO Auto-generated catch block    
            e.printStackTrace();    
        }    
            
            
    } catch (FileNotFoundException e) {    
        // TODO Auto-generated catch block    
        e.printStackTrace();    
    }    
                
}

}
[java] view plain copy
import java.io.*;
public class Main {
public static void main(String[] args) {

    try {     
        FileInputStream fis=new FileInputStream("d://desktop//test.txt");     
        int i;     
             
        try {     
            while((i=fis.read()) != -1){     
                System.out.println(i);     
            }     
            /*假設test.txt檔裡頭只有一個文字 "陳" ,且其編碼為 utf8   
             * 輸出   
             *  233   
                153   
                179   
             */    
        } catch (IOException e) {     
            // TODO Auto-generated catch block     
            e.printStackTrace();     
        }     
             
             
    } catch (FileNotFoundException e) {     
        // TODO Auto-generated catch block     
        e.printStackTrace();     
    }     
                 
}

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

[java] view plaincopy
import java.io.*;
public class Main {
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {

        FileInputStream fis=new FileInputStream("d://desktop//test.txt");    
        try {    
            InputStreamReader isr=new InputStreamReader(fis,"utf8");    
            int i;    
            while((i=isr.read()) != -1){    
                System.out.println((char)i);  //輸出  陳    
            }    
        } catch (Exception e) {    
            // TODO Auto-generated catch block    
            e.printStackTrace();    
        }                                           
                
}

}
[java] view plain copy
import java.io.*;
public class Main {
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {

        FileInputStream fis=new FileInputStream("d://desktop//test.txt");     
        try {     
            InputStreamReader isr=new InputStreamReader(fis,"utf8");     
            int i;     
            while((i=isr.read()) != -1){     
                System.out.println((char)i);  //輸出  陳     
            }     
        } catch (Exception e) {     
            // TODO Auto-generated catch block     
            e.printStackTrace();     
        }                                            
                 
}

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

[java] view plaincopyprint?
import java.io.*;
public class Main {
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {

        FileInputStream fis=new FileInputStream("d://desktop//test.txt");    
            
        try {    
            InputStreamReader isr=new InputStreamReader(fis,"utf8");                    
            BufferedReader br=new BufferedReader(isr);    
                
            String line;    
            while((line=br.readLine()) != null){    
                System.out.println(line);    
            }    
        } catch (Exception e) {    
            // TODO Auto-generated catch block    
            e.printStackTrace();    
        }                                           
                
}

12.4 转换流–OutputStreamWriter类与InputStreamReader类

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

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

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

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

（点击查看大图）图12-7 转换步骤
从图12-7中可以清楚地发现，不管如何操作，最终全部是以字节的形式保存在文件中。

举报
关注
一键三连

java中FileInputStream与InputStream的available()方法的作用
weixin_39851884的博客
1万+
available()方法如果要从网络中下载文件时，我们知道网络是不稳定的，也就是说网络下载时，read()方法是阻塞的，说明这时我们用inputStream.available()获取不到文件的总大小。此时就需要通过 HttpURLConnection httpconn = (HttpURLConnection)url.openConnection(); httpconn.g

优质评论可以帮助作者获得更高权重
表情包
Java学习之FileInputStream与FileReader的区别
逸凌Time
3987
我们对于文件中数据的操作无非就有两种：读出与写入对于Java来说，对数据的操作有字节流（FileOutputStream、FileInputStream）与字符流（FileWriter、FileReader），这两种方法其实差不多，都是从文件中写入数据或读出数据，他俩的区别就是字节流是以字节为单位进行操作的，而字符流是以字符为单位进行操作的。我们都知道一个英文字母占一个字节，一个中文汉字占…
对java中FileInputStream、BufferInputStream的理解
qq_22847203的博客
8227
在计算机中文件是byte 、byte、byte地存储 FileInputStream在读取文件的时候，就是一个一个byte地读取， DataInputStream则是在FileInputStream的一个轻量级的包装类， BufferInputStream则是自带缓冲区，默认缓冲区大小为8X1024 通俗地讲就是： FileInputStream在读取文件的
File,FileInputStream,FileReader,InputStreamReader,B…
1-18
File file =newFile (“hello.txt”); in=newFileInputStream(file); BufferedReader bufReader=newBufferedReader(newInputStreamReader(in)); …
FileInputStream、InputStreamReader和BufferedReader…
1-27
{ FileInputStream fis=new FileInputStream(“d://desktop//test.txt”); try { InputStreamReader isr=new InputStreamReader(fis,“utf8”); BufferedReader …
InputStream InputStreamReader 输入流读取文件
白得不能再白
5676
package htc; /------------FoolishDoger------------------2017-9-28--------------/ import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.File; import java.io.FileInp
（转）Java 之 FileReader FileInputStream InputStreamReader BufferedReader 作用与区别
weixin_30715523的博客
28
Java 之 FileReader FileInputStream InputStreamReader BufferedReader 作用与区别 ava.io下面有两个抽象类：InputStream和ReaderInputStream是表示字节输入流的所有类的超类Reader是用于读取字符流的抽象类InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。即用…
…BufferReader和InputStreamReader_zlsdgg的博客
2-13
{fileInputStream=newFileInputStream(file);inputStreamReader=newInputStreamReader(fileInputStream);fileOutputStream=newFileOutputStream(newFile("C:\Users\…
IO流缓冲流 FileInputStream、BufferedInputStream、B…
1-20
节点流:无非是一根管道直接钝到数据源上,直接读,直接写文件字节输入流InputStream,字节输出流OutputStream,字符输入流Reader,字符输出流Writer 处理流:包在别的流…
BufferedReader、FileReader、FileInputStream
E01014165的专栏
287
BufferedReader 类 BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，读取一个文本行，从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。一般用法： BufferedReader br = new BufferedReader(new InputStreamRea
java 基础之IO—温故
shameant
61

File类 1 ） File 类介绍 File 类封装了对用户机器的文件系统进行操作的功能。例如，可以用 File 类获得文件上次修改的时间移动，或者对文件进行删除、重命名。换句话说，流类关注的是文件内容，而 File 类关注的是文件在磁盘上的存储。 File 类的主要方法有： getName(),getCanonicalFile(),lastModified(),isDer…
聊聊FileReader文件输入流的二三事_ApolloNing的博客
2-18
客官,小板凳坐好,开始啦!FileReader的构造方法和FileInputStream很相似,都是传入文件路径或者文件对象又或者是文件描述符。根据继承图以及方法,来过一下常用的API吧…
…的快速读取四种方式—小数组+FileInputStream、小…
2-4
//使用BufferedReader流将字节流转为字符流,进行高效读取 try(BufferedReader bufferedReader =newBufferedReader( newInputStreamReader(newFileInputStream("D:\proj…
JAVA基础篇—文件与流
weixin_30871905的博客
99
处理字节流的抽象类 InputStream 是字节输入流的所有类的超类,一般我们使用它的子类,如FileInputStream等. OutputStream是字节输出流的所有类的超类,一般我们使用它的子类,如FileOutputStream等. 2.InputStreamReader OutputStreamWriter 处理字符流的抽象类 InputStreamReader 是…
Java 中 FileReader FileInputStream InputStreamReader BufferedReader之间的区别与作用
qi531621028的博客
2895
转自：http://www.cnblogs.com/lianghui66/p/3303546.html ava.io下面有两个抽象类：InputStream和Reader InputStream是表示字节输入流的所有类的超类 Reader是用于读取字符流的抽象类 InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。即用Reader读取出来的
Java FileReader InputStreamReader类源码解析_weixin…
2-10
publicclassFileReaderextendsInputStreamReader{ publicFileReader(String fileName)throwsFileNotFoundException{ super(newFileInputStream(fileName)); …
BufferedReader、FileReader、FileInputStream的区别
azrael6619的专栏
72
BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，读取分行文本很适合，BufferedReader是针对Reader的，不直接针对文件，也不是只针对文件读取。 FileReader是由java.io.InputStreamReade扩展来的，是针对文件读取的。实际使用时往往用 BufferedR…
Java 笔记（01）之 FileReader FileInputStream InputStreamReader BufferedReader 作用与区别
OMG_C的博客
1694
ava.io下面有两个抽象类：InputStream和Reader InputStream是表示字节输入流的所有类的超类 Reader是用于读取字符流的抽象类 InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。即用Reader读取出来的是char数组或者String ，使用InputStream读取出来的是byte数组。弄清了两个超类的根本区别
Java-FileInputStream、InputStreamReader、StringBuffer，Java读出文件中的数据到控制台输出
HengX的博客
670
FileInputStream fop=new FileInputStream(file); FileInputStream:作用是从文件file中读出byte流到fop中 InputStreamReader reader=new InputStreamReader(fop,“gbk”); InputStreamReader作用是把刚刚从文件中读出的byte流转换为character（字…
Java文件读写操作（FileInputStream、FileReader、BufferedReader）
runnerxin的博客
2175
1.字节流和字符流选择字节流：字节流读取的时候，读到一个字节就返回一个字节；主要用于读取图片，MP3，AVI视频文件。字符流：字符流使用了字节流读到一个或多个字节，如读取中文时，就会一次读取2个字节。只要是处理纯文本数据，就要优先考虑使用字符流。2.处理流和节点流节点流：和操作系统紧密连接的流。该层的与文件输入输出的操作都比较原始，没有进过优化，功能比较单一。（FileReade
File,FileInputStream,FileReader,InputStreamReader,BufferedReader
tanyit的专栏
1091
定义一个字节流： Java代码 FileInputStream fileInputStream = new FileInputStream(“d:/text.txt”); // 定义一个指向D:/TEXT.TXT 的字节流 InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
File,FileInputStream,FileReader,InputStreamReader,BufferedReader
lyq123333321的专栏
498
File,FileInputStream,FileReader,InputStreamReader,BufferedReader 的使… 参考资料：l 《 core java 》 12 章l
Java文件输入FileInputStream BufferedReader
哈哈哈哈哈哈哈哈的博客
70
Java.io下面有两个抽象类：InputStream和ReaderInputStream是表示字节输入流的所有类的超类Reader是用于读取字符流的抽象类 InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。即用Reader读取出来的是char数组或者String，使用InputStream读取出来的是byte数组。 1.FileInputStream从文件系统中的某个文件中获得输入字节。构造方法摘要 FileInputStream(File…
Java 之 FileReader FileInputStream InputStreamReader BufferedReader 作用与区别
cooledi的博客
267
Java 之 FileReader FileInputStream InputStreamReader BufferedReader 作用与区别 ava.io下面有两个抽象类：InputStream和Reader InputStream是表示字节输入流的所有类的超类 Reader是用于读取字符流的抽象类 InputStream提供的是字节流的读取，而非文本读取，这是和Reade