欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

常用IO流的使用方式

程序员文章站 2024-03-04 21:27:18
...
 常用IO流这里指的是用于对文件的读取操作的IO流,IO流分类两大类,分别是字节流和字符流,字节流相关类用于处理字节相关文件,比如视频、音频、图片、格式化文件等。字符流相关类用于处理字符相关文件,比如.txt之类的文件没有格式的文件。

常用IO流的使用方式
一、常用字符流
Reader:字符输入流,是一个抽象类其子类必须实现read(char[], int, int)和close()方法
BufferedReader:从字符输入流中读取文本,缓冲字符以便提供对字符、数组和行的有效读取。可以指定缓冲区的大小也可以使用默认大小(足够了)
CharArrayReader:源是字符的字符输入流。
StringReader:源是字符串的字符流。
InputStreamReader:字节输入流到字符输入流的桥梁,并使用指定的字符集将字节解码为字符。
可以在BufferedReader中包装一个InputStreamReader来提高字节的读取效率。
构造方法:
InputStreamReader(InputStream in):实用默认字符集创建“字节-字符”对象
InputStreamReader(InputStream in, Charset cs):使用给定的字符继创建“字节-字符”对象
InputStreamReader(InputStream in, CharsetDecoder dec):创建一个使用给定字符集解码器的InputStreamReader。
InputStreamReader(InputStream in, String charsetName):创建一个使用名为charsetName的InputStreamReader。
常用方法:
String getEncoding():返回该流的字符编码名称
int read():读取单一字符。
int read(char[] cbuf, int offset, int length):将字符读入数组的一部分。
boolean ready():是否准备好开始读取字符。
void close():关闭流。
InputStreamReader子类:
FileReader:用来读取字符输入流文件的

Writer:字符输出流
BufferedWriter:文本写入字符输出流,缓冲字符。提供单个字符、数组和字符串的高效写入
CharArrayWriter:字符缓冲输出流,用于写入字符数据。可以用户toCharArray()和toString()方法来检索数据。
OutputStreamWriter:字符输出流到字节输出流的桥梁,用指定的字符集将字符编码成字节。为了达到最高效率,
可以在BufferedWriter中包装一个OutputStreamWriter来提高字符转换成字节的效率。
构造方法:
OutputStreamWriter(OutputStream out):使用默认字符集编码创建OutputStreamWriter
OutputStreamWriter(OutputStream out, Charset cs):使用指定字符集编码创建OutputStreamWriter
OutputStreamWriter(OutputStream out, CharsetEncoder enc):使用指定编码器创建OutputStreamWriter
OutputStreamWriter(OutputStream out, String charsetName):使用命名字符集来创建OutputStreamWriter
常用方法:
void close():在刷新流之前关闭流。
void flush():刷新流
String getEncoding():获取字符集的编码
void write(char[] cbuf, int off, int len):写入字符数组的一部分。
void write(int c):写入单个字符
void write(String str, int off, int len):写入字符串的一部分。
OutputStreamWriter的子类:
FileWriter:用来写入字符输出流到指定文件

二、常用字节流
InputStream:字节输入流
BufferedInputStream:缓存字节输入流,能够对输入流中的字节进行缓冲。提供了标记方法mark()和重置方法reset(),当BufferedInputStream
被创建时内部缓冲区即被创建,默认缓存区大小是8M。
ByteArrayInputStream:以字节数组保存数据,包含一个内部缓冲区,可以从流中读取的字节。内部计数器为read()方法提供需要跟踪的下一个字节。
FileInputStream:从文件系统中获取文件的输入字节流,
OutputStream:字节输出流
BufferedOutputStream:缓冲字节输出流,可以将字节写入底层的输出流。
ByteArrayOutputStream:以字节数组保存数据,缓冲字节输出流,数据被写入一个字节数组,当数据写入时,缓冲区会自动增长。使用toByteArray()和toString()来检索数据。
FileOutputStream:文件输出流,是将字节流写入文件或者文件描述当中

三、常用文件处理流
File:文件和目录路径名的抽象类
FileInputStream:从文件系统中获取文件的输入字节流。
FileReader:用来读取字符输入流文件的
FileOutputStream:文件输出流,是将字节流写入文件或者文件描述当中
FileWriter:用来写入字符输出流到指定文件
Files:最终类,只包含对文件、目录或其他类型文件进行操作的静态方法


BufferedInputStream、BufferedOutputStream、FileInputStream、FileOutputStream的使用代码示例

