精华内容
下载资源
问答
  • 这篇文章主要介绍了Java正则表达式之split()方法,结合实例形式...分享给大家供大家参考,具体如下:1、方法介绍(1)public String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串(2)public String[]...

    这篇文章主要介绍了Java正则表达式之split()方法,结合实例形式较为详细的分析了split方法的功能、使用方法及相关注意事项,需要的朋友可以参考下

    本文实例讲述了Java正则表达式之split()方法。分享给大家供大家参考,具体如下:

    1、方法介绍

    (1)public String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串

    (2)public String[] split(String regex,int limit) 根据匹配给定的正则表达式来拆分此字符串

    2、方法实例

    /**

    * @Title:Split.java

    * @Package:com.you.data

    * @Description:Java split()方法

    * @Author: 游海东

    * @date: 2014年3月17日 下午7:13:37

    * @Version V1.2.3

    */

    package com.you.data;

    /**

    * @类名:Split

    * @描述:1、split(String regex)

    * 根据给定正则表达式的匹配拆分此字符串

    *

    * 2、split(String regex, int limit)

    * 根据匹配给定的正则表达式来拆分此字符串。

    * @Author:游海东

    * @date: 2014年3月17日 下午7:13:37

    */

    public class Split

    {

    /**

    * @Title : main

    * @Type : Split

    * @date : 2014年3月17日 下午7:13:37

    * @Description : 1、 public String[] split(String regex)

    * 该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。

    * 因此,所得数组中不包括结尾空字符串。

    *

    * 2、public String[] split(String regex,int limit)

    * 此方法返回的数组包含此字符串的子字符串,每个子字符串都由另一个

    * 匹配给定表达式的子字符串终止,或者由此字符串末尾终止。数组中的

    * 子字符串按它们在此字符串中出现的顺序排列。如果表达式不匹配输入

    * 的任何部分,那么所得数组只具有一个元素,即此字符串。

    * @param args

    */

    public static void main(String[] args)

    {

    /**

    * 声明一个字符串str1

    */

    String str1 = "ui78,8huh,jf87,uie8,ujkdf90,hu67ghj,894ghk";

    /**

    * 声明字符串数组str2

    */

    String[] str2 = str1.split(",");

    /**

    * 遍历字符串数组

    */

    for(int i = 0;i

    {

    System.out.println("第" + i + "个:" + str2[i]);

    }

    System.out.println("\n" + "---------------------------------" + "\n");

    /**

    * 声明字符串数组str3

    */

    String[] str3 = str1.split(",",1);

    /**

    * 遍历字符串数组str3

    */

    for(int i = 0;i

    {

    System.out.println("第" + i + "个:" + str3[i]);

    }

    System.out.println("\n" + "---------------------------------" + "\n");

    /**

    * 声明字符串数组str4

    */

    String[] str4 = str1.split(",",2);

    /**

    * 遍历字符串数组str4

    */

    for(int i = 0;i

    {

    System.out.println("第" + i + "个:" + str4[i]);

    }

    System.out.println("\n" + "---------------------------------" + "\n");

    /**

    * 声明字符串数组str5

    */

    String[] str5 = str1.split(",",3);

    /**

    * 遍历字符串数组str5

    */

    for(int i = 0;i

    {

    System.out.println("第" + i + "个:" + str5[i]);

    }

    System.out.println("\n" + "---------------------------------" + "\n");

    /**

    * 声明字符串数组str6

    */

    String[] str6 = str1.split(",",4);

    /**

    * 遍历字符串数组str6

    */

    for(int i = 0;i

    {

    System.out.println("第" + i + "个:" + str6[i]);

    }

    System.out.println("\n" + "---------------------------------" + "\n");

    /**

    * 声明字符串数组str7

    */

    String[] str7 = str1.split(",",5);

    /**

    * 遍历字符串数组str7

    */

    for(int i = 0;i

    {

    System.out.println("第" + i + "个:" + str7[i]);

    }

    System.out.println("\n" + "---------------------------------" + "\n");

    /**

    * 声明字符串数组str8

    */

    String[] str8 = str1.split(",",6);

    /**

    * 遍历字符串数组str8

    */

    for(int i = 0;i

    {

    System.out.println("第" + i + "个:" + str8[i]);

    }

    }

    }

    3、实例结果

    第0个:ui78

    第1个:8huh

    第2个:jf87

    第3个:uie8

    第4个:ujkdf90

    第5个:hu67ghj

    第6个:894ghk

    ---------------------------------

    第0个:ui78,8huh,jf87,uie8,ujkdf90,hu67ghj,894ghk

    ---------------------------------

    第0个:ui78

    第1个:8huh,jf87,uie8,ujkdf90,hu67ghj,894ghk

    ---------------------------------

    第0个:ui78

    第1个:8huh

    第2个:jf87,uie8,ujkdf90,hu67ghj,894ghk

    ---------------------------------

    第0个:ui78

    第1个:8huh

    第2个:jf87

    第3个:uie8,ujkdf90,hu67ghj,894ghk

    ---------------------------------

    第0个:ui78

    第1个:8huh

    第2个:jf87

    第3个:uie8

    第4个:ujkdf90,hu67ghj,894ghk

    ---------------------------------

    第0个:ui78

    第1个:8huh

    第2个:jf87

    第3个:uie8

    第4个:ujkdf90

    第5个:hu67ghj,894ghk

    PS:这里再为大家提供2款非常方便的正则表达式工具供大家参考使用:

    希望本文所述对大家java程序设计有所帮助。

    展开全文
  • public String[] split(Stringregex)根据给定的正则表达式的匹配来拆分此字符串。该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此,结果数组中不包括结尾空字符串。例如,字符串 ...

    public String[] split(String regex)

    根据给定的正则表达式的匹配来拆分此字符串。

    该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此,结果数组中不包括结尾空字符串。

    例如,字符串 "boo:and:foo" 产生带有下面这些表达式的结果:Regex

    结果

    :

    { "boo", "and", "foo" }

    o

    { "b", "", ":and:f" }

    参数: regex - 定界正则表达式

    返回: 字符串数组,根据给定正则表达式的匹配来拆分此字符串,从而生成此数组。

    public String[] split(String regex, int limit)

    根据匹配给定的正则表达式来拆分此字符串。

    此方法返回的数组包含此字符串的每个子字符串,这些子字符串由另一个匹配给定的表达式的子字符串终止或由字符串结束来终止。数组中的子字符串按它们在此字符串中的顺序排列。如果表达式不匹配输入的任何部分,则结果数组只具有一个元素,即此字符串。

    limit 参数控制模式应用的次数,因此影响结果数组的长度。如果该限制 n 大于 0,则模式将被最多应用 n - 1 次,数组的长度将不会大于 n,而且数组的最后项将包含超出最后匹配的定界符的所有输入。如果 n 为非正,则模式将被应用尽可能多的次数,而且数组可以是任意长度。如果 n 为零,则模式将被应用尽可能多的次数,数组可有任何长度,并且结尾空字符串将被丢弃。

    例如,字符串 "boo:and:foo" 使用这些参数可生成下列结果:Regex

    Limit

    结果

    :

    2

    { "boo", "and:foo" }

    :

    5

    { "boo", "and", "foo" }

    :

    -2

    { "boo", "and", "foo" }

    o

    5

    { "b", "", ":and:f", "", "" }

    o

    -2

    { "b", "", ":and:f", "", "" }

    o

    0

    { "b", "", ":and:f" }

    这种形式的方法调用 str.split(regex, n) 产生与以下表达式完全相同的结果:

    参数: regex - 定界正则表达式 ;limit - 结果阈值,如上所述

    返回: 字符串数组,根据给定正则表达式的匹配来拆分此字符串,从而生成此数组

    public String replaceAll(String regex, String replacement)

    使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的每个子字符串。

    此方法调用的 str.replaceAll(regex, repl) 形式产生与以下表达式完全相同的结果:

    参数: regex - 用来匹配此字符串的正则表达式

    返回: 得到的 String

    public String replaceFirst(String regex, String replacement)

    使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的第一个子字符串。

    此方法调用的 str.replaceFirst(regex, repl) 形式产生与以下表达式完全相同的结果:

    参数:regex - 用来匹配此字符串的正则表达式

    返回: 得到的 String

    这四个方法中都有一个参数为正则表达式(Regular Expression),而不是普通的字符串。在正则表达式中具有特殊含义的字符

    特殊字符

    描述

    .

    表示任意一个字符

    [abc]

    表示a、b或c中的任意一个字符

    [^abc]

    除a、b和c以外的任意一个字符

    [a-zA-z]

    介于a到z,或A到Z中的任意一个字符

    \s

    空白符(空格、tab、换行、换页、回车)

    \S

    非空白符

    \d

    任意一个数字[0-9]

    \D

    任意一个非数字[^0-9]

    \w

    词字符[a-zA-Z_0-9]

    \W

    非词字符

    表示字符出现次数的符号

    表示次数的符号

    描述

    *

    0 次或者多次

    +

    1 次或者多次

    ?

    0 次或者 1 次

    {n}

    恰好 n 次

    {n, m}

    至少 n 次,不多于 m 次

    publicclassRegDemo2 {/***@paramargs*/publicstaticvoidmain(String[] args) {//例如,字符串 "boo:and:foo" 产生带有下面这些表达式的结果: Regex 结果//: { "boo", "and", "foo" }//o { "b", "", ":and:f" }String tempStr="boo:and:foo";

    String[] a=tempStr.split(":");

    pringStringArray(a);

    String[] b=tempStr.split("o");

    pringStringArray(b);

    System.out.println("--------------------------");//Regex Limit 结果//: 2 { "boo", "and:foo" }//: 5 { "boo", "and", "foo" }//: -2 { "boo", "and", "foo" }//o 5 { "b", "", ":and:f", "", "" }//o -2 { "b", "", ":and:f", "", "" }//o 0 { "b", "", ":and:f" }pringStringArray(tempStr.split(":",2));

    pringStringArray(tempStr.split(":",5));

    pringStringArray(tempStr.split(":",-2));

    pringStringArray(tempStr.split("o",5));

    pringStringArray(tempStr.split("o",-2));

    pringStringArray(tempStr.split("o",0));//字符串 "boo:and:foo"中的所有“:”都被替换为“XX”,输出:booXXandXXfooSystem.out.println(tempStr.replaceAll(":","XX"));//字符串 "boo:and:foo"中的第一个“:”都被替换为“XX”,输出: booXXand:fooSystem.out.println(tempStr.replaceFirst(":","XX"));

    }publicstaticvoidpringStringArray(String[] s) {intindex=s.length;for(inti=0; i

    System.err.println(i+":"+s[i]);

    }

    }

    }

    下面的程序演示了正则表达式的用法:

    /*** discription:

    *

    *@authorCoderDream

    **/publicclassRegularExTester {/***@paramargs*/publicstaticvoidmain(String[] args) {//把字符串中的“aaa”全部替換為“z”,打印:zbzczSystem.out.println("aaabaaacaaa".replaceAll("a{3}","z"));//把字符串中的“aaa”、“aa”或者“a”全部替換為“*”,打印:*b*c*System.out.println("aaabaaca".replaceAll("a{1,3}","\\*"));//把字符串中的數字全部替換為“z”,打印:zzzazzbzzccSystem.out.println("123a44b35cc".replaceAll("\\d","z"));//把字符串中的非數字全部替換為“0”,打印:1234000435000System.out.println("1234abc435def".replaceAll("\\D","0"));//把字符串中的“.”全部替換為“\”,打印:com\abc\dollapp\DollSystem.out.println("com.abc.dollapp.Doll".replaceAll("\\.","\\\\"));//把字符串中的“a.b”全部替換為“_”,//“a.b”表示長度為3的字符串,以“a”開頭,以“b”結尾//打印:-hello-allSystem.out.println("azbhelloahball".replaceAll("a.b","-"));//把字符串中的所有詞字符替換為“#”//正則表達式“[a-zA-z_0-9]”等價于“\w”//打印:#.#.#.#.#.#System.out.println("a.b.c.1.2.3.4".replaceAll("[a-zA-z_0-9]","#"));

    System.out.println("a.b.c.1.2.3.4".replaceAll("\\w","#"));

    }

    }

    值得注意的是,由于“.”、“?”和“*”等在正则表达式中具有特殊的含义,如果要表示字面上的这些字符,必须以“\\”开头。例如为了把字符串“com.abc.dollapp.Doll”中的“.”替换为“\”,应该调用replaceAll("\\.",\\\\)方法。

    Java中的正则表达式类

    public interface MatchResult

    匹配操作的结果。

    此接口包含用于确定与正则表达式匹配结果的查询方法。通过 MatchResult 可以查看匹配边界、组和组边界,但是不能修改

    public final class Matcher

    extends Object

    通过解释 Pattern 对 字符序列 执行匹配操作的引擎。

    通过调用模式的 matcher 方法从模式创建匹配器。创建匹配器后,可以使用它执行三种不同的匹配操作:matches 方法尝试将整个输入序列与该模式匹配。

    lookingAt 尝试将输入序列从头开始与该模式匹配。

    find 方法扫描输入序列以查找与该模式匹配的下一个子序列。

    每个方法都返回一个表示成功或失败的布尔值。通过查询匹配器的状态可以获取关于成功匹配的更多信息。

    public final class Pattern

    正则表达式的编译表示形式。

    指定为字符串的正则表达式必须首先被编译为此类的实例。然后,可将得到的模式用于创建 Matcher 对象,依照正则表达式,该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中,所以多个匹配器可以共享同一模式。

    因此,典型的调用顺序是Pattern p = Pattern.compile("a*b");

    Matcher m = p.matcher("aaaaab");

    boolean b = m.matches();

    在仅使用一次正则表达式时,可以方便地通过此类定义 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句boolean b = Pattern.matches("a*b", "aaaaab");

    等效于上面的三个语句,尽管对于重复的匹配而言它效率不高,因为它不允许重用已编译的模式。

    此类的实例是不可变的,可供多个并发线程安全使用。Matcher 类的实例用于此目的则不安全。

    测试代码:

    /*** discription:Java中正则表达式类的使用

    *

    *@authorCoderDream

    **/publicclassRegDemo {/***@paramargs*/publicstaticvoidmain(String[] args) {//檢查字符串中是否含有“aaa”,有返回:true,無返回:falseSystem.out.println(isHaveBeenSetting("a{3}","aaabaaacaaa"));

    System.out.println(isHaveBeenSetting("a{3}","aab"));//把字符串“abbaaacbaaaab”中的“aaa”全部替換為“z”,打印:abbzbzaSystem.out.println(replaceStr("a{3}","abbaaabaaaa","z"));

    }/***

    *@paramregEx

    *            设定的正则表达式

    *@paramtempStr

    *            系统参数中的设定的字符串

    *@return是否系统参数中的设定的字符串含有设定的正则表达式 如果有的则返回true*/publicstaticbooleanisHaveBeenSetting(String regEx, String tempStr) {booleanresult=false;try{

    Pattern p=Pattern.compile(regEx);

    Matcher m=p.matcher(tempStr);

    result=m.find();

    }catch(Exception e) {

    e.printStackTrace();

    }returnresult;

    }/*** 将字符串含有的regEx表达式替换为replaceRegEx

    *

    *@paramregEx

    *            需要被替换的正则表达式

    *@paramtempStr

    *            替换的字符串

    *@paramreplaceRegEx

    *            替换的正则表达式

    *@return替換好后的字符串*/publicstaticString replaceStr(String regEx, String tempStr,

    String replaceRegEx) {

    Pattern p=Pattern.compile(regEx);

    Matcher m=p.matcher(tempStr);

    tempStr=m.replaceAll(replaceRegEx);returntempStr;

    }

    }

    posted on 2008-02-28 11:40 CoderDream 阅读(2156) 评论(0)  编辑  收藏 所属分类: 学习笔记

    展开全文
  • /将字符串123,456,789,012根据","拆分,并输出拆分后的每一项 提示:使用String类的split()方法,按照逗号来拆分/ public class Test20191220T2 { public static void main(String[] args) { // TODO Auto-generated...

    package tan2019;

    /*将字符串123,456,789,012根据",“拆分,并输出拆分后的每一项
    提示:使用String类的split()方法,按照逗号来拆分
    将字符串"123abc456def789ghi"中的英文部分替换为”#char#"
    提示:使用正则表达式匹配英文符号[a-z],然后使用String类的replaceAll()方法来替换值
    */

    public class Test20191220T2 {
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    String s = “123,456,789,012”;
    String s1 = “123abc456def789ghi”;

    	String[] a =s.split(",");
    	for(String t:a){ //foreach
    		System.out.println(t); //遍历打印出结果
    	}
    	
    	String t1 = s1.replaceAll("[a-z]", "#char#");
    	System.out.println(t1);
    }
    

    }

    在这里插入图片描述

    展开全文
  • 01:正则表达式 在 任何一门语言都包括 ,至于正则表达式的学习 ,可以专门针对。 02:在String中使用的正则表达式。 a:String中所使用到的 正则表达式的方法包括:replaceFirst...根据 匹配 给定的正则表达式 来 拆分

    01:正则表达式 在 任何一门语言都包括 ,至于正则表达式的学习 ,可以专门针对。

    02:在String中使用的正则表达式。
    a:String中所使用到的 正则表达式的方法包括:replaceFirst() replaceAll() split()这些方法。
    b:除此之外的 方法 不可以使用正则 表达式。

    03:解释JavaSE中的 String类的split()方法:
    在这里插入图片描述
    public String[] split(String regex , int limit)
    根据 匹配 给定的正则表达式 来 拆分 此字符串。
    此方法返回的 数组 包含此字符串的每个子字符串,
    这些子字符串 由 另一个 匹配 给定的表达式 的 子字符串 终止 或 由 字符串结束 来终止。
    //开始:是从当前字符串的 开头开始的
    //结束: 由 下一个匹配的字符串结束 ,或者一直到 传递字符串的 结束位置 。
    注意: 可能会引起 空字符串的情况,如下解释。

    数组中的子字符串按它们在此字符串中的顺序排列。如果表达式不匹配输入的任何部分,则结果数组只具有一个元素,即当前字符串。

    limit 参数 控制 模式 应用的 次数,因此影响结果数组的长度。如果该限制 n 大于 0,则模式将被最多应用 n - 1 次,数组的长度将不会大于 n, 而且 数组的最后项 将包含 超出 最后匹配的定界符的所有输入。
    如果 n 为非正,则模式将被应用尽可能多的次数,而且数组可以是任意长度。并且结尾空字符串将被丢弃。
    如果 n 为零, 则模式将被应用尽可能多的次数,数组可有任何长度,并且结尾空字符串将被丢弃。

    例如,字符串 “boo:and:foo” 使用这些参数可生成下列结果:

    Regex Limit 结果
    2 { “boo”, “and:foo” }
    5 { “boo”, “and”, “foo” }
    -2 { “boo”, “and”, “foo” }
    o 5 { “b”, “”, “:and:f”, “”, “” } //结尾的 空字符串并没有被丢弃
    o -2 { “b”, “”, “:and:f”, “”, “” } //结尾的 空字符串并没有被丢弃
    o 0 { “b”, “”, “:and:f” } //结尾的空字符串【2个】 被丢弃!!!

    这种形式的方法调用 str.split(regex, n) 产生与以下表达式完全相同的结果:
    Pattern.compile(regex).split(str, n)

    replaceAll 和 replaceFirst 方法 使用的是正则表达式 ,但是正则表达式也属于字符串 ,这里也可以使用 具体的字符串的形式【此时具体的字符串 同样代表 正则表达式】 ,java教材上面写的是具体的字符串的形式。
    ====》生成新的对象, 但是并没有改变原来的字符串
    在这里插入图片描述
    第一个方法是替换,但是替换的是char,不是String。依然替换的所有的字符。

    第二个方法是替换的CharSequence(包括String, StringBuffer, StringBuilder),但是替换的是全部。

    第三个replaceAll是替换全部的 字符串形式的正则表达式,

    第四个是 替换字符串中第一个匹配的项,但是人家名字写得明明白白的replaceFirst,而且替换的也是正则表达式。

    //但是牢记: 第一个参数可以是 字符【char】 字符串【String】 字符序列【charSequence】或者是 正则表达式的字符串形式
    第二个参数 必须是 字符串的形式。

    解释:
    第一个方法:执行思路:我们用后面的 字符 替换 字符串 中出现的 所有的 第一个形式参数的字符。
    //使用的是 字符串中的包含

    第二个方法: 执行思路 同上

    第三个方法: 第一个形式参数 必须是 一个正则表达式的字符串表示形式,然后执行字符串对象的 包含功能, 将当前字符串中 包含 正则表达式的 匹配项 全部替换掉。

    第四个方法: 执行思路同上 , 但是 仅仅 替换 包含在当前字符串中的正则表达式的 第一个匹配项。

    //注意:此时 我们一定要注意,在使用replaceAll的时候 传递的如果是要给字符串,那么此时的字符串 被解释成为一个 正则表达式 而存在。 在一般情况下 确定的字符串 如果被当做是一个 正则表达式 而存在的话, 那么就表示 必须匹配当前的 字符串的一种形式 而没有了 正则表达式的 多种形式的可能。
    因此我们总结:确定的字符串 也是正则表达式的一种特殊形式, 只不过与大多数的正则表达式而言 , 没有那么多变化,就这一种可能。
    public static void main(String args[]) {
    String value = “cat” ;
    System.out.println(value.matches(".at")); //true 可以匹配 cat fat kat mat等等。
    }

    public static void main(String args[]) {
    String value = “cat” ;
    System.out.println(value.matches(“cat”));//true 只可以匹配cat
    }

    //具体的正则表达式 可以参考 之前的网络下载资料 和 总结的笔记 以及 教材《必知必会》

    matches()匹配 正则表达式:

    在这里插入图片描述在这里插入图片描述
    语法 :public boolean matches(String regex)
    参数:regex – 匹配字符串的正则表达式。
    返回值 : 在字符串匹配给定的正则表达式时,返回 true。指的是 传递的所有的字符串 跟模式完全 吻合。

    实例
    public class Test {
    public static void main(String args[]) {
    String Str = new String(“www.w3cschool.cn”);

    	System.out.print("返回值 :" );
    	System.out.println(Str.matches("(.*)youj(.*)"));//false
    	
    	System.out.print("返回值 :" );
    	System.out.println(Str.matches("(.*)google(.*)"));//false
    
    	System.out.print("返回值 :" );
    	System.out.println(Str.matches("www(.*)"));//true
    }
    

    }
    //备注:这里我们需要 确切的知道 java的正则正则表达式 的具体写法 , 必须知道 java的正则表达式的 标准写法 和 要求。

    在java中正则表达式 如果使用 字符串的形式来写 就必须在 正则表达式 前后 加上双引号, 跟js的写法不一样 , 不可以 在后面写 gim 来表示 全局 忽略大小写 多行。
    用字符串的形式去表示一个 正则表达式 比如:
    匹配 email的格式: String Email_regex= “\w+@\w+\.\w{2,3}”;
    只能输入零和非零开头的数字:String value = “^(0|[1-9][0-9]*)13Stringvalue=[09]+(.[09]1,3)?” 只能输入有1-3位小数的正实数:String value = “^[0-9]+(.[0-9]{1,3})?

    //注意:如果想实现 忽略大小写 多行 等等 还有捕获组 这些牛逼的 要求 就需要 java提供的 正则表达式的类【Pattern Matcher】。java正则表达式通过java.util.regex包下的Pattern和Matcher类实现

    Pattern类:
    在这里插入图片描述
    //上边的 CANON_EQ CASE_INSENSITIVE COMMENTS DOTALL LITERAL MULTILINE UNICODE_CASE UNIX_LINES 写在 Patter.compile(String regex , int flags)的flags中。

    Pattern 类包含多个标志(int 类型),这些标志可以控制Pattern 匹配模式的方式。

    compile()方法:在这里插入图片描述

    Pattern类用于创建 一个 正则表达式 实例对象 , 也可以说是创建一个匹配模式。

    可以通过两个静态方法创建:compile(String regex)和compile(String regex,int flags),
    其中regex是正则表达式,flags为可选模式(如:Pattern.CASE_INSENSITIVE 忽略大小写),==>来创建正则表达式的 实例对象 。除此之外没有别的方法 来创建正则表达式 对象 , 这可以通过静态方法来创建 正则表达式对象。

    matches()方法:
    在这里插入图片描述

    Pattern类也自带一个静态匹配方法matches(String regExp, CharSequence input),但 只能 进行全字符串匹配 并且 只能 返回 是否 匹配上的 boolean值
    //Pattern 类中 只有 这个一个 matches()方法 ,正则表达式 是第一个 形式参数 ,传递的字符串是第二个形式参数。 用于测试 字符串是否 跟模式完全匹配。

    实例:
    String test1 = “Java”;
    String test2 = “Java123456”;
    System.out.println(Pattern.matches(“Java”,test1));//返回true
    System.out.println(Pattern.matches(“Java”,test2));//返回false
    //全局匹配: 使用 第一个参数的 regExp 完全跟input【全部的input输入】 进行匹配 。

    split()方法:
    在这里插入图片描述
    public String[] split(CharSequence input, int limit)
    //但是一定要 明白 这个是 正则表达式 实例对象 所具备的 split()方法。

    根据 匹配 给定的正则表达式 来 拆分 此字符串。
    此方法返回的 数组 包含此字符串的每个子字符串,
    这些子字符串 由 另一个 匹配 给定的表达式 的 子字符串 终止 或 由 字符串结束 来终止。
    //开始:是从当前字符串的 开头开始的
    //结束: 由 下一个匹配的字符串结束 ,注意: 可能会引起 空字符串的情况,如下情况。

    数组中的子字符串按它们在此字符串中的顺序排列。如果表达式不匹配输入的任何部分,则结果数组只具有一个元素,即当前字符串。

    limit 参数 控制 模式 应用的 次数,因此影响结果数组的长度。如果该限制 n 大于 0,则模式将被最多应用 n - 1 次,数组的长度将不会大于 n, 而且 数组的最后项 将包含 超出 最后匹配的定界符的所有输入。
    如果 n 为非正,则模式将被应用尽可能多的次数,而且数组可以是任意长度。并且结尾空字符串将被丢弃。
    如果 n 为零, 则模式将被应用尽可能多的次数,数组可有任何长度,并且结尾空字符串将被丢弃。

    例如,字符串 “boo:and:foo” 使用这些参数可生成下列结果:

    Regex Limit 结果
    2 { “boo”, “and:foo” }
    5 { “boo”, “and”, “foo” }
    -2 { “boo”, “and”, “foo” }
    o 5 { “b”, “”, “:and:f”, “”, “” } //结尾的 空字符串并没有被丢弃
    o -2 { “b”, “”, “:and:f”, “”, “” } //结尾的 空字符串并没有被丢弃
    o 0 { “b”, “”, “:and:f” } //结尾的空字符串【2个】 被丢弃!!!

    参数:
    input - 要拆分的字符序列。
    limit - 结果阈值,如上文中所述。

    Matcher类的解释:
    结合Pattern 和 Matcher 类的 思路。
    ①将正则表达式封装成对象 : Pattern p = Pattern.compile(regex);
    ②让正则对象和要操作的字符串相关联 -----> 匹配器引擎 : Matcher m = p.matcher(str) ;
    于是 我们得到 了一个 匹配器引擎。

    matcher()方法:
    在这里插入图片描述
    //创建Matcher
    通过Pattern的实例对象 的 matcher() 方法创建一个Matcher。 //括号里的参数 是 要被匹配的字符串。

    String text =
    "This is the text to be searched " +
    “for occurrences of the http:// pattern.”;

    String patternString = “.http://.”;
    Pattern pattern = Pattern.compile(patternString);
    Matcher matcher = pattern.matcher(text);
    //到此为止 我们创建了一个 Pattern的 实例对象 pattern。 然后又通过 这个正则表达式的 pattern的实例变量 , 创造了一个 匹配引擎 匹配器。 ====>我们可以使用 匹配器 做很多事情。

    match()方法:
    在这里插入图片描述
    Matcher 的 实例对象 的 matches() 方法用于在文本中匹配正则表达式
    没有要被传递的参数,因为之前我们创建 正则表达式 对象的时候 传入了 正则表达式 字符串, 而在创建 别的Matcher对象的时候 有传入 了所需要比较的文本。

    如果 传递整体的文本 匹配 完整的正则表达式 ,matches() 方法返回true。否则返回false。

    matches() 方法不能用于查找正则表达式多次出现,只可以 在整体的情况下 使用一次。

    lookAt()方法:
    在这里插入图片描述
    lookingAt() 与matches() 方法类似,最大的不同是,lookingAt()方法 对文本的开头 匹配正则表达式;它不需要匹配整个区域

    而matches() 对 整个文本 匹配正则表达式。

    换句话说,如果正则表达式匹配文本开头而不匹配整个文本,lookingAt() 返回true,而matches() 返回false。 示例:

    String text =
    "This is the text to be searched " +
    “for occurrences of the http:// pattern.”;
    String patternString = “This is the”;
    Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(text);
    System.out.println("lookingAt = " + matcher.lookingAt());
    System.out.println("matches = " + matcher.matches());

    上面的例子分别对文本开头和整个文本匹配正则表达式 “this is the”. 匹配文本开头的方法(lookingAt()) 返回true。

    对整个文本匹配正则表达式的方法 (matches()) 返回false,因为 整个文本包含多余的字符,而 正则表达式要求文本精确匹配”this is the”,前后又不能有额外字符。

    find() start() end()

    //find() start() end()方法。
    在这里插入图片描述在这里插入图片描述在这里插入图片描述

    find() 方法用于 在 文本 中 查找出现 的匹配的正则表达式,文本是创建Matcher时,通过 Pattern.matcher(text) 方法传入的。
    如果在文本中多次匹配,find() 方法返回第一个,之后每次调用 find() 都会返回下一个。
    ---->以此来实现 全局匹配。 这个find()方法 的目的 不是完全匹配 ,而是查找 字符串中 与模式匹配的 一段字符串。 也就是说 传递的字符串 中 有很多 子字符串 跟 这个模式匹配,
    —>强调不是传递的字符串 跟这个 模式全部匹配。

    //Matcher的实例对象 调用find()方法 , 返回 boolean值。true表示 有下一个匹配值 false表示没有下一匹配值。

    //这个可是要注意了, 并不是 说 让传递的文本整体 跟 最外层的正则表达式整体 完全匹配的情况, 而是要 找到 传递的文本中 是否 包含正则表达式所匹配的字符串 , 且找到起始位置。

    start() 和 end() 返回每次匹配的字串在整个文本中的开始和结束位置。实际上, end() 返回的是字符串末尾的后一位,这样,可以在把 start() 和 end() 的返回值直接用在String.substring() 里。
    //我们就可以 找到 传递文本中 每一个 与 正则表达式 匹配的字符串喽,且可以通过 start() 和 end()的返回值 来拿到具体的 字符串了。

    String text =
    "This is the text which is to be searched " +
    “for occurrences of the word ‘is’.”;
    String patternString = “is”;
    Pattern pattern = Pattern.compile(patternString);
    Matcher matcher = pattern.matcher(text);
    int count = 0;
    while(matcher.find()) {
    count++;
    System.out.println("found: " + count + " : " + matcher.start() + " - " + matcher.end());
    }
    这个例子在文本中找到模式 “is” 4次,输出如下:

    found: 1 : 2 - 4
    found: 2 : 5 - 7
    found: 3 : 23 - 25
    found: 4 : 70 - 72

    group()方法:
    在这里插入图片描述
    使用group(int groupNo) 方法访问一个分组。一个正则表达式可以有多个分组。每个分组由一对括号标记。想要访问正则表达式中某分组匹配的文本,可以把分组编号传入 group(int groupNo)方法。

    group(0) 表示整个正则表达式,要获得一个有括号标记的分组,分组编号应该从1开始计算
    如果使用group(x) 指定 要输出的分组的时候 没有匹配项 则输出 null。

    //至此 我们可以拿到 传递字符串中 与 最外层的正则表达式匹配的 字符串 , 且可以拿到 这个匹配字符串的每个 分组, ====> 我们可以通过 稍微麻烦一些的办法 来实现 每个匹配字符串 中 每个分组 的替代 工作。

    String text =
    “John writes about this, and John Doe writes about that,” +
    " and John Wayne writes about everything."
    ;
    String patternString1 = "(John) (.+?) ";
    Pattern pattern = Pattern.compile(patternString1);
    Matcher matcher = pattern.matcher(text);
    while(matcher.find()) {
    System.out.println("found: " + matcher.group(1) +
    " " + matcher.group(2));
    }
    注意代码中引用分组的方式。代码输出如下

    found: John writes
    found: John Doe
    found: John Wayne

    ----->在使用 正则表达式 查找一个字符串中 是否 有匹配项的时候 我们 千万不可以在正则表达式中 加上 ^ $ 这样的位置字符。

    Matcher实例对象的 replaceAll() replaceFirst() 方法:

    //replaceAll() 方法 全部 替换 传递字符串中的 跟正则表达式 匹配得 子字符串;

    //replaceFirst() 只替换第一个匹配的。

    //在处理之前,Matcher 会先重置。所以这里的匹配表达式从文本开头开始计算。

    //这个匹配 不是完全匹配 ,而是 查找传递字符串 中是否 存在 跟正则表达式 匹配的项, 如果存在 那么就全部替换掉。 注意:依然是 不能够 替换分组 ,替换的是 与 最外层正则表达式 匹配的 字符串。
    ---->但是我们可以解释 start() end()方法来替换分组。

    示例如下
    String text = “aabfooaabfooabfoob” ;
    String patternString1 = “a*b”;
    Pattern pattern = Pattern.compile(patternString1);
    Matcher matcher = pattern.matcher(text);

    	String replaceAll = matcher.replaceAll("-");
    	System.out.println("replaceAll   = " + replaceAll);
    
    	String replaceFirst = matcher.replaceFirst("-");
    	System.out.println("replaceFirst = " + replaceFirst);
    

    输出如下:
    replaceAll = -foo-foo-foo-
    replaceFirst = -fooaabfooabfoob

    appendReplacement() appendTail() 方法:
    在这里插入图片描述
    appendReplacement() 和 appendTail() 方法用于替换输入文本中的字符串短语,同时把替换后的字符串附加到一个 StringBuffer 中。

    被Matcher的实例对象调用。

    当find() 方法找到一个匹配项时,可以调用 appendReplacement() 方法,这会导致输入字符串被增加到StringBuffer 中,而且匹配文本被替换。 从上一个匹配文本结尾处开始,直到本次匹配文本会被拷贝【两次匹配 之间的 字符串 会被拷贝 , 且匹配的内容会被 第二个形式参数替换掉】。

    ---->:并不是传递字符串的 完全匹配, 而是全局字符串中 查找 与模式匹配的子字符串 , 然后替换, 注意 此时 匹配模式 匹配的是最外层的模式 简而言之 是 正则表达式 全部都匹配。

    appendReplacement() 会记录拷贝StringBuffer 中的内容,可以持续调用find(),直到没有匹配项。

    直到最后一个匹配项目,输入文本中剩余一部分没有拷贝到 StringBuffer.

    这部分文本是从最后一个匹配项结尾,到文本末尾部分。通过调用 appendTail() 方法,可以把这部分内容拷贝到 StringBuffer 中.

    我们是使用 Matcher的实例对象 来调用的 , 结合 find()方法 和 while()循环,来匹配 替换 和 添加 ,执行所有的 传递文本。

    如果没有 找到任何 匹配项 则 stringBuffer实例对象大小是 0 ;

    String text =
    “John writes about this, and John Doe writes about that,” +
    " and John Wayne writes about everything."
    ;

    String patternString1 = "((John) (.+?)) ";
    Pattern pattern = Pattern.compile(patternString1);
    Matcher matcher = pattern.matcher(text);
    StringBuffer stringBuffer = new StringBuffer();

    while(matcher.find()){
    matcher.appendReplacement(stringBuffer, "Joe Blocks ");
    System.out.println(stringBuffer.toString());
    }
    matcher.appendTail(stringBuffer);
    System.out.println(stringBuffer.toString());

    注意我们在while循环中调用appendReplacement() 方法。在循环完毕后调用appendTail()。 代码输出如下:

    Joe Blocks
    Joe Blocks about this, and Joe Blocks
    Joe Blocks about this, and Joe Blocks writes about that, and Joe Blocks
    Joe Blocks about this, and Joe Blocks writes about that, and Joe Blocks
    writes about everything.
    在这里插入图片描述

    展开全文
  • String[] split(String regex) // 根据给定正则表达式的匹配拆分此字符串。 //例1 public static void main(String[] args) { String s="张三 李四 钢铁侠";//给定字符串用空格连接 String[] arr=s.split(" ")...
  • 切割:记得以前想把一个字符分成几块,调用的是String中的split函数。最初聊天室私聊的时候还以;...(只要看到regex就要反应过来是正则表达式)split(String regex)根据给定正则表达式的匹配拆分此字符串。下面来看具...
  • split() 方法根据匹配给定的正则表达式来拆分字符串public String[] split(String regex,int limit)limit 参数控制模式应用的次数,因此影响所得数组的长度。如果该限制 n 大于 0,则模式将被最多应用 n - 1 次,...
  • 分享给大家供大家参考,具体如下:1、方法介绍(1)public String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串(2)public String[] split(String regex,int limit) 根据匹配给定的正则表达式来拆分此...
  • java字符串拆分 空字符Java String split() method is used to split the string into a string ... Java String split()方法用于根据提供的正则表达式将字符串拆分为字符串数组。 Java字符串拆分 (Java Strin...
  • Java 正则表达式

    2014-10-16 15:18:26
    1示例1-区间匹配比如匹配[1,2] 正则表达式为:^[(\\[]\\d+,\\d+[)\\]]$ 注明:颜色便于拆分理解   2示例2-正整数匹配 ...正则表达式为:^[1-9][0-9]*...4 示例4- 根据正则表达式截取字符串 输入:{start : [{\"ver
  • 文章目录java.long.String 中的对正则的支持方法进行字符串验证, 匹配某个正则根据正则替换全部根据正则替换首个根据正则拆分根据正则拆分成指定的个数案例, 找出字符串中的字母案例: 字符串拆分(按数字拆分)案例: ...
  • Java正则表达式括号内容匹配工作中碰到的一些问题与解决方法记录下来以备不时之需商品品名规定英文括号正则表达式拆分规则.*? :所有内容[1-9] :整数数字1到9\d :0到9\d* :*表示可跟多个数字\. :小数点\.? :?...
  • java正则表达式

    2013-05-17 23:31:59
    000.00; unitPrice.split("\\."... String[] split(String regex) 根据给定的正则表达式的匹配来拆分此字符串。  其它预定义字符类   \d 数字:[0-9]   \D 非数字: [^0-9]   
  • package lily; import java.util.Scanner; /* * 分割功能 * String类的public String[] split(String... * 根据给定正则表达式的匹配拆分此字符串。 * * 举例: * 百合网,世纪佳缘,珍爱网,QQ * 搜索好友 * ...
  • 根据给定正则表达式的匹配拆分此字符串。返回一个字符串数组。 split 基础用法 String s = "123,abc,ABC"; String[] split = s.split(","); for(String s1 :split){ System.out.println(s1); /** * ...
  • public static void main(String[] args) {getChaXun();}/*** @param year 输入的年* @param c Counyry对象* @return 日志中追加的后缀*/public static String Panduan(String year,Country c) {String string=null;...
  • public static void main(String[] args) {getChaXun();} /*** @param year 输入的年* @param c Counyry对象* @return 日志中追加的后缀*/public static String Panduan(String year,Country c) {String string=...
  • 在String类中,有四个特殊的方法: public String[] split(String regex)根据给定的正则表达式的匹配来拆分此字符串。该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此,结果数组中...
  • 根据匹配给定的正则表达式来拆分此字符串。
  • 分割功能  String类的public String[] split(String regex)  根据给定正则表达式的匹配拆分此字符串。 例子:  可以用来做年龄段的筛选,比如说,我要筛选18-26之间的年龄段的人  而18-26在后台是字符串...
  • 使用String的split方法,split方法:根据给定正则表达式的匹配拆分字符串。如下: 1 public String[] split(String regex); 2. 案例: 代码如下: 1 package cn.itcast_03; 2 3 import java....
  • Java语言中的split() 方法根据匹配给定的正则表达式来拆分字符串。这里要注意正则表达式中的特殊字符。下面的代码执行后可以把test字符串按照我们预想的那种情况进行分割,没有问题。String test = "aasd#qwedc#...
  • String.split()方法:根据给定正则表达式的匹配拆分此字符串 例如,字符串 "boo:and:foo" 使用这些表达式可生成以下结果: Regex 结果 : { "boo", "and", "foo" } O { "b", "", ":and:f...
  • Java语言中的split() 方法根据匹配给定的正则表达式来拆分字符串。这里要注意正则表达式中的特殊字符。 下面的代码执行后可以把test字符串按照我们预想的那种情况进行分割,没有问题。 String test = "aasd#...
  • 正则表达式

    2011-12-16 22:25:09
    4) String[] split(String regex)根据给定正则表达式拆分该字符串后得到的字符串数组。 3、 创建正则表达式: 正则表达式中使用的常见字符: 1) \t:制表符(‘\u0009’). 2) \n:换行(‘\u000A’)。 3) \r:回车(...
  • 正则表达式Java中无论正则表达式是否有边界匹配(^$)都是做全匹配验证 boolean matches(String regex); 根据给定的正则表达式来验证当前字符串是否满足格式要求,满足返回true String[] spilt(Strig regex); 将...
  • java 将字符串拆分成块装数组

    千次阅读 2018-03-24 16:47:42
    根据给定正则表达式的匹配拆分此字符串。 该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此,所得数组中不包括结尾空字符串。 例如,字符串 "boo:and:foo" 使用这些表达式可生成...
  • java拆分字符串

    2012-04-25 17:15:54
    问题引出:用^拆分如下字符串:B0005433^1~6^01^0001~...根据给定的正则表达式的匹配来拆分此字符串。 该方法的作用是使用给定的表达式和限制参数0来调用两参数split方法。因此数组中不包括结尾空字符串。 例如:...
  • 正则分割功能

    2015-10-31 17:40:18
    //public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串。  //举例:判断一个人的年龄是否符合要求 // girl // age 18-24 import java.util.Scanner; public class zhengzefenge { ...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 173
精华内容 69
关键字:

java根据正则拆分

java 订阅