如何比较两个对象字段的差异，对象比较工具类实现

已于 2024-07-18 23:06:33 修改
阅读量487 收藏 6
点赞数 4
分类专栏： 工具类 文章标签： java 工具类 对比
于 2024-07-16 18:13:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q2qwert/article/details/140472309
版权

一、概述

ModelDiffUtil 的工具类，用于比较两个对象之间的差异，并将差异以Map的形式返回。该类的主要方法是diffToMap，它接受两个对象作为输入，并可选地接受一个忽略字段的列表。该方法首先将输入对象转换为JSON字符串，然后将JSON字符串转换为Map，最后比较两个Map的差异并返回结果。该类还包含一些辅助方法，如convertJsonToMap和doCompare，用于处理JSON到Map的转换和比较两个Map的差异。

二、方法说明

1、getDiffMap(T sourceObject, T targetObject)

将两个对象的差异转换为 Map 格式。

调用示例：

class User {
    private String name;
    private int age;

    // 构造函数、getter 和 setter 方法
}

User sourceUser = new User();
sourceUser.setName("Alice");
sourceUser.setAge(25);

User targetUser = new User();
targetUser.setName("Bob");
targetUser.setAge(30);

Map<String, Map<String, String>> diffMap = ModelDiffUtil.getDiffMap(sourceUser, targetUser);

执行结果：

{
  "name": {
    "source": "Alice",
    "target": "Bob"
  },
  "age": {
    "source": "25",
    "target": "30"
  }
}

2、getDiffMap(T sourceObject, T targetObject, List<String> ignoreFields)

将两个对象的差异转换为 Map 格式，可以指定忽略的字段。

调用示例：

List<String> ignoreFields = Arrays.asList("age");
User sourceUser = new User();
sourceUser.setName("Alice");
sourceUser.setAge(25);

User targetUser = new User();
targetUser.setName("Bob");
targetUser.setAge(30);

Map<String, Map<String, String>> diffMap = ModelDiffUtil.getDiffMap(sourceUser, targetUser, ignoreFields);

执行结果：

{
  "name": {
    "source": "Alice",
    "target": "Bob"
  }
}

3、 getDiffMap(String sourceJsonStr, String targetJsonStr)

从两个 JSON 字符串中提取差异。

调用示例：

String sourceJsonStr = "{\"name\":\"Alice\",\"age\":25}";
String targetJsonStr = "{\"name\":\"Bob\",\"age\":30}";

Map<String, Map<String, String>> diffMap = ModelDiffUtil.getDiffMap(sourceJsonStr, targetJsonStr);

执行结果：

{
  "name": {
    "source": "Alice",
    "target": "Bob"
  },
  "age": {
    "source": "25",
    "target": "30"
  }
}

4、 diffToMap(String sourceJsonStr, String targetJsonStr, List<String> ignoreFields)

从两个 JSON 字符串中提取差异，可以指定忽略的字段。

调用示例：

String sourceJsonStr = "{\"name\":\"Alice\",\"age\":25}";
String targetJsonStr = "{\"name\":\"Bob\",\"age\":30}";

List<String> ignoreFields = Arrays.asList("age");

Map<String, Map<String, String>> diffMap = ModelDiffUtil.getDiffMap(sourceJsonStr, targetJsonStr, ignoreFields);

执行结果：

{
  "name": {
    "source": "Alice",
    "target": "Bob"
  }
}

