java正则表达式讲解

最新推荐文章于 2024-06-28 08:15:00 发布
最新推荐文章于 2024-06-28 08:15:00 发布
阅读量424 收藏
点赞数
分类专栏： Java 文章标签： java 正则表达
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28851503/article/details/85018537
版权

正则表达式基本简介

正则表达式（Regular Expression）是一种文本模式，包含数字，字母和以及特殊字符（元字符）等。从语法上来看，它虽然繁琐难以理解，但是在描述和处理文本方面它显得格外强大。很多编程语言都支持正则，包括但不限于C++、C#、Golang、java、python、js等等，而不同的语言其正则的语法亦略微有些差异。

正则表达式的的底层引擎实现有两种：DFA 自动机（Deterministic Final Automata 确定型有穷自动机）和 NFA 自动机（Non deterministic Finite Automaton 不确定型有穷自动机）。DFA自动机的时间复杂度是线性的，更加稳定，但是功能有限。而NFA的时间复杂度比较不稳定，有时候很好，有时候不怎么好，好不好取决于你写的正则表达式(可参考一个由正则表达式引发的血案)。

下面将简单介绍一下java（8）- NFA 正则表达式的使用。

Java正则介绍

Java正则方面主要包含三个类：Pattern、Matcher、PatternSyntaxException，在java.util.regex包下。

Pattern类

在Pattern注释中是这样描述这个类的：A compiled representation of a regular expression（正则表达式的编译表示）。java中，一个正则表达式（字符串）必须编译成该类的实例，才能去被Matcher使用，一个pattern实例是可以被多个matcher进行使用的。

compile

Pattern类不提供公共的构造函数，其只对外暴露了两个静态重载方法来编译构建pattern实例：

public static Pattern compile(String regex) {
    return new Pattern(regex, 0);
}
public static Pattern compile(String regex, int flags) {
    return new Pattern(regex, flags);
}

由代码可见，Pattern的私有构造函数会有一个flags的参数，第一个函数默认给的是0，第二个是让使用者自己控制，那么flags这个参数有什么用呢？这个参数可以被赋予哪儿些值呢？

flags是匹配标志，一个位掩码，其可取值如下：

表达式值embedded flag描述
Pattern.UNIX_LINES0x01(?d)此模式下只有’\n’换行符被认可，且同’.’,’^’,’$'一样进行匹配
Pattern.CASE_INSENSITIVE0x02(?i)默认情况下，大小写不敏感只针对US-ASCII字符，此模式在搭配UNICODE_CASE时可使得Unicode字符对大小写不敏感
Pattern.COMMENTS0x04(?x)在此模式下，空格会被忽略，且以‘#’开头的行注释会被忽略
Pattern.MULTILINE0x08(?m)此模式下，’^‘和’KaTeX parse error: Expected group after '^' at position 19: …匹配一行的开始和结束，此外，'^̲'仍然匹配字符串的开始，''也匹配字符串的结束。默认情况下，这两个表达式仅仅匹配字符串的开始和结束
Pattern.LITERAL0x10无此模式下输入的字符串被认为是文字字符，其中的元字符和转移字符将失去其特殊意义。除了标志CASE_INSENSITIVE和UNICODE_CASE与此标志一起使用时保留其影响，其他标志会变得多余
Pattern.DOTALL0x20(?s)此模式下’.'符号可以匹配任意字符，包含行结束符（默认情况不包含）
Pattern.UNICODE_CASE0x40(?u)使用此模式，当同时使用CASE_INSENSITIVE模式时，匹配是对大小写不敏感
Pattern.CANON_EQ0x80无启动规范等价，此模式下，如果且仅当它们的完整规范分解匹配时，将认为两个字符匹配
Pattern.UNICODE_CHARACTER_CLASS0x100(?U)启用Unicode版本的预定义字符类和POSIX字符类

下面给出flags的一种使用情况，针对三种情况匹配正则忽略大小写问题：

  1. flags = 0（默认）, 预期结果不不忽略；
  2. flags = Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE，预期结果忽略大小写；
  3. 正则加入(?i)且flags=0（默认），预期结果忽略大小写；
