JAVA_可变参数Stream-File

最新推荐文章于 2023-07-02 22:34:09 发布
最新推荐文章于 2023-07-02 22:34:09 发布
阅读量284 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42073385/article/details/108310665
版权

可变参数:

可变参数:就是形参的个数是可以变化的

格式:修饰符 返回值类型 方法名(数据类型…变量名){}

范例:public static int getSum(int… arr){}

可变参数注意事项:这里的变量其实是一个数组

public class MyVariableParameter2 {
    public static void main(String[] args) {
        /*
        定义一个方法 求N个数的和
         */
        int sum1 = getSum(1, 2, 3, 4, 5);
        System.out.println(sum1);
    }
    public static int getSum(int... arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }

        return sum;
    }
}
创建不可变集合:

//JDK1.9以后才可以

方法名说明
ststic List of(E…elements)创建一个具有指定元素的List集合对象
ststic Set of(E…elements)创建一个具有指定元素的Set集合对象
ststic <K,V> Map <K,V> of(E…elements)创建一个具有指定元素的Map集合对象
public class MyVariableParameter4 {
    public static void main(String[] args) {
        //集合的批量添加
        //首先是通过调用List.of方法来创建一个不可变的集合,of方法的形参就是一个可变参数
        //再创建一个ArrayList集合,并把这个不可变的集合中所有的数据,都添加到ArrayList中.
        ArrayList<String> list = new ArrayList<>(List.of("a","b","c","d"));
        System.out.println(list);

        //传递的参数中,不能存在重复元素
        Set<String> set = Set.of("a", "b", "c", "d");
        System.out.println(set);

        //
        Map<String, String> map = Map.of("张三", "江苏", "李四", "北京", "王五", "山海");
        System.out.println(map);

        //
        Map<String, String> map1 = Map.ofEntries(Map.entry("张三", "江苏"), Map.entry("李四", "北京"));
        System.out.println(map1);
    }
}

1.在List,Set,Map接口中,都存在of方法,可以创建一个不可变的集合

2.这个集合不能添加,不能删除,不能修改.

3.但是可以结合集合的带参构造,实现集合的批量添加.

4.在Map接口中,还有一个ofEntries方法可以提高代码的阅读性

首先会把键值对封装成一个Entry对象,再把这个Entry对象添加到集合当中

Stream流:

操作集合

stream流的三类方法:

stream流的获取方法:

单列集合:

可以使用Collection接口中的默认方法stream()生成流

default Stream stream()

双列集合:

间接的生成流

可以通过keySet或者entrySet获取一个set集合,在获取Stream流

数组:

Arrays中的静态方法stream生成流

同种数据类型的多个数据:

1,2,3,4,5…

“aaa”,“bbb”,“ccc”…

使用stream.of(T…values)生成流

/*
  Stream流的获取
  单列集合:  集合对象,stream();
  双列集合:   不能直接获取,需要间接获取
            集合对象.keySet().stream();
            集合对象.entrySet().stream();
            集合对象.entrySet().stream();
   数组  :  Arrays.stream(数组名);

   同种数据类型的多个数据 :
            stream.of(数据1,数据2,数据3);
             */
public class MyStream1 {
    public static void main(String[] args) {
        //单列集合
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

//        Stream<String> stream = list.stream();
//       stream.forEach(s-> System.out.println((s)));
        list.stream().forEach(s -> System.out.println(s));


        //双列集合
        HashMap<String,Integer>  hm = new HashMap<>();
        hm.put("zhangsan",23);
        hm.put("lisi",24);
        hm.put("wangwu",23);
        //双列集合不能直接获取Stream流
        //keyset 先获取到所有的键  再把这个set集合中所有的键放到stream流中
        //hm.keySet().stream().forEach(s -> System.out.println(s));

        //entrySet
        //现货区到所有的键值对对象
        //再把这个set集合中所有的键值对对象放到stream流中
        hm.entrySet().stream().forEach(s-> System.out.println(s));

        //数组
        int[] arr = {1,2,3,4};
        Arrays.stream(arr).forEach(s-> System.out.println(s));

        //同种数据类型的多个数据
        Stream.of(1,2,3,4,5,6,7).forEach(s-> System.out.println(s));

    }
}
中间方法 filter:
public class MyStream3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张亮");
        list.add("谢广坤");

        //filter方法获取流中的 每一个数据
        //而test方法中的s,就依次表示流中的每一个数据
        //我们只要在test方法中对s进行判断就可以了
        //如果判断的结果为true,则当前的数据留下
        //如果判断的结果为false,则当前数据不要
