File类、递归、字节流

File类

对文件和文件夹进行操作

File类的构造

• public File(String path):
• public File(String parent，String child);
• public File(File parent ,Stirng child);

 //创建File对象
        File file = new File("F:\\test\\新建文件夹\\新建文件夹\\1.txt");
        //打印路径
        System.out.println(file);

        //将路径信息分成两部分
        File file1 = new File("F:\\test\\新建文件夹","新建文件夹\\1.txt");
        //打印
        System.out.println(file1);

        File file2=new File("F:\\test\\新建文件夹");
        File f=new File(file2,"新建文件夹\\1.txt");
        System.out.println(f);
        //F:\test\新建文件夹\新建文件夹\1.txt
        //F:\test\新建文件夹\新建文件夹\1.txt
        //F:\test\新建文件夹\新建文件夹\1.txt

File类的方法

• public String getAbsoultPath();//获取File对象的绝对路径
• public Stirng getPath();获取File对象构造时传入的路径
• public String getName();获取File对象的文件或者时文件家的名子
• public long lenth();获取File对象的大小（字节）
• public boolean exists();判断FIle对象文件是否存在
• public boolean isDirector()判断File对象文件是否为文件夹
• public boolean idFIle()；判断File对象文件是否为文件
• public boolean mkdir();创建单级文件夹
• public boolean mkdirs()创建多级文件夹‘
• public boolean creatNewFile();创建一个新的文件
• public boolean delete();删除文件或者文件夹

    //创建File对象
        File file = new File("F:\\test\\新建文件夹\\新建文件夹\\1.txt");
        //获取绝对路径
        String absolutePath = file.getAbsolutePath();
        System.out.println(absolutePath);

        //获取构造器中传入的路径
        String path = file.getPath();
        System.out.println(path);

        //获取文件的名字或者文件夹的名字
        String name = file.getName();
        System.out.println(name);

        //获取文件的长度
        long length = file.length();
        System.out.println(length);
        //F:\test\新建文件夹\新建文件夹\1.txt
        //F:\test\新建文件夹\新建文件夹\1.txt
        //1.txt
        //0
         //判断文件或者文件夹是否存在
        boolean exists = file.exists();
        System.out.println("文件或者文件夹是否存在"+exists);

        //判断是文件还是文件夹
        boolean directory = file.isDirectory();
        System.out.println("是文件夹吗"+directory);
        boolean file1 = file.isFile();
        System.out.println("是文件？"+file1);
        //文件或者文件夹是否存在true
        //是文件夹吗false
        //是文件？true
        //创建一个文件夹
        boolean mkdir = new File("F:\\test\\新建文件夹\\新建文件夹\\4.txt").mkdir();
        System.out.println(mkdir);
        //创建文件
        boolean newFile = new File("F:\\test\\新建文件夹\\新建文件夹\\5.txt").createNewFile();
        System.out.println(newFile);

        //删除文件过着文件夹
        boolean delete = file.delete();
        System.out.println("删除是否成功"+delete);
         //打印出文件夹下所有的文件以及文件夹
        File fileList = new File("F:\\test\\新建文件夹\\新建文件夹");
        String[] list = fileList.list();
        for (String s : list) {
            System.out.println(s);
        }
        //打印文件或者文件夹下所有的File对象
        File[] files = fileList.listFiles();
        for (File file2 : files) {
            System.out.println(file2);
        }
        //2.txt
3.txt
4.txt
5.txt
F:\test\新建文件夹\新建文件夹\2.txt
F:\test\新建文件夹\新建文件夹\3.txt
F:\test\新建文件夹\新建文件夹\4.txt
F:\test\新建文件夹\新建文件夹\5.txt

list和listFIles只能过去当前文件下的文件不能访问下个文件下的文件

• 相对路径和绝对路径的比较

1. 相对路径 无根盘符 相对与自己的项目的存储路径 “1.txt" “aa\1.txt”
2. 绝对路径 以盘符开始的路径 C:\Users\Administrator\Desktop\temp\aaa\1.txt

递归

递归就是一个方法中调用自己

