Java 8 stream 经典示例

 

import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

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

/**
 * Java 8 – Streams
 * url:http://www.studytrails.com/java/java8/java8_streams/
 *
 * @author gongxr
 */
@Slf4j
public class StreamDemo {
    /**
     * 过滤：filter
     * 匹配操作：noneMatch、anyMatch
     */
    @Test
    public void testMatch() {
        List<String> genre = new ArrayList<>(Arrays.asList("rock", "pop", "jazz", "reggae"));
        // a:2
        long a = genre.stream().filter(s -> s.startsWith("r")).count();
        log.info("a:{}", a);

        // 一个都匹配不上；noneMatch:true
        boolean noneMatch = genre.stream().peek(System.out::println).noneMatch(String::isEmpty);
        log.info("noneMatch:{}", noneMatch);

        // anyMatch:true
        boolean anyMatch = genre.stream().anyMatch(s -> s.indexOf("r") == 0);
        log.info("anyMatch:{}", anyMatch);
    }

    /**
     * forEach:如果想对流经的每个元素应用一个函数，从而改变某些状态，那么请用 forEach();最终操作。
     * peek:如果想打印流经的每个元素的状态（日志或 debug），这时应该用 peek()；中间操作。
     */
    @Test
    public void testForEachPeek() {
        List<String> genre = new ArrayList<>(Arrays.asList("rock", "pop", "jazz", "reggae"));
        genre.stream().filter(s -> s.startsWith("r")).forEach(System.out::println);
        log.info("------------");

        genre.stream().filter(s -> s.startsWith("r")).peek(System.out::println).collect(Collectors.toList());
        log.info("------------");

        // 一个都匹配不上；b:true
        boolean b = genre.stream().peek(System.out::println).noneMatch(String::isEmpty);
        log.info("b:{}", b);
        log.info("------------");

        long count = genre.stream().peek(System.out::println).count();
        log.info("count:{}", count);
    }

    /**
     * 数据去重（distinct）
     */
    @Test
    public void listDistinctTest() {
        List<Integer> listNum = new ArrayList<>(Arrays.asList(1, 1, 1, 2, 2, 2, 3, 3));
        log.info("listNum:{}", listNum);
        List<Integer> listNumNew = listNum.stream().distinct().collect(Collectors.toList());
        log.info("listNumNew:{}", listNumNew);
    }

    /**
     * map和flatMap的对比
     * map：分别对单个值进行单独处理
     * flatMap：扁平化操作，将所有数据拉平一次性处理
     */
    @Test
    public void testMap() {
        List<String> list = new ArrayList<>(Arrays.asList("rock", "pop", "jazz", "reggae"));
//        分别对单个值进行单独处理；mapList:[[RO, K], [POP], [JAZZ], [REGGAE]]
        List<List<String>> mapList = list.stream().map(x -> Arrays.stream(x.toUpperCase().split("C")).collect(Collectors.toList())).collect(Collectors.toList());
        log.info("mapList:{}", mapList);

//      将所有数据拉平一次性处理；flatMapList:[RO, K, POP, JAZZ, REGGAE]
        List<String> flatMapList = list.stream().flatMap(x -> Arrays.stream(x.toUpperCase().split("C"))).collect(Collectors.toList());
        log.info("flatMapList:{}", flatMapList);

//      mapToInt、mapToLong、mapToDouble； integers:[1, 2]
        List<Integer> integers = Stream.of("1", "2").mapToInt(Integer::parseInt).boxed().collect(Collectors.toList());
        log.info("integers:{}", integers);
    }

    /**
     * Collectors.toMap
     */
    @Test
    public void testToMap() {
        List<User> list = getUserList();
        Map<String, Integer> map = list.stream().collect(Collectors.toMap(User::getName, User::getAge, (k, v) -> k));
        log.info("Map:{}", map);

        Map<String, User> map2 = list.stream().collect(Collectors.toMap(User::getName, t -> t));
        log.info("Map2:{}", map2);

        Map<String, String> map3 = getUserList().stream().collect(Collectors.toMap(User::getName, User::getGender));
        log.info("map3:{}", map3);
    }

    /**
     * 分组
     * Collectors.groupingBy
     */
    @Test
    public void testGroupingBy() {
        List<User> list = getUserList();
        Map<String, List<User>> collect = list.stream().collect(Collectors.groupingBy(User::getGender));
        log.info("根据性别分组:{}", collect.toString());

        Map<String, Set<String>> collect2 = list.stream().collect(Collectors.groupingBy(User::getGender,
                Collectors.mapping(User::getName, Collectors.toSet())));
        log.info("根据性别对名字进行分组：{}", collect2.toString());
    }

