复习第二天： IO流

IO流：

什么事IO流？
感觉就是字面意思。I表示InputStream (输入流 )，O表示OutputStream (输出流)
为啥么要使用IO流呢？
IO流其实一直跟我们息息相关，当你从网上下载一个图片或者把一个文件从一个位置拷贝到另外的一个位置这都是在使用IO流。在 Java 中,把这些不同类型的输入、输出源抽象为流(Stream),而其中输入或输出的数据则称为数据流(Data Stream),
‘流’的介绍：
流一般分为输入流（Input Stream）和输出流（Output Stream）两类，但这种划分并不是绝对的。比如一个文件，当向其中写数据时，它就是一个输出流；当从其中读取数据时，它就是一个输入流。当然，键盘只是一个输入流，而屏幕则只是一个输出流。其实我们可以通过一个非常简单的方法来判断，只要是向内存中写入就是输入流，从内存中写出就是输出流）
流的分类：
①：按照流向划分： 输入流和输出流
②：按照数据类型划分：字节流(二进制可以读取所有文件) 和 字符流(读取文本文件，只能处理纯文本，图片，视频等就不可以处理)

首先我们先讲下跟IO流互相配合的一个File类

             File类：是一个跟系统无关的  重点单词有俩：director（文件夹/目录）   path（路径）

File类 的应用

 //File类是不需要创建的，是跟系统无关的类
 //使用 new File(path)   这里的path要写你要操作的一个路径，可以是绝对路径可以是相对路径
 File file = new File("D:\\cs\\第一个");    // 通过File() 可以直接读取到这个路径下的文件

        System.out.println("打印一个冒号："+File.pathSeparator); //在window系统的是； 如果字啊Linux是 ：
        System.out.println("打印一个分号："+File.separator);        //在window系统的是 \ 如果字啊Linux是 /

File构造器：

// File构造器有三种方式：
                   //① 直接一个参数new File()         写一个路径
                   new File("D:\cs\第一个\Loveyou.txt");  //路径可以是绝对路径也可以是相对路径
                   //②有两个参数
                   new File(parent,child);   partent:表示一个计算机的硬盘(D:\\)   child(文件名)
                   //③ //测试第三种构造器    两种参数
          			  File parent = new File("c:\\");
				      File file1 = new File(parent, "hello.java");

File的方法：
①： 创建一个空文件

        File file = new File("D:\\cs\\第一个\\Loveyou.txt"); //这里填写你要写的创建文件的绝对路径
        boolean newFile = file.createNewFile();//返回值是一个布尔类型， 告诉你创建是否成功

②：删除文件

 File file = new File("D:\\cs\\第一个\\Loveyou.txt"); //这里填写你要写的创建文件的绝对路径
 boolean delete = file.delete();//返回值是一个布尔类型， 告诉你删除是否成功

③：创建文件或者文件夹

 //创建单层目录
 File file = new File("D:\\AX");  //AX就是你创建的一个文件夹一级目录
 boolean mkdir= file.mkdir()
 //创建多层目录
 File file = new File("D:\\AX\\AX\\AX\\AX\\AX\\AX");// AX\\AX\\AX\\AX\\AX\\AX就是你创建的多层文件夹
 boolean mkdirs = file .mkdirs();

④显示目录下的所有文件

 File file = new File("D:\\丽晶");
 String[] list = file.list();   //list表示的目录下所有文件名， 返回的是一个目录
 //使用listFiles（ ） 遍历出所有子文件
 File[] files = file .listFiles();
 System.out.println(Arrays.toString(files));
 

IO流的详情

        /**
         * 使用输入输出流复制一个图片
         */
        //实例化对象
