IO输入/输出流（二）

前言：

Java中对数据进行持久化操作

字节流：

java中具体到文件中的数据将会使用到输入/输出流

• 1 字节输出流OutputStream的写入
  定义：java.io.OutputStream是抽象类，是所有字节(B,1B=8bit)输出流的超类，作用为从Java程序中写出文件，后面将以其实现类FileOutputStream为例作介绍
  
  

  FileOutputStream类的构造方法.png

public class FileOutputStream Demo{
  public static void main(String[] args){
    
    /*
    *流对象的构造方法，可以创建新文件，如果文件本就存在，则会直接覆盖原有文件！！！
    */

    // 1.创建字节数出流的子类对象（FileOutputStream），绑定数据目的(要生成的文件)
    FileOutputStream fos =  new FileOutputStream("c:\\test.txt");

    // 2.调用流对象的write()方法进行写操作
    fos.write(100);//写入一个字节，输出结果根据ASCII表对应为"d"
    byte[] bytes = {65,66,67,68};
    fos.write(bytes);//写入一个字节数组，输出结果根据ASCII表对应为"ABCD"
    fos.write(bytes,1,2);//写入部分字节，输出结果根据ASCII表对应为"BC"
    fos.write("ABCD".getBytes());//直接写入字符串，利用getBytes()方法，将字符串自动转换为字节数组，输出结果根据ASCII表对应为"ABCD"

    // 3.调用流对象的close()方法释放资源（因为其实质为利用操作系统的读/写流）
    fos.close(); 
    }
}

附ASCII表

ACSII表.jpg

• 2 字节输出流OutputStream的续写及换行

public class FileOutputStream Demo{
  public static void main(String[] args){
    File file = new File("c:\\test.txt");
    FileOutputStream fos =  new FileOutputStream(file,true);//true代表续写
    fos.write("ABCD\r\n".getBytes());//写入一个字节数组，输出结果根据ASCII表对应为"ABCD"
    fos.write("\r\n".getBytes());//"\r\n即为换行符"
    fos.write("EFGH".getBytes());
    fos.close(); 
    
  }
}

• 3 字节输入流InputStream的读取
  定义：java.io.InputStream是抽象类，是所有字节(B,1B=8bit)输入流的超类，作用为从Java程序中写出文件，后面将以其实现类FileInputStream为例作介绍
  
  

  FileInputStream类的构造方法.png.png

public class FileInputStream Demo{
  public static void main(String[] args){
    // 1.创建字节输入流的子类对象（FileInputStream），绑定数据源(要读取的文件)
    FileInputStream fis =  new FileInputStream("c:\\test.txt");//test.txt中内容为"abcde"

    // 2.调用流对象的读取方法进行写操作
    // 2.1 调用read()方法
    int i = fis.read();//read()方法每执行一次只读取一个字节，并会自动读取到下一字节处，读取到文件结尾会返回"-1"，可采用下面的while循环进行字节读取
    int len=0;
    while((len = fis.read()) ! = -1){
      System.out.println((char)len);
    }
    // 2.2调用read(byte[] b)方法
    byte[] b = new byte[2];//数组起到缓冲作用，控制长度可以提高效率
    int len2 = fis.read(b);//读取到的有效的字节数
    System.out.println(new String(b));//输出结果为"ab"
    System.out.println(len2);//输出结果为"2"
    int len2 = fis.read(b);
    System.out.println(new String(b));//输出结果为"cd"
    System.out.println(len2);//输出结果为"2"
    int len2 = fis.read(b);
    System.out.println(new String(b));//输出结果为"ed"
    System.out.println(len2);//输出结果为"1"
    int len2 = fis.read(b);
    System.out.println(new String(b));//输出结果为"ed"
    System.out.println(len2);//输出结果为"-1"
    //可以根据控制byte数组长度，以及判断读取到的有效字节数是否等于数组长度来进行读取，从而提高效率    

    // 3.调用流对象的close()方法释放资源（因为其实质为利用操作系统的读/写流）
    fis.close(); 
    }
}

• 4 利用字节流的文件的复制

public class Copy{
  public static void main(String[] args) {
  /*
  * 此处以直接读取字节数组的形式进行文件复制（效率高）
  */
  
    //定义两个流的对象变量
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try{
      //建立两个流对象，绑定数据源和数据目的
      fis = new FileInputStream("c:\\test.txt");
      fos = new FileOutputStream("d:\\test.txt");
      //读取数组，写入数组
      byte[] bytes = new byte[1024];//定义字节数组，缓冲用
      int len = 0;
      while((len = fis.read(bytes)) != -1){
        fos.write(bytes,0,length);
      }
    }catch(IOException ex){
      System.out.println(ex);
      throws new RuntimeException("文件复制失败");
    }finally{
      try{
        if(fos! = null){
          fos.close();
        }catch(IOException ex){
          throws new RuntimeException("释放fos资源失败");
        }finally{
          try{
            if(fis! = null){
              fis.close();
            }
          }catch(IOException ex){
            throws new RuntimeException("释放fis资源失败");
          }
        }
      }
    }
  }
}

• 5 字符输出流Writer的写入
  定义：java.io.Writer是抽象类，是所有字符输出流的超类，作用为从Java程序中写出文本文件，后面将以其实现类FileWriter为例作介绍

public class WriterDemo{
  public static void main(String[] args){
    FileWriter fw = new FileWriter();
    
    //写一个字符
    fw.write("a");
    fw.flush();//字符输出流写数据的时候，必须调用flush()刷新流的缓冲
    //写一个字符数组
    char[] c = {"a","b","c"};
    fw.write(c);
    fw.flush();
    //写一个字符串
    fw.write("abc");
    fw.flush();

    fw.close();
  }
}

• 6 字符输入流Reader的读取

public class ReaderDemo{
  public static void main(String[] args){
    FileReader fr = new FileReader ("c:\\test.txt");
    int len = 0;
    while((len = fr.read()) != -1){
      System.out.print((char)len);
    }
    fr.close();
  }
}

• 7 利用字符流的文件的复制

public class Copy{
  public static void main(String[] args){
    FileReader fr = null;
    FileWriter fw = null;
    try{
      fr = new FileReader("c:\\test.txt");
      fw = new FileWriter("d:\\test.txt");
      char[] cbuf = new char[1024];
      int len = 0 ;
      while(( len = fr.read(cbuf)) != -1){
        fw.write(cbuf, 0, len);
        fw.flush();
      }     
    }catch(IOException ex){
      System.out.println(ex);
      throw new RuntimeException("复制失败");
    }finally{
      try{
        if(fw!=null)
        fw.close();
      }catch(IOException ex){
        throw new RuntimeException("释放资源失败");
      }finally{
        try{
          if(fr!=null)
          fr.close();
        }catch(IOException ex){
          throw new RuntimeException("释放资源失败");
        }
      }
    }
  }
}