Java--数组

最新推荐文章于 2024-11-12 21:14:07 发布
最新推荐文章于 2024-11-12 21:14:07 发布
阅读量578 收藏 9
点赞数 14
分类专栏： Java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77012210/article/details/139008276
版权

## 一、数组入门

### 1.1 概述

-   变量

    -   变量是在内存中开辟了一片空间，用来存储对应类型的数据
    -   存一个

-   数组

    -   数组是在内存中开辟了一组连续的空间，用来存储对应类型的数据
    -   0~N个

-   数组注意事项

    -   数据类型

        -   数组中存储元素的类型

    -   数组的长度

        -   数组中最多存储元素的数量

    ```
    int[] arr = new int[8];
    ```

### 1.2 创建数组

#### 动态创建

-   确定类型和长度
-   在数组创建之初没有向数组中存入数据
-   数组中的数据都是默认值
-   先声明后创建

```
int[] arr;
arr = new int[10];
```

-   声明的同时创建

```
int[] arrr = new int[20];
```

#### 静态创建

-   确定类型，长度由JVM计算得到
-   在数组创建的同时就存入了数据
-   全写【通用】

```
int[] arr = new int[]{11,22,33,44,55};
```

-   简写【有些场景不适用】

```
int[] arr = {11,22,33,44,55};
```

### 1.3 访问数组

#### 数组的长度

-   arr.length

#### 数组的索引

-   数组中每一个数据都是数组的元素
-   每一个元素都有自己的标记--索引【下标】
-   索引从0开始，到数组长度-1结束

#### 读取数据

-   数组名称[索引]

```
// 创建长度为·10的数组
int[] arr = new int[10];
// 读取数组中索引为0的数据存入i
int i = arr[0];
```

#### 写入数据

-   数组名称[索引] = 数据;

```
// 创建长度为·10的数组
int[] arr = new int[10];
// 把100这个数字存入数组arr的索引为0的位置
arr[0] = 100;
```

```
package com.shine.array;
​
public class Demo04 {
    public static void main(String[] args) {
        // 创建长度为4的int类型数组
        int[] arr = new int[4]; 
        // 读取数组索引为0位置的元素
        System.out.println(arr[0]);
        
        // 把111存入数组索引0的位置
        arr[0] = 111;
        System.out.println(arr[0]);
    }
}
```

### 1.4 遍历数组

```
package com.shine.array;
​
public class Demo05 {
    public static void main(String[] args) {
        // 创建数组
        int[] arr = new int[] {2,4365,3,5,235};
        // 读取数组中的数据
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        
        System.out.println("==============for==============");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        
        System.out.println("==============while==============");
        int index = 0;
        while (index < arr.length) {
            System.out.println(arr[index]);
            index++;
        }
        
        System.out.println("==============do-while==============");
        index = 0;
        do {
            System.out.println(arr[index]);
            index++;
        } while (index < arr.length);
        
        System.out.println("==============foreach==============");
        /**
         *  foreach
         *      增强for
         *      高级for
         *  for(数据类型 变量名 : 数组){
         *      
         *  }
         */
        for (int i : arr) {
            System.out.println(i);
        }
    }
}
```

```
package com.shine.array;
​
public class Demo06 {
    public static void main(String[] args) {
        /**
         *  1、数组元素书写的位置
         *  2、数组的长度
         *  3、数据的类型
         *  4、通过索引访问
         */
        // 创建数组存储司马八达,使用多种方式遍历
        String[] names = new String[] {"司马一","司马二","司马三","司马四","司马五","司马六","司马七","司马八"};
        System.out.println("=============for==============");
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
    }
}
```

### 1.5 数组元素默认值

| 类型      | 默认值    |
| ------- | ------ |
| byte    | 0      |
| short   | 0      |
| int     | 0      |
| long    | 0      |
| float   | 0.0    |
| double  | 0.0    |
| boolean | false  |
| char    | \u0000（空字符的二进制） |
| 引用类型    | null   |

```
package com.shine.array;
​
import java.util.Scanner;
​
public class Demo07 {
    public static void main(String[] args) {
        /**
         *  各种类型数组的默认值
         *      整数      0
         *      小数      0.0
         *      布尔      false
         *      字符      \u0000
         *      引用类型    null
         */
        // 整数
        int[] arrInt = new int[10];
        System.out.println(arrInt[6]);
        System.out.println(arrInt[8]);
        
        double[] arrDouble = new double[10];
        System.out.println(arrDouble[2]);
        System.out.println(arrDouble[8]);
        
        boolean[] arrBoolean = new boolean[10]; // 0000 0000==false,0000 0001==true
        System.out.println(arrBoolean[3]);
        System.out.println(arrBoolean[7]);
        
        char[] arrChar = new char[10];
        System.out.println(arrChar[0]); // char类型数组中的默认值是空格,\u0000
        System.out.println(arrChar[5]);
        
        String[] arrStr = new String[10];
        System.out.println(arrStr[1]);
        System.out.println(arrStr[6]);
        
        Scanner[] arrScanner = new Scanner[10];
        System.out.println(arrScanner[2]);
        System.out.println(arrScanner[7]);
        
    }
}
```

