Java8——Stream流

我们先上手个小demo

import java.util.Arrays;

public class DemoStream {

    public static void main(String[] args) {
        String[] strList = {"李茂展","董浩","李沫熙","李哲","杨宁宁"};
        //接下来我们将使用stream流方式对strList进行操作，返回带 李 ，长度为3的
        Arrays.stream(strList).filter((name)->name.contains("李"))
                .filter((name)->name.length()==3)
                .forEach(name-> System.out.println(name));
    }
}

Stream中集合的处理方案

这张图展示了过滤、映射、跳过、计数等多步操作，这是一个集合元素的处理方案，也就是一种函数模型
中间执行过程中集合并不会真正的被处理，而是到最后count的时候才会被执行，这就是函数模型的操作，而之所以这样的得益于Lambda的延迟加载

Stream流获取

Stream流获取有两种方式

• Collection的有stream()方法获取stream流

import java.util.*;
import java.util.stream.Stream;

public class DemoStream {


    public static void main(String[] args) {
        //list集合获取stream方式
        ArrayList<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();
        
        //hash获取stream方式
        HashSet<String> hashSet = new HashSet<>();
        Stream<String> stream2 = hashSet.stream();
        
        //map集合我们可以分别把键值对转换成流对象
        HashMap<String, String> map = new HashMap<>();
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();

        Collection<String> values = map.values();
        Stream<String> stream = values.stream();
        
        
    }
}

• 有一个Java.util.stream有一个静态方法of也可以获得stream流

public static void main(String[] args) {
      //list集合获取stream方式
      ArrayList<String> list = new ArrayList<>();
      Stream<ArrayList<String>> stream = Stream.of(list);
      
  }

Stream方法的学习总结

首先分成两类

1. 延迟方法
2. 终结方法

foreach()方法 —— 终结方法

遍历之后就不能使用stream流中的其他方法

import java.util.stream.Stream;

public class ForStream {

    public static void main(String[] args) {
        Stream.of("李茂展","李沫熙","杨宁宁").forEach(name-> System.out.println(name));
    }
}

filter()方法 —— 延迟方法

执行过滤之后，仍然可以使用stream的其他方法

Stream.of("李茂展","李沫熙","杨宁宁").filter(name->name.contains("李")).forEach(name-> System.out.println(name));

类名引用静态方法的使用

我们使用Math.abs()来求绝对值
首先我们创建一个函数式接口

@FunctionalInterface
public interface AbsFunc {
    public abstract int myAbs(int num);
}

然后我们可以使用lambda表达式来引用Math的静态方法

public class DemoStream {

    public static void getAbs(Integer num,AbsFunc absFunc){
        int myAbs = absFunc.myAbs(num);
        System.out.println(myAbs);

    }

    public static void main(String[] args) {
        getAbs(-10,Math::abs);
    }

}

结构打印出来是 10

同样的使用super引用父类方法的时候，由于在子类中super是存在的，在lambda中我们可以使用super::show来完成调用

同样的使用this的时候，在lambda中我们可以使用this::show来完成调用

同样的使用new的时候，在lambda中我们可以使用Person::new来完成调用

---