java实现的类似于sql join操作的工具、通用递归

最新推荐文章于 2024-05-01 19:17:00 发布
最新推荐文章于 2024-05-01 19:17:00 发布
阅读量53 收藏
点赞数
文章标签： java sql python 开发语言
原文链接：https://www.cnblogs.com/binz/p/17664073.html
版权

java实现的类似于sql join操作的工具类(java集合的一对多，一对一关联操作)，通用递归，最低需要java8
直接上代码，缺包的自行替换为自己项目中存在的

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

import org.apache.commons.lang3.exception.ExceptionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import cn.hutool.core.util.ObjectUtil;

/**
 * @description：数据列表关联，类似于sql中的join
 * @author： Binz 
 * @time：2019-09-29 09:40
 */
public class Java8Util {

    private static final Logger logger = LoggerFactory.getLogger(Java8Util.class);

    /**
     * @description：关联到主表的基本类型属性去  一对多
     * @param： t1 主表
     * @param： t2 关联表
     * @param： t1JoinKey 主表的关联key
     * @param： t2JoinKey 关联表的关联key
     * @param： toT1ListProperty 需要赋值到t1的List属性
     * @return  
     * @author： Binz
     * @time：2019-09-29 09:44
     * <pre>
     * 例如：Java8Util.joinToList(users, roles, User::getId, Role::getUserId, User::setRoles);
     * </pre>
     */
    public static <P,C,JR> void joinToList(Collection<P> t1, Collection<C> t2,Function<P, JR> t1JoinKey ,Function<C,JR> t2JoinKey,BiConsumer<P,List<C>> toT1ListProperty) {
        try {
            Map<Object,List<C>> valueMap = new HashMap<>();
            JR t2JoinValue;
            for (C c : t2) {
                t2JoinValue = t2JoinKey.apply(c);
                valueMap.putIfAbsent(t2JoinValue, new ArrayList<>());
                valueMap.get(t2JoinValue).add(c);
            }
            JR t1JoinValue;
            List<C> list;
            for (P p : t1) {
                t1JoinValue = t1JoinKey.apply(p);
                list = valueMap.get(t1JoinValue);
                toT1ListProperty.accept(p, list); 
            }
        } catch (Exception e) {
            logger.error( ExceptionUtils.getStackTrace(e));
        }
    }

    /**
     * @description：关联到主表的基本类型属性去  一对多
     * @param： t1 主表
     * @param： t2 关联表
     * @param： t1JoinKey 主表的关联key
     * @param： t2JoinKey 关联表的关联key
     * @param： getT2PropertyKey 获取t2指定属性
     * @param： toT1ListProperty 需要赋值到t1的List属性
     * @return  
     * @author： Binz
     * @time：2019-09-29 09:44
     * <pre>
     * 例如：Java8Util.joinToListProperty(users, roles, User::getId, Role::getUserId, Role::Id ,Role::getName ， User::setRoleNames);
     * </pre>
     */
    public static <P,C,JR,SR> void joinToListProperty(Collection<P> t1, Collection<C> t2,Function<P, JR> t1JoinKey ,Function<C,JR> t2JoinKey,Function<C, SR> getT2PropertyKey ,BiConsumer<P,List<SR>> toT1PropertyKey) {
        try {
            Map<Object,List<SR>> valueMap = new HashMap<>();
            JR t2JoinValue;
            for (C c : t2) {
                t2JoinValue = t2JoinKey.apply(c);
                valueMap.putIfAbsent(t2JoinValue, new ArrayList<>());
                valueMap.get(t2JoinValue).add(getT2PropertyKey.apply(c));
            }
            JR t1JoinValue;
            List<SR> list;
            for (P p : t1) {
                t1JoinValue = t1JoinKey.apply(p);
                list = valueMap.get(t1JoinValue);
                toT1PropertyKey.accept(p,list); 
            }
        } catch (Exception e) {
            logger.error( ExceptionUtils.getStackTrace(e));
        }
    }
    
    public static <P,C,JR,SR> void joinToSetProperty(Collection<P> t1, Collection<C> t2,Function<P, JR> t1JoinKey ,Function<C,JR> t2JoinKey,Function<C, SR> getT2PropertyKey ,BiConsumer<P,Set<SR>> toT1PropertyKey) {
        try {
            Map<Object,Set<SR>> valueMap = new HashMap<>();
            JR t2JoinValue;
            for (C c : t2) {
                t2JoinValue = t2JoinKey.apply(c);
                valueMap.putIfAbsent(t2JoinValue, new HashSet<>());
                valueMap.get(t2JoinValue).add(getT2PropertyKey.apply(c));
            }
            JR t1JoinValue;
            Set<SR> list;
            for (P p : t1) {
                t1JoinValue = t1JoinKey.apply(p);
                list = valueMap.get(t1JoinValue);
                toT1PropertyKey.accept(p,list); 
            }
        } catch (Exception e) {
            logger.error( ExceptionUtils.getStackTrace(e));
        }
    }