### 1.6 练习题【掌握】

#### 输出练习

```
package com.shine.array02;
​
public class Demo01 {
    public static void main(String[] args) {
        
        /**
         *  输出练习：创建int数组
         *  1、遍历输出数组中的每一个元素
         *  2、遍历输出数组中索引为偶数的元素
         *  3、输出数组中数值大/小于66的数据
         *  4、输出数组中的3位数数字
         *  5、倒序遍历输出数组中的数据
         */
        
        int[] arr = new int[] {2,4365,3,5,235,66,77,444555,2233,1235,77,99};
        
        // 1、遍历输出数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {  // i表示数组元素的索引,从0开始,到数组长度-1结束,逐渐向后一个
            System.out.println(arr[i]);
        }
        
        // 倒序遍历输出数组中的数据
        /**
         *  倒序：
         *      开始：arr.length-1
         *      结束：0
         */
        System.out.println("------------------");
        
        // 5、倒序遍历输出数组中的数据
        for (int i = arr.length-1; i >= 0; i--) {   // i表示数组元素的索引,从arr.length-1开始,到0结束,逐渐向前
            System.out.println(arr[i]);
        }
        
        System.out.println("------------------");
        
        // 2、遍历输出数组中索引为偶数的元素
        for (int i = 0; i < arr.length; i++) {
            // 判定索引是否偶数
            if (i % 2 == 0) {
                // 索引是偶数
                System.out.println(arr[i]);
            }
        }
        System.out.println("------------------");
        
        // 3、输出数组中数值大/小于66的数据
        
        // 遍历每一个元素
        for (int i = 0; i < arr.length; i++) {
            // 判定元素是否大于66
            if (arr[i] > 66) {
                // 元素大于66
                System.out.println(arr[i]);
            }
        }
        System.out.println("------------------");
        
        // 4、输出数组中的3位数数字【100~999】
        // 遍历每一个元素
        for (int i = 0; i < arr.length; i++) {
            // 判定元素是否三位数
            if (arr[i]>=100 && arr[i]<=999) {
                // 输出三位数元素
                System.out.println(arr[i]);
            }
        }
        System.out.println("------------------");
    }
}
```

#### 计算练习

```
package com.shine.array02;
​
public class Demo02 {
    public static void main(String[] args) {
        /**
         *  计算练习：创建int数组
         *  1、计算数组中元素的总和
         *  2、计算数组中元素的平均值
         *  3、统计小于60数字的数量
         *  4、查询范围在60~70数字的数量
         */
        
        // 1、计算数组中元素的总和
        int[] arr = new int[] {2,4365,3,5,235,66,77,444555,2233,1235,77,99};
        
        // 累计总和
        double sum = 0;
        
        // 遍历数组中的每一个数据
        for (int i = 0; i < arr.length; i++) {
            // 累加每一个数据
            // sum += i;    i是索引
            sum += arr[i];
        }
        System.out.println("总和:" + sum);
        
        // 2、计算数组中元素的平均值
        double avg = sum/arr.length;
        System.out.println("平均值:" + avg);
        
        // 3、统计小于60数字的数量
        // 计数
        int count = 0;
        // 遍历数组中的每一个数据
        for (int i = 0; i < arr.length; i++) {
            // 判定数据是否小于60
            if (arr[i] < 60) {
                // 发现小于60的数据,计数+1
                count++;
            }
        }
        System.out.println("小于60数据的数量是:" + count);
    }
}
```

## 二、数组扩容【掌握】

### 2.1 概述

-   数组创建的时候需要指定数据的类型和数组的长度

-   类型和长度一旦确定就不能更改

-   如果数组中已经存满了元素，还有更多的元素需要存入，数组就需要扩容

-   扩容的思路：

    -   创建比原数组更大的数组，容纳原来的数据和后来的数据

### 2.2 手动扩容

