JAVA 字节流和字符流_、文件输入字节流是( )a、fileouputstream-CSDN博客

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

字节流

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

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

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

IO 操作的基本步骤

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

1、使用File 找到一个文件

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

3、进行读或写的操作

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

字节输出流：OutputStream

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

[java]view plaincopyprint? 
   
 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

[java]view plaincopyprint? 
   
 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(); //关闭  
     }  
   
 }  

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

[java]view plaincopyprint? 
   
 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类的构造方法：

[java]view plaincopyprint? 
   
 public FileOuputStream(File file,boolean append) throws FileNotFoundException  

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

[java]view plaincopyprint? 
   
 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 可以读取输入流的内容，那么此类的定义如下：

[java]view plaincopyprint? 
   
 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

[java]view plaincopyprint? 
   
 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()方法一个个的读取数据

[java]view plaincopyprint? 
   
 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类的定义格式：

[java]view plaincopyprint? 
   
 public abstract class Writer  
   
 extends Object  
   
 implements Appendable,Closeable,Flushable

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

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

[java]view plaincopyprint? 
   
 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

[java]view plaincopyprint? 
   
 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类的定义：

[java]view plaincopyprint? 
   
 public abstract class Reader  
   
 extends Object  
   
 implements Readable,Closeable

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

读取的方法：

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

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

[java]view plaincopyprint? 
   
 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();  
   
   }}  

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

[java]view plaincopyprint? 
   
 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 完成

[java]view plaincopyprint? 
   
 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]); //写入数据  
         }  
     }  
   
 }  

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

[java]view plaincopyprint? 
   
 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()。

[java]view plaincopyprint? 
   
 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(); //刷新  
     }  
   
 }  

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

得出这样的一个结论：

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

字节 --> 文件

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

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

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