java学习笔记——正则表达式

最新推荐文章于 2023-03-04 21:39:35 发布
最新推荐文章于 2023-03-04 21:39:35 发布
阅读量251 收藏
点赞数 1
分类专栏： 笔记 文章标签： java 正则表达式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lemon6564562/article/details/108826636
版权

正则表达式

正则表达式：符合一定规则的表达式

  • 用途：用于专门操作字符串的规则
  • 优点：可以简化对字符串的复杂操作
  • 缺点：符号定义越多，正则表达式越长，阅读性越差

语法规则：
Regular_expression

示例

package regular_expression;
/**
 * 正则表达式：符合一定规则的表达式
 * 用途：用于专门操作字符串的规则
 * 优点：可以简化对字符串的复杂操作
 * 缺点：符号定义越多，正则表达式越长，阅读性越差
 * @author MCC
 * 需求：对QQ号码进行校验，要求：5-15位，0不能开头，只能是数字
 */
public class RegularExpression {
	public static void main(String[] args) {
//		System.out.println(check("1425146201"));
//		System.out.println(myCheck("1425146201"));	
		System.out.println(regularCheck("1425146201"));
	}
	public static boolean check(String str) {
		int count = str.length();
		boolean flag1 = false, flag2 = true, temp = false;
		if((count>=5&&count<=15) && !str.startsWith("0")) {
			flag1 = true;
		}
		for(int i=0; i<str.length(); i++) {
			temp = str.charAt(i)<='9' && str.charAt(i)>='0';
			flag2 = temp && flag2;
			//或者转换成数组
//			char[] ch = str.toCharArray();
//			for(int i=0; i<ch.length; i++){}
		}
		return flag1 && flag2;
	}
	/*
	 * 一种简单写法
	 */
	public static boolean myCheck(String str) {
		if(!str.startsWith("0")) {
			if(str.length()>=5 && str.length()<=15) {
				//改进之处
				try {
					long l = Long.parseLong(str);//如果包含字母，则转换失败，报异常
					return true;
				}catch(NumberFormatException e) {
					System.out.println("只能是纯数字");
				}
			}else {
				System.out.println("长度应为0-15之间");
			}
		}else {
			System.out.println("不能用0开头");
		}
		return false;
	}
	/*
	 * 使用正则表达式
	 */
	public static boolean regularCheck(String str) {
		//使用boolean matches(String regex)//String regex是正则表达式
		String reg = "[1-9][0-9] {4,14}";
		boolean flag = str.matches(reg);
		return flag;
	}
}

匹配

package regular_expression;
/**
 * 正则表达式：匹配
 * boolean matches(String regex)//用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false.
 * 
 * @author MCC
 * 
 * 字符类：
 * [abc]	判断字符串上某一位置出现的字符是否为abc之一
 * [^abc]	Any character except a, b, or c (negation) 否定
 * [a-zA-Z]	a through z or A through Z, inclusive (range) 范围
 * [a-d[m-p]]	a through d, or m through p: [a-dm-p] (union) 并集
 * [a-z&&[def]]	d, e, or f (intersection) 交集
 * [a-z&&[^bc]]	a through z, except for b and c: [ad-z] (subtraction) 减去
 * [a-z&&[^m-p]]	a through z, and not m through p: [a-lq-z](subtraction) 减去
 * 
 * 预定义字符类：要使用\\d, \\D, 因为\是转义字符
 * .	Any character (may or may not match line terminators)
 * \d	A digit: [0-9]
 * \D	A non-digit: [^0-9]
 * \h	A horizontal whitespace character: [ \t\xA0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000]
 * \H	A non-horizontal whitespace character: [^\h]
 * \s	A whitespace character: [ \t\n\x0B\f\r]
 * \S	A non-whitespace character: [^\s]
 * \v	A vertical whitespace character: [\n\x0B\f\r\x85\u2028\u2029]
 * \V	A non-vertical whitespace character: [^\v]
 * \w	A word character: [a-zA-Z_0-9]
 * \W	A non-word character: [^\w]
 * 
 * Greedy 数量词：
 * X?	X, once or not at all
 * X*	X, zero or more times
 * X+	X, one or more times
 * X{n}	X, exactly n times
 * X{n,}	X, at least n times
 * X{n,m}	X, at least n but not more than m times
 * 
 */
