Java学习 之 IO流(字节流、字符流)

/*

字节输出流: OutputStream

OutputStream是抽象类，表示输出字节流的所有类的超类，操作的数据都是字节

    void  close()关闭此输出流并释放与此流有关的所有系统资源

    void flush()刷新此输出流并强制写出所有缓冲的输出字节

    void write(byte[] b) 将b.length个字节从指定的byte数组写入此输出流

    void write(byte[] b , int off , int len)将指定byte数组从偏移量off开始的len个字节写入此输出流

    abstract void write(int b)将指定的字节写入此输出流

FileOutputStream类即文件输出流，用于将数据写入File的输出流

    FileOutputStream(Fille file)创建一个指定File对象表示的文件中写入数据的文件输出流

    FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流

*/

public class FileOutPutStreamDemo{

   public static void main(String[] args){

       //创建存储数据的文件

       File file = new File("c:\a.txt");

       //创建一个用于操作文件的字节输出流对象，一创建就必须明确数据存储的目的地

      //输出流目的是文件，会自动创建。如果文件存在，则覆盖

      FileOutputStream fos = new FileOutputStream(file);

     //调用父类的write方法

     byte[] b = "abcde".getBytes();

     fos.write(b);

     //关闭流资源

    fos.close();

   }

}

/*

文件续写和换行

FileOutputStream(File file , boolean append)创建一个向指定File对象表示的文件中写入数据的文件输出流

FileOutputStream(String name , boolean append)创建一个向指定name的文件中写入数据的文件输出流

*/

public class FileOutputStreamDemo2{

    public static void main(String[] args){

        File file = new File("c:\a.txt");

        FileOutputStream fos = new FileOutputStream(file , true);

        String str = "
" +"ab";

        fos.write(str.getBytes());

        fos.close();

   }

}

/*

IO异常的处理

*/

public class FileOutputStreamDemo3{

    public static void main(String[] args){

     File file = new File("c:\a.txt");

    //定义FileOutputStream的引用

   FileOutputStream fos = null;

   try{

      //创建FileOutputStream对象

     fos = new FileOutputStream(file);

      //写出数据

     fos.write("abc".getBytes());

       }catch(IOException e){

         System.out.println(e.toString() + "------");

       }finally{

         //一定要判断fos是否为null,只有不为null时,才可以关闭资源

        if(fos != null){

            try{

             fos.close();

                }catch(IOException e){

                throw new RuntimeException("");

                }

             }

       }

    }

}

/*

字节输入流:InputStream

InputStream是抽象类，表示字节输入流的所有类的超类

  abstract int read()从输入流中读取数据的下一个字节

  int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中

FileInputStream类即文件输入流

 abstract int read()从输入流中读取数据的下一个字节

*/

public class FileInputStreamDemo{

    public static void main(String[] args){

     File file = new File("c:\a.txt");

    //创建一个字节输入流对象，必须明确数据源，其实就是创建字节读取和数据源相关联

   FileInputStream fis = new FileInputStream(file):

  //读取数据，一次读一个字节

  int ch = 0;

  while((ch = fis.read()) != -1){

    System.out.println( "ch=" + (char)ch);

  }

  //关闭资源

   fis.close();

    }

}

/*

读取数据read(byte[] b)

*/

public class FileInputStreamDemo2{

    public static void main(String[] args){

    File file = new File("c:\a.txt"); 

    //创建一个字节输入流对象，必须明确数据源，其实就是创建字节读取和数据源相关联

    FileInputStream fis = new FileInputStream(file);

   //创建一个字节数组

   byte[] b = new byte[1024];//长度可以定义成1024的整数倍

   int len = 0;

   while((len = fis.read(b)) != -1){

     System.out.println(new String(b , 0 , len));

   }

   fis.close();

   }

}

/*

复制文件: 读取一个已有的数据, 并将这些读到的数据写入到另一个文件中

*/

public class CopyFileTest{

