24蓝旭培训第三周博客

最新推荐文章于 2024-06-13 08:37:22 发布

Kise-Ryota

最新推荐文章于 2024-06-13 08:37:22 发布

阅读量1.4k

点赞数 45

文章标签： java

本文链接：https://blog.csdn.net/2301_80426536/article/details/137381970

版权

File

Java中File类表示文件或目录的路径名。它可以用于创建、删除、重命名、复制文件或目录。

如果需要读取或写入文件内容，必须使用IO流来完成。想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。

File对象可以作为参数传递给流的构造器，指明读取或写入的"终点"。

创建File对象

首先需要通过绝对路径和相对路径来定位文件或目录的路径信息。

绝对路径是从根目录开始的完整路径，可以唯一地确定一个文件或目录的位置，如：C:\Users\Administrator\Desktop\test.txt。

相对路径是相对于当前目录的路径，可以通过与当前目录的相对位置来确定文件或目录的位置，如：..\Documents\test.txt（其中“..”表示当前目录的上级目录。）

可以注意到，路径中的每级目录之间用一个路径分隔符隔开，

而路径分隔符和系统有关：

windows和DOS系统默认使用"\"来表示
UNIX和URL使用"/"来表示

Java程序支持跨平台运行，因此路径分隔符要慎用。
为了解决这个隐患，File类提供了一个常量：
public static final String separator:根据操作系统，动态的提供分隔符。

例子：


File file1 = new File("d:\\atguigu\\info.txt");
File file2 = new File("d:" + File.separator + "atguigu" + File.separator + "info.txt");
//这里就是用常量public static final String separator代替了分隔符的使用
File file3 = new File("d:/atguigu");

使用File类来创建文件或目录的对象：

public File(String pathname) \\以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。

public File(String parent,String child) \\以parent为父路径，child为子路径创建File对象。

public File(File parent,String child) \\根据一个父File对象和子文件路径创建File对象。

例子：

File file1 = new File("myfile.txt"); \\创建一个名为“myfile.txt”的文件对象

File file2 = new File("D:\\myFolder\\myfile.txt"); \\在指定位置创建一个新的文件对象，可以使用相同的构造函数，并将目录路径作为参数

File file3 = new File("D:\\myFolder","myfile.txt"); \\以parent为父路径，child为子路径创建File对象。

File file4 = new File(file3,"myfile.txt"); \\根据一个父File对象和子文件路径创建File对象。

常用方法

判断文件类型、获取文件信息

getPath()：返回文件路径的字符串表示。
getName()：返回文件名。
isDirectory()：判断文件是否是目录。
isFile()：判断文件是否是普通文件。
exists()：判断文件是否存在。
canRead()：判断是否可读取文件。
canWrite()：判断是否可写入文件。
length()：返回文件的大小，以字节为单位。
listFiles()：返回此目录中包含的文件和目录的文件数组。

例子：

import java.io.File;
 
public class FileDemo {
    public static void main(String[] args) {
        // 实例化一个文件对象
        File file = new File("D:/test.txt");
 
        // 调用getPath()方法获取文件路径
        String path = file.getPath();
        System.out.println("文件的路径为：" + path);
 
        // 调用getName()方法获取文件名
        String name = file.getName();
        System.out.println("文件名为：" + name);
 
        // 调用isDirectory()方法判断是否是目录
        boolean isDir = file.isDirectory();
        System.out.println("是否是目录：" + isDir);
 
        // 调用exists()方法判断文件是否存在
        boolean isExist = file.exists();
        System.out.println("文件是否存在：" + isExist);
 
        // 调用length()方法获取文件大小
        long size = file.length();
        System.out.println("文件大小为：" + size + "字节");
    }
}


//运行结果
文件的路径为：D:\test.txt
文件名为：test.txt
是否是目录：false
文件是否存在：false
文件大小为：0字节

创建文件、删除文件功能

createNewFile()：创建一个新的空的文件
mkdir()：只能创建一级文件夹
mkdirs()：可以创建多级文件夹
delete()：删除由此抽象路径名表示的文件或空文件夹

例子：

File file = new File("example.txt");
try {
    if (file.createNewFile()) {
        System.out.println("文件创建成功！");
    } else {
        System.out.println("文件已存在！");
    }
} catch (IOException e) {
    e.printStackTrace();
}

File file = new File("example.txt");
if (file.delete()) {
    System.out.println("文件已删除！");
} else {
    System.out.println("文件删除失败！");
}

重命名功能

public boolean renameTo(File dest) //把文件重命名为指定的文件路径

