JavaIO（03）字节流--OutputStream and InputStream

IO概述：

 

IO流用来处理设备之间的数据传输

java对数据的操作是通过流的方式

java用于操作流的对象都在IO包中

流按操作数据分为两种：字节流与字符流（编码表）

流按流向分为：输入流，输出流

 

IO流常用基类

 

java.io包中的流的基本操作主要有：字节流和字符流

 

字节流的抽象基类：

 

InputStream： 进入程序的流

OutputStream：流出程序的流

 

在字节流中输出数据主要使用OutputStream类完成，输入使用的是InputStream类；

 

字符流的抽象基类：

 

Reader：

Writer：

 

在字符流中输出主要是使用Writer类完成，输入主要使用Reader类完成；

 

注：有这四个类派生出来的子类名称都是以期父类名作为子类名的后缀；

如：父类：InputStream -----   子类：FileInputStream

如：父类：Reader      ------  子类：FileReader

 

在java中IO操作主要的操作流程如下：

 

1：使用File类打开一个文件

2：通过字节流或字符流的子类指定要输出的位置；

3：进行读/写操作

4：关闭输入/输出

 

详解字节流--（OutputStream）

 

字节流主要操作byte类型的数据，主要操作类是OutputStream类和InputStream类；

1：字节输出流

根据API文档介绍：

public abstract class OutputStream extends Object implements Closeable, Flushable

发现OutputStream类属于抽象类，要想使用此类，则必须使用子类实例化对象；

 

2：OutputStream类中的常用方法：

将一个字节数据写入数据流：

public abstract void write(int b)throws IOException

将一个byte数组写入数据流：

public void write(byte[] b)throws IOException

将一个指定范围的byte数组写入数据流：

public void write(byte[] b,int off,int len)throws IOException

刷新缓存区：

public void flush()throws IOException

关闭数据流：

public void close()throws IOException

 

3：使用FileOutputStream子类的构造方法：

public FileOutputStream(File file)throws FileNotFoundException

操作时必须接收File类的实例，指明要输出的文件路径；

 

实例01：
需求:向文件中写入字符串
//public byte[] getBytes():使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中;

package cn.itcast03;

/*
 * 将一个字节数据写入数据流：
 * public abstract void write( int b)throws IOException
 * 将一个byte数组写入数据流：
 * public void write(byte[] b)throws IOException
 * 将一个指定范围的byte数组写入数据流：
 * public void write(byte[] b, int off,int len)throws IOException
 * 刷新缓存区：
 * public void flush()throws IOException
 * 关闭数据流：
 * public void close()throws IOException
 */

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class FileOutputStream01 {
     public static void main(String[] args) throws IOException {
           //声明File对象
          File f = new File("a.txt" );

           //通过子类实例化父类对象
          OutputStream out = new FileOutputStream(f);

           //进行写操作

          String s = "I love JAVA";

           byte[] bytes = s.getBytes();

           //将一个byte数组写入数据流：
          out.write(bytes);

           //将一个指定范围的byte数组写入数据流：
          out.write(bytes,1,5);

           //将一个字节数据写入数据流
          out.write( 'b');
          out.close();
     }
}

实例02：
package cn.itcast03;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

//追加新的内容
//public FileOutputStream(String name,boolean append)throws FileNotFoundException
//如果将append的值设置为true,则表示在文件的末尾追加内容；

public class FileOutStream03 {
     public static void main(String[] args) throws IOException {

          File file = new File("b.txt" );

          FileOutputStream fos = new FileOutputStream(file,true );

          String s = "Hello World";
           byte[] bytes = s.getBytes();
           for (int i = 0; i < bytes.length; i++) {
              fos.write(bytes[i]);
          }
          fos.close();

     }

}

　　

详解字节流--（InputStream）

 

查看API文档：

public abstract class InputStream extends Object implements Closeable

 

InputStream类的常用方法：

 

取得出入文件的大小：

public int available()throws IOException

关闭输入流：

public void close()throws IOException

读取一个字节内容，以数字的方式读取（从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1

）

public abstract int read()throws IOException

将内容读到byte数组中，同时返回读入的个数

public int read(byte[] b)throws IOException

实例01：
package cn.itcast04;
/*
 * public abstract int read()throws IOException
 * public int read(byte[] b)throws IOException
 */

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo01 {
     public static void main(String[] args) throws IOException {
/*
//        File f = new File("G:"+File.separator+"JavaTest"+File.separator+"test01.txt ");
          File f = new File("a.txt");
          FileInputStream fis = new FileInputStream(f);

           int b;
          while ((b=fis.read())!=-1) {
              System.out.println((char)b);
          }
          fis.close();
*/
          System. out.println("==============================================" );
          File f = new File("a.txt" );
          FileInputStream fis2 = new FileInputStream(f);
           /*
          //将所有内容读取到数组中
          byte[] bytes =new  byte[1024];
          //用于记录本次读取字节的个数
          fis2.read(bytes);
          fis2.close();
          System.out.println(new String(bytes));
          出现的问题：数组长度是1024，但是读取的数组长度只有17字节，所以会有1007个无用的空间转为字符串；
          修正错误如下：
          */
           /*
           *
          byte[] bytes = new  byte[1024];
           int len ;
          while(( len=fis2.read(bytes))!=-1)
          {
              String s = new String(bytes,0, len);
              System.out.println(s);
          }
          fis2.close();
          出现的问题：以上虽然指定了byte数组的范文，但是程序依然开辟了很多的无用的空间，以上的程序没有从根本上解决问题。
          解决方法：使用File提供的length()方法来取得文件的大小
          */
           byte[] bytes = new byte[( int)f.length()];
           int len;
           //如果len的值不是-1，表示文件没有读完；
           while((len=fis2.read(bytes))!=-1)
          {
              String s = new String(bytes,0,len);
              System. out.println(s);
          }
          fis2.close();
     }
}