Java学习--File

File

File概述和构造方法

File：他是文件和目录路径名的抽象表示

• ​ 文件和目录是可以通过File封装成对象的。
• ​ 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。他可以是存在的，也可以是不存在的。将来要通过具体操作把这个路径的内容转换为具体存在的。

File类的构造方法

public static void main(String[] args) {
        //File(String pathname):通过将给定的路径名字转换成抽象路径名来创建新的File实例
        File f1=new File("E:\\Java\\IO.txt");
        System.out.println(f1);

        //File(String parent,String child)从父路径名字符串和子路径名字符串创建新的File实例
        File f2=new File("E:\\Java","IO.txt");
        System.out.println(f2);

        //File(File parent,String child)从父抽象路径名和子路径名字符串创建新的File实例
        File f3=new File("E:\\Java");
        File f4=new File(f3,"Java.txt");
        System.out.println(f4);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

绝对路径和相对路径

绝对路径：是一个完整的路径，从盘符开始

相对路径：是一个简化的路径，相对于当前项目下的路径

示例代码

 public static void main(String[] args) {
        //是一个完整路径，从盘符开始
        File f1=new File("E:\\Java\\a.txt");
        //是一个简化的路径，从当前项目的根目录开始
        File f2=new File("a.txt");
        File f3=new File("modelName\\a.txt");

    }
1
2
3
4
5
6
7
8

File 类创建功能

方法分类

示例代码

 public static void main(String[] args) throws IOException {
        //在practice模块下创建一个文件java.txt
        File f1=new File("practice\\java.txt");
        System.out.println(f1.createNewFile());
        System.out.println("===========================");
        //在practice模块下创建一个文件夹JavaSE
        File f2=new File("practice\\javaSE");
        System.out.println(f2.mkdir());
        System.out.println("++++++++++++++++++++++++++++++++");
        //在practice模块下创建一个多级目录JavaWeb\\Html
        File f3=new File("practice\\JavaWeb\\Html");
        System.out.println(f3.mkdirs());
        System.out.println("*********************************");
        //在JavaWeb\\Html中创建一个123.html文件
        File f4=new File(f3,"123.html");
        System.out.println(f4.createNewFile());
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

File 类型的判断和获取功能

示例代码

public static void main(String[] args) throws IOException {
        //创建File对象
        File f=new File("practice\\java.txt");

        //public boolean isDirectory()：测试此抽象路径名表示的File是否为目录
        //public boolean isFile():测试此抽象路径名表示的File是否为文件
        //public boolean exists():测试此抽象路径名表搜狐File是否存在

        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());

        // public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串
        // public String getPath()：将此抽象路径名转换为路径名字符串
        // public String getName()：返回由此抽象路径名表示的文件或目录的名称
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());


        //public File[] listFiles() 返回此抽象路径名表示的目录中的文件和目录的对象数组
        File f2=new File("E:\\Java");
        File [] fileArray=f2.listFiles();
        for (File file : fileArray) {
            System.out.println(file);
            System.out.println(file.getPath());
            if (file.isFile()){
                System.out.println(file);
            }
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

File类删除功能

删除目录时的注意事项：

​ 如果一个目录中有内容（目录，文件），不能直接删除，应该先删除目录中的内容，最后才删除目录

示例代码：

public static void main(String[] args) {
        //删除practice模块下的javaSE目录
        File f1=new File("practice\\javaSE");
        System.out.println(f1.delete());

        //删除practice模块下的java.txt文件
        File f2=new File("practice\\java.txt");
        System.out.println(f1.delete());

        //删除javaWeb文件
        File f3=new File("practice\\javaWeb");
        File f4=new File("practice\\javaWeb\\Html");
        File f5=new File("practice\\javaWeb\\Html\\123.html");
        //先删除123.html
        System.out.println(f5.delete());

        //再删除Html目录
        System.out.println(f4.delete());
        //最后删除javaWeb文件夹
        System.out.println(f3.delete());

    }	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

递归

概述

​ 递归指的是方法定义中调用方法本身的现象

递归解决问题的思路

​ 把一个复杂的问题层层华为一个与原问题相思的规模较小的问题来求解

​ 递归策略只需少量的程序就可描述出解题过程中所需要的多次重复计算

递归解决问题要找到两个内容

• 递归出口：否则会出现内存溢出
• 递归规则：与原问题相似的规模较小的问题

字节流

IO流的概述和分类

1. IO流介绍

   • IO:输入/输出（input/output）

   • 流：是一种抽象概念，是对数据传输的总称，也就是说数据在设备间的传输称为流，流的本质是数据传输

   • IO流就是用来处理设备间数据传输问题的，常见应用：文件复制，文件上传，文件下载

2. IO流的分类

   按照数据流向分

   • 输入流：读数据
   • 输出流：写数据

   按照数据类型分

   ​ 字节流：字节流可分为字节输入流和字节输出流

   ​ 字符流：字符流可分为字符输入流和字符输出流

3. IO流的的使用场景

   • 如果操作的是纯文本文件，优先使用字符流
   • 如果操作的是图片，视频，音频等二进制文件，优先使用字节流
   • 如果不确定文件类型，优先使用字节流，字节流是万能的流

字节流写数据

• 字节流抽象基类

  • InputStream:这个抽象类是表示字节输入流的所有类的超类
  • OutputStream:这个抽象类是表示字节输出流的所有类的超类
  • 子类名特点：子类名称都是以其父类名作为子类名的后缀

• 字节输出流

  • FileOutStream(String name):创建文件输出流以指定的名称写入文件

• 使用字节输出流写数据的步骤

  • 创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输入流对象指向文件）
  • 调用字节输出流对象的写数据方法
  • 释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）

• 示例代码

• public static void main(String[] args) throws IOException {
          File file=new File("practice\\src\\practice3\\123.txt");
          System.out.println(file.createNewFile());
          //创建字节流对象以文件输出流以指定的名称写入文件
          FileOutputStream fileOutputStream=new FileOutputStream("practice\\src\\practice3\\123.txt");
          //将指定的字节写入此文件输入流
          fileOutputStream.write(23);
          //最后都要释放资源
          fileOutputStream.close();
      }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

字节流写入数据的三种方式

写数据的方法分类

示例代码

 public static void main(String[] args) throws IOException {
        //创建文件输入流已指定名称写入文件
        FileOutputStream fileOutputStream=new FileOutputStream("practice\\src\\practice3\\124.txt");
        fileOutputStream.write(89);
        byte [] bytes={12,123,45,43};
        byte [] bytes1="awewds".getBytes();
        fileOutputStream.write(bytes);
        fileOutputStream.write(bytes1);
        fileOutputStream.write(bytes1,2,3);
        //释放资源
        fileOutputStream.close();
    }
1
2
3
4
5
6
7
8
9
10
11
12

字节流写数据的两个小问题

• 字节流写入数据如何实现换行

  • windows:\r\n
  • linux:\n
  • mac:\r

• 字节流如数据如何实现追加写入

  • public FileOutputStream(String name,boolean append)

  • 创建文件输出流以指定的名称写入文件。如果第二个参数为true，则字节将写入文件末尾而不是开头

示例代码

public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileOutputStream fileOutputStream=new FileOutputStream("practice\\src\\practice3\\125.txt",true);

        //写数据
        for (int i = 0; i < 10; i++) {
            fileOutputStream.write("hello".getBytes());
            fileOutputStream.write("\r\n".getBytes());
        }
        //释放资源
        fileOutputStream.close();
    }
1
2
3
4
5
6
7
8
9
10
11
12

字节流写数据加异常处理

异常处理格式

​ try-catch-finally

try{
	可能出现异常的代码
}catch(异常类名 变量名){
	异常处理的代码
}finally{
	执行所有清除操作
}
1
2
3
4
5
6
7

finally特点

• 被finally控制的语句一定会执行，除非JVM退出

示例代码

public static void main(String[] args) {
        //加入Finally来实现释放资源
        FileOutputStream fileOutputStream=null;
        try {
            fileOutputStream=new FileOutputStream("practice\\src\\practice3\\123.txt");
            fileOutputStream.write("hello".getBytes());
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (fileOutputStream!=null){
                try {
                    fileOutputStream.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }

        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

字节流读取数据（一次读一个字节数据）

• 字节输入流
  • FileInputStream(String name)通过打开与世界文件的链接来创建一个FileInputStream,该文件由文件系统中的路径名name名命
• 字节输入流读取数据的步骤
  • 创建字节输入流对象
  • 调用字节输入流对象的读数据方法
  • 释放资源
• 示例代码

 public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fileInputStream=new FileInputStream("E:\\Java\\IO\\practice\\src\\practice3\\123.txt");
        //根据目的地创建字节输入流对象
        FileOutputStream fileOutputStream=new FileOutputStream("practice\\src\\practice3\\124.txt");
        //读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
        int num;
        while((num=fileInputStream.read())!=-1){
            fileOutputStream.write(num);
        }

        //释放资源
        fileOutputStream.close();
        fileInputStream.close();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

字节流复制文件

案例需求

​ 把“E:\itcast\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt” (文件可以是任意文件)

实现步骤

​ 复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目 的地)

​ 数据源： E:\itcast\窗里窗外.txt — 读数据 — InputStream — FileInputStream

​ 目的地： myByteStream\窗里窗外.txt — 写数据 — OutputStream — FileOutputStream 代码实现

public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fileInputStream=new FileInputStream("E:\\itcast\\窗里窗外.txt");
        //根据目的创建字节输出流对象
        FileOutputStream fileOutputStream=new FileOutputStream("E:\\Java\\IO\\practice\\src\\practice3\\123.txt");
        //读写数据，是指文本文件（一次读取一个字节，一次写入一个字节）
        int by;
        while ((by=fileInputStream.read())!=-1){
            fileOutputStream.write(by);
        }
        //释放资源
        fileInputStream.close();
        fileOutputStream.close();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

字节流读数据（一次读一个字节数据）

• 一次读一个字节数组

  • ​ public int read(byte [] b)从输入流读取最多b.length个字节的数据
  • 返回的是读入缓冲区的粽子节数，也就是实际的读取字节个数

• 示例代码

  public static void main(String[] args) throws IOException {
          //创建字节输入流对象
          FileInputStream fileInputStream=new FileInputStream("E:\\itcast\\\\窗里窗外.txt");
  
          byte [] bys= new byte[1024];    //1024及其倍数
          int len;
          //循环读取
          while((len=fileInputStream.read(bys))!=-1){
              System.out.println(new String(bys,0,len));
          }
          //释放资源
          fileInputStream.close();
      }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

字节流复制文件

案例需求：

​ 把“E:\itcast\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt” (文件可以是任意文件)

实现步骤：

• 复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目 的地)

• 数据源： E:\itcast\窗里窗外.txt — 读数据 — InputStream — FileInputStream

• 目的地： myByteStream\窗里窗外.txt — 写数据 — OutputStream — FileOutputStream

代码实现：

public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fileInputStream=new FileInputStream("E:\\itcast\\sp.png");

        //根据目的地创建字节输出流对象
        FileOutputStream fileOutputStream=new FileOutputStream("E:\\Java\\IO\\practice\\src\\practice3\\sp.png");
        //读写数据，复制图片（一次读写一个字节）
        byte [] bys=new byte[1024];
        int len;
        while ((len=fileInputStream.read())!=-1){
            fileOutputStream.write(bys,0,len);
        }
        //释放资源
        fileOutputStream.close();
        fileInputStream.close();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

字节缓冲流

字节缓冲流构造方法

1. 字节缓冲流介绍

   • IbufferOutputStream:该类实现缓冲输出流，通过蛇者这样的输出流，应用程序可以向迪岑俄国输出流写入字节，而不必为写入的每个字节导致底层系统的调用
   • IbufferedInputStream:创建BufferedInputStream将创建一个内部缓冲区数组，当从流中读取或跳过字节时，内部缓冲区根据需要从所包含的输入流中重新填充，一次很多字节

2. 构造方法

   方法名	说明
   BufferedOutputStream(OutputStream out)	创建字节缓冲输出流对象
   BufferedInputStream(InputStream out)	创建字节缓冲输入流对象

3. 示例代码

    public static void main(String[] args) throws IOException {
           //字节缓冲流
           BufferedOutputStream bos=new BufferedOutputStream(
                   new FileOutputStream("E:\\itcast\\窗里窗外.txt"));
           //写数据
           bos.write("窗外的麻雀，咿呀咿呀哟".getBytes());
           bos.write("蚂蚁牙嘿".getBytes());
           //释放资源
           bos.close();
           //字节缓冲输入流
           BufferedInputStream bis=new BufferedInputStream(
                   new FileInputStream("E:\\Java\\IO\\practice\\src\\practice3\\窗里窗外.txt")
           );
           
           //一次读取一个字节组数据
           byte [] bys=new byte[1024];
           int len;
           while ((len=bis.read())!=-1){
               System.out.println(new String(bys,0,len));
           }
           //释放资源
           bis.close();
       }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23

   字节缓冲流复制视频

   案例需求：

   ​ 把“E:\itcast\字节流复制图片.avi”复制到模块目录下的“字节流复制图片.avi”

   实现步骤：

   ​ 根据数据源创建字节输入流对象

   ​ 根据目的地创建字节输出流对象

   ​ 读写数据

   ​ 复制视频 释放资源

   代码实现

   public static void main(String[] args) throws IOException {
   //复制视频
   // method1();
   method2();
   }
   //字节缓冲流一次读写一个字节数组
   public static void method2() throws IOException {
   BufferedInputStream bis = new BufferedInputStream(new
   FileInputStream("E:\\itcast\\字节流复制图片.avi"));
   BufferedOutputStream bos = new BufferedOutputStream(new
   FileOutputStream("myByteStream\\字节流复制图片.avi"));
   byte[] bys = new byte[1024];
   int len;
   while ((len=bis.read(bys))!=‐1) {
   bos.write(bys,0,len);
   }
   bos.close();
   bis.close();
   }
   //字节缓冲流一次读写一个字节
   public static void method1() throws IOException {
   BufferedInputStream bis = new BufferedInputStream(new
   FileInputStream("E:\\itcast\\字节流复制图片.avi"));
   BufferedOutputStream bos = new BufferedOutputStream(new
   FileOutputStream("myByteStream\\字节流复制图片.avi"));
   int by;
   while ((by=bis.read())!=‐1) {
   bos.write(by);
   }
   bos.close();
   bis.close();
   }
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33