public class RegularMatch {
	public static void main(String[] args) {
		String str = "a";
		String reg = "[bc]";//字符串第一个位置只能是bc中的一个，并且字符串只能有一个字符
							//如果去掉[]代表第一位只能是b，第二位只能是c
		boolean flag = str.matches(reg);
		System.out.println(flag);//false 
		
		System.out.println(checkTel("13464623061"));
	}
	//匹配电话号码
	public static boolean checkTel(String num) {
		/*
		 * 假设手机号段只有13X, 15X, 18X
		 */
		String reg = "[1][358]\\d{9}";
		return num.matches(reg);
	}
}

切割

package regular_expression;
/**
 * 切割：
 * String[] split(String regex)
 * @author MCC
 *
 */
public class RegularSplit {
	public static void main(String[] args) {
		mySplit("www.baidu.com", "\\.");//以.切割
		mySplit("C:\\Users\\MCC\\Desktop", "\\\\");//以\\切割(转义字符)
		mySplit("abcddeffgh", "(.)\\1");
		/* 以叠词切割, 
		 * ()是组的概念, (.)代表第一组上的数任意取值, 
		 * \1代表第二位上的数要与第一组中的数相同, 由于 \ 是转义字符, 因此想表达 \ 要使用 \\
		 * 
		 * 组：
		 * 若想将某个规则作用后的结果被重用，可以将该规则封装成一个组，用()表示，
		 * 每个组都有自己的编号，从1开始，想要使用已有的组时，通过 \n 的形式完成(n是组的编号, 由于转义字符, 要使用 \\)
		 * 
		 * ((A)(B(C))) 有4组
		 * 1. ((A)(B(C)))
		 * 2. (A)
		 * 3. (B(C))
		 * 4. (C)
		 */
		mySplit("duwfka1xdowjf1xd1xd161258", "([1][x][d])\\1");//在出现1xd1xd的位置切割
		//在出现ac1xd1xd的位置切割
		mySplit("duwfkaac1xdowjfac1xd1xd161258", "([a][c]([1][x][d]))\\2");
	}
	public static void mySplit(String str, String regex) {
		String[] s = str.split(regex);
		for(String ss : s) {
			System.out.print(ss+"  ");
		}
		System.out.println();
	}
}

替换

package regular_expression;
/**
 * 替换：(String replace()//不使用正则表达式)
 * String replaceAll(String regex, String replacement)
 * @author MCC
 *
 */
public class RegularReplace {
	public static void main(String[] args) {
		String str = "1an8c341bci86csb22l100xke3yw722";
		String str1 = "12ee3566tt19982qq74wwww8qq";
		myReplaceAll(str, "\\d+", "#");//将字符串中的数字替换成#
		myReplaceAll(str, "\\d{2,}", "#");//将字符串中的数字连续出现2次或两次以上的替换为#
		myReplaceAll(str1, "(.)\\1+", "#");//将字符串中的叠词替换成#,qqqq变成#, 而非##
		myReplaceAll(str1, "(\\D)\\1+", "#");//将字符串中的字母叠词替换成#
		//将重叠的字母替换成单个字母
		//$n-替换操作中的特殊操作
		myReplaceAll(str1, "(\\D)\\1+", "$1");//$n-获取第n组中的元素，本例中，有叠词tt,则$1==t
		
		//将每个字符前加两个0
		String str2 = "abcdefg";
		myReplaceAll(str2, "(\\D)", "00$1");
	}
	public static void myReplaceAll(String str, String regex, String newStr) {
		String s = str.replaceAll(regex, newStr);
		System.out.println(s);
	}
}

获取

1. 步骤：

  1. 将正则表达式封装成对象——Pattern对象
  2. 让正则表达式对象与要操作的字符串相关联——compile()
  3. 关联后，获取正则匹配引擎——Matcher对象
  4. 通过引擎对符合规则的子串进行操作，比如取出——使用Matcher类提供的方法