//        FileInputStream fileInputStream = new FileInputStream("D:\\系统软件\\乐视手机回忆照片\\123.jpg");
//        FileOutputStream fileOutputStream = new FileOutputStream("D:\\ceshi.jpg");
//        //通过集合的形式传送 速度会快
//        long l = System.currentTimeMillis();
//        byte[] bytes = new byte[1024];
//          int len=0;
//          while ((len=fileInputStream.read(bytes))!=-1){
//                fileOutputStream.write(bytes);
//          }
//        long n = System.currentTimeMillis();
//          fileOutputStream.close();
//          fileInputStream.close();

//        System.out.println("复制成功用时："+(n-l)+"毫秒");

        /***
         * 字节输入流
         *      方法：read（ 读取下一个字节）
         *            read（byte【】 byte） 读取字节数组
         *            close（）  关闭流
         *            使用的时候要调用 FileIntputStream  作用： 把硬盘上的数组读取到内存里面
         *       字节输入流使用步骤：
         *          ①创建FileInputStream对象 构造方法要绑定读取的数据源
         *          ②使用对象方法 read（） 读文件
         *          ③ 释放资源 close（）
         *     特点：  在读取到没有文件的时候返回一个-1
         *     关流的时候： 顺序从下往上
         */
             //读取文件路径
        FileInputStream fileInputStream = new FileInputStream("D:\\QQ\\platform.tpc");
             //  第一种方法：使用方法，并且循环没一个字节
        int len=0;
//           while ((len=fileInputStream.read())!=-1){
//               System.out.print((char)len);
//           }
           //第二种方法： 直接遍历数组，  输出数组
        byte[] bytes = new byte[1024];
          while ((len= fileInputStream.read(bytes))!=-1){
               // System.out.println(bytes); 遍历数组
              for (byte b:bytes){
                  System.out.print((char)b);
              }
          }
          fileInputStream.close();


        /**
         * 输入字符流
         *        Reader：
         *            read()  读取
         *            close()  关流
         *    调用对象FileReader
         */

        System.out.println("******************输入字符流*************************");
        FileReader fileReader = new FileReader("D:\\开发信息\\李震烨(1).txt");
            int le =0 ;
//         while ((le=fileReader.read())!=-1){
//             System.out.println((char)le);
//         }
        char[] chars = new char[1024];
        while ((len=fileReader.read(chars))!=-1){
            System.out.println(new String (chars,0,len));
        }

         fileReader.close();


        /**
         * 字符输出流
         *       FileWriter：   flush（）   刷新 流对象可以继续使用
         *                      close()      刷新缓冲区 然后通过释放资源的方式   流不能再使用
         */
        System.out.println("***********************************字符输出流");
        FileWriter fileWriter = new FileWriter("D:\\cs.txt");

        // FileWriter fileWriter = new FileWriter("D:\\cs.txt",true);  表示在原有的基础上添加
        // FileWriter fileWriter = new FileWriter("D:\\cs.txt",false);  表示直接替换原来文档
        //一个一个的写
        fileWriter.write(99);
        fileWriter.write(99);
        fileWriter.write(99);fileWriter.write(99);
        fileWriter.write(99);
       ///通过字符写
        char[] chars1 = {895,54,554,75};
          fileWriter.write(chars1);  //直接添加数组

        //必须要刷新 不然东西都是写在缓冲区
        fileWriter.flush();
        fileWriter.close();