public class RegexDemo {

    public static void main(String[] args) {
        System.out.println("====case one====");
        String regex = "Hello";
        String text = "Hello, word! hello!";

        Pattern pattern1 = Pattern.compile(regex);
        Matcher matcher1 = pattern1.matcher(text);
        while (matcher1.find()) {
            System.out.println("match1: " + matcher1.group());
        }
        System.out.println("====case two====");
        Pattern pattern2 = Pattern.compile(regex, Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);
        Matcher matcher2 = pattern2.matcher(text);
        while (matcher2.find()) {
            System.out.println("match2: " + matcher2.group());
        }
        System.out.println("====case three====");
        String regex3 = "(?i)Hello";
        Pattern pattern3 = Pattern.compile(regex3);
        Matcher matcher3 = pattern3.matcher(text);
        while (matcher3.find()) {
            System.out.println("match3: " + matcher3.group());
        }
    }
}

输出结果如下，可以看到全部达到预期结果：

====case one====
match1: Hello
====case two====
match2: Hello
match2: hello
====case three====
match3: Hello
match3: hello
matches
public static boolean matches(String regex, CharSequence input) ;

matches是Pattern类提供的静态公共方法，用于判断正则与输入的文本是否匹配.

quote
public static String quote(String s);

quote方法是Pattern提供的静态公共方法，其说明为“Metacharacters or escape sequences in the input sequence will be given no special meaning”，意义是输入序列中的元字符或转义序列将没有特殊含义，也就是说用此方法得到的一个字符串，其内部的 ‘.’ , ‘*’ 等特殊符号和’\n’等转义符号将变成普通的文本。

私有方法

下面是Pattern类下的私有方法：

// 创建Matcher对象
public Matcher matcher(CharSequence input)；

// 获取当前正则的flags标志
public int flags();

// 返回正则表达式
public String pattern();

// 根据正则匹配的结果来分割输出的字符串数组
// example：regex = "(?i)A|a"; text = "小a你好，我是大A。"
// 则结果为 {"小", "你好，我是大","。"}
// limit是控制匹配的次数，若limit = n，则最多匹配n-1次，limit=0表示全匹配。
// example：limit = 2，能匹配1次
// 则结果为 {"小","你好，我是大A。"}
public String[] split(CharSequence input, int limit) ;

// 同上，默认limit=0
public String[] split(CharSequence input);

// 根据正则匹配结果分割输出流式的数组（全匹配），从而可进行流式操作
public Stream<String> splitAsStream(final CharSequence input);

// 创建可用于匹配字符串的谓词
public Predicate<String> asPredicate();

这里来说明一下split方法，split方法时根据正则匹配的结果来分割输出的字符串数组。参数limit是控制匹配的次数，若limit = n，则最多匹配n-1次，limit=0表示全匹配。 下面用2中情况来说明：

  1. limit=0(默认)，预期结果为 {“小”, “你好，我是大”,"。"}
  2. limit=2，预期结果为 {“小”,“你好，我是大A。”}
public class RegexDemo {

    public static void main(String[] args) {
        String regex = "(?i)A|a";
        String text = "小a你好，我是大A。";
        Pattern pattern = Pattern.compile(regex);
        String[] result1 = pattern.split(text);
        System.out.println("====limit 0====");
        Stream.of(result1).forEach(System.out::println);
        System.out.println("====limit 2====");
        String[] result2 = pattern.split(text, 2);
        Stream.of(result2).forEach(System.out::println);
}

输出结果如下：

====limit 0====
小
你好，我是大
。
====limit 2====
小
你好，我是大A。

Matcher类

Matcher类是对输入字符串进行解释和匹配操作的引擎。其没有公共构造方法。是通过Pattern 对象的matcher方法来创建Matcher对象的。

quoteReplacement

quoteReplacement是Matcher类提供的仅有的一个静态公共方法，源码如下：

public static String quoteReplacement(String s) {
    if ((s.indexOf('\\') == -1) && (s.indexOf('$') == -1))
        return s;
    StringBuilder sb = new StringBuilder();
    for (int i=0; i<s.length(); i++) {
        char c = s.charAt(i);
        if (c == '\\' || c == '$') {
            sb.append('\\');
        }
        sb.append(c);
    }
    return sb.toString();
}

其作用是处理字符串文本中的‘$’和‘\’两个字符，将其从原本的特殊意义字符转义成普通字符。

校验是否匹配

Matcher类的校验API如下：

// 尝试查找与该模式匹配的输入序列的下一个子序列。
public boolean find();

// 重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
public boolean find(int start);

// 匹配全文本
// example： 
// regex = "regex"; text = "regex"; result = true
// regex = "regex"; text = "regex, matches"; result = false
public boolean matches();

// 从文本的最开始位置进行匹配，判断是否与该模式匹配。
// example： 
// regex = "regex"; text = "matches, regex"; result = false
// regex = "regex"; text = "regex, matches"; result = true
public boolean lookingAt()；

下面通过代码来说明一下matchers和lookingAt方法的使用，首先是matches方法：

