利用stream实现行政区域列表转tree树形结构

最新推荐文章于 2023-07-10 17:11:26 发布
最新推荐文章于 2023-07-10 17:11:26 发布
阅读量628 收藏
点赞数
分类专栏： Java开发中各种问题场景处理 文章标签： java spring boot 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45614471/article/details/127864601
版权

一、数据结构

CREATE TABLE `t_districts` (
  `adcode` bigint NOT NULL COMMENT '主键(区域编码)\r\n',
  `pid` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '父级区域编码',
  `name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '行政单位名称',
  `citycode` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '城市编码',
  `level` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '行政单位类别 省 市 区/县 街道/乡镇',
  `center` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '经度，纬度',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  PRIMARY KEY (`adcode`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci ROW_FORMAT=DYNAMIC;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ehe.core.pojo.domain.StringTenantEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import lombok.experimental.Accessors;
import javax.persistence.Column;
import javax.persistence.Transient;
import java.util.LinkedList;
import java.util.List;

@ApiModel(value = "行政区域", description = "行政区域")
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@ToString(callSuper = true)
@Accessors(chain = true)
@TableName(value = "t_districts")
public class Districts{

    /** 城市编码 */
    @ApiModelProperty(value = "城市编码", position = 10, required = true)
    @Column(length = 255)
    private String citycode;

    /** 区域编码 */
    @ApiModelProperty(value = "区域编码", position = 11, required = true)
    @Column(length = 255)
    private String adcode;

    /** 城市编码 */
    @ApiModelProperty(value = "城市名称", position = 12, required = true)
    @Column(length = 255)
    private String name;

    /** 区域中心点 */
    @ApiModelProperty(value = "区域中心点", position = 13, required = true)
    @Column(length = 255)
    private String center;

    /** 行政区划级别 */
    @ApiModelProperty(value = "行政区划级别", position = 14, required = true)
    @Column(length = 60)
    private String level;

    /** 上级区域编码 */
    @ApiModelProperty(value = "上级区域编码", position = 15, required = true)
    @Column(length = 60)
    private String pid;

    @Transient
    @TableField(exist = false)
    private boolean hasChildren;

    @TableField(exist = false)
    List<Districts> childrenList = new LinkedList<>();

}


public List<DistrictsVO> getAreaTree(String pid) {
       List<Districts> districtsList = districtsService.selectAll();
            districtsList.stream().filter(districts -> "0".equals(districts.getPid()))
                    .peek(districts -> addChildren(districts,districtsList))
                    .collect(Collectors.toList());
            return BeanConverts.convert(districtsList,DistrictsVO.class);
        return BeanConverts.convert(districtsList,DistrictsVO.class);
    }

private void addChildren(Districts districts, List<Districts> districtsList) {
        districts.setChildrenList(
                districtsList.stream().filter(vo -> districts.getAdcode().equals(vo.getPid()))
                .peek(children -> addChildren(children,districtsList)).collect(Collectors.toList())
        );
    }

import com.baomidou.mybatisplus.annotation.TableField;
import com.ehe.core.pojo.vo.StringVO;
import com.ehe.elder.domain.Districts;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import lombok.experimental.Accessors;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.LinkedList;
import java.util.List;

/**
 * 行政区域 VO
 * @author rambo
 */
@ApiModel(value = "行政区域 VO", description = "行政区域 VO")
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@ToString(callSuper = true)
@Accessors(chain = true)
public class DistrictsVO{

    /** 城市编码 */
    @ApiModelProperty(value = "城市编码", position = 10, required = true)
    private String citycode;

    /** 区域编码 */
    @ApiModelProperty(value = "区域编码", position = 11, required = true)
    private String adcode;

    /** 城市名称 */
    @ApiModelProperty(value = "城市名称", position = 12, required = true)
    private String name;

    /** 区域中心点 */
    @ApiModelProperty(value = "区域中心点", position = 13, required = true)
    private String center;

    /** 行政区划级别 */
    @ApiModelProperty(value = "行政区划级别", position = 14, required = true)
    private String level;

    /** 上级区域编码 */
    @ApiModelProperty(value = "上级区域编码", position = 15, required = true)
    private String pid;

    @TableField(exist = false)
    List<Districts> childrenList = new LinkedList<>();

}

二、工具类

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import javax.annotation.Nonnull;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

/**
 * bean 转换 工具类
 * @author jerry
 */
@Slf4j
public final class BeanConverts {
    private BeanConverts() {
    }

    /**
     * BeanUtils.copyProperties 增强
     * 拷贝时，source 值为空则不拷贝
     * @param source 源数据
     * @param target 目标数据
     * @param ignoreProperties 忽略属性
     */
    public static void copyPropertiesIgnoreNull(@Nonnull Object source, @Nonnull Object target, String... ignoreProperties) {
        Set<String> ignoreSet = new HashSet<>();
        if (ignoreProperties != null) {
            ignoreSet.addAll(Arrays.asList(ignoreProperties));
        }
        ignoreSet.addAll(getObjectNullFieldName(source));
        BeanUtils.copyProperties(source, target, ignoreSet.toArray(new String[0]));
    }

    /**
     * 获取对象字段值为null 的字段名称集合
     * @param object 源数据
     * @return 字段名称集合
     */
    public static List<String> getObjectNullFieldName(@Nonnull Object object) {
        BeanMap beanMap = BeanMap.create(object);
        List<String> fieldNameList = new ArrayList<>();
        for (Object key : beanMap.keySet()) {
            if (beanMap.get(key) == null) {
                fieldNameList.add(key.toString());
            }
        }
        return fieldNameList;
    }

    /**
     * 将对象转换为map
     * 不转换空值字段
     * @param obj 对象
     * @return 键值对
     */
    public static Map<String, Object> objToMapIgnoreNull(Object obj) {
        return objToMap(obj, true);
    }

    /**
     * 将对象转换为map
     * @param obj 对象
     * @return 键值对
     */
    public static Map<String, Object> objToMap(Object obj) {
        return objToMap(obj, false);
    }

    /**
     * 将对象转换为map
     * @param obj 对象
     * @param ignoreNull 忽略空值字段
     * @return 键值对
     */
    private static Map<String, Object> objToMap(Object obj, boolean ignoreNull) {
        Map<String, Object> map = new HashMap<>(10);
        if (obj != null) {
            BeanMap beanMap = BeanMap.create(obj);
            for (Object key : beanMap.keySet()) {
                Object value = beanMap.get(key);
                if (ignoreNull && value == null) {
                    continue;
                }
                map.put(key.toString(), value);
            }
        }
        return map;
    }

    /**
     * bean 转换
     * @param obj 源对象
     * @param clazz 目标类型
     * @param <T> 泛型
     * @return 目标对象
     */
    public static <T> T convert(Object obj, @Nonnull Class<T> clazz) {
        if (obj == null) {
            return null;
        }
        T t = BeanUtils.instantiateClass(clazz);
        BeanUtils.copyProperties(obj, t);
        return t;
    }

    /**
     * bean 转换
     * @param optional 源对象
     * @param clazz 目标类型
     * @param <T> 泛型
     * @return 目标对象
     */
    public static <T> Optional<T> convert(@Nonnull Optional<?> optional, @Nonnull Class<T> clazz) {
        return optional.map(obj -> convert(obj, clazz));
    }

    /**
     * bean 集合转换
     * @param collection 源对象集合
     * @param clazz 目标类型
     * @param <T> 泛型
     * @return 目标对象集合
     */
    @Nonnull
    public static <T> List<T> convert(@Nonnull Collection<?> collection, @Nonnull Class<T> clazz) {
        return collection.stream().map(item -> convert(item, clazz)).collect(Collectors.toList());
    }

    /**
     * bean 集合转换
     * @param iterable 实体集合
     * @param clazz 目标类型
     * @param <T> 泛型
     * @return 目标对象集合
     */
    @Nonnull
    public static <T> List<T> convert(@Nonnull Iterable<?> iterable, @Nonnull Class<T> clazz) {
        return convert(StreamSupport.stream(iterable.spliterator(), false), clazz);
    }

    /**
     * bean 集合转换
     * @param stream 实体集合流
     * @param clazz 目标类型
     * @param <T> 泛型
     * @return 目标对象集合
     */
    @Nonnull
    public static <T> List<T> convert(@Nonnull Stream<?> stream, @Nonnull Class<T> clazz) {
        return stream.map(entity -> convert(entity, clazz)).collect(Collectors.toList());
    }

    /**
     * 实体分页转换
     * @param page 实体分页
     * @param clazz 目标对象
     * @param <T> 泛型
     * @return 目标分页
     */
    @Nonnull
    public static <T> Page<T> convert(@Nonnull Page<?> page, @Nonnull Class<T> clazz) {
        List<T> list = convert(page.getContent(), clazz);
        return new PageImpl<>(list, page.getPageable(), page.getTotalElements());
    }

    /**
     * map 转对象
     * @param clazz 目标类型
     * @param collection 键值对集合
     * @param <T> 泛型
     * @return 目标对象集合
     */
    @Nonnull
    public static <T> List<T> mapToObj(@Nonnull Class<T> clazz, @Nonnull Collection<Map<String, Object>> collection) {
        return collection.stream().map(map -> BeanConverts.mapToObj(clazz, map)).collect(Collectors.toList());
    }

    /**
     * map 转对象
     * @param clazz 目标类型
     * @param map 键值对
     * @param <T> 泛型
     * @return 目标对象
     */
    public static <T> T mapToObj(@Nonnull Class<T> clazz, @Nonnull Map<String, Object> map) {
        T d = BeanUtils.instantiateClass(clazz);
        BeanInfo beanInfo;
        try {
            beanInfo = Introspector.getBeanInfo(d.getClass());
        } catch (IntrospectionException e) {
            log.warn(e.getMessage(), e);
            return null;
        }
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor property : propertyDescriptors) {
            Method setter = property.getWriteMethod();
            if (setter == null) {
                continue;
            }
            Object value = map.get(property.getName());
            if (value == null) {
                continue;
            }
            try {
                setter.invoke(d, value);
            } catch (Exception e) {
                log.warn(e.getMessage(), e);
            }
        }
        return d;
    }

    /**
     * 对象集合中取出两个字段，组成map
     * @param collection 对象集合
     * @param keyProperty key属性值
     * @param valueProperty value属性值
     * @param <E> 泛型
     * @return 属性值map
     */
    @Nonnull
    public static <E> Map<String, E> propertyToMap(@Nonnull Collection<?> collection, @Nonnull String keyProperty, @Nonnull String valueProperty) {
        Map<String, E> map = new LinkedHashMap<>();
        if (collection.isEmpty()) {
            return map;
        }
        Object obj = collection.iterator().next();
        BeanInfo beanInfo;
        try {
            beanInfo = Introspector.getBeanInfo(obj.getClass());
        } catch (IntrospectionException e) {
            log.warn(e.getMessage(), e);
            return map;
        }
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        Method keyGetter = null;
        Method valueGetter = null;
        for (PropertyDescriptor property : propertyDescriptors) {
            if (keyProperty.equals(property.getName()) && property.getReadMethod() != null) {
                keyGetter = property.getReadMethod();
            } else if (valueProperty.equals(property.getName()) && property.getReadMethod() != null) {
                valueGetter = property.getReadMethod();
            }
        }
        if (keyGetter == null || valueGetter == null) {
            return map;
        }
        for (Object item : collection) {
            try {
                map.put(keyGetter.invoke(item).toString(), (E) valueGetter.invoke(item));
            } catch (IllegalAccessException | InvocationTargetException e) {
                log.warn(e.getMessage(), e);
            }
        }
        return map;
    }
}

三、stream流

官方示例：
在这里插入图片描述

public interface Stream<T> extends BaseStream<T, Stream<T>> {

  /**
     * Returns a stream consisting of the elements of this stream, additionally
     * performing the provided action on each element as elements are consumed
     * from the resulting stream.
     *
     * <p>This is an <a href="package-summary.html#StreamOps">intermediate
     * operation</a>.
     *
     * <p>For parallel stream pipelines, the action may be called at
     * whatever time and in whatever thread the element is made available by the
     * upstream operation.  If the action modifies shared state,
     * it is responsible for providing the required synchronization.
     *
     * @apiNote This method exists mainly to support debugging, where you want
     * to see the elements as they flow past a certain point in a pipeline:
     * <pre>{@code
     *     Stream.of("one", "two", "three", "four")
     *         .filter(e -> e.length() > 3)
     *         .peek(e -> System.out.println("Filtered value: " + e))
     *         .map(String::toUpperCase)
     *         .peek(e -> System.out.println("Mapped value: " + e))
     *         .collect(Collectors.toList());
     * }</pre>
     *
     * <p>In cases where the stream implementation is able to optimize away the
     * production of some or all the elements (such as with short-circuiting
     * operations like {@code findFirst}, or in the example described in
     * {@link #count}), the action will not be invoked for those elements.
     *
     * @param action a <a href="package-summary.html#NonInterference">
     *                 non-interfering</a> action to perform on the elements as
     *                 they are consumed from the stream
     * @return the new stream
     */
    Stream<T> peek(Consumer<? super T> action);
    
}

eg:

 Stream.of("one", "two", "three", "four")
             .filter(e -> e.length() > 3)
             .peek(e -> System.out.println("Filtered value: " + e))
             .map(String::toUpperCase)
             .peek(e -> System.out.println("Mapped value: " + e))
            .collect(Collectors.toList());

java 8的stream是由三部分组成:
1、数据源，
2、零个或一个或多个中间操作，
3、一个或零个终止操作

中间操作是对数据的加工，注意，中间操作是lazy操作，并不会立马启动，需要等待终止操作才会执行。终止操作是stream的启动操作，只有加上终止操作，stream才会真正的开始执行。所以，问题解决了，比如：collect(Collectors.toList()) 就是终止操作；peek是一个中间操作，文档说明peek主要被用在debug用途，上面例子输出

Filtered value: three
Mapped value: THREE

Filtered value: four
Mapped value: FOUR

peek接收的是一个Consumer类型的参数，Consumer是没有返回值的，只是对Stream中的元素进行某些操作，但是操作之后的数据并不返回到Stream中，所以Stream中的元素还是原来的元素

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);
    
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

所以我们试一试peek对stream中基本数据类型的操作，看一下peek中对基本数据类型的操作会不会影响结果的输出：可以看到stream中的元素并没有被转换成大写格式

@GetMapping("/test04")
public void test04(){
    Stream.of("one", "two", "three", "four")
            .peek(e -> e.toUpperCase())
            .forEach(System.out::println);
    }

one
two
three
four

可以看到map是真正的对元素进行了转换

@GetMapping("/test04")
public void test04(){
   Stream.of("one", "two", "three", "four")
           .map(e -> e.toUpperCase())
           .forEach(System.out::println);
}
ONE
TWO
THREE
FOUR

peek也有例外，假如我们Stream里面是一个对象会怎么样？

@GetMapping("/test04")
public void test04(){
    Stream.of(Payment.builder().name("a").build(), Payment.builder().name("b").build(), Payment.builder().name("c").build())
            .peek(payment -> payment.setName(payment.getName().toUpperCase()))
            .forEach(System.out::println);
}

Payment(typeId=null, name=A, orderId=null)
Payment(typeId=null, name=B, orderId=null)
Payment(typeId=null, name=C, orderId=null)

如果是对象的话，实际的结果会被改变。
peek接收一个Consumer，而map接收一个Function。

Consumer是没有返回值的，

它只是对Stream中的元素进行某些操作，但是操作之后的数据并不返回到Stream中，所以Stream中的元素还是原来的元素。
而Function是有返回值的，

这意味着对于Stream的元素的所有操作都会作为新的结果返回到Stream中。

肖申克isRambo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
全国行政区划表 包含树形结构 id name parentId格式
12-25
自己整理的全国行政区划表,包含一个树形表格式为 id name parentId code格式
全国行政区 树形结构（C#）
04-18
全国行政区 树形结构（C#）。 .net1.1,随处即可运行。 后台数据为XML，不必配置数据库。 根为中国，各省为分支节点，叶子节点为各县。 附带了郑州的区-办事处-社区居委会信息树形结构，根为郑州，各区为分支节点，二级分支为各办事处，叶子节点为各社区居委会。后台数据为XML，不必配置数据库。 附带了按各县区域代码分析身份证号。后台数据为XML，不必配置数据库。
Web中树形数据(层级关系数据)的实现—以行政区树为例(二)
达拉斯母牛
07-12 6798
前面已经实现了在Java中生成行政区树(参考博客)，其实也可以在JavaScript中生成树，由于JavaScript是弱类型，从某种程度上来说，JavaScript比Java更容易构建树。在JavaScript中只要生成zTree或者Ext Tree支持的数据格式即可。 /** * 构建树，如果传入的参数有多个跟节点，则返回数组，如果只有一个根节点，则返回根节点。 * * @param
java stream转树形结构
weixin_40101745的博客
05-30 336
【代码】java stream转树形结构。
中国行政区划-已处理好逻辑树形结构
08-27
此文件为最新的行政区划，且将行政区划处理成为逻辑树形结构，导入到数据库后可直接使用上级编码形成行政区划树
java树形结构递归查询
09-04
//组装类目为树结构 assembleTree(categoryTreeDTO, allDTOList,Constants.CATEGORY_MAX_LEVEL - level); } return categoryTree; } /** * 组装树 * * @param categoryTreeDTO * @param allList ...
Java8如何将Array转换为Stream的实现
08-25
主要介绍了Java8如何将Array转换为Stream的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
利用JDK8 stream filter遍历组装树
04-21
List<Menu> children = all.stream().filter(m -> { return Objects.equals(m.getParentId(), root.getId()); }).map((m) -> { m.setChildList(getChildrens(m, all)); return m; } ).collect(Collectors.to...
利用stream实现一个简单的http下载器
09-03
主要介绍了利用stream实现一个简单的http下载器的相关资料,需要的朋友可以参考下
通过stringstream实现常用的类型转换实例代码
08-19
在本篇文章里小编给大家分享了关于通过stringstream实现常用的类型转换实例代码内容，需要的朋友们可以参考下。
2016统计用区划和城乡划分代码-完整树形结构
02-25
将国家统计局的2016版统计用区划和城乡划分代码 进行了整理，依据parent_code可以形成一个完整的树形结构。类型中1,2,3,4,5分别代表省市县乡（镇）村（居委会）五级。parent_code中的CN代表中国。
国家行业代码数据处理为树形结构
Renners的博客
07-14 577
原始数据为excel，数据如下图所示：行业代码为国家标准代码，可以自行进行百度搜索 行业代码规则如下图所示1、需求是打算将行业代码按树形展示，而在设计树形表结构的时候通常会有一个key值和父级key值（id与pid）；查看原始数据后发现数据已经是按树形进行展示，但是并不是我们要的id和pid的形式，因此我们需要将数据进行处理，这里让产品帮忙配了一下数据，将对应值的父级名称进行了填充，填充后如下图所示：2、 处理好数据后，直接打开对应数据库，将excel导入（注：导入时需要将上述excel 的第一列删除，保证
使用Stream流把数组数据按照递归进行树状结构的构建
qq_46063644的博客
03-22 152
【代码】使用Stream流把数组数据按照递归进行树状结构的构建。
java8 stream 树_Java 8 特性—— Streams 构造树结构
weixin_34355933的博客
02-25 180
/*获取资源的树结构*/@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(locations={"classpath:spring/applicationContext-beans.xml"})publicclassSysResourceTree{@AutowiredprivateISysResourceSer...
Stream流实现Tree树状结构无限递归
Devil_Mao的博客
01-21 802
Stream流实现Tree树状结构无限递归 场景：在使用mybatis plus操作多层数据格式，多层遍利操作影响数据查询效率 代码 例子：需要返回给前端多级菜单 省(直辖市)/市/区(县) /** * 查询国家列表 * * @author MYH * @date 2022/1/14 16:27 */ public List<Region> regionList(String countryName) { List&
对于树的序列化，用了stream，很好
weixin_33953384的博客
02-26 146
https://leetcode.com/problems/serialize-and-deserialize-binary-tree/?tab=Description   下面这个解法里面的C++部分很好： https://discuss.leetcode.com/topic/28041/recursive-preorder-python-and-c-o-n  ...
Java stream流 省市区返回树结构
qq_16648117的博客
07-10 93
Java stream流 省市区返回树结构
JAVA 省市区对象 转成 树结构
qq_34734073的博客
05-09 1264
ID 省 市 区 1 广东省 深圳市 宝安区 2 广东省 广州市 天河区 3 广东省 广州市 从化区 4 浙江省 杭州市 西湖区 例如从数据库中获取这种格式数据，然后要转成树结构 无需多重遍历，时间复杂度O(n)，用map来存放每个key的索引位置，然后根据key在树List中找到对应的层级，进行添加数据。 附上代码： public class TestDemo { public static void main(String[] args) { Ad...
java树形结构递归实现
最新发布
09-25
2. 使用lambda表达式和Stream API的特性，通过对节点列表进行分组、过滤等操作，实现树形结构的转化。 3. 返回根节点，即树形结构的结果。 请注意，以上步骤仅为大致的实现思路，具体实现还需根据业务场景和数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值