Stream流和方法引用

最新推荐文章于 2021-04-16 18:20:35 发布
最新推荐文章于 2021-04-16 18:20:35 发布
阅读量355 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Harvesters/article/details/104817843
版权

1. Stream流

1.1. Stream流引入

Stream流完全不是I/O流，按照流水线处理方式来考虑代码中的思想。
JDK1.8 之后，我们拥有了Lambda表达式，让代码的中心偏向解决实际问题，直到重点，
可以提高效率。
Stream流中使用了大量Lambda表达式，利用Lambda操作 方式，提供开发效率

1.2 传统遍历方式和Stream类处理方式对比

public class Demo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>() ;
        list.add("李渊") ;
        list.add("李世民") ;
        list.add("李隆基") ;
        list.add("李隆飞") ;
        list.add("武则天") ;
        list.add("段段") ;
        ArrayList<String> list1 = new ArrayList<>() ;
        for (String s : list) {
            if (s.contains("李")) {
                list1.add(s) ;
            }
        }
        System.out.println(list1);
        ArrayList<String> list2 = new ArrayList<>() ;
        for (String s : list1) {
            if (3 == s.length()) {
                list2.add(s) ;
            }
        }
        for (String s : list2)
        System.out.println(s);
    }
}

public class BetterDemo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>() ;
        list.add("李渊") ;
        list.add("李世民") ;
        list.add("李隆基") ;
        list.add("李隆飞") ;
        list.add("武则天") ;
        list.add("段段") ;
        /**
         *  使用stream流对Demo1进行优化
         */
        list.stream()
                .filter(s -> s.contains("李"))
                .filter(s -> s.length() == 3)
                .forEach(s -> System.out.println(s));
    }
}

1.3 Stream流对应的思想

流水线: 原材料从头到尾只会占用一份空间，中间的过程中不会占 用空间。最后生成一个结果。
Stream流有一些特征:
1. 带有很多Stream流操作的方法， filter，limit， map，sorted，skip…这些方法大多是都会使用到函数式接 口，有lambda表达式
2. 整个Stream流模型操作过程中，只有执行到count， foreach这些方法，操作真正的执行中的模型，如果不存在结 果导向，中间的所有操作是无效的，这里得益于Lambda表达式的延后性
3. Stream流是存在一定的管道性 Pipelining 流水线

1.4 获取Stream流

java.util.stream.Stream JDK1.8的新特征
1. 所有的Collection集合都有对应的Stream();
2. 可以通过Stream类中的static Stream of()获取
static Stream of(T… t); static Stream of(T t);

public class Demo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>() ;
        Stream<String> stream1 = list.stream() ;
        Set<String> set = new HashSet<>() ;
        Stream<String> stream2 = set.stream();
        //只要是connector单列集合都可以用stream（）方法直接转换为Stream流
        Map<String , String> map = new HashMap<>() ;
        Stream<String> stream3 = map.keySet().stream() ;
        Stream<String> stream4 = map.values().stream() ;
        Stream<Map.Entry<String , String>> stream5 = map.entrySet().stream();
        //Map要先转换成键，值或者键值对等单列集合在调用stream（）方法转换为Stream流
        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
        Integer[] arr1 = {1,2,3,4,5,6} ;
        Stream<Integer> stream7 = Stream.of(arr1);
        String[] arr2 = {"飞哥" , "羽羽" , "段段"} ;
        Stream<String> stream8 = Stream.of(arr2);
        //使用Stream接口中的静态方法将数组装换为Stream流
        //把数组转换成Stream流
    }
}

1.5 Stream常用方法

延迟方法:
返回值类型依然是Stream接口本身，并没有影响我们操 作真正的资源
允许链式操作，
例如 filter(XXX).limit(XXX).sorted(XXX).
终结方法: 返回值类型不是Stream接口本身，要么处理数据，要么返回其他类型数据，并且不再支持Stream流对象链式操作， count，foreach

1.5.1 foreach方法

forEach（）方法将stream流中的数据进行遍历
返回值不再是stream流
是一个终结流方法
forEach（）方法中的参数为Consumer函数式接口

package com.my.demo1;

import java.util.stream.Stream;
/**
 *  forEach（）方法将stream流中的数据进行遍历
 *  返回值不再是stream流
 *  是一个终结流方法
 */
public class Demo3 {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("飞哥", "羽羽", "段段");
        //流中的forEach方法对流中的数据进行遍历
        //forEach（）方法中的参数为Consumer函数式接口
        //可以用lambda表达式书写
        stream.forEach((s -> System.out.println(s)));
    }
}
1.5.2 filter方法

