JUC并发编程学习（十三）-学习Stream流的使用

已于 2022-04-27 23:47:11 修改
阅读量350 收藏 3
点赞数 1
分类专栏： JUC并发编程 文章标签： stream
于 2020-06-10 22:03:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36654629/article/details/106648988
版权

说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。

传统集合的多步遍历代码

几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。例如：

import java.util.ArrayList;
import java.util.List;
public class Demo01ForEach {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        for (String name : list) {
        System.out.println(name);
        }
    }
}

这是一段非常简单的集合遍历操作：对集合中的每一个字符串都进行打印输出操作。

循环遍历的弊端

Java 8的Lambda让我们可以更加专注于做什么（What），而不是怎么做（How），这点此前已经结合内部类进行了对比说明。现在，我们仔细体会一下上例代码，可以发现：

  • for循环的语法就是“怎么做”
  • for循环的循环体才是“做什么”

为什么使用循环？因为要进行遍历。但循环是遍历的唯一方式吗？遍历是指每一个元素逐一进行处理，而并不是从第一个到最后一个顺次处理的循环。前者是目的，后者是方式。
试想一下，如果希望对集合中的元素进行筛选过滤：

  1. 将集合A根据条件一过滤为子集B；
  2. 然后再根据条件二过滤为子集C。

那怎么办？在Java 8之前的做法可能为：

import java.util.ArrayList;
import java.util.List;
public class Demo02NormalFilter {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        List<String> zhangList = new ArrayList<>();
        for (String name : list) {
            if (name.startsWith("张")) {
            zhangList.add(name);
            }
        }

        List<String> shortList = new ArrayList<>();
        for (String name : zhangList) {
        if (name.length() == 3) {
            shortList.add(name);
            }
        }

        for (String name : shortList) {
            System.out.println(name);
        }
       }
}

这段代码中含有三个循环，每一个作用不同：

  1. 首先筛选所有姓张的人；
  2. 然后筛选名字有三个字的人；
  3. 最后进行对结果进行打印输出

每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。循环是做事情的方式，而不是目的。另一方面，使用线性循环就意味着只能遍历一次。如果希望再次遍历，只能再使用另一个循环从头开始。

那，Lambda的衍生物Stream能给我们带来怎样更加优雅的写法呢？

Stream的更优写法

package com.demo.java.study8;


import java.util.ArrayList;
import java.util.List;


/**
* @ClassName:
* @PackageName: com.demo.java.study8
* @author: youjp
* @create: 2020-02-16 15:48
* @description:
* @Version: 1.0
*/
public class Test {


    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三sasa");


        list.stream().filter(s -> s.startsWith("张"))
                .filter(s -> s.length()==3)
                    .forEach(System.out::println);

    }
}

直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。代码中并没有体现使用线性循环或是其他任何算法进行遍历，我们真正要做的事情内容被更好地体现在代码中。

整体来看，流式思想类似于工厂车间的“生产流水线”。

什么是 Stream？

Stream是操作集合的一种计算数据的工具。集合就是数据，Stream是计算集合中的数据的工具

和以前的Collection操作不同， Stream操作还有两个基础的特征：

  • Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（flfluentstyle）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
  • 内部迭代： 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。

流的操作分为两种，分别为中间操作 和 终端操作。

在这里插入图片描述

当使用一个流的时候，通常包括三个基本步骤：
获取一个数据源（source）→ 数据转换→执行操作获取想要的结果。
每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

获取流

java.util.stream.Stream 是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）获取一个流非常简单，有以下几种常用的方式：

  • 所有的 Collection 集合都可以通过 stream 默认方法获取流；
  • Stream 接口的静态方法 of 可以获取数组对应的流

根据Collection获取流
首先， java.util.Collection 接口中加入了default方法 stream 用来获取流，所以其所有实现类均可获取流

package com.demo.java.study8;

import java.util.*;
import java.util.stream.Stream;

/**
* @ClassName:
* @PackageName: com.demo.java.study8
* @author: youjp
* @create: 2020-02-16 15:48
* @description:
* @Version: 1.0
*/
public class Test {

