随笔6

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+
转换成代码:
List<Integer> transactionsIds = 
widgets.stream()
             .filter(b -> b.getColor() == RED)
             .sorted((x,y) -> x.getWeight() - y.getWeight())
             .mapToInt(Widget::getWeight)
             .sum();

package com.lk.menu.stream;

import java.io.*;
import java.util.*;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @Author: Lukizzz
 * @Date: 2018/8/17 10:37
 * @Description:   流的操作
 */

public class StreamServiceTest {

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

        //1.流的map操作,大小写转换
        List<String> wordList = new ArrayList<>();
        wordList.add("apple");
        wordList.add("pear");
        List<String> output = wordList.stream().map(String::toUpperCase).collect(Collectors.toList());
                                                                       //.collect(Collectors.toCollection(LinkedList::new
        System.out.println(output);



        //2.流的map操作,平方数
        List<Integer> nums = Arrays.asList(1,2,3,4);
        List<Integer> aquareNums = nums.stream().map(n -> n * n).collect(Collectors.toList());
        System.out.println(aquareNums);



        //3.IntStream构造流
         IntStream.of(5,6,7,8).map(n -> n * n).forEach(System.out::println);



         //4.流的flatMap操作,把多个list的元素放在一个新的stream里
        Stream<List<Integer>> inputStream = Stream.of(
                Arrays.asList(1),
                Arrays.asList(2, 3),
                Arrays.asList(4, 5, 6)
        );
        Stream<Integer> outputStream = inputStream.flatMap((childList) -> childList.stream());
        //以数组的形式输出
        outputStream.forEach(System.out::println);
        //以列表方式输出
        //System.out.println( outputStream.collect(Collectors.toList()));



        //5.流的filter操作,先进行平方数再留下偶数(筛选)
        List<Integer> nums1 = Arrays.asList(1,2,3,4);
        List<Integer> aquareNums1 = nums1.stream().map(n -> n * n).filter( n -> n%2==0).collect(Collectors.toList());
        System.out.println(aquareNums1);




        //6.peek不同于forEach直接结束,他可以多次使用,因为它对每个元素操作并返回一个新的stream
        //因为惰性的关系,所有操作是在最后一步一起执行的
        Stream.of("one","two","three","four").filter(e -> e.length()>3).peek(e -> System.out.println("Filtered value: " + e))
                                                                       .map(String::toUpperCase)
                                                                       .peek(e -> System.out.println("Mapped value: " + e))
                                                                       .collect(Collectors.toList());




        //7.进行Short-circuiting的操作如findFirst、 findAny时返回的类型需要放在optional容器中
        //多条件筛选是可行的
        List<Integer> nums2 = Arrays.asList(1,2,3,4);
        Optional<Integer> aquareNums2 = nums2.stream().map(n -> n * n).filter(n -> n%2==0 && n>5 ).findFirst();
        System.out.println(aquareNums2);



        //8.reduce()方法的几个demo
        //字符串拼接
        String concat = Stream.of("A","B","C","D").reduce("",String::concat);
        System.out.println(concat);
        //求最小值
        double minValue = Stream.of(-5.0,-2.0,3.0,5.0,10.0).reduce(Double.MAX_VALUE,Double::min);
        System.out.println(minValue);
        //求最大值
        double maxValue = Stream.of(-5.0,-2.0,3.0,5.0,10.0).reduce(Double.MIN_VALUE,Double::max);
        System.out.println(maxValue);
        //求和,有初始值(初始值:算上这个值)
        int sumValue = Stream.of(5,6,7,8,9).reduce(0,Integer::sum);
        System.out.println(sumValue);
        //求和,无初始值,返回的是optional
        Optional<Integer> sumValue1 = Stream.of(5,6,7,8,9).reduce(Integer::sum);
        System.out.println(sumValue1);
        //过滤掉大写字母+字符串连接
        concat = Stream.of("a", "B", "c", "D", "e", "F").
                filter(x -> x.compareTo("Z") > 0).
                reduce("", String::concat);
        System.out.println(concat);




       /*9.文件中最长的一行的长度 distinct():去重复 sorted():排序
         根据属性排序  Stream<T> sorted(Comparator<? super T> comparator);
        对对象的进行操作Stream<T> peek(Consumer<? super T> action);
        截断--取先maxSize个对象 Stream<T> limit(long maxSize);
        截断--忽略前N个对象 Stream<T> skip(long n);
        */
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\xxxx.txt"),"gb2312"));
        int longest = br.lines().mapToInt(String::length).max().getAsInt();br.close();
        System.out.println(longest);




        //10.文件中最长的一行的单词(注意io流读取文件的时候要规定编码格式,不然会乱码)
        BufferedReader br1 = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\xxxx.txt"),"gb2312"));
        List<String> words = br1.lines().flatMap(line -> Stream.of(line.split(""))).filter(word -> word.length() > 0).
                map(String::toLowerCase).distinct().sorted().collect(Collectors.toList());br1.close();
        System.out.println(words);

       /* allMatch：Stream 中全部元素符合传入的 predicate，返回 true
        anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
        noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true*/


       //11.随机生成10个整数,筛选出其中的正整数
        Random rand = new Random();
        Supplier<Integer> supplier = rand::nextInt;
        Stream.generate(supplier).limit(10).filter(n ->n>0).forEach(System.out::println);

        //12.随机生成10个(10-100)之间的整数
        Random random = new Random();
        IntStream intStream = random.ints(10,100);
        intStream.limit(10).forEach(System.out::println);
    }
}

//按照uid分组并计算获得星星数的平均值 
Map<Integer,Double> map = dataSearch.stream().collect(Collectors.groupingBy(AppraiseRecord::getAnchorUid,Collectors.averagingDouble(AppraiseRecord::getStarNum)));

        Map<Integer,Object> finalMap = new LinkedHashMap<>();
        //将map按value值倒序排序并将结果add给finalMap
        map.entrySet().stream()
                .sorted(Map.Entry.<Integer,Double>comparingByValue()
                        .reversed()).forEachOrdered(e -> finalMap.put(e.getKey(), e.getValue()));
//遍历finalMap并将数据添加进dataList
        for (Map.Entry<Integer,Object> entry:finalMap.entrySet()){
            Map<Integer,Object> data = new HashMap<Integer, Object>();
            data.put(1,entry.getKey());
            BigDecimal bg = new BigDecimal((Double) entry.getValue());
            double f1 = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            data.put(2,f1);
            dataList.add(data);
        }