在整个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 OutputStream
- extends Object
- implements 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 stub
- File 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 stub
- File 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 stub
- File 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 InputStream
- extends Object
- implements 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 stub
- File 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 stub
- File 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 Writer
- extends Object
- implements 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 stub
- File 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 stub
- File 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 Reader
- extends Object
- implements 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 stub
- File 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 stub
- File 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 stub
- File 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 stub
- File 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 stub
- File file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件
- Writer wt = new FileWriter(file); //声明字符输出流 通过子类实例化
- String str = "Hello World\r\n"; //要输出的信息
- wt.write(str); //写入数据
- wt.flush(); //刷新
- }
- }
实际上来讲,最早的操作中,并没有刷新,但是因为使用了关闭,所以表示会强制刷新,刷新的是缓冲区(内存)
得出这样的一个结论:
字节流在操作的时候是直接与文件本身关联,不使用缓冲区
字节 --> 文件
字符流在操作的时候是通过缓冲区与文件操作
字符 --> 缓冲 --> 文件
综合比较来讲,在传输或者在硬盘上保存的内容都是以字节的形式存在的,所以字节流的操作较多,但是在操作中文的时候字符流比较好使