    /**
     * @description：关联到主表的基本类型属性去  一对一
     * @param： t1 主表
     * @param： t2 关联表
     * @param： t1JoinKey 主表的关联key
     * @param： t2JoinKey 关联表的关联key
     * @param： toT1PropertyKey 把t2 设置到 t1指定的属性
     * @return  
     * @author： Binz
     * @time：2019-09-29 09:44
     * <pre>
     * 例如：joinToEntity(users, accountss, User::getId, Account::getUserId,  User::setAccount);
     * </pre>
     */
    public static <P,C,JR> void joinToEntity(Collection<P> t1, Collection<C> t2,Function<P, JR> t1JoinKey ,Function<C,JR> t2JoinKey,BiConsumer<P,C> toT1EntityProperty) {
        try {
            Map<Object,List<P>> m1 = new HashMap<>(t1.size());
            Object t1KeyValue;
            for (P p : t1) {
                t1KeyValue = t1JoinKey.apply(p);
                m1.putIfAbsent(t1KeyValue, new ArrayList<>());
                m1.get(t1KeyValue).add(p);
            }
            Object t2JoinKeyValue;
            List<P> ps;
            for (C c : t2) {
                t2JoinKeyValue = t2JoinKey.apply(c);
                ps = m1.get(t2JoinKeyValue);
                if(ps != null) {
                    for (P p : ps) {
                        toT1EntityProperty.accept(p, c);
                    }
                }
            }
        } catch (Exception e) {
            logger.error( ExceptionUtils.getStackTrace(e));
        }
    }