  1. regex = “regex”; text = “regex” 预期结果true
  2. regex = “regex”; text = “regex, matches”; 预期结果false
public class RegexDemo {

    public static void main(String[] args) {
        String regex = "regex";
        String text1 = "regex";
        String text2 = "regex, matches";
        System.out.println("====case one====");
        System.out.println(Pattern.matches(regex, text1));
        System.out.println("====case two====");
        System.out.println(Pattern.matches(regex, text2));
    }
}

输出结果如下：

====case one====
true
====case two====
false

其次是lookingAt方法：

  1. regex = “regex”; text = “matches, regex”; 预期结 false
  2. regex = “regex”; text = “regex, matches”; 预期结 true
public class RegexDemo {

    public static void main(String[] args) {
        String regex = "regex";
        String text1 = "matches, regex";
        String text2 = "regex, matches";
        Pattern pattern = Pattern.compile(regex);
        System.out.println("====case one====");
        Matcher matcher1 = pattern.matcher(text1);
        System.out.println(matcher1.lookingAt());
        System.out.println("====case two====");
        Matcher matcher2 = pattern.matcher(text2);
        System.out.println(matcher2.lookingAt());
    }
}

输出结果如下：

====case one====
false
====case two====
true
定位匹配配置

Matcher类的定位查找方面的API如主要是group, start, end与region等，如下所示：

// 返回指定的符合匹配条件的子序列(正则的组概念), 0代表这个那个正则表达式，group>0表示正则的子表达式
// example: regex = "(.)\\1{2,}"; text = "Hello, aaaaa!";
// 匹配结果 group(0) = "aaaaa" ; group(1) = "a";
public String group(int group)
// 返回匹配到的子串，同 matcher.group(0)
public String group()
// 根据组名得到匹配子串
// example: regex = "(?<groupName>.)\\1{2,}"; text = "Hello, aaaaa!";
// 匹配结果 group(0) = "aaaaa" ; group(groupName) = "a";
public String group(String name)
// 返回捕获组的个数
public int groupCount();

// 返回匹配到的字串的开始索引位置
public int start();
// 返回上一个匹配操作期间给定组ID捕获的子序列的起始索引。
public int start(int group);
// 返回上一个匹配操作期间给定组名捕获的子序列的起始索引。
public int start(String name)；

// 最后一个字符匹配后的偏移量
public int end();
// 返回上一个匹配操作期间给定组ID捕获的子序列的最后一个字符匹配的偏移量
public int end(int group);
// 返回上一个匹配操作期间给定组名捕获的子序列的最后一个字符匹配的偏移量
public int end(String name);

// 设置匹配器的匹配域（文本索引区间）
// example：regex = "VIP|(?<wifi>wifi)|(?<vip>vip)|wifi"; text = "我用的wifi是vip的。";
//          region(0,8);
// 结果： 能匹配到wifi, 无法匹配到vip
public Matcher region(int start, int end);
// 返回匹配域的开始位置
public int regionStart();
// 返回匹配域的结束位置
public int regionEnd();

下面通过使用代码来说明一下group和region的使用。首先是group，下面的代码将展示group几个重载方法的使用：

public class RegexDemo {

