69600人阅读
Java基础知识（165）
字节流与和字符流的使用非常相似，两者除了操作代码上的不同之外，是否还有其他的不同呢？
实际上字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件，如图12-6所示。
下面以两个写文件的操作为主进行比较，但是在操作时字节流和字符流的操作完成之后都不关闭输出流。
范例：使用字节流不关闭执行
Java代码 &
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&{&&&&&&&&&&&&File&f&=&new&File(&d:&&+&File.separator&+&&test.txt&);&&&&&&&&&&OutputStream&out&=&null;&&&&&&&&&&&&&&&&&&&out&=&new&FileOutputStream(f);&&&&&&&&&&&&&&&String&str&=&&Hello&World!!!&;&&&&&&&&&&&&&byte&b[]&=&str.getBytes();&&&&&&&&&&&&&&&&&out.write(b);&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}&&&&&&&&}&&&
程序运行结果：
此时没有关闭字节流操作，但是文件中也依然存在了输出的内容，证明字节流是直接操作文件本身的。而下面继续使用字符流完成，再观察效果。
范例：使用字符流不关闭执行
Java代码 &
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&{&&&&&&&&&&&&&&&&&&&&&File&f&=&new&File(&d:&&+&File.separator&+&&test.txt&);&&&&&&&&&&&&&&&&&&&&Writer&out&=&null;&&&&&&&&&&&&&&&&&&&&&&&&&&&out&=&new&FileWriter(f);&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&String&str&=&&Hello&World!!!&;&&&&&&&&&&&&&&&&out.write(str);&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}&&&&}&&&
程序运行结果：
程序运行后会发现文件中没有任何内容，这是因为字符流操作时使用了缓冲区，而&& 在关闭字符流时会强制性地将缓冲区中的内容进行输出，但是如果程序没有关闭，则缓冲区中的内容是无法输出的，所以得出结论：字符流使用了缓冲区，而字节流没有使用缓冲区。
提问：什么叫缓冲区？
在很多地方都碰到缓冲区这个名词，那么到底什么是缓冲区？又有什么作用呢？
回答：缓冲区可以简单地理解为一段内存区域。
可以简单地把缓冲区理解为一段特殊的内存。
某些情况下，如果一个程序频繁地操作一个资源（如文件或数据库），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域之中，以后直接从此区域中读取数据即可，因为读取内存速度会比较快，这样可以提升程序的性能。
在字符流的操作中，所有的字符都是在内存中形成的，在输出前会将所有的内容暂时保存在内存之中，所以使用了缓冲区暂存数据。
如果想在不关闭时也可以将字符流的内容全部输出，则可以使用Writer类中的flush()方法完成。
范例：强制性清空缓冲区
Java代码 &
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&{&&&&&&&&&&&&&&&&&&&&&File&f&=&new&File(&d:&&+&File.separator&+&&test.txt&);&&对象&&&&&&&&&&&&&&&&&&&&&&Writer&out&=&null;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&out&=&new&FileWriter(f);&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&String&str&=&&Hello&World!!!&;&&&&&&&&&&&&&&&&out.write(str);&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&out.flush();&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&}&&&&}&&&
程序运行结果：
此时，文件中已经存在了内容，更进一步证明内容是保存在缓冲区的。这一点在读者日后的开发中要特别引起注意。
提问：使用字节流好还是字符流好？
学习完字节流和字符流的基本操作后，已经大概地明白了操作流程的各个区别，那么在开发中是使用字节流好还是字符流好呢？
回答：使用字节流更好。
在回答之前，先为读者讲解这样的一个概念，所有的文件在硬盘或在传输时都是以字节的方式进行的，包括图片等都是按字节的方式存储的，而字符是只有在内存中才会形成，所以在开发中，字节流使用较为广泛。
字节流与字符流主要的区别是他们的的处理方式
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等
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1022200次
积分：9449
积分：9449
排名：第1496名
原创：42篇
转载：428篇
评论：106条
(1)(1)(3)(2)(1)(3)(8)(2)(2)(3)(2)(4)(16)(6)(1)(4)(5)(7)(3)(1)(1)(5)(5)(2)(1)(21)(5)(19)(30)(1)(4)(11)(8)(25)(4)(10)(65)(40)(43)(6)(10)(3)(18)(7)(30)(21)您所在的位置： &
字节流与字符流的区别（1）
字节流与字符流的区别（1）
清华大学出版社
《Java开发实战经典》第12章Java IO，Java IO操作主要指的是使用Java进行输入、输出操作，Java中的所有操作类都存放在java.io包中，在使用时需要导入此包。本节为大家介绍字节流与字符流的区别。
12.3.3& 字节流与字符流的区别（1）
字节流与和字符流的使用非常相似，两者除了操作代码上的不同之外，是否还有其他的不同呢？
实际上字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件，如图12-6所示。
（点击查看大图）图12-6& 字节流与字符流操作的区别
下面以两个写文件的操作为主进行比较，但是在操作时字节流和字符流的操作完成之后都不关闭输出流。
范例：使用字节流不关闭执行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&{&&&&不处理 &&&&&&&&&&&&&&&&&&File&f&=&new&File("d:"&+&File.separator&+&"test.txt");&&对象 &&&&&&&&&&&&&&&&&&OutputStream&out&=&null;&&&&&&&&&&&&&&&&&&&out&=&new&FileOutputStream(f);&&&&&&&&&&&&&&&&&&&&&&String&str&=&"Hello&World!!!";&&&&&&&&&&&&&byte&b[]&=&str.getBytes();&&&&&&&&&&&&&&&&&out.write(b);&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&} &}&
程序运行结果：
此时没有关闭字节流操作，但是文件中也依然存在了输出的内容，证明字节流是直接操作文件本身的。而下面继续使用字符流完成，再观察效果。
范例：使用字符流不关闭执行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&{&&不处理 &&&&&&&&&&&&&&&&&&File&f&=&new&File("d:"&+&File.separator&+&"test.txt");&对象 &&&&&&&&&&&&&&&&&&Writer&out&=&null;&&&&&&&&&&&&&&&&&&&&&&&&out&=&new&FileWriter(f);&&&&&&&&&&&&&&&&&&&&&&&&&&&&String&str&=&"Hello&World!!!";&&&&&&&&&&&&&out.write(str);&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&} &}&程序运行结果：
【责任编辑： TEL：（010）】&&&&&&
关于&&&&&&的更多文章
TIOBE编程语言排行榜Java以4.5%的差距遥遥领先于第二名，以后使
本书描述了黑客用默默无闻的行动为数字世界照亮了一条道路的故事。
讲师： 15人学习过讲师： 36人学习过讲师： 15人学习过
本书是企业应对不断变化的市场环境、客户期望和新技术
《计算机程序设计艺术》系列是被公认为计算机科学领域
这本高阶教程将通过大量示例帮助你精通Hadoop，掌握Ha
本书虽然是《网管员必读―网络应用》的改版，但它绝不是简单的修改，而是完完全全的重写，内容更实用、更专业。全书共9章，13个
51CTO旗下网站leizhimin 的BLOG
用户名：leizhimin
文章数：725
评论数：2712
注册日期：
阅读量：5863
阅读量：12276
阅读量：383100
阅读量：1074661
51CTO推荐博文
Java IO学习笔记：字节流
字节流是最基本的流，文件的操作、网络数据的传输等等都依赖于字节流。而字符流常常用于读取文本类型的数据或字符串流的操作等等。
关于字节流的API，没什么好说的，看看就知道了。这里挑几个关键点：
一、InputStream的API
1、public int read()
从输入流读取下一个数据字节。返回 0 到 255 范围内的 int 字节值。如果因已到达流末尾而没有可用的字节，则返回值 -1。
2、public int read(byte[] b)
从输入流中读取一定数量的字节并将其存储在缓冲区数组 b 中。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值 -1；否则，至少可以读取一个字节并将其存储在 b 中。此方法等同于read(b, 0, b.length)
3、public int read(byte[] b, int off, int len)
将输入流中最多 len 个数据字节读入字节数组。尝试读取多达 len 字节，但可能读取较少数量。以整数形式返回实际读取的字节数。如果由于已到达流末尾而不再有数据，则返回 -1。
b - 读入数据的缓冲区。
off - 在其处写入数据的数组 b 的初始偏移量。
len - 要读取的最大字节数。
二、OutputStream的API
1、public void write(int b)
将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。
2、public void write(byte[] b)
将 b.length 个字节从指定的字节数组写入此输出流。write(b) 的常规协定是：应该与调用 write(b, 0, b.length) 的效果完全相同。
3、public void write(byte[] b,
&&&&&&&&&&&&&&&&& int off,
&&&&&&&&&&&&&&&&& int len)
将指定字节数组中从偏移量 off 开始的 len 个字节写入此输出流。write(b, off, len) 的常规协定是：将数组 b 中的某些字节按顺序写入输出流；元素 b[off] 是此操作写入的第一个字节，b[off+len-1] 是此操作写入的最后一个字节。
b - 数据。
off - 数据中的初始偏移量。
len - 要写入的字节数。
4、public void flush()
刷新此输出流并强制写出所有缓冲的输出字节。flush 的常规协定是：如果此输出流的实现已经缓冲了以前写入的任何字节，则调用此方法指示应将这些字节立即写入它们预期的目标。
三、几点原则
1、不管是输入还是输出流，使用完毕后要close()，如果是带有缓冲区的输出流，应在关闭前调用flush()。
2、应该尽可能使用缓冲区，来减少IO次数，以提高性能。
3、能用字符流处理的不用字节流。
下面是一个操作字节流的例子：
要操作的文本文件x.txt
白日依山尽，黄河入海流。&&欲穷千里目，更上一层楼。 ―― 王之涣《登鹳雀楼》登
import java.io.*; /** * Created by IntelliJ IDEA. * * @author leizhimin
22:16:44 */ public class TestIOStream { &&&&public static void main(String[] args) { &&&&&&&&testStream(); &&&&&&&&testBufferedStream(); &&&&&&&&testSelectStream(); &&&&} &&&&/** &&&& * 字节流测试 &&&& */ &&&&public static void testStream() { &&&&&&&&InputStream fis = null; &&&&&&&&OutputStream fos = null; &&&&&&&&try { &&&&&&&&&&&&fis = new FileInputStream("C:\\x.txt"); &&&&&&&&&&&&fos = new FileOutputStream("C:\\xcopy.txt"); &&&&&&&&&&&&long num = 0;&&&&//读取字节计数 &&&&&&&&&&&&int bt = 0;&&&&&&//每次读入字节内容 &&&&&&&&&&&&//当读入文件末尾时，读入数据的值为-1 &&&&&&&&&&&&//每次读入一个字节，存放到变量bt中，直到读完整个文件 &&&&&&&&&&&&while ((bt = fis.read()) != -1) { //&&&&&&&&&&&&&&&&System.out.print(bt);&& //以数字的形式逐个输出文件的每个字节 &&&&&&&&&&&&&&&&System.out.print((char) bt);&& //以字母的形式逐个输出文件的每个字节 &&&&&&&&&&&&&&&&fos.write(bt);&&//将字节写入输出流中，实现文件的copy功能 &&&&&&&&&&&&&&&&num++; &&&&&&&&&&&&} &&&&&&&&&&&&System.out.println("读取的字节数为" + num); &&&&&&&&&&&&fis.close(); &&&&&&&&&&&&fos.close(); &&&&&&&&} catch (FileNotFoundException e) { &&&&&&&&&&&&System.out.println("找不到指定的文件！"); &&&&&&&&&&&&e.printStackTrace(); &&&&&&&&} catch (IOException e) { &&&&&&&&&&&&System.out.println("文件读取时发生IO异常！"); &&&&&&&&&&&&e.printStackTrace(); &&&&&&&&} &&&&} &&&&/** &&&& * 缓冲的字节流测试 &&&& */ &&&&public static void testBufferedStream() { &&&&&&&&int buffer = 10; //缓冲大小 &&&&&&&&try { &&&&&&&&&&&&BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\x.txt")); &&&&&&&&&&&&BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\bf2.txt")); &&&&&&&&&&&&int bench = 0; &&&&&&&&&&&&byte bts[] = new byte[buffer];&&&&&&//创建字节流缓存 &&&&&&&&&&&&while ((bis.read(bts)) != -1) { &&&&&&&&&&&&&&&&bos.write(bts);&&//将字节写入输出流中，实现文件的copy功能 &&&&&&&&&&&&&&&&bench++; &&&&&&&&&&&&} &&&&&&&&&&&&System.out.println("bench=" + bench); &&&&&&&&&&&&//将输入流缓冲区中的数据全部写出（千万记住) &&&&&&&&&&&&bos.flush(); &&&&&&&&&&&&bis.close(); &&&&&&&&&&&&bos.close(); &&&&&&&&} catch (FileNotFoundException e) { &&&&&&&&&&&&System.out.println("找不到指定的文件！"); &&&&&&&&&&&&e.printStackTrace(); &&&&&&&&} catch (IOException e) { &&&&&&&&&&&&System.out.println("文件读取时发生IO异常！"); &&&&&&&&&&&&e.printStackTrace(); &&&&&&&&} &&&&} &&&&/** &&&& * 字节流的选择读取测试 &&&& */ &&&&public static void testSelectStream() { &&&&&&&&OutputStream fos = null; &&&&&&&&int buffer = 25; &&&&&&&&try { &&&&&&&&&&&&BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\x.txt")); &&&&&&&&&&&&fos = new FileOutputStream("C:\\testSelectStream.txt"); &&&&&&&&&&&&byte bts[] = new byte[buffer];&&&&&&//创建缓存 &&&&&&&&&&&&//从输入流的第5个字节开始，往后读取10个字节，存放到缓存bts中 &&&&&&&&&&&&//这个方法有个陷阱，缓存buffer的大小最小为“偏移量+要读取字节数”，在次最小应该为15，否则抛IndexOutOfBoundsException异常 &&&&&&&&&&&&bis.read(bts, 5, 10); &&&&&&&&&&&&//将字节写入输出流中，实现文件的copy功能 &&&&&&&&&&&&fos.write(bts); &&&&&&&&&&&&bis.close(); &&&&&&&&&&&&fos.close(); &&&&&&&&} catch (FileNotFoundException e) { &&&&&&&&&&&&System.out.println("找不到指定的文件！"); &&&&&&&&&&&&e.printStackTrace(); &&&&&&&&} catch (IOException e) { &&&&&&&&&&&&System.out.println("文件读取时发生IO异常！"); &&&&&&&&&&&&e.printStackTrace(); &&&&&&&&} &&&&}&}
1、缓冲的功能应该通过相应的缓冲流来包装原始流来实现，而不是自己连续多次数据，最后写到一个数组中，这是很愚昧的做法（但是还有很多人在用）。
2、read(byte[] b, int off, int len)这个方法要好好体会了，往往和你想象的不一样。
3、将读取的一个字节强制转换为char是不合适的，除非你想看看能输出什么。
&本文出自 “” 博客，转载请与作者联系！
了这篇文章
类别：┆阅读(0)┆评论(0)
10:53:50 16:34:07字节流跟字符流在运行的过程中查码表的方式有什么不同 - Java Web开发当前位置:& &&&字节流跟字符流在运行的过程中查码表的方式有什么不字节流跟字符流在运行的过程中查码表的方式有什么不同&&网友分享于：&&浏览：8次字节流和字符流在运行的过程中查码表的方式有什么不同这个学期我们开了JSP课，让我们最头痛的一件事就是中文字符乱码的问题，虽然老师也给讲了，但是本人资质愚钝，依然没懂，希望能有学长指点一二，在这里谢谢了。问题是这个样子：
OutputStream&&out=response.getOutputStream();
&&&&&&&&out1.write("中国".getBytes());
当我用字节流向浏览器输出中文时，居然没有乱码，记得老师说过，servlet&默认指定的字符集是iso8859-1
我用的是IE浏览器，据老师讲，凡是支持中文的浏览器，都支持gb2312,那么，当我向浏览器输出汉字的话，它应该乱码才对，但是没有。我想知道为什么。
&&&&&&&&PrintWriter&out&=&response.getWriter();
out.write("中国");&
当我用字符流向浏览器输出中国时，它果断乱码了，我搞不明白，为什么&字节流不会乱码，而字符流就乱码了。
求大神指教，谢谢了。------最佳解决方案--------------------看看tomcat这段源码
public&ServletOutputStream&getOutputStream()&throws&
stream&=&createOutputStream();///创建response的2进制的输出流
public&PrintWriter&getWriter()&throws&IOException
ResponseStream&newStream&=&(ResponseStream)createOutputStream();////////创建2进制流
OutputStreamWriter&osr&=&new&OutputStreamWriter(newStream,&getCharacterEncoding());
writer&=&new&ResponseWriter(osr,&newStream);///得到response的字符输出流
public&String&getCharacterEncoding()//////response的编码，默认是ISO-8859-1的
if(encoding&==&null)//////////////////////////////////如果没有指定编码
return&"ISO-8859-1";
public&void&setContentType(String&type)；设置response的类型和编码
encoding&=&RequestUtil.parseCharacterEncoding(type);////////得到指定的编码
if(encoding&==&null)
encoding&=&"ISO-8859-1";//////////////////////////如果沒有指定编码方式
contentType&=&type&+&";charset="&+&
"中国"&转编码为iso_8859_1&肯定乱麻------其他解决方案--------------------response.setContentType这个方法应该知道吧,是指定输出类型的，默认是text/html
用java.net.URLEncoder类，这个是html格式网络传输文本数据时编码用的，
text/html就会把程序里需要输出的内容利用java.net.URLEncoder解析html传输时需要的格式，
如果你是用PrintWriter去输出的话，因为你没设定字符编码格式，
所以默认编码格式是iso-8859-1,
那么服务器会用URLEncoder.encode("中国",&"iso-8859-1")
就是以iso-8859-1的格式去编码字符串"中国"，
然后再把编码后的字符串发送给客户端浏览器，客户段浏览器是按照自己的编码格式，
比如是gbk，那么就是URLDecoder.decode(接收的字符串,&"gbk")解码，
那么自然得到的就是??
而"中国".getBytes()这个得到的是一个长度为4的byte数组，
而且是用OutputStream直接发送的，不需要经过服务器编码，直接发送给客户浏览器，
客户浏览器也不需要解码，类似于得到new&String("中国".getBytes(),"gbk")这样的一个字符串，
所以用outputstream输出没有出现乱码情况。
最后，以上过程只是为了理解方便才用URLEncoder和URLDecoder，
http网络传输协议的解码和编码真实过程要复杂很多，并不是这么简单。------其他解决方案--------------------引用:4楼说的对，但是我如果弄不明白，心里会不舒服，再碰到类似的问题心里就慌张不知所措了，还是弄明白的好。
我把上面的代码稍微改一下，
OutputStream&&out=response.getOutputStream();
&&&&&&&&&out1.write("中国".getBytes("utf-8"));
这样改的话肯定乱码了。
我还有一点不明白就是三楼学长……
你这样理解是对的，应该说string.getBytes()，
里面就是按java默认unicode进行编码而获得字节叔祖的。
out.write("中国".getBytes("utf-8"));
这个得到的流是"utf-8"编码格式的字节流，在客户端浏览器是用gbk编码格式来解码的，当然是乱码，
如果你把浏览器编码改成utf-8那么就能正确显示了，
如果还不能理解你可以输出下
System.out.println(Arrays.toString("中国".getBytes("utf-8")));
System.out.println(Arrays.toString("中国".getBytes("gbk")));
System.out.println(Arrays.toString("中国".getBytes()));
你会发现"中国".getBytes()其实和"中国".getBytes("gbk")是相等的。
------其他解决方案--------------------简单的理解就是response.writer是以字符形式输出，需要服务器指定字符格式进行编码后再发送给客户浏览器，
由于服务器默认字符格式是iso-8859-1，而浏览器默认字符格式为gbk，自然得到的是不正确的结果， 共&2&页:
12345678910
12345678910
12345678910 上一篇：下一篇：文章评论相关解决方案 12345678910 Copyright & &&版权所有字节流与字符流的区别详解
我的图书馆
字节流与字符流的区别详解
先来看一下流的概念：
在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据的时候要使用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。
程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。
字节流与字符流
在包中操作文件内容的主要有两大类：字节流、字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用完成，输入使的是，在字符流中输出主要是使用类完成，输入流主要使用类完成。（这四个都是抽象类）
java中提供了专用于输入输出功能的包Java.io,其中包括：
&&&& InputStream,OutputStream,Reader,Writer
&&&& InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象,
&&&& Reader和 Writer.两个是为字符流（一个字符占两个字节）设计的,主要用来处理字符或字符串.
字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点
&&&& 所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列
&&&&& 字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串； 2. 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以
&&&&&& 字节流是最基本的，所有的InputStrem和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的 但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的encode来处理，也就是要进行字符集的转化 这两个之间通过 InputStreamReader,OutputStreamWriter来关联，实际上是通过byte[]和String来关联 在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的
==================我们还可以看到：============
Reader类的read()方法返回类型为int ：作为整数读取的字符（占两个字节共16位），范围在
0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1
inputStream的read()虽然也返回int，但由于此类是面向字节流的，一个字节占8个位，所以返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。因此对于不能用0-255来表示的值就得用字符流来读取！比如说汉字.
在中操作也是有相应步骤的，以文件操作为例，主要的操作流程如下：
1&使用类打开一个文件
2&通过字节流或字符流的子类，指定输出的位置
3&进行读写操作
4&关闭输入输出
IO操作属于资源操作，一定要记得关闭
字节流主要是操作类型数据，以数组为准，主要操作类就是、
字节输出流：
OutputStream是整个包中字节输出流的最大父类，此类的定义如下：
public&abstract&class&OutputStream&extends&Object&implements&Closeable,Flushable
从以上的定义可以发现，此类是一个抽象类，如果想要使用此类的话，则首先必须通过子类实例化对象，那么如果现在要操作的是一个文件，则可以使用：类。通过向上转型之后，可以为实例化
Closeable表示可以关闭的操作，因为程序运行到最后肯定要关闭
Flushable：表示刷新，清空内存中的数据
FileOutputStream类的构造方法如下：
public&FileOutputStream(File&file)throws&FileNotFoundException
1&import&java.io.F
&2&import&java.io.FileOutputS
&3&import&java.io.IOE
&4&import&java.io.OutputS
&6&public&class&Test11&{
&7&&&&&public&static&void&main(String[]&args)&throws&IOException&{
&8&&&&&&&&&File&f&=&new&File("d:"&+&File.separator+"test.txt");
&9&&&&&&&&&OutputStream&out=new&FileOutputStream(f);//如果文件不存在会自动创建
10&&&&&&&&&String&str="Hello&World";
11&&&&&&&&&byte[]&b=str.getBytes();
12&&&&&&&&&out.write(b);//因为是字节流，所以要转化成字节数组进行输出
13&&&&&&&&&out.close();
也可以一个字节一个字节进行输出，如下：
1&import&java.io.F
&2&import&java.io.FileOutputS
&3&import&java.io.IOE
&4&import&java.io.OutputS
&6&public&class&Test11&{
&7&&&&&public&static&void&main(String[]&args)&throws&IOException&{
&8&&&&&&&&&File&f&=&new&File("d:"&+&File.separator+"test.txt");
&9&&&&&&&&&OutputStream&out=new&FileOutputStream(f);//如果文件不存在会自动创建
10&&&&&&&&&String&str="Hello&World";
11&&&&&&&&&byte[]&b=str.getBytes();
12&&&&&&&&&for(int&i=0;i&b.i++){
13&&&&&&&&&&&&&out.write(b[i]);
14&&&&&&&&&}
15&&&&&&&&&out.close();
以上输出只会进行覆盖，如果要追加的话，请看类的另一个构造方法：
public&FileOutputStream(File&file,boolean&append)throws&FileNotFoundException
在构造方法中，如果将的值设置为，则表示在文件的末尾追加内容。
1&import&java.io.F
&2&import&java.io.FileOutputS
&3&import&java.io.IOE
&4&import&java.io.OutputS
&6&public&class&Test11&{
&7&&&&&public&static&void&main(String[]&args)&throws&IOException&{
&8&&&&&&&&&File&f&=&new&File("d:"&+&File.separator+"test.txt");
&9&&&&&&&&&OutputStream&out=new&FileOutputStream(f,true);//追加内容
10&&&&&&&&&String&str="\r\nHello&World";
11&&&&&&&&&byte[]&b=str.getBytes();
12&&&&&&&&&for(int&i=0;i&b.i++){
13&&&&&&&&&&&&&out.write(b[i]);
14&&&&&&&&&}
15&&&&&&&&&out.close();
文件中换行为：
字节输入流：
既然程序可以向文件中写入内容，则就可以通过从文件中把内容读取进来，首先来看类的定义：
public&abstract&class&InputStream&extends&Object&implements&Closeable
与类一样，本身也是一个抽象类，必须依靠其子类，如果现在是从文件中读取，就用来实现。
观察类的构造方法：
public&FileInputStream(File&file)throws&FileNotFoundException
1&import&java.io.F
&2&import&java.io.FileInputS
&3&import&java.io.IOE
&4&import&java.io.InputS
&6&public&class&Test12&{
&7&&&&&public&static&void&main(String[]&args)&throws&IOException&{
&8&&&&&&&&&File&f&=&new&File("d:"&+&File.separator+"test.txt");
&9&&&&&&&&&InputStream&in=new&FileInputStream(f);
10&&&&&&&&&byte[]&b=new&byte[1024];
11&&&&&&&&&int&len=in.read(b);
12&&&&&&&&&in.close();
13&&&&&&&&&System.out.println(new&String(b,0,len));
但以上方法是有问题的，用不用开辟这么大的一个字节数组，明显是浪费嘛，我们可以根据文件的大小来定义字节数组的大小，类中的方法：
1&import&java.io.F
&2&import&java.io.FileInputS
&3&import&java.io.IOE
&4&import&java.io.InputS
&6&public&class&Test13&{
&7&&&&&public&static&void&main(String[]&args)&throws&IOException&{
&8&&&&&&&&&File&f&=&new&File("d:"&+&File.separator+"test.txt");
&9&&&&&&&&&InputStream&in=new&FileInputStream(f);
10&&&&&&&&&byte[]&b=new&byte[(int)&f.length()];
11&&&&&&&&&in.read(b);
12&&&&&&&&&in.close();
13&&&&&&&&&System.out.println(new&String(b));
我们换种方式，一个字节一个字节读入
1&import&java.io.F
&2&import&java.io.FileInputS
&3&import&java.io.IOE
&4&import&java.io.InputS
&6&public&class&Test14&{
&7&&&&&public&static&void&main(String[]&args)&throws&IOException&{
&8&&&&&&&&&File&f&=&new&File("d:"&+&File.separator+"test.txt");
&9&&&&&&&&&InputStream&in=new&FileInputStream(f);
10&&&&&&&&&byte[]&b=new&byte[(int)&f.length()];
11&&&&&&&&&for(int&i=0;i&b.i++){
12&&&&&&&&&&&&&b[i]=(byte)&in.read();
13&&&&&&&&&}
14&&&&&&&&&in.close();
15&&&&&&&&&System.out.println(new&String(b));
但以上情况只适合知道输入文件的大小，不知道的话用如下方法：
1&import&java.io.F
&2&import&java.io.FileInputS
&3&import&java.io.IOE
&4&import&java.io.InputS
&6&public&class&Test15&{
&7&&&&&public&static&void&main(String[]&args)&throws&IOException&{
&8&&&&&&&&&File&f&=&new&File("d:"&+&File.separator+"test.txt");
&9&&&&&&&&&InputStream&in=new&FileInputStream(f);
10&&&&&&&&&byte[]&b=new&byte[1024];
11&&&&&&&&&int&temp=0;
12&&&&&&&&&int&len=0;
13&&&&&&&&&while((temp=in.read())!=-1){//-1为文件读完的标志
14&&&&&&&&&&&&&b[len]=(byte)&
15&&&&&&&&&&&&&len++;
16&&&&&&&&&}
17&&&&&&&&&in.close();
18&&&&&&&&&System.out.println(new&String(b,0,len));
在程序中一个字符等于两个字节，那么提供了、两个专门操作字符流的类。
字符输出流：
Writer本身是一个字符流的输出类，此类的定义如下：
public&abstract&class&Writer&extends&Object&implements&Appendable，，
此类本身也是一个抽象类，如果要使用此类，则肯定要使用其子类，此时如果是向文件中写入内容，所以应该使用的子类。
FileWriter类的构造方法定义如下：
public&FileWriter(File&file)throws&IOException
字符流的操作比字节流操作好在一点，就是可以直接输出字符串了，不用再像之前那样进行转换操作了。
1&import&java.io.F
&2&import&java.io.FileW
&3&import&java.io.IOE
&4&import&java.io.W
&6&public&class&Test16&{
&7&&&&&public&static&void&main(String[]&args)&throws&IOException&{
&8&&&&&&&&&File&f&=&new&File("d:"&+&File.separator+"test.txt");
&9&&&&&&&&&Writer&out=new&FileWriter(f);
10&&&&&&&&&String&str="Hello&World";
11&&&&&&&&&out.write(str);
12&&&&&&&&&out.close();
在默认情况下再次输出会覆盖，追加的方法也是在构造函数上加上追加标记
1&import&java.io.F
&2&import&java.io.FileW
&3&import&java.io.IOE
&4&import&java.io.W
&6&public&class&Test17&{
&7&&&&&public&static&void&main(String[]&args)&throws&IOException&{
&8&&&&&&&&&File&f&=&new&File("d:"&+&File.separator+"test.txt");
&9&&&&&&&&&Writer&out=new&FileWriter(f,true);//追加
10&&&&&&&&&String&str="\r\nHello&World";
11&&&&&&&&&out.write(str);
12&&&&&&&&&out.close();
字符输入流：
Reader是使用字符的方式从文件中取出数据，类的定义如下：
public&abstract&class&Reader&extends&Objects&implements&Readable，
Reader本身也是抽象类，如果现在要从文件中读取内容，则可以直接使用子类。
FileReader的构造方法定义如下：
public&FileReader(File&file)throws&FileNotFoundException
以字符数组的形式读取出数据：
1&import&java.io.F
&2&import&java.io.FileR
&3&import&java.io.IOE
&4&import&java.io.R
&6&public&class&Test18&{
&7&&&&&public&static&void&main(String[]&args)&throws&IOException&{
&8&&&&&&&&&File&f&=&new&File("d:"&+&File.separator+"test.txt");
&9&&&&&&&&&Reader&input=new&FileReader(f);
10&&&&&&&&&char[]&c=new&char[1024];
11&&&&&&&&&int&len=input.read(c);
12&&&&&&&&&input.close();
13&&&&&&&&&System.out.println(new&String(c,0,len));
也可以用循环方式，判断是否读到底：
1&import&java.io.F
&2&import&java.io.FileR
&3&import&java.io.IOE
&4&import&java.io.R
&6&public&class&Test19&{
&7&&&&&public&static&void&main(String[]&args)&throws&IOException&{
&8&&&&&&&&&File&f&=&new&File("d:"&+&File.separator+"test.txt");
&9&&&&&&&&&Reader&input=new&FileReader(f);
10&&&&&&&&&char[]&c=new&char[1024];
11&&&&&&&&&int&temp=0;
12&&&&&&&&&int&len=0;
13&&&&&&&&&while((temp=input.read())!=-1){
14&&&&&&&&&&&&&c[len]=(char)&
15&&&&&&&&&&&&&len++;
16&&&&&&&&&}
17&&&&&&&&&input.close();
18&&&&&&&&&System.out.println(new&String(c,0,len));
字节流与字符流的区别
字节流和字符流使用是非常相似的，那么除了操作代码的不同之外，还有哪些不同呢？
字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的
字节流在操作文件时，即使不关闭资源（方法），文件也能输出，但是如果字符流不使用方法的话，则不会输出任何内容，说明字符流用的是缓冲区，并且可以使用方法强制进行刷新缓冲区，这时才能在不的情况下输出内容
那开发中究竟用字节流好还是用字符流好呢？
在所有的硬盘上保存文件或进行传输的时候都是以字节的方法进行的，包括图片也是按字节完成，而字符是只有在内存中才会形成的，所以使用字节的操作是最多的。
如果要程序实现一个拷贝功能，应该选用字节流进行操作（可能拷贝的是图片），并且采用边读边写的方式（节省内存）。
发表评论：
TA的最新馆藏