    public static void main(String[] args) {
       List<String> list=new ArrayList<>();
        Stream stream=list.stream();


        Set<String> list2=new HashSet<>();
        Stream stream1=list2.stream();


        Vector<String> list3=new Vector<>();
        Stream stream2=list3.stream();
    }
}

根据Map获取流
java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流需要分key、value或entry等情况

package com.demo.java.study8;


import java.util.*;
import java.util.stream.Stream;


/**
* @ClassName:
* @PackageName: com.demo.java.study8
* @author: youjp
* @create: 2020-02-16 15:48
* @description:
* @Version: 1.0
*/
public class Test {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        Stream keyStream=map.keySet().stream();
        Stream valueStream=map.values().stream();
        Stream<Map.Entry<String,String>>    entryStream=map.entrySet().stream();
    }
}

根据数组获取流

package com.demo.java.study8;
import java.util.*;
import java.util.stream.Stream;

/**
* @ClassName:
* @PackageName: com.demo.java.study8
* @author: youjp
* @create: 2020-02-16 15:48
* @description:
* @Version: 1.0
*/
public class Test {
    public static void main(String[] args) {
        String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
        Stream<String> stream=Stream.of(array);
    }
}

备注： of 方法的参数其实是一个可变参数，所以支持数组。

常用方法

流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：
延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。本小节中，终结方法包括 count 和 forEach 方法。

备注：本小节之外的更多方法，请自行参考API文档。

逐一处理：forEach
虽然方法名字叫 forEach ，但是与for循环中的“for-each”昵称不同。

void forEach(Consumer<? super T> action);

该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理。
复习Consumer接口

java.util.function.Consumer<T>接口是一个消费型接口。
Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。

基本使用

package com.demo.java.study8;


import java.util.*;
import java.util.stream.Stream;

public class Test {

    public static void main(String[] args) {
        String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
        Stream<String> stream=Stream.of(array);
        stream.forEach(s -> System.out.println(s));
    }
}

过滤：filter
可以通过 filter 方法将一个流转换成另一个子集流。方法签名：

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。
复习Predicate接口
此前我们已经学习过 java.util.stream.Predicate 函数式接口，其中唯一的抽象方法为：

boolean test(T t);

该方法将会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的 filter 方法将会留用元素；如果结果为false，那么 filter 方法将会舍弃元素。

package com.demo.java.study8;


import java.util.*;
import java.util.stream.Stream;


/**
* @ClassName:
* @PackageName: com.demo.java.study8
* @author: youjp
* @create: 2020-02-16 15:48
* @description:
* @Version: 1.0
*/
public class Test {


    public static void main(String[] args) {


        String[] array = { "张无忌", "李翠山", "刘三丰", "张一元" };
        Stream<String> stream=Stream.of(array);
        Stream<String> result= stream.filter(s -> s.startsWith("张"));
        result.forEach(s -> System.out.println(s));
    }
}

在这里通过Lambda表达式来指定了筛选的条件：必须姓张。

映射：map
如果需要将流中的元素映射到另一个流中，可以使用 map 方法。方法签名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个 Function 函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流

复习Function接口
此前我们已经学习过 java.util.stream.Function 函数式接口，其中唯一的抽象方法为：

R apply(T t);

这可以将一种T类型转换成为R类型，而这种转换的动作，就称为“映射”。
基本使用

package com.demo.java.study8;


import java.util.stream.Stream;


/**
* @ClassName:
* @PackageName: com.demo.java.study8
* @author: youjp
* @create: 2020-02-17 14:05
* @description:
* @Version: 1.0
*/
public class Test2 {


    public static void main(String[] args) {
        String[] array = { "10", "18", "20", "21" };
        Stream<String> stream=Stream.of(array);
         Stream result=  stream.map(s -> Integer.parseInt(s));
         result.forEach(s-> System.out.println(s));
    }
}

这段代码中， map 方法的参数通过方法引用，将字符串类型转换成为了int类型（并自动装箱为 Integer 类对象）。