/*        list.stream().filter(
                new Predicate<String>() {
                    @Override
                    public boolean test(String s) {
                        boolean result = s.startsWith("张");//以张开头的
                        return result;
                    }
                }
        ).forEach(s-> System.out.println(s));         */

        //因为Predicate接口中只有一个抽象方法test
        //所以我们可以使用lambda表达式来简化
        list.stream().filter(
                (String s)->{
                    boolean result = s.startsWith("张");//以张开头的
                    return result;
                }
        ).forEach(s-> System.out.println(s));

        list.stream().filter(
               s ->  s.startsWith("张")).forEach(s-> System.out.println(s));//以张开头的
    }
}

stream流中常见的中间操作方法:

Stream limit(long maxSize):截取指定参数的个数

Stream skip(long n):跳过指定参数个数的数据

static Stream concat(Stream a,Stream b):合并a和b另两个流为一个流

Stream distinct():取出流中的重复元素.依赖(hashCode和equals方法)

public class MyStream4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张亮");
        list.add("谢广坤"); list.add("谢广坤"); list.add("谢广坤"); list.add("谢广坤");
        
//        Stream<T> limit(long maxSize):截取指定参数的个数
       list.stream().limit(2).forEach(s-> System.out.println(s));
       
//        Stream<T> skip(long n):跳过指定参数个数的数据
       list.stream().skip(2).forEach(s-> System.out.println(s));//跳过前两个
        
//        static<T> Stream<T> concat(Stream a,Stream b):合并a和b另两个流为一个流
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("张三丰");
        list2.add("张无忌");
        list2.add("张翠山");
        Stream.concat(list.stream(),list2.stream()).forEach(s -> System.out.println(s));
        
//       Stream<T> distinct():取出流中的重复元素.依赖(hashCode和equals方法)
        list.stream().distinct().forEach(s -> System.out.println(s));


    }
}
stream流的常见终结操作方法:

void forEach(Consumer action):对此流的每个元素执行操作

Consumer接口中的方法 void accept(T t):对给定的参数执行此操作

long count():返回此流中的元素数

public class MyStream5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张亮");
        list.add("谢广坤");

//        void forEach(Consumer action):对此流的每个元素执行操作
//        Consumer接口中的方法  void accept(T t):对给定的参数执行此操作
        //在forEach方法的底层,会循环获取到流中的每一个数据
        //并循环调用accept方法,并把每一个数据传递给accept方法
        //s就依次表示了流中的每一个数据
        //所以,我们只要在accept方法中,写上马上处理的业务逻辑就可以了
        list.stream().forEach(
                new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                }
        );
        System.out.println("============================");
        //lambda表达式的简化格式
        //是因为Consumer接口中,只有一个accept方法
        list.stream().forEach(
                (String s)-> {System.out.println(s);}
        );
        System.out.println("============================");
        //lambda表达式进一步简化
        list.stream().forEach(s-> System.out.println(s));

        System.out.println("============================");
//        long count():返回此流中的元素数
        long count = list.stream().count();
        System.out.println(count);
    }
}
Stream流的收集操作:

需求:过滤元素并遍历集合

