JavaSE进阶09：Stream流、File类
系列文章目录
JavaSE进阶01：继承、修饰符
JavaSE进阶02：多态、抽象类、接口
JavaSE进阶03：内部类、Lambda表达式
JavaSE进阶04：API中常用工具类
JavaSE进阶05：包装类、递归、数组的高级操作、异常
JavaSE进阶06：Collection集合、迭代器、List、ArrayList、LinkedList
JavaSE进阶07：泛型、Set集合、TreeSet、二叉树、红黑树
JavaSE进阶08：HashSet、Map集合、HashMap、TreeMap、可变参数、不可变集合
JavaSE进阶09：Stream流、File类
JavaSE进阶10：IO流、字节流、字节缓冲流
JavaSE进阶11：字符流、字符缓冲流、转换流、对象操作流、Properties集合
JavaSE进阶12：多线程、线程同步、线程池
JavaSE进阶13：网络编程入门、UDP通信程序、TCP通信程序、日志、枚举
JavaSE进阶14：类加载器、反射
JavaSE进阶15：XML、注解、单元测试
JavaSE进阶扩充：JDK8 HashMap底层分析（了解）
JavaSE进阶扩充：JDK8 ArrayList线程安全问题和源码分析、集合常见面试题
Java进阶作业
文章目录
- 系列文章目录
-
- 1.Stream流
-
- 1.1Stream流概述【理解】
- 1.2Stream流的常见生成方式【应用】
- 1.3Stream流中间操作方法【应用】
- 1.4Stream流终结操作方法【应用】
- 1.5Stream流的收集操作【应用】
- 2.File类
-
- 2.1File类概述和构造方法【应用】
- 2.2绝对路径和相对路径【理解】
- 2.3File类创建功能【应用】
- 2.4File类删除功能【应用】
- 2.5File类判断和获取功能【应用】
- 2.6File类练习一：创建文件【应用】
- 2.7File类练习二：删除一个多级文件夹【应用】
- 2.8File类练习三： 统计文件夹中每种文件的个数【应用】
1.Stream流
1.1Stream流概述【理解】
-
Stream流的好处
- 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印
- Stream流把真正的函数式编程风格引入到Java中
- 代码简洁
-
Stream流的思想
-
Stream流的三类方法
- 获取Stream流
- 创建一条流水线,并把数据放到流水线上准备进行操作
- 中间方法
- 流水线上的操作
- 一次操作完毕之后,还可以继续进行其他操作
- 终结方法
- 一个Stream流只能有一个终结方法
- 是流水线上的最后一个操作
- 获取Stream流
-
案例需求
按照下面的要求完成集合的创建和遍历
- 创建一个集合，存储多个字符串元素
- 把集合中所有以"张"开头的元素存储到一个新的集合
- 把"张"开头的集合中的长度为3的元素存储到一个新的集合
- 遍历上一步得到的集合
-
原始方式示例代码
import java.util.*;
public class MyStream1 {
public static void main(String[] args) {
//集合的批量添加
ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
//list.add()
//遍历list1把以张开头的元素添加到list2中。
ArrayList<String> list2 = new ArrayList<>();
for (String s : list1) {
if(s.startsWith("张")){
list2.add(s);
}
}
//遍历list2集合，把其中长度为3的元素，再添加到list3中。
ArrayList<String> list3 = new ArrayList<>();
for (String s : list2) {
if(s.length() == 3){
list3.add(s);
}
}
for (String s : list3) {
System.out.println(s);
}
}
}
/*
张三丰
张无忌
张翠山
*/
- 使用Stream流示例代码
package Stream;
import java.util.ArrayList;
import java.util.List;
public class StreamDemo {
public static void main(String[] args) {
//集合的批量添加
ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
//Stream流
list1.stream().filter(s->s.startsWith("张"))
.filter(s->s.length() == 3)
.forEach(s-> System.out.println(s));
}
}
/*
张三丰
张无忌
张翠山
*/
1.2Stream流的常见生成方式【应用】
-
生成Stream流的方式
-
Collection体系单列集合
使用默认方法stream()生成流。
集合对象.stream(); -
Map体系双列集合
把Map转成Set集合，间接的生成流。
集合对象.keySet().steam(); 所有键放入流
集合对象.values().stream(); 所有值放入流
集合对象.entrySet().stream(); 所有键值对放入流 -
数组
通过Arrays中的静态方法stream生成流。
Arrays.stream(数组名); -
同种数据类型的多个数据
通过Stream接口的静态方法of(T… values)生成流
Stream.of(数据1,数据2,数据3…);
-
package Stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.stream.Stream;
public class MyStream1 {
public static void main(String[] args) {
method1();//单列集合
method2();//双列集合
method3();//数组
method4();//同种数据类型的多个数据
}
private static void method4() {
System.out.println("--------同种数据类型的多个数据放入流----------");
Stream.of(1.1,2.2,3.3,4.4).forEach(s-> System.out.println(s));
}
private static void method3() {
System.out.println("--------数组放入流----------");
int [] arr = {1,2,3};
Arrays.stream(arr).forEach(s-> System.out.println(s));
}
private static void method2() {
HashMap<String,Integer> hm = new HashMap<>();
hm.put("zhangsan",23);
hm.put("lisi",24);
hm.put("wangwu",25);
hm.put("zhaoliu",26);
hm.put("qianqi",27);
//双列集合不能直接获取Stream流
System.out.println("---------所有键放入流---------");
//方式1：keySet。先获取到所有的键，再把这个Set集合中所有的键放到Stream流中。
hm.keySet().stream().forEach(s-> System.out.println(s));
System.out.println("---------所有值放入流---------");
//方式2：entrySet。先获取到所有的值，再把这个Collection集合中所有的值放到Stream流中。
hm.values().stream().forEach(s-> System.out.println(s));
System.out.println("--------所有键值对放入流----------");
//方式3：entrySet。先获取到所有的键值对对象，再把这个Set集合中所有的键值对对象放到Stream流中。
hm.entrySet().stream().forEach(s-> System.out.println(s));
}
private static void method1() {
System.out.println("--------单列集合放入流----------");
ArrayList<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
// Stream stream = list.stream();
// stream.forEach(s-> System.out.println(s));
list.stream().forEach(s-> System.out.println(s));
}
}
/*
--------单列集合放入流----------
aaa
bbb
ccc
---------所有键放入流---------
lisi
qianqi
zhaoliu
zhangsan
wangwu
---------所有值放入流---------
24
27
26
23
25
--------所有键值对放入流----------
lisi=24
qianqi=27
zhaoliu=26
zhangsan=23
wangwu=25
--------数组放入流----------
1
2
3
--------同种数据类型的多个数据放入流----------
1.1
2.2
3.3
4.4
*/
1.3Stream流中间操作方法【应用】
-
概念
中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作
-
常见方法
方法名 说明 Stream filter(Predicate predicate) 用于对流中的数据进行过滤 Stream limit(long maxSize) 返回此流中的元素组成的流，截取前指定参数个数的数据 Stream skip(long n) 跳过指定参数个数的数据，返回由该流的剩余元素组成的流 static Stream concat(Stream a, Stream b) 合并a和b两个流为一个流 Stream distinct() 返回由该流的不同元素（根据Object.equals(Object) ）组成的流 -
filter代码演示
import java.util.ArrayList;
import java.util.function.Predicate;
public class Demo02 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三丰");
arrayList.add("张无忌");
arrayList.add("野原新之助");
arrayList.add("王二麻子");
arrayList.add("张良");
//Stream filter(Predicate predicate);
/*
filter方法是获取流中的每一个数据
test方法中的s,就依次表示流中的每一个数据，如果判断的结果为true,就留下当前数据。为false,就不留。
*/
//匿名内部类完整格式
arrayList.stream().filter(new Predicate<String>() {
@Override
public boolean test(String s) {
boolean result = s.length() == 4;
return result;
}
}).forEach(s -> System.out.println(s));
//Lambda不省略
arrayList.stream().filter(
(String s)->{
boolean result = s.length() == 5;
return result;
}
).forEach(s -> System.out.println(s));
//Lambda省略
arrayList.stream().filter(s -> s.length() == 2).forEach(s -> System.out.println(s));
}
}
/*
王二麻子
野原新之助
张良
*/
- limit、skip、concat、distinct代码演示
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo03 {
public static void main(String[] args) {
//创建一个集合，存储多个字符串元素
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("张三丰");
arrayList.add("张无忌");
arrayList.add("野原新之助");
arrayList.add("王二麻子");
arrayList.add("张良");
System.out.println("----需求1：取前4个数据在控制台输出----");
arrayList.stream().limit(4).forEach(s-> System.out.println(s));
System.out.println("----需求2：跳过2个元素，把剩下的元素在控制台输出----");
arrayList.stream().skip(2).forEach(s-> System.out.println(s));
System.out.println("----需求3：跳过2个元素，把剩下的元素中前2个在控制台输出----");
arrayList.stream().skip(2).limit(2).forEach(s-> System.out.println(s));
System.out.println("----需求4：合并需求1和需求2得到的流，并把结果在控制台输出----");
Stream<String> s1 = arrayList.stream().limit(4);
Stream<String> s2 = arrayList.stream().skip(2);
Stream.concat(s1,s2).forEach(s-> System.out.println(s));
System.out.println("----需求5：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复----");
Stream<String> s3 = arrayList.stream().limit(4);
Stream<String> s4 = arrayList.stream().skip(2);
Stream.concat(s3,s4).distinct().forEach(s-> System.out.println(s));
}
}
/*
----需求1：取前4个数据在控制台输出----
张三丰
张无忌
野原新之助
王二麻子
----需求2：跳过2个元素，把剩下的元素在控制台输出----
野原新之助
王二麻子
张良
----需求3：跳过2个元素，把剩下的元素中前2个在控制台输出----
野原新之助
王二麻子
----需求4：合并需求1和需求2得到的流，并把结果在控制台输出----
张三丰
张无忌
野原新之助
王二麻子
野原新之助
王二麻子
张良
----需求5：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复----
张三丰
张无忌
野原新之助
王二麻子
张良
*/
1.4Stream流终结操作方法【应用】
-
概念
终结操作的意思是,执行完此方法之后,Stream流将不能再执行其他操作
-
常见方法
方法名 说明 void forEach(Consumer action) 对此流的每个元素执行操作 long count() 返回此流中的元素数
import java.util.ArrayList;
import java.util.function.Consumer;
public class MyStream5 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("野原新之助");
arrayList.add("王二麻子");
method1(arrayList);
// long count()：返回此流中的元素数
long count = arrayList.stream().count();
System.out.println("此流中的元素数:"+count);
}
private static void method1(ArrayList<String> list) {
// void forEach(Consumer action)：对此流的每个元素执行操作
// Consumer接口中的方法void accept(T t)：对给定的参数执行此操作
//在forEach方法的底层,会循环获取到流中的每一个数据.
//并循环调用accept方法,并把每一个数据传递给accept方法
//s就依次表示了流中的每一个数据.
//所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.
System.out.println("==========Consumer匿名内部类==========");
list.stream().forEach(
new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
}
);
System.out.println("==========Lambda表达式==========");
//Consumer接口中,只有一个accept方法,它是函数接口
list.stream().forEach(
(String s)->{
System.out.println(s);
}
);
System.out.println("==========Lambda省略格式==========");
list.stream().forEach(s->System.out.println(s));
}
}
/*
==========Consumer匿名内部类==========
野原新之助
王二麻子
==========Lambda表达式==========
野原新之助
王二麻子
==========Lambda省略格式==========
野原新之助
王二麻子
此流中的元素数:2
*/
1.5Stream流的收集操作【应用】
-
概念
对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中。
因为Steam流不会对原数据做任何修改，若想得到流操作后的数据需要在终结前收集。 -
常用方法
方法名 说明 R collect(Collector collector) 把结果收集到集合中 -
工具类Collectors提供了具体的收集方式
方法名 说明 public static Collector toList() 把元素收集到List集合中 public static Collector toSet() 把元素收集到Set集合中 public static Collector toMap(Function keyMapper,Function valueMapper) 把元素收集到Map集合中 -
Stream流不修改源数据代码演示
import java.util.ArrayList;
import java.util.List;
public class MyStream6 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
list.add(i);
}
//筛选出能被2整除的数
list.stream().filter(number -> number % 2 == 0).forEach(number -> System.out.println(number));
System.out.println("====================");
for (Integer integer : list) {
System.out.println(integer);
}
}
}
/*
2
4
6
8
10
====================
12345678910
*/
- Stream收集操作代码演示
- toList和toSet方法演示：
import java.util.*;
import java.util.stream.Collectors;
// toList和toSet方法演示
public class MyStream6 {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
list1.add(i);
}
list1.add(10);
list1.add(10);
list1.add(10);
//filter只负责过滤数据的。
//collect只负责收集数据，但是他不负责创建容器,也不负责把数据添加到容器中。
//Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.
List<Integer> list2 = list1.stream().filter(number -> number % 2 == 0)
.collect(Collectors.toList());
System.out.println("Collectors.toList():"+list2);//List可重复
Set<Integer> set = list1.stream().filter(number -> number % 2 == 0)
.collect(Collectors.toSet());
System.out.println("Collectors.toSet():"+set);//Set不可重复，toSet()会帮助去重
}
}
/*
Collectors.toList():[2, 4, 6, 8, 10, 10, 10, 10]
Collectors.toSet():[2, 4, 6, 8, 10]
*/
import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;
/**
保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
*/
public class MyStream8 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("zhangsan,23");
arrayList.add("lisi,24");
arrayList.add("wangwu,25");
Map<String, Integer> map = arrayList.stream().filter(
s -> {
String[] split = s.split(",");
int age = Integer.parseInt(split[1]);
return age >= 24;
}
//Collectors.toMap 创建一个map集合并将数据添加到集合当中
).collect(Collectors.toMap(
s -> s.split(",")[0],//该lambda表达式是如何获取到Map中的键
s -> Integer.parseInt(s.split(",")[1]) ));//该lambda表达式是如何获取Map中的值
System.out.println(map);
}
}
/*
{lisi=24, wangwu=25}
*/
2.File类
IO就可以对硬盘中的文件进行读写
File表示要读写的文件在哪，也可以对文件进行创建，删除等操作
2.1File类概述和构造方法【应用】
-
File类介绍
- 它是文件和目录路径名的抽象表示
- 文件和目录是可以通过File封装成对象的
- 对于File而言,其封装的并不是一个真正存在的文件,仅仅是一个路径名而已.它可以是存在的,也可以是不存在的.将来是要通过具体的操作把这个路径的内容转换为具体存在的
-
File类的构造方法
方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例 File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例 File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例
import java.io.File;
public class FileDemo01 {
public static void main(String[] args) {
//File(String pathname): 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
File f1 = new File("D:\\JavaSpace\\java.txt");
System.out.println(f1);//D:\JavaSpace\java.txt
//File(String parent, String child): 从父路径名字符串和子路径名字符串创建新的 File实例
File f2 = new File("D:\\JavaSpace","java.txt");
System.out.println(f2);//D:\JavaSpace\java.txt
//File(File parent, String child): 从父抽象路径名和子路径名字符串创建新的 File实例
File f3 = new File("D:\\JavaSpace");
File f4 = new File(f3,"java.txt");
System.out.println(f4);//D:\JavaSpace\java.txt
}
}
2.2绝对路径和相对路径【理解】
-
绝对路径
是一个完整的路径,从盘符开始
-
相对路径
是一个简化的路径,相对当前项目下的路径
import java.io.File;
public class FileDemo02 {
public static void main(String[] args) {
// 是一个完整的路径,从盘符开始
File file1 = new File("D:\\JavaSpace\\a.txt");//绝对路径
//当前项目根目录下的a.txt
File file2 = new File("a.txt");
//当前项目的指定模块下的b.txt
File file3 = new File("模块名\\b.txt");
}
}
File file2 = new File(“a.txt”);//当前项目根目录下的a.txt
File file3 = new File(“FileModule\b.txt”);//当前项目的FileModule模块下的b.txt
2.3File类创建功能【应用】
-
方法分类
方法名 说明 public boolean createNewFile() 当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件 public boolean mkdir() 创建由此抽象路径名命名的目录 public boolean mkdirs() 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录 -
注意事项
- createNewFile方法
- 如果文件存在，创建失败，返回false
- 如果文件不存在，创建成功，返回true
- 不管调用者有没有后缀名，都是创建的文件
- mkdir方法
- 只能创建单级文件夹，不能创建多级文件夹
- 不管调用者有没有后缀名，都是创建的单级文件夹
- mkdirs方法
- 可以创建单级文件夹,也可以创建多级文件夹
- 不管调用者有没有后缀名,只能创建文件夹
- 疑问
- 既然mkdirs能创建单级,也能创建多级.那么mkdir可以忽略? 答：是的
- createNewFile方法
import java.io.File;
import java.io.IOException;
public class FileDemo03 {
public static void main(String[] args) throws IOException {
//需求1：创建多级文件夹
File f4 = new File("D:\\JavaFileSpace\\JavaWEB\\java3.txt");//创建JavaFileSpace、JavaWEB、java3.txt这三个文件夹
System.out.println(f4.mkdirs());
System.out.println("--------");
//需求2：创建单级文件夹
File f3 = new File("D:\\JavaFileSpace\\JavaSE");//在D:\JavaFileSpace目录下创建一个单级文件夹JavaSE
System.out.println(f3.mkdirs());//因为mkdirs也能创建单级，直接不考虑mkdir
System.out.println("--------");
//需求3：创建文件
File f1 = new File("D:\\JavaFileSpace\\java.txt");//创建的java.txt文件
System.out.println(f1.createNewFile());
System.out.println("--------");
File f2 = new File("D:\\JavaFileSpace\\java2");//创建的java2文件，不管有没有后缀名，都是创建的文件
System.out.println(f2.createNewFile());
System.out.println("--------");
//需求4：在不存在的目录下创建文件 会报错
File f5 = new File("D:\\JavaFileSpace\\JavaWEB2\\HTML2\\java4.txt");
System.out.println(f5.createNewFile());
}
}
/*
true
--------
true
--------
true
--------
true
--------
Exception in thread "main" java.io.IOException: 系统找不到指定的路径。
at java.base/java.io.WinNTFileSystem.createFileExclusively(Native Method)
at java.base/java.io.File.createNewFile(File.java:1024)
at lesson.FileDemo02.main(FileDemo02.java:28)
第二次运行则全部为false,因为文件和目录都已存在
*/
2.4File类删除功能【应用】
-
方法分类
方法名 说明 public boolean delete() 删除由此抽象路径名表示的文件或目录 -
注意事项
- 删除并不会进电脑回收站。
- 只能删除文件和空文件夹。
- 如果要删除一个有内容的文件夹，只能先进入到这个文件夹，把里面的内容全部删除完毕，才能再次删除这个文件夹。
- 若文件或者文件夹正在被打开，也不能删除。
import java.io.File;
import java.io.IOException;
public class FileDemo04 {
public static void main(String[] args) throws IOException {
//需求1：删除绝对路径的文件
File f1 = new File("D:\\JavaFileSpace\\java.txt：");
System.out.println("删除绝对路径文件D:\\JavaFileSpace\\java.txt：" + f1.delete());
//需求1：删除绝对路径的空文件夹
File f2 = new File("D:\\JavaFileSpace\\JavaSE：");
System.out.println("删除绝对路径文件夹D:\\JavaFileSpace\\JavaSE：" + f2.delete());
//前提：在当前项目中创建a.txt文件，在当前模块中创建b.txt文件
File f3 = new File("a.txt");
File f4 = new File("FileModule\\b.txt");
File f5 = new File("FileModule\\newDir");
File f6 = new File("FileModule\\newDir\\c.txt");
System.out.println("在当前项目中创建a.txt文件：" + f3.createNewFile());
System.out.println("在当前模块中创建b.txt文件：" + f4.createNewFile());
System.out.println("在当前模块目录下创建newDir文件夹：" + f5.mkdir());
System.out.println("在当前模块的newDir文件夹下创建c.txt：" + f6.mkdir());
System.out.println("删除当前项目中创建a.txt文件：" + f3.delete());
System.out.println("删除当前模块目录下的b.txt：" + f4.delete());
System.out.println("删除当前模块目录下的newDir文件夹(非空文件夹)：" + f5.delete());
System.out.println("删除newDir文件夹下创建c.txt：" + f6.delete());
System.out.println("删除当前模块目录下的newDir文件夹(空文件夹)：" + f5.delete());
}
}
/*
删除绝对路径文件D:\JavaFileSpace\java.txt：false
删除绝对路径文件夹D:\JavaFileSpace\JavaSE：false
在当前项目中创建a.txt文件：true
在当前模块中创建b.txt文件：true
在当前模块目录下创建newDir文件夹：true
在当前模块的newDir文件夹下创建c.txt：true
删除当前项目中创建a.txt文件：true
删除当前模块目录下的b.txt：true
删除当前模块目录下的newDir文件夹(非空文件夹)：false
删除newDir文件夹下创建c.txt：true
删除当前模块目录下的newDir文件夹(空文件夹)：true
*/
2.5File类判断和获取功能【应用】
-
判断功能
方法名 说明 public boolean isDirectory() 测试此抽象路径名表示的File是否为目录 public boolean isFile() 测试此抽象路径名表示的File是否为文件 public boolean exists() 测试此抽象路径名表示的File是否存在 -
获取功能
方法名 说明 public String getAbsolutePath() 返回绝对路径的字符串 public String getPath() 返回相对路径的字符串 public String getName() 返回由此抽象路径名表示的文件或目录的名称 public File[] listFiles() 返回此抽象路径名表示的目录中的文件和目录的File对象数组 -
注意事项
- getName方法
- 1.如果调用者是文件,那么获取的是文件名和后缀名
- 2.如果调用者是一个文件夹,那么获取的是文件夹的名字
- listFiles方法
- 1.当调用者是一个文件时，返回null
- 2,当调用者是一个空文件夹时，返回长度为0的数组
- 3.当调用者是一个有内容的文件夹时，获取这个文件夹里面所有的文件和文件夹的File对象，并把这些File对象都放在一个数组中返回。包括隐藏文件和隐藏文件夹都可以获取。
- 4.当调用者是一个有权限才能进入的文件夹时，返回null
- getName方法
import java.io.File;
import java.io.IOException;
public class FileDemo05 {
public static void main(String[] args) throws IOException {
File file1 = new File("a.txt");//当前项目下创建a.txt文件
method(file1);
file1.createNewFile();
method(file1);
File file2 = new File("FileModule\\newDir");//当前模块下创建newDir文件夹
file2.mkdirs();
method(file2);
File file3 = new File(".");//当前项目
File[] files = file3.listFiles();//返回值是一个File类型的数组
System.out.println("File数组长度："files.length);
for (File path : files) {
System.out.println(path);
}
}
private static void method(File file) {
System.out.println(file.getName()+"该路径的File是文件吗？"+file.isFile());
System.out.println(file.getName()+"该路径的File是文件甲吗？"+file.isDirectory());
System.out.println("当前路径的File是否存在"+file.exists());
System.out.println("File的绝对路径："+file.getAbsoluteFile());
System.out.println("File的相对路径："+file.getPath());
System.out.println("----------------------------");
}
}
/*
a.txt该路径的File是文件吗？false
a.txt该路径的File是文件甲吗？false
当前路径的File是否存在false
File的绝对路径：D:\AAAAA\IDEAWorkSpace\MyJavaEE\a.txt
File的相对路径：a.txt
----------------------------
a.txt该路径的File是文件吗？true
a.txt该路径的File是文件甲吗？false
当前路径的File是否存在true
File的绝对路径：D:\IDEAWorkSpace\MyJavaEE\a.txt
File的相对路径：a.txt
----------------------------
newDir该路径的File是文件吗？false
newDir该路径的File是文件甲吗？true
当前路径的File是否存在true
File的绝对路径：D:\AAAAA\IDEAWorkSpace\MyJavaEE\FileModule\newDir
File的相对路径：FileModule\newDir
----------------------------
File数组长度：4
.\.idea
.\a.txt
.\FileModule
.\out
*/
2.6File类练习一：创建文件【应用】
- 案例需求
- 在当前模块下的TestFiles文件夹中创建一个aaa.txt文件
- 注意事项
- 文件所在的文件夹必须要存在
import java.io.File;
import java.io.IOException;
public class Test1 {
public static void main(String[] args) throws IOException {
//1.创建File对象,指向TestFiles文件夹
File file = new File("FileModule\\TestFiles");
//2.判断TestFiles文件夹是否存在,如果不存在则创建
if(!file.exists()){
//如果文件夹不存在,就创建出来
file.mkdirs();
}
//3.创建File对象,指向aaa文件夹下的aaa.txt文件
File newFile = new File(file,"aaa.txt");
//4.创建这个文件
newFile.createNewFile();
}
}
2.7File类练习二：删除一个多级文件夹【应用】
-
案例需求
- 删除一个多级文件夹
-
注意事项
- delete方法只能删除文件和空文件夹。如果现在要删除一个有内容的文件夹?先删掉这个文件夹里面所有的内容,最后再删除这个文件夹。
-
实现步骤
- 定义一个方法,接收一个File对象
- 遍历这个File对象,获取它下边的每个文件和文件夹对象
- 判断当前遍历到的File对象是文件还是文件夹
- 如果是文件,直接删除
- 如果是文件夹,递归调用自己,将当前遍历到的File对象当做参数传递
- 参数传递过来的文件夹File对象已经处理完成,最后直接删除这个空文件夹
-
代码实现
import java.io.File;
public class Test2 {
public static void main(String[] args) {
File src = new File("D:\\JavaFileSpace");
deleteDir(src);
}
//1.定义一个方法,接收一个File对象
private static void deleteDir(File src) {
//先删掉这个文件夹里面所有的内容.
//递归: 方法在方法体中自己调用自己.
//注意: 此方法可以解决所有文件夹和递归相结合的题目
//2.遍历这个File对象,获取src它下边的每个文件和文件夹对象
File[] files = src.listFiles();
//3.判断当前遍历到的File对象是文件还是文件夹
for (File file : files) {
//4.如果是文件,直接删除
if(file.isFile()){
file.delete();
}else{
//5.如果是文件夹,递归调用自己,将当前遍历到的File对象当做参数传递
deleteDir(file);//参数一定要是src文件夹里面的文件夹File对象
}
}
//6.参数传递过来的文件夹File对象已经处理完成,最后直接删除这个空文件夹
src.delete();
}
}
2.8File类练习三： 统计文件夹中每种文件的个数【应用】
-
案例需求
统计一个文件夹中每种文件的个数并打印
-
实现步骤
- 定义一个方法,参数是HashMap集合用来统计次数和File对象要统计的文件夹
- 遍历File对象,获取它下边的每一个文件和文件夹对象
- 判断当前File对象是文件还是文件夹
- 如果是文件,判断这种类型文件后缀名在HashMap集合中是否出现过
- 没出现过,将这种类型文件的后缀名存入集合中,次数存1
- 出现过,获取这种类型文件的后缀名出现的次数,对其+1,在存回集合中
- 如果是文件夹,递归调用自己,HashMap集合就是参数集合,File对象是当前文件夹对象
import java.io.File;
import java.util.HashMap;
public class Test3 {
public static void main(String[] args) {
//统计一个文件夹中,每种文件出现的次数.
//定义一个变量用来统计的弊端:同时只能统计一种文件。
//利用map集合进行数据统计,键=文件后缀名，值=次数。
File file = new File("FileModule\\TestFiles");
HashMap<String, Integer> hm = new HashMap<>();
getCount(hm, file);
System.out.println(hm);
}
//1.定义一个方法,参数是HashMap集合用来统计次数和File对象要统计的文件夹
private static void getCount(HashMap<String, Integer> hm, File file) {
//2.遍历File对象,获取它下边的每一个文件和文件夹对象
File[] files = file.listFiles();
for (File f : files) {
//3.判断当前File对象是文件还是文件夹
if(f.isFile()){
//如果是文件,判断这种类型文件后缀名在HashMap集合中是否出现过
String fileName = f.getName();
String[] fileNameArr = fileName.split("\\.");//没有后缀名的文件不考虑
if(fileNameArr.length == 2){
String fileEndName = fileNameArr[1];
if(hm.containsKey(fileEndName)){
//出现过,获取这种类型文件的后缀名出现的次数,对其+1,在存回集合中
Integer count = hm.get(fileEndName);
//这种文件又出现了一次.
count++;
//把已经出现的次数给覆盖掉.
hm.put(fileEndName,count);
}else{
// 没出现过,将这种类型文件的后缀名存入集合中,次数存1
hm.put(fileEndName,1);
}
}
}else{
//如果是文件夹,递归调用自己,HashMap集合就是参数集合,File对象是当前文件夹对象代码实现
getCount(hm,f);
}
}
}
}
/*
{jpg=2, txt=3, java=1, doc=2}
*/