day17[File类_IO流]

课前回顾:
   1.Map:双列集合的顶级接口
   2.HashMap:
     a.特点:
       无序,无索引,key唯一,哈希表
     b.方法:
       put:添加键值对
       get:根据key获取value
       containsKey:判断是否包含在指定的key
       remove:根据key删除value
       keySet:获取所有的key存到set集合中
       entrySet:获取键值对象(Map.Entry)对存到set集合中
       values():获取所有的value
    3.HashMap的子类:LinkedHashMap:有序,无索引,key唯一,哈希表+链表
    4.TreeSet:
      a.特点:可以给元素排序  无索引,元素唯一,红黑树
      b.构造:TreeSet():给元素进行自然排序
            TreeSet(Comparator c)->给元素按照指定的规则排序
    5.TreeMap:
      a.可以给key排序   无索引,key唯一,红黑树
      b.构造:
        TreeMap()-> 给key做自然排序
        TreeMap(Comparator c)->给key按照指定的排序规则排序
    6.HashTable和Vector
      HashTable:
        a.特点:线程安全,不能存储null值null减,哈希表结构,无索引,key唯一,无序
      Vector:
        a.特点:线程安全,数组结构
    7.Properties属性集:
      特点:
        a.是HashTable的子类
        b.无序
        c.key唯一
        d.key和value必须是String的
        e.线程安全,无索引
        f.可以和IO结合使用的集合
      方法:
        setProperty(k,v)存储key和value
        getProperty(k)根据key获取value
        stringPropertyNames()->获取所有的key
        load(输入流对象)->将流中的数据加载到Poperties集合中
今日重点:
   所有

第一章.File类

一.File类

学IO流之前需要知道的常识:
1.File:代表的是文件
2.Directory:目录,文件夹
3.Path:路径
4.Input:输入
5.Output:输出
6.路径分隔符:
  路径是由什么组成的:盘符 文件夹名字  文件名组成
  \:代表的是路径中文件夹和文件夹  文件夹和文件之间的分隔符
    windows:  \    E:\Idea\io
    linux :   /    E:/Idea/io
  ;  代表的是路径和其他路经之间的分隔符
7.问题:
  E:\Idea\io\1.jpg
  1.jpg的父路径是谁:E:\Idea\io\
8.问题:
  名字为1.jpg的一定是图片吗?不一定
  要想判断是否为文件或者文件夹,不要看名字,要看类型

File类:文件和目录路径名的抽象表示形式
说白了:可以利用File的构造,传递文件或者文件夹的路径,表示一个文件或者文件夹,然后就可以调用File类中的方法去操作表示的文件或者文件夹

二.File的静态成员

static String pathSeparator 与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
static String separator  与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。

public class Demo01File {
    public static void main(String[] args) {
       // static String pathSeparator 与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator);//   ;
        // static String separator  与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
        String separator = File.separator;
        System.out.println(separator);//   \
        System.out.println("=======在java中如何表示路径=======");
        /*
          在java中  \\ 代表的是  一个 \
         */
        String path = "E:\\Idea\\io\\1.jpg";
        System.out.println(path);
    }
}

经验值:如果让代码中的路径更通用

注意: 写代码 做到 一次编写,到处运行

public class Demo02File {
 public static void main(String[] args) {
     String path = "E:\\Idea\\io\\1.jpg";
     System.out.println(path);
     System.out.println("=====================");
     String path1 = "E:"+File.separator+"Idea"+File.separator+"io"+File.separator+"1.jpg";
     System.out.println(path1);
 }
}

三.File的构造方法

File(String pathname):根据String表示的路径创建File对象 
     pathname:表示一个文件或者文件夹的路径
File(String parent, String child) :根据路径创建File对象
     parent:父路径
     child:子路径
File(File parent, String child) :根据路径创建File对象
     parent:是一个File对象,表示的是父路径
     child:子路径