public class MyStream6 {
    public static void main(String[] args) {
        /*
        
         */
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
/*        list.stream().filter(
                (Integer i)->{
                    return  i % 2 == 0;
                }
        );*/
        list.stream().filter(number -> number%2 == 0).forEach(number -> System.out.println(number));
        System.out.println("=================================");
        for (Integer integer : list) {
            System.out.println(integer);
        }
        /*2
        4
        6
        8
        10
                =================================
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10*/
        
    }
}

结论:在Stream流中无法直接修改集合,数组等数据源中的数据.

Stream流的收集操作:

Stream流的收集方法:

R collect(Collector collector)

工具类Collectors提供了具体的收集方式:

public static Collector toList():把元素收集到List集合中

public static Collector toSet():把元素收集到Set集合中

public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中

public class MyStream7 {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
                list1.add(i);
        }
        list1.add(10);
        //List可以有重复的
        //set不保留有重复的

        //
        List<Integer> list = list1.stream().filter(number -> number % 2 == 0).
                collect(Collectors.toList());
        System.out.println(list);

        Set<Integer> set = list1.stream().filter(number -> number % 2 == 0).collect(Collectors.toSet());
        System.out.println(set);
        /*[2, 4, 6, 8, 10, 10]
        [2, 4, 6, 8, 10]*/
    }
}

File:

IO流是什么?

1.可以将数据从本地文件中读取出来

2.可以将数据从内存保存到本地文件

File类是什么?

1.在读写数据时告诉虚拟机要操作的(文件/文件夹)在哪

File类概述和构造方法

File:它是文件和目录路径名的抽象表示

文件和目录可以通过File封装成对象

File封装的对象仅仅是一个路径名.他可以是存在的,也可以是不存在的.

方法名说明
File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
File(String parent, String child)从父路径名字符串和子路径名字符串创建新的 File实例
File(File parent, String child)从父抽象路径名和子路径名字符串创建新的 File实例
public class FileDemo1 {
    public static void main(String[] args) {
        //File(String   pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
        String path = "D:\\itheima\\a.txt";
        File file = new File(path);
        //为什么要把字符串表示形式的路径变成File对象
        //就是为了使用file的方法

        //File(String   parent, String child)从父路径名字符串和子路径名字符串创建新的   File实例
        String path1 = "D:\\itheima";
        String path2 = "a.txt";
        File file1 = new File(path1,path2);//把两个路径进行拼接
        System.out.println(file1);//D:\itheima.a.txt

        //File(File   parent, String child)从父抽象路径名和子路径名字符串创建新的   File实例
        File file3 = new File("D:\\itheima");
        String path3 = "a.txt";
        File file4 = new File(file3,path3);
        System.out.println(file4);//D:\itheima\a.txt

    }
}

1.2绝对路径和相对路径【理解】

  • 绝对路径

    是一个完整的路径,从盘符开始

  • 相对路径

    是一个简化的路径,相对当前项目下的路径

  • 示例代码

1.3File类创建功能【应用】

  • 方法分类

    方法名说明
    public boolean createNewFile()当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
    public boolean mkdir()创建由此抽象路径名命名的目录
    public boolean mkdirs()创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录
public class FileDemo3 {
    public static void main(String[] args) throws IOException {
        //public boolean createNewFile()创建一个新的空文件夹
         //注意点:
             //1.如果文件存在,那么创建失败,返回false
            //2.如果文件不存在,那么创建成功,返回true
            //3.createNewFile方法不管调用者有没有后缀名,只能创建文件
        File file = new File("D:\\itheima\\a.txt");
        boolean result1 = file.createNewFile();
        System.out.println(result1);

        //public boolean mkdir()  创建一个单级文件夹
        //注意点:
          //1.只能创建单级文件夹,不能创建多级文件夹
            //2.不管调用者有没有后缀名,只能创建单级文件夹
        File file2 = new File("D:\\itheima\\a\\b\\c");
        boolean result2 = file.mkdir();
        System.out.println(result2);//false
        //public boolean mkdirs()创建一个多级文件夹
         //注意点:
        //1能创建单级文件夹,能创建多级文件夹
        //2.不管调用者有没有后缀名,只能创建文件夹
        File file3 = new File("D:\\itheima\\aa\\bb\\cc");
        boolean result3 = file3.mkdirs();
        System.out.println(result3);
    }
}

