Day12-Java进阶-Stream流 & File类

1. Stream流

1.1 体验Stream流的作用

package com.itheima.day12.stream;

import java.util.ArrayList;
import java.util.List;

public class StreamDemo {
    /* 
        需求: 按照下面的要求完成集合的创建和遍历
                1. 创建一个集合，存储多个字符串元素
                2. 把集合中所有以"张"开头的元素存储到一个新的集合
                3. 把"张"开头的集合中的长度为3的元素存储到一个新的集合
                4. 遍历上一步得到的集合中的元素输出
     */
    public static void main(String[] args) {
        // 1. 创建一个集合，存储多个字符串元素
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("张良");
        list.add("王二麻子");
        list.add("谢广坤");
        list.add("张三丰");
        list.add("张翠山");

        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));

    }

    private static void method(List<String> list) {
        // 2. 把集合中所有以"张"开头的元素存储到一个新的集合
        ArrayList<String> list1 = new ArrayList<>();

        for (String s : list) {
            if(s.startsWith("张")){
                list1.add(s);
            }
        }

        // 3. 把"张"开头的集合中的长度为3的元素存储到一个新的集合
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if(s.length() == 3){
                list2.add(s);
            }
        }

        // 4. 遍历上一步得到的集合中的元素输出
        for (String s : list2) {
            System.out.println(s);
        }
    }
}

1.2 

1.2.1 获取Stream流对象

package com.itheima.day12.stream;

import java.util.*;
import java.util.function.Consumer;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamDemo1 {
    /*
        获取Stream流对象演示
            - 将数据放在流水线的传送带上

            1. 集合获取 Stream 流对象 (使用Collection接口中的默认方法)
                    default Stream<E> stream()

                    * Map集合获取Stream流对象, 需要间接获取
                            - map.entrySet().stream()

            2. 数组获取 Stream 流对象 (使用Arrays数组工具类中的静态方法)
                    static <T> Stream<T> stream (T[] array)

            3. 零散的数据获取 Stream 流对象 (使用 Stream 类中的静态方法)
                    static <T> Stream<T> of(T... values)
     */
    public static void main(String[] args) {

        Stream.of(1, 2, 3, 4, 5, 6).forEach(s -> System.out.println(s));
        Stream.of("张三", "李四", "王五", "赵六").forEach(s -> System.out.println(s));

    }

    private static void method2() {
        int[] arr1 = {11, 22, 33};
        double[] arr2 = {11.1, 22.2, 33.3};


        Arrays.stream(arr1).forEach(s -> System.out.println(s));
        Arrays.stream(arr2).forEach(s -> System.out.println(s));
    }

    private static void method1() {
        List<String> list = new ArrayList<String>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        list.stream().forEach(s -> System.out.println(s));


        Set<String> set = new HashSet<String>();
        set.add("张三丰");
        set.add("张无忌");
        set.add("张翠山");
        set.add("王二麻子");
        set.add("张良");
        set.add("谢广坤");

        set.stream().forEach(s -> System.out.println(s));


        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("张三丰", 100);
        map.put("张无忌", 35);
        map.put("张翠山", 55);
        map.put("王二麻子", 22);
        map.put("张良", 30);
        map.put("谢广坤", 55);

        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        entrySet.stream().forEach(s -> System.out.println(s));
    }
}

1.2.2 中间方法

package com.itheima.day12.stream;

import java.util.ArrayList;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class StreamDemo2 {
    /*
        Stream流的中间操作方法
            - 操作后返回Stream对象, 可以继续操作

            Stream<T> filter(Predicate<? super T> predicate) 用于对流中的数据进行过滤
            Stream<T> limit(long maxSize) 获取前几个元素
            Stream<T> skip(long n) 跳过前几个元素
            Stream<T> distinct() 去除流中重复的元素依赖 (hashCode 和 equals方法)
            static <T> Stream<T> concat(Stream a, Stream b) 合并a和b两个流为一个流

            注意事项: 流对象已经被消费过(使用过), 就不允许再次消费了.

     */
    public static void main(String[] args) {
        // 需求: 将集合中以 【张】 开头的数据，过滤出来并打印在控制台
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
        System.out.println("-------------------------------------");
        // 需求1: 取前3个数据在控制台输出
        list.stream().limit(3).forEach(s -> System.out.println(s));
        System.out.println("-------------------------------------");
        // 需求2: 跳过3个元素, 把剩下的元素在控制台输出
        list.stream().skip(3).forEach(s -> System.out.println(s));
        System.out.println("-------------------------------------");
        // 需求3: 跳过2个元素, 把剩下的元素中前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(s -> System.out.println(s));
        System.out.println("-------------------------------------");
        // 需求4: 取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);
        // 需求5: 跳过2个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);
        // 需求6: 合并需求4和需求5得到的流, 并把结果在控制台输出
        Stream<String> s3 = Stream.concat(s1, s2);
        // s3.forEach(s -> System.out.println(s));
        System.out.println("-------------------------------------");
        // 需求7: 合并需求4和需求5得到的流, 并把结果在控制台输出，要求字符串元素不能重复
        s3.distinct().forEach(s -> System.out.println(s));
    }


}

