java8新特性从入门到应用 第二章 Streams数据流

最新推荐文章于 2023-01-03 21:06:25 发布
最新推荐文章于 2023-01-03 21:06:25 发布
阅读量236 收藏 1
点赞数
分类专栏： Java8新特性 java8新特性从入门到应用 文章标签： java8 Stream java8特性
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/madmk/article/details/83379185
版权

java8新特性从入门到应用 第二章 Stream 数据流

此流非彼流，估计第一眼看到这个标题的同学会将Streams当作InputStream或OutputStream 的兄弟，其实不然，Streams只是借用了流的概念，和原本的输入输出流是完全不同的东西。

本文代码及API部分转载自幸运的天才小驴

特点介绍
  1. Stream是对一系列集合进行操作的api
  2. 使用FunctionalInterface接口作为参数，可以直接使用Lambda，直观易懂
  3. Stream采用管道式api进行操作（指返回类型是类本身类型的方法，这类方法可以一直点下去从而省去中间声明命名等过程，使得写出来的代码更具可读性）。
  4. Stream的源可以是无限的(难以理解？其实就是根据设置一定的规则Stream将按规则 源源不断的生成数据)。
  5. Stream只能使用一次，当出现终端操作的时候Streams就会被消耗完（Stream不可复用）。
  6. Stream只循环一次，无论有多少中间操作。

你可以简单的将Stream的概念先理解成循环，然后在向下阅读，比较循环和Stream的异同，自然而然就可以学会了，（某些的大佬的解释是很严谨，但刚看时反而理解不上去）

Stream组成

Stream有3部分组成

  1. 源：指创建一个Stream的部分，有且只有一个
    相当于你想要循环的数据 比如你想循环一个数组，那么这个数组就是源
  2. 中间操作：指返回值是自己本身或另一个Stream的部分，可以有零到多个。
    相当于循环体，你想对循环的数据作什么，判断？、计算？ 这都叫中间操作
  3. 终端：用于启动流的运行并产生结果或副作用。
    就是循环完成了你想干什么， 求和？查找？ 这就是终端
源

指创建一个Stream，可以从多种数据类型中进行创建

  1. 直接创建
Stream stream=Stream.of("1","2","3");
Stream stream=Stream.generate(Math::random);
  1. 从Collection (List,Set) 中产生
Collection list=new ArrayList();
Stream stream=list.stream();
  1. 将数组转为Stream
String[] arr={"1","2","3"};
Stream stream=Stream.of(arr);
Stream stream=Arrays.stream(arr);

ps: 只要api支持很多类都可以直接转成 Stream

中间操作

