Java中获取几位不同的随机数

最新推荐文章于 2024-07-05 11:16:39 发布
原创 最新推荐文章于 2024-07-05 11:16:39 发布 · 2.8k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #random #exception #string #thread

本文介绍如何使用Java生成指定范围内的不重复随机数，并将其存储到集合中。此外，还探讨了从集合中正确迭代元素的方法，避免因错误的迭代逻辑导致的NoSuchElementException异常。 
       Set<Integer> set = new HashSet<Integer>();
        Random random = new Random();
        while (set.size() < 4) {//取得4个
            set.add(random.nextInt(10));//0-9范围数据
        }
        Iterator<Integer> it = set.iterator();
        List<Object> suit=new ArrayList<Object>(); 
        String matter="";
        for(;it.hasNext();){
            // matter+=it.next().toString()+"  ";
             suit.add(it.next());//切记不能两个一起添加，这样会认为迭代2次,会报异常错误：NoSuchElementException
        }
        System.out.println(matter);//或则直接这样输出
        for(int i=0;i<suit.size();i++)
        {
        	System.out.println(suit.get(i));
        }


 

 当报错这个错误的时候，只是说里面迭代了2次，比如我这样写:

String matter=""; 
for(;it.hasNext();)
{
matter+=it.next().toString()+"   ";
suit.add(it.next());
}
这样写就一定会报下面的错误。
Exception in thread "main" java.util.NoSuchElementException
	at java.util.HashMap$HashIterator.nextEntry(Unknown Source)
	at java.util.HashMap$KeyIterator.next(Unknown Source)