1.2.3 终结方法

package com.itheima.stream;

import java.util.stream.Stream;

public class StreamDemo3 {
    /*
        Stream流的终结操作方法
            - 流水线中的最后一道工序

            public void forEach (Consumer action) 对此流的每个元素执行遍历操作
            public long count () 返回此流中的元素数
     */
    public static void main(String[] args) {
        long count = Stream.of(1, 2, 3, 4, 5, 6).filter(s -> s % 2 == 0).count();
        System.out.println(count);
    }
}

1.2.4 Stream 收集操作

toList() 和 toSet() 方式

package com.itheima.day12.stream;

import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo4 {
    /*
        Stream流的收集操作

            public R collect (Collector c) : 将流中的数据收集到集合

                Collectors
                    public static <T> Collector toList()
                    public static <T> Collector toSet()
                    public static  Collector toMap(Function keyMapper , Function valueMapper)
     */
    public static void main(String[] args) {

        List<Integer> list1 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).filter(s -> s % 2 == 0).collect(Collectors.toList());

        System.out.println(list1);


        Set<Integer> list2 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10).filter(s -> s % 2 == 0).collect(Collectors.toSet());
        System.out.println(list2);

    }
}

toMap 方式

package com.itheima.day12.stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class StreamDemo5 {
    /*
        创建一个 ArrayList 集合，并添加以下字符串
        "张三,23"
        "李四,24"
        "王五,25"
        保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
     */
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三,23");
        list.add("李四,24");
        list.add("王五,25");

        Map<String, Integer> map = list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return Integer.parseInt(s.split(",")[1]) >= 24;
            }
        }).collect(Collectors.toMap(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.split(",")[0];
            }
        }, new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s.split(",")[1]);
            }
        }));

        System.out.println(map);
    }
}

1.2.5 综合案例

package com.itheima.day12.stream;

import java.util.ArrayList;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class StreamTest {
    /*
        现在有两个 ArrayList 集合，分别存储6名男演员和6名女演员，要求完成如下的操作：
            1. 男演员只要名字为3个字的前两人
            2. 女演员只要姓林的，并且不要第一个
            3. 把过滤后的男演员姓名和女演员姓名合并到一起
            4. 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
            5. 演员类Actor, 里面有一个成员变量, 一个带参构造方法，以及成员变量对应的get/set方法
     */
    public static void main(String[] args) {
        ArrayList<String> manList = new ArrayList<String>();
        manList.add("周润发");
        manList.add("成龙");
        manList.add("刘德华");
        manList.add("吴京");
        manList.add("周星驰");
        manList.add("李连杰");

        ArrayList<String> womanList = new ArrayList<String>();
        womanList.add("林心如");
        womanList.add("张曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖贤");

        Stream<String> s1 = manList.stream().filter(s -> s.length() == 3).limit(2);
        Stream<String> s2 = womanList.stream().filter(s -> s.startsWith("林")).skip(1);
        Stream<String> s3 = Stream.concat(s1, s2);

        s3.forEach(new Consumer<String>() {
            @Override
            public void accept(String name) {
                Actor a = new Actor(name);
                System.out.println(a);
            }
        });
    }
}

class Actor {
    private String name;


    public Actor() {
    }

    public Actor(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    public String toString() {
        return "Actor{name = " + name + "}";
    }
}

2. File类

2.1 File类介绍

2.2 案例1-文件夹路径报错提示

package com.itheima.file;

import java.io.File;
import java.util.Scanner;

public class FileTest1 {
    /*
        需求: 键盘录入一个文件夹路径，如果输入错误就给出提示，并继续录入，直到正确为止
     */
    public static void main(String[] args) {

        File dir = getDir();
        System.out.println(dir);

    }