统计个数：count
正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数：

long count()

该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。基本使用：

package com.demo.java.study8;
import java.util.*;
import java.util.stream.Stream;

/**
* @ClassName:
* @PackageName: com.demo.java.study8
* @author: youjp
* @create: 2020-02-16 15:48
* @description:
* @Version: 1.0
*/
public class Test {
    public static void main(String[] args) {
        String[] array = { "张无忌", "李翠山", "刘三丰", "张一元" };
        Stream<String> stream=Stream.of(array);
        Stream<String> result= stream.filter(s -> s.startsWith("张"));
        System.out.println(result.count());
        
    }
}

取用前几个：limit
limit 方法可以对流进行截取，只取用前n个。方法签名：

Stream<T> limit(long maxSize);

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用：

package com.demo.java.study8;
import java.util.*;
import java.util.stream.Stream;

/**
* @ClassName:
* @PackageName: com.demo.java.study8
* @author: youjp
* @create: 2020-02-16 15:48
* @description:
* @Version: 1.0
*/
public class Test {
    public static void main(String[] args) {
        String[] array = { "张无忌", "李翠山", "刘三丰", "张一元" };
        Stream<String> stream=Stream.of(array);
        Stream<String> result= stream.limit(3);
        result.forEach(s -> System.out.println(s));
        
    }
}

输出：

张无忌
李翠山
刘三丰

跳过前几个：skip
如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

Stream<T> skip(long n);

如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。基本使用：

package com.demo.java.study8;
import java.util.*;
import java.util.stream.Stream;

/**
* @ClassName:
* @PackageName: com.demo.java.study8
* @author: youjp
* @create: 2020-02-16 15:48
* @description:
* @Version: 1.0
*/
public class Test {
    public static void main(String[] args) {
        String[] array = { "张无忌", "李翠山", "刘三丰", "张一元" };
        Stream<String> stream=Stream.of(array);
        Stream<String> result= stream.skip(2);
        result.forEach(s -> System.out.println(s));
    }
}

输出：

刘三丰
张一元

组合：concat
如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

备注：这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。

package com.demo.java.study8;
import java.util.*;
import java.util.stream.Stream;
/**
* @ClassName:
* @PackageName: com.demo.java.study8
* @author: youjp
* @create: 2020-02-16 15:48
* @description:
* @Version: 1.0
*/
public class Test {
    public static void main(String[] args) {

        String[] array = { "张无忌", "李翠山", "刘三丰", "张一元" };
        Stream<String> stream1=Stream.of(array);
        Stream<String> stream2=Stream.of(array);

        Stream<String> result1= stream1.skip(2);
        Stream<String> result2=stream2.limit(2);
        Stream stream=Stream.concat(result1,result2);
        stream.forEach(s-> System.out.println(s));

    }
}

输出：

刘三丰
张一元
张无忌
李翠山

练习：集合元素处理

题目

现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用Stream流式处理方式依次进行以下若干操作步骤：

  1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
  2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
  3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
  4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
  5. 将两个队伍合并为一个队伍；存储到一个新集合中。
  6. 根据姓名创建 Person 对象；存储到一个新集合中。
  7. 打印整个队伍的Person对象信息。

两个队伍（集合）的代码如下：

package com.demo.java.study8;


import java.util.*;
import java.util.stream.Stream;


/**
* @ClassName:
* @PackageName: com.demo.java.study8
* @author: youjp
* @create: 2020-02-16 15:48
* @description:
* @Version: 1.0
*/
public class Test {


    public static void main(String[] args) {


        //第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");


        //第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");
    }
}

解决：

package com.demo.java.study8;


import java.util.*;
import java.util.stream.Stream;


/**
* @ClassName:
* @PackageName: com.demo.java.study8
* @author: youjp
* @create: 2020-02-16 15:48
* @description:
* @Version: 1.0
*/
public class Test {