所谓中间操作就是一系列Api的集合
`以下内容非原创 原文地址：幸运的天才小驴
多个 中间操作 可以连接起来形成一个流水线，除非流水 线上触发终止操作，否则中间操作不会执行任何的处理! 而在终止操作时一次性全部处理，称为“惰性求值”.

筛选与切片
方法描述
filter(Predicate p)从流中排除某些元素
distinct()通过流元素的 hashCode() 和 equals() 对流进行去重
limit(long maxSize)截断流，使其元素不超过给定数量
skip(long n)跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素 不足 n 个，则返回一个空流。与 limit(n) 互补

案例：

定义一个集合： Employee 重写 hashcode ， equals — 去重时使用

List<Employee> emps = Arrays.asList(
          new Employee(101, "林青霞", 28, 9889.99),
          new Employee(102, "东方不败", 29, 4329.85),
          new Employee(103, "周星驰", 40, 1233.88),
          new Employee(104, "大圣", 500, 5000.44),
          new Employee(105, "张无忌", 15, 3000.09),
          new Employee(102, "东方不败", 29, 4329.85)
  );

执行操作：
内部迭代 - 迭代操作由Stream API 完成操作

public void test2() {
    // 中间操作不会做任何处理
    Stream<Employee> stream = emps.stream()
            .filter((e) -> {
                System.out.println("惰性求值");
                return e.getAge() < 30;
            });
    System.out.println("--------------------");

    // 终止操作，一次性执行全部功能， 称为 "惰性求值"
    stream.forEach(System.out::println);
}

执行结果：

--------------------
惰性求值
Employee{id=101, name='林青霞', age=28, salary=9889.99, status=null}
惰性求值
Employee{id=102, name='东方不败', age=29, salary=4329.85, status=null}
惰性求值
惰性求值
惰性求值
Employee{id=105, name='张无忌', age=15, salary=3000.09, status=null}
惰性求值
Employee{id=102, name='东方不败', age=29, salary=4329.85, status=null}

**外部迭代 **

@Test
public void test3() {
     Iterator<Employee> iterator = emps.iterator();

     while (iterator.hasNext()) {
         System.out.println(iterator.next());
     }
 }

执行结果：

Employee{id=101, name='林青霞', age=28, salary=9889.99, status=null}
Employee{id=102, name='东方不败', age=29, salary=4329.85, status=null}
Employee{id=103, name='周星驰', age=40, salary=1233.88, status=null}
Employee{id=104, name='大圣', age=500, salary=5000.44, status=null}
Employee{id=105, name='张无忌', age=15, salary=3000.09, status=null}
Employee{id=102, name='东方不败', age=29, salary=4329.85, status=null}

**中间操作 - 截断流 **

@Test
public void test4() {
     emps.stream()
             .filter(employee -> employee.getAge() < 30) // 过滤年龄小于30的人
             .limit(1) // 截取一个
             .forEach(System.out::println);
 }

执行结果：

Employee{id=101, name='林青霞', age=28, salary=9889.99, status=null}

**中间操作 - 跳过 ** ps: 不是让你跳过

@Test
public void test5() {

     emps.stream()
             .filter(employee -> employee.getAge() < 30)
             .skip(2)
             .forEach(System.out::println);
 }

执行结果：

Employee{id=105, name='张无忌', age=15, salary=3000.09, status=null}
Employee{id=102, name='东方不败', age=29, salary=4329.85, status=null}

**中间操作 - 筛选去重 **

@Test
public void test6() {
     emps.stream()
             .distinct()
             .forEach(System.out::println);
 }

执行结果：

Employee{id=101, name='林青霞', age=28, salary=9889.99, status=null}
Employee{id=102, name='东方不败', age=29, salary=4329.85, status=null}
Employee{id=103, name='周星驰', age=40, salary=1233.88, status=null}
Employee{id=104, name='大圣', age=500, salary=5000.44, status=null}
Employee{id=105, name='张无忌', age=15, salary=3000.09, status=null}
映射

只介绍map 其他4个和map大同小异

方法描述
map(Function f)接收一个函数作为参数，该函数会被应用到每个元 素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f)接收一个函数作为参数，该函数会被应用到每个元 素上，产生一个新的 DoubleStream。
mapToInt(ToIntFunction f)接收一个函数作为参数，该函数会被应用到每个元 素上，产生一个新的 IntStream。
mapToLong(ToLongFunction f)接收一个函数作为参数，该函数会被应用到每个元 素上，产生一个新的 LongStream。
flatMap(Function f)接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

案例：
map操作

 public void test7() {
     List<String> list = Arrays.asList("aaa", "java", "ccc", "java8", "hello world");

     list.stream()
             .map((x) -> x.toUpperCase())
             .forEach(System.out::println);

     System.out.println("-------------");

     emps.stream()
             .map(Employee::getAge)
             .forEach(System.out::println);
 }

执行结果：

AAA
JAVA
CCC
JAVA8
HELLO WORLD
-------------
28
29
40
500
15
29

flatMap操作
先定义一个 filterCharacter(String str) 方法：

private static Stream<Character> filterCharacter(String str) {
        List<Character> characters = new ArrayList<>();

        for (Character character : str.toCharArray()) {
            characters.add(character);
        }
        return characters.stream();
    }

执行测试代码：

@Test
public void test8() {
    List<String> list = Arrays.asList("aaa", "hello world");

    Stream<Stream<Character>> streamStream = list.stream()
            .map(LambdaStramAPI::filterCharacter);

    streamStream.forEach((s) -> {
        s.forEach((c) -> System.out.println(c + ""));
        System.out.println();
    });

    System.out.println("----------------------");

    list.stream()
            .flatMap(LambdaStramAPI::filterCharacter)
            .forEach(System.out::println);


}

执行结果：

a
a
a

h
e
l
l
o

w
o
r
l
d

----------------------
a
a
a
h
e
l
l
o

w
o
r
l
d
排序
方法描述
sorted()产生一个新流，其中按自然顺序排序
sorted(Comparator comp)产生一个新流，其中按比较器顺序排序

案例：

@Test
public void test9() {
    emps.stream()
            .map(Employee::getSalary)
            .sorted()
            .forEach(System.out::println);

    System.out.println("-----------------");

    emps.stream()
            .map(Employee::getAge)
            .sorted(Integer::compare)
            .forEach(System.out::println);
}

执行结果：

1233.88
3000.09
4329.85
4329.85
5000.44
9889.99
-----------------
15
28
29
29
40
500
Stream的终止操作

终止操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如:List、Integer，甚至是 void 。

查找与匹配
方法描述结果
allMatch(Predicate p)检查是否匹配所有元素boolean
anyMatch(Predicate p)检查是否至少匹配一个元素boolean
noneMatch(Predicate p)检查是否没有匹配所有元素boolean
findFirst()返回第一个元素T
findAny()返回当前流中的任意元素T
count()返回流中元素总数long
max(Comparator c)返回流中最大值T
min(Comparator c)返回流中最小值T
forEach(Consumer c)内部迭代(使用 Collection 接口需要用户去做迭 代，称为外部迭代。相反，Stream API 使用内部 迭代——它帮你把迭代做了)void

案例：
匹配

public void test10() {
    boolean allMatch = emps.stream()
            .allMatch((employee -> employee.getName().equals("林青霞")));
    System.out.println(allMatch);

    System.out.println("-----------------");

    boolean anyMatch = emps.stream()
            .anyMatch(employee -> employee.getName().equals("林青霞"));
    System.out.println(anyMatch);

    System.out.println("-----------------");

    boolean noneMatch = emps.stream()
            .noneMatch(employee -> employee.getName().equals("林青霞"));
    System.out.println(noneMatch);
}

执行结果：

false
-----------------
true
-----------------
false

**第一个元素 、 任意一个元素 **

public void test12() {
    Optional<String> first = emps.stream()
            .map(Employee::getName)
            .sorted()
            .findFirst(); // 获取第一个元素
    System.out.println(first.get());

    System.out.println("-----------------");

    Optional<Employee> findAny = emps.parallelStream()
            .filter(employee -> employee.getName().equals("林青霞"))
            .findAny(); //任意一个元素
    System.out.println(findAny.get());
}

执行结果：

东方不败
-----------------
Employee{id=101, name='林青霞', age=28, salary=9889.99, status=null}

**统计总个数、 最大、 最小值 **

public void test13() {
    Stream<Employee> stream = emps.stream();
    long count = stream.count();
    System.out.println(count);

    System.out.println("-----------------");

    Optional<Double> doubleOptional = emps.stream()
            .map(Employee::getSalary)
            .max(Double::compare); //最大值
    System.out.println(doubleOptional.get());

    System.out.println("-----------------");

    Optional<Employee> employeeOptional = emps.stream()
            .min((x, y) -> Double.compare(x.getSalary(),  y.getSalary())); // 最小值
    System.out.println(employeeOptional.get());
}

执行结果：

6
-----------------
9889.99
-----------------
Employee{id=103, name='周星驰', age=40, salary=1233.88, status=null}
归约

ps: map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它 来进行网络搜索而出名。 --转载自幸运的天才小驴

方法描述
reduce(T iden, BinaryOperator b)可以将流中元素反复结合起来，得到一个值。 返回 T
reduce(BinaryOperator b)可以将流中元素反复结合起来，得到一个值。 返回 Optional< T>

案例：
求和

@Test
public void test14() {
     List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

     Integer sum = list.stream()
             .reduce(0, (x, y) -> x + y);
     System.out.println(sum);
 }

执行结果：

55

计算次数

public void test15() {
    Optional<Double> doubleOptional = emps.stream()
            .map(Employee::getSalary)
            .reduce(Double::max);
    System.out.println(doubleOptional);

    System.out.println("-----------------");

    //查看 东方不败 出现的次数 -- 【此处还有点毛病】
    Optional<Integer> sumOptional = emps.stream()
            .map(Employee::getName)
            .flatMap(LambdaStramAPI::filterCharacter)
            .map((c) -> {
                if (c.equals("东")) return 1;
                else return 0;
            }).reduce(Integer::sum);
    System.out.println(sumOptional.get());
}

执行结果：

Optional[9889.99]
-----------------
0
收集
方法描述
collect(Collector c)将流转换为其他形式。接收一个 Collector接口的 实现，用于给Stream中元素做汇总的方法

案例：

public void test16(){
   List<String> collect = emps.stream()
           .map(Employee::getName)
           .collect(Collectors.toList());
   collect.forEach(System.out::println);

   System.out.println("-------------------");

   Set<String> set = emps.stream()
           .map(Employee::getName)
           .collect(Collectors.toSet());
   set.forEach(System.out::println);

   System.out.println("-------------------");

   HashSet<String> hashSet = emps.stream()
           .map(Employee::getName)
           .collect(Collectors.toCollection(HashSet::new));
   hashSet.forEach(System.out::println);
}

执行结果：

林青霞
东方不败
周星驰
大圣
张无忌
东方不败
-------------------
周星驰
林青霞
大圣
东方不败
张无忌
-------------------
周星驰
林青霞
大圣
东方不败
张无忌

**收集统计 **

 public  void test17(){
     // 统计总个数
     Long count = emps.stream()
             .collect(Collectors.counting());
     System.out.println(count);

     System.out.println("-------------------");

     // 求平均值
     Double avg = emps.stream()
             .collect(Collectors.averagingDouble(Employee::getSalary));
     System.out.println(avg);

     System.out.println("-------------------");

     // 求和
     Double sum = emps.stream()
             .collect(Collectors.summingDouble(Employee::getSalary));
     System.out.println(sum);

     System.out.println("-------------------");

     //求最大值
     Optional<Employee> max = emps.stream()
             .collect(Collectors.maxBy((x, y) -> Double.compare(x.getSalary(), y.getSalary())));
     System.out.println(max.get());

     System.out.println("-------------------");

     //求最小值
     Optional<Double> min = emps.stream()
             .map(Employee::getSalary)
             .collect(Collectors.minBy(Double::compare));
     System.out.println(min.get());


     System.out.println("-------------------");

     //统计分析
     DoubleSummaryStatistics doubleSummaryStatistics = emps.stream()
             .collect(Collectors.summarizingDouble(Employee::getSalary));
     System.out.println(doubleSummaryStatistics.getAverage());

     System.out.println("-------------------");

     //拼接
     String join = emps.stream()
             .map(Employee::getName)
             .collect(Collectors.joining(",", "--", "--"));
     System.out.println(join);
 }

执行结果：

6
-------------------
4630.683333333333
-------------------
27784.1
-------------------
Employee{id=101, name='林青霞', age=28, salary=9889.99, status=null}
-------------------
1233.88
-------------------
4630.683333333333
-------------------
--林青霞,东方不败,周星驰,大圣,张无忌,东方不败--

**收集-分组 **

public  void test18(){
    Map<String, List<Employee>> group = emps.stream()
            .collect(Collectors.groupingBy(Employee::getName));
    System.out.println(group);
}

执行结果：

{
周星驰=[Employee{id=103, name='周星驰', age=40, salary=1233.88, status=null}], 
林青霞=[Employee{id=101, name='林青霞', age=28, salary=9889.99, status=null}], 
大圣=[Employee{id=104, name='大圣', age=500, salary=5000.44, status=null}], 
东方不败=[
Employee{id=102, name='东方不败', age=29, salary=4329.85, status=null}, 
Employee{id=102, name='东方不败', age=29, salary=4329.85, status=null}
], 
张无忌=[Employee{id=105, name='张无忌', age=15, salary=3000.09, status=null}]}

**收集-多级分组 **

public void test19(){
    Map<String, Map<String, List<Employee>>> group = emps.stream()
            .collect(Collectors.groupingBy(Employee::getName, Collectors.groupingBy((e) -> {
                if (e.getAge() < 30) return "青年";
                else if (e.getAge() < 50) return "中年";
                else return "老年";
            })));
    System.out.println(group);
}

执行结果：

{周星驰={中年=[Employee{id=103, name='周星驰', age=40, salary=1233.88, status=null}]}, 
林青霞={青年=[Employee{id=101, name='林青霞', age=28, salary=9889.99, status=null}]}, 
大圣={老年=[Employee{id=104, name='大圣', age=500, salary=5000.44, status=null}]}, 
东方不败={青年=[
Employee{id=102, name='东方不败', age=29, salary=4329.85, status=null}, 
Employee{id=102, name='东方不败', age=29, salary=4329.85, status=null}
]}, 
张无忌={青年=[Employee{id=105, name='张无忌', age=15, salary=3000.09, status=null}]}}

Collector 接口中方法的实现决定了如何对流执行收集操作(如收 集到 List、Set、Map)。但是 Collectors 实用类 供了很多静态 方法，可以方便地创建常见收集器实例，具体方法与实例如下表:

Collector 接口API
方法返回类型作用
toListList把流中元素收集到List
toSetSet把流中元素收集到Set
toCollectionCollection把流中元素收集到Set
countingLong计算流中元素的个数
summingIntInteger对流中元素的整数属性求和
averagingIntDouble计算流中元素Integer属性的平均 值
summarizingIntIntSummaryStatistics收集流中Integer属性的统计值。 如:平均值
joiningString连接流中每个字符串
maxByOptional根据比较器选择最大值
minByOptional根据比较器选择最小值
reducing归约产生的类型从一个作为累加器的初始值 开始，利用BinaryOperator与 流中元素逐个结合，从而归 约成单个值
collectingAndThen转换函数返回的类型包裹另一个收集器，对其结 果转换函数
groupingByMap<K, List>根据某属性值对流分组，属 性为K，结果为V
partitioningByMap<Boolean, List>根据true或false进行分组
madmk
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Collectors.summingDouble()
技匠而已
09-04 6768
Collectors.summingDouble() Java 8 流的新类 java.util.stream.Collectors 实现了 java.util.stream.Collector 接口，同时又提供了大量的方法对流 ( stream ) 的元素执行 map and reduce 操作，或者统计操作。 Collectors.summingDouble() 方法将流中的所有元素视为 Double类型，并计算所有元素的总和 ( sum ) summingDoubleExample代码 @Test
通过自定义收集器解决Collectors.summingDouble计算精度丢失问题
最新发布
弹指天下
04-13 2452
1、自定义收集器Collectorreturn Collector . of(//1、结果容器() -> new BigDecimal [ 1 ] , //2、累加器(result , item) -> {if(item!= 0) {= null) {} else {} } } , //3、并行计算时的合并器(result1 , result2) -> {} , //4、结果转换 total -> total [ 0 ] . doubleValue());2、通过自定义收集器计算。
java8之CollectorsAPI详解(带实例)04
weixin_39715061的博客
03-09 2719
写给自己避免忘掉:private static void testSummingDouble() { System.out.println("testSummingDouble"); Optional.of(menu.stream().collect(Collectors.summingDouble(Dish::getCalories))) .ifPrese...
Java8中Collectors的使用
weixin_44316557的博客
10-27 889
Java8中Collectors的使用
01、Java 8 - 收集器 – java.util.stream.Collectors
qq_33291299的博客
01-03 1049
Java 8 流的新类 java.util.stream.Collectors 实现了 java.util.stream.Collector 接口，同时又提供了大量的方法对流 ( stream ) 的元素执行 map and reduce 操作，或者统计操作。
Java8新特性终极指南Java开发Java经验技巧共27
11-21
8. **并行流（Parallel Streams）**：Stream API的并行流特性允许开发者利用多核处理器的优势，通过并行处理提高性能。只需简单地调用`.parallel()`，流操作就能自动并行化。 9. ** Nashorn JavaScript引擎**：Java...
Java8 新特性
04-27
Java8是Java编程语言的一次重大更新，引入了许多新的特性和功能，极大地提升了开发效率和代码的可读性。以下是一些主要的Java8新特性详解： 1. **Lambda表达式**：Lambda表达式是Java8中最显著的新特性，它为Java...
Java8Streams:Java8流
04-29
2.流接口Java 8中的Stream是一种以声明方式迭代数据集合的更为方便的替代方法。 流的优点是它们可以顺序或并行处理。 关于所执行的操作，它们是两种类型。 中间操作：执行过滤或转换。 终端操作：产生结果。 中间...
Java8新特性代码
12-21
Java 8是Java编程语言的一个重大更新，引入了许多新的特性和功能，极大地提高了开发效率和代码的可读性。以下是对这些新特性的详细解析： 1. **lambda表达式**：这是Java 8最重要的特性之一，它使得函数式编程成为...
redis-streams-101-java：Redis Streams和Java入门
02-04
Redis Streams和Java入门 该项目显示了如何使用使用使用者组来发布和使用消息。 这是使用单个使用者的第一个基本示例。 建立 > cd redis-streams-101-java > mvn clean verify 跑 运行生产者 > cd redis-streams-...
java8中Collectors收集器的使用
zpflwy1314的博客
04-27 985
Collectors 实现了接口 Collector<T,A,R> 收集器将strom结果进行收集 T: 需要进行reduce操作的元素类型 A:reduce操作的动态集合类型 R:reduce操作的结果类型 举例 //将名字集合到list List<String> list = people.stream().map(Person::getName).collec...
Stream中Collectors.groupingBy toMap mapping操作实例
热门推荐
徐海兴的专栏
07-20 2万+
groupingBy用于分组，toMap用于list转map 测试代码： 1.建一个实体类，测试中用 package com.xhx.java; /** * xuhaixing * 2018/7/20 21:43 **/ public class Student { private String name; private String sex; priva...
Java 笔记
zhanghengchao123的博客
05-09 435
JavaList深拷贝list分段截取数据Streamlist去重 查重 List 深拷贝 public class ListDeepCopy { public static <T> List<T> deepCopy(List<T> src) throws IOException, ClassNotFoundException { ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); O
Java8的Stream中的Collectors操作求double类型和的坑
故事码的博客
07-17 3575
Java8的Stream中的Collectors操作求double类型和的坑 无敌踩坑王的我又双叒叕来了！！！！！！ 例子： @Test public void testSumDouble() { double a = 0.001; double b = 0.002; double c = 0.004; List<Double> doubleList = new ArrayList<>();
Java8 测试串行流stream 并行流parallelStream 以及 Collectors.summingDouble
xianjinyao的博客
11-05 6220
public void testParallelStream() { List&lt;Double&gt; doubleList = Stream.generate(Math::random).limit(1000000).collect(Collectors.toList()); long time1 = System.currentTimeMillis(); dou...
lambda表达式操作三——Collectors的方法操作测试集合
tj的博客
12-07 467
Collectors的方法操作测试集合
Java 8实战（九）- Collectors收集器
及时当勉励，岁月不待人
09-22 2421
Java 8实战（九）- Collectors收集器
Stream的简单学习（三）之Collectors的简单用法
果咩
07-07 2010
首先创建我们的数据 ArrayList<User> users = new ArrayList<>(); users.add(new User("张1",10)); users.add(new User("张2",40)); users.add(new User("张3",20)); users.add(new User("张4",30)); users.add(new User("张5",30)); 以下操作都是在collect里进行 【Collectors.toList】：转化
Java8中Collectors详解
scofen的博客
03-10 2563
文章目录 1.averagingDouble 2.collectingAndThen 3.counting 4.groupingBy 4.1groupingBy(Function) 4.2groupingBy(Function, Collector) 4.3groupingBy(Function, Supplier, Collector) 5.groupingByConcurrent 5.1gro...
JavaEE基础教程：第8章 Java输入输出流详解
3. 字节流（Byte Streams）：Java中的字节流包括字节输入流和字节输出流，用于处理任何类型的原始数据（如图像、音频或二进制文件）。基本的字节流类包括`InputStream`和`OutputStream`，它们是所有字节流的基类，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值