    public static File getDir (){
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个文件夹路径: ");
        while (true) {
            String path = sc.nextLine();

            File dir = new File(path);

            if (!dir.exists()) {
                System.out.println("您输入的文件夹不存在, 请重新输入: ");
            } else if (dir.isFile()){
                System.out.println("您输入的是一个文件路径, 请重新输入: ");
            } else {
                return dir;
            }
        }
    }

}

2.3 案例2-寻找指定后缀名的文件

package com.itheima.file;

import java.io.File;
import java.util.Scanner;

public class FileTest2 {
    /*
        需求: 键盘录入一个文件夹路径，找出这个文件夹下所有的 .java 文件
     */
    public static void main(String[] args) {
        File dir = FileTest1.getDir();

        printJavaFile(dir);
    }


    /**
     * 对接收到的文件夹路径进行遍历, 找出所有的.java文件
     */
    public static void printJavaFile(File dir) {
        // 1. 获取当前路径下所有的文件和文件夹对象
        File[] files = dir.listFiles();

        // 2. 对数组遍历, 获取每一个文件或文件夹对象
        for (File file : files) {
            // 3. 判断是否是.java文件
            if (file.isFile()) {
                if (file.getName().endsWith(".java")) {
                    System.out.println(file);
                }
            } else {
                // 4. 代码执行到这里, 说明是文件夹
                // 思路: 调用方法, 进入这个文件夹继续找.java文件
                if (file.listFiles() != null) {
                    printJavaFile(file);
                }
            }
        }
    }


    private static void method(File dir) {
        // 获取当前路径下所有的文件和文件夹对象
        File[] files = dir.listFiles();
        // 遍历数组, 获取每一个文件或文件夹对象
        for (File file : files) {
            // 判断是否是文件, 并且文件的后缀名需要.java结尾
            if (file.isFile() && file.getName().endsWith(".java")) {
                System.out.println(file);
            }
        }
    }
}

2.4 案例3-文件夹的增删

package com.itheima.file;

import java.io.File;

public class FileTest3 {
    /*
        需求: 设计一个方法, 删除文件夹 (delete() 只能删除空文件夹)
     */
    public static void main(String[] args) {
        deleteDir(new File("D:\\test2"));
    }

    public static void deleteDir(File dir) {
        File[] files = dir.listFiles();
        for (File file : files) {
            if (file.isFile()) {
                // 文件直接删
                file.delete();
            } else {
                // 文件夹的话, 需要进入文件夹继续删除.
                if (file.listFiles() != null) {
                    deleteDir(file);
                }
            }
        }
        // 循环结束后, 删除空文件夹
        dir.delete();
    }
}

2.5 案例4-统计文件夹大小

package com.itheima.file;

import java.io.File;

public class FileTest4 {
    /*
        需求: 键盘录入一个文件夹路径，统计文件夹的大小
     */
    public static void main(String[] args) {

        File dir = FileTest1.getDir();

        System.out.println(getLength(dir));

    }

    public static long getLength(File dir) {
        long sum = 0;
        File[] files = dir.listFiles();
        for (File file : files) {
            if (file.isFile()) {
                sum += file.length();
            } else {
                if (file.listFiles() != null) {
                    sum += getLength(file);
                }
            }
        }
        return sum;
    }
}

2.6 案例5-统计各类文件个数

package com.itheima.file;

import java.io.File;
import java.util.HashMap;
import java.util.function.BiConsumer;

public class FileTest5 {
    /*
        需求：键盘录入一个文件夹路径，统计文件夹中每种文件的个数并打印（考虑子文件夹）
            打印格式如下：
                txt:3个
                doc:4个
                jpg:6个
     */

    static HashMap<String, Integer> hm = new HashMap<>();
    static int count = 0;       // 统计没有后缀名的文件

    public static void main(String[] args) {

        File dir = FileTest1.getDir();

        getCount(dir);

        hm.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String key, Integer value) {
                System.out.println(key + ":" + value + "个");
            }
        });

        System.out.println("没有后缀名文件的个数为:" + count);

    }

    public static void getCount(File dir) {
        File[] files = dir.listFiles();

        for (File file : files) {
            if (file.isFile()) {
                // 文件的话, 统计个数
                // 1. 获取文件名
                String fileName = file.getName();
                if (fileName.contains(".")) {
                    // 2. 获取后缀名
                    String[] sArr = fileName.split("\\.");
                    String type = sArr[sArr.length - 1];
                    // 3. 统计
                    if (!hm.containsKey(type)) {
                        hm.put(type, 1);
                    } else {
                        hm.put(type, hm.get(type) + 1);
                    }
                } else {
                    // 没有后缀名, 单独统计
                    count++;
                }
            } else {
                // 文件夹的话, 递归调用
                if (file.listFiles() != null) {
                    getCount(file);
                }
            }
        }
    }
}