stream详解

已于 2024-03-20 14:52:57 修改
阅读量1.4k 收藏 16
点赞数 4
分类专栏： Java 文章标签： java servlet jvm
于 2022-08-02 10:58:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43454016/article/details/126118154
版权

Java中的Stream流

公司中用了很多Stream流，经常用来筛选出PO类型的List中想要的数据，所以还是比较常用的。

Stream是Java8的新成员，允许以声明式方式处理数据集合

  • 代码简洁：函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。

  • 多核友好：Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下方法。

  1. 把集合转换为流stream

  2. 操作stream流 stream流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果

有两种操作符

  1. 中间操作符
  2. 终止操作符
中间操作符
流方法含义示例
filter用于通过设置的条件过滤出元素List strings = Arrays.asList(“abc”, “”, “bc”, “efg”, “abcd”,“”, “jkl”);List filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
distinct返回一个元素各异（根据流所生成元素的hashCode和equals方法实现）的流。List numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);numbers.stream().filter(i -> i % 2 == 0).distinct().forEach(System.out::println);
limit会返回一个不超过给定长度的流。List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”);List limited = strings.stream().limit(3).collect(Collectors.toList());
skip返回一个扔掉了前n个元素的流。List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”);List skiped = strings.stream().skip(3).collect(Collectors.toList());
map接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素（使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一个新版本”而不是去“修改”）。List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”);List mapped = strings.stream().map(str->str+“-itcast”).collect(Collectors.toList());
flatMap使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流。List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”);Stream flatMap = strings.stream().flatMap(Java8StreamTest::getCharacterByString);
sorted返回排序后的流List strings1 = Arrays.asList(“abc”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);List sorted1 = strings1.stream().sorted().collect(Collectors.toList());
/**
 * 功能描述:根据条件过滤集合数据  filter
 * @return : void
 */
@Test
public void filter(){
    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
    List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
    out.println(filtered);
}
/**
 * 功能描述:去除集合中重复数据  distinct
 * @return : void
 */
@Test
public void distinct(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    List<String> distincted = strings.stream().distinct().collect(Collectors.toList());
    out.println(distincted);
}
/**
 * 功能描述:指定获取集合前x条数据，重新构造一个新的集合  limit
 * @return : void
 */
@Test
public void limit(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    List<String> limited = strings.stream().limit(3).collect(Collectors.toList());
    out.println(limited);
}
/**
 * 功能描述:排除集合前x条数据，把后面的数据重新构造一个新的集合  skip
 * @return : void
 */
@Test
    public void skip(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    List<String> skiped = strings.stream().skip(3).collect(Collectors.toList());
    out.println(skiped);
}
/**
 * 功能描述:对集合中所有元素统一处理  map
 * @return : void
 */
@Test
public void map(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    List<String> mapped = strings.stream().map(str->str+"-itcast").collect(Collectors.toList());
    out.println(mapped);
}
/**
 * 功能描述:对集合中所有元素统一处理  flatMap
 * @return : void
 */
@Test
public void flatMap(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    Stream<String> stringStream = strings.stream().map(x -> x);
    Stream<String> stringStream1 = strings.stream().flatMap(x -> Arrays.asList(x.split(" ")).stream());
}
/**
 * 功能描述 : 对集合进行排序  sorted
 * @return : void
 */
@Test
public void sorted(){
    List<String> strings1 = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    List<String> strings2 = Arrays.asList("张三", "李四", "王五", "赵柳", "张哥","李哥", "王哥");
    List<Integer> strings3 = Arrays.asList(10, 2, 30, 22, 1,0, -9);
    List<String> sorted1 = strings1.stream().sorted().collect(Collectors.toList());
    List<String> sorted2 = strings2.stream().sorted(Collections.reverseOrder(Collator.getInstance(Locale.CHINA))).collect(Collectors.toList());
    List<Integer> sorted3 = strings3.stream().sorted().collect(Collectors.toList());
    out.println(sorted1);
    out.println(sorted2);
    out.println(sorted3);
}

