Java SE 8 流库（四）

1.8. 收集数据

<R,A> R collect(Collector<? super T,A,R> collector)   使用给定的收集器来收集当前流中的元素

void forEach(Consumer<? super T> action)          对此流的每个元素执行操作

void forEachOrdered(Consumer<? super T> action)   为流的每个元素执行操作，如果流具有已定义的遇到顺序，则按流的遇到顺序执行操作

Object[] toArray()                              返回包含此流的元素的数组

Stream.toArray(),会返回一个Object[]数组,如果想要数组具有正确的类型，可以将其传递到数组构造器中；

static <T> Stream<T> iterate(T seed,UnaryOperator<T> f)   返回一个由函数f迭代应用到初始元素种子产生的无限顺序排序流，产生由种子，f（种子），f（f（种子））等组成的流。Stream中的第一个元素（位置0）将是提供的种子。 对于n> 0，位置n处的元素将是对位置n-1处的元素应用函数f的结果

Iterator<T> iterator()                     返回此流的元素的迭代器

public static <T> Collector<T,?,List<T>> toList()

public static <T> Collector<T,?,Set<T>> toSet()     将产生的元素收集到列表或集合中的收集器；

public static <T,C extends Collection<T>> Collector<T,?,C> toCollection(Supplier<C> collectionFactory)

产生一个将元素收集到集合中的收集器，可以传递一个诸如TreeSet :: new的构造器引用；

public static Collector<CharSequence,?,String> joining()

public static Collector<CharSequence,?,String> joining(CharSequence delimiter)

public static Collector<CharSequence,?,String> joining(CharSequence delimiter,CharSequence prefix,CharSequence suffix)(前缀和后缀)

产生一个连接字符串的收集器，分隔符会置于字符串之间，而第一个字符串之前可以有前缀和最后一个字符串可以有后缀，如果没有指定，那么它们都为空；

public static <T> Collector<T,?,IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)

public static <T> Collector<T,?,LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)

public static <T> Collector<T,?,DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)

产生能够生成(int|long|double) SummaryStatistics对象收集器，通过它可以获得将Mapper应用于每个元素后产生的结果的个数，总和，平均值，最大值，和最小值

public class IntSummaryStatistics extends Object implements IntConsumer 对象中的方法:

public final int getMax()

public final double getAverage()

public final int getMax()

public final int getMin()

public final long getSum()

package com.itheima05.Test_JavaSE.Test_20180101;

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Created by Lenovo on 2018/1/1.
 */
public class Demo01 {

    private static final String filePath = "G:\\Idea\\src\\com\\itheima05\\Test_JavaSE\\Test_20180101\\word.txt";


    public static void main(String[] args) throws Exception{

        //实例1(iterate)
        Iterator<Integer> it = Stream.iterate(0, n -> n + 1)
                .limit(10).iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

        Object[] numbers = Stream.iterate(0, n -> n + 1)
                .limit(10)
                .toArray();
        //得到一个数组
        System.out.println("numbers:"+numbers);

        //获取数组中的第一个元素
        int number = (int)numbers[0];
        System.out.println("number:"+ number);

        //强转为int数组(会有转化异常出现)
        try {
            Integer[] intNum = (Integer[]) numbers;
            System.out.println("Integer[]:"+intNum);
        } catch (Exception e) {
            System.out.println(e);
        }

        //将数组的正确类型传递到数组的构造器中
        Integer[] arrayNums = Stream.iterate(0, n -> n + 1)
                .limit(10).toArray(Integer[]::new);
        System.out.println("arrayNums:" + arrayNums);

        //转化为set集合
        Set<String> noVowelsSet = noVowels().collect(Collectors.toSet());
        show("noVowelsSet",noVowelsSet);

        //TreeSet
        TreeSet<String> noVowelsTreeSet = noVowels().collect(Collectors.toCollection(TreeSet::new));
        show("noVowelsTreeSet",noVowelsTreeSet);

        //joining
        String noVowelsJoining = noVowels().limit(10).collect(Collectors.joining());
        System.out.println("noVowelsJoining:"+noVowelsJoining);

        //joining(",")
        String noVowelsJoining2 = noVowels().limit(10).collect(Collectors.joining(","));
        System.out.println("noVowelsJoining2:"+noVowelsJoining2);

        //summarizingInt
        IntSummaryStatistics summary = noVowels().collect(Collectors.summarizingInt(String::length));
        double average = summary.getAverage();
        int max = summary.getMax();
        long count = summary.getCount();
        System.out.println("average:"+average);
        System.out.println("max:"+max);
        System.out.println("count:"+count);

        //forEach
        System.out.println("forEach:");
        noVowels().limit(10).forEach(System.out::println);
    }
    public static Stream<String> noVowels() throws Exception{

        String contens = new String(Files.readAllBytes(Paths.get(filePath)), StandardCharsets.UTF_8);
        List<String> wordList = Arrays.asList(contens.split("\\PL+"));
        Stream<String> words = wordList.stream();
        return words.map(s -> s.replaceAll("[aeiouAEIOU]",""));
    }

    public static <T> void show(String label, Set<T> set) {

        System.out.println(label + ":" + set.getClass().getName());
        System.out.println("{" + set.stream()
                .limit(10)
                .map(Object::toString)
                .collect(Collectors.joining(",")) + "}");
    }
}

 1.9. 收集到映射表中

