浅说一维数组以及遍历，length函数

最新推荐文章于 2024-03-06 00:02:49 发布
最新推荐文章于 2024-03-06 00:02:49 发布
阅读量1.7k 收藏 9
点赞数 11
分类专栏： 后端（Java）从入门到开发 文章标签： 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45734913/article/details/126760331
版权

目录


变量：存储数据的空间（装数据的容器），变量中只能存储一个数据
数组：存储数据的空间（装数据的容器），数组中可以存储多个相同类型的数据

数组的组成部分

  1. 标识符：数组的名称，取名原则与变量一样
  2. 数组元素：数组中存储的每一个数据称之为数组元素
  3. 元素下标：因为数组在内存中是连续的空间，所以会给数组里的元素按照顺序进行编号，编号从0开始，我们把这个编号叫下标(索引)
  4. 元素类型：描述的是数组中的元素类型

声明数组

数据类型[] 数组名; 或者 数据类型 数组名[];

int[] nums ;
String[] strs;

分配空间

告诉你我这个数组里能装多少个元素（数据）
数组名 = new 数据类型[元素个数];

nums = new int[5];
strs = new String[3];

赋值

将数据存储到数组中
数组名[下标] = 数据;

nums[0] = 99;
nums[1] = 83;
nums[2] = 78;
nums[3] = 88;
nums[4] = 66;
//nums[5] = 100; //ArrayIndexOutOfBoundsException:数组下标越界

ArrayIndexOutOfBoundsException:数组下标越界

操作数据：通过数组名[下标]来操作数据
S

ystem.out.println(nums[0]);		//99
System.out.println(nums[1]); 	//83
nums[1]+=50;					//nums[1]=nums[1]+50;
System.out.println(nums[1]);

声明数组、分配空间合并写

数据类型[] 数组名 = new 数据类型[数组长度]; 或 数据类型 数组名[] = new 数据类型[数组长度]

声明一个长度为3的double类型的数组

double[] nums = new double[3];

赋值,通过数组名[下标]给元素赋值，如果没有给元素赋值，系统会给元素赋予一个默认值

nums[0] = 12.5;
nums[1] = 22.5;

输出数组里的每一个元素

System.out.println(nums[0]);//12.5
System.out.println(nums[1]);//22.5
System.out.println(nums[2]);//0.0

默认值

char[] chs = new char[2]; System.out.println(chs[0]);
//char类型数组元素默认值是空格

boolean[] bools = new boolean[2];
System.out.println(bools[0]);//false

声明数组、分配空间、赋值合并写

方法一：数据类型[] 数组名 = new 数据类型[ ]{数据1,数据2,…,数据n};
方法二：数据类型 数组名[] = new 数据类型[ ]{数据1,数据2,…,数据n};
注意：{}前面那个[ ]里不能写长度，写了就报错**

声明一个长度为3的数组，并向数组里赋值 “hello” “java” “word”

String[] strs = new String[] { "hello", "java", "word" };

操作数据

System.out.println(strs[0]);
System.out.println(strs[1]);
System.out.println(strs[2]);

声明数组、分配空间、赋值合并写的简写方式

方式一：数据类型[] 数组名 = {数据1,数据2,…,数据n};
方式二：数据类型 数组名[] = {数据1,数据2,…,数据n};

声明一个char类型的数组，并向数组里赋值 ‘a’ ‘b’ ‘c’ ‘d’

char[] chs = { 'a','b','c','d'};
System.out.println(chs[0]);// a
//System.out.println(chs[6]);		//ArrayIndexOutOfBoundsException

练习1：声明一个长度为4的int类型的数组，使用键盘输入给数组每个元素赋值。遍历输出数组。

package cn.bdqn.demo01;

import java.util.Scanner;

public class Demo04 {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		// 声明一个长度为4的int类型的数组
		int[] nums = new int[4];