    public static void main(String[] args) {
        String regex1 = "(.)\\1{2,}";
        String regex2 = "(?<groupName>.)\\1{2,}";
        String text = "Hello, aaaaa!";
        Pattern pattern1 = Pattern.compile(regex1);
        Pattern pattern2 = Pattern.compile(regex2);
        Matcher matcher1 = pattern1.matcher(text);
        Matcher matcher2 = pattern2.matcher(text);
        if (matcher1.find()) {
            System.out.println("方法group()输出：" + matcher1.group());
        }
        // 重置匹配器
        matcher1.reset();
        if (matcher1.find()) {
            System.out.println("方法group(1)输出：" + matcher1.group(1));
        }
        if (matcher2.find()) {
            System.out.println("方法group(name)输出：" + matcher2.group("groupName"));
        }
    }
}

输出结果如下：

方法group()输出：aaaaa
方法group(1)输出：a
方法group(name)输出：a

接下来是region，通过下面的代码可以了解region的使用情况：

public class RegexDemo {

    public static void main(String[] args) {
        String regex = "VIP|(?<wifi>wifi)|(?<vip>vip)|wifi";
        String text = "我用的wifi是vip的。";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        matcher = matcher.region(0, 8);
        System.out.println("方法regionStart()输出：" + matcher.regionStart());
        System.out.println("方法regionEnd()输出：" + matcher.regionEnd());
        while (matcher.find()) {
            System.out.println("方法region(0,8)匹配：" + matcher.group());
        }
        matcher = matcher.region(8, 12);
        System.out.println("方法regionStart()输出：" + matcher.regionStart());
        System.out.println("方法regionEnd()输出：" + matcher.regionEnd());
        while (matcher.find()) {
            System.out.println("方法region(8,12)匹配：" + matcher.group());
        }
    }
}

输出结果如下：

方法regionStart()输出：0
方法regionEnd()输出：8
方法region(0,8)匹配：wifi
方法regionStart()输出：8
方法regionEnd()输出：12
方法region(8,12)匹配：vip
替换匹配文本

Matcher类文本替换相关的方法如下：

// 替换第一个匹配到的第一个子串
public String replaceFirst(String replacement)

// 替换匹配到的所有子串
public String replaceAll(String replacement);

// 实现非终端添加和替换步骤
public Matcher appendReplacement(StringBuffer sb, String replacement);

// 实现终端添加和替换步骤
public StringBuffer appendTail(StringBuffer sb);

这里着重看一下appendReplacement和appendTail的使用方法，下面的代码是展示用正则来剔除英文串的情况，同时若存在白名单中的单词不剔除：

public class RegexDemo {

    private static final Pattern PATTERN_WHITE_NAME = Pattern.compile("(?i)VIP|wifi");
    private static final Pattern PATTERN_ENGLISH = Pattern.compile("[a-zA-Z]+");

    public static void main(String[] args) {
        String text = "我用的aaaAwifigood是viphelooooo的。";
        Matcher matcher = PATTERN_ENGLISH.matcher(text);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            String str = matcher.group();
            matcher.appendReplacement(sb, processWhiteName(str));
        }
        matcher.appendTail(sb);
        System.out.println(sb.toString());
    }

    private static String processWhiteName(String str) {
        StringBuilder stringBuilder = new StringBuilder();
        Matcher matcherWhiteName = PATTERN_WHITE_NAME.matcher(str);
        while (matcherWhiteName.find()) {
            stringBuilder.append(matcherWhiteName.group());
        }
        return stringBuilder.toString();
    }
}

输出结果如下：

我用的wifi是vip的。
其他API
// 重置匹配器
public Matcher reset();
// 根据新输入的文本重值匹配器
public Matcher reset(CharSequence input);

// 设置匹配器的区域边界的锚定
public Matcher useAnchoringBounds(boolean b)
// 查询此匹配器的区域边界的锚定 
// 默认情况下为true
public boolean hasAnchoringBounds();

// 设置匹配器的区域边界的透明度
public Matcher useTransparentBounds(boolean b)
// 查询此匹配器的区域边界的透明度
// 默认情况下为true
public boolean hasTransparentBounds()