public class Demo03FileConstructor {
    public static void main(String[] args) {
        /*
        File(String pathname):根据String表示的路径创建File对象
        pathname:表示一个文件或者文件夹的路径
        */
        File file = new File("E:\\Idea\\io\\1.jpg");
        System.out.println(file);
        /*
        File(String parent, String child) :根据路径创建File对象
        parent:父路径
        child:子路径
        */
        File file1 = new File("E:\\Idea\\io","1.jpg");
        System.out.println(file1);
        /*
        File(File parent, String child) :根据路径创建File对象
        parent:是一个File对象,表示的是父路径
        child:子路径
        */
        File parent = new File("E:\\Idea\\io");
        File file2 = new File(parent, "1.jpg");
        System.out.println(file2);
        System.out.println("========================");
        /*
          我们用File表示的路径可以不存在
          但是没有意义
         */
        File file3 = new File("E:\\Idea\\io1");
        System.out.println(file3);
    }
}

注:

我们用File表示的路径可以不存在,但是没有意义

四.File的获取方法

- public String getAbsolutePath() ：返回此File的绝对路径名字符串。->带盘符的路径
- public String getPath() ：将此File转换为路径名字符串。-> 获取的是File的封装路径
                           new File的时候,传递的是啥路径,getPath方法就获取的是啥路径
- public String getName()  ：返回由此File表示的文件或目录的名称。  
- public long length()  ：返回由此File表示的文件的长度。->文件的字节数 
- public File getParentFile()返回由此File表示的文件或目录的父目录，如果没有父目录，返回null。

public class Demo04FileGet {
    public static void main(String[] args) {
        File file = new File("IO\\1.txt");
        // - public String getAbsolutePath() ：返回此File的绝对路径名字符串。->带盘符的路径
        System.out.println("文件的绝对路径为:"+file.getAbsolutePath());
       /*
       - public String getPath() ：将此File转换为路径名字符串。-> 获取的是File的封装路径
         new File的时候,传递的是啥路径,getPath方法就获取的是啥路径
        */
        System.out.println("封装路径为:"+file.getPath());
       // - public String getName()  ：返回由此File表示的文件或目录的名称。
        System.out.println("文件或者文件夹的名称为:"+file.getName());
        // - public long length()  ：返回由此File表示的文件的长度。->文件的字节数
        File file1 = new File("E:\\Idea\\io\\io.txt");
        System.out.println("文件的字节数为:"+file1.length());
        // - public File getParentFile()返回由此File表示的文件或目录的父目录，如果没有父目录，返回null。
        System.out.println("1.txt:"+file.getParentFile());
    }
}

五.相对路径和绝对路径

绝对路径:从盘符开始写的路径
       什么时候使用:如果是跨盘符访问,就可以写绝对路径
相对路径:在idea中相对路径咋写
       规则:
        找参照路径,哪个路径为参照路径,哪个路径就可以省略不写,剩下的就是在代码中相对路径的写法
        在idea中参照路径是:当前project的绝对路径
       比如:找day17下面io文件夹下面的a.txt的相对路径
       a.txt的绝对路径找出来:E:\Idea\idea2019\workspace\210521_bigdata\day17\io\a.txt
       参照路径是谁:E:\Idea\idea2019\workspace\210521_bigdata
       参数路径可以直接不写了,剩下的就是相对路径写法:day17\io\a.txt
总结:  在idea中的写相对路径,是从当前的模块名开始写的
注意:  如果不写模块名,默认位置在当前的project下

public class Demo05Path {
    public static void main(String[] args)throws Exception {
        File file = new File("day17\\io\\a.txt");
        System.out.println(file.getAbsolutePath());
        System.out.println(file.createNewFile());//在指定模块位置创建
        File file1 = new File("b.txt");
        System.out.println(file1.getAbsolutePath());
        System.out.println(file1.createNewFile());//在当前project下创建
    }
}

六.File的创建方法

public boolean createNewFile() ：创建新文件
               如果要创建的文件已经存在:则创建失败,返回false
               如果要创建的文件不存在:则创建成功,返回true
public boolean mkdirs() ：创建文件夹,可以创建单级文件夹,还可以创建多级文件夹
               如果要创建的文件夹已经存在:则创建失败,返回false
               如果要创建的文件夹不存在:则创建成功,返回true

