异或运算和进制之间转换(案列:和储物柜对接)

最新推荐文章于 2023-03-20 14:40:04 发布
最新推荐文章于 2023-03-20 14:40:04 发布
阅读量231 收藏
点赞数
分类专栏： JAVA 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43863180/article/details/125042410
版权

详解Java异或运算符

异或是⼀种基于⼆进制的位运算，⽤符号XOR或者^表⽰，其运算法则是对运算符两侧数的每⼀个⼆进制位同值则取0，异值则取1.
简单理解就是不进位加法，如1+1=0，0+0=0，1+0=1.
For example: 3^5 = 6
转成⼆进制后就是 0011 ^ 0101 ⼆号位和三号位都是异值取1 末尾两个1同值取零，所以3^5 = 0110 = 6

文章目录

前言

异或运算主要用于判断两个值是否一样
异或运算的3个性质：
1.任何数和0进行异或运算，结果是原来的数，即b⊕0=b
2.任何数和其自身进行异或运算，结果为0，即b⊕b=0。
3.异或运算满足交换律和结合律，即x⊕y⊕x=y⊕(x⊕x)=y

一、异或工具类

代码如下（示例）：

package com.bly.demo;

import java.math.BigInteger;

/**
 * @ClassName BaseConversionUtils
 * @Author zhao
 * @Date 9:53 2022/05/30
 * @Description 进制转换类和校验和互相异或 计算 
 * @Version 1.0
 **/
public class BaseConversionUtils {

	/**
	 * 校验和 互相异或 计算 传字符串 例如：“8A010133” 结果：b9
	 */
	public static String getCheckXOR(String s) {
		String regex = "(.{2})";
		String replace = s.replaceAll(regex, "$1 ");
		String[] st = replace.split(" ");
		int[] c = new int[st.length + 1];
		for (int i = 0; i < st.length; i++) {
			int i1 = Integer.parseInt(st[i], 16);
			c[i] = i1;
		}
		char x = 0;
		for (int i = 0; i < c.length; i++) {
			x ^= c[i];
		}
		return String.format("%x", (int) x);

	}
	/**
	 * 十进制转换指定进制大小进制(11- 20 进制内 闭区间)
	 *
	 * @param original
	 *            十进制显示的数字字符串 (最大支持long的最大)
	 * @param baseType
	 *            转换后对的进制类型
	 * @return
	 */
	public static String encrypt(String original, BaseType baseType) {
		if (baseType == null) {
			throw new RuntimeException("进制转换类型不能为null");
		}
		Long length = baseType.getBaseLength();
		long value = Long.valueOf(original).longValue();
		StringBuilder builder = new StringBuilder();
		int i = 0;
		while (value != 0) {
			long t = value % length;
			if (t >= 0 && t < 10) {
				builder.append((char) (t + '0'));
			} else {
				builder.append((char) (t + 'A' - 10));
			}
			i++;
			value = value / length;
		}
		String num = builder.reverse().toString();

		while (num.startsWith("0")) {
			num = num.substring(1, num.length());
		}
		return num;
	}

	/**
	 * 十进制转换指定进制大小进制(11- 20 进制内 闭区间)
	 *
	 * @param original
	 *            十进制显示的数字字符串
	 * @param baseType
	 *            转换后对的进制类型
	 * @return
	 */
	public static String encryptByBigInt(String original, BaseType baseType) {
		if (baseType == null) {
			throw new RuntimeException("进制转换类型不能为null");
		}
		BigInteger length = BigInteger.valueOf(baseType.getBaseLength());
		BigInteger value = new BigInteger(original);
		StringBuilder builder = new StringBuilder();
		int i = 0;
		while (!value.toString().equals("0")) {
			int t = value.mod(length).intValue();
			if (t >= 0 && t < 10) {
				builder.append((char) (t + '0'));
			} else {
				builder.append((char) (t + 'A' - 10));
			}
			i++;
			value = value.divide(length);
		}
		String num = builder.reverse().toString();

		while (num.startsWith("0")) {
			num = num.substring(1, num.length());
		}
		return num;
	}