```
package com.shine.array;
​
import java.util.Arrays;
​
public class Demo01 {
    public static void main(String[] args) {
        /**
         *  创建两个数组，分别存入三国演义魏国和吴国的5个好汉，编写代码合并两个数组
         */
        
        String[] nameWei = new String[] {"曹操","典韦","许褚","张辽","夏侯惇"};
        String[] nameWu = new String[] {"孙坚","孙策","孙权","黄盖","周瑜"};
        
        /**
         *  原来的数组已经满了，不能容纳更多的数据
         *  需要创建更大的数组，用来存放更多的数据
         *  新数组的大小
         *      至少能容纳眼前的数据：数组01的长度 + 数组02的长度
         */
        // 创建更大的数组
        String[] names = new String[nameWei.length + nameWu.length];
        
        // 把数组复制到新数组
        /**
         * 
            names[0] = nameWei[0];
            names[1] = nameWei[1];
            names[2] = nameWei[2];
            names[3] = nameWei[3];
            names[4] = nameWei[4];
            
            names[5+0] = nameWu[0];
            names[5+1] = nameWu[1];
            names[5+2] = nameWu[2];
            names[nameWei.length + 3] = nameWu[3];
            names[nameWei.length + 4] = nameWu[4];
         */
        // 遍历nameWei中的每一个元素,把元素存入names数组
        for (int i = 0; i < nameWei.length; i++) {
            names[i] = nameWei[i];
        }
        
        // 遍历nameWu中的每一个元素,把元素存入names数组
        for (int i = 0; i < nameWu.length; i++) {
            // nameWei已经占据了nameWei.length数量的位置,需要从这个位置之后继续存入
            names[nameWei.length + i] = nameWu[i];
        }
        System.out.println(Arrays.toString(names));
    }
}
```

### 2.3 API扩容

-   System.arraycopy

    -   复制数据

-   Arrays.copyOf

    -   创建更大的、包含原数组数据的新数组

```
package com.shine.array;
​
import java.util.Arrays;
​
public class Demo02 {
    public static void main(String[] args) {
        /**
         *  从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
         *  src - 源数组。
            srcPos - 源数组中的起始位置。
            dest - 目标数组。
            destPos - 目标数据中的起始位置。
            length - 要复制的数组元素的数量。
         */
        // 源数组
        String[] nameWei = new String[] {"曹操","典韦","许褚","张辽","夏侯惇"};
        String[] nameWu = new String[] {"孙坚","孙策","孙权","黄盖","周瑜"};
        
        // 创建新数组
        String[] names = new String[nameWei.length + nameWu.length];
        
        // 复制nameWei数据到names
        System.arraycopy(nameWei, 0, names, 0, nameWei.length);
        System.out.println(Arrays.toString(names));
        
        // 把nameWu中的数据复制到names
        System.arraycopy(nameWu, 0, names, nameWei.length, nameWu.length);
    }
}
```

```
package com.shine.array;
​
import java.util.Arrays;
​
public class Demo03 {
    public static void main(String[] args) {
        // 源数组
        String[] nameWei = new String[] {"曹操","典韦","许褚","张辽","夏侯惇"};
        String[] nameWu = new String[] {"孙坚","孙策","孙权","黄盖","周瑜"};
        
        // 在nameWei的基础上创建更大的数组：包含nameWei中的数据
        
        // 创建长度为10的数组，产生一个新的数组，数组中包含nameWei中的数据
        String[] names = Arrays.copyOf(nameWei, 10);
        System.out.println(Arrays.toString(names));
        
        // 把nameWu复制到新的数组
        System.arraycopy(nameWu, 0, names, nameWei.length, nameWu.length);
        
    }
}
```

## 三、Arrays

### 3.1 概述

-   操作数组的一个工具类

-   有些快捷方法操作数组

    -   查找
    -   排序
    -   扩容
    -   填充
    -   转换成字符串

### 3.2 方法使用

```
package com.shine.array;
​
import java.util.Arrays;
​
public class Demo04 {
    public static void main(String[] args) {
        /**
            static <T> T[] copyOf(T[] original, int newLength) 
                      复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。
            static void sort(int[] a) 
                      对指定的 int 型数组按数字升序进行排序。 
            static int binarySearch(int[] a, int key) 
                      使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。 
            static void fill(int[] a, int val) 
                      将指定的 int 值分配给指定 int 型数组的每个元素。 
            static String toString(Object[] a) 
                      返回指定数组内容的字符串表示形式。 
         */
        
        int[] arr = new int[] {2,4365,3,5,235,66,77,444555,2233,1235,77,99};
        System.out.println(Arrays.toString(arr));
        
        // 排序
        Arrays.sort(arr);
        // 输出数组的字符串形式
        System.out.println(Arrays.toString(arr));
        
        // 二分查找
        System.out.println(Arrays.binarySearch(arr, 66));
        System.out.println(Arrays.binarySearch(arr, 77));
        
        // 使用指定数据填充数组
        Arrays.fill(arr, 0);
        System.out.println(Arrays.toString(arr));
    }
}
```

