java8新特性之Stream

Stream 不能被重用，一旦它被使用或使用，流将被关闭

一、创建流的方式

1、通过Collection接口方法：default Stream<E> stream()

　　　　Stream<String> stream = list.stream();

2、通过Stream接口

　　2.1  public static<T> Stream<T> of(T... values)    产生一个元素为给定值的流

String[] split = dbsetting.split("\PL+");
Stream<String> split1 = Stream.of(split);

　　2.2 public static<T> Stream<T> generate(Supplier<T> s)    产生一个无限流，它的值是通过反复调用函数s而构建的。

Stream.generate(Math::random).forEach(x-> System.out.println(x));

　　2.3  public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)      产生一个无限流，它的元素包含种子，在种子上调用f产生的值，在前一个元素上调用f产生的值

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

3、通过Arrays类的方法：public static <T> Stream<T> stream(T[] array)

String[] split = dbsetting.split("\PL+");
Arrays.stream(split).forEach(x-> System.out.println(x));

4、通过Files类的方法 : public static Stream<String> lines(Path path, Charset cs) 

Stream<String> lines1 = Files.lines(Paths.get("D://dbsetting.txt"),Charset.forName("GBK"));
ines1.forEach(x-> System.out.println(x));

二、流转换产生新的流

1、Stream<T> filter(Predicate<? super T> predicate);    原元素与某种条件匹配 产生新元素

 String[] split = dbsetting.split("\PL+");
 Stream<String> stringStream = Arrays.stream(split).filter(x -> x.length() > 0);

2、public static <T> Stream<T> stream(T[] array)    按某种方式转换原元素的值来产生新元素

String[] split = dbsetting.split("\PL+");
Arrays.stream(split).map(String::toUpperCase).forEach(x-> System.out.println(x));

3、Stream<T> limit(long maxSize);       limit方法返回一个新流，第n个元素结束 

　  Stream<T> skip(long n);       丢弃前n个元素

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

4、public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)          流拼接

String[] array = {"a", "b", "c"};
String[] array2 = {"d", "e"};
Stream.concat(Arrays.stream(array), Stream.of(array2)).forEach(x-> System.out.println(x));

5、Stream<T> distinct();       剔除重复元素

Stream.of("aa","nn","cc","dd","aa","bb").distinct().forEach(x-> System.out.println(x));

6、Stream<T> sorted();   排序

Stream.of("aa","nnn","c","dd","aaaa","bb").sorted().forEach(x-> System.out.println(x));
        Stream.of("aa","nnn","c","dd","aaaa","bb").sorted(Comparator.comparing(String::length)).forEach(x-> System.out.println(x));

7、Stream<T> peek(Consumer<? super T> action);     每次获取元素时都会调用一个函数

Object[] names =  Stream.of("aa", "bb", "cc").peek(x -> System.out.println("获取元素：" + x)).limit(2).toArray();

三、简单简约

        boolean anyMatch = Stream.of("aa", "bb", "cc", "a").anyMatch(x -> x.length() < 1);
        boolean allMatch = Stream.of("aa", "bb", "cc", "a").allMatch(x -> x.length() > 1);
        boolean noneMatch = Stream.of("aa", "bb", "cc", "a").noneMatch(x -> x.length() > 2);
        System.out.println(anyMatch);
        System.out.println(allMatch);
        System.out.println(noneMatch);
        Optional<String> max = Stream.of("aa", "bb", "cc", "a","aad").max(Comparator.comparing(String::length));
        System.out.println("max:"+max.get());
        Optional<String> min = Stream.of("aa", "bb", "cc", "a","aad").min(Comparator.comparing(String::length));
        System.out.println("min:"+min.get());
        Optional<String> any = Stream.of("aa", "bb", "cc", "a", "aad").findAny();
        Optional<String> first = Stream.of("aa", "bb", "cc", "a", "aad").findFirst();
        System.out.println("any:" + any.get());
        System.out.println("first:" + first.get());  

　

四、收集结果

        Object[] objects = Stream.of("aa", "bb", "cc", "a").toArray();
        List<String> collect = Stream.of("aa", "bb", "cc", "a").collect(Collectors.toList());
        Set<String> collect1 = Stream.of("aa", "bb", "cc", "a").collect(Collectors.toSet());
        TreeSet<String> collect2 = Stream.of("aa", "bb", "cc", "aa").collect(Collectors.toCollection(TreeSet::new));
        String collect3 = Stream.of("aa", "bb", "cc", "a").collect(Collectors.joining("---"));

        Employee wxh = new Employee("wxh", 5345.2);
        Employee www = new Employee("www", 1345.2);
        Employee aaa = new Employee("aaa2", 2345.2);
        Employee aaa2 = new Employee("aaa1", 2345.2);
        List<Employee> employees = Stream.of(wxh, www, aaa, aaa2).collect(Collectors.toList());
        Map<String, Double> employeesSalary = employees.stream().collect(Collectors.toMap(Employee::getName, Employee::getSalary));
        Map<String, Employee> collect4 = employees.stream().collect(Collectors.toMap(Employee::getName, e -> e, (o, n) -> n));
        TreeMap<String, Employee> collect5 = employees.stream().collect(Collectors.toMap(x->x.getName(), e -> e, (o, n) -> n, TreeMap::new));  

　　

五、分组

        Locale[] availableLocales = Locale.getAvailableLocales();
        //groupingBy   根据国家分组
        Map<String, List<Locale>> collect1 =     Arrays.stream(availableLocales).collect(groupingBy(Locale::getCountry));
        //groupingBy  toset  根据国家分组，分组用set类型
        Map<String, Set<Locale>> collect = Arrays.stream(availableLocales).collect(Collectors.groupingBy(Locale::getCountry, toSet()));
        //counting()  对分组后的元素计数
        Map<String, Long> collect2 = Arrays.stream(availableLocales).collect(groupingBy(Locale::getCountry, counting()));
        Employee wxh = new Employee("wxh", 1111,"salary");
        Employee www = new Employee("www", 2222,"salary");
        Employee aaa = new Employee("aaa", 3333,"salary");
        Employee aaa2 = new Employee("aaa", 2222,"bonus");
        Employee www2 = new Employee("www", 5555,"bonus");
        //summingDouble   对分组后的元素进行计算然后返回计算结果
        Map<String, Double> collect3 = Stream.of(wxh, www, aaa, aaa2, www2).collect(groupingBy(Employee::getName, summingDouble(Employee::getSalary)));
        //maxBy   对分组后的元素计算最大值，返回最大值对应的元素
        Map<String, Optional<Employee>> collect4 = Stream.of(wxh, www, aaa, aaa2, www2).collect(
                groupingBy(Employee::getName, maxBy(Comparator.comparing(Employee::getSalary))));
        //mapping   
        Map<String, Optional<String>> collect5 = Stream.of(wxh, www, aaa, aaa2, www2).collect(groupingBy(Employee::getName,
                mapping(Employee::getSalaryclass, maxBy(Comparator.comparing(String::length,Comparator.reverseOrder())))));
        Map<String, Set<Double>> collect6 = Stream.of(wxh, www, aaa, aaa2, www2).collect(groupingBy(Employee::getName, mapping(Employee::getSalary, toSet())));
        Map<String, String> collect7 = Stream.of(wxh, www, aaa, aaa2, www2).collect(groupingBy(Employee::getName, mapping(Employee::getSalaryclass, joining(","))));