tag字符串-刷题预备知识-2. Java 正则匹配 + lt.468. 验证IP地址

文章目录

  • 正则表达式一般用于字符串匹配, 字符串查找和字符串替换. 别小看它的作用, 在工作学习中灵活运用正则表达式处理字符串能够大幅度提高效率, 编程的快乐来得就是这么简单.
  • 一下子给出一堆匹配的规则可能会让人恐惧, 下面将由浅入深讲解正则表达式的使用. 附带实战案例.

1. 从简单例子认识正则表达式匹配

public class Demo1 {
    public static void main(String[] args) {
        //字符串abc匹配正则表达式"...", 其中"."表示一个字符
        //"..."表示三个字符
        System.out.println("abc".matches("..."));

        System.out.println("abcd".matches("..."));
    }
}
//输出结果
true
false
  • Java的String类中有个matches(String regex)方法, 返回值为布尔类型, 用于告诉这个字符串是否匹配给定的正则表达式.
  • 在本例中我们给出的正则表达式为**…**, 其中每个.表示一个字符, 整个正则表达式的意思是三个字符, 显然当匹配abc的时候结果为true, 匹配abcd时结果为false.

2. Java中对正则表达式的支持

  • 在java.util.regex包下有两个用于正则表达式的类, 一个是Matcher类, 另一个Pattern. Java官方文档中给出对这两个类的典型用法, 代码如下:
public class Demo2 {
    public static void main(String[] args) {
        //[a-z]表示a~z之间的任何一个字符, {3}表示3个字符, 意思是匹配一个长度为3, 并且每个字符属于a~z的字符串
        Pattern pattern = Pattern.compile("[a-z]{3}");
        Matcher m = pattern.matcher("abc");
        System.out.println(m.matches());
    }
}
//输出结果
true

image.png

正则匹配在Java中的书写方法

image.png

package cn.cyy.cl.common.bean;

import org.junit.Test;

import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExpTest {

    @Test
    public void testRegExp(){
        //String.util.regex包下, Patern类, Matcher类
        //Pattern 没有公有的构造方法, 所以对于匹配规则字符串使用compile方法转换为pattern
        Pattern pattern = Pattern.compile("\\d+");

        String exp = "this is 2022 year, and its the *&8^^021centry";

        //Matcher 也没有公有的构造犯法, 所以匹配
        Matcher matcher = pattern.matcher(exp);
        boolean isMatach_0 = matcher.matches();
        //上面这句. 等同于
        boolean isMatch = Pattern.matches("\\d+", exp);


        System.out.println(isMatach_0);
        System.out.println(isMatch);
    }

}
false;
false;

Java的正则表达式语法

image.png

a. 初步认识 .+*?

.匹配单个字符匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符，请使用诸如"[\s\S]"之类的模式。
*零次或多次匹配前面的字符或子表达式。例如，zo* 匹配"z"和"zoo"。* 等效于 {0,}。
+一次或多次匹配前面的字符或子表达式例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+ 等效于 {1,}。
?零次或一次匹配前面的字符或子表达式。例如，"do(es)?“匹配"do"或"does"中的"do”。? 等效于 {0,1}。
public class Demo3 {
    /**
     * 为了省略每次写打印语句, 这里把输出语句封装起来
     * @param o
     */
    private static void p(Object o){
        System.out.println(o);
    }

    /**
     * .	Any character (may or may not match line terminators), 任意字符
     * 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{n,}	X, at least n times     x出现至少n次
     * X{n,m}	X, at least n but not more than m times 出现n~m次
     * @param args
     */
    public static void main(String[] args) {
        p("a".matches("."));
        p("aa".matches("aa"));
        p("aaaa".matches("a*"));
        p("aaaa".matches("a+"));
        p("".matches("a*"));
        p("a".matches("a?"));

        // \d	A digit: [0-9], 表示数字, 但是在java中对"\"这个符号需要使用\进行转义, 所以出现\\d
        p("2345".matches("\\d{2,5}"));
        // \\.用于匹配"."
        p("192.168.0.123".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));
        // [0-2]指必须是0~2中的一个数字
        p("192".matches("[0-2][0-9][0-9]"));
    }
}
//输出结果
//全为true

b. 范围 []

  • []用于描述一个字符的范围, 下面是一些例子
