Stream流

Stream流

一、认识Stream流   

stream流是Jdk8开始新增的一套API(java.util.stream.*)，可以用于操作集合或者数组的数据。

优点：Stream流大量的结合了Lambda的语法风格来编程，功能强大，性能高效，代码简洁，可读性好。

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

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("赵敏");
        list.add("周芷若");
        list.add("张强");
        list.add("张三丰");
        list.add("张翠山");;
        //使用stream流，查找姓张且长度为3的人
        list.stream()
                .filter(name -> name.startsWith("张"))
                .filter(name -> name.length() == 3)
                .forEach(System.out::println);
    }
}

stream流的使用步骤

1、获取Stream流：Stream流代表一条流水线，并能与数据源建立连接。

2、调用流水线的各种方法：数据进行处理、计算。

3、获取处理的结果：遍历、统计、收集到一个新集合中返回。

二、获取Stream流

1.获取集合的Stream流

public interface stream<T>...{        }

default stream<E>stream()        获取当前集合对象的stream流

2.获取数组的Stream流

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

Stream类提供的如下方法                                          说明
public static<T>Stream<T> of(T... values)                获取当前接收数据的stream流

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

public class Demo02 {
    public static void main(String[] args) {
        //获取stream流的方式
        //1.获取集合的stream流，调用方法stream()

        Collection<String> list = new ArrayList<>();
        Stream<String> s1 = list.stream();
        //2.Map集合，怎么拿stream流,键值对分开拿，或者使用map.entrySet()
        Map<String, Integer> map = new HashMap<>();
        //获取key的stream流
        Stream<String> s2 = map.keySet().stream();
        //获取value的stream流
        Stream<Integer> s3 = map.values().stream();
        //获取键值对的stream流
        Stream<Map.Entry<String, Integer>> s4 = map.entrySet().stream();
        //获取数组的stream流
        String[] names = new String[]{"张三丰", "张翠山", "张无忌"};
        Stream<String> s6 = Arrays.stream(names);
        Stream<String> s5 = Stream.of(names);
        Stream<String> s7 = Stream.of("张三丰", "张翠山", "张无忌");
    }
}

三、Stream流的常用方法 

1.中间方法

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

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

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class Demo03 {
    public static void main(String[] args) {
        //Stream流中的中间方法，对流的操作，不会改变原来的流，而是返回了一个新的流
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("赵敏");
        list.add("周芷若");
        list.add("张强");
        list.add("张三丰");
        list.add("张翠山");
        ;
        //1.过滤方法，过滤出姓张的人
        list.stream()
                .filter(name -> name.startsWith("张") && name.length() == 3)
                .forEach(System.out::println);
        //2.排序方法
        List<Double> scores = new ArrayList<>();
        scores.add(99.3);
        scores.add(98.5);
        scores.add(99.6);
        scores.add(99.9);
        scores.add(99.2);
        scores.add(99.1);
        scores.stream()
                .sorted()//升序
                .limit(2)//获取前两个
                .forEach(System.out::println);
        System.out.println("-----------------------------------");
        scores.stream()
                .sorted((o1, o2) -> Double.compare(o2, o1))//降序
                .distinct()//去重
                .skip(2)//跳过前两个
                .forEach(System.out::println);
        //3.map映射方法，将流中的元素进行映射，拿出来变成新数据，又放到流上，返回一个新的流
        System.out.println("++++++++++++++++++++++++++++++++++++");
        scores.stream()
                .map(s -> "加十分后:"+(s+10)).forEach(System.out::println);
        System.out.println("-----------------------------------");

        //4.合并流
        Stream<String> s1 = Stream.of("张无忌", "赵敏", "周芷若");
        Stream<Integer> s2 = Stream.of(18, 36, 38);
        Stream<Object> s3 = Stream.concat(s1, s2);
        s3.forEach(System.out::println);
    }
}

2.终结方法

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

Stream提供的常用终结方法                             说明
void forEach(Consumer action)                       对此流运算后的元素执行遍历
long count()                                        统计此流运算后的元素个数
Optional<T>max(Comparator<? super T>comparator)     获取此流运算后的最大值元素
Optional<T>min(Comparator<? super T>comparator)     获取此流运算后的最小值元素

四、斗地主案例 

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Room room = new Room();
        room.start();
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Poker {
    private String size;
    private String color;
    private int num;

    @Override
    public String toString() {
        return size + color;
    }
}

class Room {
    private List<Poker> cards = new ArrayList<>();

    {
        String[] sizes = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        String[] colors = {"♦", "♣", "♥", "♠"};
        int num = 0;
        for (String size : sizes) {
            num++;
            for (String color : colors) {
                cards.add(new Poker(size, color, num));
            }
        }
        cards.add(new Poker("joker", "♚", ++num));
        cards.add(new Poker("Joker", "♛", ++num));
    }

    public void start() {
        Collections.shuffle(cards);
        Map<String, List<Poker>> players = new HashMap<>();
        List<Poker> player1 = new ArrayList<>();
        List<Poker> player2 = new ArrayList<>();
        List<Poker> player3 = new ArrayList<>();

        players.put("双哥", player1);
        players.put("龙哥", player2);
        players.put("国哥", player3);

        for (int i = 0; i < cards.size() - 3; i++) {
            Poker poker = cards.get(i);
            switch (i % 3) {
                case 0 -> player1.add(poker);
                case 1 -> player2.add(poker);
                case 2 -> player3.add(poker);
            }
        }

        List<Poker> dipai = cards.subList(cards.size() - 3, cards.size());
        System.out.println("底牌是：" + dipai);

        // 排序
        sortCards(player1);
        sortCards(player2);
        sortCards(player3);

        // 看牌
        players.forEach((name, pokers) ->
                System.out.println(name + ":" + pokers));
    }

    // 独立的排序方法
    private void sortCards(List<Poker> pokers) {
        pokers.sort((o1, o2) -> o2.getNum() - o1.getNum());
    }
}