优雅地操作 List、Map

悠悠 2023-07-16 15:55 15阅读 0赞

集合是 Java 中使用最多的 API，但在 Java 中集合操作却不像 SQL 语句那样简洁明了；想要用并行架构处理大量集合元素，也很困难。

为了解决这个问题，Java 8 API 中添加了新的成员 - 流(Stream)。

它允许以声明性方式（即通过类似查询语句来表达，而不是编写一个实现类）处理数据集合；还可以不写任何多线程代码进行透明地并行处理。

流的作用：从支持数据处理操作的源，生成的元素序列。

特点：

*  流水线：很多流操作本身会返回一个流，这样多个操作就可以链接起来，形成一个大的流水线。
 *  内部迭代：与使用迭代器显式迭代的集合不同，流的迭代操作是在背后进行的。
 *  和迭代器类似，流只能遍历一次

## **Stream 接口的使用** ##

Java 8 中的 java.util.Collection 接口，支持 2 个新方法：stream()、parallelStream()，返回一个流(接口定义在 java.util.stream.Stream 里)。

流的使用包括 3 个元素：

*  数据源，如集合
 *  中间操作链，形成一条流的流水线
 *  终端操作，执行流水线，并能生成结果

中间操作：返回另一个流，除非流水线上触发一个终端操作，否则中间操作不会执行任何处理，中间操作一般都可以合并起来，在终端操作时一次性全部处理

操作       返回类型      操作参数                   函数描述符        作用
    filter    Stream<T>    Predicate<T>              T -> boolean    过滤元素
    map       Stream<T>    Function<T, R>            T -> R          映射，将元素转换成其他形式或提取信息
    flatMap   Stream<T>    Function<T, Stream<R>>    T -> Stream<R>  扁平化流映射
    limit     Stream<T>    long                                      截断流，使其元素不超过给定数量
    skip      Stream<T>    long                                      跳过指定数量的元素
    sorted    Stream<T>    Comparator<T>             (T, T) -> int   排序
    distinct  Stream<T>                                              去重

终端操作：从流的流水线生成结果

操作        返回类型      操作参数                   函数描述符        作用
    anyMatch   boolean      Predicate<T>              T -> boolean    检查流中是否有一个元素能匹配给定的谓词
    allMatch   boolean      Predicate<T>              T -> boolean    检查谓词是否匹配所有元素
    noneMatch  boolean      Predicate<T>              T -> boolean    检查是否没有任何元素与给定的谓词匹配
    findAny    Optional<T>                                            返回当前流中的任意元素（用于并行的场景）
    findFirst  Optional<T>                                            查找第一个元素
    collect    R            Collector<T, A, R>                        把流转换成其他形式，如集合 List、Map、Integer
    forEach    void         Consumer<T>               T -> void       消费流中的每个元素并对其应用 Lambda，返回 void
    reduce     Optional<T>  BinaryOperator<T>         (T, T) -> T     归约，如：求和、最大值、最小值
    count      long                                                   返回流中元素的个数

## **构建流的方式** ##

**由值创建流**

Stream<String> stream = Stream.of("a", "b", "c", "d");

**由数组创建流**

int[] numbers = {2, 3, 5, 7, 11, 13};
    int sum = Arrays.stream(numbers).sum();

**由文件生成流**

long uniqueWords = 0;
    Stream<String> lines = Files.lines(Paths.get("a.txt"), Charset.defaultCharset())){
    								uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" ")))
    								.distinct()
    								.count();

**由函数生成流，创建无限流**

Stream.iterate(0, n -> n + 2).limit(10).forEach(System.out::println);

Stream.generate(Math::random).limit(5).forEach(System.out::println);

**为了避免了暗含的装箱成本，Java 8 还是推出了IntStream、DoubleStream和 LongStream，分别将流中的元素特化为int、long和double，将原始类型流特化。**

映射到数值流

double weight = list.stream()
                        .mapToDouble(Fruit::getWeight)
                    	.sum();

转换回对象流

DoubleStream doubleStream = list.stream().mapToDouble(Fruit::getWeight);
    Streaing<Double> stream = doubleStream.boxed();

数值范围流，产生 1-100 之间的偶数

IntStream evenNumbers = IntStream.rangeClosed(1, 100)
                                        .filter(n -> n % 2 == 0);

## **使用示例** ##