	/**
	 * 十进制转换指定进制大小进制(11- 35 进制内 闭区间) 十进制字符串包括以0开头的编译(转换值在long范围类)
	 *
	 * @param original
	 *            十进制显示的数字字符串
	 * @param baseType
	 *            转换后对的进制类型
	 * @return
	 */
	public static String encryptToStartZero(String original, BaseType baseType) {
		if (baseType == null) {
			throw new RuntimeException("进制转换类型不能为null");
		}
		Long length = baseType.getBaseLength();
		int a = 0;
		while (original.startsWith("0")) {
			original = original.substring(1, original.length());
			a++;
		}
		long value = Long.valueOf(original).longValue();
		StringBuilder builder = new StringBuilder();
		int i = 0;
		while (value != 0) {
			long t = value % length;
			if (t >= 0 && t < 10) {
				builder.append((char) (t + '0'));
			} else {
				builder.append((char) (t + 'A' - 10));
			}
			i++;
			value = value / length;
		}
		String num = builder.reverse().toString();
		while (num.startsWith("0")) {
			num = num.substring(1, num.length());
		}
		if (a == 0) {
			num = "1" + num;
		} else {
			num = "0" + a + num;
		}
		return num;
	}

	/**
	 * 十进制转换指定进制大小进制(11- 35 进制内 闭区间) 十进制字符串包括以0开头的编译
	 *
	 * @param original
	 *            十进制显示的数字字符串
	 * @param baseType
	 *            转换后对的进制类型
	 * @return
	 */
	public static String encryptToStartZeroToBigInt(String original, BaseType baseType) {
		if (baseType == null) {
			throw new RuntimeException("进制转换类型不能为null");
		}
		BigInteger length = BigInteger.valueOf(baseType.getBaseLength());
		int a = 0;
		while (original.startsWith("0")) {
			original = original.substring(1, original.length());
			a++;
		}

		BigInteger value = new BigInteger(original);
		StringBuilder builder = new StringBuilder();
		int i = 0;
		while (!value.toString().equals("0")) {
			int t = value.mod(length).intValue();
			if (t >= 0 && t < 10) {
				builder.append((char) (t + '0'));
			} else {
				builder.append((char) (t + 'A' - 10));
			}
			i++;
			value = value.divide(length);
		}
		String num = builder.reverse().toString();
		while (num.startsWith("0")) {
			num = num.substring(1, num.length());
		}
		if (a == 0) {
			num = "1" + num;
		} else {
			num = "0" + a + num;
		}
		return num;
	}

	/**
	 * 进制大小进制(11- 35 进制内 闭区间)转换为10进制 (编译前只支持long的最大值 否则结果会不正确)
	 *
	 * @param translation
	 *            (11- 35 进制内 闭区间)进制显示的数字字符串
	 * @param baseType
	 *            需要转换的进制类型
	 * @return
	 */
	public static String decrypt(String translation, BaseType baseType) {
		Long length = baseType.getBaseLength();
		long result = 0;
		long wei = 1;
		char[] chars = translation.toCharArray();
		for (int i = chars.length - 1; i >= 0; i--) {
			int a = 0;
			switch (chars[i]) {
				case 'A' :
					a = 10;
					break;
				case 'B' :
					a = 11;
					break;
				case 'C' :
					a = 12;
					break;
				case 'D' :
					a = 13;
					break;
				case 'E' :
					a = 14;
					break;
				case 'F' :
					a = 15;
					break;
				case 'G' :
					a = 16;
					break;
				case 'H' :
					a = 17;
					break;
				case 'I' :
					a = 18;
					break;
				case 'J' :
					a = 19;
					break;
				case 'K' :
					a = 20;
					break;
				case 'L' :
					a = 21;
					break;
				case 'M' :
					a = 22;
					break;
				case 'N' :
					a = 23;
					break;
				case 'O' :
					a = 24;
					break;
				case 'P' :
					a = 25;
					break;
				case 'Q' :
					a = 26;
					break;
				case 'R' :
					a = 27;
					break;
				case 'S' :
					a = 28;
					break;
				case 'T' :
					a = 29;
					break;
				case 'U' :
					a = 30;
					break;
				case 'V' :
					a = 31;
					break;
				case 'W' :
					a = 32;
					break;
				case 'X' :
					a = 33;
					break;
				case 'Y' :
					a = 34;
					break;
				case 'Z' :
					a = 35;
					break;
				default :
					a = Integer.valueOf(String.valueOf(chars[i]));
					break;
			}
			result += a * wei;
			wei *= length;
		}
		return String.valueOf(result);
	}