Map和flatMap的区别

map：对流中每一个元素进行处理

flatMap：流扁平化，让你把一个流中的“每个值”都换成另一个流，然后把所有的流连接起来成为一个流

  • 总结：map是对一级元素进行操作，flatmap是对二级元素操作。

  1. 本质区别：map返回一个值；flatmap返回一个流，多个值。

  2. 应用场景：map对集合中每个元素加工,返回加工后结果；flatmap对集合中每个元素加工后，做扁平化处理后（拆分层级，放到同一层）然后返回

/**
 * 方法一
 * 功能描述:  通过使用map、flatMap把字符串转换为字符输出对比区别
 * @return : void
 */
@Test
public void flatMap2Map(){
    List<String> strings = Arrays.asList("abc", "abc", "bc", "efg", "abcd","jkl", "jkl");
    final Stream<Character> flatMap = strings.stream().flatMap(Java8StreamTest::getCharacterByString);
    flatMap.forEach(System.out::println);
    //----------------------------------------------
    final Stream<Stream<Character>> mapStream = strings.stream().map(Java8StreamTest::getCharacterByString);
    //mapStream.forEach(System.out::println);
    out.println("------------------------------------------------");
    mapStream.forEach(stream-> {stream.forEach(character->{System.out.println(character);});});

}
公共方法（字符串转换为字符流）
/**
* 功能描述:字符串转换为字符流
* @param str
* @return : java.util.stream.Stream<java.lang.Character>
*/
public static Stream<Character> getCharacterByString(String str) {
    List<Character> characterList = new ArrayList<>();
    for (Character character : str.toCharArray()) {
    	characterList.add(character);
    }
    return characterList.stream();
}
终止操作符
流方法含义示例
anyMatch检查是否至少匹配一个元素，返回boolean。List strings = Arrays.asList(“abc”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);boolean b = strings.stream().anyMatch(s -> s == “abc”);
allMatch检查是否匹配所有元素，返回boolean。List strings = Arrays.asList(“abc”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);boolean b = strings.stream().allMatch(s -> s == “abc”);
noneMatch检查是否没有匹配所有元素，返回boolean。List strings = Arrays.asList(“abc”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);boolean b = strings.stream().noneMatch(s -> s == “abc”);
findAny将返回当前流中的任意元素。List strings = Arrays.asList(“cv”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);Optional any = strings.stream().findAny();
findFirst返回第一个元素List strings = Arrays.asList(“cv”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);Optional first = strings.stream().findFirst();
forEach遍历流List strings = Arrays.asList(“cv”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);strings.stream().forEach(s -> out.println(s));
collect收集器，将流转换为其他形式。List strings = Arrays.asList(“cv”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);Set set = strings.stream().collect(Collectors.toSet());List list = strings.stream().collect(Collectors.toList());Map<String, String> map = strings.stream().collect(Collectors.toMap(v ->v.concat(“_name”), v1 -> v1, (v1, v2) -> v1));
reduce可以将流中元素反复结合起来，得到一个值。List strings = Arrays.asList(“cv”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);Optional reduce = strings.stream().reduce((acc,item) -> {return acc+item;});if(reduce.isPresent())out.println(reduce.get());
count返回流中元素总数。List strings = Arrays.asList(“cv”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”);long count = strings.stream().count();
/**
 * 功能描述 : 判断集合中是否至少存在一个元素满足条件
 * @return : void
 */
@Test
public void anyMatch(){
    List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    boolean b = strings.stream().anyMatch(s -> s == "abc");
    out.println(b);
}
/**
 * 功能描述 : 判断集合中是否所有元素都满足条件
 * @return : void
 */
@Test
public void allMatch(){
    List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    boolean b = strings.stream().allMatch(s -> s == "abc");
    out.println(b);
}
/**
 * 功能描述 : 判断集合中是否所有元素都不满足条件
 * @return : void
 */