java随机数4-36位
12-12
随机数6位可以用于短信验证码，随机数30位适合订单编号（随机数+时间）
JAVA中获取不同随机数
blackxulei的专栏
03-27 602
      刚开始学习JAVA，最近在自己做一个 猜数字 小游戏。感觉获得4个不同随机数 是本程序的关键。之前在网上搜了些获取随机数的方法，但由于自己对JAVA理解尚浅，所以都不太能读懂。于是自己就已有知识，想了一个获得不同随机数的算法。   我就以从0—9中选4个不同随机数为例。     int[] anArray = new int[10];  for(int i = 0;i  {  
java 取不同的随机数_Java实现获取指定个数的不同随机数
weixin_35709751的博客
02-13 236
两个简单的例子，代码实现如下：1、随机拆分一个整数public static List randomList(int n){Random rand = new Random();List list = new ArrayList<>();int i = 0;while (i < n) {int num = rand.nextInt(n);if (!list.contains(nu...
Java 中获取随机数的多种方法
后端小知识呀
07-05 1586
在编程中，获取随机数是一项常见的需求，Java 提供了多种方式来生成随机数。本文将介绍几种在 Java 中获取随机数的方法，并提供相应的示例代码。
Java实现获取指定个数的不同随机数
08-26
今天小编就为大家分享一篇关于Java实现获取指定个数的不同随机数，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
浅谈Java中的n种随机数产生办法
09-03
在Java编程中，生成随机数是一项常见的任务，用于模拟、测试和各种算法中。本文将深入探讨Java中生成随机数的多种方法，并分析它们的适用场景和潜在问题。 首先，最基础的随机数生成方法是使用`java.lang.Math....
Java实现生成32位与8位随机数字符串方法
最新发布
07-13
本文将探讨如何使用Java实现生成32位与8位随机数字符串的方法。 首先，我们需要理解随机数的生成原理。随机数可以分为两类：伪随机数和真随机数。在大多数应用场景中，我们使用的是伪随机数，它们是由确定的算法...
Java实现生成不重复的指定位数随机数
07-03
具体到Java代码的实现，我们可以使用Java标准库中的Random类来生成随机数。Random类提供了nextLong()、nextInt()等方法来生成各种类型的随机数。然而，仅仅使用Random类并不能直接保证生成的随机数不重复。因此，...
Java随机数的几种实现方式
09-02
Java随机数的几种实现方式 Java语言提供了多种方法来生成随机数，每种方法都有其特定的应用场景和优势。以下将详细介绍四种常用的随机数生成方式：使用Math.random()、使用Random类、使用ThreadLocalRandom类以及...
Java产生随机五个不重复的数
m0_53677355的博客
01-09 7041
以下代码帮助理解随机数： import java.util.Random; public class Test3 { public static void main(String[] args) { Random random = new Random(); //随机产生一个int类型取值范围内的数字 int num1 = random.nextInt(); System.out.println(num1);
java获取随机的两位数字（可改为多位）
01-06
java获取随机的两位数字（可改为多位），可用于订单号后补数字等
Java获取随机数的3种方法
09-01
本篇文章主要介绍了Java获取随机数的3种方法，现在分享给大家，也给大家做个参考，感兴趣的小伙伴们可以参考一下。
JAVA获取5位随机数
weixin_38167847的博客
04-09 3940
package baofoo.utils; import org.junit.Test; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Random; import java.util.logging.SimpleFormatter; /** * 2 *...
【Java lang Math】获取N位随机数
开发学习工作日志
01-06 544
/** * 获取N位随机数 * * @param num * @return */ public static int getNbitRandomNumber(int num) { if (num <= 0) { throw new IllegalArgumentException(); ...
java获取随机10位数
weixin_33877700的博客
06-30 927
代码示例相关视频讲解：数组-Go代码演示科普文章：如何使用Java获取随机10位数 在编程中，有时我们需要生成随机的10位数。在Java中，我们可以利用Random类来生成随机数。本文将介绍如何使用Java来获取随机的10位数，并附上代码示例。 1. 使用Random类生成随机数 在Java中，Random类可以帮助我们...
java生成5随机数
Helios32的博客
11-21 1922
java实现指定范围生成随机数
JAVA产生五位随机验证码
qq_63161641的博客
03-22 1523
Java产生5位随机数
java 随机获得四位数字_javascript获取四位数字或者字母的随机数
weixin_39875760的博客
03-02 847
本章节通过代码实例介绍一下如何实现简单的四位随机数功能。比较简单的一种实现方式就是从数字和字母中随机抽取四个不重复的字符。代码实例如下:function only(ele,arr){if(arr.length==0){return true;}for(var j=0;jif(ele==arr[j]){return false;}else{return true;}}}var arr=[0,1,2,...
用Java实现一个五位的随机验证码
ttwxd的博客
01-02 1257
java简单实现随机生成二维码
Java获取六位随机数并且不可重复
03-20
<think>好的，我现在要解决用户的问题：用Java生成六位不重复的随机数。用户提到了之前的引用，我需要参考这些资料来提供方法。首先，我需要明确需求，六位不重复的随机数，可能指的是每个数字都不重复，或者整个六位数在生成过程中不重复。根据用户的例子，比如引用[1]中生成的是10位数，可能这里的“不重复”指的是整个数值不重复，而不是每个数字的位置不重复。不过需要确认。 然后，用户提供的示例代码中，使用String.format("%010d", ...)生成10位数字符串，并检查是否存在于列表中。这种方法在生成大量随机数时会有性能问题，因为列表的contains方法是O(n)时间复杂度。当数据量增加到十万级别时，效率会很低，如引用[3]中的测试显示时间可能较长。因此，需要考虑更高效的数据结构，比如HashSet，因为它的contains方法是O(1)时间复杂度。 接下来，用户需要的是六位数，所以范围是从100000到999999吗？不过如果允许前导零的话，可能范围是000000到999999，但六位数的字符串形式的话，可能需要补零到六位。比如，如果生成的数小于100000，用String.format("%06d", ...)来格式化为六位。 另外，生成方法需要确保不重复。一种方法是生成随机数，检查是否已经存在于一个集合中，如果存在则重新生成，直到找到一个不重复的。这种方法在接近覆盖所有可能值时，碰撞概率增加，生成时间会变长。对于六位数来说，总共有900000个可能的数值（从100000到999999），但如果允许前导零的话，是1000000个可能（000000到999999）。不过用户可能只需要六位数字，即不允许前导零，所以范围是100000到999999，共900000个可能值。这时候，如果用户需要生成的数量接近这个范围，比如生成几十万个，那么使用随机生成并检查的方法效率会很低。此时应该考虑其他方法，比如预先生成所有可能的数，然后随机打乱顺序，依次取出。但对于六位数来说，预先生成所有可能的值可能内存占用较大，但900000个整数大约占用几MB内存，应该是可行的。 不过用户可能只需要生成一个或多个不重复的六位数，比如每次生成一个，需要保证之前没有生成过。这时候，可能需要维护一个已生成的集合。但如果是单次生成一个六位数，不需要考虑历史记录，那么问题就简化为生成一个六位数，其中每一位数字都不重复。比如像123456这样的数，每位数字都不重复。这时候，问题就变成了生成一个六位数，每个数字都是唯一的。这可能和用户的问题有关，但根据用户的示例代码，他们可能指的是整个数值不重复，而不是每个数字的位置不重复。 需要进一步分析用户的问题。用户的问题描述是“生成一个六位不重复的随机数”，可能有两种情况：1）生成的数值本身在多次生成中不重复；2）生成的数值的各位数字不重复。例如，123456是六位且各位不重复，而112345则不符合。需要根据上下文判断。根据用户提供的引用中的例子，比如引用[1]中的代码生成的是十位数，并且检查整个字符串是否重复，因此可能用户的问题属于第一种情况，即生成的六位数整体不重复。但用户可能混淆了两种需求，需要进一步确认。 不过，根据用户给出的例子中的方法，比如引用[2]中的temp1变量，使用随机位置的方法，可能涉及到生成不重复的数值。或者，用户可能想要生成一个六位数，其中每一位数字都不重复。比如，像123456或135790这样的数，每一位数字都是唯一的。这时候，生成方法需要确保每个位置的数字不与之前的重复。 如果是这种情况，那么生成方法应该是：首先生成第一个数字（不能为0），然后依次生成后续的每个数字，确保不与前面的数字重复。例如，第一位可以是1-9，第二位是0-9中排除第一位，依此类推。这种方法可以生成一个每位都不重复的六位数。 例如，生成方法可以是： 1. 第一位选1-9中的随机数。 2. 第二位选剩下的9个数字中的随机数（包括0，排除第一位）。 3. 第三位选剩下的8个数字。 4. 依此类推，直到第六位。 这种方法可以保证每个数字都不重复，且总共有9×9×8×7×6×5= 136080种可能的组合。 但用户的问题可能更倾向于生成一个六位的数值，并且这个数值在之前生成的数值中没有出现过。例如，在系统中生成唯一的六位验证码，需要确保每次生成的验证码是唯一的。这时候，就需要维护一个已生成的集合，每次生成时检查是否已存在。 但根据用户给出的引用，例如引用[1]中的代码是生成十位数，并检查是否存在列表中，所以用户可能想要的是这种方法。但是当数据量很大时，使用ArrayList的contains方法效率低下，应该改用HashSet来提高效率。 因此，针对用户的请求，可能的解决方案有两种： 方案一：生成一个六位数，每个数字都不重复（例如123456）。 方案二：生成一个六位数，在全局范围内不重复（例如之前未生成过）。 需要根据用户的实际需求来选择。但根据用户的示例代码中的情况，可能更倾向于方案二。不过用户的问题描述是“生成一个六位不重复的随机数”，可能指的是每个生成的数值在全局范围内唯一，而不仅仅是每个数字的位置不重复。因此，可能需要回答两种方法，但需要明确用户的意图。 假设用户需要的是方案二，即确保每次生成的六位数是唯一的，那么需要维护一个已生成数值的集合，每次生成时检查是否已存在。此时，可以采用HashSet来存储已生成的数值，以提高查询效率。 例如，代码结构可能如下： Set<String> generated = new HashSet<>(); Random random = new Random(); public String generateUniqueRandom() { while (true) { int num = random.nextInt(900000) + 100000; // 生成100000到999999之间的数 String code = String.valueOf(num); if (!generated.contains(code)) { generated.add(code); return code; } } } 但这种方法在生成大量数值时会有性能问题，尤其是当集合接近饱和时，碰撞概率很高，导致循环次数增加。对于六位数来说，最多有900000个可能的数值，所以当生成的数值数量接近这个数目时，效率会变得极低。此时，更好的方法是预先生成所有可能的数值，存储在列表中，然后随机打乱顺序，依次取出。这种方法可以保证唯一性和高效性。 例如： List<Integer> numbers = new ArrayList<>(); for (int i = 100000; i <= 999999; i++) { numbers.add(i); } Collections.shuffle(numbers); // 每次取用时，从列表中按顺序取出即可 这种方法适用于需要生成全部或大部分可能的数值的情况。但如果只需要生成少量数值，比如几千个，那么第一种方法可能更合适，因为预先生成所有数值需要较大的初始化时间和内存。 回到用户的问题，用户可能只需要生成一个六位不重复的随机数，或者生成多个但每次都要唯一。这时候，如果用户需要的是生成多个唯一的数值，那么建议使用HashSet来存储已生成的数值，并使用高效的随机生成方法。 另外，用户提供的引用[2]中提到了使用取模的方法来生成随机位置，可能涉及到一个数组或列表中的元素随机排列，避免重复。这可能类似于洗牌算法，或者生成不重复的随机索引。 例如，引用[2]中的代码temp1 = Math.abs(r.nextInt()) % (values.length-1); 这可能是在随机选择一个位置，然后交换元素，用于生成不重复的随机数序列。这可能类似于Fisher-Yates洗牌算法的一部分。 因此，另一种方法是预先生成所有可能的六位数，然后进行洗牌，按需取出。这可以保证不重复且高效。 总结，可能的解决方案： 1. 使用HashSet存储已生成的数值，每次生成随机数直到找到未存在的。适合生成数量远小于总可能值的情况。 2. 预先生成所有可能的数值，洗牌后依次取出。适合需要生成大量数值的情况。 3. 生成每位数字不重复的六位数，此时生成方法不同，需要确保每个位置的数字唯一。 现在需要明确用户的问题到底是哪一种情况。根据用户提供的引用[1]，生成的十位数是整体不重复，因此可能用户的问题也是要求生成的六位数整体不重复。因此，需要提供相应的Java代码，可能结合用户提供的引用中的方法。 例如，用户提供的引用[1]中的代码使用ArrayList来存储已生成的数值，并通过循环检查是否存在。但这种方法效率低，建议改为HashSet。同时，生成六位数时，可以使用类似的方法： public static String generateSixDigitUnique() { Set<String> numSet = new HashSet<>(); Random random = new Random(); String randomNum; do { int num = random.nextInt(900000) + 100000; // 生成100000到999999之间的数 randomNum = String.valueOf(num); } while (numSet.contains(randomNum)); numSet.add(randomNum); return randomNum; } 但每次调用这个函数时，需要维护一个外部的Set，否则每次调用都会创建一个新的Set，导致无法记录之前生成的数值。因此，需要将Set作为静态变量或者在类中维护。 例如： public class RandomGenerator { private static Set<String> generatedNumbers = new HashSet<>(); private static Random random = new Random(); public static String generate() { String randomNum; do { int num = random.nextInt(900000) + 100000; randomNum = String.valueOf(num); } while (generatedNumbers.contains(randomNum)); generatedNumbers.add(randomNum); return randomNum; } } 但这样会有一个问题，当生成的数值超过900000个时，会进入死循环。因此，需要处理这种情况，比如抛出异常或者返回null。 不过用户的问题可能只需要生成单个或者少量数值，因此这种情况下，这种方法可以工作。如果用户需要生成大量数值，比如接近90万，那么应该使用预先生成并洗牌的方法。 此外，生成六位数时，使用String.format("%06d", ...)可以处理数值不足六位的情况，比如如果允许前导零的话。例如，生成0到999999之间的数，然后格式化为六位字符串，补零。例如： int num = random.nextInt(1000000); String randomNum = String.format("%06d", num); 这样可以得到从000000到999999的六位数。如果用户允许前导零，则总共有100万种可能，否则如果不允许前导零，则必须生成100000到999999之间的数，共90万种可能。需要根据用户的需求决定。 根据用户的问题中的“六位不重复随机数”，可能允许前导零，比如像012345这样的数值是否有效。这需要进一步确认。例如，验证码通常允许前导零，因此可能允许。因此，生成方法应该是生成0到999999之间的数，然后格式化为六位，补零。 例如： int num = random.nextInt(1000000); String randomNum = String.format("%06d", num); 然后检查是否存在于集合中。如果用户不允许前导零，则需要生成100000到999999之间的数，即num = random.nextInt(900000) + 100000。 现在回到用户的问题，用户可能想要的是生成一个六位数，可能是允许前导零的，因此总共有1000000个可能值。如果用户需要生成很多这样的数值，比如接近百万级别，那么预先生成并洗牌的方法更高效。 例如： public class RandomGenerator { private List<String> numbers; private int index = 0; public RandomGenerator() { numbers = new ArrayList<>(1000000); for (int i = 0; i < 1000000; i++) { numbers.add(String.format("%06d", i)); } Collections.shuffle(numbers); } public String getNext() { if (index >= numbers.size()) { throw new IllegalStateException("All numbers have been generated."); } return numbers.get(index++); } } 这种方法会预先创建所有可能的六位数，并打乱顺序，然后依次取出，确保不重复且高效。但初始化需要较多内存，对于百万级别的数，存储为字符串可能需要大约几十MB的内存，这在现代应用中是可以接受的。 但如果用户只需要生成一个六位数，并且不需要维护状态，那么这种方法可能没有必要。因此，需要根据用户的具体场景来选择方法。 总结可能的解决方案： 1. 使用HashSet检查重复，适合少量生成。 2. 预先生成并洗牌，适合大量生成。 3. 生成每位数字不重复的六位数（即六位数的每一位数字都不同）。 现在需要确定用户的需求是哪种。例如，生成一个六位数，每位数字都不重复，那么方法不同。例如，生成这样的数： public static String generateSixDigitUniqueDigits() { List<Integer> digits = new ArrayList<>(Arrays.asList(0,1,2,3,4,5,6,7,8,9)); Random random = new Random(); StringBuilder sb = new StringBuilder(); // 第一位不能为0 int first = random.nextInt(9) + 1; // 1-9 sb.append(first); digits.remove(Integer.valueOf(first)); for (int i = 1; i < 6; i++) { int index = random.nextInt(digits.size()); int digit = digits.get(index); sb.append(digit); digits.remove(index); } return sb.toString(); } 这种方法生成一个六位数，每位数字都不重复，第一位不为0。例如，生成123456或307895等。这种情况下，总共有9×9×8×7×6×5= 136080种可能的组合。 用户的问题可能指的是这种情况，即每个生成的六位数的各位数字都不重复，而不仅仅是整个数值唯一。这种情况下，生成方法需要确保各位数字的独特性。 需要根据用户的问题来判断。例如，用户的问题可能是在生成验证码，要求六位数且每位不重复。或者，用户可能需要生成一个唯一的标识符，例如订单号，其中六位数值整体不重复。 如果用户的问题属于前者，即每位数字不重复，则需要使用上述方法。否则，如果是整体数值不重复，则使用HashSet或预先生成的方法。 根据用户提供的引用，例如引用[1]中的代码是生成十位数，并检查整个数值是否重复，因此用户的问题可能属于后者，即整体数值不重复。因此，可能需要提供基于HashSet的方法，并优化性能。 结合用户提供的引用中的代码，例如引用[1]中使用ArrayList的contains方法，但这样效率低。用户可能希望优化这一点，因此建议使用HashSet，并生成六位数。 代码示例： import java.util.HashSet; import java.util.Random; import java.util.Set; public class UniqueSixDigitGenerator { private Set<String> generated = new HashSet<>(); private Random random = new Random(); public String generate() { String number; do { int num = random.nextInt(1000000); // 0到999999 number = String.format("%06d", num); } while (generated.contains(number)); generated.add(number); return number; } public static void main(String[] args) { UniqueSixDigitGenerator generator = new UniqueSixDigitGenerator(); for (int i = 0; i < 10; i++) { System.out.println(generator.generate()); } } } 这种方法每次生成一个六位数，并确保在同一个生成器实例中不会重复。但需要注意的是，当生成的数值超过1000000个时，会进入死循环。因此，可以在生成方法中添加检查： if (generated.size() >= 1000000) { throw new IllegalStateException("All possible six-digit numbers have been generated."); } 用户还可以根据需求调整，例如允许前导零或不允许。如果不允许，则生成范围是100000到999999： int num = random.nextInt(900000) + 100000; // 100000到999999 然后格式化为字符串，不需要补零，因为数值本身已经是六位数。 例如： number = String.valueOf(num); 但需要确保num不小于100000。不过使用random.nextInt(900000) + 100000会生成100000到999999之间的数，包括两边。 对于性能优化，使用HashSet的contains方法比ArrayList快得多，尤其是在大量数据的情况下。例如，用户引用[3]中的测试显示，使用ArrayList在十万次测试中，生成时间较长，而HashSet可以显著提高速度。 因此，在回答用户的问题时，应该推荐使用HashSet来存储已生成的数值，以提高检查效率。同时，根据是否需要前导零调整生成范围。 总结，用户的解决方案应包括： 1. 使用HashSet来高效检查重复。 2. 生成六位数的正确范围（允许或不允许前导零）。 3. 处理可能的耗尽所有数值的情况（抛出异常等）。 此外，用户可能需要生成多个不重复的数值，因此需要维护生成器的状态，确保每次生成的数值都是新的。 最后，根据用户提供的引用，例如引用[2]中提到使用随机位置和交换的方法，可能涉及洗牌算法，这也是另一种生成不重复数值的高效方法，适用于需要预先生成所有可能值的情况。</think>### Java生成六位不重复随机数方法 #### 方法一：基于HashSet去重 此方法利用HashSet的高效查重能力，适合生成少量随机数时使用。 ```java import java.util.HashSet; import java.util.Random; import java.util.Set; public class UniqueRandomGenerator { private static Set<String> generatedNumbers = new HashSet<>(); private static Random random = new Random(); public static String generateSixDigit() { String randomNum; do { int num = random.nextInt(900000) + 100000; // 生成100000-999999的六位数（不允许前导零） randomNum = String.valueOf(num); } while (generatedNumbers.contains(randomNum)); generatedNumbers.add(randomNum); return randomNum; } public static void main(String[] args) { System.out.println("生成示例：" + generateSixDigit()); } } ``` #### 方法二：预生成所有可能值并洗牌 此方法预先生成所有可能的六位数并随机打乱顺序，适合需要生成大量不重复数值的场景。 ```java import java.util.ArrayList; import java.util.Collections; import java.util.List; public class ShuffleGenerator { private static List<String> numbers = new ArrayList<>(); private static int index = 0; static { for (int i = 100000; i <= 999999; i++) { // 生成100000-999999的数值 numbers.add(String.valueOf(i)); } Collections.shuffle(numbers); // 随机打乱顺序 } public static String getNext() { if (index >= numbers.size()) { throw new IllegalStateException("所有六位数已生成完毕"); } return numbers.get(index++); } public static void main(String[] args) { System.out.println("生成示例：" + getNext()); } } ``` #### 方法三：生成每位数字不重复的六位数 若要求六位数的每一位数字均不重复，需单独处理每位数字的随机生成。 ```java import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Random; public class UniqueDigitsGenerator { public static String generate() { List<Integer> digits = new ArrayList<>(); for (int i = 0; i <= 9; i++) { digits.add(i); } Collections.shuffle(digits); // 确保第一位不为0 if (digits.get(0) == 0) { digits.set(0, digits.get(9)); // 将0与最后一位交换 } StringBuilder sb = new StringBuilder(); for (int i = 0; i < 6; i++) { sb.append(digits.get(i)); } return sb.toString().substring(0, 6); } public static void main(String[] args) { System.out.println("生成示例：" + generate()); } } ``` #### 性能与注意事项 1. **HashSet去重**：时间复杂度为$O(1)$，但接近数值上限时性能下降[^1]。 2. **预生成洗牌**：初始化耗时，但生成时时间复杂度为$O(1)$，适合高频调用[^3]。 3. **位去重方法**：仅生成每位不重复的数值，总可能性为$9 \times 9 \times 8 \times 7 \times 6 \times 5 = 136080$种。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值