Lambda和Stream流

清疚 2023-10-02 19:38 20阅读 0赞

**目录**

需要笔记的可以关注私聊,我发给你

Lambda

格式

排序

Stream流

获取流:

.stream( )

操作流(中间方法):

终结流:

收集流的操作

第一部分

第二部分

第三部分

Optional

优势 :

public static Optional of(T value) :

public static Optional ofNullable(T value) :

public T orElse(T other) :

public boolean isPresent() :

public T get() :

--------------------

## 需要笔记的可以关注私聊,我发给你 ##

![b727ed7fa76e4f77b2c45d051d1b264b.png][]

## Lambda    ##

\- Lambda表达式只能针对接口（使用匿名内部类时）  
\- 接口必须是：函数式接口  
1、在一个接口中，只有一个抽象方法需要重写的接口，称为：函数式接口  
2、函数式接口中，允许存在：静态方法、私有方法、默认方法

Java语言，为了区分函数式接口和普通接口，在函数式接口中添加一个注解：

@FunctionalInterface
    public interface Swimming{
        //只有一个抽象方法
        public abstract void swim();
    }

### 格式 ###

(形参) -> {
        //方法体功能.....
    }

( ):参数列表  
\{ \}:方法体  
\->没有特殊含义,仅是连接  
当方法体中的代码仅有一行时，可以省略return、大括号、分号

### 排序    ###

Collections.sort(list,(Integer o1,Integer o2) ->{
    return o2-o1;
    })   //降序

## Stream流 ##

### 获取流: ###

创建一条流水线,并把数据放到流水线上准备进行操作

#### .stream( ) ####

**单列集合**  
可以使用Collection接口中的默认方法stream()生成流  
default Stream<E> stream()

ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list, "关羽", "张飞", "赵云", "马超", "黄忠");
            // forEach( s -> System.out.println(s)) : 遍历stream流中的数据
    
            list.stream().forEach(s -> System.out.println(s));

**双列集合**  
双列集合不能直接获取 , 需要间接的生成流  
可以先通过keySet或者entrySet获取一个Set集合，再获取Stream流

HashMap<String, String> hs = new HashMap<>();
            hs.put("刘备", "尚香");
            hs.put("孙策", "大乔");
            hs.put("周瑜", "小乔");
    
            // 把双列集合转成单列集合 , 在生成流
            
            
            Set<String> set1 = hs.keySet();// {刘备 , 孙策 , 周瑜}
            set1.stream().forEach(s -> System.out.println(s + "--" + hs.get(s)));

**数组**  
Arrays中的静态方法stream生成流

Integer[] arr = {33, 22, 11, 55, 44};
    
            Arrays.stream(arr).forEach(s -> System.out.println(s));

把同一种数据类型多个数据放到stream  
Stream类中的of方法 , 把多个数据放在stream流上

Stream.of(11,22,33,55,44,77,66).forEach(s -> System.out.println(s));

### 操作流(中间方法): ###

**流水线上的操作:一次操作完之后,还可以继续进行其他操作**  
 1 Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤  
Predicate接口中的方法 : boolean test(T t)：对给定的参数进行判断，返回一个布尔值

filter方法会拿到stream流中的每一个元素 , 并把每一个元素传递给lambda表达式的形参s  
如果lambda表达式返回true : 表示此元素留下来  
如果lambda表达式返回false : 表示此元素过滤掉(从流中去除)

list.stream().filter((String s) -> {
                return s.length() == 2;
            }).forEach(s -> System.out.println(s));

2 Stream<T> limit(long maxSize)：截取指定参数个数的数据

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

3 Stream<T> skip(long n)：跳过指定参数个数的数据

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

4 static <T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流

Stream<String> stream1 = list.stream();
            Stream<String> stream2 = list.stream();
            Stream.concat(stream1 , stream2).forEach(s -> System.out.println(s));

5 <R> Stream<R> map(Function<T , R> mapper) : 将流中的元素类型进行转换  
泛型T : 表示的流中的元素类型 泛型R : 表示的是把流中的元素转成的目标类型

list.stream().map(  (String s) -> { return new Student(s); }  ).forEach( (Student s) -> { System.out.println(s);} );

6 Stream<T> distinct()：去除流中重复的元素。依赖(hashCode和equals方法)

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

7 Stream<T> sorted () : 将流中元素按照自然排序的规则排序

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

8 Stream<T> sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序

list2.stream().sorted( (Integer o1 , Integer o2) -> { return o2 - o1; } ).forEach(s -> System.out.println(s));

### 终结流: ###

一个Stream流只能有一个终结方法是流水线上的最后一个操作

void forEach(Consumer action)：对此流的每个元素执行操作  
Consumer接口中的方法 void accept(T t)：对给定的参数执行此操作

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

long count()：返回此流中的元素个数

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

### 收集流的操作 ###

####    第一部分 ####

需求：过滤元素并遍历集合  
定义一个集合，并添加一些整数 1,2,3,4,5,6,7,8,9,10  
将集合中的奇数删除，只保留偶数。  
遍历集合得到 2，4，6，8，10 结论：在Stream流中无法直接修改集合,数组等数据源中的数据。