		// 使用键盘输入给数组每个元素赋值
		// System.out.println("请输入数组里的第1个元素值：");
		// nums[0]=sc.nextInt();
		// System.out.println("请输入数组里的第2个元素值：");
		// nums[1]=sc.nextInt();
		// System.out.println("请输入数组里的第3个元素值：");
		// nums[2]=sc.nextInt();
		// System.out.println("请输入数组里的第4个元素值：");
		// nums[3]=sc.nextInt();
		
		//上述赋值操作，可以使用循环来实现
		for(int i =0;i<4;i++){
			System.out.println("请输入数组里的第"+(i+1)+"个元素值：");
			nums[i]=sc.nextInt();
		}
		
		System.out.println("数组中的元素依次是：");
		//输出数组里的每一个元素值
		// System.out.println(nums[0]);
		// System.out.println(nums[1]);
		// System.out.println(nums[2]);
		// System.out.println(nums[3]);
		
		//遍历数组：将数组中元素按照下标顺序依次输出
		for(int i = 0;i<4;i++){
			System.out.println("数组第"+(i+1)+"个元素是："+nums[i]);
		}

	}

}

遍历以及length的灵活运用

遍历

数据元素是怎样在内存中存放的？
主要有2种存储方式：

1、顺序存储，Random Access（Direct Access）：
这种方式，相邻的数据元素存放于相邻的内存地址中，整块内存地址是连续的。可以根据元素的位置直接计算出内存地址，直接进行读取。读取一个特定位置元素的平均时间复杂度为O(1)。正常来说，只有基于数组实现的集合，才有这种特性。Java中以ArrayList为代表。

2、链式存储，Sequential Access：
这种方式，每一个数据元素，在内存中都不要求处于相邻的位置，每个数据元素包含它下一个元素的内存地址。不可以根据元素的位置直接计算出内存地址，只能按顺序读取元素。读取一个特定位置元素的平均时间复杂度为O(n)。主要以链表为代表。Java中以LinkedList为代表。

每个遍历方法的实现原理是什么？

  1. 传统的for循环遍历，基于计数器的：
    遍历者自己在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后，停止。主要就是需要按元素的位置来读取元素。
  2. 迭代器遍历，Iterator：
    每一个具体实现的数据集合，一般都需要提供相应的Iterator。相比于传统for循环，Iterator取缔了显式的遍历计数器。所以基于顺序存储集合的Iterator可以直接按位置访问数据。而基于链式存储集合的Iterator，正常的实现，都是需要保存当前遍历的位置。然后根据当前位置来向前或者向后移动指针。
  3. foreach循环遍历：
    根据反编译的字节码可以发现，foreach内部也是采用了Iterator的方式实现，只不过Java编译器帮我们生成了这些代码。

各遍历方式对于不同的存储方式，性能如何？

  1. 传统的for循环遍历，基于计数器的：
    因为是基于元素的位置，按位置读取。所以我们可以知道，对于顺序存储，因为读取特定位置元素的平均时间复杂度是O(1)，所以遍历整个集合的平均时间复杂度为O(n)。而对于链式存储，因为读取特定位置元素的平均时间复杂度是O(n)，所以遍历整个集合的平均时间复杂度为O(n2)（n的平方）。
    ArrayList按位置读取的代码：直接按元素位置读取。
  2. 迭代器遍历，Iterator：
    那么对于RandomAccess类型的集合来说，没有太多意义，反而因为一些额外的操作，还会增加额外的运行时间。但是对于Sequential
    Access的集合来说，就有很重大的意义了，因为Iterator内部维护了当前遍历的位置，所以每次遍历，读取下一个位置并不需要从集合的第一个元素开始查找，只要把指针向后移一位就行了，这样一来，遍历整个集合的时间复杂度就降低为O(n)；

length的写法：
数组名.length自动获取该数组的长度。

遍历输出以下数组：

package cn.bdqn.demo01;

public class Demo05 {

	public static void main(String[] args) {
		//遍历以下数组
		int[] nums = {11,23,45,6,78,96,88,73,62,12,10,36,55,99,45,66,19,64,13};
		
		//获取数组中元素的个数： 数组名.length;
		int length =nums.length;
		System.out.println("数组中元素个数："+length);

		//遍历数组
		for(int i =0;i<nums.length;i++){
			System.out.println(nums[i]);
		}
	
	}

}