## 四、冒泡排序【重点】

### 4.1 概述

-   数组中相邻的两个元素比较，大的向后小的向前

-   比较的轮数

    -   数组长度-1
    -   每次找到一个最大元素放到最后，如果是长度为10的数组，需要找到9次最大值

-   每一轮比较的次数

    -   逐渐减少
    -   如果数组长度是10，第一轮需要比较9对，第二轮需要比较8对...

### 4.2 冒泡排序代码实现

```
package com.shine.array;
​
import java.util.Arrays;
​
public class Demo05 {
    public static void main(String[] args) {
        int[] arr = new int[] {2,3,5,66,235,4365};
        // 确定比较的总轮数：数组长度-1，每轮都找出一个最大值放在最后
        for (int i = 0; i < arr.length - 1; i++) {
            // 每一轮中相邻的两个元素比较,比较的次数是长度-1-i,需要比较的元素随着轮数的增加逐渐减少
            for (int j = 0; j < arr.length-i-1; j++) {
                // 相邻的元素比较
                if (arr[j] > arr[j+1]) {
                    // 发现前面的数据大于后面的数据,交换他们的位置
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}
```

## 五、引用类型参数和返回值【困难】【量力而行】

### 5.1 概述

-   引用类型变量也可以当做方法中的参数和返回值类型

### 5.2 引用类型参数

```
package com.shine.array02;
​
import java.util.Arrays;
​
public class Demo03 {
    public static void main(String args[]) {
        /**
         *  1、编写方法，传入一个数组，返回数组中的最大值
         *  2、编写方法，传入一个数组，对数组排序【无需返回值】
         *  3、编写方法，传入一个数组，计算元素平均值
         *  4、传入数组和新的长度，返回新指定长度的数组【包含原数组中的内容】
         *  5、编写方法，传入数组，返回数组的字符串表示形式
         */
        
        int[] arr = new int[] {2,66,235,4365,3,5};
        int m = max(arr);
        System.out.println(m);
        
        System.out.println(avg(arr));
        
        int[] newArr = copyOf(arr, 20);
        System.out.println(Arrays.toString(newArr));
    }
    
    /**
     *  返回数组中的最大值
     * @param arr
     * @return
     */
    public static int max(int arr[]) {
        // 假设第一个就是最大的
        int max = arr[0];
        // 遍历后面的每一个数据
        for (int i = 1; i < arr.length; i++) {
            // 比较每一个数据
            if (max < arr[i]) {
                // 发现更大的数据,记录这个数据
                max = arr[i];
            }
        }
        return max;
    }
    
    /**
     *  计算数组元素平均值
     * @param arr
     * @return
     */
    public static double avg(int[] arr) {
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum / arr.length;
    }
    
    /**
     *  传入数组和新的长度，返回新指定长度的数组【包含原数组中的内容】
     * @param arr
     * @param newLength
     * @return
     */
    public static int[] copyOf(int[] arr,int newLength) {
        // 创建指定长度的数组
        int[] newArr = new int[newLength];
        // 复制源数据到新数组
        System.arraycopy(arr, 0, newArr, 0, arr.length);
        return newArr;
    }
    
}
```

### 5.3 引用类型返回值

```
package com.shine.array02;
​
import java.util.Arrays;
import java.util.Random;
​
public class Demo04 {
    public static void main(String[] args) {
        /**
         *  生成指定长度的随机数数组，数字范围0~100
         */
        
        System.out.println(Arrays.toString(getNums(10)));
        
    }
    
    /**
     *  生成指定长度的随机数数组，数字范围0~100
     * @param count
     * @return
     */
    public static int[] getNums(int count) {
        // 创建随机对象类
        Random r = new Random();
        
        // 创建指定长度的数组
        int[] arr = new int[count];
        
        // 指定的次数
        for (int i = 0; i < arr.length; i++) {
            // 生成随机数存入数组
            arr[i] = r.nextInt(101);
        }
        return arr;
    }
    
}
```

## 六、可变长参数【了解】

### 6.1 概述

-   可以在方法的形参中声明可变长参数，用来接受任意长度相同类型的参数

### 6.2 入门案例