public class StreamDemo5 {
        public static void main(String[] args) {
            ArrayList<Integer> list = new ArrayList<>();
            // 批量添加数据
            Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    
            // 将集合中的奇数删除，只保留偶数。
            list.stream().filter( (Integer i) -> {return i % 2 == 0;} ).forEach(
                    s -> System.out.println(s)
            );
    
            System.out.println("集合中的元素:" + list);
        }
    }

####    第二部分 ####

使用Stream流的方式操作完毕之后，我想把流中的数据起来，该怎么办呢？

Stream流的收集方法  
R collect(Collector collector) : 此方法只负责收集流中的数据 , 创建集合添加数据动作需要依赖于参数 工具类Collectors提供了具体的收集方式  
public static <T> Collector toList()：把元素收集到List集合中  
public static <T> Collector toSet()：把元素收集到Set集合中  
public static Collector toMap(Function keyMapper,Function valueMapper)：把元素收集到Map集合中  
 **Set**  
 **需求 :  
定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10  
将集合中的奇数删除，只保留偶数。  
遍历集合得到2，4，6，8，10**

public class StreamDemo6 {
        public static void main(String[] args) {
            ArrayList<Integer> list = new ArrayList<>();
            // 批量添加数据
            Collections.addAll(list, 1, 2, 2, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 10);
    
            Set<Integer> set = list.stream().filter((Integer i) -> {
                return i % 2 == 0;
            }).collect(Collectors.toSet());
            System.out.println("set = " + set);
        }

**List  
收集方法叫做collect , 但是此方法只负责收集元素 => 2 4 6 8 10 , 并把添加完元素的List集合返回  
Collectors.toList() : 在底层会创建一个新的List集合 , 并把collect方法收集到的元素2 4 6 8 10存储到List集合中**

List<Integer> newList = list.stream().filter((Integer i) -> {
                return i % 2 == 0;
            }).collect(Collectors.toList());
    
            System.out.println("newList = " + newList);
        }

####    第三部分 ####

**1 创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄  
"zhangsan,23"  
"lisi,24"  
"wangwu,25"  
2 保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值  
需求1 : 保留年龄大于等于24岁的人  
需求2 : 并将结果收集到Map集合中，姓名为键，年龄为值  
收集方法 :  
public static Collector toMap(Function keyMapper , Function valueMapper)：把元素收集到Map集合中**

public static void main(String[] args) {
            // 创建一个集合
            ArrayList<String> list = new ArrayList<>();// {"zhangsan,23", "lisi,24", "wangwu,25"}
            Collections.addAll(list, "zhangsan,23", "lisi,24", "wangwu,25");
    
    
            Map<String, Integer> map = list.stream().filter((String s) -> {
                // 需求1 : 保留年龄大于等于24岁的人
                String[] strings = s.split(",");
                // 把字符串"23" 转换成 整数 23
                int age = Integer.parseInt(strings[1]);
                return age >= 24;
            }).collect(Collectors.toMap(
    
                    /*
                        流中的数据 : "lisi,24"  , "wangwu,25"
                        lambda中的形参s , 表示的就是流中的每一个数据
                        举例 : s = "wangwu,25"
                     */
    
                    (String s) -> {
                        String[] strings = s.split(",");// {"lisi" , "24"}
                        return strings[0];
                    }  // 需要设定map集合中的键
                    ,
                    (String s) -> {
                        String[] strings = s.split(",");// {"lisi" , "24"}
                        return Integer.parseInt(strings[1]);
                    }
            ));
    
            // 打印map集合
            System.out.println(map);
        }
    }

## Optional ##

###    优势 : ###

Optional 类的引入很好的解决空指针异常 , 同样Optional类可以对空值判断形成一种规范

boolean present = Optional.ofNullable(stu).isPresent();
            if(present){
                System.out.println("有效对象");
            }

####    public static <T> Optional<T> of(T value) : ####

通过非null值构建一个Optional容器,注意value不能不为null否则抛出异常

String s = "abc";
          
            Optional<String> optional = Optional.of(s);
            System.out.println(optional);

返回结果:Optional\[abc\]  
(null)空的话报错

####    public static <T> Optional<T> ofNullable(T value) : ####

通过指定值构建一个Optional容器,如果值为null则返回Optional.empty

String s ="abc";
             Optional<String> optional = Optional.ofNullable(s);
             System.out.println(optional);

返回结果:Optional\[abc\]  
(null)空的话:Optional.empty

####    public T orElse(T other) : ####

返回值如果存在，否则返回 other 。

String s = "abc";
    Optional<String> optional = Optional.ofNullable(s);
    String result = optional.orElse("qwe");
             System.out.println("result = " + result);

返回结果:Optional\[abc\]  
(null)空的话:返回qwe

####    public boolean isPresent() : ####

如果对象为null返回的是false , 如果对象不为null返回的是true !!!

boolean result = optional.isPresent();
             System.out.println(result);

不为空返回结果true  
(null)空的话:返回false

####    public T get() : ####

如果 Optional中存在值，则返回值，否则抛出 NoSuchElementException

if (optional.isPresent()) {
                String s1 = optional.get();
                System.out.println(s1);
            }

Optional中存在值，则返回值，否则抛出 NoSuchElementException

[b727ed7fa76e4f77b2c45d051d1b264b.png]: https://img-blog.csdnimg.cn/b727ed7fa76e4f77b2c45d051d1b264b.png