    /**
     * 数据转List
     */
    @Test
    public void testArrayToList() {
        int[] arr = {1, 2, 3, 4, 5};
        List<Integer> list = IntStream.of(arr).boxed().collect(Collectors.toList());
        log.info(list.toString());

        String[] arr2 = {"a", "b", "c"};
        List<String> list2 = Stream.of(arr2).collect(Collectors.toList());
        log.info(list2.toString());
    }

    /**
     * sorted:排序
     */
    @Test
    public void testSorted() {
        int[] arr = {1, 2, 3, 4, 5};
        int[] arrReverse = IntStream.of(arr).boxed().sorted(Comparator.reverseOrder()).mapToInt(Integer::intValue).toArray();
        Arrays.stream(arrReverse).boxed().forEach(x -> log.info(x.toString()));
    }

    /**
     * 统计个数(List to Map)
     */
    @Test
    public void testStat() {
        List<String> list = Arrays.asList("a", "a", "b", "c", "b", "b");
//        toMap(key取值，value取值，key已存在的处理逻辑，实例对象类型)
        LinkedHashMap<String, Integer> map = list.stream().collect(Collectors.toMap(k -> k, k -> 1, Integer::sum, LinkedHashMap::new));
        map.forEach((k, v) -> System.out.println(k + ":" + v));
        System.out.println("-----");
        map = list.stream().collect(Collectors.toMap(k -> k, k -> 1, Integer::sum, LinkedHashMap::new));
        map.forEach((k, v) -> System.out.println(k + ":" + v));
    }

    /**
     * 多个元素合并为一个元素(reduce)
     * reduce：按照特定规则处理每个元素，然后返回处理后的结果
     */
    @Test
    public void testReduce() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        int n = list.stream().reduce(0, Integer::sum);
        log.info("n:【{}】", n);

        List<String> list2 = Arrays.asList("a", "a", "b", "c", "b", "b");
        StringBuffer sb = list2.stream().map(StringBuffer::new).reduce(new StringBuffer(), StringBuffer::append);
        log.info("StringBuffer:【{}】", sb);
    }

    /**
     * 数学运算
     * 最大值，最小值，平均值等数学操作
     */
    @Test
    public void testCompute() {
        int max = IntStream.rangeClosed(10, 20).max().getAsInt();
        int min = IntStream.rangeClosed(10, 20).min().getAsInt();
        double average = IntStream.rangeClosed(10, 20).average().getAsDouble();
        long count = IntStream.rangeClosed(10, 20).count();
        int sum = IntStream.rangeClosed(10, 20).sum();
        log.info("max:{}", max);
        log.info("min:{}", min);
        log.info("aDouble:{}", average);
        log.info("count:{}", count);
        log.info("sum:{}", sum);
    }

    /**
     * IntStream:数字流
     * boxed：用于将流中的元素转换为对应的对象类型
     */
    @Test
    public void testIntStream() {
        // range是左闭右开，还有rangeClose，左闭右闭；integersList:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        List<Integer> integersList = IntStream.range(0, 10).boxed().collect(Collectors.toList());
        log.info("integersList:{}", integersList);

        // 随机生成一个数字列表，integers2:[681, 309, 672]
        List<Integer> integers2 = IntStream.generate(() -> new Random().nextInt(1000)).limit(3).boxed().collect(Collectors.toList());
        log.info("integers2:{}", integers2);

//      迭代函数，生成一个有序无限的Int数据流  integers3:[1, 2, 4]
        List<Integer> integers3 = IntStream.iterate(1, x -> x * 2).limit(3).boxed().collect(Collectors.toList());
        log.info("integers3:{}", integers3);

//        和并流，使用concat方法将连个不同流合并为一个流输出  integers4:[1, 2, 3, 4]
        IntStream intStream = IntStream.of(1, 2);
        IntStream intStream2 = IntStream.builder().add(3).add(4).build();
        List<Integer> integers4 = IntStream.concat(intStream, intStream2).boxed().collect(Collectors.toList());
        log.info("integers4:{}", integers4);
    }

    public List<User> getUserList() {
        User user1 = new User("Mike", 11, "男", "Street #1");
        User user2 = new User("Jill", 22, "女", "Street #2");
        User user3 = new User("Tom", 33, "男", "Street #3");
        User user4 = new User("Lily", 22, "女", "Street #4");
        List<User> list = Lists.newArrayList(user1, user2, user3, user4);
        return list;
    }

}

 

User.Class

package org.study2.java8.stream;


public class User {

    private int id;
    private String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }

}

 

详细讲解参考：

https://www.cnblogs.com/andywithu/p/7404101.html