public class Demo4 {
    private static void p(Object o){
        System.out.println(o);
    }

    public static void main(String[] args) {
        //[abc]指abc中的其中一个字母
        p("a".matches("[abc]"));
        //[^abc]指除了abc之外的字符
        p("1".matches("[^abc]"));
        //a~z或A~Z的字符, 以下三个均是或的写法
        p("A".matches("[a-zA-Z]"));
        p("A".matches("[a-z|A-Z]"));
        p("A".matches("[a-z[A-Z]]"));
        //[A-Z&&[REQ]]指A~Z中并且属于REQ其中之一的字符
        p("R".matches("[A-Z&&[REQ]]"));
    }
}
//输出结果
全部为true

C. 认识\s \w \d \

\\dA digit: [0-9] 数字数字字符匹配。等效于 [0-9]。
\DA non-digit: [^0-9] 非数字非数字字符匹配。等效于 [^0-9]。
\\sA whitespace character: [ \t\n\x0B\f\r] 空格匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
\SA non-whitespace character: [^\s] 非空格匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
\\wA word character: [a-zA-Z_0-9] 数字字母和下划线匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。
\WA non-word character: [^\w] 非数字字母和下划线与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。
public class Demo5 {
    private static void p(Object o){
        System.out.println(o);
    }

    public static void main(String[] args) {
        /**
         * \d	A digit: [0-9]          数字
         * \D	A non-digit: [^0-9]     非数字
         * \s	A whitespace character: [ \t\n\x0B\f\r] 空格
         * \S	A non-whitespace character: [^\s]       非空格
         * \w	A word character: [a-zA-Z_0-9]          数字字母和下划线
         * \W	A non-word character: [^\w]             非数字字母和下划线
         */
        // \\s{4}表示4个空白符
        p(" \n\r\t".matches("\\s{4}"));
        // \\S表示非空白符
        p("a".matches("\\S"));
        // \\w{3}表示数字字母和下划线
        p("a_8".matches("\\w{3}"));
        p("abc888&^%".matches("[a-z]{1,3}\\d+[%^&*]+"));
        // 匹配 \
        p("\\".matches("\\\\"));
    }
}
//输出结果
全部为true

对Java中转移字符的说明:

image.png

d. 边界处理

  • ^在中括号内表示取反的意思[^],
  • 但是 如果不在中括号里则表示字符串的开头.
^The beginning of a line 一个字符串的开始匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与"\n"或"\r"之后的位置匹配。
$The end of a line 字符串的结束
匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与"\n"或"\r"之前的位置匹配。
\\bA word boundary 一个单词的边界, 可以是空格, 换行符等匹配一个字边界，即字与空格间的位置。例如，“er\b"匹配"never"中的"er”，但不匹配"verb"中的"er"。
public class Demo6 {
    private static void p(Object o){
        System.out.println(o);
    }

    public static void main(String[] args) {
        /**
         * ^	The beginning of a line 一个字符串的开始
         * $	The end of a line       字符串的结束
         * \b	A word boundary         一个单词的边界, 可以是空格, 换行符等
         */
        p("hello sir".matches("^h.*"));
        p("hello sir".matches(".*r$"));
        p("hello sir".matches("^h[a-z]{1,3}o\\b.*"));
        p("hellosir".matches("^h[a-z]{1,3}o\\b.*"));
    }
}

image.png

3. Matcher类的matches(),find()和lookingAt()

  • matches()方法会将整个字符串与模板进行匹配.
  • find()则是从当前位置开始进行匹配, 如果传入字符串后首先进行find(), 那么当前位置就是字符串的开头, 对当前位置的具体分析可以看下面的代码示例
  • lookingAt()方法会从字符串的开头进行匹配.
public class Demo8 {
    private static void p(Object o){
        System.out.println(o);
    }

    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d{3,5}");
        String s = "123-34345-234-00";
        Matcher m = pattern.matcher(s);

        //先演示matches(), 与整个字符串匹配.
        p(m.matches());
        //结果为false, 显然要匹配3~5个数字会在-处匹配失败

        //然后演示find(), 先使用reset()方法把当前位置设置为字符串的开头
        m.reset();
        p(m.find());//true 匹配123成功
        p(m.find());//true 匹配34345成功
        p(m.find());//true 匹配234成功
        p(m.find());//false 匹配00失败