	/**
	 * 进制大小进制(11- 35 进制内 闭区间)转换为10进制
	 *
	 * @param translation
	 *            (11- 35 进制内 闭区间)进制显示的数字字符串
	 * @param baseType
	 *            需要转换的进制类型
	 * @return
	 */
	public static String decryptByBigInt(String translation, BaseType baseType) {
		BigInteger length = BigInteger.valueOf(baseType.getBaseLength());
		BigInteger result = new BigInteger("0");
		BigInteger wei = new BigInteger("1");
		char[] chars = translation.toCharArray();
		for (int i = chars.length - 1; i >= 0; i--) {
			long a = 0;
			switch (chars[i]) {
				case 'A' :
					a = 10l;
					break;
				case 'B' :
					a = 11l;
					break;
				case 'C' :
					a = 12l;
					break;
				case 'D' :
					a = 13l;
					break;
				case 'E' :
					a = 14l;
					break;
				case 'F' :
					a = 15l;
					break;
				case 'G' :
					a = 16l;
					break;
				case 'H' :
					a = 17l;
					break;
				case 'I' :
					a = 18l;
					break;
				case 'J' :
					a = 19l;
					break;
				case 'K' :
					a = 20l;
					break;
				case 'L' :
					a = 21l;
					break;
				case 'M' :
					a = 22l;
					break;
				case 'N' :
					a = 23l;
					break;
				case 'O' :
					a = 24l;
					break;
				case 'P' :
					a = 25l;
					break;
				case 'Q' :
					a = 26l;
					break;
				case 'R' :
					a = 27l;
					break;
				case 'S' :
					a = 28l;
					break;
				case 'T' :
					a = 29l;
					break;
				case 'U' :
					a = 30l;
					break;
				case 'V' :
					a = 31l;
					break;
				case 'W' :
					a = 32l;
					break;
				case 'X' :
					a = 33l;
					break;
				case 'Y' :
					a = 34l;
					break;
				case 'Z' :
					a = 35l;
					break;
				default :
					a = Long.valueOf(String.valueOf(chars[i]));
					break;
			}
			BigInteger multiply = wei.multiply(BigInteger.valueOf(a));
			result = result.add(multiply);
			wei = wei.multiply(length);
		}
		return result.toString();
	}

	/**
	 * 进制大小进制(11- 35 进制内 闭区间)转换为10进制 数字字符串有零开头的情况 (编译前只支持long的最大值 否则结果会不正确)
	 *
	 * @param translation
	 *            (11- 35 进制内 闭区间)进制显示的数字字符串
	 * @param baseType
	 *            需要转换的进制类型
	 * @return
	 */
	public static String decryptToStartZero(String translation, BaseType baseType) {
		Long length = baseType.getBaseLength();
		long result = 0;
		long wei = 1;
		int a1 = 0;
		if (translation.startsWith("0")) {
			char c = translation.charAt(1);
			a1 = Integer.valueOf(String.valueOf(c));
			translation = translation.substring(2, translation.length());
		} else {
			translation = translation.substring(1, translation.length());
		}
		char[] chars = translation.toCharArray();
		for (int i = chars.length - 1; i >= 0; i--) {
			int a = 0;
			switch (chars[i]) {
				case 'A' :
					a = 10;
					break;
				case 'B' :
					a = 11;
					break;
				case 'C' :
					a = 12;
					break;
				case 'D' :
					a = 13;
					break;
				case 'E' :
					a = 14;
					break;
				case 'F' :
					a = 15;
					break;
				case 'G' :
					a = 16;
					break;
				case 'H' :
					a = 17;
					break;
				case 'I' :
					a = 18;
					break;
				case 'J' :
					a = 19;
					break;
				case 'K' :
					a = 20;
					break;
				case 'L' :
					a = 21;
					break;
				case 'M' :
					a = 22;
					break;
				case 'N' :
					a = 23;
					break;
				case 'O' :
					a = 24;
					break;
				case 'P' :
					a = 25;
					break;
				case 'Q' :
					a = 26;
					break;
				case 'R' :
					a = 27;
					break;
				case 'S' :
					a = 28;
					break;
				case 'T' :
					a = 29;
					break;
				case 'U' :
					a = 30;
					break;
				case 'V' :
					a = 31;
					break;
				case 'W' :
					a = 32;
					break;
				case 'X' :
					a = 33;
					break;
				case 'Y' :
					a = 34;
					break;
				case 'Z' :
					a = 35;
					break;
				default :
					a = Integer.valueOf(String.valueOf(chars[i]));
					break;
			}
			result += a * wei;
			wei *= length;
		}
		if (a1 != 0) {
			String suffix = "";
			for (int i = a1; i > 0; i--) {
				suffix += 0;
			}
			return suffix + String.valueOf(result);
		}
		return String.valueOf(result);
	}