练习一：
需求：
1）根据班级人数来创建数组
2）将每个学生的成绩存入到数组中
3）求班级学生成绩总和
4）求班级学生平均成绩

package cn.bdqn.demo02;

import java.util.Scanner;

public class Demo01 {
	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		// 1）根据班级人数来创建数组:班级人数有多少个，数组的长度为就为多少
		System.out.println("请输入班级人数：");
		int num = sc.nextInt();

		// 根据班级人数来创建一个存放学生成绩的数组
		double[] scores = new double[num];

		// 声明一个变量sum用来累加所有学生的成绩
		double sum = 0;

		// 2）将每个学生的成绩存入到数组中
		for (int i = 0; i < scores.length; i++) {
			System.out.println("请输入第" + (i + 1) + "个学生的成绩：");
			scores[i] = sc.nextDouble();
			// 3）求班级学生成绩总和
			sum += scores[i];
		}

		// 4）求班级学生平均成绩
		double avg = sum / num;

		System.out.println("该班学生成绩总和：" + sum);
		System.out.println("该班学生平均成绩：" + avg);

	}

}

增强for循环

语法结构：
for(数据类型 变量名:数组名或集合名){
对变量进行操作的代码
}

执行规律：
将数组或者集合中的元素依次取出来存入到变量中，然后操作这个变量就等同于操作数组或者集合中的数据

注意：增强for循环的执行效率比普通for循环高

增强for循环遍历数组的运用：

