Java Stream

什么是 Stream

Java 中的 Stream 是一种新的抽象数据类型，它允许程序员以声明式的方式处理数据，而不需要编写繁琐的循环代码。Stream 可以支持顺序或并行的处理操作，并支持高效的内存消耗。

Stream 可以从一个数据源（如集合，数组，文件等）中获取数据，然后对数据进行各种处理，最后将处理结果输出到控制台或文件中。Stream 提供了一系列非常有用的操作，如 map，filter，reduce，collect 等，可以极大地提高编程效率。

Stream 常用函数

• filter 根据条件过滤数据
• map 将一个流中的值转换成另一个流
• limit 获取指定数量的数据
• sorted 对流中的元素进行排序
• distinct 根据流中元素的hashCode和equals去重
• forEach 遍历流中的每一个数据
• collect 将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
• min/max 获取流中的最大/最小值
• count 获取流中元素的个数
• anyMatch 是否存在满足条件的元素
• allMatch 流中元素是否都满足条件
• noneMatch 流中元素是否都不满足条件

filter

import java.util.*;
import java.util.stream.Collectors;

/**
 * 对一组存放了数字的List集合进行了过滤处理
 */
public class FilterTest {

    private static List<Integer> numberList = new ArrayList();

    static {
        numberList.add(1);
        numberList.add(9);
        numberList.add(3);
    }

    public static void filterTest() {
        List<Integer> resultList = numberList.stream().filter(x -> x > 2).collect(Collectors.toList());
        System.out.println(resultList);
    }
 
 
    public static void main(String[] args) {
        filterTest();
    }
 }

map

import java.util.*;
import java.util.stream.Collectors;

/**
 * 对numberList集合中的元素做了一层包装处理，并对其中的元素做了+1操作
 */
public class MapTest {

    private static List<Integer> numberList = new ArrayList();

    static {
        numberList.add(1);
        numberList.add(9);
        numberList.add(3);
    }

    public static void mapDemo() {
        List<Integer> resultList = numberList.stream().map(x -> Integer.valueOf(x) + 1).collect(Collectors.toList());
        System.out.println(resultList);
    }
 
 
    public static void main(String[] args) {
        filterDemo();
    }
 }

limit

import java.util.*;
import java.util.stream.Collectors;

/**
 * 取出了队列中的前3个元素
 */
public class LimitTest {

    private static List<Integer> numberList = new ArrayList();

    static {
        numberList.add(1);
        numberList.add(9);
        numberList.add(3);
    }

    public static void limitDemo() {
        //取出队列中的前n个元素 limit用法
        System.out.println(numberList.stream().limit(3).collect(Collectors.toList()));
    }
 
 
    public static void main(String[] args) {
        limitDemo();
    }
 }

sorted

import java.util.*;
import java.util.stream.Collectors;

/**
 * 使用了升序排序去处理numberList集合，得出的结果是一个以升序排序的结果集。
 */
public class SortedTest {

    private static List<Integer> numberList = new ArrayList();

    static {
        numberList.add(1);
        numberList.add(9);
        numberList.add(3);
    }

    public static void sortedDemo() {
       //默认是升序排序
       System.out.println(numberList.stream().sorted().collect(Collectors.toList()));
    }
 
 
    public static void main(String[] args) {
        sortedDemo();
    }
 }

distinct

import java.util.*;
import java.util.stream.Collectors;

/**
 * 可以实现对numberList集合进行去重操作，得出的结果中只会有一个3
 */
public class DistinctTest {

    private static List<Integer> numberList = new ArrayList();

    static {
        numberList.add(1);
        numberList.add(9);
        numberList.add(3);
        numberList.add(3);
    }

    public static void distinctDemo() {
        //去重
        System.out.println(numberList.stream().distinct().collect(Collectors.toList()));
    }
 
 
    public static void main(String[] args) {
        distinctDemo();
    }
 }

forEach

import java.util.*;
import java.util.stream.Collectors;