	/**
	 * 进制大小进制(11- 35 进制内 闭区间)转换为10进制 数字字符串有零开头的情况
	 *
	 * @param translation
	 *            (11- 35 进制内 闭区间)进制显示的数字字符串
	 * @param baseType
	 *            需要转换的进制类型
	 * @return
	 */
	public static String decryptToStartZeroByBigInt(String translation, BaseType baseType) {
		BigInteger length = BigInteger.valueOf(baseType.getBaseLength());
		BigInteger result = BigInteger.valueOf(0l);
		BigInteger wei = BigInteger.valueOf(1l);
		int a1 = 0;
		if (translation.startsWith("0")) {
			char c = translation.charAt(1);
			a1 = Integer.valueOf(String.valueOf(c));
			translation = translation.substring(2, translation.length());
		} else {
			translation = translation.substring(1, translation.length());
		}
		char[] chars = translation.toCharArray();
		for (int i = chars.length - 1; i >= 0; i--) {
			long a = 0;
			switch (chars[i]) {
				case 'A' :
					a = 10l;
					break;
				case 'B' :
					a = 11l;
					break;
				case 'C' :
					a = 12l;
					break;
				case 'D' :
					a = 13l;
					break;
				case 'E' :
					a = 14l;
					break;
				case 'F' :
					a = 15l;
					break;
				case 'G' :
					a = 16l;
					break;
				case 'H' :
					a = 17l;
					break;
				case 'I' :
					a = 18l;
					break;
				case 'J' :
					a = 19l;
					break;
				case 'K' :
					a = 20l;
					break;
				case 'L' :
					a = 21l;
					break;
				case 'M' :
					a = 22l;
					break;
				case 'N' :
					a = 23l;
					break;
				case 'O' :
					a = 24l;
					break;
				case 'P' :
					a = 25l;
					break;
				case 'Q' :
					a = 26l;
					break;
				case 'R' :
					a = 27l;
					break;
				case 'S' :
					a = 28l;
					break;
				case 'T' :
					a = 29l;
					break;
				case 'U' :
					a = 30l;
					break;
				case 'V' :
					a = 31l;
					break;
				case 'W' :
					a = 32l;
					break;
				case 'X' :
					a = 33l;
					break;
				case 'Y' :
					a = 34l;
					break;
				case 'Z' :
					a = 35l;
					break;
				default :
					a = Long.valueOf(String.valueOf(chars[i]));
					break;
			}
			result = result.add(wei.multiply(BigInteger.valueOf(a)));
			wei = wei.multiply(length);
		}
		if (a1 != 0) {
			String suffix = "";
			for (int i = a1; i > 0; i--) {
				suffix += 0;
			}
			return suffix + result.toString();
		}
		return String.valueOf(result);
	}

