Java8 Stream

Java8 Stream

Java8中的Stream是一种新的抽象概念，它可以让你以一种声明的方式处理数据集合。Stream API可以极大地简化代码编>写，同时提高代码的可读性和性能。下面是Java8新特性Stream的介绍和示例：

Stream的特点：

Stream不是数据结构，它不会保存数据。
Stream不会改变源对象，相反，他们会返回一个持有结果的新Stream。
Stream操作是延迟执行的。这意味着它们会等到需要结果时才执行。
Stream的操作分为两类：中间操作和终端操作。中间操作返回一个新的Stream对象，可以链式调用多个中间操作。终端操作>会生成一个结果或副作用，例如forEach()或sum()。

例：

List<String> list = Arrays.asList("apple", "banana", "orange", "avocado");
list.stream().filter(s -> s.startsWith("a")).forEach(System.out::println);

users.add(new User(1, "aaa", 31, "M", false));
users.add(new User(2, "bbb", 28, "F", true));
users.add(new User(3, "ccc", 2, "M", false));
users.add(new User(4, "ddd", 5, "F", false));

一、查找

1. findFirst

如果一个集合数据是有序的，而且你要查找符合条件的第一条数据。

这时用findFirst是比较合适的。

Optional<User> optional = users.stream().filter(a -> a.getAge() > 5).findFirst();

if (optional.isPresent()){
    System.out.println(optional.get().getName());
}

2. findAny

将返回集合中符合条件的任意一个元素。

Optional<User> any = users.stream().filter(a -> a.getAge() < 30).findAny();

if (any.isPresent()){
    System.out.println(any.get().getName());
}

3. findFirst和findAny如何选择？

• 如果你不关心返回的是哪一个数据，只要符合条件的就行，那就用findAny。
  而且在并行流上，findAny限制更少。
• 如果你关心集合的顺序，要返回符合条件的第一个元素，那就用findFirst。

二、匹配

1. anyMatch

是否有1条age>50的数据？

Boolean anyMatch= users.stream().anyMatch(a -> a.getAge() > 50);

2. allMatch

是否所有数据都满足age<50

Boolean allMatch= users.stream().allMatch(a -> a.getAge() < 50);

3. noneMatch

是否所有数据都不满足age<50

Boolean noneMatch= users.stream().noneMatch(a -> a.getAge() < 50);

三、过滤合计排序

1.如果满足条件的对象存在

如果对象不存在，则会抛出异常：java.util.NoSuchElementException: No value present

User user = userList.stream().filter(t -> 1 == t.getId()).findAny().get();

2.如果对象不存在则返回特定对象

User n = userList.stream().filter(t -> 3 == t.getId()).findAny().orElse(null);

3.判断对象是否存在

boolean b = userList.stream().filter(t -> 3 == t.getId()).findAny().isPresent();

4.List

List<User> users = userList.stream().filter(u -> u.getGae() > 18).collect(Collectors.toList());

5.合计

int sum = userList.stream().mapToInt(User::getAge()).sum();

6.排序

// 降序reversed
companyList = companyList.stream().sorted(Comparator.comparing(Company::getCreateTime).reversed()).collect(Collectors.toList());

7.查找下标

可以使用Java 8的Stream API和Lambda表达式来实现查找list中值的index。下面是一个示例代码：

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        int valueToFind = 6;
        int index = list.stream()
                .filter(i -> i == valueToFind)
                .findFirst()
                .map(i -> list.indexOf(i))
                .orElse(-1);

        System.out.println("The index of " + valueToFind + " is: " + index);
    }
}

要找到列表中特定值的最后一个索引，可以使用Java 8的Stream API和Lambda表达式来实现。下面是一个示例代码：

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 5, 10);

        int valueToFind = 5;
        int lastIndex = IntStream.range(0, list.size())
                .filter(i -> list.get(i) == valueToFind)
                .reduce((first, second) -> second)
                .orElse(-1);

        System.out.println("The last index of " + valueToFind + " is: " + lastIndex);
    }
}

java 8 找到list 最后一个值得index

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        int lastIndex = list.stream()
                .reduce((first, second) -> second)
                .map(i -> list.lastIndexOf(i))
                .orElse(-1);

        System.out.println("The last index is: " + lastIndex);
    }
}

四、去重

数组去重复方式

    /***
     * 数组去重复方式
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<String> aList = new ArrayList<String>();
        aList.add("aa");
        aList.add("bb");
        aList.add("cc");
        aList.add("dd");
        aList.add("cc");
        aList.add("dd");
        aList.add("aa");
        aList.add("bb");
        aList.add("cc");
        aList.add("cc");
        aList.add("aa");

        // 1.groupingBy方法（这个去重复结果是乱序的）
        List<String> newList = aList.stream().collect(Collectors.groupingBy(m -> m)).keySet()
                .stream().collect(Collectors.toList());
        // 升序排序
        newList.stream().sorted().collect(Collectors.toList()).
                forEach(m -> System.out.println(m));

        // 2.set方法
        ArrayList<String> collect = aList.stream().collect(
                Collectors.collectingAndThen(
                        Collectors.toCollection(
                                () -> new HashSet<>()
                        )
                        , ArrayList::new)
        );
        System.out.println("=============================");
        collect.forEach(m -> System.out.println(m));
    }

 // 结果========================================================
 aa
 bb
 cc
 dd
 // ==========================================================

其他

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 10, 15, 20, 25);

        // 从集合中过滤出所有大于10的数字
        List<Integer> filteredNumbers = numbers.stream()
                .filter(num -> num > 10)
                .collect(Collectors.toList());
        System.out.println(filteredNumbers); // 输出: [15, 20, 25]

        // 将集合中的所有元素转换为大写
        List<String> words = Arrays.asList("apple", "banana", "orange");
        List<String> upperCaseWords = words.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println(upperCaseWords); // 输出: [APPLE, BANANA, ORANGE]

        // 对集合中的所有元素进行求和
        int sum = numbers.stream()
                .reduce(0, Integer::sum);
        System.out.println(sum); // 输出: 75

        // 从集合中找出最大的元素
        int max = numbers.stream()
                .max(Integer::compareTo)
                .get();
        System.out.println(max); // 输出: 25

        // 从集合中找出最小的元素
        int min = numbers.stream()
                .min(Integer::compareTo)
                .get();
        System.out.println(min); // 输出: 5

        // 对集合中的所有元素进行排序
        List<Integer> sortedNumbers = numbers.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.println(sortedNumbers); // 输出: [5, 10, 15, 20, 25]

        // 从集合中找出所有不重复的元素
        List<Integer> distinctNumbers = Arrays.asList(1, 2, 3, 4, 5, 5, 4, 3, 2, 1);
        List<Integer> uniqueNumbers = distinctNumbers.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println(uniqueNumbers); // 输出: [1, 2, 3, 4, 5]
    }
}