package com.wangxiaofei.io;
import static org.junit.Assert.*;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import org.junit.Test;
public class BufferedInputStreamTest {
    private static final String FILE_PATH="D:/Workspaces/MyEclipse Professional 2014/JAVASECode/src/com/wangxiaofei/io/";
    @Test
    public void test() throws IOException {
        //声明字节流
        FileInputStream fis=null;
        FileOutputStream fos=null;
        //声明字节缓冲流
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        //声明文件
        File file=null;
        try {
          //读取源文件
          fis=new FileInputStream(FILE_PATH+"Faded.mp3");
          //写入文件
          file=new File(FILE_PATH+"out-faded.mp3");
          if(!file.exists()){
              file.createNewFile();
          }
          fos=new FileOutputStream(file);
          //创建字节输入输出缓冲流对象
          bis=new BufferedInputStream(fis);
          bos=new BufferedOutputStream(fos);
          //每次读取写入字节的大小
          byte[] bys=new byte[1024];
          int len=0;
          try {
            long start=System.currentTimeMillis();
            while((len=bis.read(bys))!=-1){
               bos.write(bys, 0, len);
            }
            long end=System.currentTimeMillis();
            System.out.println("总耗时:"+(end-start));
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            System.out.println("找不到文件");
            e.printStackTrace();
        }finally{
            if(null!=bis) bis.close();
            if(null!=bos) bos.close();
        }   
    }
}

BufferedReader、BufferedWriter、FileReader、FileWriter代码示例如下:

package com.wangxiaofei.io;
import static org.junit.Assert.*;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import org.junit.Test;
public class BufferedWriterTest {
    /**
     * BufferedWriter:字符输出缓冲流,搞效地将字符、字符数组、字符串写入文本
     * 构造方法:
     * BufferedWriter(Writer writer):创建一个字符输出缓冲流,使用默认大小缓冲区。
     * BufferedWriter(Writer writer,int size):创建一个字符输出缓冲流,指定缓冲区的大小。
     * 常用方法:
     * void close():关闭流。
     * void flush():刷新流。
     * void newLine():写入一行分隔符(换行)
     * void write(char[] cbuf, int off, int len):从字符数组写入一部分字符,off-从哪里开始,len-需要几个。
     * void write(int c):写入单个字符。
     * void write(String s, int off, int len):从字符串中写入一部分字符,off-从哪里开始,len-需要几个。
     * @throws IOException 
     */
    //任务1:将字符、字符数组的一部分、字符串的一部分写入test.txt文件中 
    @Test
    public void test1() throws IOException {
        char c='t';
        char[] charArray={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','k','r','s','t','u','v','w','x','y','z'};
        String str="ABCDEFGHIJKLMNOPQRSTUVWSYZ";
        //创建一个文件对象,用于输出。
        File file=new File("D:/Workspaces/MyEclipse Professional 2014/JAVASECode/src/com/wangxiaofei/io/test.txt");
        //判断该文件是否存在,不存在则创建
        if(!file.exists()){
            file.createNewFile();
        }
        //创建文件字符输出流对象
        FileWriter fw=new FileWriter(file);
        //创建字符输出流的缓冲对象
        BufferedWriter bw=new BufferedWriter(fw);
        //将字符、字符数组的一部分、字符串的一部分写入test.txt文件中 
        bw.write(c);
        bw.flush();
        bw.newLine();//换行
        bw.write(charArray, 0, 5);
        bw.flush();
        bw.newLine();//换行
        bw.write(str, 5, 10);
        bw.flush();
        bw.newLine();//换行
        bw.close();
    }

    //任务2:将note.txt的内容写入到test.txt中
    @Test
    public void test2() throws Exception{
      //创建文件对象
      File sourceFile=new File("D:/Workspaces/MyEclipse Professional 2014/JAVASECode/src/com/wangxiaofei/io/note.txt");
      if(!sourceFile.exists()) throw new Exception("源文件不存在");
      //创建字符缓冲输入流
      //BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream(sourceFile)))
      BufferedReader br=new BufferedReader(new FileReader(sourceFile));
      //创建目标文件
      File destinationFile=new File("D:/Workspaces/MyEclipse Professional 2014/JAVASECode/src/com/wangxiaofei/io/test.txt");
      if(!destinationFile.exists()){
          destinationFile.createNewFile();
      }
      //创建字符缓冲输出流
      BufferedWriter bw=new BufferedWriter(new FileWriter(destinationFile));
      String str=null;
      //将源文件的内容写入到目标文件中
      while((str=br.readLine())!=null){
          bw.write(str);
          bw.newLine();
          bw.flush();
      }
      br.close();
      bw.close();
    }
}

ByteArrayInputStream代码示例如下:

package com.wangxiaofei.io;
import static org.junit.Assert.*;
import java.io.ByteArrayInputStream;
import org.junit.Test;
public class ByteArrayInputStreamTest {
    // 对应英文字母“abcddefghijklmnopqrsttuvwxyz”
    private static final byte[] byteArray={
        0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
        0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A
    };
    /**
     * ByteArrayInputStream:字节缓冲输入流
     * @throws Exception 
     */
    @Test
    public void test() throws Exception {
        //创建ByteArrayInputStream对象
        ByteArrayInputStream bais=new ByteArrayInputStream(byteArray);
        //在字节数组流中读取5个字节,并以字符串的形式输出。
        for(int i=0;i<5;i++){
            //是否可读
            if(bais.available()>0){
                System.out.println("第"+i+"个字节:"+(char)bais.read());
            }
        }
        //判断是否有标记功能,没有则上报异常。
        if(!bais.markSupported()) throw new Exception("ByteArrayInputStream标记功能不可用");
        bais.mark(0);
        //跳过5个字节后再往后读取5个字节,以字符的形式输出
        bais.skip(5);
        byte[] temArray=new byte[5];
        bais.read(temArray, 0, 5);//从当前位置开始读取,读取长度为5
        for(byte bys:temArray){
            System.out.print((char)bys+" ");
        }
        System.out.println();
        //重置后输出标记位置上的后5个字节,以字符的形式输出。
        bais.reset();
        bais.read(temArray, 0, 5);
        for(byte bys:temArray){
            System.out.print((char)bys+" ");
        }
    }
}

ByteArrayOutputStream示例代码如下:

package com.wangxiaofei.io;
import static org.junit.Assert.*;
import java.io.ByteArrayOutputStream;
import org.junit.Test;
public class ByteArrayOutputStreamTest {
    @Test
    public void test() {
      ByteArrayOutputStream bios=new ByteArrayOutputStream();
      //写入字节数据
      for(int i=0;i<5;i++){
          bios.write(101+i);
      }
      //转换字节数组
      byte[] bys=bios.toByteArray();
      for(byte b:bys){
          System.out.println((char)b);
      }
    }
}

CharArrayReader代码示例如下:

package com.wangxiaofei.io;
import static org.junit.Assert.*;
import java.io.CharArrayReader;
import java.io.IOException;
import org.junit.Test;
public class CharArrayReaderTest {
    //定义字符数组
    private static final char[] arr={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','k','r','s','t','u','v','w','x','y','z'};
    @Test
    public void test() throws IOException {
        //1、创建字符缓冲输入流
        CharArrayReader car=new CharArrayReader(arr);
        //2、读取5个字符
        for(int i=0;i<5;i++){
            //是否开始读取
            if(car.ready()){
                //是否支持标记功能
              if(!car.markSupported()){
                  return;
              }else{
                  //需要进行强转
                  char temp=(char)car.read();
                  System.out.println("第"+(i+1)+"个字符:"+temp);
              } 
            }
        }
        //3、标记已经读取的位置
        car.mark(0);//下一次读取字符从f字符开始
        //4、跳过5个字符后读取后5个字符的串
        car.skip(5);//下一个字符从K位置开始读
        char[] char5=new char[5];
        car.read(char5, 0, 5);
        //String.valueOf(char[] c):将字符数组转换为字符串值
        System.out.println("继跳过5个字符后读取的字符为:"+String.valueOf(char5));
        //5、重置字符流,到被标记的位置,继续读取5个字符
        car.reset();
        char[] makerlast=new char[5];
        car.read(makerlast, 0, 5);
        System.out.println("从标记开始读5个字符:"+String.valueOf(makerlast));
        //关闭流
        car.close();
    }
}

CharArrayWriter示例代码如下:

package com.wangxiaofei.io;
import java.io.CharArrayWriter;
import java.io.IOException;
import org.junit.Test;
public class CharArrayWriterTest {
    //定义字符数组
    private static final char[] arr={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','k','r','s','t','u','v','w','x','y','z'};
    @Test
    public void test() throws IOException {
      //1、创建字符输出流
      CharArrayWriter caw=new CharArrayWriter();
      //2、写入字符A后写入串AB
      caw.write('A');
      caw.write("AB");
      //3、从arr中读取defgh并写入
      caw.write(arr, 3, 8);
      System.out.println("输出流内容为:"+caw);
      //4、写入字符0后写入123456789
      caw.write("0");
      caw.write("123456789");
      //5、从arr中读取ijkl并写入
      caw.write(arr,8,12);
      System.out.println("输出流内容为:"+caw);
      //6、计算输出流中字符的长度
      int size=caw.size();
      System.out.println("输出流内容长度为:"+size);
      //7、转换成字符数组
      char[] c=caw.toCharArray();
      System.out.println(c[c.length-1]);
      System.out.println("转换后的字符数组:"+String.valueOf(c));
      //8、将该字符输出流写入另一个字符输出流中
      CharArrayWriter caw2=new CharArrayWriter();
      caw.writeTo(caw2);
      System.out.println("caw2的字符流内容:"+caw2);
      //关闭流
      caw.close();
      caw2.close(); 
    }
}