filter方法将一个stream流中的数据进行过滤
返回值仍然是一个stream流
filter() 方法中的参数为Predicate函数式接口

package com.my.demo1;

import java.util.stream.Stream;
/**
 *  filter方法将一个stream流中的数据进行过滤
 *  返回值仍然是一个stream流
 */
public class Demo4 {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("李隆基", "李隆飞", "杨玉环", "武则天");
        Stream<String> stream1 = stream.filter((s -> s.startsWith("李"))) ;
        stream1.forEach((s -> System.out.println(s)));

        //stream.forEach(s -> System.out.println(s));
        // 报错！！！
        //一个stream流只能消费一次，第一个stream使用过后就关闭了，所以就不能再调用方法了
    }
}
1.5.3map()方法

map（）方法将一种stream流转换为另一种stream流
返回值仍然是一个stream流
map（）方法中的参数为Function函数式接口

package com.my.demo1;

import java.util.stream.Stream;
/**
 *  map（）方法将一种stream流转换为另一种stream流
 *  返回值仍然是一个stream流
 */
public class Demo5 {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        Stream<Integer> integerStream = stream.map((s -> Integer.parseInt(s)));
        integerStream.forEach((s) -> System.out.println(s));
    }
}
1.5.4count（）

count（）方法用于统计stream流中的元素个数
返回值不再是一个Stream流,是一个long类型数据
是一个终结流方法

package com.my.demo1;

import java.util.ArrayList;
import java.util.stream.Stream;

/**
 *  count（）方法用于统计stream流中的元素个数
 *  返回值不再是一个Stream流,是一个long类型数据
 *  是一个终结流方法
 */
public class Demo6 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>() ;
        list.add(1) ;
        list.add(2) ;
        list.add(3) ;
        list.add(4) ;
        list.add(5) ;
        Stream<Integer> stream = list.stream();
        System.out.println(stream.count());
    }
}
1.5.5limit(long maxSize)方法

limit(long maxSize)方法是对流中的元素进行截取
返回值仍然是一个stream流，可以进行链式操作

package com.my.demo1;

import java.util.stream.Stream;

public class Demo7 {
    /**
     *  limit(long maxSize)方法是对流中的元素进行截取
     *  返回值仍然是一个stream流，可以进行链式操作
     */
    public static void main(String[] args) {
        String[] strings = {"飞哥" , "羽羽" , "小明" , "段段"};
        Stream<String> stream = Stream.of(strings);
        Stream<String> stream1 = stream.limit(3);
        stream1.forEach(s -> System.out.println(s));

    }
}

2. 方法引用

2.1 Lambda冗余问题以及方法引用初识

public class Demo11 {
    public static void main(String[] args) {
        printString((s) -> System.out.println(s));
        printString(System.out::println);

    }
    public static void printString(FunctionIn1 fun) {
        fun.print("飞哥");
    }
}

2.2 方法引用小要求

  1. 明确对象 对象 ==> 调用者 类对象，类名，super，this，构造方法，数组构造方法
  2. 明确的执行方法 该方法只有名字不需要显式出现参数
  3. 需要处理的数据 【联想，推导，省略】
  4. :: 方法引用格式

2.3 通过类对象来执行方法引用

  1. 明确对象 类对象
  2. 明确执行的方法 自定义
  3. 处理的数据 简单要求为String类型
public class Demo12 {
    public static void main(String[] args) {
//        printString((s -> {
//            MethodDemo1 methodDemo1 = new MethodDemo1();
//            methodDemo1.printUppercase(s);
//        }));
        /**
         *  使用方法引用对lambda表达式进行优化
         */
        printString(new MethodDemo1()::printUppercase);
    }
    public static void printString(FunctionIn1 fun){
        fun.print("aaaddd");
    }
}

2.4 通过类名来执行方法引用

public class Demo13 {
    public static void main(String[] args) {
//        int num = test(-10 , (n) ->{
//            return Math.abs(n);
//        });
        /**
         *  使用方法引用优化lambda表达式
         */
        int num = test(-10 , Math::abs);
        System.out.println(num);
    }
    public static int test(int number , FunctionIn2 fun) {
        return fun.calsAbs(number);
    }
}

2.5 通过super关键字执行方法引用