1.4File类删除功能【应用】

  • 方法分类

    方法名说明
    public boolean delete()删除由此抽象路径名表示的文件或目录
public class FileDemo4 {
    public static void main(String[] args) {
        //删除D:\itheima\a.txt
        //删文件  直接删除
        File file = new File("D:\\itheima\\a.txt");
        boolean result = file.delete();
        System.out.println(result);
        //删文件夹
        //只能删空文件夹
        //如果要删有文件的文件夹 只能先删除里面的文件 然后在删文件夹
        File file1 = new File("D:\\itheima");
        boolean result1 = file.delete();
        System.out.println(result1);
    }
}

1.5File类判断和获取功能【应用】

  • 判断功能

    方法名说明
    public boolean isDirectory()测试此抽象路径名表示的File是否为目录
    public boolean isFile()测试此抽象路径名表示的File是否为文件
    public boolean exists()测试此抽象路径名表示的File是否存在

  • 获取功能

    方法名说明
    public String getAbsolutePath()返回此抽象路径名的绝对路径名字符串
    public String getPath()将此抽象路径名转换为路径名字符串
    public String getName()返回由此抽象路径名表示的文件或目录的名称
    public File[] listFiles()返回此抽象路径名表示的目录中的文件和目录的File对象数组
public class FileDemo5{
    public static void main(String[] args) {

        //判断是否为目录
        File file1 = new File("D:\\itheima");
        boolean result1 = file1.isDirectory();
        System.out.println(result1);

        //判断是否为文件
        File file2 = new File("D:\\itheima\\a.txt");
        boolean result2 = file2.isFile();
        System.out.println(result2);

        //判断文件是否存在
        File file3 = new File("D:\\itheima\\a.txt");
        boolean result3 = file3.isFile();
        System.out.println(result3);

    }
}

public class FileDemo6 {
    public static void main(String[] args) {

        File file = new File("D:\\itheima\\a.txt");
        String absolutePath = file.getAbsolutePath();
        System.out.println(absolutePath);

        String path = file.getPath();
        System.out.println(path);

        String name = file.getName();
        System.out.println(name);
        
    }
}

1.6File类练习一【应用】

  • 案例需求

    在当前模块下的aaa文件夹中创建一个a.txt文件

  • 实现步骤

    • 创建File对象,指向aaa文件夹
    • 判断aaa文件夹是否存在,如果不存在则创建
    • 创建File对象,指向aaa文件夹下的a.txt文件
    • 创建这个文件
