【Java】基础练习 --- Stream练习

1.拼接

给定一个字符串数组,使用 Stream 把所有字符串拼接成一个字符串。

String[] arr = {"a", "b", "c"};
输出: abc
1
2

（1）源码：

package swp.kaifamiao.codes.Java.d0907;

import java.util.stream.Stream;

/**
 * {class description}
 * 给定一个字符串数组,使用 Stream 把所有字符串拼接成一个字符串。
 * 本题使用 reduce 方法来将所有的字符串通过指定的操作（这里是字符串连接）合并在一起
 * @author SWP
 * @version 1.0.0
 */
public class Text01 {
    public static void main(String[] args) {
        // 给定一个字符串数组
        String[] arr = {"H", "e", "l","l","o"," ","W","o","r","l","d","!"};
        // 创建一个Stream对象，将字符串数组转换为 Stream
        Stream<String> stringStream = Stream.of(arr);
        // 使用 reduce方法将所有的字符串通过字符串连接操作合并在一起
        // reduce方法接收两个参数，一个是初始值，一个是 BinaryOperator 接口的实现，这里传入一个空字符串作为初始值，
        // 并使用 lambda 表达式来实现字符串的连接操作
        String result = stringStream.reduce( "" ,(s1,s2) -> s1 + s2);
        // 输出拼接后的结果
        System.out.println(result);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

（2）运行效果：

---

2.求值

有一个整数集合，分别完成以下操作：

• 所有元素之和
• 最大值
• 最小值

（1）源码：

package swp.kaifamiao.codes.Java.d0907;

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

/**
 * {class description}
 * 有一个整数集合，分别完成以下操作：
 * 1.所有元素之和
 * 2.最大值
 * 3.最小值
 * @author SWP
 * @version 1.0.0
 */
public class Text02 {
    public static void main(String[] args) {
        // 创建一个整数数组列表
        List<Integer> numbers = Arrays.asList(5,2,0,1,3,14);
        // 创建Stream流对象
        Stream stream = numbers.stream();
        // 使用reduce方法计算所有元素的和
        int sum = numbers.stream().reduce(0,Integer::sum);
        System.out.println("所有元素和为:" + sum);
        // 求最大值
        int max = numbers.stream().max(Integer::compare).get();
        System.out.println("元素中的最大值:" + max);
        // 求最小值
        int min = numbers.stream().min(Integer::compare).get();
        System.out.println("元素中的最小值:" + min);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

（2）运行效果：

---

3.薪资最低的员工

有一个员工类Employee,里面有name、age和salary字段。请通过 Stream 对多个Employee对象按salary排序,然后取前3个输出。

（1）源码：

package swp.kaifamiao.codes.Java.d0907;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * {class description}
 * 有一个员工类Employee,里面有name、age和salary字段。请通过 Stream 对多个 Employee 对象按 salary 排序,然后取前3个输出。
 * @author SWP
 * @version 1.0.0
 */
public class Text03 {
    public static void main(String[] args) {
        List<Employee> emp = new ArrayList<>();
        emp.add(new Employee("张三",20,6900.98));
        emp.add(new Employee("李四",27,8980.23));
        emp.add(new Employee("王五",24,6102.34));
        emp.add(new Employee("钱六",25,7200.00));
        emp.add(new Employee("赵七",22,9000.88));
        emp.add(new Employee("孙八",23,12900.66));
        // 创建 Stream 流对象
        Stream stream = emp.stream();
        // 使用sorted方法进行排序，并使用 limted 进行截取，最后使用 Collector 将流中的数据收集到集合中
        List<Employee> sortedEmployees = emp.stream()
                .sorted(Comparator.comparingDouble(Employee::getSalary))
                .limit(3)
                .collect(Collectors.toList());
        // 遍历输出
        for (Employee employee : sortedEmployees) {
            System.out.println(employee);
        }

    }
}
class Employee{
    private String name;
    private Integer age;
    private Double salary;

    public Employee() {
    }

    public Employee(String name, Integer age, Double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public Integer getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(Integer age) {
        this.age = age;
    }

    /**
     * 获取
     * @return salary
     */
    public Double getSalary() {
        return salary;
    }

    /**
     * 设置
     * @param salary
     */
    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public String toString() {
        return "Employee{name = " + name + ", age = " + age + ", salary = " + salary + "}";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

（2）运行效果：

---

4.平均值

有一个整数集合，求每个元素平方的平均值。

（1）源码：

package swp.kaifamiao.codes.Java.d0907;

import java.util.List;

/**
 * {class description}
 * 有一个整数集合，求每个元素平方的平均值。
 * @author SWP
 * @version 1.0.0
 */
public class Text04 {
    public static void main(String[] args) {
     
        List<Integer> numbers1 = List.of(5,2,0,1,3,1,4);
        System.out.println(numbers1.stream().mapToDouble(x ->x*x).average());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

（2）运行效果：

---

5.斗地主

有一个集合保存扑克牌的花色(四种)，另一个集合保存扑克牌点数(13个)。创建一个新的集合保存所有的扑克牌(54张，包含 大小王)。将扑克牌分为四份（3个玩家，1份底牌），排序后输出四份手牌。

（1）Text05类：

package swp.kaifamiao.codes.Java.d0907;

import java.util.*;

/**
 * {class description}
 *
 * @author SWP
 * @version 1.0.0
 */
public class Text05 {
    public static void main(String[] args) {
        // 创建花色的集合
        List<String> flower = new ArrayList<>();
        // 向集合中添加花色元素
        Collections.addAll(flower, "♠️", "♥️", "♦️", "♣️");

        // 创建点数的集合
        List<String> points = new ArrayList<>();
        // 向点数集合中添加元素
        Collections.addAll(points,"A","2","3","4","5","6","7","8","9","10","J","Q","K");

        // 创建扑克牌的集合
        List<String> poker = new ArrayList<>();
        // 遍历两个集合，向扑克牌中添加大小王外的其他52张手牌
        for (String flowerItem : flower){
            for (String pointsItem : points){
                poker.add(flowerItem+pointsItem);
            }
        }
        // 向手牌的集合中添加大小王
        poker.add("JOKER");
        poker.add("joker");

        // 打乱手牌顺序（洗牌）
        Collections.shuffle(poker);

        // 创建 玩家一 的手牌集合,截取 0 到 1/3的手牌给到 玩家一
        List<String> player1 = new ArrayList<>(poker.subList(0 , (poker.size()-3)/3));

        // 创建 玩家二 的手牌集合 ，截取 1/3 到 2/3 的手牌给到 玩家二
        List<String> player2 = new ArrayList<>(poker.subList((poker.size()-3)/3 , (poker.size()-3)*2/3));

        // 创建玩家三的手牌的集合 , 截取 2/3 到 poker.size() 的手牌给到 玩家三
        List<String> player3 = new ArrayList<>(poker.subList((poker.size()-3)*2/3 , poker.size() - 3));

        // 创建底牌的集合(最后三张)
        List<String> bottom = new ArrayList<>(poker.subList(poker.size() - 3, poker.size()));

        for (int count = 0, i = 0; count < 17; count ++) {
            player1.add(poker.get(i ++));
            player2.add(poker.get(i ++));
            player3.add(poker.get(i ++));
        }

        Collections.sort(player1);
        Collections.sort(player2);
        Collections.sort(player3);

        // 输出 各位玩家的 手牌 以及 底牌
        System.out.println("玩家1 的手牌为:" + player1);
        System.out.println("玩家2 的手牌为:" + player2);
        System.out.println("玩家3 的手牌为:" + player3);
        System.out.println("底牌 为:" + bottom);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

（2）PokerGame类：

package swp.kaifamiao.codes.Java.d0907;

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

/**
 * {class description}
 *
 * @author SWP
 * @version 1.0.0
 */
public class PokerGame {
    private Poker poker;

    public PokerGame(){
        poker = new Poker();
    }

    public List<List<String>> start(){
        // 扑克牌
        List<Poker.Card> poker = this.poker.getPokers();
        // 洗牌
        for (int i = 0; i < 3; i++) {
            Collections.shuffle(poker);
        }

        // 发牌
        List<Poker.Card> player1 = new ArrayList<>();
        List<Poker.Card> player2 = new ArrayList<>();
        List<Poker.Card> player3 = new ArrayList<>();
        List<String> bottom = List.of(poker.get(51).getString(), poker.get(52).getString(), poker.get(53).getString());

        for (int count = 0, i = 0; count < 17; count ++) {
            player1.add(poker.get(i ++));
            player2.add(poker.get(i ++));
            player3.add(poker.get(i ++));
        }

        // 排序
        List<String> p1 = player1.stream()
                .sorted((a, b) -> a.getOrder() - b.getOrder())
                .map(a -> a.getString())
                .collect(Collectors.toList());

        List<String> p2 = player2.stream()
                .sorted((a, b) -> a.getOrder() - b.getOrder())
                .map(a -> a.getString())
                .collect(Collectors.toList());

        List<String> p3 = player3.stream()
                .sorted((a, b) -> a.getOrder() - b.getOrder())
                .map(a -> a.getString())
                .collect(Collectors.toList());

        // 结果
        List<List<String>> result = List.of(p1, p2, p3, bottom);

        return result;
    }

}

class Poker {
    // 花色
    private static final List<String> color = List.of("♠", "♥", "♣", "♦");
    // 点数
    private static final List<String> points = List.of("2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");

    private List<Card> pokers;

    public Poker(){
        pokers = new ArrayList<>();
        for (int i = 0; i < color.size(); i++) {
            for (int j = 0; j < points.size(); j++) {
                // order 4 * j + i + j + 2
                pokers.add(new Card(color.get(i), points.get(j), j + 2));
            }
        }

        // 大小王
        pokers.add(new Card(null, "大王", 0));
        pokers.add(new Card(null, "小王", 1));
    }

    public List<Card> getPokers() {
        return pokers;
    }

    public void setPokers(List<Card> pokers) {
        this.pokers = pokers;
    }


    class Card {

        private String color;

        private String point;

        private Integer order;

        public Card(String color, String point, Integer order){
            this.color = color;
            this.point = point;
            this.order = order;
        }

        public Integer getOrder(){
            return this.order;
        }

        public String getString(){
            return color == null? point : color + point;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

（3）GameTest类：

package swp.kaifamiao.codes.Java.d0907;

import java.util.List;

/**
 * {class description}
 *
 * @author SWP
 * @version 1.0.0
 */
public class GameTest {
    public static void main(String[] args) {
        PokerGame game = new PokerGame();

        List<List<String>> start = game.start();

        for (List<String> list : start){
            System.out.println(list);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

（4）运行效果：

---

6.生日提醒

编写一个生日提醒程序，使用Map来存储人名和对应的生日日期。够根据日期提醒用户哪些人今天过生日？

（1）源码:

package swp.kaifamiao.codes.Java.d0907;

import java.time.LocalDate;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * Text06类用于计算距离生日还有多少天
 */
public class Text06 {
    public static void main(String[] args) {
        // 创建一个HashMap用于存储人员姓名和生日信息
        HashMap<String, LocalDate> brith = new HashMap<>();

        // 添加人员的生日信息
        brith.put("张三", LocalDate.of(2002, 5, 20));
        brith.put("李四", LocalDate.of(1998, 9, 12));
        brith.put("王五", LocalDate.of(1997, 5, 14));

        // 输出当前所有生日信息
        System.out.println(brith);

        // 使用迭代器遍历生日信息
        Iterator<Map.Entry<String, LocalDate>> iterator = brith.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, LocalDate> next = iterator.next();
            // 计算距离当前日期的天数
            int day = next.getValue().getDayOfMonth() - LocalDate.now().getDayOfMonth();
            // 判断是否在当前月份且距离生日的天数小于等于7天
            boolean isBrith = next.getValue().getMonth().equals(LocalDate.now().getMonth())
                    && day <= 7;
            // 输出距离生日的天数
            if (isBrith) {
                System.out.printf("距离%s生日还有%d天\n", next.getKey(), day);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

（2）运行效果：