• 递归求和

  public static void main(String[] args) {
        
        System.out.println(getsum(10));
    }
    public static int getsum(int n){
        if(n==1){
            return 1;
        }
      return getsum(n-1)+n;

• 递归的阶乘

 public static void main(String[] args) {
        //使用递归求出n的阶乘
        System.out.println(getAccumulate(10));

    }
    public static int getAccumulate(int n){
        if(n==1){
            return 1;}
    return getAccumulate(n-1)*n;

• 对于文件夹的多级搜索 使用递归方式

 public static void main(String[] args) {
        //创建File对象
        File file = new File("F:\\test");
        getmkdirTofile(file);
        //
    }
    //创建一个方法使用递归方式打印所有得文件
    public static void getmkdirTofile(File file){
        //遍历文件夹下的文件  如果是文件夹的就继续遍历文件
        File[] files = file.listFiles();
        //遍历 判断
        for (File file1 : files) {
            //筛选以.txt结尾 并且是文件
            if(file1.getName().endsWith(".txt")&&file1.isFile()){
            System.out.println(file1);}
            //如果是文件夹
        else if(file.isDirectory())
        {
            getmkdirTofile(file1);
        }

        }
    }
    //F:\test\1.txt
F:\test\新建文件夹\新建文件夹\2.txt
F:\test\新建文件夹\新建文件夹\3.txt\2.txt
F:\test\新建文件夹\新建文件夹\3.txt\4.txt
F:\test\新建文件夹\新建文件夹\3.txt\5.txt
F:\test\新建文件夹\新建文件夹\3.txt\zhang\2.txt
F:\test\新建文件夹\新建文件夹\3.txt\zhang\4.txt
F:\test\新建文件夹\新建文件夹\3.txt\zhang\5.txt
F:\test\新建文件夹\新建文件夹\4.txt
F:\test\新建文件夹\新建文件夹\5.txt

}

list和listFiles只能列出子文件和子文件夹

IO流

：Input 输入流就是 就是从外部设备到程序 都数据流
Output 输出流 从程序到外部设备 写数据流

java中的IO的四大流

1. 字节输入流 InputStream(抽象类)
2. 字节输出流 OutStream(抽象类)
3. 字符输入流Reader（抽象类）
4. 字符输出流Write(抽象类)
   java中的所有流都是以上四个流的子类
   比如：FileWriter像文件中写出字符为单位的数据
   比如：FileInputStream从文件中读取以字节为单位的数据

字节流

万物皆对象 IO流万物皆字节
IO流中的一切皆字节，所有的数据都是有字节组成（0101010二进制）
5. 字节输出流
OutputStream(抽象类)
公共方法：
public void Close() 关闭资源 释放资源
public void flush() 刷新缓冲区
public void write(int b);//一次一个字节
public void write(byte[] bs)//一次一个字节数组
public void write(byte[] bs,int startIndex,int len);一次写一个字节数组的一部分

6. FileOutputStream类的使用
   文件的字节输出流（像文件中写字节数据）
   构造方法
   public FileOutputStream(String path)//传入文件的路径
   public FileOutputStream(File file);//传入文件的File对象

FileOutputStream fos = new FileOutputStream("a.txt");
        FileOutputStream fos = new FileOutputStream("a.txt");
        //一次写入一个字节
        fos.write(97);
        //一次写入一个字节数组
        byte[] bs={65,55,77,88};
        fos.write(bs);
        //一次写入字节数组的一部分
        byte[] bs1={65,55,77,88,99,100};
        fos.write(bs,1,2);

        //追加续写
        FileOutputStream fos2 = new FileOutputStream("a.txt", true);
        fos2.write(97);


        //换行
        //window \r\n
        FileOutputStream fos3 = new FileOutputStream("a.txt", true);
        for (int i = 0; i < 10; i++) {
            fos3.write("java\r\

• 字节输入流
  顶层父类 InputStream(抽象类)
  共性方法
  public void close()释放资源
  public int read() //一次读一个字节
  public int read(byte[] bs)//一次读一个字节数组
  返回值表示读的字节个数

• FileInputStream类
  文件的输入流（字节为单位）
  构造方法：
  public FileInputStream(Stirng path)//传入文件的路径
  publicFileInputStream(File file)；传入文件的对象

//创建字节输入流对象
        FileInputStream fis = new FileInputStream("a.txt");
        //一次读取一个字节
        /*int b=fis.read();
        System.out.println((char)b);*/
        //循环读取字节
        //存储读取的字节
        int b=0;
        //文件中有数据不等于-1
        while((b = fis.read())!=-1){
            System.out.println((char)b);
        }
        //关闭资源
        fis.close();

• 一次读取一个字节数组

 //创建字节输入流对象
        FileInputStream fis = new FileInputStream("a.txt");
        //创建字节数组
        byte[] bs = new byte[4];
        /*//定义读的大小
        int len = fis.read(bs);
        System.out.println("读"+len+"字节");
        System.out.println(new String(bs,0,len));*/
        //一次读取一个字节数组
        int len= 0;
        while((len=fis.read(bs))!=-1){
            System.out.println(new String(bs,0,len));
        }
        fis.close();

• 字节流拷贝图片

ic static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fileInputStream = new FileInputStream("E:\\黑马\\就业\\upload\\1.png");
        //创建字节输出流对象
        FileOutputStream fileOutputStream = new FileOutputStream("Cop.png");
        //创建字节数组 定义字节数组每次存取的大小
        byte[] bs = new byte[1024];
        int len=0;
        while ((len=fileInputStream.read(bs))!=-1){
            fileOutputStream.write(bs,0,len);
        }
        //释放资源
        fileOutputStream.close();
        fileInputStream.close();