// 在此匹配器执行的最后一次匹配操作, 如果输入的结尾被搜索引擎命中，则返回true,
public boolean hitEnd();

// 返回匹配结果
public MatchResult toMatchResult();

// 返回此匹配器的模式
public Pattern pattern();
// 根据新的模式设置匹配器
public Matcher usePattern(Pattern newPattern);

// 如果更多输入可以将正匹配更改为负匹配，则返回true
public boolean requireEnd();

PatternSyntaxException类

PatternSyntaxException顾名思义，是用来表示在正则在编译的时候是否有语法错误。提供了如下API：

// 获取错误的描述
public String getDescription();
// 获取错误的索引
public int getIndex() ;
// 获取错误的正则表达式模式。
public String getPattern() ;
//返回多行字符串，包含语法错误及其索引的描述、错误的正则表达式模式和模式中错误索引的可视化指示
public String getMessage()

通过一个代码示例来看一下API的使用情况：

public class RegexDemo {

    public static void main(String[] args) {
        String regex = "((?i)[a-zA-Z]+";
        try {
            Pattern pattern = Pattern.compile(regex);
        } catch (PatternSyntaxException e) {
            System.out.println("getIndex输出: " + e.getIndex());
            System.out.println("getDescription输出: " + e.getDescription());
            System.out.println("getMessage输出: " + e.getMessage());
            System.out.println("getPattern输出: " + e.getPattern());
        }
    }
}

输出结果：

