【java】java8 stream 案例

stream 使用案例

案例一：遍历数组、集合

• forEach

Integer[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Arrays.stream(array).forEach(System.out::println);

// 数组转list
List<Integer> list = Arrays.stream(array).collect(Collectors.toList());
// 另一种打印写法
list.stream().forEach(item -> System.out.println(item));

案例二：数组、集合转字符串

• joining

List<Integer> listInt = new ArrayList<>();
        listInt.add(1);
        listInt.add(2);
        listInt.add(3);
        listInt.add(4);
String str3 = listInt.stream().map(r -> r.toString()).collect(Collectors.joining(","));
System.out.println(str3);

案例三：数组、集合去掉某些元素

• filter

List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
list = list.stream().filter(item -> {
            return !item.equals("3");
        }).collect(Collectors.toList());
System.out.println(list);

结果：

原list [1, 2, 3, 4]
现list [1, 2, 4]

案例四：集合最大值

• max

List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
Integer integer = list.stream().max((x, y) -> {
            return (x - y);
        }).get();
System.out.println(integer);

结果：

9

案例五：集合求和

• reduce

List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
Integer integer = list.stream().reduce((x, y) -> x+y).get();
System.out.println(integer);

结果：

10

案例六：集合元素乘2

• map

List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
List<Integer> collect = list.stream().map(integer1 -> (integer1 * 2)).collect(Collectors.toList());

结果：

[2, 4, 6, 8]

案例七：集合元素排序

• map

List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
List<Integer> collect = list.stream().sorted((x, y) -> x - y).collect(Collectors.toList());

结果：

[1, 2, 3, 4]

案例八：集合元素排序

• map

List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
List<Integer> collect = list.stream().map(integer1 -> (integer1 * 2)).collect(Collectors.toList());

结果：

[2, 4, 6, 8]

案例九：List 转 HashMap

List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
Map<String, Integer> collect = list.stream().collect(Collectors.toMap(Function.identity(), s -> 1));

数组转list

String[] arr = {"a","b","c";
List list = Stream.of(arr).collect(Collectors.toList());

两个List集合取交集、并集、差集、去重并集的一个简单Demo，可供参考：

import java.util.ArrayList;
import java.util.List;
import static java.util.stream.Collectors.toList;
 
 
public class Test {
 
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>();
        list1.add("1");
		list1.add("2");
		list1.add("3");
		list1.add("5");
		list1.add("6");
 
        List<String> list2 = new ArrayList<String>();
        list2.add("2");
		list2.add("3");
		list2.add("7");
		list2.add("8");
 
        // 交集
        List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());
        System.out.println("---交集 intersection---");
        intersection.parallelStream().forEach(System.out :: println);
 
        // 差集 (list1 - list2)
        List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());
        System.out.println("---差集 reduce1 (list1 - list2)---");
        reduce1.parallelStream().forEach(System.out :: println);
 
        // 差集 (list2 - list1)
        List<String> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(toList());
        System.out.println("---差集 reduce2 (list2 - list1)---");
        reduce2.parallelStream().forEach(System.out :: println);
 
        // 并集
        List<String> listAll = list1.parallelStream().collect(toList());
        List<String> listAll2 = list2.parallelStream().collect(toList());
        listAll.addAll(listAll2);
        System.out.println("---并集 listAll---");
        listAll.parallelStream().forEachOrdered(System.out :: println);
 
        // 去重并集
        List<String> listAllDistinct = listAll.stream().distinct().collect(toList());
        System.out.println("---得到去重并集 listAllDistinct---");
        listAllDistinct.parallelStream().forEachOrdered(System.out :: println);
 
        System.out.println("---原来的List1---");
        list1.parallelStream().forEachOrdered(System.out :: println);
        System.out.println("---原来的List2---");
        list2.parallelStream().forEachOrdered(System.out :: println);
 
    }
}

groupingBy

1. 数据准备

public class TestGroupBy {
    @Data
    public static class User {
        private Integer id;
        private Integer schoolId;
        private String userName;
        private String edu;
        private double price;
    }

    public static List<TestListToMap.User> users = new ArrayList<>();

    static {
        TestListToMap.User u1 = new TestListToMap.User();
        u1.setId(1001);
        u1.setSchoolId(100);
        u1.setUserName("小1");
        u1.setEdu("001");
        u1.setPrice(0.01);

        TestListToMap.User u2 = new TestListToMap.User();
        u2.setId(1002);
        u2.setSchoolId(100);
        u2.setUserName("小2");
        u2.setEdu("002");
        u2.setPrice(0.20);
        
        TestListToMap.User u3 = new TestListToMap.User();
        u3.setId(2010);
        u3.setSchoolId(200);
        u3.setUserName("小3");
        u3.setEdu("001");
        u3.setPrice(3.00);
        
        TestListToMap.User u4 = new TestListToMap.User();
        u4.setId(3001);
        u4.setSchoolId(300);
        u4.setEdu("001");
        u4.setPrice(40.0);

        users.add(u1);
        users.add(u2);
        users.add(u3);
        users.add(u4);
    }
}

2. 处理

public void test1() {
    Map <String,List < User >> collect = users.stream().collect(Collectors.groupingBy(User: :getEdu));
}

forEach

public static void main(String[] args) {
        // 创建一个数组
        ArrayList<Integer> numbers = new ArrayList<>();

        // 往数组中添加元素
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        System.out.println("ArrayList: " + numbers);

        // 所有元素乘以 10
        System.out.print("更新 ArrayList: ");
       
        // 将 lambda 表达式传递给 forEach
        numbers.forEach((e) -> {
            e = e * 10;
            System.out.print(e + " ");
        });
    }

内容输出：

ArrayList: [1, 2, 3, 4]
更新 ArrayList: 10 20 30 40