   public static void main(String[] args){

   //明确源和目的

  File srcFile = new File("c:\a.txt");

  File destFile = new File("d:\a,txt");

  //明确字节流 输入流和源相关联,输出流和目的关联

  FileInputStream fis = new FileInputStream(srcFile);

  FileOutputStream fos = new FileOutputStream(destFile);

  //使用输入流的读取方法读取字节,并将字节写入到目的中

 int ch = 0;

 while((ch = fis.read()) != -1){

   fos.write(ch);

 }

 //关闭资源

 fos.close();

 fis.close();

}

}

/*

缓冲区方式复制文件

*/

public class CopyFileByBufferTest{

   public static void main(String[] args){

   //明确源和目的

  File srcFile = new File("c:\a.txt");

  File destFile = new File("d:\a,txt");

  //明确字节流 输入流和源相关联,输出流和目的关联

  FileInputStream fis = new FileInputStream(srcFile);

  FileOutputStream fos = new FileOutputStream(destFile);

 //定义一个缓冲区

byte[] buf = new byte[1024];

 int len = 0;

 while((len = fis.read(b)) != -1){

   fos.write(buf , 0 , len);//将数组中的指定长度的数据写入到输出流中

 }

 //关闭资源

 fos.close();

 fis.close();

}

}

 

/*

字符流:

          字符输入流: Reader,读取字符流的抽象超类

                              int read()读取单个字符

                              int read(char[] cbuf)将字符读入数组

                              FileReader类:

                              FileReader(File file)在给定从中读取数据的File的情况下创建一个新FileReader

                              FileReader(String fileName)在给定从中读取数据的文件名的情况下创建一个新FileReader

*/

//字节流读取字符的问题

public class CharStreamDemo{

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

        //读取文件中的中文

       readCNTest();

       //给文件中写中文

      writeCNTest();

    }

   //读取中文

  public static void readCNTest() throws IOException{

     FileInputStream fis = new FileInputStream("c:\a.txt");

     int ch = 0;

    while((ch = fis.read) != -1){

       System.out.println(ch);

    }

  }

  //写中文

  public static void writeCNTest() throws IOException{

   FileOutputStream fos = new FileOutputStream("c:\a.txt");

    fos.write("你好".getBytes());

     fos.close();

  }

}

//FileReader读取包含中的文件

public class CharStreamDemo2{

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

        //读取文件中的中文

       readCNTest();

       //给文件中写中文

      writeCNTest();

    }

   //读取中文

  public static void readCNTest() throws IOException{

     FileInputStream fis = new FileInputStream("c:\a.txt");

     int ch = 0;

    while((ch = fis.read) != -1){

       //输出的字符对应的编码值

       System.out.println(ch);

       //输出字符本身

      System.out.println((char)ch);

    }

  }

  //写中文

  public static void writeCNTest() throws IOException{

   FileOutputStream fos = new FileOutputStream("c:\a.txt");

    fos.write("你好".getBytes());

     fos.close();

  }

}

/*

字符输出流Writer:写入字符流的抽象超类

                           void write(char[] cbuf)写入字符数组

                           abstract void write(char[] cbuf , int off , int len)写入字符数组的某一部分

                           void write(int c)写入单个字符

                           void write(String str)写入字符串

                           void write(String str , int off , int len)写入字符串的某一部分

FileWriter类:

                    FileWriter(File file)根据给定的File对象构造一个FileWriter对象

                    FileWriter(File file , boolean append)根据给定的File对象构造一个FileWriter对象

                    FileWriter(String fileName)根据给定的文件名构造一个FileWriter对象

                    FileWriter(String fileName , boolean append)根据给定的文件名及指示是否附加写入数据的boolean值来构造FileWriter对象

*/

public class FileWriterDemo{

    public static void main(String[] args){

    FileWriter fw = new FileWriter("c:\a.txt");

    fw.write("你好");

    fw.flush();

   fw.close();  

  }

}

/*

flush()和close()区别:

  abstract void close()关闭流 ,  但要先刷新

  abstract void flush()刷新该流的缓冲

 flush():将流中的缓冲区的数据刷新到目的地中,刷新后, 流还可以继续使用

 close():关闭资源,但在关闭前会将缓冲区中的数据先刷新到目的地,否则丢失数据,然后在关闭流,

             流不可以使用。如果写入数据多，一定要一边写一边刷新,最后一次可以不刷新,由close完成刷新并关闭

*/