例子：


    public void test4(){
        File file1 = new File("hello.txt");
        File file2 = new File("D:\\io\\hi.txt");

        boolean renameTo = file2.renameTo(file1);
        System.out.println(renameTo);

    }

Path

Path表示的是一个目录名序列，其后还可以跟着一个文件名。Path 类是jdk7新增加的特性之一，用来代替java.io.File类。
之所以新增这个类，是由于java.io.File类有很多缺陷：
1.java.io.File类里面很多方法失败时没有异常处理，或抛出异常
java.io.File.delete()方法返回一个布尔值指示成功或失败但是没有失败原因

2.Path 速度快，方便。

下面是Path使用的一些方法：

1.删除文件

public static void main (String[] args){
    Path path = Paths.get("D://afile")
    try{
        Files.delete(path);
    }catch(IOException e){
        System.out.println(e.getmessage());
    }
}

    Path dir = Paths.get("F:\\LZ\\pdf");
    DirectoryStream<Path> stream = Files.newDirectoryStream(dir);
    for(Path path : stream){
        System.out.println(path.getFileName());
    }

3.创建多级目录

    Path dir = Paths.get("F:\\LZ\\xx\\dd");
    Files.createDirectories(dir);

4.创建文件

    Path dir = Paths.get("F:\\LZ\\xx\\dd\\1.txt");
    Files.createFile(dir);

5.文件的复制

    Path src = Paths.get("F:\\LZ\\xx\\dd\\1.txt");
    Path target = Paths.get("F:\\LZ\\xx\\dd\\2.txt");
 
    //REPLACE_EXISTING:文件存在，就替换
    Files.copy(src, target,StandardCopyOption.REPLACE_EXISTING);

6.一行一行读取文件

    Path src = Paths.get("F:\\LZ\\xx\\dd\\1.txt");
    BufferedReader reader = Files.newBufferedReader(src,StandardCharsets.UTF_8);
    String line ;
    while((line=reader.readLine()) != null){
        System.out.println(line);
    }
    reader.close();

7.写入字符串

    Path src = Paths.get("F:\\LZ\\xx\\dd\\1.txt");
    BufferedWriter writer = Files.newBufferedWriter(src, StandardCharsets.UTF_8
            ,StandardOpenOption.APPEND); // 追加
    writer.write("hello word Path");
    writer.close();

流

Stream 就好像一个高级的迭代器，但只能遍历一次，在流的过程中，可以对流中的元素执行一些操作。要想操作流，首先需要有一个数据源，可以是数组或者集合。每次操作都会返回一个新的流对象，方便进行链式操作，但原有的流对象会保持不变。

流的操作可以分为两种类型：

1）中间操作，可以有多个，每次返回一个新的流，可进行链式操作。

2）终端操作，只能有一个，每次执行完，无法执行下一个操作，因此只能放在最后。

例子：

List<String> list = new ArrayList<>();
list.add("武汉加油");
list.add("中国加油");
list.add("世界加油");
list.add("世界加油");

long count = list.stream().distinct().count();
System.out.println(count);

//distinct() 方法是一个中间操作（去重），它会返回一个新的流（没有共同元素）。
//count() 方法是一个终端操作，返回流中的元素个数。

中间操作不会立即执行，只有等到终端操作的时候，流才开始真正地遍历，就是一次遍历执行多个操作，性能就大大提高了。

创建流

如果是数组的话，可以使用 Arrays.stream() 或者 Stream.of() 创建流；如果是集合的话，可以直接使用 stream() 方法创建流，因为该方法已经添加到 Collection 接口中。

例子：

public class CreateStreamDemo {
    public static void main(String[] args) {
        String[] arr = new String[]{"武汉加油", "中国加油", "世界加油"};
        Stream<String> stream = Arrays.stream(arr);

        stream = Stream.of("武汉加油", "中国加油", "世界加油");

        List<String> list = new ArrayList<>();
        list.add("武汉加油");
        list.add("中国加油");
        list.add("世界加油");
        stream = list.stream();
    }
}

操作流

1.过滤

通过 filter() 方法可以从流中筛选出我们想要的元素。

public class FilterStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        Stream<String> stream = list.stream().filter(element -> element.contains("王"));
        stream.forEach(System.out::println);
    }
}


/*
运行结果
王力宏
*/

element -> element.contains("王") 就是筛选出带有“王”的字符串。

forEach() 方法接收的是一个 Consumer类型的参数，类名 :: 方法名是 Java 8 引入的新语法，System.out 返回 PrintStream 类。

stream.forEach(System.out::println); 相当于在 for 循环中打印，类似于下面的代码：

for (String s : strs) {
    System.out.println(s);
}

2.映射