        //下面我们演示不在matches()使用reset(), 看看当前位置的变化
        m.reset();//先重置
        p(m.matches());//false 匹配整个字符串失败, 当前位置来到-
        p(m.find());// true 匹配34345成功
        p(m.find());// true 匹配234成功
        p(m.find());// false 匹配00始边
        p(m.find());// false 没有东西匹配, 失败

        //演示lookingAt(), 从头开始找
        p(m.lookingAt());//true 找到123, 成功
    }
}

参考文章:
1.
2
3.

正则表达式在Java中的使用

](https://juejin.cn/post/6844903825426366471#heading-7)

4. Matcher类中的start()和end()

  • 如果一次匹配成功的话start()用于返回匹配开始的位置, end()用于返回匹配结束字符的后面一个位置
public class Demo9 {
    private static void p(Object o){
        System.out.println(o);
    }

    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("\\d{3,5}");
        String s = "123-34345-234-00";
        Matcher m = pattern.matcher(s);

        p(m.find());//true 匹配123成功
        p("start: " + m.start() + " - end:" + m.end());
        p(m.find());//true 匹配34345成功
        p("start: " + m.start() + " - end:" + m.end());
        p(m.find());//true 匹配234成功
        p("start: " + m.start() + " - end:" + m.end());
        p(m.find());//false 匹配00失败
        try {
            p("start: " + m.start() + " - end:" + m.end());
        }catch (Exception e){
            System.out.println("报错了...");
        }
        p(m.lookingAt());
        p("start: " + m.start() + " - end:" + m.end());
    }
}
//输出结果
true
start: 0 - end:3
true
start: 4 - end:9
true
start: 10 - end:13
false
报错了...
true
start: 0 - end:3

lt.468. 验证IP地址

[案例需求]
在这里插入图片描述

[思路分析]

  • 根据IP的四个块(A.B.C.D), 我们逐一进行正则匹配
  • 要求每个块范围是(0, 255), 切不允许有前置零出现, 共五种情况:
  1. 块只包含一块数字,
    • 范围是0 到9;
  2. 块包含两位数字,
    • 第一位的范围是1到9, 第二位是0到9;
  3. 块包含三位数字,
    • 第一位为1, 第二位, 第三位可以是0到9;
    • 第一位为2, 第二为0到4, 第三位可以是0到9;
    • 第一位为2, 第二位为5, 第三位可以是0到5;

所以. 每个块的pattern = “([0-9] | [1-9][0-9] | 1[0-9][0-9] | 2[0-4][0-9] | 25[0-5])”

  • 注意, 正则中的小括号表示的是这个正则是一个整体;

  • 整个IP地址的正则匹配串为:

  • IPV4 = “^(” + pattern + “\.) {3}” + pattern + “$”;

  • IPV6的匹配如下:
  1. 每个块: pattern = “([0-9a-fA-F]{1,4})”;
  2. IPV6 = “^(” + pattern + “\😃{7}” + pattern + “$”

[代码实现]

import java.util.regex.Pattern;
class Solution {
  String chunkIPv4 = "([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])";
  Pattern pattenIPv4 =
          Pattern.compile("^(" + chunkIPv4 + "\\.){3}" + chunkIPv4 + "$");

  String chunkIPv6 = "([0-9a-fA-F]{1,4})";
  Pattern pattenIPv6 =
          Pattern.compile("^(" + chunkIPv6 + "\\:){7}" + chunkIPv6 + "$");

  public String validIPAddress(String IP) {
    if (IP.contains(".")) {
      return (pattenIPv4.matcher(IP).matches()) ? "IPv4" : "Neither";
    }
    else if (IP.contains(":")) {
      return (pattenIPv6.matcher(IP).matches()) ? "IPv6" : "Neither";
    }
    return "Neither";
  }
}
posted @   青松城  阅读(53)  评论(0)  编辑  收藏  举报
相关博文：
· 完整代码实例-Java实现简单的逆波兰计算器
· 五, Java实现栈以及栈的一些应用 0.5
· 正则表达式
· Java正则表达式的语法与示例
· 书城6 - 正则表达式
阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· .NET10 - 预览版1新功能体验（一）
点击右上角即可分享
微信分享提示