public class Demo06Create {
    public static void main(String[] args)throws IOException {
        File file = new File("E:\\Idea\\io\\io.txt");
        //File file = new File("E:\\Idea\\io\\io");
        /*
        public boolean createNewFile() ：创建新文件
        如果要创建的文件已经存在:则创建失败,返回false
        如果要创建的文件不存在:则创建成功,返回true
        */
        System.out.println("文件是否创建成功:"+file.createNewFile());
       /*
        public boolean mkdirs() ：创建文件夹,可以创建单级文件夹,还可以创建多级文件夹
        如果要创建的文件夹已经存在:则创建失败,返回false
        如果要创建的文件夹不存在:则创建成功,返回true
        */
        File file1 = new File("E:\\Idea\\io\\aa");
        //File file1 = new File("E:\\Idea\\io\\aa\\bb\\cc");
        //File file1 = new File("E:\\Idea\\io\\bb.txt");
        System.out.println("文件夹是否创建成功:"+file1.mkdirs());
    }
}

七.File类的删除方法

boolean delete()  -> 删除文件夹或者文件  ->  删除的时候要注意:不走回收站
                     如果删除文件夹的话,此文件夹必须是空文件夹

public class Demo07Delete {
    public static void main(String[] args) {
        File file = new File("E:\\Idea\\io\\io.txt");
        System.out.println("文件是否删除成功:"+file.delete());
        System.out.println("===================");
        File file1 = new File("E:\\Idea\\io\\aa");
        System.out.println("文件夹是否删除成功:"+file1.delete());
    }
}

八.File类的判断方法

boolean exists()  -> 判断指定的文件或者文件夹是否存在
boolean isFile()  -> 判断是否为文件
boolean isDirectory()  ->判断是否为文件夹

public class Demo08Is {
    public static void main(String[] args) {
        File file = new File("E:\\Idea\\io\\aa");
        //boolean exists()  -> 判断指定的文件或者文件夹是否存在
        System.out.println("文件或者文件夹是否存在:"+file.exists());
        //boolean isFile()  -> 判断是否为文件
        System.out.println("是否为文件:"+file.isFile());
        //boolean isDirectory()  ->判断是否为文件夹
        System.out.println("是否为文件夹:"+file.isDirectory());
    }
}

九.File的遍历方法

String[] list() ->获取的是文件或者文件夹,只能遍历一级文件夹
File[] listFiles() ->获取指定文件夹下的文件或者子文件夹,返回的是File数组  ,只能遍历一级文件夹(要是用,就用listFiles())

public class Demo09ListFile {
    public static void main(String[] args) {
        //String[] list() ->获取的是文件或者文件夹,只能遍历一级文件夹
        File file = new File("E:\\Idea\\io");
       /* String[] list = file.list();
        for (String s : list) {
            System.out.println(s);
        }*/
       /*
        File[] listFiles() ->获取指定文件夹下的文件或者子文件夹,返回的是File数组  ,只能遍历一级文件夹
        listFiles()实现原理:
          先调用list方法,获取指定的子文件夹或者文件,
          将获取出来的子文件夹或者文件存放到File[]数组中
        */
        File[] files = file.listFiles();
        for (File file1 : files) {
            System.out.println(file1);
        }
    }
}

练习:遍历指定文件夹下所有的.jpg文件

步骤:
  1.创建File对象,传递要遍历的文件夹路径
  2.调用listFiles()方法,对指定的文件夹进行遍历,获取下面的文件或者子文件夹
  3.遍历File[]数组,把每一个子文件夹和文件的File对象获取出来
  4.调用getName(),将文件或者文件夹名字获取出来
  5.判断,如果名字是以.jpg结尾的,就输出

public class Demo10ListFiles {
    public static void main(String[] args) {
        //1.创建File对象,传递要遍历的文件夹路径
        File file = new File("E:\\Idea\\io");
        method(file);
    }
    private static void method(File file) {
        //2.调用listFiles()方法,对指定的文件夹进行遍历,获取下面的文件或者子文件夹
        File[] files = file.listFiles();
        //3.遍历File[]数组,把每一个子文件夹和文件的File对象获取出来
        for (File newFile : files) {
            if (newFile.isFile()){
                //4.调用getName(),将文件或者文件夹名字获取出来
                String name = newFile.getName();
                //5.判断,如果名字是以.jpg结尾的,就输出
                if (name.endsWith(".jpg")){
                    System.out.println(name);
                }
            }else{
                //递归调用
                method(newFile);
            }
        }
    }
}

第二章.字节流

一.IO流介绍以及输入输出以及流向的介绍

1.IO流
  I:Input  输入
  O:Output 输出