2.

  • 正则表达式regular-expression属于Pattern类
  • Pattern类在Package java.util.regex下
  • Pattern类不能new对象，通过下述方法将正则表达式封装成Pattern对象
    static Pattern compile​(String regex)
    static Pattern compile​(String regex, int flags)

3.
两个方法：

  1. 将原字符串与规则进行匹配, 注意：只匹配一次
    boolean find()
    boolean find​(int start)     从指定位置开始获取
  2. 获取匹配后的结果（取出满足规则的子串），注意：只取出一次
    String group()

4.

  • 获取与规则匹配的子串的开始位置和结束位置
    int start()
    int end()
    包含start，不包含end
package regular_expression;
/**
 * 获取：将字符串中符合规则的子串取出
 * 操作步骤：
 * 1.将正则表达式封装成对象
 * 2.让正则表达式对象与要操作的字符串相关联
 * 3.关联后，获取正则匹配引擎
 * 4.通过引擎对符合规则的子串进行操作，比如取出
 * @author MCC
 * 正则表达式regular-expression属于Pattern类
 * Pattern类在Package java.util.regex下
 * Pattern类不能new对象，通过下述方法将正则表达式封装成Pattern对象
 * static Pattern compile​(String regex)	
 * static Pattern compile​(String regex, int flags)	
 */

import java.util.regex.*;

public class RegularGet {
	public static void main(String[] args) {
		getString();
	}
	public static void getString() {
		String str = "ming tian jiu yao fang jia le";
		//将字符串中连续三个字母组成的子串取出
		//1.将正则表达式封装成对象
		String regex = "[a-z]{3}";
		String regex1 = "\\b[a-z]{3}\\b";//加入单词边界匹配器
		Pattern p = Pattern.compile(regex1);
		//2.让正则表达式对象与要操作的字符串相关联，并获取匹配器(引擎)，即Matcher对象
		Matcher m = p.matcher(str);//matcher(CharSequence input), String是CharSequence的子类
		//Matcher类有许多方法，其中String类的matches(),replaceAll()
		//就是封装了Pattern类和Matcher类的方法实现的
		/*
		 * 两个方法：
		 * 1. 将原字符串与规则进行匹配, 注意：只匹配一次
		 * boolean	find()	
		 * boolean	find​(int start)//从指定位置开始获取
		 * 2.获取匹配后的结果(取出满足规则的子串)，注意：只取出一次
		 * String	group()
		 */
		//循环获取所有符合规则的子串
		while(m.find()==true) {
			System.out.println(m.group());//匹配的结果有些不是单词，要找到单词的边界
			/*
			 * 获取与规则匹配的子串的开始位置和结束位置
			 * int	start()
			 * int	end()
			 * 包含start, 不包含end
			 */
			System.out.println(m.start()+"..."+m.end());
		}
		/*
		边界匹配器：
		^	The beginning of a line
		$	The end of a line
		\b	A word boundary
		\b{g}	A Unicode extended grapheme cluster boundary
		\B	A non-word boundary
		\A	The beginning of the input
		\G	The end of the previous match
		\Z	The end of the input but for the final terminator, if any
		\z	The end of the input
		*/
		
	}
}

练习

  • 判断字符串是否正确–匹配
  • 将已有的字符串变成另一个字符串–替换
  • 按照要求将已有字符串变成多个字符串–切割（获取规则以外的字符串）
  • 获取符合要求的字符串–获取（获取符合规则的字符串）

程序1

package regular_expression;
/**
 * 判断字符串是否正确--匹配
 * 将已有的字符串变成另一个字符串--替换
 * 按照要求将已有字符串变成多个字符串--切割（获取规则以外的字符串）
 * 获取符合要求的字符串--获取（获取符合规则的字符串）
 * @author MCC
 *
 */
