JAVA 字节流和字符流

在整个IO 包中，流的操作就分两种

字节流

字节输出流 OutputStream、字节输入流 InputStream

字符流，一个字符 = 两个字节

字符输出流 Writer、字符输入流是 Reader

IO 操作的基本步骤

在java 中使用IO 操作必须按照以下的步骤完成：

1、使用File 找到一个文件

2、使用字节流或字符流的子类为OutputStream、InputStream、Writer、Reader 进行实例化操作

3、进行读或写的操作

4、关闭：close()，在流的操作中最终必须进行关闭。

字节输出流：OutputStream

在java.io 包中 OutputStream 是字节输出流的最大父类

public abstract cla OutputStreamextends Objectimplements Closeable,Flushable

此类是一个抽象类，所以使用时需要依靠子类进行实例化操作

如果此时要完成文件的输出操作，则使用FileOutputStream 为 OutputStream 进行实例化操作。

OutputStream 提供了以下的写入数据方法：

写入全部字节数组： public void write(byte[] b) throws IOException

写入部份字节数组： public void write(byte[] b,int off,int len) throws IOException

定入一个数据： public abstract void wirte(int b) throws IOException

package org.ouputstreamdemo;import java.io.File;import java.io.FileOutputStream;import java.io.OutputStream;public class OutPutStreamDemo01 {/** * @param args */public static void main(String[] args) throws Exception  {// TODO Auto-generated method stubFile file = new File("D:"+File.separator+"demo.txt"); //要操作的文件OutputStream opts = new FileOutputStream(file); //声明字节输出流 通过子类实例化String str = "Hello World"; //要输出的信息                byte b[] = str.getBytes();  //将String变为byte数组                opts.write(b); //写入数据opts.close(); //关闭}}

以上的操作是全部的字节数组内容输出，当然，也可以通过循环一个个的输出

package org.ouputstreamdemo;import java.io.File;import java.io.FileOutputStream;import java.io.OutputStream;public class OutputStreamDemo02 {/** * @param args */public static void main(String[] args) throws Exception {// TODO Auto-generated method stubFile file = new File("D:"+File.separator+"demo.txt"); //要操作的文件OutputStream opts = new FileOutputStream(file); //声明字节输出流 通过子类实例化String str = "Hello World"; //要输出的信息byte b[] = str.getBytes(); 将String变为byte数组for (int i=0;i<b.length;i++){opts.write(b[i]); //写入数据}opts.close(); //关闭}}

但是，以上执行的时候可以发现也会存在一些问题，每次执行完之后，所有的内容将会被新的内容替换。如果希望追加内容，则需要观察FileOutputStream类的构造方法：

public FileOuputStream(File file,boolean append) throws FileNotFoundException

如果将append 的内容设置为true，则表示增加内容

package org.ouputstreamdemo;import java.io.File;import java.io.FileOutputStream;import java.io.OutputStream;public class OutputStreamDemo02 {/** * @param args */public static void main(String[] args) throws Exception {// TODO Auto-generated method stubFile file = new File("D:"+File.separator+"demo.txt"); //要操作的文件OutputStream opts = new FileOutputStream(file,true); //声明字节输出流 通过子类实例化String str = "Hello World\r\n"; //要输出的信息 "\r\n" 表示回车byte b[] = str.getBytes(); 将String变为byte数组for (int i=0;i<b.length;i++){opts.write(b[i]); //写入数据}opts.close(); //关闭}}

字节输入流：InputStream

使用InputStream 可以读取输入流的内容，那么此类的定义如下：

public abstract class InputStreamextends Objectimplements Closeable

此类也属于一个抽象类，那么如果要想使用的话，则肯定还是依靠其子类，如果现在是文件操作则使用是FileInputStream,FileInputStream类的构造方法：

public FileInputStream(File file) throws FileNotFoundException

实例化之后就可以通过如下的方法取得数据：

将内容读入到字节数组之中：public int read(byte[] b) throws IOException

每次读一个数据：public abstract int read() throws IOException

package org.inputstreamdemo;import java.io.File;import java.io.FileInputStream;import java.io.InputStream;public class InputStreamDemo01 {/** * @param args */public static void main(String[] args) throws Exception {// TODO Auto-generated method stubFile file =  new File("D:"+File.separator+"demo.txt"); //要操作的文件InputStream ipts = new FileInputStream(file); //字节输入流 通过子类进行实例化操作byte b[] = new byte[2000]; //开辟空间接收读取的内容int len = ipts.read(b); //将内容读入到byte数组中 System.out.println(new String(b,0,len));//输出内容ipts.close();//关闭}}

以上是一种比较常见的读取形式，但是以上的代码有一个缺点，会受到开辟空间的限制。如果现在想动态的开辟数组的空间，则可以根据文件的大小来决定 。采用read()方法一个个的读取数据

package org.inputstreamdemo;import java.io.File;import java.io.FileInputStream;import java.io.InputStream;public class InputStreamDemo02 {/** * @param args */public static void main(String[] args) throws Exception {// TODO Auto-generated method stubFile file =  new File("D:"+File.separator+"demo.txt"); //要操作的文件InputStream ipts = new FileInputStream(file); //字节输入流 通过子类进行实例化操作byte b[] = new byte[(int)file.length()]; //开辟空间接收读取的内容for (int i=0;i<b.length;i++){b[i] = (byte) ipts.read(); //一个个的读取数据}System.out.println(new String(b)); //输出内容，直接转换ipts.close(); //关闭}}

字符输出流：Writer

Writer 类是在io包中操作字符的最大父类，主要功能是完成字符流的输出。Writer类的定义格式：

public abstract class Writerextends Objectimplements Appendable,Closeable,Flushable

与OutputStream 一样，都属于抽象类，如果要进行文件中的保存，则使用FileWriter

写入操作：public void write(String str) throws IOException，不用再转换

package org.writerdemo;import java.io.File;import java.io.FileWriter;import java.io.Writer;public class WriterDemo01 {/** * @param args */public static void main(String[] args) throws Exception {// TODO Auto-generated method stubFile file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件Writer wt = new FileWriter(file); //声明字符输出流 通过子类实例化String str = "Hello World\r\n"; //要输出的信息wt.write(str);  //写入数据wt.close(); //关闭}}

程序也可以进行内容的追加： public FileWriter(File file,bollean append) throws IOException

package org.writerdemo;import java.io.File;import java.io.FileWriter;import java.io.Writer;public class WriterDemo01 {/** * @param args */public static void main(String[] args) throws Exception {// TODO Auto-generated method stubFile file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件Writer wt = new FileWriter(file,true); //声明字符输出流 通过子类实例化 表示可以追加String str = "Hello World\r\n"; //要输出的信息wt.write(str);  //写入数据wt.close(); //关闭}}

字符输入流：Reader

字符输入流与字节输入流不同的地方在与，使用的是char 数组。Reader类的定义：

public abstract class Readerextends Objectimplements Readable,Closeable

是一个抽象类，要是现在进行文件的读取使用 FileReader

读取的方法：

读取一组字符： public int read(char[] cbuf) throws IOException

读取一个个字符： public int read() throws IOException

package org.readerdemo;import java.io.File;import java.io.FileReader;import java.io.Reader;public class ReaderDemo01 {/** * @param args */public static void main(String[] args) throws Exception {// TODO Auto-generated method stubFile file = new File("D:"+File.separator+"demo.txt"); //要操作的文件Reader rd = new FileReader(file); //字节输入流 通过子类进行实例化操作char str[] = new char[1024]; //开辟空间接收读取的内容int len = rd.read(str); 将内容读入到char 数组中System.out.println(new String(str,0,len)); 输出内容                rd.close();  }}

以上完成了一个字符的输入流，那么当然也可以通过循环的方式，一个个的进行读取的操作

package org.readerdemo;import java.io.File;import java.io.FileReader;import java.io.Reader;public class ReaderDemo01 {/** * @param args */public static void main(String[] args) throws Exception {// TODO Auto-generated method stubFile file = new File("D:"+File.separator+"demo.txt"); //要操作的文件Reader rd = new FileReader(file); //字节输入流 通过子类进行实例化操作char str[] = new char[(int) file.length()]; //开辟空间接收读取的内容for (int i =0;i<str.length;i++){str[i]=(char) rd.read(); //一个个的读取数据}System.out.println(new String(str)); //输出内容，直接转换                rd.close();         }}

字节流与字符流的区别

以上操作的代码有两组，那么实际中应该使用那组更好呢？

为了看清楚区别，下面以一对简单的程序为例，此程序就是向文件中保存内容。

范例：使用OutputStream 完成

package org.ouputstreamdemo;import java.io.File;import java.io.FileOutputStream;import java.io.OutputStream;public class OutputStreamDemo02 {/** * @param args */public static void main(String[] args) throws Exception {// TODO Auto-generated method stubFile file = new File("D:"+File.separator+"demo.txt"); //要操作的文件OutputStream opts = new FileOutputStream(file); //声明字节输出流 通过子类实例化String str = "Hello World"; //要输出的信息byte b[] = str.getBytes(); 将String变为byte数组for (int i=0;i<b.length;i++){opts.write(b[i]); //写入数据}}}

以上的程序执行时没有关闭发现内容可以正常的输出，下面再看字符流

package org.writerdemo;import java.io.File;import java.io.FileWriter;import java.io.Writer;public class WriterDemo01 {/** * @param args */public static void main(String[] args) throws Exception {// TODO Auto-generated method stubFile file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件Writer wt = new FileWriter(file); //声明字符输出流 通过子类实例化String str = "Hello World\r\n"; //要输出的信息wt.write(str);  //写入数据}}

以上的字符流并没有关闭。但是执行之后文件中并不存在内容，意味着没有输出。

但是现在使用Writer 类中的一个访法：flush()。

package org.writerdemo;import java.io.File;import java.io.FileWriter;import java.io.Writer;public class WriterDemo01 {/** * @param args */public static void main(String[] args) throws Exception {// TODO Auto-generated method stubFile file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件Writer wt = new FileWriter(file); //声明字符输出流 通过子类实例化String str = "Hello World\r\n"; //要输出的信息wt.write(str);  //写入数据        wt.flush(); //刷新}}

实际上来讲，最早的操作中，并没有刷新，但是因为使用了关闭，所以表示会强制刷新，刷新的是缓冲区（内存）

得出这样的一个结论：

字节流在操作的时候是直接与文件本身关联，不使用缓冲区

字节 --> 文件

字符流在操作的时候是通过缓冲区与文件操作

字符 --> 缓冲 --> 文件

综合比较来讲，在传输或者在硬盘上保存的内容都是以字节的形式存在的，所以字节流的操作较多，但是在操作中文的时候字符流比较好使