Java Stream API 提供了许多用于处理集合数据的方法，以下是一些常用的方法：


  1. filter(Predicate<? super T> predicate)
  • 功能：用于过滤流中的元素。它接受一个Predicate（一个返回布尔值的函数式接口）作为参数，只有当Predicate返回true时，元素才会被保留在流中。
  • 示例：假设有一个包含整数的列表，我们想要过滤出所有偶数。 


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

public class StreamFilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> evenNumbers = numbers.stream()
               .filter(n -> n % 2 == 0)
               .collect(Collectors.toList());
        System.out.println(evenNumbers); 
    }
}


  • 输出：[2, 4, 6]


  1. map(Function<? super T,? extends R> mapper)
  • 功能：将流中的每个元素映射为另一个元素。它接受一个Function作为参数，该函数用于将输入元素转换为输出元素。
  • 示例：假设有一个包含字符串的列表，我们想要将每个字符串转换为其长度。

 


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

public class StreamMapExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        List<Integer> wordLengths = words.stream()
               .map(String::length)
               .collect(Collectors.toList());
        System.out.println(wordLengths); 
    }
}


  • 输出：[5, 6, 6]


  1. forEach(Consumer<? super T> action)
  • 功能：用于对流中的每个元素执行给定的操作。它接受一个Consumer（一个接受参数但不返回值的函数式接口）作为参数。
  • 示例：假设有一个包含整数的列表，我们想要打印每个整数。

 

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

public class StreamForEachExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        numbers.stream().forEach(System.out::println);
    }
}

 

1
2
3
4
5


  1. collect(Collector<? super T,A,R> collector)
  • 功能：用于将流中的元素收集到一个集合或其他数据结构中。它接受一个Collector作为参数，Collectors类提供了许多预定义的收集器。
  • 示例：除了前面示例中用到的Collectors.toList()，还可以使用Collectors.toSet()收集为一个集合，用于去除重复元素。 
import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;

public class StreamCollectExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3);
        Set<Integer> uniqueNumbers = numbers.stream()
               .collect(Collectors.toSet());
        System.out.println(uniqueNumbers); 
    }
}


  • 输出：[1, 2, 3]


  1. reduce(T identity, BinaryOperator<T> accumulator)
  • 功能：将流中的元素归约为一个值。它接受一个初始值（identity）和一个二元操作符（BinaryOperator，一个接受两个参数并返回一个相同类型参数的函数式接口）。
  • 示例：计算一个整数列表的总和。 
import java.util.Arrays;
import java.util.List;

public class StreamReduceExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.stream()
               .reduce(0, (a, b) -> a + b);
        System.out.println(sum); 
    }
}


  • 输出：15


  1. sorted () 和 sorted (Comparator<? super T> comparator)
  • 功能：对流中的元素进行排序。无参数的sorted()方法会按照元素的自然顺序进行排序（对于实现了Comparable接口的元素），带比较器的sorted方法可以根据自定义的比较规则进行排序。
  • 示例：对一个字符串列表按照字典序排序。 


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

public class StreamSortedExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("banana", "apple", "cherry");
        List<String> sortedWords = words.stream()
               .sorted()
               .collect(Collectors.toList());
        System.out.println(sortedWords); 
    }
}


  • 输出：[apple, banana, cherry]


  1. limit(long maxSize)
  • 功能：用于截断流，使其元素个数不超过指定数量。
  • 示例：从一个整数列表中获取前三个元素。 
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamLimitExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> limitedNumbers = numbers.stream()
               .limit(3)
               .collect(Collectors.toList());
        System.out.println(limitedNumbers); 
    }
}


  • 输出：[1, 2, 3]


  1. skip(long n)
  • 功能：用于跳过流中的前n个元素。
  • 示例：跳过一个整数列表中的前两个元素。 
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamSkipExample {
        public static void main(String[] args) {
            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
            List<Integer> skippedNumbers = numbers.stream()
                   .skip(2)
                   .collect(Collectors.toList());
            System.out.println(skippedNumbers); 
        }
}


  • 输出：[3, 4, 5]