三、内部方法
1、convertJsonToMap(Object json, String root, Map<String, Object> resultMap, List<String> ignoreFields)

  • 功能：将 JSON 对象转换为 Map ，忽略指定的字段。 - 这是一个内部辅助方法，通常不会被外部直接调用。
    2、doCompare(Map<String, Object> sourceMap, Map<String, Object> targetMap)
  • 功能：执行实际的比较操作，更新 sourceMap 以反映差异。 - 这是一个内部辅助方法，通常不会被外部直接调用。
  1. compareSourceMapWithTargetMap(Map<String, Object> sourceMap)
  • 功能：比较 sourceMap 和 targetMap ，处理 sourceMap 中独有的项。 - 这是一个内部辅助方法，通常不会被外部直接调用。
  1. compareTargetMapWithSourceMap(Map<String, Object> sourceMap, Map<String, Object> targetMap)

  • 功能：比较 sourceMap 和 targetMap ，处理 targetMap 中独有的或已更改的项。 - 这是一个内部辅助方法，通常不会被外部直接调用。

    1. processEntry(Map<String, Object> sourceMap, String key, Object value, Object targetValue)
    • 功能：处理单个条目的逻辑，根据提供的值构建差异映射或移除条目。 - 这是一个内部辅助方法，通常不会被外部直接调用。 这个工具类在需要比较对象差异并以特定格式获取结果的场景中非常有用，例如数据同步、版本控制、数据审计等。

二、完整的代码

pom依赖:

<dependency>
   <groupId>com.google.code.gson</groupId>
   <artifactId>gson</artifactId>
   <version>2.8.8</version>
</dependency>

完整代码：

import com.ecwid.consul.json.GsonFactory;
import com.google.gson.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import java.util.*;

/**
 * @author: fhey
 * @create: 2022-04-26 15:29
 * @description: 对象比较工具类
 */
@Slf4j
public class ModelDiffUtil {

    private static final Gson gson = GsonFactory.getGson();
    private final static String SOURCE_VALUE = "source";
    private final static String TARGET_VALUE = "target";
    private final static String DOT_SEPARATOR = ".";

    /**
     * 将两个对象的差异转换为Map格式。
     *
     * @param sourceObject  原始对象
     * @param targetObject 当前对象
     * @return 包含差异的Map
     */
    public static<T> Map<String, Map<String, String>> getDiffMap(T sourceObject, T targetObject) {
        return getDiffMap(sourceObject, targetObject, null);
    }

    /**
     * 将两个对象的差异转换为Map格式，可以指定忽略的字段。
     *
     * @param sourceObject  原始对象
     * @param targetObject 当前对象
     * @param ignoreFields  忽略的字段列表
     * @return 包含差异的Map
     */
    public static <T> Map<String, Map<String, String>> getDiffMap(T sourceObject, T targetObject, List<String> ignoreFields) {
        try {
            String sourceJsonStr = gson.toJson(sourceObject);
            String targetJsonStr = gson.toJson(targetObject);
            return getDiffMap(sourceJsonStr, targetJsonStr, ignoreFields);
        } catch (JsonSyntaxException e) {
            log.error("Failed to parse object to JSON", e);
            return new HashMap<>();
        }
    }

    /**
     * 从JSON字符串中提取差异。
     *
     * @param sourceJsonStr  原始JSON字符串
     * @param targetJsonStr 当前JSON字符串
     * @return 包含差异的Map
     */
    public static Map<String, Map<String, String>> getDiffMap(String sourceJsonStr, String targetJsonStr) {
        return getDiffMap(sourceJsonStr, targetJsonStr, null);
    }

    /**
     * 从JSON字符串中提取差异，可以指定忽略的字段。
     *
     * @param sourceJsonStr  原始JSON字符串
     * @param targetJsonStr 当前JSON字符串
     * @param ignoreFields   忽略的字段列表
     * @return 包含差异的Map
     */
    public static Map<String, Map<String, String>> getDiffMap(String sourceJsonStr, String targetJsonStr, List<String> ignoreFields) {
        try {
            JsonObject sourceJson = new JsonParser().parse(sourceJsonStr).getAsJsonObject();
            JsonObject targetJson = new JsonParser().parse(targetJsonStr).getAsJsonObject();
            Map<String, String> sourceMap = new LinkedHashMap<>();
            Map<String, String> targetMap = new LinkedHashMap<>();
            convertJsonToMap(sourceJson, StringUtils.EMPTY, sourceMap, ignoreFields);
            convertJsonToMap(targetJson, StringUtils.EMPTY, targetMap, ignoreFields);
            return doCompare(sourceMap, targetMap);
        } catch (JsonSyntaxException e) {
            log.error("Failed to parse JSON string", e);
            return new HashMap<>();
        }
    }