getIndex输出: 14
getDescription输出: Unclosed group
getMessage输出: Unclosed group near index 14
((?i)[a-zA-Z]+
              ^
getPattern输出: ((?i)[a-zA-Z]+
lazycece
关注
专栏目录
无涯教程-Java 正则 - Pattern quote(String s)函数
无涯教程
12-31 868
java.util.regex.Pattern.quote(String s)方法返回指定String的文字模式。
java正则表达式匹配网页所有网址和链接文字的示例
09-04
在Java编程中，正则表达式是处理文本模式匹配的强大工具，尤其在处理网页内容时，如提取网址和链接文字。这个示例展示了如何使用Java的正则表达式来匹配网页中的所有网址和链接文字。下面将详细讲解相关知识点。 1....
Java正则表达式详解（1）
溺水的鱼 - Later equals never.
10-12 1617
如果你曾经用过Perl或任何其他内建正则表达式支持的语言，你一定知道用正则表达式处理文本和匹配模式是多么简单。如果你不熟悉这个术语，那么“正则表达式”（Regular Expression）就是一个字符构成的串，它定义了一个用来搜索匹配字符串的模式。
正则表达式(Java版整理)
12-21 2137
基础元字符 代码 说明 . 匹配除换行符以外的任意字符 \w 匹配字母或数字或下划线或汉字 \s 匹配任意的空白符 \d 匹配数字 ^ 匹配字符串的开始 $ 匹配字符串的结束 \b 匹配字符串的结束 重复 代码/语法 说明 * 重复零次或更多次 + 重复一次或更多次 ? 重复零次或一次 {n} 重复n
Java正则表达式详解
不混了的专栏
05-23 390
Java正则表达式详解 本文出自:http://www.computerworld.com.cn 作者:仙人掌工作室 (2002-01-29 20:49:25) 如果你曾经用过Perl或任何其他内建正则表达式支持的语言，你一定知道用正则表达式处理文本和匹配模式是多么简单。如果你不熟悉这个术语，那么“正则表达式”（Regular Expression）就是一个字符构成的串，它定义了一个用来搜索匹配字
Java——正则表达式详解
吴声子夜歌的博客
03-07 6252
Java对正则表达式的支持是从1.4版本开始的，此前的JRE版本不支持正则表达式。Java语言中的正则表达式匹配功能主要是通过和类实现的。find()：在一个字符串里寻找一个给定模式的匹配：用一个给定的模式尝试匹配一个字符串的开头matches()：用一个给定的模式去尝试匹配一个完整的字符串：进行替换操作，对所有的匹配都进行替换：进行替换操作，只对第一个匹配进行替换compile()：把一个正则表达式编译成一个模式flags()：返回某给定模式的匹配标志matches()
java使用正则表达式判断邮箱格式是否正确的方法
09-03
在Java程序设计中，经常会遇到需要验证邮箱地址格式正确性的情况。...通过上述的讲解和示例代码，我们可以清楚地了解到如何使用正则表达式来验证Java中的邮箱格式是否正确，以及相关的Java字符串处理技巧。
java_zhengze.rar_正则表达式_正则表达式 java
09-14
本资料"java_zhengze.rar"提供了对Java正则表达式的详细讲解，包括基本概念、元字符、预定义字符类以及各种匹配操作，对于Java开发者来说是一份非常实用的学习资源。 首先，我们来了解一下正则表达式的基石——元...
Java通过正则表达式获取字符串中数字的方法示例
08-31
本篇文章将详细讲解如何使用Java和正则表达式来获取字符串中的数字。 首先，我们需要了解Java中的`java.util.regex`包，这个包提供了`Pattern`和`Matcher`两个类来处理正则表达式。`Pattern`类用于编译正则表达式，...
java正则表达式实例教程
01-12
Java正则表达式是Java编程语言中用于处理字符串的强大工具，它允许程序员通过模式匹配来查找、替换或分割文本。本教程将深入讲解Java中的正则表达式，并提供丰富的实例来帮助开发者理解和应用这些概念。 1. 正则...
java 正则表达式讲解
mojianpo 莫建坡
11-12 109
比如：判断字符串中不能含有“,:*” 三个字符 java 写法： String str = "*aaa"; String regex = "^.*[,:*].*$"; boolean b = str.matches(regex); ====================================== \\ 反斜杠 \t 间隔 ('\u0009') \n 换行 ('\u000...
Java的正则表达式详细演示说明（建议收藏）
SeeYouAgain的博客
02-01 1356
每天进步一点点，每一点点去进步。正则表达式，用起来很爽，所以更不能轻易放过她，你不重视她，她就会离你而去。
Java 正则详解
Byyyi耀的博客
12-20 1112
Java正则详解
【Java】正则表达式的理解与运用
JockLiu的博客
05-18 245
正则表达式 正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。 相关元字符 字符 描述 \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换...
[ Java ] 最通俗易懂的正则表达式讲解
爪白白的个人博客
05-13 2596
定义了字符串的模式。 正则表达式可以用来搜索、编辑或处理文本。 并不仅限于某一种语言。
java中正则表达式的理解和使用
村长
02-09 616
在编程中，有时你会发现正则表达式是一个很有用的工具，这篇文章让我和大家一起来理解和使用正则表达式。         首先我们来看看正则表达式的基础知识，包括点符号(.)，方括号([])，或(|)，匹配次数符(*,+,?,{n},{m,n})，非(^)，空白符（\s）和其它常用字符等。         点符号，.号可以匹配所有字符，包括空格号，例如d.y，就可以匹配day,d@y,d!y,d y
Java中的正则表达式详解
最新发布
微赚淘客系统开发者博客
06-28 719
正则表达式（Regular Expression，简称regex）是一种用于匹配字符串模式的工具。它由一系列字符组成，这些字符定义了一个搜索模式。正则表达式的强大之处在于其灵活性和简洁性，能够用简短的语法描述复杂的字符串匹配规则。
浅谈java正则表达式(新手必看，易理解，通俗易懂)
小询的博客
08-03 2719
今天看了点书，小结一下，首先正则表达式（RegularExpressions）的用途主要有以下几个： 1.字符串匹配（字符匹配） 2.字符串查找 3.字符串替换 举几个小例子吧。 有时我们要检查我们自己填写的IP地址格式是否正确，这里我们就要用到正则表达式来设置这个格式。 有一个网页包含大量的数据，假如我们要将里面的所有email地址或者所有的手机号呀，链接呀等等。这些都要和设置的格式
Java正则表达式实例详解及应用
Java正则表达式实例讲解文档是一份详尽的教程，旨在帮助读者理解和应用Java中的正则表达式。正则表达式是一种强大的文本处理工具，在编程中广泛用于字符串匹配、搜索和替换等操作。本文档首先介绍了正则表达式的概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值