首页 / JAVA / java8新特性学习三(Stream API)

java8新特性学习三(Stream API)

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java8新特性学习三(Stream API)，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8579字，纯文字阅读大概需要13分钟。

内容图文

java8中有两大最为重要的改变。一个是Lambda表达式，另一个是Stream API。

Stream 中文称为 “流”，通过将集合转换为这么一种叫做 “流” 的元素序列，通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作。Stream API提供了一种高效且易于使用的处理数据的方式。

先说下Stream的优势：Collection是一种静态的内存数据结构，面向内存存储在内存中，而Stream是有关计算的，面向CPU通过CPU实现计算的。它是java对集合操作的优化，相较于迭代器，使用Stream的速度非常快，并且它支持并行方式处理集合中的数据，默认情况能充分利用cpu的资源。同时支持函数式编程，代码非常简洁。

注意：

stream自己不会存储元素；

Stream不会改变源对象。相反，它会返回一个持有结果的新Stream；

Stream操作是延迟执行的。这意味着他们会等到需要结果德时候才执行。

Stream的操作三步骤

技术分享图片

1.创建stream

Stream的创建需要一个数据源（通常是一个容器或者数组）：

@Test
    public void test1(){
        //方法一、通过集合创建stream
        List<String> list= Arrays.asList("aa","dd","cc","bb","mm","zz");
        //返回一个顺序流
        Stream<String> stream1 = list.stream();
        //返回一个并行流
        Stream<String> stringStream1 = list.parallelStream();

        //方法二、通过数组创建stream
        int[] array={1,2,3,4,5};
        IntStream stream2 = Arrays.stream(array);

        //方法三、通过stream类中的静态方法of创建
        Stream<String> stream3 = Stream.of("I", "love", "you", "too");

        //方法四、创建无限流
        //迭代，遍历前十个偶数
        Stream<Integer> stream4 = Stream.iterate(0, t -> t + 2);
        stream4.limit(10).forEach(System.out::println);
        //生成
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

2.中间操作

多个中间操作可以连成一条流水线，除非流水线触发终止操作，不然中间操作不会执行任何的处理，属于延迟加载。

中间操作就是对容器的处理过程，包括：排序（sorted...），筛选（filter,limit,distinct...），映射(map，flatMap...)等

2.1 筛选与切片

filter(Predicate<? super T> predicate)：从流中过滤某些元素

limit(long maxSize):截断流

skip(n):跳过前n个元素，与limit配合使用实现分页操作

distinct：去重，使用了hashCode和equals方法来获取不同的元素，因此我们的类必须实现hashCode和equals方法。

    @Test
    public void test2(){
        User user1=new User("1003","张三",25,"成都");
        User user2=new User("1004","李四",22,"绵阳");
        User user3=new User("1002","王五",24,"南充");
        User user4=new User("1005","赵六",23,"广元");
        User user5=new User("1001","张三",21,"成都");
        User user6=new User("1003","张三",25,"南充");
        User user7=new User("1004","李四",22,"绵阳");
        User user8=new User("1003","张三",25,"成都");
        List<User> list=Arrays.asList(user1,user2,user3,user4,user5,user6,user7,user8);

        //filter过滤
        list.stream().filter(u->u.getAge()>=24).forEach(System.out::println);
        System.out.println("******************");

        //limit截断
        list.stream().filter(u->"张三".equals(u.getName())).limit(2).forEach(System.out::println);
        System.out.println("******************");

        //skip
        list.stream().skip(2).limit(5).forEach(System.out::println);
        System.out.println("******************");

        //skip，User类需实现hashCode与equals方法
        list.stream().filter(u->"张三".equals(u.getName())).distinct().forEach(System.out::println);
    }

2.2 映射

map(function f)：接收一个函数作为参数，将元素转换为其他形式或提取信息，该函数会被应用到每一个元素上，并将其映射为一个新的元素。

flatMap(function f)：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

 @Test
    public void test3(){
        //map(function f)
        List<String> list= Arrays.asList("aa","dd","cc","bb","mm","zz");
        list.stream().map(str->str.toUpperCase()).forEach(System.out::println);
        System.out.println("***********");

        User user1=new User("1003","张三",25,"成都");
        User user2=new User("1004","李四",22,"绵阳");
        User user3=new User("1002","王五",24,"南充");
        List<User> list2=Arrays.asList(user1,user2,user3);
        list2.stream().map(User::getName).forEach(System.out::println);

        //flushMap(function f)
        System.out.println("*********");
        list.stream().flatMap(StreamTest::filterCharactor).forEach(System.out::println);
    }

    public static Stream<Character> filterCharactor(String str){
        List<Character> list=new ArrayList<>();
        for(Character ch:str.toCharArray()){
            list.add(ch);
        }
        return list.stream();
    }

2.3 排序

sorted()：自然排序，其中的元素必须实现Comparable接口；

sorted(Comparator com):定制排序，我们可以使用lambda来创建一个Comparator实例，可以按照升序或者降序来排序元素。

@Test
    public void test4(){
        //sorted():自然排序：Comparable
        List<String> list= Arrays.asList("aa","dd","cc","bb","mm","zz");
        list.stream().sorted().forEach(System.out::println);

        System.out.println("**************");
        //sorted(Comparator com) --定制排序
        User user1=new User("1001","张三",25,"南充");
        User user2=new User("1002","李四",22,"绵阳");
        User user3=new User("1003","王五",25,"成都");
        User user4=new User("1004","赵六",21,"乐山");
        User user5=new User("1005","田七",22,"南充");
        List<User> list2=Arrays.asList(user1,user2,user3,user4,user5);
        
        list2.stream().sorted((u1,u2)->{
            if(u1.getAge().equals(u2.getAge())){
                return u1.getName().compareTo(u2.getName());
            }else{
                return -u1.getAge().compareTo(u2.getAge());
            }
        }).forEach(System.out::println);
    }

3.终止操作

一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用。

3.1查找与匹配

allMatch 检查是否匹配所有元素
anyMatch 检查是否至少匹配一个元素
noneMatch 检查是否没有匹配所有元素
findFirst 返回第一个元素
findAny 返回当前流中的任意元素
count 返回流中元素的总个数
max 返回流中最大值
min 返回流中最小值

@Test
    public void test5(){
        User user1=new User("1001","张三",26,"南充");
        User user2=new User("1002","李四",22,"绵阳");
        User user3=new User("1003","王五",25,"成都");
        User user4=new User("1004","赵六",21,"乐山");
        User user5=new User("1005","田七",22,"南充");
        List<User> list1=Arrays.asList(user1,user2,user3,user4,user5);
        //allMatch
        boolean b1 = list1.stream().allMatch(u -> u.getAge() == 22);
        System.out.println("allMatch==="+b1);
        //anyMatch
        boolean b2 = list1.stream().anyMatch(u -> u.getAge() == 22);
        System.out.println("anyMatch==="+b2);
        //noneMatch
        boolean b3 = list1.stream().noneMatch(u -> u.getAge() == 22);
        System.out.println("noneMatch==="+b3);
        //findFirst
        Optional<User> first = list1.stream().sorted((u1, u2) ->
                                Integer.compare(u1.getAge(), u2.getAge())).findFirst();
        System.out.println(first.get());
        //findAny
        System.out.println("-------------------");
        Optional<User> any = list1.stream().findAny();
        System.out.println(any.get());
        //count
        long count = list1.stream().count();
        System.out.println("count==="+count);
        //max
        Optional<User> max = list1.stream().max((u1, u2) -> Integer.compare(u1.getAge(), u2.getAge()));
        System.out.println(max.get());
        //min
        Optional<Integer> min = list1.stream().map(User::getAge).min(Integer::compare);
        System.out.println(min.get());
    }

　3.2 归约

reduce(T identity,BinaryOperator)：可以将流中元素反复结合起来，得到一个值。返回T
reduce(BinaryOperator):返回Optional<T>

  @Test
    public void test6(){
        //reduce(T t,BinaryOperator b)
        List<Integer> list1=Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum = list1.stream().reduce(0, (x, y) -> x + y);
        System.out.println("sum="+sum);

        //reduce(BinaryOperator b)
        User user1=new User("1001","张三",26,"南充");
        User user2=new User("1002","李四",22,"绵阳");
        User user3=new User("1003","王五",25,"成都");
        User user4=new User("1004","赵六",21,"乐山");
        User user5=new User("1005","田七",22,"南充");
        List<User> list2= Arrays.asList(user1,user2,user3,user4,user5);
        Optional<Integer> sumAge = list2.stream().map(u -> u.getAge()).reduce(Integer::sum);
        System.out.println("sumAge="+sumAge.get());
    }

　　3.3 收集

collect（Collector c）：将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法。

Collector接口中方法的实现决定了如何对流执行收集操作（如收集到List、set、map）。但是Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例。

 @Test
    public void test7(){
        User user1=new User("1001","张三",26,"南充");
        User user2=new User("1002","李四",22,"成都");
        User user3=new User("1003","王五",25,"成都");
        User user4=new User("1004","赵六",21,"乐山");
        User user5=new User("1005","张三",22,"南充");
        List<User> list1= Arrays.asList(user1,user2,user3,user4,user5);

        //收集list
        List<String> list = list1.stream().map(u -> u.getName()).collect(Collectors.toList());
        list.forEach(System.out::println);

        System.out.println("---------------------");
        //收集set
        Set<String> set = list1.stream().map(u -> u.getName()).collect(Collectors.toSet());
        set.forEach(System.out::println);

        System.out.println("---------------------");
        //收集平均值
        Double avg = list1.stream().collect(Collectors.averagingInt(User::getAge));
        System.out.println("avg="+avg);

        System.out.println("----------------");
        //收集sum
        int sum = list1.stream().collect(Collectors.summingInt(User::getAge));
        System.out.println("sum="+sum);

        System.out.println("----------------");
        //收集max
        Optional<User> maxUser = list1.stream().collect(Collectors.maxBy((u1, u2) -> Integer.compare(u1.getAge(), u2.getAge())));
        System.out.println(maxUser);

        System.out.println("----------------");
        //收集min
        Optional<Integer> min = list1.stream().map(User::getAge).collect(Collectors.minBy(Integer::compare));
        System.out.println(min.get());

        System.out.println("----------------");
        //分组
        Map<String, List<User>> groupUser = list1.stream().collect(Collectors.groupingBy(User::getAddress));
        System.out.println(groupUser);

        System.out.println("----------------");
        //分区
        Map<Boolean, List<User>> partMap = list1.stream().collect(Collectors.partitioningBy(u -> u.getAge() > 24));
        System.out.println(partMap);

        System.out.println("----------------");
        //连接字符串
        String str = list1.stream().map(User::getName).collect(Collectors.joining(","));
        System.out.println(str);
    }

原文：https://www.cnblogs.com/mabaoying/p/12903073.html

内容总结

以上是互联网集市为您收集整理的java8新特性学习三(Stream API)全部内容，希望文章能够帮你解决java8新特性学习三(Stream API)所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1179063.html

来源：【匿名】

【上一篇】Java-二分法查找提升【下一篇】JAVA/JSP学习系列之五

更多 ►

【java8新特性学习三(Stream API)】教程文章相关的互联网学习教程文章

JAVA8之妙用Optional解决判断Null为空的问题【代码】

直接上实战 //以前写法 public String getCity(User user) throws Exception{if(user!=null){if(user.getAddress()!=null){Address address = user.getAddress();if(address.getCity()!=null){return address.getCity();}}}throw new Excpetion("取值错误"); }//java8写法 public String getCity(User user) throws Exception{return Optional.ofNullable(user).map(u-> u.getAddress()).map(a->a.getCity()).orElseThrow(()->n...

Java8系列之重新认识HashMap

http://www.importnew.com/20386.html Java8系列之重新认识HashMap原文出处：前利简介Java为数据结构中的映射定义了一个接口java.util.Map，此接口主要有四个常用的实现类，分别是HashMap、Hashtable、LinkedHashMap和TreeMap，类继承关系如下图所示：下面针对各个实现类的特点做一些说明：(1) HashMap：它根据键的hashCode值存储数据，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的。 Hash...

java8 CompletableFuture.supplyAsync +线程池实现多线程处理【代码】

public void dealGovernanceStrategyNew(List<StrategyStreamOperation> commonAll, StrategyDetail strategyDetail, List<String> instanceList) {if (Objects.isNull(strategyDetail.getType()) && Objects.isNull(strategyDetail.getRetainNum())) {// 500一组分批处理List<List<String>> lists = ListSplitUtil.splitList(instanceList, 500);// 对于集合写操作：synchronizedList 相对于Vector 、CopyOnWriteArrayList性能更佳...

java8 函数式编程入门官方文档中文版 java.util.stream 中文版流处理的相关概念【代码】【图】

前言本文为java.util.stream 包文档的译文极其个别部分可能为了更好理解,陈述略有改动,与原文几乎一致原文可参考在线API文档 https://docs.oracle.com/javase/8/docs/api/ Package java.util.stream Description 一些用于支持流上函数式操作的类，例如在集合上的map-reduce转换。例如 int sum = widgets.stream() .filter(b -> b.getColor() == RED) .mapToInt(b -> b.getWeight()) .sum();此处，我们使用widgets, 他是一个 Col...

Java8 Lambda - Functioanl Interface 函数式接口

在java 8 里面新增了functional interface 这个概念。并且添加了新的annotation @FunctionalInterfaceI 1 什么是functional interface 函数式接口了？functional interface : functional interface only have 1 abstract method。这就是函数接口的定义。简单明白，函数接口其实就是一个抽象方法的接口(interface). 2 函数式接口的类型这里我只介绍基本的几个类型Predicate<T>，Consumer<T>，Function<T, R>，Supplier<T>这些函数式...

Java8 集合去重和排序【代码】

java 8 去重和排序排序的方法 List<Integer> lists = Arrays.asList(1,1,2,3);// 升序lists.sort(Comparator.comparing(Integer::intValue));// 降序lists.sort(Comparator.comparing(Integer::intValue).reversed());或者// 升序 lists.stream().sorted().collect(Collectors.toList());// 降序 lists.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList()); import java.util.*; import java.util...

Java8排序【代码】

@Data @AllArgsConstructor @NoArgsConstructor publicclass Apple {privateint wight; }排序List<Integer> numList = new ArrayList<>(Arrays.asList(10, 50, 5, 200, 9, 25)); List<Apple> applelist = new ArrayList<Apple>() {{add(new Apple(10));add(new Apple(50));add(new Apple(5));add(new Apple(400));add(new Apple(9));} }; // 常规升序 numList = numList.stream().sorted().collect(Collectors.toList()); // 常规逆...

ThreadLocal源码解析-Java8【代码】【图】

目录一.ThreadLocal介绍　　1.1 ThreadLocal的功能　　1.2 ThreadLocal使用示例二.源码分析-ThreadLocal　　2.1 ThreadLocal的类层级关系　　2.2 ThreadLocal的属性字段　　2.3 创建ThreadLocal对象　　2.4 ThreadLocal-set操作　　2.5 ThreadLocal-get操作　　2.6 ThreadLocal-remove操作三.ThreadLocalMap类　　3.0 线性探测算法解决hash冲突　　3.1 Entry内部类　　3.2 ThreadLocalMap的常量介绍　　3.3 实例化ThreadLocalMap　...

Java8 内置的函数式接口【代码】

1.Java8 内置的四大核心函数式接口（1）Consumer<T> : 消费型接口 void accept(T t);（2）Supplier<T> : 供给型接口　　 T get();（3）Function<T, R> : 函数型接口　　 R apply(T t);（4）Predicate<T> : 断言型接口　　 boolean test(T t);2.四大核心函数式接口示例/*** 有参数无返回* Consumer<T> 消费型接口* void accept(T t);*/@Testpublicvoid test1(){happy(1000, (m) -> System.out.println("KTV消费"+m+"元...

Java8获取参数名及Idea/Eclipse/Maven配置【代码】【图】

在Java8之前，代码编译为class文件后，方法参数的类型固定，但是方法名称会丢失，方法名称会变成arg0、arg1....。而现在，在Java8开始可以在class文件中保留参数名，这就给反射带来了极大的遍历。像mybatis等需要使用反射机制获取方法参数的时候就可以不用像以前一样需要使用类似于@Para之类的注解。功能测试代码参考自,点击进入编写测试类import java.lang.reflect.Method;import java.lang.reflect.Parameter;publicclass GetRun...

java8新特性学习三(Stream API)【代码】【图】

java8中有两大最为重要的改变。一个是Lambda表达式，另一个是Stream API。Stream 中文称为 “流”，通过将集合转换为这么一种叫做 “流” 的元素序列，通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作。Stream API提供了一种高效且易于使用的处理数据的方式。先说下Stream的优势：Collection是一种静态的内存数据结构，面向内存存储在内存中，而Stream是有关计算的，面向CPU通过CPU实现计算的。它是java对...

Java8集合框架——LinkedHashSet源码分析【代码】【图】

本文的目录结构如下：一、LinkedHashSet 的 Javadoc 文档注释和简要说明二、LinkedHashSet 的内部实现：构造函数三、LinkedHashSet 的 add 操作和 remove 操作一、LinkedHashSet 的 Javadoc 文档注释和简要说明　　还是以官方 javadoc 作为参考进行说明：LinkedHashSet 是 Set 接口的 hash table 和 linked list 实现，而且迭代顺序可预测（按照元素的插入顺序），实际上 LinkedHashSet 继承了 HashSet，内部使用了 LinkedHashMap ...

JAVA8新加的语法糖简介【代码】

JAVA8新加的语法糖Lambda表达式//一个接口中只有抽象方法时可用//通过编译器帮我们推断类型//例子:事件监听器中控件对象.addActionListener(e->JOptionpane.showMessageDiaLonh(null,提示语言)；);//抽象方法一个参数时(),多个参数(x1,x2,x3,..) @FunctionalInterface//直接判断下面的接口可否使用Lambda表达式Stream语法//数组->集合List<类型> list = Arrays.asList(数组对象);?//集合->数组String[] strs = list.toArray(new 类...

Java8内存结构—永久代(PermGen)和元空间(Metaspace)【代码】【图】

本文转载作者：liuxiaopeng博客地址：https://www.cnblogs.com/paddix/p/5309550.html一、JVM 内存结构　　根据 JVM 规范，JVM 内存共分为虚拟机栈、堆、方法区、程序计数器、本地方法栈五个部分。　　1、虚拟机栈：每个线程有一个私有的栈，随着线程的创建而创建。栈里面存着的是一种叫“栈帧”的东西，每个方法会创建一个栈帧，栈帧中存放了局部变量表（基本数据类型和对象引用）、操作数栈、方法出口等信息。栈的大小可以固定也...

Java8 函数式接口【代码】【图】

1. 概述函数式接口（Functional Interface）就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。提到函数式接口肯定少不了 Lambda 表达式，函数式接口可以隐式的转换为 Lambda 表达式。我们可以选择向各种各样的方法和构造函数传递 Lambda 表达式，包括在 Java 8 之前创建的一些方法和构造函数。因为 Lambda 表达式在 Java 中表示为函数接口。2. 什么是函数式接口？先来看看传统的创建线程是怎么写的Thread t1 = new ...

首页 / JAVA / java8新特性学习三(Stream API)

java8新特性学习三(Stream API)

内容导读

内容图文

Stream的操作三步骤

1.创建stream

2.中间操作

2.1 筛选与切片

2.2 映射

2.3 排序

3.终止操作

3.1查找与匹配

3.2 归约

3.3 收集

内容总结

内容备注

内容手机端

【java8新特性学习三(Stream API)】教程文章相关的互联网学习教程文章

JAVA8 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程

　3.2 归约

　　3.3 收集