/**
 * forEach函数主要是一个遍历的功能，其实和传统的for循环没有太大的区别
 */
public class ForEachTest {

    private static List<Integer> numberList = new ArrayList();

    static {
        numberList.add(1);
        numberList.add(9);
        numberList.add(3);
    }
    
    public static void forEachDemo() {
        numberList.stream().forEach(x -> {
            int j = x + 1;
            System.out.println(j);
        });
    }
 
 
    public static void main(String[] args) {
        forEachDemo();
    }
 }

collect

import java.util.*;
import java.util.stream.Collectors;

/**
 * collect可以将原先以List结构进行存储的数据转换为以Map，Set等多种功能结构的存储方式。
 */
public class CollectTest {

    private static List<Integer> numberList = new ArrayList();

    static {
        numberList.add(1);
        numberList.add(9);
        numberList.add(3);
    }
    
    public static void collectDemo() {
        Map<Integer, Integer> resultMap = numberList.stream().collect(Collectors.toMap(Integer::intValue, x -> x));
        System.out.println(resultMap);
        Map<Integer, List<Integer>> listTypeMap = numberList.stream().collect(Collectors.groupingBy(x -> x.intValue()));
        System.out.println(listTypeMap);
        Set<Integer> resultSet = numberList.stream().collect(Collectors.toSet());
        System.out.println(resultSet);
    }
     
 
    public static void main(String[] args) {
        collectDemo();
    }
 }

min/max

import java.util.*;
import java.util.stream.Collectors;

/**
 * max/min可以实现对numberList集合的统计功能，分别实现了对numberList集合中的最大值和最小值的计算效果
 */
public class MinMaxTest {

    private static List<Integer> numberList = new ArrayList();

    static {
        numberList.add(1);
        numberList.add(9);
        numberList.add(3);
    }
    
    public static void minMaxTest() {
        System.out.println(numberList.stream().max(Integer::compareTo).get());
        System.out.println(numberList.stream().min(Integer::compareTo).get());
    }
     
 
    public static void main(String[] args) {
        minMaxTest();
    }
 }

count

import java.util.*;
import java.util.stream.Collectors;

/**
 * count函数从字面意思上就很好理解其具体意思了，主要是用于统计集合的总个数。
 */
public class CountTest {

    private static List<Integer> numberList = new ArrayList();

    static {
        numberList.add(1);
        numberList.add(9);
        numberList.add(3);
    }
    
    public static void countDemo() {
        System.out.println(numberList.stream().count());
    }    
     
 
    public static void main(String[] args) {
        countDemo();
    }
 }

match

import java.util.*;
import java.util.stream.Collectors;

/**
 * 介绍了anyMatch / allMatch / noneMatch 这三个函数的用法
 */
public class MatchTest {

    private static List<Integer> numberList = new ArrayList();

    static {
        numberList.add(1);
        numberList.add(9);
        numberList.add(3);
    }
    
    public static void matchDemo() {
        System.out.println(numberList.stream().anyMatch(x -> x > 100));
        System.out.println(numberList.stream().allMatch(x -> x > 100));
        System.out.println(numberList.stream().noneMatch(x -> x > 100));
    }
 
    public static void main(String[] args) {
        matchDemo();
    }
 }

练习

以下代码，如何可以获取testNumberList中最大的两位数字呢？

public static void main(String[] args) {
    List<Integer> testNumberList = new ArrayList<>();
    testNumberList.add(1);
    testNumberList.add(22);
    testNumberList.add(11);
    testNumberList.add(4);
    testNumberList.add(123);
    //如何获取最大的两位数字
}

参考：

public static void main(String[] args) {
    List<Integer> testNumberList = new ArrayList<>();
    testNumberList.add(1);
    testNumberList.add(22);
    testNumberList.add(11);
    testNumberList.add(4);
    testNumberList.add(123);
    //如何获取最大的两位数字
    System.out.println(testNumberList.stream().sorted((x1,x2)-> x2-x1).limit(2).collect(Collectors.toList()));
}