7、I/O流

一、流的概念：流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。I/O就即用于处理设备之间的数据传输。

　　1、流的分类：

　　　　a）、按操作数据单位分类：字节流、字符流。

　　　　b）、按流向分类：输入流、输出流。

　　　　c）、按照功能分类：节点流、处理流。

　　

　　　　字节流的抽象基类：InputStream、OutputStream
　　　　字符流的抽象基类：Reader、Writer

二、字符流：Reader、Writer

　　1、FileWriter：

 public class IOTest {
 
     /**
      * 需求：往一个文本文件里写入一些字符、字符串
      * 1、创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。而且该文件会被创建到指定目录下，如果该目录下已有同名文件，将被覆盖。
      * 2、调用write方法，将字符串写入到流(内存)中
      * 3、调用flush方法刷新缓冲中的数据，将数据刷到目的地中
      * 4、close方法：关闭流资源，但是关闭之前会刷新一次内存中的缓冲数据，将数据刷新到目的地中
      *
      * 注意：close和flush的区别：flush刷新后流可以继续使用;close刷新后会关闭流
      */
     public static void main(String[] args) {
         Writer writer = null;
         try{
             /* true:代表打开已存在的文件。如果指定的文件不存在，就会创建新的文件
              *     如果指定的文件已存在，不会创建新的文件，会在原有数据的基础上追加新的数据*/
             writer = new FileWriter("E:\\qqq.txt", true);
             writer.append('a'); //将指定字符添加到此 writer
             writer.append("123qwerewqr");//将指定字符序列添加到此 writer。
             writer.append("--abcdesafd", 0, 4);// 包含头，不包含尾 将指定字符序列的子序列添加到此 writer.Appendable  即将"--abcdesafd"的第0-3位上的字符添加到write上
             char[] ch = new char[]{'A', 'Q', 'W', 'T'};
             writer.write(ch);//写入数组
             writer.write(ch, 1, 2);//写入数组的一部分
             writer.write("adsfkwe\r\n字符流写入示例");// 记事本里要换行使用\r\n
 
             writer.flush();// 调用flush方法刷新缓冲中的数据，将数据刷到目的地中
 
         }catch(Exception e){
             e.printStackTrace();
         }finally{
             try {
                 if(writer != null){
                     writer.close();// 在关闭流资源之前，会先调用flush方法，然后再关闭
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }
 }
 
 运行后可在相应的txt文件中看到下面的类容：
 
 a123qwerewqr--abAQWTQWadsfkwe
 字符流写入示例

　　2、FileRead：

　　　　a）、一个一个的读：

 public class IOTest {
     /**
      * 1、创建一个fileReader对象，和指定的文件想关联，要保证文件已经存在，如果不存在会报FileNotFoundException错误
      * 2、调用读取流的read方法，一次读一个字节，并且会自动往下读。
      * 3、调用close方法关闭资源
      */
 
     public static void main(String[] args) {
         try {
             FileReader fr = new FileReader("E://qqq.txt");
             System.out.println((char)fr.read()); //这个地方一定要加强转，否则显示的将是ASCLL码的值
             //读取文件中所有的字符
             while(fr.ready()){  //如果保证下一个 read() 不阻塞输入
                 System.out.print((char)fr.read());
             }
             fr.close();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

　　　　b）、用数组来一次性提取文件中的类容：

public class IOTest {
    /**
     * 1、创建一个fileReader对象，和指定的文件想关联，要保证文件已经存在，如果不存在会报FileNotFoundException错误
     * 2、调用读取流的read方法，一次读一个字节，并且会自动往下读。
     * 3、调用close方法关闭资源
     */
 
    public static void main(String[] args) {
        try {
            FileReader fr = new FileReader("E://qqq.txt");
            char[] buff = new char[4];
            int num1 = fr.read(buff);// 将字符读入至buff数组里，返回的是读取的字符数
            System.out.println(num1 + "\t" + String.valueOf(buff));
 
            int num2 = fr.read(buff);
            System.out.println(num2 + "\t" + String.valueOf(buff));
            fr.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 
/*
显示结果为：
4    a123
4    qwer
*/

三、字符流的缓冲区：缓冲区提高了流的操作效率。但必须注意在创建缓冲区之前必须要先有流的对象。

　　1、BufferedWriter

 public class IOTest {
     public static void main(String[] args) {
         FileWriter fw = null;
         BufferedWriter bw = null;
         try {
             fw = new FileWriter("E:\\qqq.txt");// 创建一个字符流的输出对象
             bw = new BufferedWriter(fw);// 创建一个缓冲区字符流，将字符流对象作为参数传递给构造方法
             bw.write("asdflkj;l123123");// 通过 write方法将内容写入缓冲区里
             bw.write("asdflkj;l123123");
             bw.newLine();//写入一个行分隔符。
             bw.write("asflkj;l123123");
             bw.newLine();
             bw.write("asdflkj;l123123");
             bw.flush();// 通过flush方法将缓冲区里的内容写入至目标文件里
 
         } catch (Exception e) {
             e.printStackTrace();
         } finally{
             try{
                 if(bw != null){
                     bw.close();// 会关闭与之相关的字符流对象
                 }
             }catch(Exception e){
                 e.printStackTrace();
             }
         }
     }
     /*
      在qqq.txt文件中输出结果为：
      asdflkj;l123123asdflkj;l123123
      asflkj;l123123
      asdflkj;l123123
      * */
 }

　　2、BufferedReader

 public class IOTest {
     public static void main(String[] args) {
         FileReader fr = null;
         BufferedReader br = null;
         try {
             // 创建一个字符输入流对象
             fr = new FileReader("E:\\qqq.txt");
             // 创建一个缓冲字符输入流，将字符输入流对象作为参数传递给构造方法
             br = new BufferedReader(fr);
             String str = "";
             while((str = br.readLine()) != null){ //readLine():读取一个文本行
                 System.out.println(str);
             }
         }catch (Exception e) {
             e.printStackTrace();
         } finally{
             try{
                 if(br != null){
                     br.close();// 关闭与之相关的字符流
                 }
             }catch(Exception e){
                 e.printStackTrace();
             }
         }
     }
 }

四、字节流：InputStream、OutputStream

　　1、FileInputStream

 public class IOTest {
     /**
      * 读取a.jpg这幅图片中的数据在后台显示
      */
     public static void main(String[] args) {
         FileInputStream fis = null;
         try{
             fis = new FileInputStream("E:\\a.jpg");
             byte[] buff = new byte[1024];
             int len = 0;
             while((len = fis.read(buff)) != -1){
                 for(int i = 0; i < len; i++){
                     System.out.print(buff[i]);
                 }
                 System.out.println();
             }
 
         }catch(Exception e){
             e.printStackTrace();
         }finally{
             try{
                 if(fis != null){
                     fis.close();
                 }
             }catch(Exception e){
                 e.printStackTrace();
             }
         }
     }
 }

　　2、FileOutputStream

 public class IOTest {
     /*
      * 向qqq.txt文件中写入一个一组数据
      */
     public static void main(String[] args) {
         FileOutputStream fos = null;
         try{
             fos = new FileOutputStream("E:\\qqq.txt");
             byte[] b1 = new byte[]{122, 97, 99, 65, 90};
             fos.write(b1);// 通过write方法写入一个字节数组
         }catch(Exception e){
             e.printStackTrace();
         }finally{
             try{
                 if(fos != null){
                     fos.close();
                 }
             }catch(Exception e){
                 e.printStackTrace();
             }
         }
     }
 }

　　3、通过字节流及字节流缓冲区复制一个图片

 public class IOTest {
     /*将E盘中的a.jpg图片复制为b.jpg
      *
      */
     public static void main(String[] args) {
         FileInputStream fis = null;
         FileOutputStream fos = null;
         try{
             fis = new FileInputStream("E:\\b.jpg");
             fos = new FileOutputStream("E:\\c.jpg");
             byte[] buff = new byte[1024];
             int len = 0;
             while((len = fis.read(buff)) != -1){
                 for(int i = 0; i < len; i++){
                     fos.write(buff[i]);
                 }
             }
         }catch(Exception e){
             e.printStackTrace();
         }finally{
             try{
                 if(fis != null)fis.close();
             }catch(Exception e){e.printStackTrace();}
             try{
                 if(fos != null)fos.close();
             }catch(Exception e){e.printStackTrace();}
         }
     }
 }

五、读取键盘录入：

 public class IOTest {
     /*
      * 读取键盘值
      */
     public static void main(String[] args) throws IOException {
         //获取到读取键盘录入的流对象。类型是InputStream
         InputStream is = System.in;
         while(true){
             int num1 = is.read();// 返回的是一个ASCLL码的值
             System.out.println((char)num1);
         }
 
     }
 }

六、File：将文件或者文件夹封装成对象，方便对文件与文件夹的属性信息进行操作。separator：与系统有关的默认名称分隔符。

　　1、对文件的一些常见操作的举例：

 public class IOTest {
 
     public static void main(String[] args) throws IOException {
         /*
          * 实验的空目录或者说是起始目录为E:\\99
          */
         File file = new File("E:\\99\\a.txt");
         File file1 = new File("E:\\99\\aa");
         File file2 = new File("E:\\99\\bb\\cc");
         File file3 = new File("E:\\99\\qqq.txt");
         /*
          * 创建文件或这是一个文件夹
          */
         //创建一个"a.txt"文件，创建成功则返回true
         System.out.println("createNewFile():" + file.createNewFile());
         //创建一个名字为"aa"的文件夹
         System.out.println("createNewFile():" + file1.mkdir());
         // 创建多级目录即在E:\\99目录下先创建一个bb文件夹，再在bb文件夹下新建一个cc文件夹
         System.out.println("mkdirs():" + file2.mkdirs());
 
         /*
          * 删除一个文件或者删除一个文件夹
          */
         System.out.println("delete():" + file.delete());
         System.out.println("delete():" + file1.delete());
         System.out.println("delete():" + file2.delete());
         /*
          * 判断
          */
         //测试此抽象路径名表示的文件或目录是否存在
         System.out.println("exists()：" + file.exists());
         //测试此抽象路径名表示的文件是否是一个目录。
         System.out.println("isDirectory()：" + file.isDirectory());
         //测试此抽象路径名表示的文件是否是一个标准文件。
         System.out.println("isFile():" + file.isFile());
         // 测试此抽象路径名指定的文件是否是一个隐藏文件。
         System.out.println("isHidden():" + file.isHidden());
         /*
          * 获取信息
          */
         //返回由此抽象路径名表示的文件或目录的名称。
         System.out.println("getName():" + file3.getName());
         //返回此抽象路径名父目录的路径名字符串,如果此路径名没有指定父目录，则返回 null。
         System.out.println("getParent():" + file3.getParent());
         //将此抽象路径名转换为一个路径名字符串。
         System.out.println("getPath():" + file3.getPath());
         //返回此抽象路径名的绝对路径名字符串。
         System.out.println("getAbsolutePath()：" + file3.getAbsolutePath());
     }
 }