关于java:Java-8中filtermapsorteddistinctlimitreduce的用法

43次阅读

共计 2316 个字符，预计需要花费 6 分钟才能阅读完成。

在 Java 8 中，引入了一个名为 Stream 的全新 API，用于解决汇合数据。Stream API 提供了一种流式解决数据的办法，能够通过链式调用一系列的操作来解决汇合中的元素。以下是次要的 Stream API 及其代码示例：

1. filter()：依据指定条件过滤流中的元素，并返回一个新的流。

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(1, 2, 3, 4, 5);

        // 过滤出偶数
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(number -> number % 2 == 0)
                                           .collect(Collectors.toList());

        System.out.println(evenNumbers); // 输入: [2, 4]
    }
}

2. map()：将流中的元素映射为另一种类型，并返回一个新的流。

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

public class Main {public static void main(String[] args) {List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // 将名字转换为大写
        List<String> upperCaseNames = names.stream()
                                           .map(name -> name.toUpperCase())
                                           .collect(Collectors.toList());

        System.out.println(upperCaseNames); // 输入: [ALICE, BOB, CHARLIE]
    }
}

3. sorted()：对流中的元素进行排序，默认是升序。也能够传入自定义的 Comparator 来进行排序。

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(3, 1, 4, 1, 5, 9, 2);

        // 排序
        List<Integer> sortedNumbers = numbers.stream()
                                             .sorted()
                                             .collect(Collectors.toList());

        System.out.println(sortedNumbers); // 输入: [1, 1, 2, 3, 4, 5, 9]
    }
}

4. distinct()：去除流中的反复元素。

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(1, 2, 2, 3, 3, 3, 4, 5);

        // 去除反复元素
        List<Integer> distinctNumbers = numbers.stream()
                                               .distinct()
                                               .collect(Collectors.toList());

        System.out.println(distinctNumbers); // 输入: [1, 2, 3, 4, 5]
    }
}

5. limit()：截取流中的前 N 个元素。

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(1, 2, 3, 4, 5);

        // 截取前 3 个元素
        List<Integer> limitedNumbers = numbers.stream()
                                              .limit(3)
                                              .collect(Collectors.toList());

        System.out.println(limitedNumbers); // 输入: [1, 2, 3]
    }
}

6. reduce()：对流中的元素进行归约操作，能够通过提供的操作符（如加法、乘法等）进行计算。

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

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

        // 求和
        Optional<Integer> sum = numbers.stream()
                                       .reduce((a, b) -> a + b);

        System.out.println(sum.orElse(0)); // 输入: 15
    }
}