public class RegularPractice1 {
	public static void main(String[] args) {
		//将下述字符串转换成：我是中国人
		String str = "我我...我..是是是..是是是...中中国..人.";
		/*
		 * 替换：
		 * 1.去掉.
		 * 2.将叠词变成单个字符
		 */
		str = str.replaceAll("\\.+", "");
		System.out.println(str);//我我我是是是是是是中中国人
		str = str.replaceAll("(.)\\1+", "$1");
		System.out.println(str);//我是中国人
	}
}

程序2

将ip地址按照地址段排序

package regular_expression;

import java.util.TreeSet;

/**
 * 将ip地址按照地址段排序
 * @author MCC
 *
 */
public class RegularPractice2 {
	public static void main(String[] args) {
		String ip = "192.168.0.154 102.49.23.13 10.10.10.10 8.109.90.30";
		//将ip拆成String[]在进行比较不行，因为192与8进行比较时，逐位进行比较，1<8，192排在了8的前面，错误
		//1.将每位补两个0
		ip = ip.replaceAll("(\\d+)", "00$1");
		//00192.00168.000.00154 00102.0049.0023.0013 0010.0010.0010.0010 008.00109.0090.0030
		//2.取前三位
		ip = ip.replaceAll("0*(\\d{3})", "$1");//0开头(可以不存在)，数字一共出现3次
		//192.168.000.154 102.049.023.013 010.010.010.010 008.109.090.030
		//3.以空格为切割符切割
		String ip_str[] = ip.split(" ");
		//4.存入到TreeSet中，自动排序
		TreeSet<String> tr = new TreeSet<String>();
		for(String temp : ip_str) {
			tr.add(temp);
		}
		//打印数据
		for(String ip_res : tr) {
			//打印时不打印最前面的0
			System.out.println(ip_res.replaceAll("0+(\\d+)", "$1"));
			/*
			8.19.90.30
			10.10.10.10
			12.49.23.13
			192.168.0.154
			*/
		}
	}
}

程序3

对邮件地址进行校验

package regular_expression;
/**
 * 对邮件地址进行校验
 * @author MCC
 *
 */
public class RegularPractice3 {
	public static void main(String[] args) {
		System.out.println(checkMailAddress("1654882116@qq.com"));
		System.out.println(checkMailAddress("zhangsan123@xyz.edu.cn"));
	}
	public static boolean checkMailAddress(String address) {
		//可以验证123@abc.com类的邮箱
//		String regex = "\\w{5,15}@[a-zA-Z0-9]+\\.[a-zA-Z]+";
		//可以验证123@abc.com.cn类的邮箱
//		String regex = "\\w{5,15}@[a-zA-Z0-9]+\\.[a-zA-Z]+\\.[a-zA-Z]+";
		//综合结果
//		String regex = "\\w{5,15}@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";//正常情况下，域名最多两个
//		String regex = "\\w+@\\w+(\\.\\w+)+";//相对不精确匹配
		String regex = "\\w{5,15}@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,2}";//正常情况下，域名最多两个
		return address.matches(regex);
	}
}

程序4

模拟网页爬虫

package regular_expression;

import java.io.*;
import java.util.regex.*;
import java.net.*;
/**
 * 模拟网页爬虫
 * @author MCC
 *
 */
