File类
1.使用计算机产品的时候 经常保存文件读取文件
2.包:java.io
3.类:File类型
4.文件和目录路径名的抽象表示形式
5.java把电脑中的文件和文件夹(目录)封装为了一个file类我们可以使用File类对文件和文件夹进行操作
6.可以操作:
- 创建一个文件/文件夹
- 删除文件/文件夹
- 获取文件/文件夹
- 判断文件/文件夹是否存在
- 对文件夹遍历
- 获取文件的大小
- File类是一个与系统无关的类 任何操作系统都可以使用这个类的方法
- 单词:
- file 文 件
- Directory 文件夹/目录
- path 路径
7.字段摘要
static String pathSeparator
与系统有关的路径分隔符, 为了方便,它被表示为一个字符串。
static char pathSeparatorChar
与系统有关的路径分隔符。
static String separator
与系统有关的默认名称分隔符,为了方便,它被表示为一个字符串。 `
static char separatorChar
与系统有关的默认名称分隔符。
案例:
```
package FileDemo;
import java.io.File;
import TestDemo.Test;
/**
- 使用计算机产品的时候 经常保存文件读取文件
- 包:java.io
- 类:File类型
- 文件和目录路径名的抽象表示形式
- java把电脑中的文件和文件夹(目录)封装为了一个file类我们可以使用File类对文件和文件夹进行操作
- 可以操作:
- 创建一个文件/文件夹
- 删除文件/文件夹
- 获取文件/文件夹
- 判断文件/文件夹是否存在
- 对文件夹遍历
- 获取文件的大小
- File类是一个与系统无关的类 任何操作系统都可以使用这个类的方法
- 单词:
- file 文 件
- Directory 文件夹/目录
- path 路径
- @author lenovo
*/
public class FileTest {
public static void main(String[]args) {
String s=File.pathSeparator;//; // ;路径与路径之间用的是;(路径分隔符)c:My:a.txt;D:\Love\b.txt
String s1=File.separator;//\ //\ 名称分隔符
System.out.println(s);
System.out.println(s1);
System.out.println(“F:\codes\java\lesson2\src”+File.pathSeparator+Test.class);
}
}
```
注意事项:
File不分操作系统的 windows 分号 ; Linux 冒号 :
文件分隔符 Windows \反斜杠 Linux 正斜杠/
8.绝对路径和相对路径
1.绝对路径:
案例:F:\codes\java\lesson2\src
分析:
绝对路径是一个完整的路径
以盘符开始:F:\codes\java\lesson2\src
2.相对路径:
案例:/lesson2/src
分析:
相对路径是一个简化的路径
当前项目的根目录:/lesson2/src
注意事项:1.路径是不区分大小写
2.路径中的文件名分隔符windows使用反斜杠 反斜杠是转义字符两个反斜杠代表一个反斜杠
\n换行 \t制表符
案例:
System.out.println(“F:\\codes\\java\\lesson2\\src”);
9.File 类的构造方法
File (File parent, String child)
根据parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
案例:
package FileDemo;
import java.io.File;
import TestDemo.Test;
/**
* 使用计算机产品的时候 经常保存文件读取文件
* 包:java.io
* 类:File类型
* 文件和目录路径名的抽象表示形式
* java把电脑中的文件和文件夹(目录)封装为了一个file类我们可以使用File类对文件和文件夹进行操作
* 可以操作:
* 创建一个文件/文件夹
* 删除文件/文件夹
* 获取文件/文件夹
* 判断文件/文件夹是否存在
* 对文件夹遍历
* 获取文件的大小
* File类是一个与系统无关的类 任何操作系统都可以使用这个类的方法
* 单词:
* file 文 件
* Directory 文件夹/目录
* path 路径
*
* @author lenovo
*
*/
public class FileTest {
public static void main01(String[]args) {
String s=File.pathSeparator;//; // ;路径与路径之间用的是;(路径分隔符)c:My:a.txt;D:\Love\b.txt
String s1=File.separator;//\ //\ 名称分隔符
System.out.println(s);
System.out.println(s1);
System.out.println("F:\\codes\\java\\lesson2\\src"+File.pathSeparator+Test.class);
}
public static void main(String[]args) {
//File类构造方法
//Show1();
//show2("C:\\love\\ini\\lib\\","my\\123.txt");
//好处:父路径和子路径 可以单独书写使用起来非常灵活 父路径和子路径都可以变化
//使用更灵活
File file=new File("C:\\love");
//file.方法()
show3(file,"\\lib\\123.jpg");
//file可以经过一些操作
//使用file之前对其进行一些操作
}
public static void Show1() {
File f1=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banque.java");
//只代表一个路径
//用f1表示一个路径 不用每次在操作时复制绝对路径
System.out.println(f1);//重写了object类的toString
File f2=new File("\\lesson2\\src\\_yzq_banque.java\\123.txt");
//相对路径
System.out.println(f2);
}
public static void show2(String parent,String child) {
File file=new File(parent,child);
System.out.println(file);
}
public static void show3(File parent,String child) {
File file=new File(parent,child);
System.out.println(file);
}
}
好处:
file可以经过一些操作
使用file之前对其进行一些操作
当file满足某些操作时才进行show3操作
父路径和子路径 可以单独书写使用起来非常灵活 父路径和子路径都可以变化
父路径是file类可以使用file的方法对路径进行一些操作再使用路径创建对象
-----------------------------------------------------------------------------
File(String pathname)
通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
案例:
package FileDemo;
import java.io.File;
import TestDemo.Test;
/**
* 使用计算机产品的时候 经常保存文件读取文件
* 包:java.io
* 类:File类型
* 文件和目录路径名的抽象表示形式
* java把电脑中的文件和文件夹(目录)封装为了一个file类我们可以使用File类对文件和文件夹进行操作
* 可以操作:
* 创建一个文件/文件夹
* 删除文件/文件夹
* 获取文件/文件夹
* 判断文件/文件夹是否存在
* 对文件夹遍历
* 获取文件的大小
* File类是一个与系统无关的类 任何操作系统都可以使用这个类的方法
* 单词:
* file 文 件
* Directory 文件夹/目录
* path 路径
*
* @author lenovo
*
*/
public class FileTest {
public static void main01(String[]args) {
String s=File.pathSeparator;//; // ;路径与路径之间用的是;(路径分隔符)c:My:a.txt;D:\Love\b.txt
String s1=File.separator;//\ //\ 名称分隔符
System.out.println(s);
System.out.println(s1);
System.out.println("F:\\codes\\java\\lesson2\\src"+File.pathSeparator+Test.class);
}
public static void main(String[]args) {
//File类构造方法
Show1();
}
public static void Show1() {
File f1=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banque.java");
//只代表一个路径
//用f1表示一个路径 不用每次在操作时复制绝对路径
System.out.println(f1);//重写了object类的toString
File f2=new File("\\lesson2\\src\\_yzq_banque.java\\123.txt");
//相对路径
System.out.println(f2);
}
}
-----------------------------------------------------------------------------------------
File(String parent, String child)
根据parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
案例:
package FileDemo;
import java.io.File;
import TestDemo.Test;
/**
* 使用计算机产品的时候 经常保存文件读取文件
* 包:java.io
* 类:File类型
* 文件和目录路径名的抽象表示形式
* java把电脑中的文件和文件夹(目录)封装为了一个file类我们可以使用File类对文件和文件夹进行操作
* 可以操作:
* 创建一个文件/文件夹
* 删除文件/文件夹
* 获取文件/文件夹
* 判断文件/文件夹是否存在
* 对文件夹遍历
* 获取文件的大小
* File类是一个与系统无关的类 任何操作系统都可以使用这个类的方法
* 单词:
* file 文 件
* Directory 文件夹/目录
* path 路径
*
* @author lenovo
*
*/
public class FileTest {
public static void main01(String[]args) {
String s=File.pathSeparator;//; // ;路径与路径之间用的是;(路径分隔符)c:My:a.txt;D:\Love\b.txt
String s1=File.separator;//\ //\ 名称分隔符
System.out.println(s);
System.out.println(s1);
System.out.println("F:\\codes\\java\\lesson2\\src"+File.pathSeparator+Test.class);
}
public static void main(String[]args) {
//File类构造方法
//Show1();
show2("C:\\love\\ini\\lib\\","my\\123.txt");
//好处:父路径和子路径 可以单独书写使用起来非常灵活 父路径和子路径都可以变化
//使用更灵活
}
public static void Show1() {
File f1=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banque.java");
//只代表一个路径
//用f1表示一个路径 不用每次在操作时复制绝对路径
System.out.println(f1);//重写了object类的toString
File f2=new File("\\lesson2\\src\\_yzq_banque.java\\123.txt");
//相对路径
System.out.println(f2);
}
public static void show2(String parent,String child) {
File file=new File(parent,child);
System.out.println(file);
}
}
File(String parent, String child)构造方法的好处:
父路径和子路径 可以单独书写使用起来非常灵活 父路径和子路径都可以变化
10.File类中常用的方法
1.获取功能方法
1.public String getAbsolutePath():返回此File的绝对路径名字符串
案例:
```
package FileDemo;
import java.io.File;
import TestDemo.Test;
/**
- 使用计算机产品的时候 经常保存文件读取文件
- 包:java.io
- 类:File类型
- 文件和目录路径名的抽象表示形式
- java把电脑中的文件和文件夹(目录)封装为了一个file类我们可以使用File类对文件和文件夹进行操作
- 可以操作:
- 创建一个文件/文件夹
- 删除文件/文件夹
- 获取文件/文件夹
- 判断文件/文件夹是否存在
- 对文件夹遍历
- 获取文件的大小
- File类是一个与系统无关的类 任何操作系统都可以使用这个类的方法
- 单词:
- file 文 件
- Directory 文件夹/目录
- path 路径
- @author lenovo
*/
public class FileTest {
public static void main01(String[]args) {
String s=File.pathSeparator;//; // ;路径与路径之间用的是;(路径分隔符)c:My:a.txt;D:\Love\b.txt
String s1=File.separator;//\ //\ 名称分隔符
System.out.println(s);
System.out.println(s1);
System.out.println(“F:\codes\java\lesson2\src”+File.pathSeparator+Test.class);
}
public static void main02(String[]args) {
//File类构造方法
//Show1();
//show2(“C:\love\ini\lib\”,“my\123.txt”);
//好处:父路径和子路径 可以单独书写使用起来非常灵活 父路径和子路径都可以变化
//使用更灵活
File file=new File("C:\\love");
//file.方法()
show3(file,"\\lib\\123.jpg");
//file可以经过一些操作
//使用file之前对其进行一些操作
}
public static void Show1() {
File f1=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banque.java");
//只代表一个路径
//用f1表示一个路径 不用每次在操作时复制绝对路径
System.out.println(f1);//重写了object类的toString
File f2=new File("\\lesson2\\src\\_yzq_banque.java\\123.txt");
//相对路径
System.out.println(f2);
}
public static void show2(String parent,String child) {
File file=new File(parent,child);
System.out.println(file);
}
public static void show3(File parent,String child) {
File file=new File(parent,child);
System.out.println(file);
}
public static void main(String[]args) {
func1();
}
public static void func1() {
File file=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banqueText.java");
System.out.println(file.getAbsolutePath());
//普通打印绝对路径
File file1=new File("_yzq_banqueText.java");//默认保存到当前项目的根目录 YZQY
System.out.println(file1.getAbsolutePath());//绝对路径加上根目录
//结果:
/**
* F:\codes\java\lesson2\src\_yzq_banqueText.java
F:\codes\java\YZQY\_yzq_banqueText.java
*
*
*
*/
}
}
```
2.public String getPath():将此File转换为路径名字符串
案例:
```
package FileDemo;
import java.io.File;
import TestDemo.Test;
/**
- 使用计算机产品的时候 经常保存文件读取文件
- 包:java.io
- 类:File类型
- 文件和目录路径名的抽象表示形式
- java把电脑中的文件和文件夹(目录)封装为了一个file类我们可以使用File类对文件和文件夹进行操作
- 可以操作:
- 创建一个文件/文件夹
- 删除文件/文件夹
- 获取文件/文件夹
- 判断文件/文件夹是否存在
- 对文件夹遍历
- 获取文件的大小
- File类是一个与系统无关的类 任何操作系统都可以使用这个类的方法
- 单词:
- file 文 件
- Directory 文件夹/目录
- path 路径
- @author lenovo
*/
public class FileTest {
public static void main01(String[]args) {
String s=File.pathSeparator;//; // ;路径与路径之间用的是;(路径分隔符)c:My:a.txt;D:\Love\b.txt
String s1=File.separator;//\ //\ 名称分隔符
System.out.println(s);
System.out.println(s1);
System.out.println(“F:\codes\java\lesson2\src”+File.pathSeparator+Test.class);
}
public static void main02(String[]args) {
//File类构造方法
//Show1();
//show2(“C:\love\ini\lib\”,“my\123.txt”);
//好处:父路径和子路径 可以单独书写使用起来非常灵活 父路径和子路径都可以变化
//使用更灵活
File file=new File("C:\\love");
//file.方法()
show3(file,"\\lib\\123.jpg");
//file可以经过一些操作
//使用file之前对其进行一些操作
}
public static void Show1() {
File f1=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banque.java");
//只代表一个路径
//用f1表示一个路径 不用每次在操作时复制绝对路径
System.out.println(f1);//重写了object类的toString
File f2=new File("\\lesson2\\src\\_yzq_banque.java\\123.txt");
//相对路径
System.out.println(f2);
}
public static void show2(String parent,String child) {
File file=new File(parent,child);
System.out.println(file);
}
public static void show3(File parent,String child) {
File file=new File(parent,child);
System.out.println(file);
}
public static void main(String[]args) {
func2();
}
public static void func1() {
File file=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banqueText.java");
System.out.println(file.getAbsolutePath());
//普通打印绝对路径
File file1=new File("_yzq_banqueText.java");//默认保存到当前项目的根目录 YZQY
System.out.println(file1.getAbsolutePath());//绝对路径加上根目录
//结果:
/**
* F:\codes\java\lesson2\src\_yzq_banqueText.java
F:\codes\java\YZQY\_yzq_banqueText.java
*
*
*
*/
}
public static void func2() {
File file=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banqueText.java");
System.out.println(file.getPath());
File file1=new File("_yzq_banqueText.java");
System.out.println(file1.getPath());//当需要保留原来创建的路径的时候使用getPath
//file1重写toString就是调用getPath
//结果
/*
*
* F:\codes\java\lesson2\src\_yzq_banqueText.java
_yzq_banqueText.java
* 本身是什么就是什么
*
*
*/
}
}
```
3.public String getName():返回由此File表示的文件或目录的名称
案例:
```
package FileDemo;
import java.io.File;
import TestDemo.Test;
/**
- 使用计算机产品的时候 经常保存文件读取文件
- 包:java.io
- 类:File类型
- 文件和目录路径名的抽象表示形式
- java把电脑中的文件和文件夹(目录)封装为了一个file类我们可以使用File类对文件和文件夹进行操作
- 可以操作:
- 创建一个文件/文件夹
- 删除文件/文件夹
- 获取文件/文件夹
- 判断文件/文件夹是否存在
- 对文件夹遍历
- 获取文件的大小
- File类是一个与系统无关的类 任何操作系统都可以使用这个类的方法
- 单词:
- file 文 件
- Directory 文件夹/目录
- path 路径
- @author lenovo
*/
public class FileTest {
public static void main01(String[]args) {
String s=File.pathSeparator;//; // ;路径与路径之间用的是;(路径分隔符)c:My:a.txt;D:\Love\b.txt
String s1=File.separator;//\ //\ 名称分隔符
System.out.println(s);
System.out.println(s1);
System.out.println(“F:\codes\java\lesson2\src”+File.pathSeparator+Test.class);
}
public static void main02(String[]args) {
//File类构造方法
//Show1();
//show2(“C:\love\ini\lib\”,“my\123.txt”);
//好处:父路径和子路径 可以单独书写使用起来非常灵活 父路径和子路径都可以变化
//使用更灵活
File file=new File("C:\\love");
//file.方法()
show3(file,"\\lib\\123.jpg");
//file可以经过一些操作
//使用file之前对其进行一些操作
}
public static void Show1() {
File f1=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banque.java");
//只代表一个路径
//用f1表示一个路径 不用每次在操作时复制绝对路径
System.out.println(f1);//重写了object类的toString
File f2=new File("\\lesson2\\src\\_yzq_banque.java\\123.txt");
//相对路径
System.out.println(f2);
}
public static void show2(String parent,String child) {
File file=new File(parent,child);
System.out.println(file);
}
public static void show3(File parent,String child) {
File file=new File(parent,child);
System.out.println(file);
}
public static void main(String[]args) {
func3();
}
public static void func1() {
File file=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banqueText.java");
System.out.println(file.getAbsolutePath());
//普通打印绝对路径
File file1=new File("_yzq_banqueText.java");//默认保存到当前项目的根目录 YZQY
System.out.println(file1.getAbsolutePath());//绝对路径加上根目录
//结果:
/**
* F:\codes\java\lesson2\src\_yzq_banqueText.java
F:\codes\java\YZQY\_yzq_banqueText.java
*
*
*
*/
}
public static void func2() {
File file=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banqueText.java");
System.out.println(file.getPath());
File file1=new File("_yzq_banqueText.java");
System.out.println(file1.getPath());
//结果
/*
*
* F:\codes\java\lesson2\src\_yzq_banqueText.java
_yzq_banqueText.java
* 本身是什么就是什么
*
*
*/
}
public static void func3() {
File file=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banqueText.java");
System.out.println(file.getName());
File file1=new File("_yzq_banqueText.java");
System.out.println(file1.getName());//打印最后一层的文件或文件夹
//结果:
/**
*
* _yzq_banqueText.java
_yzq_banqueText.java
*
*
*
*
*
*
*
*/
}
}
```
4.public long length():返回由此File类表示的文件的长度
案例:
```
package FileDemo;
import java.io.File;
import TestDemo.Test;
/**
- 使用计算机产品的时候 经常保存文件读取文件
- 包:java.io
- 类:File类型
- 文件和目录路径名的抽象表示形式
- java把电脑中的文件和文件夹(目录)封装为了一个file类我们可以使用File类对文件和文件夹进行操作
- 可以操作:
- 创建一个文件/文件夹
- 删除文件/文件夹
- 获取文件/文件夹
- 判断文件/文件夹是否存在
- 对文件夹遍历
- 获取文件的大小
- File类是一个与系统无关的类 任何操作系统都可以使用这个类的方法
- 单词:
- file 文 件
- Directory 文件夹/目录
- path 路径
- @author lenovo
*/
public class FileTest {
public static void main01(String[]args) {
String s=File.pathSeparator;//; // ;路径与路径之间用的是;(路径分隔符)c:My:a.txt;D:\Love\b.txt
String s1=File.separator;//\ //\ 名称分隔符
System.out.println(s);
System.out.println(s1);
System.out.println(“F:\codes\java\lesson2\src”+File.pathSeparator+Test.class);
}
public static void main02(String[]args) {
//File类构造方法
//Show1();
//show2(“C:\love\ini\lib\”,“my\123.txt”);
//好处:父路径和子路径 可以单独书写使用起来非常灵活 父路径和子路径都可以变化
//使用更灵活
File file=new File("C:\\love");
//file.方法()
show3(file,"\\lib\\123.jpg");
//file可以经过一些操作
//使用file之前对其进行一些操作
}
public static void Show1() {
File f1=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banque.java");
//只代表一个路径
//用f1表示一个路径 不用每次在操作时复制绝对路径
System.out.println(f1);//重写了object类的toString
File f2=new File("\\lesson2\\src\\_yzq_banque.java\\123.txt");
//相对路径
System.out.println(f2);
}
public static void show2(String parent,String child) {
File file=new File(parent,child);
System.out.println(file);
}
public static void show3(File parent,String child) {
File file=new File(parent,child);
System.out.println(file);
}
public static void main(String[]args) {
func4();
}
public static void func1() {
File file=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banqueText.java");
System.out.println(file.getAbsolutePath());
//普通打印绝对路径
File file1=new File("_yzq_banqueText.java");//默认保存到当前项目的根目录 YZQY
System.out.println(file1.getAbsolutePath());//绝对路径加上根目录
//结果:
/**
* F:\codes\java\lesson2\src\_yzq_banqueText.java
F:\codes\java\YZQY\_yzq_banqueText.java
*
*
*
*/
}
public static void func2() {
File file=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banqueText.java");
System.out.println(file.getPath());
File file1=new File("_yzq_banqueText.java");
System.out.println(file1.getPath());
//结果
/*
*
* F:\codes\java\lesson2\src\_yzq_banqueText.java
_yzq_banqueText.java
* 本身是什么就是什么
*
*
*/
}
public static void func3() {
File file=new File("F:\\codes\\java\\lesson2\\src\\_yzq_banqueText.java");
System.out.println(file.getName());
File file1=new File("_yzq_banqueText.java");
System.out.println(file1.getName());//打印最后一层的文件或
//结果:
/**
*
* _yzq_banqueText.java
_yzq_banqueText.java
*
*
*
*
*
*
*
*/
}
public static void func4() {
File file=new File(“C:\Users\lenovo\Desktop\1.png”);
System.out.println(file.length());
File file1=new File("123.txt");
System.out.println(file1.length());//打印最后一层的文件或
//结果:
/**
*
* 16048
0
*
*
*
*
*
*
*
*/
}
}
```
2.判断功能方法
1.public boolean existe():此File表示的文件或目录是否实际存在
案例:
```
package TestDemo;
import java.io.File;
//exists判断文件是否存在 返回一个布尔值
public class Test1 {
public static void main(String[]args) {
method1();
}
public static void method1() {
// File file=new File(“F:\codes\java\lesson2\src\_yzq_banqueText.java\123.txt”);
// System.out.println(file.exists());
//
// File file1=new File("_yzq_banqueText.java");
// System.out.println(file1.exists());
//结果: false false
File file=new File(“F:\codes\java\lesson2\src\_yzq_banqueText.java”);
System.out.println(file.exists());
File file1=new File("_yzq_banqueText.java");
System.out.println(file1.exists());
//运行结果:True False
}
}
```
2.public boolean isDirectory():此File表示的是否为目录
案例:
```
package TestDemo;
import java.io.File;
//exists判断文件是否存在 返回一个布尔值
public class Test1 {
public static void main(String[]args) {
method1();
}
public static void method1() {
// File file=new File(“F:\codes\java\lesson2\src\_yzq_banqueText.java\123.txt”);
// System.out.println(file.exists());
//
// File file1=new File("_yzq_banqueText.java");
// System.out.println(file1.exists());
//结果: false false
File file=new File(“F:\codes\java\lesson2\src”);
System.out.println(file.isDirectory());
File file1=new File(“src”);
System.out.println(file1.isDirectory());
//运行结果:True True
}
}
```
3.public boolean isFile():此File表示的是否为文件
案例:
```
package TestDemo;
import java.io.File;
//exists判断文件是否存在 返回一个布尔值
public class Test1 {
public static void main(String[]args) {
method1();
}
public static void method1() {
// File file=new File(“F:\codes\java\lesson2\src\_yzq_banqueText.java\123.txt”);
// System.out.println(file.exists());
//
// File file1=new File("_yzq_banqueText.java");
// System.out.println(file1.exists());
//结果: false false
File file=new File(“F:\codes\java\lesson2\src”);
System.out.println(file.isDirectory());//True
System.out.println(file.isFile());//false
File file1=new File(“src”);
System.out.println(file1.isDirectory());//false
System.out.println(file1.isFile());//true
//
}
}
```
3.创建和删除方法
1.public boolean createNewFile():当且仅当具有该名称的文件尚不存在时,创建一个新的空文件
案例:
```
package TestDemo;
import java.io.File;
import java.io.IOException;
//exists判断文件是否存在 返回一个布尔值
public class Test1 {
public static void main01(String[]args) {
method1();
}
public static void method1() {
// File file=new File(“F:\codes\java\lesson2\src\_yzq_banqueText.java\123.txt”);
// System.out.println(file.exists());
//
// File file1=new File("_yzq_banqueText.java");
// System.out.println(file1.exists());
//结果: false false
File file=new File(“F:\codes\java\lesson2\src”);
System.out.println(file.isDirectory());//True
System.out.println(file.isFile());//false
File file1=new File(“src”);
System.out.println(file1.isDirectory());//false
System.out.println(file1.isFile());//true
//运行结果:True False
}
public static void main(String[]args) throws IOException {
Test1();
}
public static void Test1() throws IOException {
File file=new File("F:\\codes\\java\\lesson2\\src\\Yzq3");
boolean b =file.createNewFile();
System.out.println(file.isDirectory());
File file1=new File("q.txt");
System.out.println(file1.createNewFile());
File file2=new File("src//homework");//创建的还是文件
System.out.println(file2.createNewFile());
//运行结果: false false True
//路径错误报错
}
}
```
案例:
```
package TestDemo;
import java.io.File;
import java.io.IOException;
//exists判断文件是否存在 返回一个布尔值
public class Test1 {
public static void main01(String[]args) {
method1();
}
public static void method1() {
// File file=new File(“F:\codes\java\lesson2\src\_yzq_banqueText.java\123.txt”);
// System.out.println(file.exists());
//
// File file1=new File("_yzq_banqueText.java");
// System.out.println(file1.exists());
//结果: false false
File file=new File(“F:\codes\java\lesson2\src”);
System.out.println(file.isDirectory());//True
System.out.println(file.isFile());//false
File file1=new File(“src”);
System.out.println(file1.isDirectory());//false
System.out.println(file1.isFile());//true
//运行结果:True False
}
public static void main(String[]args) throws IOException {
Test1();
}
public static void Test1() throws IOException {
File file=new File("F:\\codes\\java\\lesson2\\src\\Yzq3");
System.out.println(file.isDirectory());
boolean b =file.createNewFile();
File file1=new File("m.txt");
System.out.println(file1.createNewFile());
//运行结果: false True
}
}
```
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vy7RWuMh-1601987061113)(C:\Users\lenovo\Desktop\双向链表\2020-10-06_162802.png)]
2.public boolean delete():删除由此File表示的文件或目录
案例:
```
package TestDemo;
import java.io.File;
import java.io.IOException;
//exists判断文件是否存在 返回一个布尔值
public class Test1 {
public static void main01(String[]args) {
method1();
}
public static void method1() {
// File file=new File(“F:\codes\java\lesson2\src\_yzq_banqueText.java\123.txt”);
// System.out.println(file.exists());
//
// File file1=new File("_yzq_banqueText.java");
// System.out.println(file1.exists());
//结果: false false
File file=new File(“F:\codes\java\lesson2\src”);
System.out.println(file.isDirectory());//True
System.out.println(file.isFile());//false
File file1=new File(“src”);
System.out.println(file1.isDirectory());//false
System.out.println(file1.isFile());//true
//运行结果:True False
}
public static void main(String[]args) throws IOException {
Test1();
}
public static void Test1() throws IOException {
File file=new File("F:\\codes\\java\\lesson2\\src\\Yzq3");
boolean b =file.delete();
System.out.println(b);
}
}
结果:
true
```
3.public boolean mkdir():创建由此File表示的目录
案例:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gvH4VMjt-1601987061116)(C:\Users\lenovo\Desktop\双向链表\2020-10-06_170338.png)]
4.public boolean mkdirs:创建由此File表示的目录,包括任何必须但不存在的父目录
案例:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zpx86nCf-1601987061118)(C:\Users\lenovo\Desktop\双向链表\2020-10-06_170932.png)]
4.File类遍历(文件夹)目录功能
1.public String[] list():返回一个String数组,表示该File目录中的所有子文件或目录
获取所有文件的字符串的名字
2.public File[] listFiles():返回一个File数组,表示该File目录中的所有的文件或目录
获取所有的文件然后打印文件的名字
案例:
```
package FileDemo;
import java.io.File;
/**
*
- 遍历
- @author lenovo
*/
public class FileTest2 {
public static void main(String[]args) {
File file=new File("F:\\codes\\java\\lesson2\\src\\456\\789");
String[]strArr =file.list();
for(String s:strArr) {
System.out.println(s);
}
File[]files=file.listFiles();
for(File name:files) {
System.out.println(name);
System.out.println(name.getName());
System.out.println(name.getAbsolutePath());
}
}
}
结果:
homeWork
F:\codes\java\lesson2\src\456\789\homeWork
homeWork
F:\codes\java\lesson2\src\456\789\homeWork
```
注意事项:
list和listfiles只能遍历当前目录的子文件或者子文件夹
5.如何打印文件中的包含的文件夹的文件以及包含的文件夹
案例:
```
package FileDemo;
import java.io.File;
/**
*
- 遍历
- @author lenovo
*/
public class FileTest2 {
public static void main01(String[]args) {
File file=new File("F:\\codes\\java\\lesson2\\src\\456\\789\\123.txt");
//不能遍历文件只能遍历目录
/**
*
*错误提示:
* Exception in thread "main" java.lang.NullPointerException
at FileDemo.FileTest2.main(FileTest2.java:20)
*
*
*
*
*/
String[]strArr =file.list();
for(String s:strArr) {
System.out.println(s);
}
File[]files=file.listFiles();
for(File name:files) {
System.out.println(name);
System.out.println(name.getName());
System.out.println(name.getAbsolutePath());
System.out.println(name.getParent());
}
}
//当遍历到一个文件的时候判断它是一个文件夹还是文件
public static void main(String[]args) {
File file =new File("E:\\abc");
getAllFile(file);
// String[]strArr=file.list();
// for(String s:strArr) {
// System.out.println(s);
// }
//
}
public static void getAllFile(File dir) {
File[]files=dir.listFiles();
for(File file:files) {
if(file.isDirectory()) {
System.out.println(file);
//如果是一个文件夹 继续遍历
getAllFile(file);
}
else {
System.out.println(file);
}
}
}
}
结果:
E:\abc\a
E:\abc\a\a.txt
E:\abc\a.txt
E:\abc\abc.txt
E:\abc\b
E:\abc\b.txt
```
6.案例2如何打印java文件夹中的.java文件
案例:
```
package FileDemo;
import java.io.File;
/**
*
- 遍历
- @author lenovo
*/
public class FileTest2 {
public static void main01(String[]args) {
File file=new File("F:\\codes\\java\\lesson2\\src\\456\\789\\123.txt");
//不能遍历文件只能遍历目录
/**
*
*错误提示:
* Exception in thread "main" java.lang.NullPointerException
at FileDemo.FileTest2.main(FileTest2.java:20)
*
*
*
*
*/
String[]strArr =file.list();
for(String s:strArr) {
System.out.println(s);
}
File[]files=file.listFiles();
for(File name:files) {
System.out.println(name);
System.out.println(name.getName());
System.out.println(name.getAbsolutePath());
System.out.println(name.getParent());
}
}
//当遍历到一个文件的时候判断它是一个文件夹还是文件
public static void main(String[]args) {
File file =new File("E:\\abc");
getAllFile(file);
// String[]strArr=file.list();
// for(String s:strArr) {
// System.out.println(s);
// }
//
}
public static void getAllFile(File dir) {
File[]files=dir.listFiles();
for(File file:files) {
if(file.isDirectory()) {
//如果是一个文件夹 继续遍历
getAllFile(file);
}
else {
//判断当前文件是不是。java文件 endswith() 判断是不是。txt结尾
String name=file.getName();
if(name.endsWith(".java")) {
System.out.println(file);
}
}
}
}
}
结果:
E:\abc\a\a.java
E:\abc\a.java
E:\abc\b\b.java
E:\abc\b.java
```
7.案例3.如何不区别大小写
package FileDemo;
import java.io.File;
/**
*
* 遍历
*
*
*
*
* @author lenovo
*
*/
public class FileTest2 {
public static void main01(String[]args) {
File file=new File("F:\\codes\\java\\lesson2\\src\\456\\789\\123.txt");
//不能遍历文件只能遍历目录
/**
*
*错误提示:
* Exception in thread "main" java.lang.NullPointerException
at FileDemo.FileTest2.main(FileTest2.java:20)
*
*
*
*
*/
String[]strArr =file.list();
for(String s:strArr) {
System.out.println(s);
}
File[]files=file.listFiles();
for(File name:files) {
System.out.println(name);
System.out.println(name.getName());
System.out.println(name.getAbsolutePath());
System.out.println(name.getParent());
}
}
//当遍历到一个文件的时候判断它是一个文件夹还是文件
public static void main(String[]args) {
File file =new File("E:\\abc");
getAllFile(file);
// String[]strArr=file.list();
// for(String s:strArr) {
// System.out.println(s);
// }
//
}
public static void getAllFile(File dir) {
File[]files=dir.listFiles();
for(File file:files) {
if(file.isDirectory()) {
//如果是一个文件夹 继续遍历
getAllFile(file);
}
else {
//判断当前文件是不是。java文件 endswith() 判断是不是。txt结尾
String name=file.getName();
if(name.toLowerCase().endsWith(".java")) {
System.out.println(file);
}
}
}
}
}
结果:
E:\abc\a\a.java
E:\abc\a.java
E:\abc\b\b.java
E:\abc\b.java
toLowerCase()大写转小写
endsWith判断结尾
8.String[] list(FilenameFile filter)方法
1.含义:返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中满足指定过滤的文件和目录
FilenameFilter接口:实现此接口的类实例可用于过滤器文件名
2.方法摘要:
boolean accept(File dir,String name)
含义:
测试指定文件是否应该包含在某一文件列表中。
案例:
```
package FileDemo;
import java.io.File;
import java.io.FilenameFilter;
/**
- FileFilter接口: 实现此接口的类实例可用于过滤文件名。(筛选符合条件的文件)
- @author lenovo
*/
public class FileTest3 {
public static void main01(String[]args) {
File file=new File(“E:\abc”);
File []strArr=file.listFiles(new FileFileterImpl());
//过滤完之后只有文件夹和。java文件
for(File file2:strArr) {
System.out.println(file2);
}
}
public static void main(String[]args) {
File file=new File(“E:\abc”);
getAllFile(file);
}
public static void getAllFile(File dir) {
//File[]files=dir.listFiles(new FileFileterImpl());
// File[]files=dir.listFiles(new FilenameFilter() {
//
//
//
//
// public boolean accept(File pathname) {
// // TODO 自动生成的方法存根
// if(pathname.isDirectory()) {
// return true;
// }
// return pathname.getName().toLowerCase().endsWith(".java");
// }
//
//
//
//
// });
File[]files=dir.listFiles((a)->{return a.isDirectory()||a.getName().toLowerCase().endsWith(".java");});
for(File file:files) {
if(file.isDirectory()) {
//如果是一个文件夹 继续遍历
getAllFile(file);
}
else {
System.out.println(file);
}
}
}
}
package FileDemo;
import java.io.File;
import java.io.FileFilter;
public class FileFileterImpl implements FileFilter {
@Override
public boolean accept(File pathname) {
if(pathname.isDirectory()) {
return true;
}
return pathname.getName().toLowerCase().endsWith(".java");
}
}
结果:
E:\abc\a\a.java
E:\abc\a.java
E:\abc\b\b.java
E:\abc\b.java
```
: 实现此接口的类实例可用于过滤文件名。(筛选符合条件的文件)
*
*
*
*
*
- @author lenovo
*/
public class FileTest3 {
public static void main01(String[]args) {
File file=new File(“E:\abc”);
File []strArr=file.listFiles(new FileFileterImpl());
//过滤完之后只有文件夹和。java文件
for(File file2:strArr) {
System.out.println(file2);
}
}
public static void main(String[]args) {
File file=new File(“E:\abc”);
getAllFile(file);
}
public static void getAllFile(File dir) {
//File[]files=dir.listFiles(new FileFileterImpl());
// File[]files=dir.listFiles(new FilenameFilter() {
//
//
//
//
// public boolean accept(File pathname) {
// // TODO 自动生成的方法存根
// if(pathname.isDirectory()) {
// return true;
// }
// return pathname.getName().toLowerCase().endsWith(".java");
// }
//
//
//
//
// });
File[]files=dir.listFiles((a)->{return a.isDirectory()||a.getName().toLowerCase().endsWith(".java");});
for(File file:files) {
if(file.isDirectory()) {
//如果是一个文件夹 继续遍历
getAllFile(file);
}
else {
System.out.println(file);
}
}
}
}
package FileDemo;
import java.io.File;
import java.io.FileFilter;
public class FileFileterImpl implements FileFilter {
@Override
public boolean accept(File pathname) {
if(pathname.isDirectory()) {
return true;
}
return pathname.getName().toLowerCase().endsWith(".java");
}
}
结果:
E:\abc\a\a.java
E:\abc\a.java
E:\abc\b\b.java
E:\abc\b.java
```