String字符串的replace函数和正则表达式

向右看齐 2022-06-15 22:26 399阅读 0赞

package zhengze;
    
    
    public class sss {
    
    
     public static void main(String[] args) {
     // TODO Auto-generated method stub
             String str="hello,java!";
             System.out.println(str.replace("\\w", "#"));
             System.out.println(str.replace("\\w*", "#"));
             System.out.println(str.replace("\\w*?", "#"));
             //首先\\w是代表匹配所有数字字母下划线，没有表示数量则是代表一个字符。
             //然后*+?这三个是正则特殊字符中，表示数量。*0或多，+1或多，?0或1
             //算是{n} {n,} {n,m}这三个表示数量的。这样，几乎所有数量都可以表示了。
             //这里我叫它们是正则数量符，这样总共有6种数量符。
             //数量表示符又有三种模式，贪婪模式，勉强模式，占用模式。最后两个表示式一样。
             //所以这里我就介绍下贪婪模式和勉强模式，前者除非条件固定，那么会一直匹配下去
             //后者除非条件固定，那儿会匹配最少的字符
             //贪婪模式是表示式加一个任意的数量符，勉强模式是贪婪模式加一个?数量符
             System.out.println("\r\n以下测试的是replaceFirst函数");
             System.out.println("普通匹配，没有任何模式"+str.replaceFirst("\\w", "#"));
             System.out.println("0或多的贪婪模式"+str.replaceFirst("\\w*", "#"));
             System.out.println("0或多的勉强模式"+str.replaceFirst("\\w*?", "#"));   
             System.out.println("2位的贪婪模式"+str.replaceFirst("\\w{2}", "#"));
             System.out.println("2位的勉强模式"+str.replaceFirst("\\w{2}?", "#"));
             System.out.println("大于2位的贪婪模式"+str.replaceFirst("\\w{2,}", "#"));
             System.out.println("大于2位的勉强模式"+str.replaceFirst("\\w{2,}?", "#"));
             System.out.println("2到4位的贪婪模式"+str.replaceFirst("\\w{2,4}", "#"));
             System.out.println("2到4位的勉强模式"+str.replaceFirst("\\w{2,4}?", "#"));
             
             System.out.println("\r\n以下测试的是replaceAll函数");
             System.out.println("普通匹配，没有任何模式"+str.replaceAll("\\w", "#"));
             System.out.println("0或多的贪婪模式"+str.replaceAll("\\w*", "#"));
             System.out.println("0或多的勉强模式"+str.replaceAll("\\w*?", "#"));   
             System.out.println("2位的贪婪模式"+str.replaceAll("\\w{2}", "#"));
             System.out.println("2位的勉强模式"+str.replaceAll("\\w{2}?", "#"));
             System.out.println("大于2位的贪婪模式"+str.replaceAll("\\w{2,}", "#"));
             System.out.println("大于2位的勉强模式"+str.replaceAll("\\w{2,}?", "#"));
             System.out.println("2到4位的贪婪模式"+str.replaceAll("\\w{2,4}", "#"));
             System.out.println("2到4位的勉强模式"+str.replaceAll("\\w{2,4}?", "#"));
             
             System.out.println("\r\n以下单独测试的是replaceAll函数,0或多的贪婪模式");
             System.out.println("java的结果是"+"java".replaceAll("\\w*", "#"));
             System.out.println("java,的结果是"+"java,".replaceAll("\\w*", "#"));
             System.out.println("java,,的结果是"+"java,,".replaceAll("\\w*", "#"));
             System.out.println(",java,,的结果是"+",java,,".replaceAll("\\w*", "#"));
             
     }
    
    
    }

首先介绍一下知识点。字符串的三个替换方法是如程序所示。有三种。

输入结果是

