1.File类

File类是专门处理电脑磁盘上面的文件和文件夹的一个类

./当前的工作路径

../相对于当前工作目录的上一级目录

../../相对于当前工作目录的上上一级的目录

相对路径：得有参照物

绝对路径：从磁盘的根目录（D：、F：）开始，一级一级的找，没有参照物

1.1 File类的构造方法

Constructor and Description
File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例。
File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例。
File(URI uri) 通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

2. File（String pathname）；传入文件或文件夹名字的路径，对当前路径的一个抽象，数理化出来，可以对文件进行操作

3. File（String parent , String child）;parent 父路径 child 子路径,子路径是在父路径的下面

1. File(File parent,String child);

*_5.File.separator 在windows自己识别正斜线 在Linux自动识别为反斜线_

  1. 更具有兼容性，在任何系统都不会报错
  1. package com.qfedu.test1file;
  3. import java.io.File;
  5. //file类的构造方法
  7. public class Demo1 {
  8.     public static void main(String[] args) {
  9.         //`File(String pathname)`  
  10.         //通过将给定的路径名字符串转换为抽象路径名来创建新的 `File`实例。
  11.         File file = new File("E:/aaa/AAA.txt");
  12.         System.out.println(file);
  14.         //`File(String parent,  String child)`  
  15.         //从父路径名字符串和子路径名字符串创建新的 `File`实例。
  16.         //parent 父路径    child 子路径
  17.         //子路径是在父路径的下面
  18.         File file2 = new File("E:/aaa", "AAA.txt");
  19.         System.out.println(file2);
  21.         //`File(File parent, String child)`  
  22.         //从父抽象路径名和子路径名字符串创建新的 `File`实例。
  23.         File file3 = new File(new File("E:/aaa"), "AAA.txt");
  24.         System.out.println(file3);
  26.         //File.separator   在windows自己识别正斜线   在Linux自动识别为反斜线\
  27.         File file4 = new File("E:" + File.separator + "aaa" +                                         File.separator + "1.txt");
  28.         System.out.println(file4);
  30.     }
  31. }

1.2使用对象创建文件和文件夹

  1. boolean createNewFile(); 创建文件，返回bollean类型数据
  2. 【注意事项】：
  3.     1.创建文件的时候，文件路径不存在会报错
  4.     2.硬盘坏了，也不能创建
  6. boolean mkdir（）；创建单级的路径
  8. boolean mkdirs（）； 创建多级的路径
  1. package com.qfedu.test1file;
  3. import java.io.File;
  4. import java.io.IOException;
  6. //方法
  8. public class Demo2 {
  9.     public static void main(String[] args) throws IOException{
  10.         File file = new File("E:/aaa/BBB.txt");
  12.         //编译时异常，可能没有这个文件，所以抛异常
  13.         System.out.println(file.createNewFile());//创建文件
  15.         File file2 = new File("E:/aaa/bbb");
  16.         System.out.println(file2.mkdir());//mkdir 创建单级路径
  18.         File file3 = new File("E:/aaa/ccc/eee/ffff");
  19.         System.out.println(file3.mkdirs());//mkdirs 创建单级路径
  20.     }
  22. }

1.3删除文件或者文件夹

boolean delete(); 立即删除，（删除文件夹的时候，必须是空的才能删）

void deleteOnExit();程序结束时才删除

  1. package com.qfedu.test1file;
  3. import java.io.File;
  5. public class Demo3 {
  6.     public static void main(String[] args) {
  7.         File file = new File("E:/aaa/BBB.txt");
  8.         System.out.println(file.delete());//立即删除
  10.         //删除文件夹
  11.         //删除文件加的时候只能删除空的文件夹
  12.         File file2 = new File("E:/aaa/BBB");
  13.         System.out.println(file2.delete());
  15.         File file3 = new File("E:/aaa/AAA.txt");
  16.         file3.deleteOnExit();//程序退出才删除
  17.     }
  19. }

1.4File对象的判断方法

boolean isFile(); 判断是不是文件

boolean isDirectory(); 判断是不是文件夹

boolean isHidden(); 判断是不是隐藏文件

boolean isAbsolute(); 判断是不是绝对路径

boolean exists(); 判断对应的文件或者文件夹是否存在

1.5返回值是String类型的方法

String getName(); 获取文件或文件夹的名字

String getPath(); 获取当前File对象路径的

String getParent(); 获取当前文件的上级目录

String getAbsolutPath(); 获取绝对路径

1.6返回值是long类型的方法

long length(); 占用字节数，英文和数字字符都是一个字节，中文根据编译器不一样可能是2字节或者3字节

long lastModified(); 获取当前文件最后修改的时间，这个时间是时间戳

  1.         时间戳从1970年1月1日0时0分到现在的秒数