public static void main(String[] args) {

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

		// 遍历数组
		System.out.println("-----普通for循环遍历数组-----");
		for (int i = 0; i < nums.length; i++) {
			System.out.println(nums[i]);
		}
		
		System.out.println("-----增强for循环遍历数组-----");
		for(int a : nums){
			System.out.println(a);
		}
		
		System.out.println("------------------------");
		for (int i : nums) {
			i+=100;
			System.out.println(i);
		}

声明变量并将变量直接输出

int num = 10;
System.out.println(num); // 10

数组是一个引用数据类型，直接输出数组名，输出的是数组在内存中的地址值

int[] nums = { 11, 22, 33, 44, 55 };
System.out.println(nums); //[I@4eafccbe

练习二：
有一个数列：8，4，2，1，23，344，12
循环输出数列的值
求数列中所有数值的和
猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数

package cn.bdqn.demo02;

import java.util.Scanner;

public class Demo04 {

	public static void main(String[] args) {
		
		int[] num = {8,4,2,1,23,344,12};
		
		//循环输出数列的值
		for (int i : num) {
			System.out.println(i);
		}
		
		//求数列中所有数值的
		//声明一个变量sum用来累加数组中所有元素之和
		int sum = 0;
		for (int i : num) {
			sum+=i;
		}
		System.out.println("数组中所有元素之和为："+sum);
		
		//猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数
		Scanner sc = new Scanner(System.in);
		System.out.println("请任意输入一个整数：");
		int guess = sc.nextInt();
		
		for (int i : num) {
			if(i==guess){
				System.out.println("数组中包含你猜测的数据");
				break;
			}
		}

	}

}

练习三：
有一个数列：8，4，2，1，23，344，12
猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数,如果包含此数，输出此数在数组中的位置(下标)，如果不包含此数，则输出数组中不包含此数

package cn.bdqn.demo02;

import java.util.Scanner;

public class Demo05 {

	public static void main(String[] args) {

		int[] num = { 8, 4, 2, 1, 23, 344, 12 };

		Scanner sc = new Scanner(System.in);
		System.out.println("请任意输入一个整数：");
		int guess = sc.nextInt();
		
		//声明一个变量，用来统计比较的次数
		int count = 0;
		for (int i = 0; i < num.length; i++) {
			//判断你猜测的数据在不在数组
			if(guess!=num[i]){
				count++;
				if(count==num.length){
					System.out.println("你猜测的数据不在此数组中");
				}
			}else{
				System.out.println("你猜测的数据在此数组中，下标为："+i);
				//只要猜测的数据在数组中，后续就不需要再进行比较，退出整个循环
			}
		}
		
		
	}

}

获取数组中的最大值或者最小值

思想：
1）先假设数组中的第1个元素（下标为0）为最大值
2）依次将数组中后面的元素与这个最大值进行比较，如果比这个最大值还要大，取代它称为新的最大值
3）比较到最后一个元素，就可以获取这个数组中的最大值

package cn.bdqn.demo03;

public class Demo01 {

	public static void main(String[] args) {
		int[] nums = { 56, 60, 78, 42, 311, 88, 12 };
		// 1）先假设数组中的第1个元素（下标为0）为最大值
		int max = nums[0];

		// 2）依次将数组中后面的元素与这个最大值进行比较，如果比这个最大值还要大，取代它称为新的最大值
		// if(nums[1]>max){
		// max=nums[1];
		// }
		//
		// if(nums[2]>max){
		// max = nums[2];
		// }
		//
		// if(nums[3]>max){
		// max = nums[3];
		// }
		//
		// if(nums[4]>max){
		// max = nums[4];
		// }
		//
		// if(nums[5]>max){
		// max = nums[5];
		// }
		//
		// if(nums[6]>max){
		// max = nums[6];
		// }

		for (int i = 0; i < nums.length; i++) {
			if (nums[i] > max) {
				max = nums[i];
			}
		}

		System.out.println("数组中的最大值：" + max);

		// 获取最小值思路与获取最大值思路一样
		// 假设数组中第一个元素为最小值
		int min = nums[0];
		// 依次将数组中的元素取出来与这个最小值进行比较，如果元素值比这个最小值还小，就成为新的最小值，比较到最后一个元素，就可以得到数组中的最小值
		for (int i = 0; i < nums.length; i++) {
			if (nums[i] < min) {
				min = nums[i];
			}
		}
		System.out.println("数组中的最小值：" + min);
	}

}

练习四：
有一组学员的成绩{99，85，82，63， 60}，已经是按降序排列。 要增加一个学员的成绩，将它插入成绩序列，并保持降序

思想：
1）声明一个长度比原来数组长度大1的数组
2）将原来数组里元素按照顺序存入到新的数组中
3）使用Scanner类获取你要增加的学员成绩
4）通过循环比较获取增加的学员成绩的插入位置
5）从插入元素插入位置开始及之后的元素依次往后移动一位（从最后一个元素开始，倒着移动）
6）将要插入的成绩存储到插入位置

package cn.bdqn.demo03;

import java.util.Scanner;

public class Demo02 {
	public static void main(String[] args) {

		// 创建Scanner类对象
		Scanner sc = new Scanner(System.in);

		int[] scores = { 99, 85, 82, 63, 60 };

		// 1）声明一个长度比原来数组长度大1的数组
		int[] newScores = new int[scores.length + 1];

		// 2）将原来数组里元素按照顺序存入到新的数组中
		// newScores[0]=scores[0];
		// newScores[1]=scores[1];
		// newScores[2]=scores[2];
		// newScores[3]=scores[3];
		// newScores[4]=scores[4];
		// 使用循环来实现上述赋值操作,赋值结束后，新数组元素是[99,85,82,63,60,0]
		for (int i = 0; i < scores.length; i++) {
			newScores[i] = scores[i];
		}

		System.out.println("插入学生成绩前的数组：");
		for (int i : newScores) {
			System.out.print(i + " ");
		}
		System.out.println();

		// 3）使用Scanner类获取你要增加的学员成绩
		System.out.println("请输入你要增加的学员成绩：");
		int insert = sc.nextInt();

		// 设置插入的成绩插入的位置，默认将其插入在数组最后位置
		int index = newScores.length - 1;
		// 4）通过循环比较获取增加的学员成绩的插入位置
		for (int i = 0; i < newScores.length; i++) {
			// 比较，如果插入的学员成绩比数组里的元素大，得到其插入位置
			if (insert > newScores[i]) {
				index = i;
				// 一旦得到插入成绩比数组元素大，就结束比较，后面不再进行比较
				break;
			}
		}

		// 5）从插入元素插入位置开始及之后的元素依次往后移动一位（从最后一个元素开始，倒着移动）
		for (int i = newScores.length - 1; i > index; i--) {
			newScores[i] = newScores[i - 1];
		}

		// 6）将要插入的成绩存储到插入位置
		newScores[index] = insert;

		// 输出数组里的所有元素，看一下是否满足了需求
		System.out.println("插入学生成绩后的数组：");
		for (int i : newScores) {
			System.out.print(i + " ");
		}

	}

}

练习五：
删除数组strs中的某个元素，删除完这个元素之后，后面的元素依次往前移动一位

package cn.bdqn.demo03;

import java.util.Scanner;

public class Demo03 {

	public static void main(String[] args) {

		String[] strs = { "hello", "java", "html", "css", "JavaScript" };
		System.out.println("---元素删除前---");
		for (int i = 0; i < strs.length; i++) {
			System.out.print(strs[i] + " ");
		}
		System.out.println();
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你想删除的元素的下标(0-4):");
		int index = sc.nextInt();

		if (index == 4) {
			strs[4] = null;
		} else {
			for (int i = index; i < strs.length - 1; i++) {
				strs[i] = strs[i + 1];
			}
			// 元素往前移动之后，最后一个元素赋值为null
			strs[strs.length - 1] = null;
		}

		System.out.println("---元素删除后---");
		for (int i = 0; i < strs.length; i++) {
			System.out.print(strs[i] + " ");
		}
		System.out.println();

	}

}

总结

数组常用写法：
数据类型[] 数组名 = new 数据类型[数组长度];
数据类型[] 数组名 = new 数据类型[ ]{数据1,数据2,…,数据n};
数组是一个引用数据类型，直接输出数组名，输出的是数组在内存中的地址值
遍历：通过for循环来遍历
length函数：数组名.length自动获取该数组的长度。
增强for循环：将数组或者集合中的元素依次取出来存入到变量中，然后操作这个变量就等同于操作数组或者集合中的数据

道长爱睡懒觉
关注
  • 11
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
一维数组的遍历方法
jiaxiao_jian的博客
03-13 4088
一、//遍历数组 public static void getArray(int [] arr){ System.out.print("{"); for(int i = 0; i &lt;arr.length; i++){ if(i != arr.length-1){ System.out.print(arr[i]+","); }else{ System.out.print...
一维数组的遍历
阿杨洋的博客
09-21 2219
一维数组的遍历
一维数组遍历
llixiangjian的博客
08-17 660
public class Demo1 { public static void main(String[] args) { int[] arr = { 10, 29, 3, 49, 59 }; // 遍历--for循环： for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } // 遍
一维数组的遍历 .
diankui6178的博客
12-11 486
[php] view plaincopyprint? foreach遍历数组 <?php /* *数组的遍历 */ $language=array("French",'German','Russian','Chinese','Hindi','Quechu'); foreach($languageas$...
UEFIBIOS浅说.pptx
04-26
UEFIBIOS浅说 本文将从UEFI BIOS浅说 pptx文件中提炼出重要的知识点，以下是详细的解释： 一、BIOS 的概念和功能 BIOS（Basic Input/Output System，基本输入输出系统）是电脑中的一组固化程序，提供最低级的硬件...
浅说深度学习之：序列学习
02-25
第二篇介绍了深度学习的历史背景，以及如何高效地训练神经网络。而这一篇当中，我们将一起认识自然语言处理领域的核心：序列学习。图1：长短期记忆(LSTM)单元。LSTM有四个输入权重和四个循环权重。Peepholes是记忆...
数组的length属性（Array）
pan_542pan11的博客
10-04 5322
数组的length属性： 数组的项数保存在其length属性中，这个属性始终会返回0或更大的值。 数组最后一项的索引始终是length-1 const colors = ["red","blue","green"]; const names =[]; /* alert() 方法用于显示带有一条指定消息和一个 确认 按钮的警告框。 */ alert(colors.length); //3 alert(names.length); //0 数组的length属性不是只读的。 const colors
c语言------一维数组的定义和遍历
weixin_63779802的博客
10-27 1775
数组的创建方式：type_t是指数组的元素类型arr_name是指数组你所定义的名字const_是一个常量表达式，用来指定数组的大小在C语言中使用数组必须先进行定义,一维数组的定义方式如下:1.i < 10;}}2. 注意这里使用memset函数需要引入头文件#include//按照字节初始化内存}3. 使用#define SIZE提前定义SIZE的大小//10个单元格 初始0//此处的定义具有不可变性}4.// 6个单元格。
C语言遍历一维数组的四种方式
weixin_46364710的博客
05-12 4060
遍历数组的四种方式： x[i] *(x+i) p[i] *(p+i) 具有相同的功能：访问数组的第i+1个数组元素 这里的p为指向数组首地址的指针 这四种方式其实非常好记： x[i] *(x+i）p[i] *(p+i) 前两种方式和后两种方式很相似: x[i]和p[i]很像，*(x+i)和*(p+i)很像 C语言验证代码： /*Function:遍利数组的四种方式：x[i],*(x+i),p[i],*(p+i) ...
Java一维数组的遍历
舟舟舟小白的博客
03-08 1888
一维数组的遍历 一维数组可以理解为只能存放一行相同数据类型的数据。在Java中，如果要使用数组，需要先声明数组，然后分配数组内存（即可以存放多少个数据） public class Arrary { public static void main(String[] args) { //定义数组 int []arr = new int[]{1,2,3,4,3,2...
Java | 一维数组的遍历
最新发布
yingzix688的博客
03-06 652
一、使用for循环遍历数组 在Java中，使用for循环是遍历数组的一种常见方式。通过数组的索引来访问每个元素，直到遍历完数组的所有元素。
Java 一维数组 一维数组的遍历
m0_43443133的博客
03-18 504
一维数组 一维数组的遍历 public class Demo { public static void main(String[] args) { int[] abc= {20,90,48,92}; for(int i=0;i<abc.length;i++) { System.out.println(abc[i]); } } } ...
数组的length如何理解
u014660201的专栏
04-19 3981
如何理解数组的length? Java中的数组其实也是一个对象，但是确实是一个特殊的对象，实在是太特殊了， 以致我们都不好把它多做对象处理。 1.数组是对象，继承自Object 唯一比Object多一个成员变量length，而且应该是public的。 2.java.lang.reflect.Array是final的，所以数组肯定不是它的子类 这个类用来动
Java基础：一维数组的遍历
qq_52130567的博客
07-05 1367
所谓遍历，就是将一组数据中的所有元素访问一遍。一维数组的遍历就是访问一维数组中所含的所有数据，说白了就是扫描整个一维数组。用于批量查找或操作数组的元素数组的下标区间是在[0, 数组长度 - 1](或者[0, 数组长度) )，所以可以用循环结构中的for循环实现。代码格式：如果想访问数组中部分元素，可以修改i的初值和循环条件问题：随机生成10个介于[0, 100]的随机整数，求这些数中，大于它们平均数的有几个思路分析：代码： 其中，将随机数录入数组的操作看似可以和计算总和的操作写在一个for循环上，但违
数组 length 方法 和 String length() 方法
Po_tato的博客
10-31 3456
数组具有 length 属性 String 具有 length（） 方法 数组具有 length 属性 用 数组变量名.length 可获得数组长度。 int[] arr = new int[8]; int lengthInt=arr.length; //获得数组长度 System.out.println(lengthInt); // 打印结...
遍历一维数组
CWHcwh123456的博客
06-19 142
遍历一维数组
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

道长爱睡懒觉

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

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

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

打赏作者

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

抵扣说明：

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

余额充值