Java 8引入的Stream API，附代码示例

在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

18. removeIf()：可以方便的删除集合中满足指定条件的元素。

    List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
    
    // 删除所有偶数
    numbers.removeIf(n -> n % 2 == 0);
    
    System.out.println(numbers); 
    
    // 输出：[1, 3, 5]

19. merge()：用于合并具有相同键的值。

    import java.util.HashMap;
    import java.util.Map;
    
    public class Merge {
     public static void main(String[] args) {
         Map<String, Integer> map1 = new HashMap<>();
         map1.put("apple", 1);
         map1.put("banana", 2);
    
         Map<String, Integer> map2 = new HashMap<>();
         map2.put("banana", 3);
         map2.put("orange", 4);
    
         map2.forEach((key, value) -> map1.merge(key, value, (v1, v2) -> v1 + v2));
         System.out.println(map1);
     }
    }
    
    // 输出：{orange=4, banana=5, apple=1}
    
    // 该方法接受三个参数：
    // key：要合并的键。
    // value：要合并的值。
    // remappingFunction：一个BiFunction接口的实例，用于定义如何合并已有值和要合并的值。

20. concat()：用于将两个流合并为一个新的流。

    import java.util.stream.Stream;
    
    public class StreamConcatExample {
     public static void main(String[] args) {
         Stream<String> stream1 = Stream.of("Hello", "World");
         Stream<String> stream2 = Stream.of("Java", "8");
    
         Stream<String> concatStream = Stream.concat(stream1, stream2);
         concatStream.forEach(System.out::println);
     }
    }
    
    // 输出：
    // Hello
    // World
    // Java
    // 8

    这些只是Stream API的一些常用操作，还有很多其他的方法可以用于处理集合数据。通过使用Stream API，可以简化集合的操作，并使代码更加清晰和易于理解。