jdk1.8的stream学习之二

map()和flatmap()函数

map和flatmap函数入参都是一个Function函数。从函数上看二者不同在于，map函数是普通的表达式运算，而flatmap则是一个必须将表达式统一包装到一个流的表达式。
map函数式对流中的每一个元素进行遍历然后进行运算，返回一个新的流对象。这里需要注意，foreach也是遍历运算，区别在于foreach在于纯消费，没有返回值。而map是运算后将结果返回给新的流。

    List<String> strings = Lists.newArrayList("hello", "world","apple");
    List<String> collect = strings.stream().map(s -> s += ":").collect(Collectors.toList());
    System.out.println(strings);
    System.out.println(collect);
    输出入下：说明不影响原来的对象状态
    [hello, world, apple]
    [hello:, world:, apple:]

flatmap是一个处理更高纬度的操作。map函数只能处理一层纬度，返回的也是一层纬度。而flatmap可以处理多层纬度，然后返回一维。
比如我们需要将一个二维list转换为1纬list。那么用flatmap通过一个很简单的函数就可以直接转换。

    List<List<String>> listList = Lists.newArrayList();
    listList.add(Lists.newArrayList("apple", "mi","huawei"));
    listList.add(Lists.newArrayList("dell", "lenvo","isony"));
    listList.add(Lists.newArrayList("tmall", "jd","qq"));
    List<Object> collect = listList.stream().flatMap(s -> s.stream()).collect(Collectors.toList());
    System.out.println(JSONObject.toJSONString(collect));
    输出结果如下：
    ["apple","mi","huawei","dell","lenvo","isony","tmall","jd","qq"]

还是以上面的例子，那么如果我想继续拆成单个字母的数组呢？可以通过继续再进行一次flatmap运算即可。也就是flatmap的功能主要是将一个维度减少一层。

    List<Object> collect = listList.stream().
            flatMap(s -> s.stream()).
            flatMap(b -> Stream.of(b.split("|"))).
            distinct().
            collect(Collectors.toList());
    System.out.println(JSONObject.toJSONString(collect));
    输出结果如下：
    ["a","p","l","e","m","i","h","u","w","d","n","v","o","s","y","t","j","q"]

flatmapToDouble、int、long 是将对象直接映射成对于的类型：

比如一系列特定分割符的字符串，(实际应用场景中，我们有一种场景是给用户设置限额，限额分为不同等级。和对应系统约定好限额配置规则，则只需要一行代码就可以解释完成。)

    List<String> strings = Lists.newArrayList("123/456","789/123","456/789");
    double[] doubles = strings.stream().
            flatMapToDouble(s -> Stream.of(s.split("/")).mapToDouble(e -> Double.valueOf(e))).
            toArray();
    System.out.println(JSONObject.toJSONString(doubles));
    输出结果如下：
    [123.0,456.0,789.0,123.0,456.0,789.0]

max方法和min方法获取流中最大值最小值,这里可以传入自定义实现的Comparator实现类进行自定义排序。

     List<Integer> Integers = Lists.newArrayList(1,4,99,5,55,23);
    Optional<Integer> max = Integers.stream().max((a,b) -> a.compareTo(b));
    Optional<Integer> min = Integers.stream().min((a,b) -> a.compareTo(b));
    System.out.println(JSONObject.toJSONString(max.get()));
    System.out.println(JSONObject.toJSONString(min.get()));

noneMatch 判断是否都不匹配。如果是，则返回true，如果不是则返回false

如下场景判断list中是否有偶数，很显然没有，返回true。

     List<Integer> Integers = Lists.newArrayList(1,3,5,7);
    boolean b = Integers.stream().noneMatch(a -> a % 2 == 0);
    System.out.println(b);

peek 对流中元素做处理，不返回。对应和map区别，map会将处理返回，peek处理后不返回。

    List<Integer> collect = Stream.of(1, 3, 5, 6, 7).peek(a -> a = a + 1).collect(Collectors.toList());
    System.out.println(JSONObject.toJSONString(collect));
    输出结果如下：
    [1,3,5,6,7]

skip函数，入参是一个long基本类型，效果是忽略流中指定个元素。如果超过流的长度，则会返回流

    List<Integer> collect = Stream.of(1, 3, 5, 6, 7).skip(7).collect(Collectors.toList());
    System.out.println(JSONObject.toJSONString(collect));
    输出结果如下：会把流中前7个元素全部忽略掉，所以输出一个空的数组
    []
    List<Integer> collect = Stream.of(1, 3, 5, 6, 7).skip(2).collect(Collectors.toList());
    System.out.println(JSONObject.toJSONString(collect));
    输出结果如下: 会把前2个元素给忽略掉，然后返回后面的元素。
    [5,6,7]

sorted，对流中元素进行排序。不指定排序方式，按照默认的方式排序。可以自定义排序方式

    List<Integer> collect = Stream.of(99, 5, 47, 34, 2).sorted().collect(Collectors.toList());
    System.out.println(JSONObject.toJSONString(collect));
    输出结果如下: 
    [2,5,34,47,99]

toArray 将流转换成数组，

    Object[] objects = Stream.of(99, 5, 47, 34, 2).toArray();
    System.out.println(JSONObject.toJSONString(objects));
    输出结果如下：
     [99,5,47,34,2]