```
package com.shine.array02;
​
public class Demo05 {
    public static void main(String[] args) {
        /**
         *  求和的方法
         */
        System.out.println(sum(1,2,3));
        System.out.println(sum(1,2,3,4,5));
        System.out.println(sum(1,2,3,4,5,6,7));
        
        int[] arr = {11,22,33};
        System.out.println(sum(arr));
    }
    
    /**
     *  计算任意数量整数相加的结果
     * @param nums  任意数量的整数
     * @return      相加的结果
     */
    public static int sum(int...nums) {
        int sum = 0;    // 记录总和
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }
    
}
```

### 6.3 注意事项

-   一个方法中只能存在一个可变长参数
-   可变长参数必须在方法的最后一个形参位置
-   方法中可以定义其他非可变长参数

一只勤劳的小蜜蜂Yy
关注
专栏目录
Java--数组的使用
weixin_57638634的博客
06-14 418
Java--数组的使用
Java-数组-数组的遍历
voiley的博客
12-19 868
Java数组知识点
【Java -- 数组的动态初始化和静态初始化】
qq_45312083的博客
08-14 1140
Java 数组的初始化有两种方式：静态初始化和动态动态初始化。
Java--打乱数组
m0_58476311的博客
09-27 1716
Java--打乱数组
Java数组--新建数组/合并数组--方法/实例
IT利刃出鞘的博客
10-26 819
原文网址： 简介 本文用示例介绍Java如何创建数组对象、如何合并多个数组为一个数组。 新建数组 基本类型 int[] a = new int[5]; //指定长度 int[] b = new int[]{1, 2, 3}; //指定初始值 数组与可变参数 可变参数其实就是数组，如下： package org.example.a; public class Demo { public static void main(String[] ar...
java---json数组转数组
junxunfs的博客
01-27 507
json数组转数组
初识java - 数组的定义与使用
qq_61777435的博客
11-04 1208
一，数组的基本概念1.1什么数组1.2数组的创建及初始化1.2.1数组的创建1.2.2数组的初始化1.3数组的使用1.4数组的遍历二，数组是引用类型2.1初始JVM的内存分布2.2 基本类型变量与引用类型变量的区别2.3数组作为参数在传参上的数据变动三，数组的应用场景（cv程序猿）3.1 保存数据3.2 作为函数的参数3.3 作为函数的返回值四. 数组练习。
Java--数组作为方法参数和返回值
热门推荐
罗俊
10-11 1万+
文章目录前言内容1. 数组作为方法参数2. 数组作为方法返回值4. 断点调试总结end 前言 以前的方法中我们学习了方法的参数和返回值，但是使用的都是基本数据类型。那么作为引用类型的数组能否作为 方法的参数进行传递呢，当然是可以的。 内容 1. 数组作为方法参数 数组作为方法参数传递，传递的参数是数组内存的地址。 public static void main(String[] args) { ...
Java-数组案例:猜数字游戏
weixin_52309279的博客
04-06 2286
需求: 开发一个幸运小游戏,游戏规则如下: 游戏后台随机生成1-20之间的五个数(无所谓是否重复),然后让大家来猜数字: ① 未猜中提示:"未命中",并继续猜测 ② 猜中提示:"运气不错,猜中了",并输出该数据第一次出现的位置,且输出全部5个数据,最终结束本游戏. 分析: (1) 随机生成5个1-20之间的数据存储起来==>使用数组 (2) 定义一个死循环,输入数据猜测,遍历数组,判断数据是否在数组中,如果在,进行对应提示并结束死循环;如果没有猜中,提示集训猜测直到猜中为止. 代码
java----数组----最值问题
07-14
定义数组scores并赋值56,90,34,20,统计出最高分,最低分,平均分
java-c语法8---数组---马克-to-win java视频
05-19
java语法 数组 马克-to-win java视频 array 的详细介绍
Educoder题目：Java入门 - 数组进阶答案解析.md
11-01
Educoder题目：Java入门 - 数组进阶答案解析
java-c语法8---非矩形数组---马克-to-win java视频
05-18
java语法 非矩形数组 马克-to-win java视频 二重循环
Java - 数组面试题 - 个人整理
08-20
数组 - 需要参加面试的人
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 242
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
1112--接口
最新发布
kequanrrr的博客
11-12 239
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
JAVA-01-变量
LJH_laura_li的博客
11-08 488
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 331
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
JAVA---数组从小到大排序方法
09-15
在Java中，可以使用内置的Arrays.sort()方法对整型数组进行从小到大的排序。这个方法是基于快速排序算法实现的，适用于各种类型的数组，包括基本数据类型和对象数组（如果实现了Comparable接口）。对于基本类型数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值