    /**
     * 将JSON对象转换为Map，忽略指定的字段。
     *
     * @param json         JSON对象
     * @param root         当前JSON路径
     * @param resultMap    存储转换结果的Map
     * @param ignoreFields 忽略的字段列表
     */
    /**
     * 将JSON对象转换为Map，忽略指定的字段。
     *
     * @param json         JSON对象
     * @param root         当前JSON路径
     * @param resultMap    存储转换结果的Map
     * @param ignoreFields 忽略的字段列表
     */
    private static void convertJsonToMap(JsonElement json, String root, Map<String, String> resultMap, List<String> ignoreFields) {
        if (json.isJsonObject()) {
            JsonObject jsonObject = json.getAsJsonObject();
            for (Map.Entry<String, JsonElement> entry : jsonObject.entrySet()) {
                String key = entry.getKey();
                if (CollectionUtils.isNotEmpty(ignoreFields) && ignoreFields.contains(key)) {
                    continue;
                }
                JsonElement value = entry.getValue();
                String newRoot = (root.isEmpty())? key : root + DOT_SEPARATOR + key;
                if (value.isJsonObject() || value.isJsonArray()) {
                    convertJsonToMap(value, newRoot, resultMap, ignoreFields);
                } else if(value.isJsonPrimitive()){
                    resultMap.put(newRoot, value.getAsJsonPrimitive().getAsString());
                }
            }
        } else if (json.isJsonArray()) {
            JsonArray jsonArray = json.getAsJsonArray();
            for (int i = 0; i < jsonArray.size(); i++) {
                JsonElement value = jsonArray.get(i);
                String newRoot = (root.isEmpty())? "[" + i + "]" : root + "[" + i + "]";
                if (value.isJsonObject() || value.isJsonArray()) {
                    convertJsonToMap(value, newRoot, resultMap, ignoreFields);
                } else if(value.isJsonPrimitive()){
                    resultMap.put(newRoot, value.getAsJsonPrimitive().getAsString());
                }
            }
        }
    }

    /**
     * 执行实际的比较操作，返回包含差异的Map
     *
     * @param sourceMap  原始Map
     * @param targetMap 当前Map
     * @return 包含差异的Map
     */
    private static Map<String, Map<String, String>> doCompare(Map<String, String> sourceMap, Map<String, String> targetMap) {
        Map<String, Map<String, String>> diffMap = new HashMap<>();
        for (Map.Entry<String, String> entry : targetMap.entrySet()) {
            String key = entry.getKey();
            String newValue = entry.getValue();
            String oldValue = sourceMap.get(key);
            if (sourceMap.containsKey(key)) {
                if (!ObjectUtils.equals(newValue, oldValue)) {
                    addDiffMap(diffMap, key, oldValue, newValue);
                }
            } else {
                addDiffMap(diffMap, key, StringUtils.EMPTY, newValue);
            }
        }
        return diffMap;
    }


