3.java8流的使用 stream的映射map，flatMap

1.代码

项目地址

必要bean类：Employee

package com.netease.streamlearningbyjava.bean;

import java.util.Objects;

/**
 * 创建日期：2021/10/29 14:01
 *
 * @author tony.sun
 * 类说明：
 */

public class Employee {
    private String name;
    private int age;
    private double salary;

    public Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
//    去重

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
                Double.compare(employee.salary, salary) == 0 &&
                name.equals(employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, salary);
    }
}

必要listBean值：

List<Employee> employees=Arrays.asList(
            new Employee("张三",18,9999.99),
            new Employee("李四",58,5555.55),
            new Employee("王五",26,3333.33),
            new Employee("赵六",36,6666.66),
            new Employee("田七",12,8888.88),
            new Employee("田七",12,8888.88)
    );

在这个类里：Stream9mapping

2.步骤简介

map是映射的意思

1.map，可以对每个list里的值进行复制，在插件一个新的流

1.将list里的小写转为大写

List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
        //list里面的每个转为大写
        list
                .stream()//转流
                .map((str) -> str.toUpperCase())//调用map方法，对每个值进行操作，这里是对每个值进行大写化
                .forEach(System.out::println);//对每个值进行遍历，

打印结果：

1.stream()：.转为流
2.map表示映射操作，括号里面的表示操作内容，这里是进行大写化
3.map括号里面的格式一般是：“(str) ->”，其中str是可以任意字母写的，而str相当于一个传入的参数，可以用于操作，这里的操作是 str.toUpperCase()。

2.获取list的bean里面的某个值

/**
 * 获取list里面的 bean里的一个值
 */
System.out.println("----------------------------------------------");
employees.stream()
        .map(Employee::getName)
        .forEach(System.out::println);

打印结果：

把名字都拿出来打印；
1.操作内容：Employee::getName，表示获取bean里面的name；map会对list的每个bean类进行操作，也就是会获取每个bean，然后后面的操作是对每个bean都会操作一次，这里是对每个bean获取name。所以创建一个新bean的时候，会是一个只有name的list。

对字符串里的每个字符拿出来，添加到list里面，然后返回list

/**
     * 对字符串里的每个字符拿出来，添加到list里面，然后返回list
     * @param str string原料
     * @return 返回字符list
     */
    public static Stream<Character> filterCharacter(String str){
        List<Character> list=new ArrayList<>();//创建一个字符list
        //对字符串进行遍历，并添加到一个字符list
        for (char ch : str.toCharArray()) {
            list.add(ch);
        }
        //返回这个字符流
        return list.stream();
    }

方法一：用map

Stream<Stream<Character>> stream = list.stream()
                //filterCharacter方法在这里不需要传入参数，因为map这个家伙已经拿出来每个值，然后对每个值进行操作，这里它将其给filterCharacter，相当于传入了值
                .map(Stream9mapping::filterCharacter);//{a,a,a},{b,b,b}，……
        stream.forEach((sm)->{
            sm.forEach(System.out::println);//{a,a,a,b,b,b,……}
        });

方法二用flatMap

2.flatMap

将list里面的字符串的每个字符拿出来，创建一个只有字符的流
对字符串里的每个字符拿出来，添加到list里面，然后返回list

/**
     * 对字符串里的每个字符拿出来，添加到list里面，然后返回list
     * @param str string原料
     * @return 返回字符list
     */
    public static Stream<Character> filterCharacter(String str){
        List<Character> list=new ArrayList<>();//创建一个字符list
        //对字符串进行遍历，并添加到一个字符list
        for (char ch : str.toCharArray()) {
            list.add(ch);
        }
        //返回这个字符流
        return list.stream();
    }

方法一：用map

Stream<Stream<Character>> stream = list.stream()
                //filterCharacter方法在这里不需要传入参数，因为map这个家伙已经拿出来每个值，然后对每个值进行操作，这里它将其给filterCharacter，相当于传入了值
                .map(Stream9mapping::filterCharacter);//{a,a,a},{b,b,b}，……
        stream.forEach((sm)->{
            sm.forEach(System.out::println);//{a,a,a,b,b,b,……}
        });

方法二：用flatMap

Stream<Character> characterStream = list.stream()
                .flatMap(Stream9mapping::filterCharacter);//{a,a,a,b,b,b,……}
        characterStream.forEach(System.out::println);

打印结果：

两种方法的结果都一样
map(Stream9mapping::filterCharacter)会默认给个list泛型里的值。所以不用传入参数。

3.反思总结

后面遇到再更新，敬请期待