缓冲流的简单介绍：

 public static void main(String[] args) throws IOException {
        /** 字节缓冲输出流 字节缓冲输出流 字节缓冲输出流 字节缓冲输出流 字节缓冲输出流 字节缓冲输出流
         * 字节缓冲输出流  BufferedOutputSteam   extends OutputStream
         *          close();
         *          flusg();
         *          write();
         *          使用步骤：
         *              ①创建FileOutputStream对象
         *              ②创建 BufferedOutputStream 对象
         *              ③ 使用 BufferedOutputSteam 中的方法 write（ ）    写进去缓冲区
         *              ④ 使用 BufferedOutputStream   flush（）   刷新缓冲区，
         *              ⑤ 释放流
         */


         System.out.println("**********************字节缓冲输出流*****************************");

         //       使用步骤：
        //             ①创建FileOutputStream对象
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\cs.txt");
        //             ②创建 BufferedOutputStream 对象
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        //              ③ 使用 BufferedOutputSteam 中的方法 write（ ）    写进去缓冲区
        bufferedOutputStream.write("我是大神，你是什么".getBytes());
        //              ④ 使用 BufferedOutputStream   flush（）   刷新缓冲区，
             bufferedOutputStream.flush();
        //              ⑤ 释放流
        bufferedOutputStream.close();


        /**
         * 字节缓冲输出流  BufferedIntputStream
         *              read()
         *              使用步骤：
         *                 ① 创建一个FileIntputStream对象
         *                 ② 创建 BufferedIntputStream 对象
         *                 ③  使用read （） 读取硬盘的内容，然后 使用循环遍历
         *                 ④ 关闭流
         */
        FileInputStream fileInputStream = new FileInputStream("D:\\ss.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        byte[] bytes = new byte[1024];
        int len=0;
        while ((len=bufferedInputStream.read(bytes))!=-1){
            System.out.print(new String(bytes,0,len));
        }

           fileInputStream.close();
    }

关于集合Properties：

 public static void main(String[] args) throws IOException {
        /**  一般都是保存账号密码的
         * Properties 可以保存在流中 或者从流加载
         *  方法：   ①添加数据  setProperty(k,v);
         *           ② 得到key 对应的value  getProperty(k);
         *           ③ 得到所有key 的集合  stringPropertyName()      {相当于是一个map集合的keyset（）}
         *      关于流的方法：
         *                    ①  store() 表示 把集合里面的ky 存储到 对应路径的里面
         *                    ②  load()
         *
         */

        //集合实例化
        Properties properties = new Properties();
        //添加数据：
        properties.setProperty("第一名", "hao123456");
        properties.setProperty("第二名", "ha456");
        properties.setProperty("第三名", "hao1256");
        properties.setProperty("第四名", "hao156");
        properties.setProperty("第五名", "ha3456");
        System.out.println(properties);
        //遍历集合  使用方法stringPropertyNames
        Set<String> strings = properties.stringPropertyNames();
        /**
         * 可以使用foreach  也可以用遍历器
         */
        //①  使用foreach 循环 遍历
         for (String s:strings){
             System.out.println("key："+s+"，value是："+properties.getProperty(s));
         }

         //② 使用entrySet()循环
        Set<Map.Entry<Object, Object>> entries = properties.entrySet();
        for (Map.Entry<Object, Object> m:entries
             ) {
            System.out.println(m.getValue()+"===="+m.getKey());

        }


        /**
         *
         *  重点是 使用store方法存在内存里面
         * 把集合里面内容写到 硬盘上：
         */
        Properties pro = new Properties();  //定义的双链集合
        //添加数据
        pro.setProperty("第一个东西", "hdjskh123");
        pro.setProperty("第二个东西", "hd123");
        pro.setProperty("第三个东西", "h23");

        //创建一个输出流， 并选择输出的地址
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\cs.txt");
        pro.store(fileOutputStream,"save date");
        fileOutputStream.flush();
        fileOutputStream.close(); //关流
        //也可以合并成一句
      //  pro.store(new FileOutputStream("d:\\cs.txt"),"save data");


        /**
         * 把硬盘数据存储到集合里面
         */
           //创建集合
        Properties properties1 = new Properties();
        //读取的路径
        FileInputStream fileInputStream = new FileInputStream("D:\\ss.txt");
        properties1.load(fileInputStream);
         fileInputStream.close();

         //遍历输出 看看集合里面的key 和value
        Set<String> strings1 = properties1.stringPropertyNames();
        for ( String s:strings1){
            System.out.println(s+"====="+properties1.getProperty(s));
        }

    }