1.7获取当前文件夹的所有文件和文件夹

1.7.1获取文件

listFiles()；返回File数组

  1. package com.qfedu.test1file;
  3. import java.io.File;
  5. //获取当前文件夹的所有文件和文件夹
  7. public class Demo7 {
  8.     public static void main(String[] args) {
  9.         File file = new File("E:/aaa");
  10.         //获取当前文件夹下的所有文件和文件夹
  11. //        System.out.println(file.listFiles());
  12.         File[] files = file.listFiles();
  13.         //数组遍历
  14.         for (File file2 : files) {
  15.             System.out.println(file2);
  16.         }
  18.     }
  20. }

1.7.2删除文件夹下的所有文件

用到递归的思想，如果是文件夹就再方法中再次调用方法。

  1. package com.qfedu.test1file;
  3. import java.io.File;
  5. //递归删除
  6. public class Demo7diguiDEL {
  7.     public static void main(String[] args) {
  8.         //删除某个目录下面所有的文件（包括子文件）   递归
  9.         File file = new File("E:/aaa");
  10.         del(file);
  12.     }
  13.     //递归 删除该位置所有文件
  14.     public static void del(File f) {
  15.         File[] files = f.listFiles();//获取f目录下所有文件和文件夹
  16.         for (File file1 : files) {
  17.             if (file1.isDirectory()) {//是否是文件夹
  18.                 del(file1);//在调用一次方法 （自己调用自己） 递归的思想
  19.             }else {
  20.                 file1.delete();//如果不是文件夹，就是文件，是文件就删除
  21. //                System.out.println(file1.delete());
  22.             }
  23.         }
  24.     }
  26. }

2 IO流【超级重点】

  1.     电脑上的文件，比如文档，音频，视频，图片等，在进行读取和存些的时候都是以流的形式进行操作的，叫IO流（input output）。
  3.     IO流就是对电脑中的文件进行读和写的，CPU通过内存从硬盘上面读取数据，每次读取4kb左右（缓冲值）。
  5.     缓冲值：提高读取和存储的效率、保护磁盘

2.1读取和输入的概念

2.1.1读取数据

比如磁盘有一个1.txt，可以通过java代码将它读取到java内存中，从java内存展示出来

磁盘中某个文件数据 —> java内存 —> 展示数据（eclipse控制台展示）

2.1.2写入数据

先把java代码中的数据写入到java代码中，然后在写入磁盘

数据—> java内存—> 磁盘上面

2.2IO流的分类

  1. 参照物是内存：可以理解为当前java代码
  2. I：
  3.     input 输入，从磁盘读取数据到内存里面，从磁盘到内存叫输入
  4.     磁盘读取到java里是输入
  5. O：
  6.     output 输出，从内存中去数据，写道磁盘上面，叫做输出
  7.     从java写道磁盘是输出
  9. 输入流：
  10.     两种：字节输入流和字符输入流
  11.     字节输入流：
  12.     InputStream：有一个子类FileInputStream
  13.     BufferedInputStream
  14.     1.实例化一个file对象，带数据内容
  15.     2.开始使用输入流 FileInputStream
  16.     3.加一个缓冲流 BufferedInputStream
  17.     4.准备一个字节数组byte[] 
  18.     5.while循环读取，因为不知道读取几次 终止条件是length-1
  19.     6.new String(字节数组，0，lenght) 将自己数组内的数据打印出自己能看懂的格式
  20.     案例看下面
  22. 输出流：
  23.     两种：字节输出流和字符输出流
  24.     案例FileOutputStream

输入流案例

  1. package com.qfedu.test2IOliu;
  3. import java.io.BufferedInputStream;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileNotFoundException;
  7. import java.io.IOException;
  9. //IO输入流 InputStream 一个子类(文件字节输入流)FileInputStream
  10. public class Demo1 {
  11.     public static void main(String[] args) throws IOException {
  12.         //1.创建对应的文件对象
  13.         File file = new File("E:/aaa/1.txt");
  14.         //2.创建文件字节输入流对象来操作文件对象
  15.         FileInputStream fis = new FileInputStream(file);
  16.         //3.FileInputStream  本身是不带缓冲效果的，要想给输入流对象加上缓冲效果
  17.         //BufferedInputStream(InputStream in) 增加缓冲效果
  18.         BufferedInputStream bis = new BufferedInputStream(fis);
  19.         //以上fis就有了缓冲的效果
  21.         //4.创建一个字节数组    这个数组就是缓冲区
  22.         //1024*4是每次读取的字节   缓冲值为4kb 
  23.         byte[] buf = new byte[1024 * 4];//4kb的容器 4096个字节
  25.         int length = -1;//定义结束条件，文件中到达结尾是-1
  26.         //5.将1.txt里面的数据读取到java内存中(缓存数组)
  27.         //bis.read(buf) bis读取到buf缓存数组中
  28.         while ((length = bis.read(buf)) != -1) {
  29.             System.out.println(length);//length字节数
  31.             System.out.println(new String(buf,0,length));
  32.         }
  34.         //6.流是需要关闭的
  35.         bis.close();
  36.         fis.close();
  37.     }
  38. }