    /**
     * 将差异项添加到差异映射中。
     *
     * 此方法用于在处理两个数据集的差异时，将特定的差异项添加到一个映射中，
     * 其中每个差异项由一个键值对表示，包括源值和目标值。
     *
     * @param diffMap 保存差异项的映射，其中键是差异项的标识，值是包含源值和目标值的映射。
     * @param key 差异项的标识，用于在diffMap中作为键。
     * @param value 源对象中的值，表示差异的起始点。
     * @param targetValue 目标对象中的值，表示与源值不同的目标值。
     */
    private static void addDiffMap(Map<String, Map<String, String>> diffMap, String key, String value, String targetValue) {
        Map<String, String> diffItemMap = new HashMap<>();
        diffItemMap.put(SOURCE_VALUE, value);
        diffItemMap.put(TARGET_VALUE, targetValue);
        diffMap.put(key, diffItemMap);
    }
}
知北游z
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
利用Java反射机制实现对象相同字段的复制操作
08-24
Java反射机制是Java语言中一个强大的工具，可以实现对象相同字段的复制操作。下面是对该机制的详细介绍和分析。 一、为什么需要对象相同字段的复制操作？ 在项目开发中，我们经常需要在不同的对象之间复制值，这是...
简单DTO对象比较工具类
hyl29742的博客
06-13 531
因工作需要对两个数据库表DTO对象进行比较。 public class CompareFacility { public static boolean objectEqualsTo(Object t1,Object t2){ boolean result = true; if( t1 == null || t2 == null){ throw new NullPointerException(); } .
Java对象通用比对工具
最新发布
(づ￣ 3￣)づxl
07-06 895
前段时间的任务中，遇到了需要识别两个对象不同属性的场景，如果使用传统的一个个属性比对equals方法，会存在大量的重复工作，而且为对象新增了属性后，比对方法也需要同步修改，不方便维护，于是便打算构造一个通用的比对方法。对于基本对象判断，如果返回object类型需要进一步解析判断，后续如果有其他基本对象，比如业务自定义的基本对象也可以往里面加，或者再进行优化，通过本地线程的方式动态指定基本对象类型。这里记录了根对象，当前处理的对象，以及反射获取的对象信息。一个java对象，他的属性是多样的，会有。
对象字段对比工具类
qq_34677946的博客
01-16 355
对象变更, 字段对比，支持列表通过指定基准字段进行对比，支持查询变更记录自定义视图返回给前端。
Java工具类：CompareUtils（比较对象字段值变化）
热门推荐
小白一个
05-06 1万+
目录 前言 示例引入 工具文件 CompareUtils Compare CompareNode 前言 我们在工作中，可能会在日志中记录数据的变化情况，这样可以有助于运维人员对问题排查。 或者在公共处理的数据增加一个日志页面，记录每次修改的变化。比如：小王在 2022-05-05 23:58:27 时间点修改了年龄，把 28 改为了 18）， 这样也可以方便用户的数据追踪，这样公共数据一旦出了问题，我们从日志进行跟踪，那么最后是谁造成的，也就一目了然。 可见，展示字段值的变化..
通用对象比较工具类-GeneralComparator
Have U created values TODAY
08-27 1621
由于公司有同步数据的逻辑，涉及到对大批量数据的对比，选择性覆盖，需要对许多不同的数据Beans进行对比。 以前都是针对不同对象重写equals方法，面对大量不同值对象，需要重写很多，比较麻烦，而且重写equals方法大多也只是变量值进行比较。； 有看过别人写的一些，很多都很不理想。。So 一言不合就写个工具类 简单的逻辑 1、判断类型，基本类型、集合、对象分别处理； 2、基本类型
java 对象属性比较工具类
zhouzhiwengang的专栏
09-14 4661
package com.zxy.product.human.web.log; import java.lang.reflect.Field; import java.util.HashMap; import java.util.Map; import com.google.common.collect.Maps; /**  * BeanUtil 对象属性比较工具类
对象字段变化比较工具
07-26
2. **递归比较**：对于嵌套的对象或包含复杂数据结构的对象，工具需要能够递归地比较每个字段，包括子对象和数组等。 3. **自定义比较逻辑**：有些字段可能需要特定的比较规则，例如日期的比较可能需要考虑时区，...
SQL Server数据库中的表名称、字段比较
09-09
因此，开发一个工具来自动比较不同版本数据库的表和字段差异是很有必要的。 在提供的代码片段中，可以看到一个简单的控制台应用程序，它使用ADO.NET连接到SQL Server并获取两个数据库（ttPRD和ttQAS）的表信息。`...
Java对象属性数据比较，返回变化数据
05-16
`ObjectCompareUtil.java`很可能就是一个工具类，提供了静态方法来比较两个对象的属性差异。 在`ObjectCompareUtil`中，可能会有如下的核心方法： ```java public static <T> Map, DiffResult> compareObjects(T ...
ObjectCompares:比较两个引用类型的所有属性值和字段值是否相等。可用于判断一个Clone的对象和原对象比较，看是否被更改过
05-23
`ObjectCompares` 类似于这样的工具，它提供了一个方便的方式来深度比较两个引用类型的实例，确保它们的属性和字段值都完全一致。 `ObjectCompares` 类可能包含以下功能： 1. **深度比较**：此工具能够递归地遍历...
（二十）Java工具类Diffable、DiffBuilder、Diff比较对象的区别及建造者模式详解
OceanSky的专栏
02-08 4196
建造者模式（Builder pattern）使用多个简单的对象一步一步的构建成一个复杂的对象，这种类型的设计模式属于创建型模式，他提供了一种创建对象的最佳方式； 一个Builder类会一步一步的构造最终的对象，该Builder类是独立于其它对象的； 建造者模式主要是解决在软件系统中，有时候面临者一个复杂对象的创建工作，其通常由各个部分的子对象用一定的算法构成，由于需求的变化，这个复杂对象的各个部分...
比较map对象之间的工具类，特殊场景，value的string类型相等，认同为相等（附源码）
cucgyfjklx的博客
05-19 1万+
比较map对象之间的工具类，特殊场景，value的string类型相等，认同为相等（附源码）
常用对象判断工具类ObjectUtils
oswin_bfcx的博客
07-17 1922
package com.asiainfo.esb.ailog.common.utils; import java.util.Base64; import java.util.Collection; import java.util.Map; /** * <h1>对象操作工具类</h1> * @author dengyw * @date 2019年7月16日 下...
java比较两个实体类及属性差异工具类(简版)
AnNong
11-09 5490
思路：通过反射技术获取所有属性并进行对比，详细步骤如下： package com.app.business.utils; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.Method; import java.sql.Timestamp; import...
java怎么比较两个实体类的属性值
chendyi0的博客
09-11 2152
java怎么比较两个实体类的属性值 package cn.mollie.utils; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.Method; import java.sql.Timestamp; import java.util.ArrayList; import java.util.Arrays; import java.util.Date; impor
同对象比较工具类(计算变化趋势、变化百分比)
QWQ19980801的博客
07-14 679
同一对象比较属性，获取变化趋势和变化百分比
java实现对象对比工具类
flyq_coffee
02-24 1643
目录说明对比示例/结果源码 说明 此工具类对比两个Java对象相同属性以及不同属性 对比示例/结果 对比示例,可以对比实体，实体中嵌套实体，实体中嵌套集合等 { "id":"", "username":"", "age":0, "address":[ { "province":"", "city":"", "disrtict":"" } ], "details":{ "sex":"", "mobile":"" } } 一下对比结果(更多测试可使用下方源码进行
java两个对象实体类字段值进行对比，以一个为基准，不同则进行更新操作，插入ES索引，代码样例demo
09-27
### 回答1： 可以这样实现：首先，比较两个实体类字段值，如果不同，则使用ES API更新索引；其次，可以使用Java 8流式编程的方式，对实体类属性进行对比，不同则进行更新操作；最后，使用Apache Commons Lang库提供的ObjectUtils工具类，可以实现把Java对象以JSON格式插入ES索引。 ### 回答2： 以下是一个用Java编写的示例代码，用于比较两个对象实体类的字段值并进行更新操作，并插入ES索引： ```java import org.elasticsearch.client.RestHighLevelClient; import org.elasticsearch.common.xcontent.XContentType; import org.elasticsearch.action.index.IndexRequest; import org.elasticsearch.action.index.IndexResponse; import org.elasticsearch.client.RequestOptions; import java.io.IOException; public class ObjectComparisonDemo { public static void main(String[] args) { YourEntityClass object1 = getObject1(); // 第一个对象实例 YourEntityClass object2 = getObject2(); // 第二个对象实例 if (!object1.equals(object2)) { // 检查两个对象是否不同 // 更新对象1的字段值为对象2的字段值 object1.setField1(object2.getField1()); object1.setField2(object2.getField2()); // ... 更新其他字段 // 插入ES索引 RestHighLevelClient client = createElasticsearchClient(); IndexRequest request = new IndexRequest("your_index_name"); request.source(object1.toJson(), XContentType.JSON); try { IndexResponse response = client.index(request, RequestOptions.DEFAULT); if (response.getResult() == IndexResponse.Result.CREATED) { System.out.println("数据插入ES索引成功！"); } else { System.out.println("数据插入ES索引失败！"); } } catch (IOException e) { e.printStackTrace(); } finally { try { client.close(); } catch (IOException e) { e.printStackTrace(); } } } } // 创建Elasticsearch客户端 private static RestHighLevelClient createElasticsearchClient() { // 根据实际情况配置Elasticsearch连接参数并创建客户端 return new RestHighLevelClient(/* Elasticsearch连接参数配置 */); } // 返回第一个对象实例的示例方法，请根据实际情况替换成自己的实现 private static YourEntityClass getObject1() { YourEntityClass object1 = new YourEntityClass(); // 设置对象1的字段值 object1.setField1("value1"); object1.setField2("value2"); // ... 设置其他字段的值 return object1; } // 返回第二个对象实例的示例方法，请根据实际情况替换成自己的实现 private static YourEntityClass getObject2() { YourEntityClass object2 = new YourEntityClass(); // 设置对象2的字段值 object2.setField1("updatedValue1"); object2.setField2("updatedValue2"); // ... 设置其他字段的值 return object2; } } // 你的实体类示例，请根据实际情况替换成自己的实现 class YourEntityClass { private String field1; private String field2; // ... 其他字段 // getter和setter方法 public String getField1() { return field1; } public void setField1(String field1) { this.field1 = field1; } public String getField2() { return field2; } public void setField2(String field2) { this.field2 = field2; } // JSON序列化方法 public String toJson() { // 根据实际情况将对象转为JSON字符串 // 使用第三方库，如Gson、Jackson等 return /* 返回JSON字符串 */; } } ``` 这个示例程序包含了以下内容： 1. `YourEntityClass`类：代表你的实体类，其中包含了需要对比的字段和相关的getter和setter方法。 2. `getObject1()`和`getObject2()`方法：实例化第一个和第二个对象实例的示例方法，你需要根据实际情况替换成自己的实现。 3. `RestHighLevelClient`类：用于与Elasticsearch服务进行交互，你需要根据实际情况配置Elasticsearch连接参数并创建客户端。 4. 对象实例的字段值对比逻辑：通过比较两个对象实例的字段值是否相等，如果不相等，则将对象1的字段值更新为对象2的字段值。 5. 在字段值更新后，将对象1的内容插入到Elasticsearch索引中。 ### 回答3： 在Java中，对比两个对象实体类字段的值并进行更新操作，然后插入ES索引的示例代码如下： 首先，我们假设有一个实体类Person，它有几个字段：id、name、age。 ```java public class Person { private long id; private String name; private int age; // 省略构造函数、getter和setter方法 } ``` 接下来，我们使用一个新的Person对象实例来和已有的Person对象进行对比，判断是否有字段值不同，然后进行更新操作和插入ES索引。 ```java Person existingPerson = ...; // 已有的Person对象 Person newPerson = ...; // 新的Person对象 // 对比id字段 if (existingPerson.getId() != newPerson.getId()) { existingPerson.setId(newPerson.getId()); } // 对比name字段 if (!existingPerson.getName().equals(newPerson.getName())) { existingPerson.setName(newPerson.getName()); } // 对比age字段 if (existingPerson.getAge() != newPerson.getAge()) { existingPerson.setAge(newPerson.getAge()); } // 更新操作 update(existingPerson); // 插入ES索引 insertIntoES(existingPerson); ``` 上述代码逐个字段对比，如果字段值不同就进行更新操作。在实际应用中，可能需要根据具体的业务需求来调整对比逻辑。 更新操作和插入ES索引的具体实现方法根据使用的技术栈不同而有所差异，比如使用Hibernate时，可以使用`Session.update()`方法来更新数据库记录；使用Elasticsearch时，可以使用相应的Java客户端库来插入ES索引。 总之，以上示例代码提供了一个基本的框架，通过对比字段值的方式来实现更新操作和插入ES索引。根据具体的业务需求和技术栈选择相应的实现方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

知北游z

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值