Stream中间操作之映射 [Java][详解]

Stream的中间操作之映射

1. map(Function f)

   • 接收一个函数作为参数,将元素转换为其他形式或者是提取信息,并将其映射成为一个新的元素

   • 这个函数会应用到每一个元素上

   • 这个方法的形参是一个函数型接口(函数型接口是函数式接口中的一个)

     • 函数式接口 — 我们一般分为四种:

       1. 消费型接口
       2. 供给型接口
       3. 函数型接口
       4. 断定型接口

     • 我们一般创建函数式接口的实例对象时都是通过使用lambda表达式的方式

关于map()方法这里我们先举一个例子:

eg:这个例子是将元素装换为其他形式

package stream流.中间操作.映射;

import java.util.stream.Stream;
import java.util.List;
import java.util.Arrays;

public class Demo1 {
    public static void main(String[] args) {
        /*
        这个时候我们先创建了一个List<String>类型的对象,这个对象中存储了一些小写字母
         */
        List<String> list = Arrays.asList("aa","bb","cc","dd","ee");
        /*
        这里我们使用了Stream类中的中间操作中的映射操作,将我们的list集合中的每个元素都调用了一次toUpperCase()方法,也就是将我们的
        list集合中的元素(也就是字符串)全部转换成了大写
         */
        list.stream().map(str -> str.toUpperCase()).forEach(System.out :: println);
    }
}

然后关于map()方法这里再举一个例子:

这个例子中我们会使用到两个自定义类: 所以我们先将这两个自定义类给出

自定义类一: Employee

package stream流;

public class Employee {
    private int age;
    private String name;
    public Employee(){

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

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

自定义类二: EmployeeDate

package stream流.中间操作;

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

public class EmployeeDate {
    public EmployeeDate(){

    }
    public static List<Employee> getEmployeeDate(){
        List<Employee>  list = new ArrayList<>();
        Employee e1 = new Employee(1001,"马化腾",20,8001);
        Employee e2 = new Employee(1002,"马云",47,8701);
        Employee e3 = new Employee(1003,"刘强东",34,8401);
        Employee e4 = new Employee(1004,"曹操",32,4501);
        Employee e5 = new Employee(1005,"刘备",12,5401);
        Employee e6 = new Employee(1006,"张飞",21,6601);

        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
        list.add(e5);
        list.add(e6);
        return list;
    }
}

在这个例子中,我们是要提取元素的某写信息

eg: — > 我们要统计员工中姓名长度大于2的姓名

package stream流.中间操作.映射;

import stream流.中间操作.Employee;
import stream流.中间操作.EmployeeDate;
import java.util.stream.Stream;

import java.util.List;

public class Demo2{
    public static void main(String[] args) {
        /*
        这里我们先获得了一个员工集合
         */
        List<Employee> list = EmployeeDate.getEmployeeDate();
        /*
        然后我们对员工集合对象调用了stream()方法就得到了员工集合所对应的流,然后我们再通过使用这个流调用map()方法进行映射
        就得到了由员工姓名构成的一个Stream对象
         */
        Stream<String> stream = list.stream().map(Employee :: getName);
        /*
        然后我们再对员工姓名构成的流进行一个筛选操作,我们就得到了员工姓名长度超过2的名字了
         */
        stream.filter(s -> s.length()>2).forEach(System.out :: println);
    }
}

2. flatMap(Function f)

   • 接收一个函数作为参数,然后将每一个参数都转换为一个流,然后将这些流合并成为一个流
   • 这个方法的形参是一个函数型接口

注意: 合理的使用flatMap()方法可以帮助我们避免出现流中流的情况

• 如果是使用map()方法进行映射操作,这个时候很可能会返回一个流,并且这个流中还包含着另一个流
  • 这种情况也可以称之为流中流
• 如果是使用flatMap()方法则不会出现这种情况,因为我们的flatMap()方法是将我们的流最终合并成为了一个流

这里我们举一个例子:

eg:

package stream流.中间操作.映射;

import stream流.中间操作.Employee;
import stream流.中间操作.EmployeeDate;
import java.util.stream.Stream;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;

public class Demo3 {
    public static void main(String[] args) {

        List<String> list = Arrays.asList("AA","BB","CC","DD");
        list.stream().flatMap(str -> new Demo3().fromStringToStream(str)).forEach(System.out :: println);
    }
    public Stream<Character> fromStringToStream(String str){

        ArrayList<Character> arrayList = new ArrayList<>();
        for(Character c : str.toCharArray()){
            arrayList.add(c);
        }
        return arrayList.stream();
    }
}

• 这里我们使用了flatMap()方法,所以避免了流中流的出现
• 这个时候我们的流中的每个元素都会进行映射, 这个时候每个元素进行映射之后都会得到一个新的流,然后这个时候我们的流中的每个元素又都是一个流,但是这个时候我们的flatMap()方法中最后又将我们每个元素对应的流合并成为了一个流

如果这个时候我们使用map()方法,这个时候就会出现流中流的现象

eg:

package stream流.中间操作.映射;

import stream流.中间操作.Employee;
import stream流.中间操作.EmployeeDate;
import java.util.stream.Stream;
import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;

public class Demo4 {
    public static void main(String[] args) {

        List<String> list = Arrays.asList("AA","BB","CC","DD");
        
        /*
        这个时候如果我们只调用一次forEach()方法,这个时候就会出现流中流,输出的不是一个一个的字母,而是四个流
        
        所以这个时候我们要进行嵌套的forEach()方法,这个时候我们就会拿到流中的流,然后对这个流中的流进行内部迭代
         */
        list.stream().map(str -> new Demo3().fromStringToStream(str)).forEach(s -> s.forEach(System.out :: println));
    }
    public Stream<Character> fromStringToStream(String str){

        ArrayList<Character> arrayList = new ArrayList<>();
        for(Character c : str.toCharArray()){
            arrayList.add(c);
        }
        return arrayList.stream();
    }
}