输出流案例

需求：将一个字符串数据写入到空的文件夹里 getBytes 字符串转成字节数组

  1. package com.qfedu.test2IOliu;
  3. import java.io.BufferedOutputStream;
  4. import java.io.File;
  5. import java.io.FileNotFoundException;
  6. import java.io.FileOutputStream;
  7. import java.io.IOException;
  9. //IO输入流 OutputStream 一个子类(文件字节输入流)FileOutputStream
  10. public class Demo3 {
  11.     public static void main(String[] args) throws IOException {
  12.         //1.创建一个被写入的文件对象
  13.         File file = new File("E:/aaa/3.txt");
  14.         //2.字节输出流
  15.         FileOutputStream fos = new FileOutputStream(file);
  16.         //3.缓冲输出流
  17.         BufferedOutputStream bos = new BufferedOutputStream(fos);
  18.         //4.将字符串写入磁盘中
  19.         String string = "杨博是我儿，我是朱志伟";
  20.         byte[] bytes = string.getBytes();
  21.         bos.write(bytes);
  22.         //关闭流   先关后开的流
  23.         bos.close();
  24.         fos.close();
  26.     }
  27. }

案例

从../路径复制一个视频到E：/aaa文件夹下

分析：源文件需要输入流 >>>>内存>>>>>>在输出到E：/aaa文件夹下

  1. package com.qfedu.test2IOliu;
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.File;
  6. import java.io.FileInputStream;
  7. import java.io.FileNotFoundException;
  8. import java.io.FileOutputStream;
  9. import java.io.IOException;
  11. //复制图片
  12. public class Demo5anli2 {
  13.     public static void main(String[] args) throws IOException {
  14.         copyPhoto();
  15.         copyPhoto1();
  16.     }
  17.     public static void copyPhoto() throws IOException {
  18.         long start = System.currentTimeMillis();//开始时间 计算程序运行时间
  19.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("C:\\Users\\ZHU\\Pictures\\Saved Pictures\\luo.jpeg")));
  20.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("E:/aaa/luo1.png")));
  21.         byte[] b1 = new byte[1024 * 4];
  22.         int length = -1;
  23.         while((length = bis.read(b1)) != -1) {
  24.             bos.write(b1);
  25.         }
  26.         bos.close();
  27.         bis.close();
  28.         System.out.println("复制完成");
  29.         long end = System.currentTimeMillis();//结束时间  
  30.         System.out.println(end - start);//计算代码运行所用得时间 检查效率
  31.     }
  34.     public static void copyPhoto1() throws IOException {
  35.         long start = System.currentTimeMillis();//开始时间 计算程序运行时间
  36.         FileInputStream fis =  new FileInputStream(new File("C:\\Users\\ZHU\\Pictures\\Saved Pictures\\luo.jpeg"));
  37.         FileOutputStream fos = new FileOutputStream(new File("E:/aaa/luo2.png"));
  39.         //不用缓冲流
  40.         int length = -1;
  41.         while((length = fis.read()) != -1) {
  42.             fos.write(length);
  43.         }
  44.         fis.close();
  45.         fos.close();
  46.         System.out.println("复制完成");
  47.         long end = System.currentTimeMillis();//结束时间  
  48.         System.out.println(end - start);//计算代码运行所用得时间 检查效率
  49.     }
  51. }

3.递归

  1. package com.qfedu.test1file;
  3. import java.io.File;
  5. //递归删除
  6. public class Demo7diguiDEL {
  7.     public static void main(String[] args) {
  8.         //删除某个目录下面所有的文件（包括子文件）   递归
  9.         File file = new File("E:/aaa");
  10.         del(file);
  12.     }
  13.     //递归 删除该位置所有文件
  14.     public static void del(File f) {
  15.         File[] files = f.listFiles();//获取f目录下所有文件和文件夹
  16.         for (File file1 : files) {
  17.             if (file1.isDirectory()) {//是否是文件夹
  18.                 del(file1);//在调用一次方法 （自己调用自己） 递归的思想
  19.             }else {
  20.                 file1.delete();//如果不是文件夹，就是文件，是文件就删除
  21. //                System.out.println(file1.delete());
  22.             }
  23.         }
  24.     }
  26. }