精华内容
下载资源
问答
  • jdk8对list的各种处理

    千次阅读 2019-08-22 20:28:13
    1、jdk8对list的处理提供了很大的方便,特别是做报表的时候才能真正体现出来这个功能的强大;在我的使用过程中有两个体会:一个是减少了数据库连接,最忌讳在循环中进行数据查询,特别是多重循环的时候;我的...

    本文链接:https://blog.csdn.net/qq_33142257/article/details/62891612
    1、jdk8的流对list的处理提供了很大的方便,特别是做报表的时候才能真正体现出来这个功能的强大;在我的使用过程中有两个体会:一个是减少了数据库连接,最忌讳在循环中进行数据查询,特别是多重循环的时候;我的同事同时和我做报表,他是在循环中查表,最后导致刷一下页面要等十几二十秒才能出来数据;我都是直接把所有的数据查出来,然后通过流很方便的就过滤出想要的数据,刷页面最多等一秒左右就出来了,提高了效率;二是减少了for循环以及多重的for循环;
    直接上实例:
    新建一个测试对象
    TestStreamModel:
    /**
     * Created by zelei.fan on 2017/3/17.
     */
    public class TestStreamModel {
     
        private int id;
     
        private String name;
     
        private int grade;
     
        private int classes;
     
        private double score;
     
        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;
        }
     
        public int getGrade() {
            return grade;
        }
     
        public void setGrade(int grade) {
            this.grade = grade;
        }
     
        public int getClasses() {
            return classes;
        }
     
        public void setClasses(int classes) {
            this.classes = classes;
        }
     
        public double getScore() {
            return score;
        }
     
        public void setScore(double score) {
            this.score = score;
        }
     
        @Override
        public String toString() {
            return "TestStreamModel{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", grade=" + grade +
                    ", classes=" + classes +
                    ", score=" + score +
                    '}';
        }
     
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
     
            TestStreamModel that = (TestStreamModel) o;
     
            if (id != that.id) return false;
            if (grade != that.grade) return false;
            if (classes != that.classes) return false;
            if (Double.compare(that.score, score) != 0) return false;
            return !(name != null ? !name.equals(that.name) : that.name != null);
     
        }
     
        @Override
        public int hashCode() {
            int result;
            long temp;
            result = id;
            result = 31 * result + (name != null ? name.hashCode() : 0);
            result = 31 * result + grade;
            result = 31 * result + classes;
            temp = Double.doubleToLongBits(score);
            result = 31 * result + (int) (temp ^ (temp >>> 32));
            return result;
        }
    }
    建一个测试类
    StreamTest:
    import com.google.common.collect.Lists;
    import com.yoho.model.TestStreamModel;
     
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;
     
    /**
     * Created by zelei.fan on 2017/3/17.
     */
    public class StreamTest {
     
        private List<TestStreamModel> getList(){
            List<TestStreamModel> list = Lists.newArrayList();
            TestStreamModel testStreamModel = new TestStreamModel();
            testStreamModel.setId(2);/*主键*/
            testStreamModel.setName("张三");/*姓名*/
            testStreamModel.setClasses(1);/*班级*/
            testStreamModel.setGrade(1);/*年级*/
            testStreamModel.setScore(80);/*成绩*/
            list.add(testStreamModel);
     
            TestStreamModel testStreamModel1 = new TestStreamModel();
            testStreamModel1.setId(1);
            testStreamModel1.setName("李四");
            testStreamModel1.setClasses(1);
            testStreamModel1.setGrade(1);
            testStreamModel1.setScore(60);
            list.add(testStreamModel1);
     
            TestStreamModel testStreamModel2 = new TestStreamModel();
            testStreamModel2.setId(3);
            testStreamModel2.setName("王二麻子");
            testStreamModel2.setClasses(2);
            testStreamModel2.setGrade(1);
            testStreamModel2.setScore(90);
            list.add(testStreamModel2);
     
            TestStreamModel testStreamModel3 = new TestStreamModel();
            testStreamModel3.setId(4);
            testStreamModel3.setName("王五");
            testStreamModel3.setClasses(2);
            testStreamModel3.setGrade(1);
            testStreamModel3.setScore(59.5);
            list.add(testStreamModel3);
     
            TestStreamModel testStreamModel4 = new TestStreamModel();
            testStreamModel4.setId(8);
            testStreamModel4.setName("小明");
            testStreamModel4.setClasses(1);
            testStreamModel4.setGrade(2);
            testStreamModel4.setScore(79.5);
            list.add(testStreamModel4);
     
            TestStreamModel testStreamModel5 = new TestStreamModel();
            testStreamModel5.setId(5);
            testStreamModel5.setName("小红");
            testStreamModel5.setClasses(2);
            testStreamModel5.setGrade(2);
            testStreamModel5.setScore(99);
            list.add(testStreamModel5);
     
            TestStreamModel testStreamModel6 = new TestStreamModel();
            testStreamModel6.setId(7);
            testStreamModel6.setName("小黑");
            testStreamModel6.setClasses(2);
            testStreamModel6.setGrade(2);
            testStreamModel6.setScore(45);
            list.add(testStreamModel6);
     
            TestStreamModel testStreamModel7 = new TestStreamModel();
            testStreamModel7.setId(6);
            testStreamModel7.setName("小白");
            testStreamModel7.setClasses(1);
            testStreamModel7.setGrade(2);
            testStreamModel7.setScore(88.8);
            list.add(testStreamModel7);
     
            TestStreamModel testStreamModel8 = new TestStreamModel();
            testStreamModel8.setId(6);
            testStreamModel8.setName("小白");
            testStreamModel8.setClasses(1);
            testStreamModel8.setGrade(2);
            testStreamModel8.setScore(88.8);
            list.add(testStreamModel8);
     
            return list;
        }
     
        public static void main(String[] args) {
            StreamTest streamTest = new StreamTest();
            List<TestStreamModel> list = streamTest.getList();
     
            /*去重,去除重复对象(每个属性的值都一样的),需要注意的是要先重写对象TestStreamModel的equals和hashCode方法*/
            System.out.println("去重前:"+list);
            List<TestStreamModel> distinctList = list.stream().distinct().collect(Collectors.toList());
            System.out.println("去重后:"+distinctList);
     
            /*排序,按id升续排列,如果要降续则改成:(a, b) -> b.getId() - a.getId(); a和b都是变量名(可以按自己意愿取名字),都是list中的对象的实例*/
            System.out.println("排序前:"+list);
            List<TestStreamModel> sortList = list.stream().sorted((a, b) -> a.getId() - b.getId()).collect(Collectors.toList());
            System.out.println("排序后"+sortList);
     
            /*过滤,按照自己的需求来筛选list中的数据,比如我筛选出不及格的(小于60分)的人,t为实例*/
            System.out.println("过滤后:"+list);
            List<TestStreamModel> filterList = list.stream().filter(t -> t.getScore() < 60).collect(Collectors.toList());
            System.out.println("过滤后"+filterList);
     
            /*map, 提取对象中的某一元素,例子中我取的是每个人的name,注意list中类型对应,如果取的是id或者班级,就应该是integer类型*/
            System.out.println("提取前:"+list);
            List<String> mapList = list.stream().map(t -> t.getName()).collect(Collectors.toList());
            System.out.println("提取后:"+mapList);
     
            /*统计,统计所有人分数的和, 主要我设置的分数属性是double类型的,所以用mapToDouble,如果是int类型的,则需要用mapToInt*/
            double sum = list.stream().mapToDouble(t -> t.getScore()).sum();
            int count = list.stream().mapToInt(t -> t.getId()).sum();
     
            /*分组, 按照字段中某个属性将list分组*/
            Map<Integer, List<TestStreamModel>> map = list.stream().collect(Collectors.groupingBy(t -> t.getGrade()));
            System.out.println("按年级分组"+map);
            /*然后再对map处理,这样就方便取出自己要的数据*/
            for(Map.Entry<Integer, List<TestStreamModel>> entry : map.entrySet()){
                System.out.println("key:"+entry.getKey());
                System.out.println("value:"+entry.getValue());
            }
     
            /*多重分组,先按年级分组,再按班级分组*/
            Map<Integer/*年级id*/, Map<Integer/*班级id*/, List<TestStreamModel>>> groupMap = list.stream().collect(Collectors.groupingBy(t -> t.getGrade(), Collectors.groupingBy(t -> t.getClasses())));
            System.out.println("按照年级再按班级分组:"+groupMap);
            System.out.println("取出一年级一班的list:"+groupMap.get(1).get(1));
     
            /*多重分组,一般多重分组后都是为了统计,比如说统计每个年级,每个班的总分数*/
            Map<Integer/*年级id*/, Map<Integer/*班级id*/, Double>> sumMap = list.stream().collect(Collectors.groupingBy(t -> t.getGrade(), Collectors.groupingBy(t -> t.getClasses(), Collectors.summingDouble(t -> t.getScore()))));
            System.out.println(sumMap);
            System.out.println("取出一年级一班的总分:"+sumMap.get(1).get(1));
     
            /*stream是链式的,这些功能是可以一起使用的,例如:计算每个年级每个班的及格人数*/
            Map<Integer/*年级*/, Map<Integer/*班级*/, Long/*人数*/>> integerMap = list.stream().filter(t -> t.getScore() >= 60).collect(Collectors.groupingBy(t -> t.getGrade(), Collectors.groupingBy(t -> t.getClasses(), Collectors.counting())));
            System.out.println("取出一年级一班及格人数:"+integerMap.get(1).get(1));
        }
    }

     ———————————————— 
    版权声明:本文为CSDN博主「中单大魔王」的原创文章,遵循CC 4.0 by-sa版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/qq_33142257/article/details/62891612

    展开全文
  • JDK8 Stream 数据效率分析

    万次阅读 多人点赞 2018-09-03 23:26:57
    JDK8 Stream 数据效率分析   Stream 是Java SE 8类库中新增的关键抽象,它被定义于 java.util.stream (这个包里有若干类型: Stream&lt;T&gt; 代表对象引用,此外还有一系列特化,如 IntStream...

    JDK8 Stream 数据流效率分析

     

    Stream 是Java SE 8类库中新增的关键抽象,它被定义于 java.util.stream (这个包里有若干流类型: Stream<T> 代表对象引用流,此外还有一系列特化流,如 IntStream,LongStream,DoubleStream等 ),Java 8 引入的的Stream主要用于取代部分Collection的操作,每个流代表一个值序列,流提供一系列常用的聚集操作,可以便捷的在它上面进行各种运算。集合类库也提供了便捷的方式使我们可以以操作流的方式使用集合、数组以及其它数据结构;

     

    stream 的操作种类

    ①中间操作 

    - 当数据源中的数据上了流水线后,这个过程对数据进行的所有操作都称为“中间操作”;
    - 中间操作仍然会返回一个流对象,因此多个中间操作可以串连起来形成一个流水线;
    - stream 提供了多种类型的中间操作,如 filter、distinct、map、sorted 等等;

    ②终端操作 

    - 当所有的中间操作完成后,若要将数据从流水线上拿下来,则需要执行终端操作;

    - stream 对于终端操作,可以直接提供一个中间操作的结果,或者将结果转换为特定的 collection、array、String 等;

    这一部分详细的说明可以参见:JDK8 Stream 详细使用

     

    stream 的特点

    ①只能遍历一次:

    数据流的从一头获取数据源,在流水线上依次对元素进行操作,当元素通过流水线,便无法再对其进行操作,可以重新在数据源获取一个新的数据流进行操作;

    ②采用内部迭代的方式:

    对Collection进行处理,一般会使用 Iterator 遍历器的遍历方式,这是一种外部迭代;

    而对于处理Stream,只要申明处理方式,处理过程由流对象自行完成,这是一种内部迭代,对于大量数据的迭代处理中,内部迭代比外部迭代要更加高效;

     

    stream 相对于 Collection 的优点

    • 无存储:流并不存储值;流的元素源自数据源(可能是某个数据结构、生成函数或I/O通道等等),通过一系列计算步骤得到;
    • 函数式风格:对流的操作会产生一个结果,但流的数据源不会被修改;
    • 惰性求值:多数流操作(包括过滤、映射、排序以及去重)都可以以惰性方式实现。这使得我们可以用一遍遍历完成整个流水线操作,并可以用短路操作提供更高效的实现;
    • 无需上界:不少问题都可以被表达为无限流(infinite stream):用户不停地读取流直到满意的结果出现为止(比如说,枚举 完美数 这个操作可以被表达为在所有整数上进行过滤);集合是有限的,但流可以表达为无线流;
    • 代码简练:对于一些collection的迭代处理操作,使用 stream 编写可以十分简洁,如果使用传统的 collection 迭代操作,代码可能十分啰嗦,可读性也会比较糟糕;

     


    stream 和 iterator 迭代的效率比较

    好了,上面 stream 的优点吹了那么多,stream 函数式的写法是很舒服,那么 steam 的效率到底怎样呢?

    先说结论:

    - 传统 iterator (for-loop) 比 stream(JDK8) 迭代性能要高,尤其在小数据量的情况下;

    - 在多核情景下,对于大数据量的处理,parallel stream 可以有比 iterator 更高的迭代处理效率;


    我分别对一个随机数列 List (数量从 10 到 10000000)进行映射、过滤、排序、规约统计、字符串转化场景下,对使用 stream 和 iterator 实现的运行效率进行了统计,测试代码 基准测试代码链接

    测试环境如下:

    System:Ubuntu 16.04 xenial

    CPU:Intel Core i7-8550U

    RAM:16GB

    JDK version:1.8.0_151

    JVM:HotSpot(TM) 64-Bit Server VM (build 25.151-b12, mixed mode)

    JVM Settings:

        -Xms1024m

        -Xmx6144m

        -XX:MaxMetaspaceSize=512m

        -XX:ReservedCodeCacheSize=1024m

        -XX:+UseConcMarkSweepGC

        -XX:SoftRefLRUPolicyMSPerMB=100

     

    1. 映射处理测试

    把一个随机数列(List<Integer>)中的每一个元素自增1后,重新组装为一个新的 List<Integer>,测试的随机数列容量从 10 - 10000000,跑10次取平均时间;

    //stream
    List<Integer> result = list.stream()
    .mapToInt(x -> x)
    .map(x -> ++x)
    .boxed()
    .collect(Collectors.toCollection(ArrayList::new));
    //iterator
    List<Integer> result = new ArrayList<>();
    for(Integer e : list){
        result.add(++e);
    }
    //parallel stream
    List<Integer> result = list.parallelStream()
    .mapToInt(x -> x)
    .map(x -> ++x)
    .boxed()
    .collect(Collectors.toCollection(ArrayList::new));

    2. 过滤处理测试

    取出一个随机数列(List<Integer>)中的大于 200 的元素,并组装为一个新的 List<Integer>,测试的随机数列容量从 10 - 10000000,跑10次取平均时间;

    //stream
    List<Integer> result = list.stream()
    .mapToInt(x -> x)
    .filter(x -> x > 200)
    .boxed()
    .collect(Collectors.toCollection(ArrayList::new));
    //iterator
    List<Integer> result = new ArrayList<>(list.size());
    for(Integer e : list){
        if(e > 200){
            result.add(e);
        }
    }
    //parallel stream
    List<Integer> result = list.parallelStream()
    .mapToInt(x -> x)
    .filter(x -> x > 200)
    .boxed()
    .collect(Collectors.toCollection(ArrayList::new));

    3. 自然排序测试

    对一个随机数列(List<Integer>)进行自然排序,并组装为一个新的 List<Integer>,iterator 使用的是 Collections # sort API(使用归并排序算法实现),测试的随机数列容量从 10 - 10000000,跑10次取平均时间;

    //stream
    List<Integer> result = list.stream()
    .mapToInt(x->x)
    .sorted()
    .boxed()
    .collect(Collectors.toCollection(ArrayList::new));
    //iterator
    List<Integer> result = new ArrayList<>(list);
    Collections.sort(result);
    //parallel stream
    List<Integer> result = list.parallelStream()
    .mapToInt(x->x)
    .sorted()
    .boxed()
    .collect(Collectors.toCollection(ArrayList::new));

    4. 归约统计测试

    获取一个随机数列(List<Integer>)的最大值,测试的随机数列容量从 10 - 10000000,跑10次取平均时间;

    //stream
    int max = list.stream()
    .mapToInt(x -> x)
    .max()
    .getAsInt();
    //iterator
    int max = -1;
    for(Integer e : list){
        if(e > max){
            max = e;
        }
    }
    //parallel stream
    int max = list.parallelStream()
    .mapToInt(x -> x)
    .max()
    .getAsInt();

    5. 字符串拼接测试

    获取一个随机数列(List<Integer>)各个元素使用“,”分隔的字符串,测试的随机数列容量从 10 - 10000000,跑10次取平均时间;

    //stream
    String result = list.stream().map(String::valueOf).collect(Collectors.joining(","));
    //iterator
    StringBuilder builder = new StringBuilder();
    for(Integer e : list){
        builder.append(e).append(",");
    }
    String result = builder.length() == 0 ? "" : builder.substring(0,builder.length() - 1);
    //parallel stream
    String result = list.stream().map(String::valueOf).collect(Collectors.joining(","));

    6. 混合操作测试

    对一个随机数列(List<Integer>)进行去空值,除重,映射,过滤,并组装为一个新的 List<Integer>,测试的随机数列容量从 10 - 10000000,跑10次取平均时间;

    //stream
    List<Integer> result = list.stream()
    .filter(Objects::nonNull)
    .mapToInt(x -> x + 1)
    .filter(x -> x > 200)
    .distinct()
    .boxed()
    .collect(Collectors.toCollection(ArrayList::new));
    //iterator
    HashSet<Integer> set  = new HashSet<>(list.size());
    for(Integer e : list){
        if(e != null && e > 200){
            set.add(e + 1);
        }
    }
    List<Integer> result = new ArrayList<>(set);
    //parallel stream
    List<Integer> result = list.parallelStream()
    .filter(Objects::nonNull)
    .mapToInt(x -> x + 1)
    .filter(x -> x > 200)
    .distinct()
    .boxed()
    .collect(Collectors.toCollection(ArrayList::new));

     

    实验结果总结

    从以上的实验来看,可以总结处以下几点:

    - 在少低数据量的处理场景中(size<=1000),stream 的处理效率是不如传统的 iterator 外部迭代器处理速度快的,但是实际上这些处理任务本身运行时间都低于毫秒,这点效率的差距对普通业务几乎没有影响,反而 stream 可以使得代码更加简洁;

    - 在大数据量(szie>10000)时,stream 的处理效率会高于 iterator,特别是使用了并行流,在cpu恰好将线程分配到多个核心的条件下(当然parallel stream 底层使用的是 JVM 的 ForkJoinPool,这东西分配线程本身就很玄学),可以达到一个很高的运行效率,然而实际普通业务一般不会有需要迭代高于10000次的计算;

    - Parallel Stream 受引 CPU 环境影响很大,当没分配到多个cpu核心时,加上引用 forkJoinPool 的开销,运行效率可能还不如普通的 Stream;

     

    使用 Stream 的建议

    - 简单的迭代逻辑,可以直接使用 iterator,对于有多步处理的迭代逻辑,可以使用 stream,损失一点几乎没有的效率,换来代码的高可读性是值得的

    - 单核 cpu 环境,不推荐使用 parallel stream,在多核 cpu 且有大数据量的条件下,推荐使用 paralle stream;

    - stream 中含有装箱类型,在进行中间操作之前,最好转成对应的数值流,减少由于频繁的拆箱、装箱造成的性能损失;

     

     

    展开全文
  • JDK8新特性之Stream详解

    千次阅读 2019-06-24 00:03:52
      JDK8 新增的成员,允许以声明性方式处理数据集合,可以把 Stream 看作是遍历数据集合的一个高级迭代器   使用的好处: 代码以声明性方式书写:说明想要完成什么,而不是说明如何完 成一个操作 可以把几个...

    1 流概述

      流是 JDK8 新增的成员,允许以声明性方式处理数据集合,可以把 Stream 流看作是遍历数据集合的一个高级迭代器
      使用流的好处: 代码以声明性方式书写:说明想要完成什么,而不是说明如何完 成一个操作 可以把几个基础操作连接起来,来表达复杂的数据处理的流水 线,同时保持代码清晰可读

      流是什么?
      从支持数据处理操作的源生成元素序列.数据源可以是集合,数组 或 IO 资源
      从操作角度来看,流与集合是不同的. 流不存储数据值; 流的目的 是处理数据,它是关于算法与计算的. 如果把集合作为流的数据源,创建流时不会导致数据流动; 如果流 的终止操作需要值时,流会从集合中获取值; 流只使用一次 流中心思想是延迟计算,流直到需要时才计算值
    在这里插入图片描述
    流使用时一般包括三件事:
      1) 一个数据源(如集合)来执行一个查询;
      2) 一个中间操作链,形成一条流的流水线
       3) 一个终端操作,执行流水线,生成结果

    2 Stream流的几种获得方式

    public class Test01 {
        public static void main(String[] args) {
            //1 如何获得流,可以通过 Collection 集合,数据, 根据字面量获得流
            // 1.1 通过 Collection 获得流
            List<String> list = new ArrayList<>();
            Collections.addAll(list, "aa", "hello", "jj", "dd", "mm", "test");
            Stream<String> stream1 = list.stream();
            System.out.println(stream1);
            stream1.forEach(System.out::println);
    
            //  1.2 根据数组获得流
            String[]data = {"zhangsan","lisi","wangwu"};
            Stream<String> stream2 = Arrays.stream(data);
            stream2.forEach(s -> System.out.print(s + " "));
            System.out.println();
    
            // 1.3 直接通过值获得流
            Stream<String> stream3 = Stream.of("1", "2", "3", "4");
            stream3.forEach(s -> System.out.print(s + " "));
            System.out.println();
    
            // 1.4 无限流
            Stream.iterate(100, x -> x + 3).limit(10).forEach(s -> System.out.print(s + " "));
            System.out.println();
        }
    }
    
    java.util.stream.ReferencePipeline$Head@50040f0c
    aa
    hello
    jj
    dd
    mm
    test
    zhangsan lisi wangwu 
    1 2 3 4 
    100 103 106 109 112 115 118 121 124 127 
    

    3 Stream流的筛选操作

    public class Test01 {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            Collections.addAll(list, "aa", "aa", "cc", "d","bb");
    
            Stream<String> stream = list.stream();
    
            //流的筛选与切片
            //去重:distinct()
            stream.distinct().forEach(System.out::println);
            System.out.println("-------------1-----------");
    
            //过滤filter(Predicate<? super T> predicate); 传递一个Predicate接口
            //   stream.filter(x -> x.length()>2).forEach(System.out::println);
    
            //java.lang.IllegalStateException:  流只能使用一次
    
            list.stream().filter(x -> x.length() > 2).forEach(System.out::println);
            System.out.println("-------------2-----------");
    
            //sorted()排序操作  Comparator<? super T> comparator 传递一个Comparator接口
            list.stream().sorted(String::compareTo).forEach(System.out::println);
            System.out.println("-------------3-----------");
    
            //limt()截断操作
            list.stream().limit(5).forEach(System.out::println);
            System.out.println("--------------4----------");
    
            //skip()跳过
            list.stream().skip(3).forEach(System.out::println);
            System.out.println("---------------5---------");
    
        }
    }
    
    aa
    cc
    d
    bb
    -------------1-----------
    -------------2-----------
    aa
    aa
    bb
    cc
    d
    -------------3-----------
    aa
    aa
    cc
    d
    bb
    --------------4----------
    d
    bb
    ---------------5---------
    
    Process finished with exit code 0
    

    4 Stream流的map映射

    public class Test02 {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            Collections.addAll(list, "aa", "aa", "bb", "cc", "d", "eeeeee");
    
            //map(Function<? super T, ? extends R> mapper); 传递一个Function接口
    
            //为每个元素应用toUpperCase()把小写转换为大写
            list.stream().map(String::toUpperCase).forEach(System.out::println);
    
            //list每个每个元素的长度,然后拼接空格  2 2 2 2 1 6
            list.stream().map(String::length).map(len->len + " ").forEach(System.out::println);
            System.out.println("----------2-------");
            
            //转换为数值流
            List<Integer> integerList= Arrays.asList(54,1,78,90,345);
            IntStream intStream = integerList.stream().mapToInt(x->x);
            intStream.forEach(x->System.out.print(x+" "));
    
        }
    }
    
    AA
    AA
    BB
    CC
    D
    EEEEEE
    2 
    2 
    2 
    2 
    1 
    6 
    ----------2-------
    54 1 78 90 345 
    Process finished with exit code 0
    

    5 Stream流的查找与匹配

    public class Test03 {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            Collections.addAll(list, "aa", "aa", "bb", "cc", "d", "eeeeee", "sssssss");
    
            //allMatch()判断流中所有的元素是否都匹配给定的谓词
            System.out.println(list.stream().allMatch(s -> s.length() > 3)); //false
    
            //anyMatch()判断流中是否有某个元素可以匹配指定的谓词
            System.out.println(list.stream().anyMatch(s -> s.equals("wkcto"))); //true
    
            //noneMathc()判断流中的元素是否都没有匹配指定谓词的
            System.out.println(list.stream().noneMatch(s -> s.equals("jj"))); //false
    
            //findAny()和findFirst()的返回值类型均为Optional<T>
    
            //查找任意一个
            System.out.println(list.stream().filter(s -> s.length() > 5).findAny().get());
    
            //查找第一个
            try {
                System.out.println(list.stream().filter(s -> s.length() > 20).findFirst().get());
            }catch (Exception e) {
                e.printStackTrace();
            }
    
            //查找第一个,如果不加orElse 会输出Optional.empty
            System.out.println(list.stream().filter(s -> s.length() > 20).findFirst().orElse("不存在"));
    
    
        }
    }
    
    false
    false
    true
    eeeeee
    java.util.NoSuchElementException: No value present
    	at java.util.Optional.get(Optional.java:135)
    	at Test03.main(Test03.java:26)
    不存在
    
    Process finished with exit code 0
    

    5 Stream流的reduce规约

    public class Test04 {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            Collections.addAll(list, "aa", "aa", "bb", "cc", "d", "eeeeee", "sssssss");
    
            //1 forEach 遍历
            list.stream().forEach(System.out::println);
    
            //2 cout 统计
            System.out.println(list.stream().filter(x -> x.length() > 2).count());
    
            //3 reduce 归纳合并
            //传递的是BinaryOperator<T> accumulator 接口
            Optional<String> reduce = list.stream().reduce((s1, s2) -> s1 + "--" + s2);
    
            System.out.println(reduce.get());
            //传递Consumer<? super T> consumer 接口
            reduce.ifPresent(System.out::println);
    
            //4数值操作
            List<Integer> list2 = Arrays.asList(6, 21, 87, 34, 1, 78, 54);
    
            //5求和,指定初始值
            //reduce(T identity, BinaryOperator<T> accumulator);
            System.out.println(list2.stream().reduce(0, Integer::sum));
    
            //求和,没有初始值
            //Optional<T> reduce(BinaryOperator<T> accumulator);
            System.out.println(list2.stream().reduce((x, y) -> x + y).orElse(0));
    
            //6最值
            //Optional<T> reduce(BinaryOperator<T> accumulator);
            System.out.println(list2.stream().reduce(Math::max).get());
            System.out.println(list2.stream().reduce(Math::min).get());
        }
    }
    
    aa
    aa
    bb
    cc
    d
    eeeeee
    sssssss
    2
    aa--aa--bb--cc--d--eeeeee--sssssss
    aa--aa--bb--cc--d--eeeeee--sssssss
    281
    281
    87
    1
    
    Process finished with exit code 0
    

    6 Stream流映射到数值流

    public class Test05 {
        public static void main(String[] args) {
            List<Integer> list2 = Arrays.asList(6, 21, 87, 34, 1, 78, 54);
    
            //求和 IntStream mapToInt(ToIntFunction<? super T> mapper);
            System.out.println(list2.stream().mapToInt(x->x).sum() );
    
            //最大值 OptionalInt max(); 
            //public int getAsInt() {
            //  if (!isPresent) {
            //      throw new NoSuchElementException("No value present");
            //  }
            //      return value;
            // }
            System.out.println(list2.stream().mapToInt(x->x).max().getAsInt() );
    
            //最小值 OptionalInt min();
            //public int orElse(int other) {
            //    return isPresent ? value : other;
            //}
            System.out.println(list2.stream().mapToInt(x->x).min().orElse(0) );
    
            //平均值
            //DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
            //OptionalDouble average();
            System.out.println(list2.stream().mapToDouble(x->x).average().getAsDouble());
            
            
            //求最大值
            System.out.println(list2.stream().max(Integer::compareTo).get()); 
            
            //求最小值
            list2.stream().min(Integer::compareTo).ifPresent(System.out::println);
        }
    }
    
    281
    87
    1
    40.142857142857146
    87
    1
    
    Process finished with exit code 0
    

    7 Stream流的collect规约

    public class Test06 {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            Collections.addAll(list, "ss", "aa", "hello", "jj","hello","xx", "good");
    
    
            //把 stream 流转换为集合
            Set<String> stringSet = list.stream().collect(Collectors.toSet());
            System.out.println( stringSet );
    
            //把 Stream 流转换为数组
            Object[] objects = list.stream().toArray();
            System.out.println( Arrays.toString(objects));
            String[] toArray = list.stream().toArray(String[]::new);
            System.out.println(Arrays.toString(toArray));
    
            //Stream 流转换为字符串
            String collect = list.stream().collect(Collectors.joining(","));
            System.out.println(collect);
        }
    }
    
    [ss, aa, jj, xx, hello, good]
    [ss, aa, hello, jj, hello, xx, good]
    [ss, aa, hello, jj, hello, xx, good]
    ss,aa,hello,jj,hello,xx,good
    
    Process finished with exit code 0
    

    7 Stream流的实际使用

      汽车枚举类

    public enum CarType {
        HATCHBACK, THREECOMPARTMENT,SUV
    }
    

      汽车实体类

    public class Car {
        private String brand; //品牌
        private boolean sold; //是否已卖
        private int price;
        private CarType type; //车型
    
        public Car(String brand, boolean sold, int price, CarType type) {
            this.brand = brand;
            this.sold = sold;
            this.price = price;
            this.type = type;
        }
        public Car(){}
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Car car = (Car) o;
            return sold == car.sold &&
                    price == car.price &&
                    Objects.equals(brand, car.brand) &&
                    type == car.type;
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(brand, sold, price, type);
        }
        //省略setter和getter方法
        //省略toString 方法
    }
    

      Stream 应用

    public class Test {
        public static void main(String[] args) {
    
            //把 Car 小汽车的数据保存到 List 集合中
            List<Car> carshop = new ArrayList<>();
    
            carshop.add(new Car("Benz", false, 68, CarType.SUV));
            carshop.add(new Car("Audi", true, 28, CarType.HATCHBACK));
            carshop.add(new Car("BMW", false, 88, CarType.HATCHBACK));
            carshop.add(new Car("Geeley", true, 18, CarType.HATCHBACK));
            carshop.add(new Car("Xiali", true, 8, CarType.THREECOMPARTMENT));
            carshop.add(new Car("Haval", false, 18, CarType.SUV));
            carshop.add(new Car("Jeep", true, 38, CarType.SUV));
            carshop.add(new Car("Honda", false, 28, CarType.THREECOMPARTMENT));
            carshop.add(new Car("Chery", true, 18, CarType.THREECOMPARTMENT));
            carshop.add(new Car("Benz", false, 58, CarType.THREECOMPARTMENT));
    
            //1 根据价格降序排序后,显示汽车品牌
            carshop.stream()
                    .sorted((c1,c2) -> c2.getPrice()-c1.getPrice())
                    .map(Car::getBrand)
                    .distinct()
                    .forEach(System.out::println);
            System.out.println("======================1=========================");
    
            //2 找出已卖的车, 按价格升序排序
            carshop.stream()
                    .filter(car -> car.isSold() )
                    .sorted(Comparator.comparing(Car::getPrice))
                    .forEach(System.out::println);
            System.out.println("======================2=========================");
    
            //3 查看有哪些车型
            carshop.stream()
                    .map(car -> car.getType())
                    .distinct()
                    .forEach(System.out::println);
            System.out.println("=======================3========================");
    
            //4 SUV 型号的车有哪些
            List<Car> collect = carshop.stream()
                    .filter(car -> car.getType() == CarType.SUV)
                    .collect(Collectors.toList());
            System.out.println("=======================4========================");
    
            //5 40万以下的车的品牌, 排序
            carshop.stream()
                    .filter(car -> car.getPrice() < 40)
                    .map(Car::getBrand)
                    .distinct()
                    .sorted()
                    .forEach(System.out::println);
            System.out.println("=========================5======================");
    
            //6 统计没有卖出去的车的数量
            System.out.println( carshop.stream().filter(car -> !car.isSold()).count() );
            System.out.println("=========================6====================");
    
            //7 判断是否有 Geeley 品牌的汽车
            System.out.println( carshop.stream().anyMatch(car -> "Geeley".equals(car.getBrand())));
            System.out.println("=========================7======================");
    
            //8 最贵的车的价格
            System.out.println(carshop.stream().map(Car::getPrice).reduce(Integer::max).get());
            System.out.println("=========================8======================");
    
            //9 显示已卖出去最贵的车
            System.out.println(carshop.stream().filter(Car::isSold)
                    .reduce(BinaryOperator.maxBy((car1,car2) ->(car1.getPrice()-car2.getPrice())))
                    .get()
            );
            System.out.println("=========================9======================");
    
            //9 显示已卖出去最贵的车
            System.out.println(carshop.stream().filter(Car::isSold)
                    .collect(Collectors.maxBy(Comparator.comparing(Car::getPrice)))
                    .get()
            );
            System.out.println("=========================10======================");
    
        }
    }
    

      运行结果

    BMW
    Benz
    Jeep
    Audi
    Honda
    Geeley
    Haval
    Chery
    Xiali
    ======================1=========================
    Car{brand='Xiali', sold=true, price=8, type=THREECOMPARTMENT}
    Car{brand='Geeley', sold=true, price=18, type=HATCHBACK}
    Car{brand='Chery', sold=true, price=18, type=THREECOMPARTMENT}
    Car{brand='Audi', sold=true, price=28, type=HATCHBACK}
    Car{brand='Jeep', sold=true, price=38, type=SUV}
    ======================2=========================
    SUV
    HATCHBACK
    THREECOMPARTMENT
    =======================3========================
    =======================4========================
    Audi
    Chery
    Geeley
    Haval
    Honda
    Jeep
    Xiali
    =========================5======================
    5
    =========================6====================
    true
    =========================7======================
    88
    =========================8======================
    Car{brand='Jeep', sold=true, price=38, type=SUV}
    =========================9======================
    Car{brand='Jeep', sold=true, price=38, type=SUV}
    =========================10======================
    
    展开全文
  • JDK8中使用Stream把List转换成int数组

    List转换成int数组的方法有很多中,例如:

    第一种

    下面这种是最简单的了,知道了list的大小,然后new一个相等大小的数组,然后遍历list把list中的数据一个一个的添加到数组中。

    List<Integer> list1 = new ArrayList<>();
    list1.add
    展开全文
  • JDK8 | 串行 Stream 与并行 parallelStream 一、串行 Stream 1.获取串行的两种方式: 所有的 Collection 集合都可以通过 stream 默认方法获取:list.stream(); Stream 接口的静态方法 of 可以获取数组...
  • 主要介绍了Jdk8中Stream的使用,让你脱离for循环,本文给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • JDK8 新特性流式数据处理

    万次阅读 多人点赞 2016-10-28 16:14:26
    在学习JDK8新特性Optional类的时候,提到对于Optional的两个操作映射和过滤设计到JDK提供的流式出来。这篇文章便详细的介绍流式处理
  • 并行就是把一个内容分成多个数据块,并用不同的线程分别处理每个数据块的。 java8中将并行进行了优化,我们可以很容易的对数据进行并行操作。Stream API可以声明性地通过 paralle() 与 sequential()在并行与...
  • Java新特性玩转JDK8操作map和filter函数 map函数 功能详情 将中的每一个元素 T 映射为 R(类似类型转换) 使用场景 转换对象,如javaweb开发中集合里面的DO对象转换为DTO对象 示例 当前端需要...
  • 并行就是把内容分割成多个数据块,每个数据块对应一个,然后用多个线程分别处理每个数据块中的。 java8中将并行进行了优化,我们可以很容易的对数据进行并行操作,Stream API可以声明式的通过paralleleStream...
  • Jdk1.8中引入了stream的概念,这个“”并不同于IO中的输入和输出,它是Jdk中的一个类:java.util.stream.Stream,使用进行处理可以帮助我们提升代码的性能。 1. 常见应用 使用Stream对集合进行过滤和...
  • 8 ]; // 8192Bytes是有讲究的 int len; while ((len = fis.read(arr)) != - 1 ) { fos.write(arr, 0 ,len); } } finally { try { // try...finally...嵌套是为了防止关闭时出现异常 if (fis != ...
  • JDK1.8并行

    2019-08-12 18:02:19
    JDK1.8提供了数据的流处理,在遍历等操作时无需新的对象,拥有更高的性能;串行流(stream)就是单线程操作,并行流(parallelStream)则是开若干个线程去处理数据,并行流处理数据是无序的;遍历性能上并行流要比...
  • JDK8新特性之Stream学习

    千次阅读 2019-06-13 17:02:11
    Stream 在Java 8中,得益于Lambda所带来的函数式编程,引入了一个全新的Stream概念,用于解决已有集合类库既有的弊端。传统集合的多步遍历代码 几乎所有的集合(如 Collection 接口或 Map 接口等)都支持直接或...
  • JDK

    千次阅读 2019-09-17 16:51:38
    JDK8 JDK9 JDK10 JDK11 JDK12 文件对比 public static void main(String[] args) throws IOException { Path dir = Paths.get("d:/"); Path path1 = dir.resolve("javastack1.txt"); Pat...
  • JDK7异常处理

    千次阅读 2017-09-11 15:07:45
    虽然我们开始了Java8的旅程,但是很多人直接从java6上手了java8, 也许有一些JDK7的特性你还不知道,在本章节中带你回顾一下我们忘记了的那些特性。 尽管我们不能讲所有特性都讲一遍,挑出常用的核心特性拎出来一起...
  • JDK8新特性】5.并行和串行

    千次阅读 2017-03-27 18:29:18
    1. 并行和串行的介绍为了适应目前多核机器的时代,提高系统CPU、内存的利用率,在jdk1.8新的stream包中针对集合的操作也提供了并行操作和串行操作。并行就是把内容切割成多个数据块,并且使用多个线程分别...
  • JDK8新特性关于Stream的作用以及使用 部分内容参考自:http://www.runoob.com/java/java8-streams.html Stream API是JDK8新添加的处理集合的关键组件,提供了多种的函数式操作。 ...
  • jdk8新特性代码

    2016-06-30 16:01:36
    jdk8新特性
  • 一.JDK1.6之前的IO异常处理try{ }里面写 要自动关闭的前提是该类必须实现了AutoCloseable接口该异常的处理和之前一样 并且系统会帮你自动关闭(自动调用接口中的close方法)自定义一个类测试是否能自动调用接口...
  • jdk8 stream流式处理替换for循环

    千次阅读 2019-08-21 11:22:16
    2、stream流处理,静态方式Stream.iterate()创建无限流 Map, List<String>> keyMap = new HashMap(); Stream.iterate(0, i -> i + 1).limit(chargeInfos.size()).forEach(i -> { // stream流式处理 ...
  • JDK 8中,我们终于可以使用了,除了您使用的API无法产生的时代之外,其他一切都很好。 然后,您最终编写了一个包装器类方法,该方法允许您将迭代器转换为Stream,因为您错过了。 public static <T> ...
  • import java.io.FileInputStream; import java.io.FileOutputStream;...JDK7的新特性 在try的后边可以增加一个(),在括号中可以定义对象 那么这个对象的作用域就在try中有效 try中的代码执行完...
  • JDK8 Stream 详细使用

    千次阅读 多人点赞 2018-09-03 23:58:53
    JDK8 管道 Stream 详细使用介绍   Stream 的获取 ① 通过集合Collection获取 List&lt;Integer&gt; list = new ArrayList&lt;Integer&gt;(Arrays.asList(1,2,3,4,5)); Stream&lt;Integer&...
  • 1. jdk8 接口的新特性 多继承和默认方法。 interface A{} interface B{} public interface Inte1 extends A,B { String add(); default int test(int a,int b){ return a*b; } } 2. 将匿名函数换成-> public...
  • * JDK7出一了一个新的异常处理方案: * try{ * * catch(异常名1 |异常名2 | ... 变量){ * ... * } * * 注意:这个方式虽然简洁,但是也不够好。 * A:处理方式是一致的。(在实际开发中,好多时候可能...
  • jdk8对list的各种处理实例详解,包括去重,排序,过滤,分组,统计
  • JDK1.8,Java8常用新特性

    万次阅读 多人点赞 2018-09-17 10:43:24
    Java8,也就是jdk1.8,是意义深远的一个新版本 是Java5之后一个大的版本升级,让Java语言和库仿佛获得了新生 新特性包含: a.随着大数据的兴起,函数式编程在处理大数据上的优势开始体现,引入了Lambada函数式...
  • 我们在之前文章:集合之 Stream ... JDK8 还为我们提供了并行的 Stream ,即多线程执行的。这显然在效率方面就会有很大的提升了。接下来我们来个示例验证一下串行的执行,是不是单线程运行。 /** * 串行 St...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 131,664
精华内容 52,665
关键字:

8jdk流处理