    public static void main(String[] args) {


        //第一支队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");


        //第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");


        // 第一个队伍只要名字为3个字的成员姓名；
        // 第一个队伍筛选之后只要前3个人；
        Stream<String> stream1=one.stream().filter(s -> s.length()==3).limit(3);


        // 第二个队伍只要姓张的成员姓名；
        // 第二个队伍筛选之后不要前2个人；
        Stream<String> stream2= two.stream().filter(s -> s.startsWith("张")).skip(2);

        // 将两个队伍合并为一个队伍；
        // 根据姓名创建Person对象；
        // 打印整个队伍的Person对象信息。
        Stream<String> stream3=Stream.concat(stream1,stream2);
        stream3.map(Person::new).forEach(person -> System.out.println(person.toString()));
        
                //stream3.map(Person::new).forEach(System.out::println);

    }
}

输出：

Person{name='宋远桥'}
Person{name='苏星河'}
Person{name='石破天'}
Person{name='张天爱'}
Person{name='张二狗'}

其他方法可另行参考博客：
https://blog.csdn.net/makyan/article/details/104533966

收破烂的小熊猫~
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【JavaSe】高级特性篇(十) Java8新特性Stream流
不想当架构师的程序员不是好程序员
08-27 898
JavaSe·高级特性篇(十) Java8新特性Stream流 1. 引言 1.1 传统集合的多步遍历代码 几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历 public static void main(String[] args) { List<...
JUC之四大函数接口以及Stream流计算（总体五篇）
热爱编写程序的药学在读书
05-10 211
1、四大函数接口 java.util.funciton.它有四大函数接口。 Function<String,Integer> function = new Function<String, Integer>() { public Integer apply(String s) { return s.length(); } }; System.out.println(f
stream流的应用与并行流与函数式编程
m0_52174905的博客
10-25 1138
stream并行流，一些sql小方法
JavaSE之JUCStream流式计算
weixin_46036165的博客
05-31 106
1、Stream流式计算 package com.coding.stream; import java.util.Arrays; import java.util.List; // 数据库、集合 ： 存数据的 // Stream：计算和处理数据交给 Stream public class StreamDemo { /** * 按条件用户筛选： * 1、id 为偶数 * 2、年龄大于24 * 3、用户名大写 映射 * 4、用户名倒排序
使用Stream方式处理集合元素
08-04 731
package com.itheima.demo03.Stream;import java.util.ArrayList;import java.util.stream.Stream;/** * @author newcityman * @date 2019/8/4 - 20:30 * /* * 练习:集合元素处理（Stream方式） * 现在有两个ArrayList集合存储队伍当中的多...
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC（Java Utilities for ...
javajdk8源码-concurrencyJava:基于JDK8源码学习并发编程知识
05-20
本资料"javajdk8源码-concurrencyJava:基于JDK8源码学习并发编程知识"旨在深入探讨JDK 8中的并发机制，并通过源码分析帮助开发者理解其工作原理。 首先，我们要关注Java并发编程的基础概念，包括线程、进程、同步和...
Java高级之并发编程.md
最新发布
03-05
### Java高级之并发编程 #### 1....综上所述，Java 8 的新特性和并发编程中使用的原子类及`volatile`等概念都是现代软件开发中极为重要的知识点，掌握它们有助于开发者构建更加高效、健壮的应用程序。
JavaCommon:Java基础用法，集合，线程，JUC，jdk5--8各个版本特性。
03-23
JavaCommon 是一个涵盖Java基础知识和进阶特性的项目，它主要关注Java编程语言的基础用法、集合框架、多线程处理以及Java并发工具集（JUC）。该项目还深入解析了从JDK 5到JDK 8各版本的重要特性，为开发者提供了丰富...
尚硅谷最新视频,包括java8，JUC，NIO
03-23
### Java 并发编程（JUC） #### 线程安全 Java 并发库（JUC）提供了多种方式来确保多线程环境下的线程安全性，如 synchronized 关键字、ReentrantLock、Atomic 类等。 #### 线程池 线程池是一种基于池化机制的多...
spark 2.0 OneForOneStreamManager
houzhizhen的专栏
11-16 450
OneForOneStreamManager只能按顺序一个接一个的读取一个流的数据块。它借助于内部的StreamSate类，StreamState类里存放了客户端编号，ManagedBufffer的迭代器，以及当前读的块编号。要读的块编号必须为当前块编号加1。 /** * StreamManager which allows registration of an Iterator, w
JAVA 8新特性（四）：Stream
java coding girl
09-02 343
目录一、介绍二、什么是流三、Stram 的操作三个步骤四、创建Stream的四种方式五、Stream的中间操作5.1 筛选与切片5.2 映射5.3 排序六、 Stream的终止操作6.1 查找与匹配6.2归约6.3 收集 一、介绍 Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对 集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对...
JAVA Stream流
weixin_62867523的博客
12-24 172
可以提供许多对集合、数组进行遍历操作的方法。 什么是流呢？ 简单的定义，就是“从支持数据处理操作的源,生成的元素序列”。 元素列表:和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。 数据源 :获取数据的源，比如集合。 数据处理操作 :流更偏向于数据处理和计算，比如 filter、map、find、sort 等。 简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一 系列流操作，最后再构建成我们需要的数据集合 流操作 流操作可以分为两类：中间操作和终端操作。
java基础语法（二）
Stream_who的博客
10-25 332
数据类型 流程控制 方法 重载和重写
Java 8中新特性Stream的详细理解和使用
m0_56245143的博客
04-18 1024
Stream是对集合Collection对象功能的增强，Stream可以对集合对象进行便利高效的聚合操作和大批量的数据操作，集合类存有的元素都是划分内存空间存储的，数据量很大的集合类会占用大量的内存。获取一个数据源source => 数据转换 => 执行操作获取需要的结果，每次转换后原来的Stream对象不变，返回一个新的Stream对象，这样可以使得对Stream的操作链式排列，形成一个管道。集合的大小是有界的，但数据流Stream可以是无界的，短路操作等可以允许无限流计算在有限的时间内完成。
js数组 方法 map() filter() some() every() 的用法数组方法 改变原数组和不改变原数组
JC_5445的博客
09-13 1767
数组方法回顾 刚开始 我们先回顾一下数组的其它方法 在深刻的记忆不看也会忘记 改变原数组的方法 pop() 删除数组的最后一个元素并返回删除的元素 push() 向数组的末尾添加一个元素，并返回新的长度 shift() 删除并返回数组的第一个元素 unshift() 向数组的开头添加一个或多个元素，并返回新的长度 reverse() 反转数组的元素排序 sort() 对数组的元素进行排序 splice() 用于插入 删除 和 替换数组元素 不会改变原数组的： concat() 连接两个或多个数组，并返
Java中方法调用完之后，原来的数改变吗？
m0_48112568的博客
07-20 1822
注：此想法来源于刘意老师的Java基础视频，用到的代码和图均出自刘意老师，我只做解释） 附代码： 内存示意图： 1.先讲第一种：基本类型：形式参数的改变对实际参数没有影响 首先在栈中为main方法开辟空间，在其中声明了两个数int a = 10,int a = 20 ， 接着为change（int int ）方法开辟内存,并把a,b两个数的值赋给形参 注意：这个时候，change方法中要求输入两个int类型的形参，老师在此出没有写出，应该是change（int x,int y ）,然
Java 8 中的 Stream API - map() 方法详解
JonTang的博客
11-03 6229
Java 8 中的 Stream API - map() 方法详解
【Java】使用Stream API处理Map并返回新的Map
提笔忘字的帝国
04-07 3009
使用Stream API处理Map并返回新的Map
尚硅谷全科视频教程：Java到大数据，一站式学习资源
- **Java JUC**（Java并发编程）：深入学习Java并发编程，包括线程池、同步机制、并发集合等，提升多线程环境下的编程能力。 - **Java NIO**：讲解非阻塞I/O，包括选择器、通道、缓冲区等，适用于高性能网络编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

收破烂的小熊猫~

你的鼓励将是我创造最大的东西~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值