码迷,mamicode.com
首页 > 编程语言 > 详细

Java8之流Stream使用,附上例子

时间:2020-02-08 13:28:01      阅读:393      评论:0      收藏:0      [点我收藏+]

标签:das   bic   foreach   count()   count   set集合   条件   vat   ping   

package stream;

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

public class steamMain {
    public static void main(String[] args) {
        /**
         * map函数
         * 将流中的每?个元素 T 映射为 R(类似类型转换)
         * 上堂课的例?就是,类似遍历集合,对集合的每个对象做处理
         * 场景:转换对象,如javaweb开发中集合??的DO对象转换为DTO对象
         */
        List<String> list = Arrays.asList("springboot教程", "微服务教程", "并发编程", "压?测试", "架构课程");
        List<String> li = Arrays.asList("asdad", "dfsfs", "erdsd", "zxcsdad", "weqqweqsd");

        List<String> resultlist = list.stream().map(obj -> "我想学习" + obj).collect(Collectors.toList());
        System.out.println(resultlist);

        List<user> list1 = Arrays.asList(new user(12, "123"), new user(23, "234"), new user(24, "345"));
        List<userDTO> resLIst = list1.stream().map(obj -> {
            userDTO user = new userDTO();
            user.setName(obj.getName());
            return user;
        }).collect(Collectors.toList());
        System.out.println(resLIst);

        /**
         * filter 函数
         * ?于通过设置的条件过滤出元素
         * 需求:过滤出字符串?度?于5的字符串
         */
        List<String> list2 = list.stream().filter(obj -> obj.length() > 4).collect(Collectors.toList());
        System.out.println(list2);

        /**
         * sorted 函数
         * sorted() 对流进??然排序, 其中的元素必须实现Comparable 接?
         */
        //默认升序
        //List<String> list4 = li.stream().sorted(Comparator.comparing(String::length)).collect(Collectors.toList());
        //反转 降序
        //List<String> list4 = li.stream().sorted(Comparator.comparing(String::length).reversed()).collect(Collectors.toList());
        List<String> list4 = li.stream().sorted(Comparator.comparing(String::length, Comparator.reverseOrder())).collect(Collectors.toList());
        System.out.println(list4);

        /**
         * limit函数
         * 截断流使其最多只包含指定数量的元素
         */
        List<String> list5 = li.stream().limit(3).collect(Collectors.toList());
        System.out.println(list5);

        /**
         * allMatch函数
         * 检查是否匹配所有元素,只有全部符合才返回true
         */
        boolean status = li.stream().allMatch(obj -> obj.length() > 4);
        System.out.println(status);

        /**
         * anyMatch函数
         * 检查是否?少匹配?个元素 只要又一个符合要求,返回true
         */
        boolean status1 = li.stream().anyMatch(obj -> obj.length() > 10);
        System.out.println(status1);


        /**
         * max函数
         */
        // Optional<user> list7 = list1.stream().max(Comparator.comparingInt(user::getAge));
        Optional<user> list7 = list1.stream().max((s1, s2) -> Integer.compare(s1.getAge(), s2.getAge()));
        System.out.println(list7.get().getAge());

        /**
         * min函数
         */
        //Optional<user> list8  =list1.stream().min(Comparator.comparingInt(user::getAge));
        Optional<user> list8 = list1.stream().min((s1, s2) -> Integer.compare(s1.getAge(), s2.getAge()));
        System.out.println(list8.get().getAge());

        /**
         * 并行流 parallelStream
         * 为什么会有这个并?流
         *   集合做重复的操作,如果使?串?执?会相当耗时,因此?般会采?多线程来加快, Java8的
         *   paralleStream?fork/join框架提供了并发执?能?
         * 底层原理
         *   线程池(ForkJoinPool)维护?个线程队列
         *   可以分割任务,将?任务拆分成?任务,完全贴合分治思想
         *
         * paralleStream并?是否?定?Stream串?快?
         *   错误,数据量少的情况,可能串?更快,ForkJoin会耗性能
         * 多数情况下并??串?快,是否可以都?并?
         *   不?,部分情况会有线程安全问题,parallelStream??使?的外部变量,?如集合?
         *   定要使?线程安全集合,不然就会引发多线程安全问题
         */
        //两种区别
        System.out.println("Stream输出集合");
        li.stream().forEach(System.out::println);
        System.out.println("parallelStream");
        li.parallelStream().forEach(System.out::println);

        //使用parallelStream有线程安全问题,所以集合对象需要集合安全的对象
        //循环10次
        for (int i = 0; i < 10; i++) {
            //arrayList的添加方法没有加锁,线程不安全
            //List paralleList = new ArrayList();
            List paralleList = new CopyOnWriteArrayList();
            //生成0到100的数,并行的加入到数组
            IntStream.range(0, 100).parallel().forEach(paralleList::add);
            //如果是用的是ArrayList 这里会报数组下标越界异常,原因ArrayLits的add方法没有加锁,循环到了第9次时,因为是多线程,查看size的时候,都同时加1了,导致下标越界。
            //换成CopyOnWriteArrayList集合则不会,因为CopyOnWriteArrayList集合的add方法有加锁
            System.out.println(paralleList.size());
        }

        /**
         * reduce操作
         * 什么是reduce操作
         *   聚合操作,中?意思是 “减少”
         *   根据?定的规则将Stream中的元素进?计算后返回?个唯?的值
         *   常??法?
         Optional<T> reduce(BinaryOperator<T> accumulator);
         */
        //累加器
        int value = Stream.of(1, 2, 3, 4, 5, 6).reduce((item1, item2) -> item1 + item2).get();
        System.out.println(value);
        //带起始值的累加器
        int value1 = Stream.of(1, 2, 3, 4, 5, 6).reduce(100, (item1, item2) -> item1 + item2);
        System.out.println(value1);

        //使用reduce求出最大值
        int value2 = Stream.of(213, 2312, 12, 454).reduce((item1, item2) -> item1 > item2 ? item1 : item2).get();
        System.out.println(value2);


        /**
         * foreach操作
         * 集合遍历的?式
         *   for循环
         *   迭代器 Iterator
         *
         * Jdk8??的新增接?
         *  default void forEach(Consumer<? super T> action) {
         *    Objects.requireNonNull(action);
         *    for (T t : this) {
         *      action.accept(t);
         *    }
         *  }
         *
         * 注意点
         *   不能修改包含外部的变量的值
         *   不能?break或者return或者continue等关键词结束或者跳过循环
         */
        list1.stream().forEach(obj -> System.out.println(obj));
        int totalAge = 0;
        //测试修改包含外部的变量的值
//        list1.stream().forEach(obj ->{
//            System.out.println(obj);
//            totalAge += obj.getAge();
//        });

        //测试?break或者return或者continue等关键词结束或者跳过循环
//        li.stream().forEach(obj ->{
//            System.out.println(obj);
//            return;
//        });


        /**
         * collector 收集器
         * ?个终端操作, ?于对流中的数据进?归集操作,collect?法接受的参数是?个Collector
         * 有两个重载?法,在Stream接???
         * default void forEach(Consumer<? super T> action) {
         *   Objects.requireNonNull(action);
         *   for (T t : this) {
         *     action.accept(t);
         *   }
         *  }
         * List<Student> results = Arrays.asList(new Student(32),new
         *  Student(33),new Student(21),new Student(29),new Student(18));
         * results.forEach(obj->{
         *  System.out.println(obj.toString());
         * });
         * Collector的作?
         *   就是收集器,也是?个接?, 它的?具类Collectors提供了很多???法
         * Collectors 的作?
         *   ?具类,提供了很多常?的收集器实现
         * Collectors.toList()
         * ArrayList::new,创建?个ArrayList作为累加器
         * List::add,对流中元素的操作就是直接添加到累加器中
         * reduce操作, 对?任务归集结果addAll,后?个?任务的结果直接全部添加到
         * 前?个?任务结果中
         * CH_ID 是?个unmodifiableSet集合
         * Collectors.toMap()
         * Collectors.toSet()
         * Collectors.toCollection() :??定义的实现Collection的数据结构收集
         * Collectors.toCollection(LinkedList::new)
         * Collectors.toCollection(CopyOnWriteArrayList::new)
         * Collectors.toCollection(TreeSet::new)
         */

        List<String> listStr = Stream.of("dsad", "dasdsa", "123dsa").collect(Collectors.toList());
        System.out.println(listStr);
        //set集合
        Set<String> setStr = Stream.of("dsad", "dasdsa", "123dsa", "123dsa").collect(Collectors.toSet());
        System.out.println(setStr);
        Set<String> setStr1 = Stream.of("dsad", "dasdsa", "123dsa", "123dsa").collect(Collectors.toCollection(TreeSet::new));
        System.out.println(setStr1);
        List<String> listStr1 = Stream.of("dsad", "dasdsa", "123dsa", "123dsa").collect(Collectors.toCollection(ArrayList::new));
        System.out.println(listStr1);

        /**
         * join函数
         * 拼接函数 Collectors.joining
         *  //重载?法?
         *  <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T>
         * accumulator, BiConsumer<R, R>combiner);
         *  //重载?法?
         *  <R, A> R collect(Collector<? super T, A, R> collector);
         * public static <T> Collector<T, ?, List<T>> toList() {
         * return new CollectorImpl<>((Supplier<List<T>>)
         * ArrayList::new, List::add,(left, right) -> {
         * left.addAll(right); return left; }, CH_ID);
         * }
         * 其中?个的实现
         * 说明:
         * 该?法可以将Stream得到?个字符串, joining函数接受三个参数,分别表示 元素之间的连
         * 接符、前缀和后缀。
         */
        //将数组集合"||"拼接在一起
        String value3 = list.stream().collect(Collectors.joining("||"));
        System.out.println(value3);
        //还可以使用join函数,指定前缀和后缀
        String value4 = list.stream().collect(Collectors.joining("||", "{", "}"));
        System.out.println(value4);

        /**
         * partitioningBy分组
         * Collectors.partitioningBy 分组,key是boolean类型
         * public static <T>
         * Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super
         * T> predicate) {
         *  return partitioningBy(predicate, toList());
         * }
         */
        //将数组长度大于5的字符串分出来
        Map<Boolean,List<String>> boMap = li.stream().collect(Collectors.partitioningBy(obj -> obj.length() > 5));
        boMap.forEach((k,v) ->{
            System.out.println(k+"->"+v);
        });


        /**
         * groupby 分组
         * 分组 Collectors.groupingBy()
         * public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<?
         * super T, ? extends K> classifier) { return groupingBy(classifier, toList());
         * }
         */

        //练习:根据学?所在的省份,进?分组

        List<Student> studentList = Arrays.asList(new Student("?东", 23), new
                Student("?东", 24), new Student("?东", 23),new Student("北京", 22), new
                Student("北京", 20), new Student("北京", 20),new Student("海南", 25));

        Map<String,List<Student>> stuMap = studentList.stream().collect(Collectors.groupingBy(obj -> obj.getProvince()));
        stuMap.forEach((k,v)->{
            System.out.println(k+"有"+v);
        });

        //算出每个地区有多少人
        /**
         * 分组统计,groupby分组进阶
         * 分组后进行统计Collectors.counting() 统计元素个数
         */
        Map<String,Long> longMap = studentList.stream().collect(Collectors.groupingBy(obj -> obj.getProvince(),Collectors.counting()));
        longMap.forEach((k,v)->{
            System.out.println(k+"有"+v+"人");
        });

        /**
         * groupby分组进阶
         * summarizing集合统计
         * 作?:可以?个?法把统计相关的基本上都完成
         * 分类
         *   summarizingInt
         *   summarizingLong
         *   summarizingDouble
         */
        IntSummaryStatistics summaryStatistics = studentList.stream().collect(Collectors.summarizingInt(obj -> obj.getAge()));
        System.out.println("平均年龄"+summaryStatistics.getAverage());
        System.out.println("总人数"+summaryStatistics.getCount());
        System.out.println("最大年龄"+summaryStatistics.getMax());
        System.out.println("最小年龄"+summaryStatistics.getMin());




    }
}
package stream;

public class Student {

    private String province;
    private int age;

    public Student() {
    }

    public Student(String province, int age) {
        this.province = province;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "province=‘" + province + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
package stream;

public class user {

    private int age;
    private String name;

    public user(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public user() {
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "user{" +
                "age=" + age +
                ", name=‘" + name + ‘\‘‘ +
                ‘}‘;
    }
}
package stream;

public class userDTO {

    private String name;

    public userDTO(String name) {
        this.name = name;
    }

    public userDTO() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

 

Java8之流Stream使用,附上例子

标签:das   bic   foreach   count()   count   set集合   条件   vat   ping   

原文地址:https://www.cnblogs.com/zexin/p/12275959.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!