场景1：

假设我们有一个Stream<Person>，并且想要将其元素收集到一个映射表中，这样后续就可以通过他们的ID来查找人员了；

public static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper,

Function<? super T,? extends U> valueMapper)

该方法有两个函数引元，keyMapper和valueMapper

在通常情况下，值应该是实际元素，因此第二个函数可以使用Function.identity();

场景2：

如果有多个元素具有相同的键，那么就会存在冲突，收集器将会抛出一个IllegalStateException对象。可以通过提过3个函数引元来覆盖这种行为，该函数会针对给定的已有的值和新值来解决冲突并确定键对应的值。这个函数应该返回已有值，新值，或它们的组合；

public static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper,

Function<? super T,? extends U> valueMapper,BinaryOperator<U> mergeFunction)

场景3：

假设我们想要了解给定国家的所有语言，这样我们就需要一个Map<String,Set<String>>;

例如：卢森堡=[德文, 法文]

首先我们为每一种语言都存储一个单例集，无论如何是，只要找到了给定的国家的新语言，我们都会将已有的集和新集做并操作；

public static <T,K,U,M extends Map<K,U>> Collector<T,?,M> toMap(Function<? super T,? extends K> keyMapper,Function<? super T,? extends U> valueMapper,BinaryOperator<U> mergeFunction,

Supplier<M> mapSupplier)

实例1：

Person类：

public class Person {

    private int id;
    private String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

CollectingIntoMaps类：

public class CollectingIntoMaps {


    public static void main(String[] args) {

        //通过id查找Name
        Map<Integer, String> idToName = person().
                collect(Collectors.toMap(Person::getId, Person::getName));
        System.out.println("idToName:"+idToName);
        //输出
        //idToName:{1001=xiaoming, 1002=xiaohei, 1003=xiaobao}

        //通过id查找Name(第二种方法)
        Map<Integer, Person> idToName2 = person().
                collect(Collectors.toMap(Person::getId, Function.identity()));
        System.out.println("idToName2:"+idToName2);
        //输出2
        //idToName2:{1001=Person{id=1001, name='xiaoming'},
        //1002=Person{id=1002, name='xiaohei'},
        //1003=Person{id=1003, name='xiaobao'}}
        Map<Integer, Person> idToName3 = person().
                collect(Collectors.toMap(Person::getId, Function.identity(),
                        (existingValue,newValue) ->
                        {throw new IllegalStateException();},TreeMap::new));
        //默认情况下，当两个元素产生相同的键时,会抛出IllegalStateException异常
        System.out.println("idToName3:"+idToName3.getClass().getName()+idToName3);
    }

    public static Stream<Person> person(){

        return Stream.of(new Person(1001,"xiaoming"),
                new Person(1002,"xiaohei"),new Person(1003,"xiaobao"));
    }

}

实例2：

public class Demo02 {

    public static void main(String[] args) {

        Stream<Locale> locales = Stream.of(Locale.getAvailableLocales());
        Map<String, String> languageNames = locales.collect(Collectors.toMap(Locale::getDisplayLanguage,
                l -> l.getDisplayLanguage(l),
                (existingValue, newValue) -> existingValue));
        System.out.println("languageNames:"+languageNames);

        //
        locales = Stream.of(Locale.getAvailableLocales());
        Map<String, Set<String>> countryLanguageSets = locales.collect(Collectors.toMap(Locale::getDisplayCountry,
                l -> Collections.singleton(l.getDisplayLanguage()),
                (a, b) -> {
                    Set<String> union = new HashSet<>(a);
                    union.addAll(b);
                    return union;
                }));
        System.out.println("countryLanguageSets:"+countryLanguageSets);
    }
}

1.10. 群组和分区

public static <T,K> Collector<T,?,Map<K,List<T>>> groupingBy(Function<? super T,? extends K> classifier)

public static <T,K> Collector<T,?,ConcurrentMap<K,List<T>>> groupingByConcurrent(Function<? super T,? extends K> classifier)

产生一个收集器，它会产生一个映射表或并发映射表，其键是将classifier应用于所有收集到的元素上所产生的的结果，而值是有具有相同键的元素构成的一个个列表；

public static <T> Collector<T,?,Map<Boolean,List<T>>> partitioningBy(Predicate<? super T> predicate)

产生一个收集器，它会产生一个映射表，其键是true/false，而值是有满足/不满足断言的元素构成的列表；

实例：

**
 * Created by Lenovo on 2018/1/3.
 * public static Locale[] getAvailableLocales()
 * public String getCountry()
 */
public class Demo03 {

    public static void main(String[] args) {

        //集组
        Stream<Locale> locales = Stream.of(Locale.getAvailableLocales());
        Map<String, List<Locale>> countryToLocale = locales.
                collect(Collectors.groupingBy(Locale::getCountry));
        List<Locale> localeList = countryToLocale.get("CH");
        System.out.println(localeList);

        //分区
        locales = Stream.of(Locale.getAvailableLocales());
        Map<Boolean, List<Locale>> languageToLocale = locales.
                collect(Collectors.partitioningBy(l -> l.getLanguage().equals("en")));
        System.out.println(languageToLocale.get(true));
    }
}

当分类函数是断言函数(返回boolean值的函数)时，流的元素可以使用分区为两个列表：该函数返回true的元素和其他元素，这种情况下，使用partitioningBy比使用groupingBy更高效；