hello,java!  
hello,java!  
hello,java!  
  
  
以下测试的是replaceFirst函数  
普通匹配，没有任何模式\#ello,java!  
0或多的贪婪模式\#,java!  
0或多的勉强模式\#hello,java!  
2位的贪婪模式\#llo,java!  
2位的勉强模式\#llo,java!  
大于2位的贪婪模式\#,java!  
大于2位的勉强模式\#llo,java!  
2到4位的贪婪模式\#o,java!  
2到4位的勉强模式\#llo,java!  
  
  
以下测试的是replaceAll函数  
普通匹配，没有任何模式\#\#\#\#\#,\#\#\#\#!  
0或多的贪婪模式\#\#,\#\#!\#  
0或多的勉强模式\#h\#e\#l\#l\#o\#,\#j\#a\#v\#a\#!\#  
2位的贪婪模式\#\#o,\#\#!  
2位的勉强模式\#\#o,\#\#!  
大于2位的贪婪模式\#,\#!  
大于2位的勉强模式\#\#o,\#\#!  
2到4位的贪婪模式\#o,\#!  
2到4位的勉强模式\#\#o,\#\#!  
  
  
以下测试的是replaceAll函数,0或多的贪婪模式  
java的结果是\#\#  
java,的结果是\#\#,\#  
java,,的结果是\#\#,\#,\#  
,java,,的结果是\#,\#\#,\#,\#

<table> 
 <tbody> 
  <tr> 
   <td>&nbsp; &nbsp; &nbsp; &nbsp;<pre><code>replace</code></pre> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;</td> 
   <td>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; <h5> 
     <div style=""> 
      <a rel="nofollow"></a> 
      <a title="in java.lang" rel="nofollow">String</a> 
      <a rel="nofollow">java</a>. 
      <a rel="nofollow">lang</a>. 
      <a rel="nofollow">String</a>.replace( 
      <span style="font-weight:normal"></span> 
      <a title="in java.lang" rel="nofollow">CharSequence</a> target, 
      <span style="font-weight:normal"></span> 
      <a title="in java.lang" rel="nofollow">CharSequence</a> replacement) 
     </div> </h5> <br> <p>Replaces each substring of this string that matches the literal target sequence with the specified literal replacement sequence. The replacement proceeds from the beginning of the string to the end, for example, replacing "aa" with "b" in the string "aaa" will result in "ba" rather than "ab".</p> 
    <dl>
      Parameters: 
     <dd> 
      <strong>target</strong> The sequence of char values to be replaced 
     </dd> 
     <dd> 
      <strong>replacement</strong> The replacement sequence of char values 
     </dd> Returns: 
     <dd>
       The resulting string 
     </dd> Since: 
     <dd>
       1.5 
     </dd> 
    </dl> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;</td> 
  </tr> 
  <tr> 
   <td><pre><code>replaceFirst</code></pre></td> 
   <td> <h5> 
     <div style=""> 
      <a rel="nofollow"></a> 
      <a title="in java.lang" rel="nofollow">String</a> 
      <a rel="nofollow">java</a>. 
      <a rel="nofollow">lang</a>. 
      <a rel="nofollow">String</a>.replaceFirst( 
      <span style="font-weight:normal"></span> 
      <a title="in java.lang" rel="nofollow">String</a> regex, 
      <span style="font-weight:normal"></span> 
      <a title="in java.lang" rel="nofollow">String</a> replacement) 
     </div> </h5> <br> <p>Replaces the first substring of this string that matches the given <a href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#sum" rel="nofollow"> regular expression</a> with the given replacement. </p> <p>An invocation of this method of the form <em>str</em><code>.replaceFirst(</code><em>regex</em><code>,</code> <em>repl</em><code>)</code> yields exactly the same result as the expression </p> 
    <blockquote> 
     <code><code><a rel="nofollow">java.util.regex.Pattern</a></code>.<code><a rel="nofollow">compile</a></code>(<em>regex</em>).<code><a rel="nofollow">matcher</a></code>(<em>str</em>).<code><a rel="nofollow">replaceFirst</a></code>(<em>repl</em>) </code> 
    </blockquote> <p>Note that backslashes (<code>\</code>) and dollar signs (<code>$</code>) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string; see <code><a rel="nofollow">java.util.regex.Matcher.replaceFirst</a></code>. Use <code><a rel="nofollow">java.util.regex.Matcher.quoteReplacement</a></code> to suppress the special meaning of these characters, if desired.</p> 
    <dl>
      Parameters: 
     <dd> 
      <strong>regex</strong> the regular expression to which this string is to be matched 
     </dd> 
     <dd> 
      <strong>replacement</strong> the string to be substituted for the first match 
     </dd> Returns: 
     <dd>
       The resulting 
      <code>String</code> 
     </dd> Throws: 
     <dd> 
      <a rel="nofollow">PatternSyntaxException</a> - if the regular expression's syntax is invalid 
     </dd> Since: 
     <dd>
       1.4 
     </dd> See Also: 
     <dd> 
      <a rel="nofollow">java.util.regex.Pattern</a> 
     </dd> @spec 
     <dd>
       JSR-51 
     </dd> 
    </dl> </td> 
  </tr> 
  <tr> 
   <td><pre><code>replaceAll</code></pre></td> 
   <td> <h5> 
     <div style=""> 
      <a rel="nofollow"></a> 
      <a title="in java.lang" rel="nofollow">String</a> 
      <a rel="nofollow">java</a>. 
      <a rel="nofollow">lang</a>. 
      <a rel="nofollow">String</a>.replaceAll( 
      <span style="font-weight:normal"></span> 
      <a title="in java.lang" rel="nofollow">String</a> regex, 
      <span style="font-weight:normal"></span> 
      <a title="in java.lang" rel="nofollow">String</a> replacement) 
     </div> </h5> <br> <p>Replaces each substring of this string that matches the given <a href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#sum" rel="nofollow"> regular expression</a> with the given replacement. </p> <p>An invocation of this method of the form <em>str</em><code>.replaceAll(</code><em>regex</em><code>,</code> <em>repl</em><code>)</code> yields exactly the same result as the expression </p> 
    <blockquote> 
     <code><code><a rel="nofollow">java.util.regex.Pattern</a></code>.<code><a rel="nofollow">compile</a></code>(<em>regex</em>).<code><a rel="nofollow">matcher</a></code>(<em>str</em>).<code><a rel="nofollow">replaceAll</a></code>(<em>repl</em>) </code> 
    </blockquote> <p>Note that backslashes (<code>\</code>) and dollar signs (<code>$</code>) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string; see <code><a rel="nofollow">Matcher.replaceAll</a></code>. Use <code><a rel="nofollow">java.util.regex.Matcher.quoteReplacement</a></code> to suppress the special meaning of these characters, if desired.</p> 
    <dl>
      Parameters: 
     <dd> 
      <strong>regex</strong> the regular expression to which this string is to be matched 
     </dd> 
     <dd> 
      <strong>replacement</strong> the string to be substituted for each match 
     </dd> Returns: 
     <dd>
       The resulting 
      <code>String</code> 
     </dd> Throws: 
     <dd> 
      <a rel="nofollow">PatternSyntaxException</a> - if the regular expression's syntax is invalid 
     </dd> Since: 
     <dd>
       1.4 
     </dd> See Also: 
     <dd> 
      <a rel="nofollow">java.util.regex.Pattern</a> 
     </dd> @spec 
     <dd>
       JSR-51 
     </dd> 
    </dl> </td> 
  </tr> 
 </tbody> 