@Test
public void noneMatch(){
    List<String> strings = Arrays.asList("abc", "abd", "aba", "efg", "abcd","jkl", "jkl");
    boolean b = strings.stream().noneMatch(s -> s == "abc");
    out.println(b);
}
/**
 * 功能描述 : 返回当前流中任意元素
 * @return : void
 */
@Test
public void findAny(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    Optional<String> any = strings.stream().findAny();
    if(any.isPresent()) out.println(any.get());
}
/**
 * 功能描述 : 返回当前流中第一个元素
 * @return : void
 */
@Test
public void findFirst(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    Optional<String> first = strings.stream().findFirst();
    if(first.isPresent()) out.println(first.get());
}
/**
 * 功能描述 : 遍历流
 * @return : void
 */
@Test
public void foreach(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    strings.stream().forEach(s -> out.println(s));
}
/**
 * 功能描述 : 流转换为其他形式
 * @return : void
 */
@Test
public void collect(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    Set<String> set = strings.stream().collect(Collectors.toSet());
    List<String> list = strings.stream().collect(Collectors.toList());
    Map<String, String> map = strings.stream().collect(Collectors.toMap(v ->v.concat("_name"), v1 -> v1, (v1, v2) -> v1));
    out.println(set);
    out.println(list);
    out.println(map);
}
/**
 * 功能描述 : 将流中元素反复结合起来，得到一个值
 * @return : void
 */
