乐趣区

关于java:Java-8引入的Stream-API附代码示例

jiezi

在 Java 8 中，引入了 Stream API，它是一种用于解决汇合数据的新形式。Stream API 提供了一种函数式编程的办法来解决汇合，使得代码更加简洁和易读。上面是一些罕用的 Stream API 及其代码示例：

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

    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(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()：将流中的元素映射为另一种类型，并返回一个新的流。

    import 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. flatMap()：将流中的每个元素映射为一个流，而后将这些流扁平化为一个流。

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

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

     // 将嵌套的列表转换为单层的流
     List<Integer> flattenedNumbers = nestedNumbers.stream()
                                                   .flatMap(list -> list.stream())
                                                   .collect(Collectors.toList());

     System.out.println(flattenedNumbers); 
 }
}

// 输入: [1, 2, 3, 4, 5, 6, 7, 8, 9]

  4. forEach()：对汇合中的每个元素执行指定操作。

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

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

     // 对汇合中的每个元素执行打印操作
     names.stream()
          .forEach(name -> System.out.println(name));
 }
}

  5. reduce()：对汇合中的元素进行归约操作，返回一个后果。

    import 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);

     if (sum.isPresent()) {int totalSum = sum.get();
         System.out.println("Sum:" + totalSum); 
     } else {System.out.println("Stream is empty.");
     }
 }
}

// 输入: Sum: 15

  6. collect()：将 Stream 中的元素收集到一个汇合中。

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

public class Main {public static void main(String[] args) {List<String> words = Arrays.asList("hello", "world");

     // 将所有单词收集到一个新的列表中
     List<String> collectedWords = words.stream()
                                        .collect(Collectors.toList());

     System.out.println(collectedWords); 
 }
}

// 输入: [hello, world]

  7. skip()：跳过流中的前 N 个元素，并返回一个新的流，其中蕴含原始流中从第 N + 1 个元素开始的所有元素。

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

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

     // 跳过前 3 个元素
     List<Integer> skippedNumbers = numbers.stream()
                                           .skip(3)
                                           .collect(Collectors.toList());

     System.out.println(skippedNumbers); 
 }
}

// 输入: [4, 5, 6]

  8. allMatch()：查看流中的所有元素是否都满足给定的条件。满足，返回 true；否则，返回 false。

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

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

     // 查看是否所有元素都大于 0
     boolean allGreaterThanZero = numbers.stream()
                                         .allMatch(n -> n > 0);

     System.out.println(allGreaterThanZero); // 输入: true

     // 查看是否所有元素都为偶数
     boolean allEvenNumbers = numbers.stream()
                                     .allMatch(n -> n % 2 == 0);

     System.out.println(allEvenNumbers); // 输入: false
 }
}

  9. anyMatch()：查看流中是否存在至多一个元素满足给定的条件。当流中至多有一个元素满足给定的条件时，返回 true；否则，返回 false。

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

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

     // 查看是否存在大于 3 的元素
     boolean anyGreaterThanThree = numbers.stream()
                                          .anyMatch(n -> n > 3);

     System.out.println(anyGreaterThanThree); // 输入: true

     // 查看是否存在正数元素
     boolean anyNegativeNumber = numbers.stream()
                                        .anyMatch(n -> n < 0);

     System.out.println(anyNegativeNumber); // 输入: false
 }
}

  10. noneMatch()：查看流中是否没有任何一个元素满足给定的条件。当流中没有任何一个元素满足给定的条件时，返回 true；否则，返回 false。

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

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

     // 查看是否没有大于 5 的元素
     boolean noneGreaterThanFive = numbers.stream()
                                          .noneMatch(n -> n > 5);

     System.out.println(noneGreaterThanFive); // 输入: true

     // 查看是否没有正数元素
     boolean noneNegativeNumber = numbers.stream()
                                        .noneMatch(n -> n < 0);

     System.out.println(noneNegativeNumber); // 输入: true
 }
}

  11. findFirst()：返回流中的第一个元素（依照流的遍历程序）。具体而言，findFirst() 办法返回一个 Optional 对象，该对象能够蕴含流中的第一个元素，如果流为空，则返回一个空的 Optional 对象。

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

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

     // 返回流中的第一个元素
     Optional<String> firstElement = names.stream()
                                          .findFirst();

     if (firstElement.isPresent()) {String firstName = firstElement.get();
         System.out.println("First element:" + firstName); 
     } else {System.out.println("Stream is empty.");
     }
 }
}

// 输入: First element: Alice

  12. findAny()：返回流中的任意一个元素（依照流的遍历程序）。具体而言，findAny() 办法返回一个 Optional 对象，该对象能够蕴含流中的任意一个元素，如果流为空，则返回一个空的 Optional 对象。

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

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

     // 返回流中的任意一个元素
     Optional<String> anyElement = names.stream()
                                        .findAny();

     if (anyElement.isPresent()) {String anyName = anyElement.get();
         System.out.println("Any element:" + anyName); 
     } else {System.out.println("Stream is empty.");
     }
 }
}

// 输入: Any element: Alice 或者其余元素

  13. count()：返回流中的元素个数。具体而言，count() 办法返回一个 long 类型的值，示意流中的元素个数。

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

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

     // 返回流中的元素个数
     long count = names.stream()
                       .count();

     System.out.println("Number of elements:" + count); 
 }
}

// 输入: Number of elements: 4

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

    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(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]

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

    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(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]

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

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

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

     System.out.println(limitedNumbers); 
 }
}

// 输入: [1, 2, 3]

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

    import 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

    这些只是 Stream API 的一些罕用操作，还有很多其余的办法能够用于解决汇合数据。通过应用 Stream API，能够简化汇合的操作，并使代码更加清晰和易于了解。

退出移动版