public class MethodDemo3 extends MethodDemo2 {
    public static void main(String[] args) {
        new MethodDemo3().show();
    }
    @Override
    public void sayHello() {
        System.out.println("你好啊！我是Demo3");
    }
    public void test(FunctionIn3 fun) {
        fun.greet();
    }
    public void show() {
//        test(() -> {
//            MethodDemo2 methodDemo2 = new MethodDemo2();
//            methodDemo2.sayHello();
//        });
        /**
         *  使用方法引用优化lambda表达式
         */
        test(super::sayHello);
    }
}

2.6 通过this关键字执行方法引用

public class MethodDemo4 {
    public static void main(String[] args) {
        new MethodDemo4().soHappy();
    }
    public void buyHouse() {
        System.out.println("买大别墅，靠大海！");
    }
    public void marry(FunctionIn4 fun) {
        fun.buy();
    }
    public void soHappy() {
//        marry(() -> {
//            this.buyHouse();
//        });
        /*
          使用方法引用优化lambda表达式
         */
        marry(this::buyHouse);
    }
}

2.7 构造器引用（构造方法引用）

public class MethodDemo5 {
    public static void main(String[] args) {
        printName("飞哥" , (name) -> {
            return new Person(name) ;
        });
        //使用构造器引用优化lambda表达式
        printName("羽羽" , Person::new);
    }
    public static void printName(String name , FunctionIn5 fun) {
        Person person = fun.creatPerson(name);
        System.out.println(person.getName());

    }
}

2.8 数组引用

