Stream流

Stream流：

Stream也称Stream流，可以用于操作集合或者数组的数据。

优势：Stream流大量的结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作集合或者数组中的数据，代码更简洁，可读性更好。

 

 

Stream流思想：

Stream流相当于工厂里面的流水线，对数据进行加工处理。

Stream流的作用：简化集合和数组的操作。

 
 

Stream操作步骤:

Stream操作步骤:

​ ①获取Stream流

​ ②调用中间方法

​ ③调用终结方法

 

 

常用方法：

获取流：

集合 Stream流:

Collection提供的如下方法	说明
default Stream stream()	获取当前集合对象的Stream流

 

数组 的Stream流:

Arrays类提供的如下 方法	说明
public static Stream stream(T[] array)	获取当前数组的Stream流

 

零散数据 的Stream流：

Stream接口提供的如下 方法	说明
public static Stream of(T… values)	获取零散数据的Stream流

 
 

package com.ouyang.demo01;

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

public class demo01 {
    public static void main(String[] args) {
        // 1.Collection接口中有一个默认方法: Stream stream(); 集合得到流
        List<String> list=new ArrayList<>();
        Stream<String> stream01 = list.stream();

        Set<String> set=new HashSet<>();
        Stream<String> stream02 = set.stream();
        // 2.Map如何获取流? Map不能直接获取流, 获取键再获取流
        Map<String,String> map=new HashMap<>();
        Stream<String> stream03 = map.keySet().stream();

        Stream<Map.Entry<String, String>> stream04 = map.entrySet().stream();

        // 3.Arrays类的public static <T> Stream<T> stream(T[] array) 数组得到流
        String[] str=new String[]{"aa","bb","cc"};
        Stream<String> stream05 = Arrays.stream(str);

        // 4.Stream接口的public static<T> Stream<T> of(T... values) 零散数据得到流
        Stream<String> stream06 = Stream.of("aa", "bb", "cc");
        Stream<Integer> stream07 = Stream.of(11, 22, 33);
        System.out.println("stream07 = " + stream07);

    }
}

 
 

中间方法：

​ 中间方法指的是调用完成后会返回新的Stream流，可以继续使用(支持链式编程)。

Stream提供的常用中间方法	说明
Stream filter(Predicate<? super T> predicate)	用于对流中的数据进行过滤。
Streamsorted()	对元素进行升序排序
Stream sorted(Comparator <? super T> comparator)	按照指定规则排序
Stream limit(long maxSize)	获取前几个元素
Stream skip(long n)	跳过前几个元素
Stream distinct()	去除流中重复的元素。
Stream map(Function<? super T,? extends R> mapper)	对元素进行加工，并返回对应的新流
static Stream concat(Stream a, Stream b)	合并a和b两个流为一个流

 
 

终结方法：

​ 终结方法指的是调用完成后，不会返回新Stream了，没法继续使用流了。

Stream提供的常用终结方法	说明
void forEach(Consumer action)	对此流运算后的元素执行遍历
long count()	统计此流运算后的元素个数

注意：

​ 1.Stream流不调用终结方法，中间方法不会被调用。

​ 2.一个Stream流只能使用一次。

 

 

package com.ouyang.demo01;

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

public class demo02 {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        Collections.addAll(one, "迪丽热巴", "宋远桥", "宋远桥", "苏星河", "老子", "老子", "庄子", "孙子", "孙子");

        //1.获取stream流
        Stream<String> stream = one.stream();


        //2.调用中间方法
        Stream<String> stringStream = stream.filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                //为true保存，为false的元素去掉
                return s.length() == 3;
            }
        });


        //3.调用终结方法
        stringStream.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("s = " + s);
            }
        });


        System.out.println("--------------");
        
        //简化，正常一步到位，重要的规律Stream的方法中给Lambda表达式   参数就是元素  ->  操作的代码
        // 规范：多个方法链式调用，每个方法一行
        one.stream()
                .filter(s->s.length() == 3)
                .forEach(s->System.out.println("s = " + s));
    }
}

---

 

package com.ouyang.demo01;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

public class demo03 {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        Collections.addAll(one, "迪丽热巴", "宋远桥", "宋远桥", "苏星河", "老子", "老子", "庄子", "孙子", "孙子");

        //1.获取Stream流2.调用中间方法处理流中的数据3.调用终结方法结束流
        // 1.limit：取前3个数据
        // one.stream().limit(3).forEach(s-> System.out.println( s));
        // one.stream().limit(3).forEach(System.out::println);

        //2.skip：跳过前2条数据
        // one.stream().skip(2).forEach(System.out::println);


        //3.distinct：去除重复数据
        // one.stream().distinct().forEach(System.out::println);


        //4.map：映射，转换流中的数据
        // String  流中存储的数据类型  ,Integer  是map要转换（返回）的类型
        // one.stream().map(new Function<String, Integer>() {
        //     @Override
        //     public Integer apply(String s) {
        //         return s.length();
        //     }
        // }).forEach(System.out::println);

        // one.stream().map(s->s.length()).forEach(System.out::println);


        //5.sorted:排序
        // one.stream().sorted().forEach(System.out::println);

        //6.sorted：排序（使用比较器）
        //逆序排序
        // one.stream().sorted((o1,o2)->o2.compareTo(o1)).forEach(System.out::println);


        //7.Stream.concat：合并流
        // List<String> two = new ArrayList<>();
        // Collections.addAll(two, "OYO","OYO");
        List<Integer> two=new ArrayList<>();
        Collections.addAll(two,11,22,33);

        Stream.concat(one.stream(),two.stream()).forEach(System.out::println);


        //8.count：统计流中元素的数量
        long count = one.stream().distinct().count();
        System.out.println("count = " + count);
    }
}

 
 

收集Stream流：就是把Stream流操作后的结果转回到集合或者数组中去返回。

​

Stream流：方便操作集合/数组的手段； 集合/数组：才是开发中的目的。

 
 

Stream提供的常用终结方法	说明
R collect(Collector collector)	把流处理后的结果收集到一个指定的集合中去
Object[] toArray()	把流处理后的结果收集到一个数组中去

Collectors工具类提供了具体的收集方式	说明
public static Collector toList()	把元素收集到List集合中
public static Collector toSet()	把元素收集到Set集合中
public static Collector toMap(Function keyMapper , Function valueMapper)	把元素收集到Map集合中

 

package com.ouyang.demo01;

import java.util.*;
import java.util.stream.Collectors;

public class demo06 {


    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        Collections.addAll(list,"11","22","33","44","55");

        List<String> toList = list.stream().limit(3).collect(Collectors.toList());
        //简化

        Set<String> toSet = list.stream().limit(3).collect(Collectors.toSet());

        Map<String, Integer> toMap = list.stream().limit(3).collect(Collectors.toMap(s -> s, s -> s.length()));

        Object[] array = list.stream().limit(3).toArray();


    }
}