使用 map() 方法可以把一个流中的元素转化成新的流中的元素。

例子：

public class MapStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        Stream<Integer> stream = list.stream().map(String::length);
        stream.forEach(System.out::println);
    }
}


/*
运行结果
3
3
2
3
*/

map() 方法接收的是一个 Function（Java 8 新增的一个函数式接口，接受一个输入参数 T，返回一个结果 R）类型的参数，此时参数为 String 类的 length 方法，也就是把 Stream<String> 的流转成一个 Stream<Integer> 的流。

3.匹配

Stream 类提供了三个方法可供进行元素匹配，它们分别是：

anyMatch()，只要有一个元素匹配传入的条件，就返回 true。

allMatch()，只有有一个元素不匹配传入的条件，就返回 false；如果全部匹配，则返回 true。

noneMatch()，只要有一个元素匹配传入的条件，就返回 false；如果全部不匹配，则返回 true。

例子：

public class MatchStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");

        boolean  anyMatchFlag = list.stream().anyMatch(element -> element.contains("王"));
        boolean  allMatchFlag = list.stream().allMatch(element -> element.length() > 1);
        boolean  noneMatchFlag = list.stream().noneMatch(element -> element.endsWith("沉"));
        System.out.println(anyMatchFlag);
        System.out.println(allMatchFlag);
        System.out.println(noneMatchFlag);
    }
}


/*
运行结果
true
true
true
*/

因为“王力宏”以“王”字开头，所以 anyMatchFlag 应该为 true；因为“周杰伦”、“王力宏”、“陶喆”、“林俊杰”的字符串长度都大于 1，所以 allMatchFlag 为 true；因为 4 个字符串结尾都不是“沉”，所以 noneMatchFlag 为 true。

4.组合

reduce() 方法的主要作用是把 Stream 中的元素组合起来，它有两种用法：

Optional<T> reduce(BinaryOperator<T> accumulator)
没有起始值，只有一个参数，就是运算规则，此时返回 Optional。

T reduce(T identity, BinaryOperator<T> accumulator)
有起始值，有运算规则，两个参数，此时返回的类型和起始值类型一致。

例子：

public class ReduceStreamDemo {
    public static void main(String[] args) {
        Integer[] ints = {0, 1, 2, 3};
        List<Integer> list = Arrays.asList(ints);

        Optional<Integer> optional = list.stream().reduce((a, b) -> a + b);
        Optional<Integer> optional1 = list.stream().reduce(Integer::sum);
        System.out.println(optional.orElse(0));
        System.out.println(optional1.orElse(0));

        int reduce = list.stream().reduce(6, (a, b) -> a + b);
        System.out.println(reduce);
        int reduce1 = list.stream().reduce(6, Integer::sum);
        System.out.println(reduce1);
    }
}



/*
运行结果
6
6
12
12
*/

运算规则可以是 Lambda 表达式（比如 (a, b) -> a + b），也可以是类名::方法名（比如 Integer::sum）。0、1、2、3 在没有起始值相加的时候结果为 6；有起始值 6 的时候结果为 12。

转换流

既然可以把集合或者数组转成流，那么也应该有对应的方法，将流转换回去——collect() 方法就满足了这种需求。

例子：

public class CollectStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");

        String[] strArray = list.stream().toArray(String[]::new);
        System.out.println(Arrays.toString(strArray));

        List<Integer> list1=list.stream().map(String::length).collect(Collectors.toList());
        //通过 stream() 方法创建集合的流后，再通过 map(String:length) 将其映射为字符串长度的一个新流，最后通过 collect() 方法将其转换成新的集合。
    }
}


/*
输出结果
周杰伦
王力宏
陶喆
林俊杰
3
3
2
3
*/

toArray() 方法可以将流转换成数组,String[]::new 是一个 IntFunction，一个可以产生所需的新数组的函数,也就是相当于返回了一个指定长度的字符串数组。

可以配套使用 map() 方法和 collect() 方法,把一个集合按照某种规则转成另外一个集合。

Kise-Ryota

关注

45
点赞
踩
45

收藏

觉得还不错? 一键收藏
0
评论
24蓝旭培训第三周博客

map() 方法接收的是一个 Function（Java 8 新增的一个函数式接口，接受一个输入参数 T，返回一个结果 R）类型的参数，此时参数为 String 类的 length 方法，也就是把 Stream<String> 的流转成一个 Stream<Integer> 的流。要想操作流，首先需要有一个数据源，可以是数组或者集合。forEach() 方法接收的是一个 Consumer类型的参数，类名 :: 方法名是 Java 8 引入的新语法，System.out 返回 PrintStream 类。
复制链接

扫一扫