@Test
public void reduce(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    //reduce方法一
    Optional<String> reduce1 = strings.stream().reduce((acc,item) -> {return acc+item;});
    //reduce方法二
    String reduce2 = strings.stream().reduce("itcast", (acc, item) -> {
    	return acc + item;
    });
    //reduce方法三
    ArrayList<String> reduce3 = strings.stream().reduce(
        new ArrayList<String>(),
   		new BiFunction<ArrayList<String>, String, ArrayList<String>>() {
    		@Override
    		public ArrayList<String> apply(ArrayList<String> acc, String item) {
    			acc.add(item);
    			return acc;
    		}
    	}, 
        new BinaryOperator<ArrayList<String>>() {
   			@Override
    		public ArrayList<String> apply(ArrayList<String> acc, ArrayList<String> item) {
    		return acc;
    		}
    	}
    );
    if(reduce1.isPresent())out.println(reduce1.get());
    out.println(reduce2);
    out.println(reduce3);
}
/**
* 功能描述 : 返回流中元素总数
* @return : void
*/
@Test
public void count(){
    List<String> strings = Arrays.asList("cv", "abd", "aba", "efg", "abcd","jkl", "jkl");
    long count = strings.stream().count();
    out.println(count);
}
幽幽唉
关注
专栏目录
Java8 Stream详解
HappyHeng的博客
10-16 2万+
Java8中提供了Stream对集合操作作出了极大的简化，学习了Stream之后，我们以后不用使用for循环就能对集合作出很好的操作。 一、流的初始化与转换：   Java中的Stream的所有操作都是针对流的，所以，使用Stream必须要得到Stream对象：   1、初始化一个流：     Stream stream = Stream.of("a", "b", "c");
集合处理常用Stream流
qq_1763467007的博客
07-06 1564
Stream API是Java 8引入的一项重要特性，它提供了一种新的处理集合数据的方式。Stream可以看作是一种高级的迭代器，它允许以声明式的方式对集合进行各种操作，如过滤、映射、排序、归约等。它可以简化集合处理的代码，并且在处理大数据集时具有性能优势。filter(Predicate predicate) map(Function mapper) flatMap(Function mapper) distinct() sorted() limit(long
JDK8之Stream流
bluede2015的博客
04-01 980
Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工 处理。
【JAVA】java 中的Stream 常用函数
最新发布
代码的魅力，根本走不出来
04-25 1179
Java中的Stream是一种用于处理集合元素的工具，它提供了一种流式操作的方式，可以轻松地对集合进行过滤、映射、聚合等操作，以及进行并行处理。Stream是Java 8引入的一种新的抽象概念，它代表了一种数据元素的序列。Stream不是数据结构，而是数据元素的流水线，可以进行一系列的操作来处理这些元素。
Jdk8 之 Stream流详细用法(一)
木字楠的博客
11-14 3736
本篇文章参考云深i不知处的文章 原文链接：https://blog.csdn.net/mu_wind/article/details/109516995 一、概述   Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方
Stream概述
madleep的博客
08-22 1922
文章目录一、Stream是什么？二、初步应用1.代码示例2.结果总结 一、Stream是什么？ Stream是一个高级迭代器，它不是数据结构，不能存储数据。它可以用来实现内部迭代，内部迭代相比平常的外部迭代，它可以实现并行求值（高效，外部迭代要自己定义线程池实现多线程来实现高效处理）、惰性求值（中没有终止操作，中间操作是不会执行的）、短路操作（拿到正确的结果就返回，不需要等到整个过程完成之后）等 二、初步应用 1.代码示例 代码如下（示例）： public class StreamDemo1 { p
stream流的常用方法
热门推荐
weixin_44702189的博客
08-04 1万+
Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。Stream中间操作：·每次返回一个新的流，可以有多个。终端操作：每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。Streamstream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。stream不会改变数据源，通常情况下会产生一个新的集合或一个值。......
Java Stream 详解
05-25
Java Stream 详解
JDK 1.8 新特性之Stream 详解.md
10-22
Stream
Java8-Stream详解
12-21
Java 8 引入的 Stream API 是一个强大的新特性，极大地提升了处理集合数据的效率和灵活性。Stream 可以理解为一个元素序列，它支持高度灵活的聚合操作，类似于 SQL 查询，但应用于内存中的数据。以下是对 Stream API...
vb adodb.stream 详解
01-27
vb adodb stream aeecss adodb resouse recordset
Java8 Stream详解.md
05-05
Java8 Stream详解.md
JDK8新特性之stream流
m0_74315688的博客
06-23 357
欢迎关注辉辉，持续更新中~
Java8新特性：StreamAPI（超详解）
weixin_52533007的博客
03-31 8289
用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，Stream讲的是计算！Stream关注的是对数据的运算，与CPU打交道，集合关注的是数据的存储，与内存打交道。Stream 自己不会存储元素。Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
JDK8的 stream流详解
weixin_42023748的博客
12-30 591
Java8新特性：Stream流详解 个人笔记 1. Stream初体验 我们先来看看Java里面是怎么定义Stream的： Asequenceof elements supporting sequential and parallel aggregate operations. 我们来解读一下上面的那句话： Stream是元素的集合，这点让Stream看起来用些类似Iterator； 可以支持顺序和并行的对原Stream进行汇聚的操作； 大家可以把Strea...
Java8_Stream详解
喜欢捣鼓各种技术
05-24 3196
JDK8 Stream详解 概念 Stream是Java8 API的新成员，它允许以声明性方式处理数据集合 。 特点 （1）代码简洁：函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。 （2）多核友好：Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下方法。 流程 1）第一步：把集合转换为流stream 2）第二步：操作stream流 stream流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(term
JDK8新特性Stream流使用详解
weixin_43883790的博客
09-15 951
Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。 元素流在管道中经过中间操作（intermediate operation）的处理，
Java8的Stream流详解
qq_43751200的博客
04-09 2070
Java8的Stream流详解Stream流的概述Stream流的获取Stream流的常用APIStream流的综合应用收集Stream流 Stream流的概述 什么是Stream流？ 在Java 8中，得益于Lambda所带来的函数式编程， 引入了一个全新的Stream流概念。 目的：用于简化集合和数组操作的API。 Stream流式思想的核心： 1、先得到集合或者数组的Stream流（就是一根传送带） 2、把元素放上去 3、然后就用这个Stream流简化的API来方便的操作元素。 问题1、Stre
JDK8新特性(九)之Stream流的find()、max()、min()、reduce()方法
北辰
12-19 2171
1.Stream流的find()方法 如果需要找到某些数据，可以使用find相关方法。方法声明： Optional<T> findFirst(); Optional<T> findAny(); import java.util.Optional; import java.util.stream.Stream; public class Demo { public static void main(String[] args) { Stream
java stream详解
06-02
Java 8引入了Stream API，它是一种函数式编程风格的API，可以帮助我们进行复杂的集合操作，以及实现并行处理等功能。本文将详细介绍Java Stream API的使用方法。 ## 什么是Stream Stream是Java 8中新增的一种数据处理方式，它可以让我们以声明式的方式对集合进行操作，而无需关心底层的实现细节。Stream可以让我们轻松地实现过滤、排序、映射、聚合等操作，而且可以支持并行处理，提高程序的运行效率。 Stream是一种惰性求值的操作，它只有在终止操作（Terminal Operation）被调用时才会开始执行中间操作（Intermediate Operation），这种设计可以让我们只对需要处理的元素进行操作，避免不必要的计算。 ## 使用Stream 使用Stream API，我们可以对集合进行一系列的操作，例如：过滤、排序、映射、聚合等。下面是一些常用的Stream操作： 1. 创建Stream对象 我们可以通过Collection.stream()或Collection.parallelStream()方法来创建Stream对象，例如： ```java List<String> list = Arrays.asList("a", "b", "c"); Stream<String> stream = list.stream(); ``` 2. 中间操作 中间操作是指对Stream对象进行的操作，例如：过滤、映射、排序等。常用的中间操作包括： - filter：过滤元素 - map：对元素进行映射 - sorted：对元素进行排序 - distinct：去重操作 - limit：限制元素数量 - skip：跳过元素 例如，我们可以通过filter()方法对Stream对象进行过滤操作： ```java List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); List<Integer> result = list.stream().filter(i -> i % 2 == 0).collect(Collectors.toList()); System.out.println(result); ``` 输出结果为： ``` [2, 4] ``` 在上面的代码中，我们首先创建了一个包含整数的List，然后使用stream()方法将List转换成Stream对象，接着使用filter()方法对元素进行过滤，最后使用collect()方法将Stream对象转换成List对象。 3. 终止操作 终止操作是指对Stream对象进行的最终操作，例如：收集、聚合等。常用的终止操作包括： - forEach：对每个元素执行操作 - collect：将元素收集到集合中 - reduce：对元素进行聚合操作 例如，我们可以通过reduce()方法对Stream对象进行聚合操作： ```java List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); Optional<Integer> result = list.stream().reduce((a, b) -> a + b); System.out.println(result.get()); ``` 输出结果为： ``` 15 ``` 在上面的代码中，我们首先创建了一个包含整数的List，然后使用stream()方法将List转换成Stream对象，接着使用reduce()方法对元素进行聚合操作，最后使用get()方法获取结果。 ## 并行流 Stream API还可以支持并行处理，可以通过parallel()方法将Stream对象转换为并行流，例如： ```java List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); int result = list.parallelStream().filter(i -> i % 2 == 0).mapToInt(i -> i).sum(); System.out.println(result); ``` 输出结果为： ``` 6 ``` 在上面的代码中，我们使用parallelStream()方法将List转换成并行流，接着使用filter()方法进行过滤操作，然后使用mapToInt()方法将元素映射为int类型，最后使用sum()方法对元素进行求和操作。 需要注意的是，并行流并不是万能的，它需要消耗额外的计算资源，而且在某些情况下可能会影响程序的性能。所以，在使用并行流时，需要根据具体的情况进行选择。 ## 总结 Java Stream API是一种非常强大的数据处理方式，它可以让我们以声明式的方式对集合进行操作，而无需关心底层的实现细节。使用Stream API，我们可以轻松地实现过滤、排序、映射、聚合等操作，而且可以支持并行处理，提高程序的运行效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值