	/**
	 * 进制种类枚举
	 */
	public enum BaseType {
		BASE_11(11L), BASE_12(12L), BASE_13(13L), BASE_14(14L), BASE_15(15L), BASE_16(16L), BASE_17(17L), BASE_18(18L), BASE_19(19L), BASE_20(20L), BASE_21(21L), BASE_22(22L), BASE_23(23L), BASE_24(24L), BASE_25(25L), BASE_26(26L), BASE_27(
				27L), BASE_28(28L), BASE_29(29L), BASE_30(30L), BASE_31(31L), BASE_32(32L), BASE_33(33L), BASE_34(34L), BASE_35(35L);
		private Long BaseLength;

		public Long getBaseLength() {
			return BaseLength;
		}

		public void setBaseLength(Long baseLength) {
			BaseLength = baseLength;
		}

		BaseType(Long baseLength) {
			this.BaseLength = baseLength;
		}
	}
}

二、使用步骤

	public static void main(String[] args) {
		String result = "";
		// 我这是开第二十四个个柜子
		String num = StringUtils.leftPad(BaseConversionUtils.encrypt("15", BaseConversionUtils.BaseType.BASE_16), 2, '0');
		System.out.println(num);
		result = "8A01" + num + "33";
		// 异或运算的值
		String checkXOR = BaseConversionUtils.getCheckXOR(result);
		System.out.println(checkXOR);
		result += checkXOR;
		// 最后发送的命令
		System.out.println(result);
		}

总结

运算规则：相同取0，相异取1
在这里插入图片描述
大家理解一下思想就好了