2.概述:将数据从一个设备上传输到另外一个设备上的技术
3.为什么学IO流:
  如果我们想将数据永久的保存起来,我们可以存到硬盘上,我们可以利用IO将数据永久地保存到硬盘上
  想用数据的时候,还可以从硬盘上将数据读出来
4.IO主要作用:
  数据传输

二.IO流的流向

I:Input  输入
  将数据从硬盘的文件中读到内存中
O:Output 输出
  从内存出发,利用代码将数据写到硬盘的文件中

三.IO流分类

1.字节流:一切皆字节(图片,音乐,视频,文本等都是字节组成)->万能流
  字节输出流:父类-> OutputStream(抽象类)
  字节输入流:父类-> InputStream(抽象类)
2.字符流:将数据看做是一个一个的字符操作,专门操作文本文档
        什么叫文本文档:用记事本或者一些个高级记事本打开,人能看懂的内容,就叫做文本文档
        .txt  .html  .css   .java
        .doc(不是)
  字符输出流:父类-> Writer(抽象类)
  字符输入流:父类-> Reader(抽象类)

InputStream OutputStream Writer Reader:都是抽象类
所以我们学要学他们的子类
FileOutputStream
FileInputStream
FileWriter
FileReader
BufferedInputStream
BufferedOutputStream
BufferedWriter
BufferedReader
OutputStreamWriter
InputStreamReader
ObjectInputStream
ObjectOutputStream
PrintStream

四.OutputStream中子类[FileOutputStream]的介绍以及方法的简单介绍

1.OutputStream:(字节输出流) 抽象类
2.子类:FileOutputStream(字节输出流)
3.构造:
  FileOutputStream(File file)->根据文件的路径创建FileOutputStream对象
  FileOutputStream(String path)->根据文件的路径创建FileOutputStream对象
4.注意:
  输出流可以自动创建不存在的文件(但是不能创建文件夹昂)
5.方法:
  void write(int b)  -> 一次写一个字节
  void write(byte[] b) -> 一次写一个字节数组
  void write(byte[] b, int off, int len) -> 一次写一个字节数组一部分
             b:要写的字节数组
             off:从数组中的哪个索引开始写
             len:写多少个字节
  void close() -> 关闭流对象

public class Demo01FileOutputStream {
    public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("day17\\io\\a.txt");
       // method(fos);
       // method01(fos);
        method02(fos);
    }
    /*
        void write(byte[] b, int off, int len) -> 一次写一个字节数组一部分
             b:要写的字节数组
             off:从数组中的哪个索引开始写
             len:写多少个字节
     */
    private static void method02(FileOutputStream fos) throws IOException {
        byte[] bytes = {97,98,99,100,101,102};
        fos.write(bytes,0,2);
        fos.close();
    }
    /*
      void write(byte[] b) -> 一次写一个字节数组
     */
    private static void method01(FileOutputStream fos) throws IOException {
       byte[] bytes = {97,98,99,100};
       fos.write(bytes);
       fos.close();
    }
    /*
     void write(int b)  -> 一次写一个字节
     */
    private static void method(FileOutputStream fos)throws IOException {
        fos.write(97);
        //关闭流对象
        fos.close();
    }
}

public class Demo02FileOutputStream {
    public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("day17\\io\\b.txt");
        //byte[] bytes = "abcd".getBytes();//[97,98,99,100]
        //byte[] bytes = {97,98,99,100};
        //fos.write(bytes);
        fos.write("你好".getBytes());
        fos.close();
    }
}

五.FileOutputStream的续写和换行

续写:
FileOutputStream(String path,boolean append)->创建对象,并有续写效果
                 append:false  ->  没有续写效果,每次运行都会创建新的文件覆盖老文件
                 append:true->没有新文件创建,直接续写追加内容
换行:
 windows: \r\n
 linux: \n
 os:   \r

public class Demo03FileOutputStream {
    public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("day17\\io\\c.txt",true);
        fos.write("窗前明月光".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("疑是地上霜".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("举头望明月".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("低头思故乡".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("离离原上草\r\n".getBytes());
        fos.write("一岁一枯荣\r\n".getBytes());
        fos.write("野火烧不尽\r\n".getBytes());
        fos.write("春风吹又生\r\n".getBytes());
        fos.close();
    }
}