public class MethodDemo6 {
    public static void main(String[] args) {
        int[] arr1 = test(5 , (n) -> {
            return new int[n] ;
        } );
        System.out.println(arr1.length);
        int[] arr2 = test(6, int[]::new);
        System.out.println(arr2.length);
        System.out.println(Arrays.toString(arr2));
    }
    public static int[] test(int length , FunctionIn6 fun) {
        return fun.buildArr(length);
    }
}
Harvesters
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Stream流
congcongxianshen的博客
07-31 1011
说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程 引入了一个全新的Stream概念，用于解决已有集合+数组既有的弊端。 /* 使用Stream流的方式,遍历集合,对集合中的数据进行过滤 Stream流是JDK1.8之后出现的 关注的是做什么,而不是怎么做 */ publ...
Stream流、 方法引用
m0_48960643的博客
08-13 220
Stream流、 方法引用
Java Stream流及方法引用
weixin_42269739的博客
06-13 379
1 Stream流 说道Stream便容易想到 I/O Stream, 而实际上, 在Java 8中, 得益于Lambda所带来的函数式编程 ,引入了全新的Stream概念, 用于解决已有集合类库既有的弊端 将 集合 , 数组转换为Stream流, 使用Stream流中的方法对数组, 集合 进行操作 循环遍历的弊端 for循环的语法就是 “怎么做” , for循环的循环体才是"做什么"; 循环并不是遍历的唯一方式, 遍历是指每一个元素注意进行处理, 而并不是从第一个到最后一个顺序处理的循环, 前者是目的,
Java高级学习-Stream+方法引用
ヤ亽o﹏妳的博客
04-09 529
文章目录Stream流获取流方法forEach过滤filterStream特点map统计个数count取前几个limit跳过前几个skip组合concat方法引用通过对象名引用成员方法通过类名引用静态成员方法通过super引用父类成员方法通过this引用成员方法类的构造器引用数组的构造器引用 Stream流 优化集合循环遍历，关注的时做什么 ，而不是怎么做 思想：类似生产线 filter，map，skip都在在对函数模型进行操作，集合元素没有真正被处理，当终结方法count执行的时候，这个模型才会按照指定
方法引用、Stream流
qq_39147602的博客
04-01 319
文章目录一、方法引用什么是方法引用方法引用符：常见引用方式1. 对象名--引用成员方法2. 类名--引用静态方法3. 类--构造引用4. 数组--构造引用二、Stream流流式思想概述获取流方式常用方法1. forEach : 逐一处理2.count：统计个数3.filter：过滤4.limit：取用前几个5.skip：跳过前几个7.map：映射8.concat：组合函数拼接与终结方法收集Stre...
Day 29 Stream流和方法引用
12-22
1.2 传统遍历方式和Stream流方式 Stream流更倾向于重点 1.3 Stream流对应的思想 流水线 原材料从头到尾只会占用一份空间，中间的过程中不会占用空间，最后生成一个结果。 Stream流有一些特征： 1. 带有很多Stream...
Java.Stream和方法引用
12-21
Stream流 Stream流引入 Stream流不是I/O流，按照流水线处理方式来考虑代码中的思想。JDK1.8 之后，我们拥有了Lambda表达式，让代码的中心偏向解决实际问题，直到重点，可以提高效率。Stream流中使用了大量Lambda...
java的Stream和方法引用
12-22
Stream和方法引用 1. Stream流 1.1. Stream流引入 Stream流完全不是I/O流，按照流水线处理方式来考虑代码中的思想。 JDK1.8 之后，我们拥有了Lambda表达式，让代码的中心偏向解决实际问题，直到重点，可以提高效率。...
JAVA学习笔记2020/4/27——Stream流、方法引用
01-20
第一章 Stream流 说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 1.1 ...
day13【Stream流、方法引用】笔记.pdf
05-20
一直以来对java8的流、Lambda都是似懂非懂，直到看了这一篇，全搞懂了。java8新特性一篇搞定！
stream流&方法引用
qq_41791459的博客
05-18 147
第一章 Stream流 说到stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“I/O”流呢？在Java8中，得益于Lambda所带来的函数式编程，引入了一个全新Stream的概念，用于解决已有集合类库既有的弊端 1.1 引言 传统集合的多步遍历代码 几乎所有的集合（如Collection接口或者Map接口等）都支持直接或者简介的遍历操作，而当我们需要对集合中的元素进行操作的时候，除了必须的添加，删除，获取外，最典型的就是集合遍历。例如： import java.util.Array
方法引用+Stream流
sgw101的博客
09-21 122
文章目录一.方法引用1.1 概述1.1.1 冗余的Lambda场景1.1.2 方法引用简化1.2 方法引用符1.3 常见引用方式1.3.1 对象名--引用成员方法1.3.2 类名--引用静态方法1.3.3 类--构造引用1.3.4 数组--构造引用二.Stream2.1 引言2.2 流式思想概述2.3 获取流方式2.4 常用方法2.4.1 forEach : 逐一处理2.4.2 count：统计个...
Java8新特性之Stream流（六）
JackieBlog
04-16 4360
1. Stream流介绍 2. Stream的创建方式 3. Stream的中间操作 4. Stream的终止操作 5. Stream的并行流 6. Stream的注意事项 7. 相关链接
stream().map()方法详解
热门推荐
qq_41135605的博客
11-04 20万+
使用Stream流时发现其中的map方法使用不好容易理解，以一个小案例详细探讨Stream中map的使用。 案例涉及知识点： 1、Stream中of方法传入可变参数 2、Stream中map元素类型转化方法 3、Function匿名接口，自定义类匿名对象的使用 4、Lambda表达式 为了便于理解，首先借鉴其他博客中的说法， stream()优点 无存储。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。 为函数式编程而生。对strea
Stream篇（—）
小猪快跑
01-24 716
什么是Stream?MSDN 中的解释太简洁了: 提供字节序列的一般视图（我可不想这么理解，这必定让我抓狂，我理解的流是向自然界的河流那样清澈而又美丽，c#中的流也是一样，许多技术或者说核心技术都需要流的帮忙）那什么是字节序列呢？其实简单的来理解的话字节序列指的是:字节对象都被存储为连续的字节序列，字节按照一定的顺序进行排序组成了字节序列那什么关于流的解释可以抽象为下列情况：打个比方：一条河中有一条
java方法引用放到map_java stream – 带方法引用的flatmap
weixin_35621342的博客
02-28 275
我是java的新手,所以我的问题是为什么这个工作：这个方法在我的Tree类中：public Stream flattened() {return Stream.concat(Stream.of(this),children.stream().flatMap(Tree::flattened));}flatMap想要一个带有t作为param的函数,而flattened方法根本没有输入参数这里发生了什么...
Stream流的常见终结操作方法
Fly_Lu的博客
12-04 1330
import java.util.ArrayList; public class dmeo03 { public static void main(String[] args) { ArrayList<String> list4 = new ArrayList<String>(); list4.add("张清和"); list4.add("张曼玉"); list4.add("张雪峰"); li.
Stream流中的常用方法_forEach
Leon_Jinhai_Sun的博客
11-10 1万+
流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种： 延迟方法：返回值类型仍然是Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方 法均为延迟方法。） 终结方法：返回值类型不再是Stream 接口自身类型的方法，因此不再支持类似StringBuilder 那样的链式调 用。本小节中，终结方法包括count 和forEach 方法。 逐一处理：fo...
stream流 skip 方法
最新发布
08-18
stream流的skip方法可以用来跳过流中的前n个元素。通过调用skip(n)，可以创建一个新的流，其中包含了原始流中跳过了前n个元素之后的所有元素。skip方法是一个有状态的中间操作，需要处理整个输入流才能生成最终结果...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值