查看: 4535|回复: 2
应该如何理解字节流和字符流以及他们之间的区别
该用户从未签到
本帖最后由 Dobbie 于
08:41 编辑
在整个IO包中，流的操作就分为两种：
字节流：字节输出流OutputStream，字节输入流InputStream
字符流（一个字符等于两个字节）：字符输出流Writer,字符输入流是Reader
IO操作的基本步骤1，使用File找到一个文件
2，使用字节流和字符流的子类为OutputStream，InputStream，Writer，Reader进行实例化操作
3，进行读或写操作
4，关闭：close()，在流的操作中最终必须进行关闭
在java中&\r\n&表示换行
& &字节流与字符流主要的区别是他们的的处理方式字节流是最基本的，所有的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等
该用户从未签到
本帖最后由 Dobbie 于
08:41 编辑
楼上说的不错，再补充一点：
字节流 FileInputStream FileOutputStream
字符流 FileReader FileWriter&&
& && & 字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点.
& &&&所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列.
& && &字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串； 2. 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以。
字节流转换成字符流可以用 InputSteamReader OutputStreamWriter
一般我们在使用的时候通常用字节流。
该用户从未签到
1楼亮了。。
Beijing Aptech Beida Jade Bird Information Technology Co.,Ltd
北大青鸟IT教育 北京阿博泰克北大青鸟信息技术有限公司 版权所有　　字节流与和字符流的使用非常相似，两者除了操作代码上的不同之外，是否还有其他的不同呢？　　实际上字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件，如图所示。
下面以两个写文件的操作为主进行比较，但是在操作时字节流和字符流的操作完成之后都不关闭输出流。范例：使用字节流不关闭执行
package&org.lxh.demo12.&&&&&
import&java.io.F&&&&&
import&java.io.FileOutputS&&&&&
import&java.io.OutputS&&&&&
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();&&&&&&&&&&&&&&&&&&&
//&此时没有关闭&&&&&
&&&&&&&&}&&&&&
程序运行结果：此时没有关闭字节流操作，但是文件中也依然存在了输出的内容，证明字节流是直接操作文件本身的。而下面继续使用字符流完成，再观察效果。范例：使用字符流不关闭执行
package&org.lxh.demo12.&&&&&
import&java.io.F&&&&&
import&java.io.FileW&&&&&
import&java.io.W&&&&&
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();&&&&&&&&&&&&&&&&&&&&
//&此时没有关闭&&&&&
&&&&}&&&&&
程序运行结果：程序运行后会发现文件中没有任何内容，这是因为字符流操作时使用了缓冲区，而&&&在关闭字符流时会强制性地将缓冲区中的内容进行输出，但是如果程序没有关闭，则缓冲区中的内容是无法输出的，所以得出结论：字符流使用了缓冲区，而字节流没有使用缓冲区。提问：什么叫缓冲区？在很多地方都碰到缓冲区这个名词，那么到底什么是缓冲区？又有什么作用呢？回答：缓冲区可以简单地理解为一段内存区域。可以简单地把缓冲区理解为一段特殊的内存。某些情况下，如果一个程序频繁地操作一个资源（如文件或数据库），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域之中，以后直接从此区域中读取数据即可，因为读取内存速度会比较快，这样可以提升程序的性能。在字符流的操作中，所有的字符都是在内存中形成的，在输出前会将所有的内容暂时保存在内存之中，所以使用了缓冲区暂存数据。如果想在不关闭时也可以将字符流的内容全部输出，则可以使用Writer类中的flush()方法完成。范例：强制性清空缓冲区
package&org.lxh.demo12.&&&&&
import&java.io.F&&&&&
import&java.io.FileW&&&&&
import&java.io.W&&&&&
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();&&&&&&&&&&&&&&&&&
//&此时没有关闭&&&&&
&&&&}&&&&&
程序运行结果：此时，文件中已经存在了内容，更进一步证明内容是保存在缓冲区的。这一点在读者日后的开发中要特别引起注意。提问：使用字节流好还是字符流好？学习完字节流和字符流的基本操作后，已经大概地明白了操作流程的各个区别，那么在开发中是使用字节流好还是字符流好呢？回答：使用字节流更好。在回答之前，先为读者讲解这样的一个概念，所有的文件在硬盘或在传输时都是以字节的方式进行的，包括图片等都是按字节的方式存储的，而字符是只有在内存中才会形成，所以在开发中，字节流使用较为广泛。字节流与字符流主要的区别是他们的的处理方式流分类：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. 什么是流
& & Java中的流是对字节序列的抽象，我们可以想象有一个水管，只不过现在流动在水管中的不再是水，而是字节序列。和水流一样，Java中的流也具有一个&流动的方向&，通常可以从中读入一个字节序列的对象被称为输入流；能够向其写入一个字节序列的对象被称为输出流。
& & Java中的字节流处理的最基本单位为单个字节，它通常用来处理二进制数据。Java中最基本的两个字节流类是InputStream和OutputStream，它们分别代表了组基本的输入字节流和输出字节流。InputStream类与OutputStream类均为抽象类，我们在实际使用中通常使用Java类库中提供的它们的一系列子类。下面我们以InputStream类为例，来介绍下Java中的字节流。
& & InputStream类中定义了一个基本的用于从字节流中读取字节的方法read，这个方法的定义如下：
public abstract int read() throws IOE
& & 这是一个抽象方法，也就是说任何派生自InputStream的输入字节流类都需要实现这一方法，这一方法的功能是从字节流中读取一个字节，若到了末尾则返回-1，否则返回读入的字节。关于这个方法我们需要注意的是，它会一直阻塞知道返回一个读取到的字节或是-1。另外，字节流在默认情况下是不支持缓存的，这意味着每调用一次read方法都会请求操作系统来读取一个字节，这往往会伴随着一次磁盘IO，因此效率会比较低。有的小伙伴可能认为InputStream类中read的以字节数组为参数的重载方法，能够一次读入多个字节而不用频繁的进行磁盘IO。那么究竟是不是这样呢？我们来看一下这个方法的源码：
public int read(byte b[]) throws IOException {
return read(b, 0, b.length);
& & 它调用了另一个版本的read重载方法，那我们就接着往下追：
public int read(byte b[], int off, int len) throws IOException {
if (b == null) {
throw new NullPointerException();
} else if (off & 0 || len & 0 || len & b.length - off) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
int c = read();
if (c == -1) {
return -1;
b[off] = (byte)c;
int i = 1;
for (; i & i++) {
c = read();
if (c == -1) {
b[off + i] = (byte)c;
} catch (IOException ee) {
& & 从以上的代码我们可以看到，实际上read(byte[])方法内部也是通过循环调用read()方法来实现&一次&读入一个字节数组的，因此本质来说这个方法也未使用内存缓冲区。要使用内存缓冲区以提高读取的效率，我们应该使用BufferedInputStream。
& & Java中的字符流处理的最基本的单元是Unicode码元（大小2字节），它通常用来处理文本数据。所谓Unicode码元，也就是一个Unicode代码单元，范围是0x0000~0xFFFF。在以上范围内的每个数字都与一个字符相对应，Java中的String类型默认就把字符以Unicode规则编码而后存储在内存中。然而与存储在内存中不同，存储在磁盘上的数据通常有着各种各样的编码方式。使用不同的编码方式，相同的字符会有不同的二进制表示。实际上字符流是这样工作的：
输出字符流：把要写入文件的字符序列（实际上是Unicode码元序列）转为指定编码方式下的字节序列，然后再写入到文件中；
输入字符流：把要读取的字节序列按指定编码方式解码为相应字符序列（实际上是Unicode码元序列从）从而可以存在内存中。
& & 我们通过一个demo来加深对这一过程的理解，示例代码如下：
import java.io.FileW
import java.io.IOE
public class FileWriterDemo {
public static void main(String[] args) {
FileWriter fileWriter = null;
fileWriter = new FileWriter("demo.txt");
fileWriter.write("demo");
} finally {
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
& & 以上代码中，我们使用FileWriter向demo.txt中写入了&demo&这四个字符，我们用十六进制编辑器WinHex查看下demo.txt的内容：
& & 从上图可以看出，我们写入的&demo&被编码为了&64 65 6D 6F&，但是我们并没有在上面的代码中显式指定编码方式，实际上，在我们没有指定时使用的是操作系统的默认字符编码方式来对我们要写入的字符进行编码。
& & 由于字符流在输出前实际上是要完成Unicode码元序列到相应编码方式的字节序列的转换，所以它会使用内存缓冲区来存放转换后得到的字节序列，等待都转换完毕再一同写入磁盘文件中。
4. 字符流与字节流的区别
& & 经过以上的描述，我们可以知道字节流与字符流之间主要的区别体现在以下几个方面：
字节流操作的基本单元为字节；字符流操作的基本单元为Unicode码元。
字节流默认不使用缓冲区；字符流使用缓冲区。
字节流通常用于处理二进制数据，实际上它可以处理任意类型的数据，但它不支持直接写入或读取Unicode码元；字符流通常处理文本数据，它支持写入及读取Unicode码元。
& & 以上是我对Java中字符流与字节流的一些认识，如有叙述不清晰或是不准确的地方希望大家可以指正，谢谢大家：）
5. 参考资料
& & 《Java核心技术 卷二》
阅读(...) 评论()技术小站：
地点：西安
时间：11月16日 14:00 - 17:00
地点：东莞
时间：11月9日 14:00 - 17:00
地点：深圳
时间：11月8日 13:00 - 17:30
地点：深圳
时间：11月2日 14:00 - 17:00
张飞电子工程师第一部
高速PCB设计指南进阶培训
韦东山linux驱动开发学习
了解RTOS操作系统开发流程
张飞硬件开发全套视频
讲师：孟瑞生
讲师：林超文
讲师：李述铜
讲师：郑振宇
移入鼠标可放大二维码
字符流和字节流有什么那区别
来源：网络整理 作者：日 17:46
[导读] 字符流在Java中，根据处理的数据单位不同，分为字节流和字符流。字符流是由字符组成的，例如 FileReader、FileWriter、BufferedReader、BufferedWriter、InputStreamReader、OutputStreamWriter 等。
　　在Java中，根据处理的数据单位不同，分为字节流和字符流。
　　字符流是由字符组成的，例如 FileReader、FileWriter、BufferedReader、BufferedWriter、InputStreamReader、OutputStreamWriter 等。
　　IT专业名词，不包含边界数据的连续流。
　　字节流是由字节组成的，字符流是由字符组成的。 Java里字符由两个字节组成。字节流是最基本的，所有的InputStream和OutputStream的子类都是，主要用在处理二进制数据，它是按字节来处理的但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的encode来处理，也就是要进行字符集的转化。在从字节流转化为字符流时，实际上就是byte［］转化为String时，public String（byte bytes， String charsetName）有一个关键的参数字符集编码，通常我们都省略了，那系统就用操作系统默认的long
　　流式传输主要指将整个音频和视频及三维媒体等多媒体文件经过特定的压缩方式解析成一个个压缩包，由视频服务器向用户计算机顺序或实时传送。在采用流式传输方式的系统中，用户不必像采用下载方式那样等到整个文件全部下载完毕，而是只需经过几秒或几十秒的启动延时即可在用户的计算机上利用解压设备对压缩的A/V、3D等多媒体文件解压后进行播放和观看。此时多媒体文件的剩余部分将在后台的服务器内继续下载。
　　字符流与字节流的区别
　　1. 什么是流
　　Java中的流是对字节序列的抽象，我们可以想象有一个水管，只不过现在流动在水管中的不再是水，而是字节序列。和水流一样，Java中的流也具有一个&流动的方向&，通常可以从中读入一个字节序列的对象被称为输入流；能够向其写入一个字节序列的对象被称为输出流。
　　2. 字节流
　　Java中的字节流处理的最基本单位为单个字节，它通常用来处理二进制数据。Java中最基本的两个字节流类是InputStream和OutputStream，它们分别代表了组基本的输入字节流和输出字节流。InputStream类与OutputStream类均为抽象类，我们在实际使用中通常使用Java类库中提供的它们的一系列子类。下面我们以InputStream类为例，来介绍下Java中的字节流。
　　InputStream类中定义了一个基本的用于从字节流中读取字节的方法read，这个方法的定义如下：
　　public abstract int read（） throws IOE
　　这是一个抽象方法，也就是说任何派生自InputStream的输入字节流类都需要实现这一方法，这一方法的功能是从字节流中读取一个字节，若到了末尾则返回-1，否则返回读入的字节。关于这个方法我们需要注意的是，它会一直阻塞知道返回一个读取到的字节或是-1。另外，字节流在默认情况下是不支持缓存的，这意味着每调用一次read方法都会请求操作系统来读取一个字节，这往往会伴随着一次磁盘IO，因此效率会比较低。有的小伙伴可能认为InputStream类中read的以字节数组为参数的重载方法，能够一次读入多个字节而不用频繁的进行磁盘IO。那么究竟是不是这样呢？我们来看一下这个方法的源码：
　　public int read（byte b［］） throws IOExcepon {
　　return read（b， 0， b.length）;
　　public int read（byte b［］， int off， int len） throws IOExcepon {
　　if （b == null） {
　　throw new NullPointerExcepon（）;
　　} else if （off 《 0 || len 《 0 || len 》 b.length - off） {
　　throw new IndexOutOfBoundsException（）;
　　} else if （len == 0） {
　　return 0;
　　int c = read（）;
　　if （c == -1） {
　　return -1;
　　b［off］ = （byte）c;
　　int i = 1;
　　for （; i 《 i++） {
　　c = read（）;
　　if （c == -1） {
　　b［off + i］ = （byte）c;
　　} catch （IOException ee） {
　　从以上的代码我们可以看到，实际上read（byte［］）方法内部也是通过循环调用read（）方法来实现&一次&读入一个字节数组的，因此本质来说这个方法也未使用内存缓冲区。要使用内存缓冲区以提高读取的效率，我们应该使用BufferedInputStream。
　　3. 字符流
　　Java中的字符流处理的最基本的单元是Unicode码元（大小2字节），它通常用来处理文本数据。所谓Unicode码元，也就是一个Unicode代码单元，范围是0x0000~0xFFFF。在以上范围内的每个数字都与一个字符相对应，Java中的String类型默认就把字符以Unicode规则编码而后存储在内存中。然而与存储在内存中不同，存储在磁盘上的数据通常有着各种各样的编码方式。使用不同的编码方式，相同的字符会有不同的二进制表示。实际上字符流是这样工作的：
　　输出字符流：把要写入文件的字符序列（实际上是Unicode码元序列）转为指定编码方式下的字节序列，然后再写入到文件中；
　　输入字符流：把要读取的字节序列按指定编码方式解码为相应字符序列（实际上是Unicode码元序列从）从而可以存在内存中。
　　我们通过一个demo来加深对这一过程的理解，示例代码如下：
　　import java.io.FileW
　　import java.io.IOE
　　public class FileWriterDemo {
　　public static void main（String［］ args） {
　　FileWriter fileWriter =
　　fileWriter = new FileWriter（&demo.txt&）;
　　fileWriter.write（&demo&）;
　　} finally {
　　fileWriter.close（）;
　　} catch （IOException e） {
　　e.printStackTrace（）;
　　以上代码中，我们使用FileWriter向demo.txt中写入了&demo&这四个字符，我们用十六进制编辑器WinHex查看下demo.txt的内容：
　　从上图可以看出，我们写入的&demo&被编码为了&64 65 6D 6F&，但是我们并没有在上面的代码中显式指定编码方式，实际上，在我们没有指定时使用的是操作系统的默认字符编码方式来对我们要写入的字符进行编码。
　　由于字符流在输出前实际上是要完成Unicode码元序列到相应编码方式的字节序列的转换，所以它会使用内存缓冲区来存放转换后得到的字节序列，等待都转换完毕再一同写入磁盘文件中。
　　4. 字符流与字节流的区别
　　经过以上的描述，我们可以知道字节流与字符流之间主要的区别体现在以下几个方面：
　　字节流操作的基本单元为字节；字符流操作的基本单元为Unicode码元。
　　字节流默认不使用缓冲区；字符流使用缓冲区。
　　字节流通常用于处理二进制数据，实际上它可以处理任意类型的数据，但它不支持直接写入或读取Unicode码元；字符流通常处理文本数据，它支持写入及读取Unicode码元。
关注电子发烧友微信
有趣有料的资讯及技术干货
下载发烧友APP
打造属于您的人脉电子圈
关注发烧友课堂
锁定最新课程活动及技术直播
声明：电子发烧友网转载作品均尽可能注明出处，该作品所有人的一切权利均不因本站而转移。
作者如不同意转载，既请通知本站予以删除或改正。转载的作品可能在标题或内容上或许有所改动。
字节流相关文章
字节流相关下载
字符流相关文章
字符流相关下载
java相关文章
java相关下载
论坛精华干货
供应链服务
版权所有 (C) 深圳华强聚丰电子科技有限公司
电信与信息服务业务经营许可证：粤B2-先来看一下流的概念：
& & &在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据的时候要使用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。
& & &程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。
字节流与字符流
& & &在java.io包中操作文件内容的主要有两大类：字节流、字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成，输入使的是InputStream，在字符流中输出主要是使用Writer类完成，输入流主要使用Reader类完成。（这四个都是抽象类）
& & &java中提供了专用于输入输出功能的包Java.io,其中包括：&&&& InputStream,OutputStream,Reader,Writer&&&& InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象,&&&& Reader和 Writer.两个是为字符流（一个字符占两个字节）设计的,主要用来处理字符或字符串.
& & &字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点&&&& 所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列
&&&&& 字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串； 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以& & &字节流是最基本的，所有的InputStrem和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的 但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的encode来处理，也就是要进行字符集的转化 这两个之间通过 InputStreamReader,OutputStreamWriter来关联，实际上是通过byte[]和String来关联 在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的 。
& & &字节流和字符流的操作过程：& &
& & &以文件操作为例，主要的操作流程如下：
& & 1&使用File类打开一个文件
& & 2&通过字节流或字符流的子类，指定输出的位置
& & 3&进行读/写操作
& & 4&关闭输入/输出
& & &IO操作属于资源操作，一定要记得关闭&
& & &字节流的操作：
& & &字节流主要是操作byte类型数据，以byte数组为准，主要操作类就是OutputStream、InputStream& & &
& & &字节输出流：OutputStream
　　OutputStream是整个IO包中字节输出流的最大父类，此类的定义如下：
public abstract class OutputStream extends Object implements Closeable,Flushable
　　从以上的定义可以发现，此类是一个抽象类，如果想要使用此类的话，则首先必须通过子类实例化对象，那么如果现在要操作的是一个文件，则可以使用：FileOutputStream类。通过向上转型之后，可以为OutputStream实例化
　　Closeable表示可以关闭的操作，因为程序运行到最后肯定要关闭
　　Flushable：表示刷新，清空内存中的数据
　　FileOutputStream类的构造方法如下：
public FileOutputStream(File file)throws FileNotFoundException
import java.io.F
import java.io.FileOutputS
import java.io.IOE
import java.io.OutputS
public class Test11 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
OutputStream out=new FileOutputStream(f);//如果文件不存在会自动创建
String str="Hello World";
byte[] b=str.getBytes();
out.write(b);//因为是字节流，所以要转化成字节数组进行输出
out.close();
也可以一个字节一个字节进行输出，如下：
import java.io.F
import java.io.FileOutputS
import java.io.IOE
import java.io.OutputS
public class Test11 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
OutputStream out=new FileOutputStream(f);//如果文件不存在会自动创建
String str="Hello World";
byte[] b=str.getBytes();
for(int i=0;i&b.i++){
out.write(b[i]);
out.close();
以上输出只会进行覆盖，如果要追加的话，请看FileOutputStream类的另一个构造方法：
public FileOutputStream(File file,boolean append)throws FileNotFoundException
在构造方法中，如果将append的值设置为true，则表示在文件的末尾追加内容。
import java.io.F
import java.io.FileOutputS
import java.io.IOE
import java.io.OutputS
public class Test11 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
OutputStream out=new FileOutputStream(f,true);//追加内容
String str="\r\nHello World";
byte[] b=str.getBytes();
for(int i=0;i&b.i++){
out.write(b[i]);
out.close();
　　字节输入流：InputStream
　　既然程序可以向文件中写入内容，则就可以通过InputStream从文件中把内容读取进来，首先来看InputStream类的定义：
　　　　　　public&abstract&class&InputStream&extends&Object&implements&Closeable
　　与OutputStream类一样，InputStream本身也是一个抽象类，必须依靠其子类，如果现在是从文件中读取，就用FileInputStream来实现。
　　观察FileInputStream类的构造方法：
　　　　　　public&FileInputStream(File&file)throws&FileNotFoundException
　　读文件：
import java.io.F
import java.io.FileInputS
import java.io.IOE
import java.io.InputS
public class Test12 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
InputStream in=new FileInputStream(f);
byte[] b=new&byte[(int)&f.length()];
//根据文件的大小来定义字节数组的大小int len=in.read(b);
in.close();
System.out.println(new String(b,0,len));
换种方式，一个字节一个字节读入
import java.io.F
import java.io.FileInputS
import java.io.IOE
import java.io.InputS
public class Test14 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
InputStream in=new FileInputStream(f);
byte[] b=new byte[(int) f.length()];
for(int i=0;i&b.i++){
b[i]=(byte) in.read();
in.close();
System.out.println(new String(b));
但以上情况只适合知道输入文件的大小，不知道的话用如下方法：
import java.io.F
import java.io.FileInputS
import java.io.IOE
import java.io.InputS
public class Test15 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
InputStream in=new FileInputStream(f);
byte[] b=new byte[1024];
int temp=0;
int len=0;
while((temp=in.read())!=-1){//-1为文件读完的标志
b[len]=(byte)
in.close();
System.out.println(new String(b,0,len));
　　字符流
　　在程序中一个字符等于两个字节，那么java提供了Reader、Writer两个专门操作字符流的类。
　　字符输出流：Writer
　　Writer本身是一个字符流的输出类，此类的定义如下：
　　　　　public&abstract&class&Writer&extends&Object&implements&Appendable，Closeable，Flushable
　　此类本身也是一个抽象类，如果要使用此类，则肯定要使用其子类，此时如果是向文件中写入内容，所以应该使用FileWriter的子类。
　　FileWriter类的构造方法定义如下：
　　　　　public&FileWriter(File&file)throws&IOException
　　字符流的操作比字节流操作好在一点，就是可以直接输出字符串了，不用再像之前那样进行转换操作了。
　　写文件：
import java.io.F
import java.io.FileW
import java.io.IOE
import java.io.W
public class Test16 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
Writer out=new FileWriter(f);
String str="Hello World";
out.write(str);
out.close();
在默认情况下再次输出会覆盖，追加的方法也是在构造函数上加上追加标记
import java.io.F
import java.io.FileW
import java.io.IOE
import java.io.W
public class Test17 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
Writer out=new FileWriter(f,true);//追加
String str="\r\nHello World";
out.write(str);
out.close();
　　字符输入流：Reader
　　Reader是使用字符的方式从文件中取出数据，Reader类的定义如下：
　　　　public&abstract&class&Reader&extends&Objects&implements&Readable，Closeable
　　Reader本身也是抽象类，如果现在要从文件中读取内容，则可以直接使用FileReader子类。
　　FileReader的构造方法定义如下：
　　　　public&FileReader(File&file)throws&FileNotFoundException
　　以字符数组的形式读取出数据：
import java.io.F
import java.io.FileR
import java.io.IOE
import java.io.R
public class Test18 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
Reader input=new FileReader(f);
char[] c=new char[1024];
int len=input.read(c);
input.close();
System.out.println(new String(c,0,len));
也可以用循环方式，判断是否读到底
import java.io.F
import java.io.FileR
import java.io.IOE
import java.io.R
public class Test19 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
Reader input=new FileReader(f);
char[] c=new char[1024];
int temp=0;
int len=0;
while((temp=input.read())!=-1){
c[len]=(char)
input.close();
System.out.println(new String(c,0,len));
　　字节流与字符流的区别
　　字节流和字符流使用是非常相似的，那么除了操作代码的不同之外，还有哪些不同呢？
　　字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的
　　字节流在操作文件时，即使不关闭资源（close方法），文件也能输出，但是如果字符流不使用close方法的话，则不会输出任何内容，说明字符流用的是缓冲区，并且可以使用flush方法强制进行刷新缓冲区，这时才能在不close的情况下输出内容
　　那开发中究竟用字节流好还是用字符流好呢？
　　在所有的硬盘上保存文件或进行传输的时候都是以字节的方法进行的，包括图片也是按字节完成，而字符是只有在内存中才会形成的，所以使用字节的操作是最多的。
　　如果要java程序实现一个拷贝功能，应该选用字节流进行操作（可能拷贝的是图片），并且采用边读边写的方式（节省内存）。
字节流与字符流的转换
& & &虽然Java支持字节流和字符流，但有时需要在字节流和字符流两者之间转换。InputStreamReader和OutputStreamWriter，这两个为类是字节流和字符流之间相互转换的类。
　　InputSreamReader用于将一个字节流中的字节解码成字符：
　　有两个构造方法：
　　　　InputStreamReader(InputStream in);
　　　　功能：用默认字符集创建一个InputStreamReader对象
　　　　InputStreamReader(InputStream in,String CharsetName);
　　　　功能：接收已指定字符集名的字符串，并用该字符创建对象
　　OutputStream用于将写入的字符编码成字节后写入一个字节流。
　　同样有两个构造方法：
　　　　OutputStreamWriter(OutputStream out);
　　　　功能：用默认字符集创建一个OutputStreamWriter对象；
　　　　OutputStreamWriter(OutputStream out,String &CharSetName);
　　　　功能：接收已指定字符集名的字符串，并用该字符集创建OutputStreamWrite对象
& & & 为了避免频繁的转换字节流和字符流，对以上两个类进行了封装。
　　BufferedWriter类封装了OutputStreamWriter类；
　　BufferedReader类封装了InputStreamReader类；
　　封装格式：
　　BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
　　BufferedReader in= new BufferedReader(new InputStreamReader(System.in);
　　利用下面的语句，可以从控制台读取一行字符串：
　　BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
　　String line=in.readLine();
阅读(...) 评论()}