public class Test1 {
    public static void main(String[] args) throws IOException {
        //创建 aaa目录下的a.txt
        File file = new File("day_11\\aaa");
        if(!file.exists()){
            file.mkdirs();
        }
        File newFile = new File(file,"a.txt");
        newFile.createNewFile();

    }
}
2218549749
关注
专栏目录
可变参数,Stream流
weixin_55800132的博客
04-02 329
1. 可变参数 1.可变参数(应用) 可变参数介绍 可变参数又称参数个数可变,用作方法的形参出现,那么方法参数个数就是可变的了 方法的参数类型已经确定,个数不确定,我们可以使用可变参数 可变参数定义格式 修饰符 返回值类型 方法名(数据类型… 变量名) { } 可变参数的注意事项 这里的变量其实是一个数组 如果一个方法有多个参数,包含可变参数,可变参数要放到最后 可变参数的基本使用 public class ArgsDemo01 { public static void main(Str
【java基础】12-Stream流和File
Nusret的博客
03-22 818
1.可变参数 代码示例 public class ArgsDemo01 { public static void main(String[] args) { System.out.println(sum(10, 20)); System.out.println(sum(10, 20, 30)); System.out.println(sum(10, 20, 30, 40)); System.out.println(sum(10,20
Java学习笔记day19-可变参数-Stream流
在每个领域闪耀
01-01 460
Day19 可变参数 可变参数：就是形参的个数是可以变化的 格式：修饰符 返回值类型 方法名(数据类型… 变量名){} 范例：public static int sum(int… a){} 这里的变量其实是一个数组 如果一个方法有多个参数，包含可变参数，可变参数要放在最后 示例： public class ChangeableTest { public static void main(String[] args) { //调用方法传递数组中的值 int sum
javaSE--进阶十(可变参数,Stream流)
zhenyu93的博客
12-01 250
可变参数 可变参数用在方法的形式参数的位置，它可以看做是一个数组，可以接收多个实际参数。 public static void main(String[] args){ int sum1=getSum(3,4,5); //求3,4,5的和 int sum2=getSum(1,2,3,4,5,6); //求1,2,3,4,5,65的和 int[] array={1,2,3,4,5,6}; int sum2=getSum(array); //求1,2,3,4,
Java不可变集合与Stream流
赵广陆
09-30 1418
目录 1 可变参数 2 创建不可变集合 3 Stream流 3.1 体验Stream流 3.2 Stream流的常见生成方式 3.3 Stream流中间操作方法 3.4 Stream流终结操作方法 3.5 Stream流的收集操作 3.6 Stream流综合练习 1 可变参数 可变参数介绍 可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了 方法的参数类型已经确定,个数不确定,我们可以使用可变参数 可变参数定义格式
java Stream配置
qq_38971066的博客
09-20 649
屏蔽底层消息中间件的差异，降低切换成本，统一消息的编程模型；目前只支持Rabbit MQ、kafka；分为消息生产者、消息消费者。导致原因：默认分组group是不同的，组流水号不一样，被认为不同组，可以消费。该属性可进行持久化，服务挂掉之后，重新连上能获得之前未消费的数据。自定义配置分组，自定义分成同一个组，解决消费问题。配置 group: spectrumrpcA。如果有多个消费者，需要注意重复消费。
java 8 stream reduce参数介绍和详解
一勺菠萝丶的博客
08-13 2125
文章目录简介reduce详解总结 简介 Stream API提供了一些预定义的reduce操作，比如count(), max(), min(), sum()等。如果我们需要自己写reduce的逻辑，则可以使用reduce方法。 本文将会详细分析一下reduce方法的使用，并给出具体的例子。 reduce详解 Stream类中有三种reduce，分别接受1个参数，2个参数，和3个参数，首先来看一个参数的情况： Optional<T> reduce(BinaryOperator<T> a
JAVA-Stream流详解
最新发布
分享，学习，专注，努力，向上。
07-02 3337
Stream（流）是Java 8引入的新特性，它是一种处理集合数据的高级抽象概念。Stream流提供了一种更为简洁、强大和易于使用的方式来操作数据集合，可以进行过滤、映射、排序、聚合等各种操作，同时还支持并行处理，提高了代码的可读性和性能。
PyPI 官网下载 | camelot_py-0.10.0-py3-none-any.whl
02-09
这个名为“camelot_py-0.10.0-py3-none-any.whl”的文件，来源于Python的官方软件包索引（Python Package Index, PyPI），它是camelot库的一个特定版本，专为Python 3设计，可在各种操作系统上运行。 camelot库是...
java11英文api文档,jdk-11.0.5_doc-all.zip
10-27
7. **文件系统和文件I/O**：`java.nio.file`包提供了异步文件操作和路径处理功能，使得处理文件变得更加灵活和高效。 8. **垃圾收集和内存管理**：Java虚拟机（JVM）的内存管理和垃圾收集策略在API文档中也有描述，...
125条常见的java面试笔试题大汇总_java_
09-29
- StringBuilder和StringBuffer：在字符串操作中提供可变性，提高性能。 6. **内存管理** - 内存区域：堆、栈、方法区、本地方法栈、程序计数器。 - 垃圾回收：自动内存管理，如何触发垃圾回收，理解可达性分析...
stream流参数总结
weixin_42596778的博客
11-04 1166
stream常见参数
一篇搞懂java面向对象高级 抽象 接口 多态 object 内部类 包装类 可变参数
qq_43206800的博客
08-26 895
1抽象类 概念： 抽象类必须使用abstract class声明 一个抽象类中可以没有抽象方法。抽象方法必须写在抽象类或者接口中 格式：abstract class 类名 { // 抽象类 } 抽象方法 定义：只声明而未实现的方法称为抽象方法（未实现指的是：没有“{}”方法体）， 抽象方法必须使用abstract关键字声明。 格式： abstract class 类名{ // 抽象类 public abstract void 方法名() ; // 抽象方法，只声明而未实现（没有{}） } 不能被实例化
java--可变参数、不可变集合、stream流
qq_45653018的博客
07-04 189
1、可变参数 理解： 可以在方法中传入不同数量的参数 写法： T…arr public static void method(W w,T...arr){ //方法体 } 底层实现： 一个不固定长度的数组。。。。调用的时候传入的数的个数或者数组就是该有的长度 注意：其他参数要写在可变参数的前面 2、不可变集合 1、List.of(T…arr) 2、Set.of(T…arr) 1、2区别在于Set集合没有重复元素 3、Map.of(键1、值1、键2、值2、键3、值3) 按照一个键一个值的方式，参数必
Java 流(Stream)、文件(File)和IO
奋斗的日子最甜美，在科技的海洋里，永无止境。
11-16 616
Java 流(Stream)、文件(File)和IO Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。 Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。 一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。 Java 为 I/O 提供了强大的而灵活的支持，使其更广
可变参数模板实现可变参数字符串一定程度替代sprintf
Bdyjy的博客
10-11 585
直接看代码： #include <iostream> #include <sstream> #include <string> // 可变参数终结 template <typename T> std::string ArgString(const T& t) { std::stringstream ss; ss << t; return ss.str(); } // 可变参数递归展开 template <typename
java file的用法_Java 关于File使用
weixin_31256263的博客
02-12 539
1.File类1.1.File类说明存储在变量,数组和对象中的数据是暂时的,当程序终止时他们就会丢失.为了能够永久的保存程序中创建的数据,需要将他们存储到硬盘或光盘的文件中.这些文件可以移动,传送,亦可以被其他程序使用.由于数据存储在文件中,所以我们需要学习一个和文件有密切关系的类,叫做File类,将要掌握获取文件的属性以及删除和重命名文件.最终如何向文件中写入数据和从文件中读取数据.那么Fi...
java file 参数_JavaFile类
weixin_42501848的博客
02-24 2221
1 绝对路径和相对路径绝对路径:是一个完整的路径以盘符(C: D:)开始的路径C:\\a.txt相对路径:是一个简化的路径相对是指的是当前的项目根目录(c:)如果使用当前项目的根目录,路径可以简化写成 a.txt路径是不区分大小写的路径中的文件名称分隔符window系统是反斜杠,反斜杠是转义字符,需要使用双反斜杠代表反斜杠2 File类的三种构造方法File(String pathname)通过将...
Java Stream流（详解）
热门推荐
m0_60489526的博客
08-29 7万+
一、Stream流引入 Lambda表达式，基于Lambda所带来的函数式编程，又引入了一个全新的Stream概念，用于解决集合类库既有的鼻端。（Lambda表达式详解在上篇博客内容） 现有一个需求： 将list集合中姓张的元素过滤到一个新的集合中 然后将过滤出来的姓张的元素中，再过滤出来长度为3的元素，存储到一个新的集合中 1.用常规方法解决需求 /...
Java入门：Stream流详解与实例
Java Stream API的引入使得处理集合数据变得更加简洁、高效。通过熟练掌握Stream API，开发者能够编写出更具可读性和性能优势的代码。在实际开发中，灵活运用Stream可以帮助我们更好地解决复杂的数据处理问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值