package constxiong.interview;
    
    import static java.util.Comparator.comparing;
    import static java.util.stream.Collectors.groupingBy;
    import static java.util.stream.Collectors.toList;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    import java.util.OptionalDouble;
    import java.util.stream.DoubleStream;
    import java.util.stream.IntStream;
    import java.util.stream.Stream;
    
    /**
     * 测试 Stream 的API
     * @author ConstXiong
     */
    public class TestStreamAPI {
    	
    	public static void main(String[] args) {
    		List<Fruit> list = Arrays.asList(new Fruit("苹果", "红色", 1.1),
    				new Fruit("苹果", "绿色", 1.7),
    				new Fruit("香蕉", "黄色", 0.8),
    				new Fruit("香蕉", "绿色", 1.1),
    				new Fruit("橘子", "橙色", 0.7));
    		
    		//获取颜色为绿色的水果的类别，按照重量排序
    		System.out.println(list.stream()
    				.filter(f -> "绿色".equals(f.getColor()))
    				.sorted(comparing(Fruit::getWeight))
    				.map(Fruit::getType)
    				.collect(toList()));
    		
    		//利用多核架构并行执行这段代码，你只需要把stream()换成parallelStream()
    		//获取颜色为绿色的水果的类别，按照重量排序
    		System.out.println(list.parallelStream()
    				.filter(f -> "绿色".equals(f.getColor()))
    				.sorted(comparing(Fruit::getWeight))
    				.map(Fruit::getType)
    				.collect(toList()));
    		
    		//打印流的执行过程
    		list.parallelStream()
    				.filter(f -> {
    					System.out.println("filter:" + f);
    					return "绿色".equals(f.getColor());
    				})
    				.map(f -> {
    					System.out.println("map:" + f);
    					return f.getType();
    				})
    				.collect(toList());
    		
    		//按重量过滤，排序，取前 2 个水果
    		System.out.println(list.stream()
    				.filter(f -> f.getWeight() > 1)
    				.sorted(comparing(Fruit::getWeight))
    				.limit(2)
    				.collect(toList()));
    		
    		//按水果类型分组
    		Map<String, List<Fruit>> map = list.stream().collect(groupingBy(Fruit::getType));
    		System.out.println(map);
    		
    		//打印水果重量合计
    		double weight = list.stream()
                    			.mapToDouble(Fruit::getWeight)
                    			.sum();
    		System.out.println(weight);
    		
    		//转换回对象流
    		DoubleStream doubleStream = list.stream().mapToDouble(Fruit::getWeight);
    		Stream<Double> stream = doubleStream.boxed(); //包装成Double流
    		
    		//打印水果的最重重量
    		OptionalDouble maxWeight = list.stream()
    			    			.mapToDouble(Fruit::getWeight)
    			    			.max();
    		System.out.println(maxWeight.getAsDouble());
    		
    		//数值范围流，产生 1-100 之间的偶数
    		IntStream evenNumbers = IntStream.rangeClosed(1, 100)
    							.filter(n -> n % 2 == 0);
    		evenNumbers.forEach(System.out::println);
    	}
    }

参考：《Java8实战》

--------------------

### 【Java面试题与答案】整理推荐 ###

*  [基础与语法][Link 1]
 *  [集合][Link 2]
 *  [网络编程][Link 3]
 *  [并发编程][Link 4]
 *  [Web][]
 *  [安全][Link 5]
 *  [设计模式][Link 6]
 *  [框架][Link 7]
 *  [算法与数据结构][Link 8]
 *  [异常][Link 9]
 *  [文件解析与生成][Link 10]
 *  [Linux][]
 *  [MySQL][]
 *  [Oracle][]
 *  [Redis][]
 *  [Dubbo][]

[Link 1]: https://www.javanav.com/interview/93b0069472fd479393006c0e73043fc4.html
[Link 2]: https://www.javanav.com/interview/4147d95e693945e7a50345fd33ec817e.html
[Link 3]: https://www.javanav.com/interview/68a57ffc78de4133bb890bdd502ac418.html
[Link 4]: https://www.javanav.com/interview/36a24fa3258e45c89873f474ce914912.html
[Web]: https://www.javanav.com/interview/4e27cb63adb440c6825a159d35cf4010.html
[Link 5]: https://www.javanav.com/interview/03affb2ce3f04fda8853f714e5764906.html
[Link 6]: https://www.javanav.com/interview/07a32a9ff17a4006a53550ce658cafed.html
[Link 7]: https://www.javanav.com/interview/5c466456e9b54ab0a749b5948e51f1d3.html
[Link 8]: https://www.javanav.com/interview/943f917041ee4f05add24539f5b861b2.html
[Link 9]: https://www.javanav.com/interview/d3f058cfc05d4c6dadd821b622e84d36.html
[Link 10]: https://www.javanav.com/interview/67a50996c28f418e83b109ea42fc3eff.html
[Linux]: https://www.javanav.com/interview/00cccb81729540d1923bd0a0ef49533a.html
[MySQL]: https://www.javanav.com/interview/d311e78502a845f1a4bb307bd6aec2b3.html
[Oracle]: https://www.javanav.com/interview/5f29e9677edf4a16be3dce30d257c9ab.html
[Redis]: https://www.javanav.com/interview/066c62b3af4d4827b2243a822c3084a9.html
[Dubbo]: https://www.javanav.com/interview/9a3e7a7740324757abaab953f7ebc455.html