小小小蜗牛|
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java编程实现对十六进制字符串异或运算代码示例
08-28
"Java 编程实现对十六进制字符串异或运算代码示例" ...这个示例展示了 Java 语言实现对十六进制字符串异或运算的详细过程，包括将十六进制字符串转换为二进制形式、进行异或运算、将结果转换回十六进制字符串等步骤。
借助逻辑运算符—异或（^）实现俩数交换
weixin_67774721的博客
08-02 986
对于通过异或运算进行数字交换操作的原理及其注意事项的解读。
Java-异或运算详解
chara9885的博客
03-20 7671
异或运算会应用在很多算法题中,这里整理了几个最常见的应用场景
浅谈异或（^），与（&），或（|）
qq_49169308的博客
12-22 1472
今天在学习hashmap源码时偶然看到这样一段代码： static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } 我当场失忆了，(h = key.hashCode()) ^ (h >>> 16)这是啥？很熟悉但是又想不起来是什么了（大佬不要笑我，我很菜的）。 吓得我马上去
异或运算 XOR ⊕ 教程
weixin_39910711的博客
06-21 6616
大家比较熟悉的逻辑运算，主要是"与运算"（AND）和"或运算"（OR），还有一种"异或运算"（XOR），也非常重要。 本文介绍异或运算的含义和应用。
异或运算实现两数交换
weixin_43433801的博客
08-25 3404
本文介绍了使用异或运算实现两个数的交换的方法
十六进制字符串按位异或运算工具和java位异或运算
10-27
当两个十六进制字符串进行按位异或运算时，会先将它们转换为二进制形式，然后逐位进行异或操作。异或运算是对两个位进行比较，如果两个位相同，则结果为0；如果两个位不同，则结果为1。 在Java中，我们可以利用`...
十六进制字符串按位异或校验和和校验工具
10-22
3. 最终，所有的异或结果会汇聚成一个单一的二进制数，转换为十六进制形式后，就是校验和。 这种校验方法的原理基于这样一个事实：对于任何数据，其本身与自身的异或结果总是0。因此，如果数据在传输过程中没有改变...
小工具集合(总加和，异或，进制转换)
11-19
小工具集合，包括三个小工具，总加和， 异或， 进制转换
异或和乘法的转换
weixin_33868027的博客
04-04 3151
今天做matlab发现0 1的异或运算和1，-1的乘法运算是可以等价的。 异或运算中设0=A，1=B 乘法运算中设-1=A，1=B 则对于异或运算： A^B=A; A^A=B; B^B=A; 对于乘法运算,同样有： A^B=A； A*A=B； B^B=B 所以在某些情况下如果异或或者乘法难以实现，可以试试将两者转换 转载于:https:/...
异或生成器小软件
01-24
功能：加空格，去空格，字节形式，长度计算，异或计算 适合hex报文分析
异或计算器及字符串之间的转换
09-16
根据界面上的提示，选择相应的功能。系统会根据输入字符的形式先判断合法性。然后将字符显示在计算结果中。
如何用异或运算交换两个数的值
m0_58969296的博客
04-23 1892
" ^ "——异或运算，二元操作运算符，对两个操作元的每个二进制位进行异或运算，运算规则为： 1^1=0，1^0=1，0^1=1，0^0=0；0^n=n，n^n=0。即相同为0，不同为1，但是这样很容易混淆，可以把异或运算记为无进位相加，如0和1异或就是1，1和1异或就会进位，要忽略，就是0。 那么如何不用临时变量去交换两个数的值呢，那么就可以利用0和任何数异或都为这个数本身，任何数和本身异或都为0，这个性质来交换两个数的值，举个例子： public static void main(String[
异或问题-------将a串转换为b串
lisads的博客
03-13 416
问题 B: 异或和或 对于一个长度为n的01序列 你可以进行以下任意次操作： 1、选择两个下标1≤i，j≤n（i≠j） 2、记x=aixor aj，y=aior aj 其中xor表示按位“异或”，or表示按位 “或” （不懂异或运算和或运算的点这里位运算） 3、然后令aj=x , ai= y 或者 ai=y ,aj=x; 给定两个01序列 s ,t 。请你判断是否可以通过有限次（可以为0次）操作将序列 s 转化为 t。 输入 第一行一个整数k，表示数据的组...
异或和同或之间的转换
热门推荐
soilblack2012的专栏
11-08 1万+
变量与变量的关系： 异或：xor(A , A)=0 xor(A,A')=1 xor(A,0)=A xor(A,1)=A' 同或：nxor(A , A)=1 nxor(A , A')=0 nxor(A , 1)=A nxor(A , 0)=A'多变量运算 异或：结果取决于变量为1的个数 A0 ^ A1 ^...^ A(n-1) ^ An = 1 变量为1的个数是奇数           
进制转换异或运算
大海技术博客
09-19 2336
进制转换异或运算 写小程序最近用到十六进制异或运算,开始怎样都异或运算到计算器上的值 最终方案是十六进制转换为十进制,结果在转换为十六进制就可以了 /将帧有数值转化为字符串 zhen001 = zhen01.toString(); // 将帧由16进制转10进制 zhen1 = parseInt(zhen001, 16); console.log('飞zhen1', zhe
^异或实现两数交换
屁屁屁喏漕
12-26 7603
转载于：https://blog.csdn.net/zxm1306192988/article/details/50446399 原文：https://blog.csdn.net/u010141928/article/details/76140165  通常我们实现两数交换不得不引入一个临时变量temp作为媒介，而使用异或运算也能实现同样的功能，甚至无需使用临时变量。 这是一个通常的做法： ...
【进制转换＋异或运算】XOR Sorting HihoCoder - 1509
BlessingXRY的博客
02-03 467
Think: 1知识点：【进制转换＋异或运算】 2题意：输入一个序列a[1..n]，判断满足一下两个条件的S有多少个 (1):0 (2):对于i(1 3解题思路： (1):先将a[i]和a[i+1]转换为二进制，然后通过异或运算相同为零不同为一的性质和(a[i] xor S) vjudge题目链接 以下为Accepted代码 #include #include #inc
异或运算^
AlexMerer的博客
08-16 3798
异或运算与一般的逻辑或不同，异或算符的值为真仅当两个运算元中恰有一个的值为真，而另外一个的值为非真。转化为命题，就是：“两者的值不同。”或“有且仅有一个为真。”符号为 XOR 或 EOR 或 ⊕（编程语言中常用^）。 基本性质： 1、交换律        a^b = b^a 2、结合律       (a^b)^c = a^(b^c) 3、对于任何数x，都有     x^x=0，x^0=x ...
十六进制字符串按位异或运算工具和java
最新发布
09-07
首先，我们可以将十六进制字符串转换为二进制表示，然后再进行按位异或运算。可以使用Integer类的parseInt方法来将十六进制字符串转换为整型，然后使用Integer.toBinaryString方法将其转换为二进制表示。 接下来，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值