</table>

从以上可以看出。第一个函数的两个参数都是字符串，而第二第三个函数的第一个参数则是正则表达式，即是一种特殊的字符串。

需要指出，只有使用了数量表达式，那么一定是三种模式中的一种。

//首先\\w是代表匹配所有数字字母下划线，没有表示数量则是代表一个字符。
             //然后*+?这三个是正则特殊字符中，表示数量。*0或多，+1或多，?0或1
             //算是{n} {n,} {n,m}这三个表示数量的。这样，几乎所有数量都可以表示了。
             //这里我叫它们是正则数量符，这样总共有6种数量符。
             //数量表示符又有三种模式，贪婪模式，勉强模式，占用模式。最后两个表示式一样。
             //所以这里我就介绍下贪婪模式和勉强模式，前者除非条件固定，那么会一直匹配下去
             //后者除非条件固定，那儿会匹配最少的字符
             //贪婪模式是表示式加一个任意的数量符，勉强模式是贪婪模式加一个?数量符

分析输出结果

一。replace函数。因为参数是字符串，而不识别正则表达式，所以不会进行任何替换。

二。replaceFirst函数。结果很好理解，可以见得，如果数量没有被固定，那么模式是能起到作用的。

三。replaceAll函数。这里面稍微复杂一点，因为函数是要替换所有的符合要求的。0或多的贪婪模式，这个比较特殊，下面讲。

0或多的勉强模式，其实就是所有0位的符合要求的，替换掉了，所以是那种输出。

四。replaceAll函数,0或多的贪婪模式。这个比较特殊。可见是只要是数字字母下划线的集合（因为是贪婪），那么就替换。然后就是只要是“单词”，那么就替换为\#\#，好像意思是单词前有个0位单词，只有0位，替换为\#。然后是非匹配和非匹配或者首尾之间也有一个0位单词，所以也得替换。