    /**
     * @description：关联到主表的基本类型属性去  一对一
     * @param： t1 主表
     * @param： t2 关联表
     * @param： t1JoinKey 主表的关联key
     * @param： t2JoinKey 关联表的关联key
     * @param： getT2PropertyKey 从t2获取某一个值
     * @param： toT1PropertyKey 把t2获取到的值设置到 t1指定的属性
     * @return  
     * @author： Binz
     * @time：2019-09-29 09:44
     * <pre>
     * 例如：joinToEntity(users, accountss, User::getId, Account::getUserId,  User::setAccount);
     * </pre>
     */
    public static <P,C,JR> void joinToEntityByFilter(Collection<P> t1, Collection<C> t2,Function<P, JR> t1JoinKey ,Function<C,JR> t2JoinKey,Predicate<P> t1Filter,Predicate<C> t2Filter,BiConsumer<P,C> toT1EntityProperty) {
        try {
            Map<Object,List<P>> m1 = new HashMap<>(t1.size());
            Object t1KeyValue;
            for (P p : t1) {
                if(t1Filter == null || t1Filter.test(p)) {
                    t1KeyValue = t1JoinKey.apply(p);
                    m1.putIfAbsent(t1KeyValue, new ArrayList<>());
                    m1.get(t1KeyValue).add(p);
                }
            }
            Object t2JoinKeyValue;
            List<P> ps;
            for (C c : t2) {
                if(t2Filter == null || t2Filter.test(c)) {
                    t2JoinKeyValue = t2JoinKey.apply(c);
                    ps = m1.get(t2JoinKeyValue);
                    if(ps != null) {
                        for (P p : ps) {
                            toT1EntityProperty.accept(p, c);
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error( ExceptionUtils.getStackTrace(e));
        }
    }



    /**
     * @description：关联到主表的基本类型属性去  一对一
     * @param： t1 主表
     * @param： t2 关联表
     * @param： t1JoinKey 主表的关联key
     * @param： t2JoinKey 关联表的关联key
     * @param： getT2PropertyKey 从t2获取某一个值
     * @param： toT1PropertyKey 把t2获取到的值设置到 t1指定的属性
     * @return  
     * @author： Binz
     * @time：2019-09-29 09:44
     * <pre>
     * 例如：joinToProperty(users, persons, User::getId, Person::getUserId, Person::getRealName User::setRealName);
     * </pre>
     */
    public static <P,C,JR,SR> void joinToProperty(Collection<P> t1, Collection<C> t2,Function<P, JR> t1JoinKey ,Function<C,JR> t2JoinKey,Function<C, SR> getT2PropertyKey ,BiConsumer<P,SR> toT1PropertyKey) {
        try {
            Map<Object,List<P>> m1 = new HashMap<>(t1.size());
            Object t1KeyValue;
            for (P p : t1) {
                t1KeyValue = t1JoinKey.apply(p);
                m1.putIfAbsent(t1KeyValue, new ArrayList<>());
                m1.get(t1KeyValue).add(p);
            }
            Object t2JoinKeyValue;
            List<P> ps;
            for (C c : t2) {
                t2JoinKeyValue = t2JoinKey.apply(c);
                ps = m1.get(t2JoinKeyValue);
                if(ps != null) {
                    for (P p : ps) {
                        toT1PropertyKey.accept(p, getT2PropertyKey.apply(c));
                    }
                }
            }
        } catch (Exception e) {
            logger.error( ExceptionUtils.getStackTrace(e));
        }
    }

    /**
     * @description：关联到主表的基本类型属性去  一对一
     * @param： t1 主表
     * @param： t2 关联表
     * @param： t1JoinKey 主表的关联key
     * @param： t2JoinKey 关联表的关联key
     * @param： t1Filter 表一过滤 可为空
     * @param： t2Filter 表二过滤 可为空
     * @param： getT2PropertyKey 从t2获取某一个值
     * @param： toT1PropertyKey 把t2获取到的值设置到 t1指定的属性
     * @return  
     * @author： Binz
     * @time：2019-09-29 09:44
     * <pre>
     * 例如：
     *  joinToPropertyByFilter(users, persons, User::getPersonId, Person::getId, e -> {
            return  e.getId() != null && e.getId() > 3;
        },null, Person::getRealName, User::setRealName);
     * </pre>
     */
    public static <P,C,JR,SR> void joinToPropertyByFilter(Collection<P> t1, Collection<C> t2,Function<P, JR> t1JoinKey ,Function<C,JR> t2JoinKey,Predicate<P> t1Filter,Predicate<C> t2Filter,Function<C, SR> getT2PropertyKey ,BiConsumer<P,SR> toT1PropertyKey) {
        try {
            Map<Object,List<P>> m1 = new HashMap<>(t1.size());
            Object t1KeyValue;
            for (P p : t1) {
                if(t1Filter == null || t1Filter.test(p)) {
                    t1KeyValue = t1JoinKey.apply(p);
                    m1.putIfAbsent(t1KeyValue, new ArrayList<>());
                    m1.get(t1KeyValue).add(p);
                }
            }
            Object t2JoinKeyValue;
            List<P> ps;
            for (C c : t2) {
                if(t2Filter == null || t2Filter.test(c)) {
                    t2JoinKeyValue = t2JoinKey.apply(c);
                    ps = m1.get(t2JoinKeyValue);
                    if(ps != null) {
                        for (P p : ps) {
                            toT1PropertyKey.accept(p, getT2PropertyKey.apply(c));
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error( ExceptionUtils.getStackTrace(e));
        }
    }

    /**
     * @description：关联到主表的基本类型属性去  一对一
     * @param： t1 主表
     * @param： t2 关联表
     * @param： t1JoinKey 主表的关联key
     * @param： t2JoinKey 关联表的关联key
     * @param： getT2PropertyKey 从t2获取某一个值
     * @param： toT1PropertyKey 把t2获取到的值设置到 t1指定的属性
     * @return  
     * @author： Binz
     * @time：2019-09-29 09:44
     * <pre>
     * 例如：
     * joinToPropertys(users, persons, User::getPersonId, Person::getId, (user,person)->{
     *      user.setRealName("乱设置的"+person.getId());
     *      user.setAge(person.getAge());
     * });
     * </pre>
     */
    public static <P,C,JR,SR> void joinToPropertys(Collection<P> t1, Collection<C> t2,Function<P, JR> t1JoinKey ,Function<C,JR> t2JoinKey,BiConsumer<P,C> toT1Propertys) {
        try {
            Map<Object,List<P>> m1 = new HashMap<>(t1.size());
            Object t1KeyValue;
            for (P p : t1) {
                t1KeyValue = t1JoinKey.apply(p);
                m1.putIfAbsent(t1KeyValue, new ArrayList<>());
                m1.get(t1KeyValue).add(p);
            }
            Object t2JoinKeyValue;
            List<P> ps;
            for (C c : t2) {
                t2JoinKeyValue = t2JoinKey.apply(c);
                ps = m1.get(t2JoinKeyValue);
                if(ps != null) {
                    for (P p : ps) {
                        toT1Propertys.accept(p, c);
                    }
                }
            }
        } catch (Exception e) {
            logger.error( ExceptionUtils.getStackTrace(e));
        }
    }


    /**
     * @description：关联到主表的基本类型属性去  一对一
     * @param： t1 主表
     * @param： t2 关联表
     * @param： t1JoinKey 主表的关联key
     * @param： t2JoinKey 关联表的关联key
     * @param： getT2PropertyKey 从t2获取某一个值
     * @param： toT1PropertyKey 把t2获取到的值设置到 t1指定的属性
     * @return  
     * @author： Binz
     * @time：2019-09-29 09:44
     * <pre>
     * 例如：
     * joinToPropertysByFilter(users, persons, User::getPersonId, Person::getId , e -> {
            return  e.getId() != null && e.getId() > 3;
        }, (t1,t2)->{
            t1.setRealName("有过滤的乱设置的"+t2.getId());
            t2.setAge(1);
        });
     * </pre>
     */
    public static <P,C,JR,SR> void joinToPropertysByFilter(Collection<P> t1, Collection<C> t2,Function<P, JR> t1JoinKey ,Function<C,JR> t2JoinKey , Predicate<P> t1Filter,BiConsumer<P,C> toT1Propertys) {
        try {
            Map<Object,List<P>> m1 = new HashMap<>(t1.size());
            Object t1KeyValue;
            for (P p : t1) {
                if(t1Filter.test(p)) {
                    t1KeyValue = t1JoinKey.apply(p);
                    m1.putIfAbsent(t1KeyValue, new ArrayList<>());
                    m1.get(t1KeyValue).add(p);
                }
            }
            Object t2JoinKeyValue;
            List<P> ps;
            for (C c : t2) {
                t2JoinKeyValue = t2JoinKey.apply(c);
                ps = m1.get(t2JoinKeyValue);
                if(ps != null) {
                    for (P p : ps) {
                        toT1Propertys.accept(p, c);
                    }
                }
            }
        } catch (Exception e) {
            logger.error( ExceptionUtils.getStackTrace(e));
        }
    }

    /**
     * 通用递归，使用示例
     * <br/>List<DepartmentTreeVo> list = new ArrayList<>();
     * <br/>Java8Util.recursion(departmentTree, DepartmentTreeVo::getChildren, t -> {
     * <br/>      list.add(t);
     * <br/>});
     * @param ts
     * @param childsFn   
     * @param then
     */
    public static <T> void  recursion(List<T> ts, Function<T, List<T>> childsFn , Consumer<T> then) {
        for(T t : ts) {
            then.accept(t);
        }
        for(T t : ts) {
            List<T> childs = childsFn.apply(t);
            if(ObjectUtil.isNotEmpty(childs)) {
                recursion(childs, childsFn, then);
            }
        }
    }
}
蜗牛～turbo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
cqengine:对Java集合的超快速类似SQL的查询
05-27
CQEngine-集合查询引擎 CQEngine –集合查询引擎–是一种高性能的Java集合，可以通过类似SQL的查询进行搜索，并且延迟极短。 每秒完成数百万个查询，查询延迟以微秒为单位 从数据库卸载查询流量-扩展您的应用程序层 即使在低端硬件上，性能也比数据库好几千倍 支持堆上持久性，堆外持久性，磁盘持久性，并支持MVCC事务隔离。 CQEngine有趣的评论： CQEngine在野外： | | （每天有亿个请求） 迭代的局限性 从集合中检索符合某些条件的对象的经典方法是迭代集合，并对每个对象进行一些测试。 如果对象符合条件，则将其添加到结果集中。 对集合中的每个对象重复此操作。 传统的迭代效率非常低，时间复杂度为O（ n t ）。 可以对其进行优化，但是需要统计信息以了解集合的构成。 基准偷窥 即使将优化应用于约定迭代，CQEngine也可以在很大的程度上优于常规迭代。
Java 8 Stream 类似用 SQL 语句形式 Java 集合运算和表达
zane_xiao的博客
06-18 972
搜索功能在 Android中也是常碰到一个场景；或者选择功能，就是基于什么来选择什么的功能。碰到这种业务场景我们常规做法:第一想到的就是去找服务器定制接口，传字段返回数组。但是这样会增加服务器的压力。第二就是本地数据库的查询，但是单一功能集成一个数据库进来，不太合适。 Stream java原生的API拯救你！ Stream是java 8新增处理数据的对象。 一句话简介： Stream 使用一种...
Java--Mybatis关联映射之关联单个对象(即一对一)；关联多个对象(即一对多)
MinggeQingchun的博客
09-01 1069
使用Mybatis框架，在业务需要对数据库进行关联查询的时候需使用关联映射 而关联映射分为关联单个对象与关联多个对象，即一对一、一对多的情况，且每种关联方式都可以有两种处理情况，即使用1条sql进行处理与使用2条sql进行处理 已有表关系如下(表的字段名与实体类中的属性名一致)： user表：主键为user_Id book表：主键为book_id Java实体类对象如下： 1、domain.User.java package domain; import java.util.List; publi
Java 下数据业务逻辑开发技术 JOOQ 和 SPL
学Java，找哪吒
09-12 1万+
JOOQ支持完整的面向对象的编程风格，可以将多个对象（方法）组合起来，形成类似SQL的语法逻辑。JOOQ可以使用Java的Lambda表达式、函数调用接口和流程控制语法，理论上也支持面向函数和面向过程，但这些表达式\语法没有为JOOQ的结构化数据对象（Result）而设计，使用时还不够方便。
使用java实现两对象（两张表）关联 [类似sql语句：left join]
weixin_42393724的博客
11-08 3926
JAVA语句实现两个表相关联
java list join_java 两个 list做类似Join操作
热门推荐
weixin_29290379的博客
02-13 1万+
背景针对两个或者多个List，(即使他们内部维护的类型不同也可以)根据某个唯一的属性，比如id，name，进行类似join 操作，即分组操作。这在Spark SQL中(转为DateFrame，注册成几张表) 或者 SQL语句中很容易实现，但是在java中却没有方法可以直接完成，那么可以参考以下的方式。转化为Map对象首先将 list 转化为 Map 对象，以list中的某个或某几个属性作为 key...
java像sql一样处理数据_快速学会像Git一样管理数据库业务版本变更
weixin_29932857的博客
01-06 159
1. 前言随着项目的不断迭代，数据库表结构、数据都在发生着变化。甚至有的业务在多环境版本并行运行。数据为王的时代，管理好数据库的版本也成为了迫切的需要。如何能做到像Git之类的版本控制工具来管理数据库？Java项目中常用Flyway和Liquibase来管理数据库版本。其中Flyway相对来说比较受欢迎。2. Flyway 的特点Flyway大受欢迎是因为它具有以下优...
java数据匹配，类似left join方式连表
在写bug的路上越走越远
11-23 2404
话不多说，上代码，获取的数据结构和left join连表的结果相同。 package com.home.util; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import net.sf.cglib.beans.BeanMap; import org.springframework.beans.BeanUtils; import java.lang.reflect.Inv
java 实现 sql join_SQL join的介绍
weixin_39924573的博客
03-07 431
学员表SELECT * FROM tb_address;SELECT * FROM tb_student1.JOIN关联两个表数据，将匹配数据展示，数据无匹配值则不展示注释：INNER JOIN与JOIN是相同SELECT*FROMtb_student stuJOIN tb_address addressON stu.`id` = address.`stu_id` ;2.LEFT JOIN返回左表...
java TreeUtil菜单递归工具类
09-07
主要为大家详细介绍了java TreeUtil菜单递归工具类，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java实现递归菜单树
09-07
主要为大家详细介绍了java实现递归菜单树，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
sql server实现递归查询的方法示例
12-16
本文实例讲述了sql server实现递归查询的方法示例。分享给大家供大家参考，具体如下： 有时候面对树结构的数据时需要进行递归查询,网上找了一番,参考了各位大神的文章,发现蛮简单的,当做个小笔记方便以后使用 sql ...
digui.rar_machinerykfm_递归的java实现
09-24
方法的递归调用 * 方法自己调用自己 * 适合于,方法中运算的主体不变,但是运行的时候,参与运行的方法参数会变化 * 注意: * 递归一定要有出口, 必须可以让程序停下 * 递归次数不能过多 * 构造方法,禁止递归
SQL如何实现MYSQL的递归查询
09-10
主要介绍了根据递归到迭代转化的思路，利用SQL实现了MYSQL的递归查询,需要的朋友可以参考下
C#(C Sharp)学习笔记_类【十五】
追求细节，成就完美
05-01 469
类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
链表刷题集
yajunjiao的专栏
04-30 628
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Spring Cloud——LoadBalancer
最新发布
????
05-01 1594
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1208
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 520
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
java实现递归
05-24
在Java中实现递归通常需要一个递归函数，它会在自身内部调用自己。 以下是一个简单的Java递归示例，计算一个整数的阶乘： ```java public class RecursionExample { public static void main(String[] args) { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值