public class RegularPractice4 {
	public static void main(String[] args) throws Exception{
		spiderTxtMail("C:\\Users\\MCC\\Desktop\\mail_text.txt", 
				"C:\\Users\\MCC\\Desktop\\mail_result.txt");
		spiderWebMail("https://tieba.baidu.com");
	}
	/*
	 * 文档爬虫
	 */
	public static void spiderTxtMail(String path, String address) throws Exception{
		//建立存储邮箱数据的容器
		StringBuilder sb = new StringBuilder();
		//读取数据源
		File file = new File(path);//判断文件是否存在省略
		BufferedReader br = new BufferedReader(new FileReader(file));
		//将规则封装成正则对象
		String regex = "\\w{6,12}@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,2}";
		
		Pattern p = Pattern.compile(regex);
		//将规则对象与数据关联
		String line = null;
		while((line=br.readLine())!=null) {
			Matcher m = p.matcher(line);
			while(m.find()) {
				sb.append(m.group()+"\n");
			}
		}
		br.close();
		//将StringBuilder中的内容写入本地
		PrintWriter pw = new PrintWriter(new FileWriter(address), true);
		pw.println(sb.toString());
		pw.close();
	}
	/*
	 * 网页爬虫
	 * 通过关联网页实现
	 */
	public static void spiderWebMail(String address) throws Exception{
		//建立URL对象
		URL url = new URL(address);
		//与网页(服务器)建立连接，不需要使用socket
		URLConnection con = url.openConnection();
		//获取输入流
		InputStream in = con.getInputStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(in));
		//将规则封装成正则对象
		String regex = "\\w{6,12}@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,2}";
		Pattern p = Pattern.compile(regex);
		//将规则对象与数据关联
		String line = null;
		while((line=br.readLine())!=null) {
			Matcher m = p.matcher(line);
			while(m.find()) {
				System.out.println(m.group());
			}
		}
		br.close();
	}
}
MCC莫大大
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java JDK 6.0学习笔记
08-25
【Java JDK 6.0学习笔记】是一份详尽的文档，主要针对Java初学者，旨在帮助他们理解和掌握Java编程的基础知识。这份笔记基于Java 6.0版本，该版本在2006年12月初正式发布，尽管相较于之前的J2SE 5.0没有显著的变化，...
Java开发详解.zip
09-02
000000_【课程介绍 —— 写在前面的话】_Java学习概述笔记.pdf 010101_【第1章：JAVA概述及开发环境搭建】_JAVA发展概述笔记.pdf 010102_【第1章：JAVA概述及开发环境搭建】_Java开发环境搭建笔记.pdf 010201_【第2...
3.4笔试总结
最新发布
m0_72618437的博客
03-04 560
笔试 是多少
笔试（1）
。。。。。。
02-12 9391
应用计算机处理日常事务或者是编写程序的时候，经常需要用到带有通配符的字符串匹配。比如：linux命令行下输入。 输入 CaCO3，其组成分别为 Ca：1，C：1，O：3，输出 Ca1C1O3
【知识积累】10. Regular Expression Matching And 44. Wildcard Matching
Darren的博客
09-29 137
PS：leetcode第10题和第44题是动态规划的类型的题，十分类似，可以放一起，当然第10题会难一些。 一、第10题 - 暴力递归 public static boolean isMatch(String str, String pattern) { return process(str.toCharArray(), pattern.toCharArray(), 0, 0); } //给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*'
【LeetCode】44.Wildcard Matching
iKun
06-13 170
这个道题的大意是：输入一个目标串：s ,以及一个匹配串：p，进行如下规则的匹配： 如果p中存在?，则可以匹配s中任意一个单个字符 如果p中存在*，则可以匹配s中任意一串连续的序列，包括空字符 解法一：双指针 给定两个指针pIndex，sIndex。一个遍历p一个遍历s。当我们遍历时，会遇见如下的情况： 当s[pIndex] == s[sIndex] 或者 ...
LeetCode OJ算法题（十）：Regular Expression Matching
op_yu的专栏
07-15 736
题目： Implement regular expression matching with support for '.' and '*'. '.' Matches any single character. '*' Matches zero or more of the preceding element. The matching should cover the entire
学习笔记
03-21
【学习笔记】这篇压缩包包含了多个关于IT领域的学习资料，主要涵盖了JavaScript和Java两个核心话题。以下是这些资源中涉及的主要知识点： 1. **盛大面试题：js检查页面上有无重复id（可用框架jquery）** 这个话题...
2021最新java面试合集pdf.rar
09-23
MongoDB学习笔记.docx mybatis原理.docx MyBatis面试专题.docx MyBatis面试专题及答案.pdf Mybatis面试题（含答案）.pdf MySQL性能优化的21个最佳实践.pdf mysql面试专题.docx MySQL面试题（含答案）.pdf Netty面试...
Java的2本经典
06-18
本文将深入探讨两本关于Java的经典书籍——《Java学习笔记》和《Java中正则表达式使用方法详解》，以及它们涵盖的重要知识点。 《Java学习笔记》是一本为初学者和进阶者量身定制的教材，旨在全面系统地介绍Java编程...
Leetcode题解（三）
weixin_30258901的博客
11-30 133
8、String to Integer (atoi) 题目 这道题目关键是要考虑清楚各种输入用例。针对每一种情况，函数都能处理，也就是函数鲁棒性很高。代码如下： 1 class Solution { 2 public: 3 int myAtoi(string str) { 4 int index=0; 5 int flag =...
String.replaceAll方法，正则妙用
小姐姐味道
07-18 2118
我通常是不太关心代码的具体实现的，因为我的开发语言很杂，倾向于一些最简单通用的方式去解决。今儿不小心在群里看到一位朋友发了下面的java代码，感觉自己还是很局限很无知的：...
正则表达式匹配(【Regular Expresssion Matching（正则表达式匹配）】)
zyzn1425077119的博客
01-09 421
参考Vosky的博客，网址：https://blog.csdn.net/hk2291976/article/details/51165010. 匹配任意一个字符，*匹配0个或者多个前导字符  *匹配0个或多个前导字符，例如a*，*的前导为a，故0或者多个a，即空字符串、a、aa、aaa、aaa、aaaaa等等     package algorithm; import java.uti...
Java String
长沙火山
10-17 495
Java String的基本用法1.计算字符串的长度 length( )计算字符串的长度 public static void main(String[] args) { // TODO Auto-generated method stub String string = new String(); string = "abcdefghlmn";
StringUtils一些常用方法
Ray777777777的博客
07-04 130
StringUtils是org.apache.commons.lang jar包里面的类方法，当输入参数String为null则不会抛出NullPointerException，而是做了相应处理，null是安全的。而JDK中String类里面的方法会抛出NullPointerException。下面我介绍StringUtils一些常用的方法，它和String类的方法有很多相似的地方。开发...
LeetCode题解-10-Regular Expression Matching
小毛的胡思乱想
03-02 261
解题思路思路是动态规划。假设s是待匹配字符串，p是表达式。定义数组matchs,其中matchs[i,j]表示s[0,i)和p[0,j)是否匹配，那么结果就是求matchs[s长度加1,p长度加1]。对于matchs[i,j]分以下情况: * i=0,j=0，空的肯定能匹配 * i=0,j!=0，那么在j>1的情况下且p[j-1]是星号的时候，match[0,j]=match[0,j-2]，相当
LeetCode 10. 正则表达式匹配
XY_xyz_xyz的博客
02-11 6535
给你一个字符串s和一个字符规律p，请你来实现一个支持 '.'和'*'的正则表达式匹配。 '.' 匹配任意单个字符 '*' 匹配零个或多个前面的那一个元素 所谓匹配，是要涵盖整个字符串s的，而不是部分字符串。 示例 1： 输入：s = "aa", p = "a" 输出：false 解释："a" 无法匹配 "aa" 整个字符串。 示例 2: 输入：s = "aa", p = "a*" 输出：true 解释：因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是...
【LeetCode】10. Regular Expression Matching - Java实现
小怪孩的成长之路
11-14 310
文章目录1. 题目描述：2. 思路分析：3. Java代码： 1. 题目描述： Given an input string (s) and a pattern (p), implement regular expression matching with support for '.' and '*'. ‘.’ Matches any single character. ‘*’ Matches ...
Regular Expression Matching @LeetCode
Fight for your dream
09-12 975
代码如下： package Algorithms; public class IsMach { public static void main(String[] str) { //System.out.println(isMatch("aa", "aa")); System.out.println(isMatch("aab", "c*a*b")
python爬虫学习笔记.pdf
09-10
Python爬虫学习笔记.pdf是一本介绍Python爬虫学习的重要文档。...因此，推荐对于爬虫学习感兴趣的朋友们，认真阅读并学习《Python爬虫学习笔记.pdf》中关于正则表达式的相关内容，相信会对你的学习和实践有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值