「java正则表达式效率」java 正则性能

博主：adminadmin 2023-03-19 15:20:11 309

本篇文章给大家谈谈java正则表达式效率，以及java 正则性能对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

java的正则表达式有什么作用？

//正则表达式，是用来匹配字符串的，即检查一定的格式，还能按格式进行分

//组，替换......

//举个简单的例子，检查一个字符串是否是IP地址类型的（192.168.0.101)。当

//然，下面的例子只是作初步的检查，即检查字符串是否为：1-3个数字接1

//个"."，1-3个数字接1个"."，1-3个数字接1个"."，1-3个数字。

public class Test {

public static void main(String args[]){

String s="192.168.0.101";

String s2="1234.1232.123";

System.out.println(s.matches("[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}"));

System.out.println(s2.matches("[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}"));

}

}

//当然，正则表达式绝不是只能检查的，还可以将字符串进行分组，提取出你

//想要的部分

//其实，不用正则表达式，也可以编。但是，大多数情况下，正则表达式可以提

//高你编程的效率。

不是用java现有API(正则表达式和replace)对字符串的指定子串进行替换,要求考虑效率

/**

* 替换第一个

* @param oriStr 原始字符串

* @param regex 要替换的部分

* @param repStr 要替换成的字符串

* @return 替换后的字符串

*/

public static String replaceFirst(String oriStr, String regex,

String repStr) {

if (oriStr.lastIndexOf(regex) != -1) {

String[] strs = oriStr.split(regex);

StringBuffer sb = new StringBuffer();

sb.append(strs[0]);

sb.append(repStr);

for (int i = 1; i strs.length; i++) {

sb.append(strs[i]);

sb.append(regex);

}

return sb.toString().substring(0, sb.toString().length() - 1);

} else {

throw new RuntimeException("目标字符串中不包含要替换的字符串");

}

}

/**

* 替换所有

* @param oriStr 原始字符串

* @param regex 要替换的部分

* @param repStr 要替换成的字符串

* @return 替换后的字符串

*/

public static String replaceAll(String oriStr, String regex,

String repStr) {

if (oriStr.lastIndexOf(regex) != -1) {

String[] strs = oriStr.split(regex);

StringBuffer sb = new StringBuffer();

for (int i = 0; i strs.length; i++) {

sb.append(strs[i]);

sb.append(repStr);

}

return sb.toString().substring(0, sb.toString().length() - 1);

} else {

throw new RuntimeException("目标字符串中不包含要替换的字符串");

}

}

用java正则表达式提取java程序中的注释

正则的效率非常低，有很多不用正则的好方法：

一，示例 某java程序

比如说一个Test2.java,将其保存在C盘根目录下，代码内容如下

/**

* @author xxx

*

*/

public class Test2 {

/* main method */

public static void main(String[] args) {

//a

int a =5;

//b

int b =5;

//a+b

System.out.println(a+b);

}

}

二，提取注释程序，将所有注释放到一个List里面，最后打印输出：

import java.io.BufferedReader;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.List;

public class Test {

private static final String javaFilePath = "C:/Test2.java";

public static void main(String[] args) throws IOException {

ListString comments = new ArrayListString();

BufferedReader bfr = new BufferedReader(new InputStreamReader(new FileInputStream(javaFilePath)));

String line=null;

while((line=bfr.readLine())!=null){

line = line.trim();

if(line.startsWith("//")){

comments.add(line);

}

else if(line.startsWith("/*")line.endsWith("*/")){

comments.add(line);

}else if(line.startsWith("/*")!line.endsWith("*/")){

StringBuffer multilineComment = new StringBuffer(line);

while((line=bfr.readLine())!=null){

line = line.trim();

multilineComment.append("\n").append(line);

if(line.endsWith("*/")){

comments.add(multilineComment.toString());

break;

}

}

}

}

bfr.close();

for(int i=0;icomments.size();i++){

System.out.println("第"+(i+1)+"处注释: ");

System.out.println(comments.get(i));

}

}

}

三，输出结果：

第1处注释:

/**

* @author xxx

*

*/

第2处注释:

/* main method */

第3处注释:

//a

第4处注释:

//b

第5处注释:

//a+b

java正则表达式中，matches和find的效率问题

你可以看下源码，匹配原理是一样的，没什么大区别。效率应该是一样的。匹配原则代码块如下。

 this.hitEnd = false;

        this.requireEnd = false;

        from        = from  0 ? 0 : from;

        this.first  = from;

        this.oldLast = oldLast  0 ? from : oldLast;

        for (int i = 0; i  groups.length; i++)

            groups[i] = -1;

        acceptMode = anchor;

        boolean result = parentPattern.matchRoot.match(this, from, text);

        if (!result)

            this.first = -1;

        this.oldLast = this.last;

        return result;

JAVA正则表达式，matcher.find和 matcher.matches的区别

1.find()方法是部分匹配，是查找输入串中与模式匹配的子串，如果该匹配的串有组还可以使用group()函数。

matches()是全部匹配，是将整个输入串与模式匹配，如果要验证一个输入的数据是否为数字类型或其他类型，一般要用matches()。

2.Pattern pattern= Pattern.compile(".*?,(.*)");

Matcher matcher = pattern.matcher(result);

if (matcher.find()) {

return matcher.group(1);

}

3.详解：

matches

public static boolean matches(String regex, CharSequence input)

编译给定正则表达式并尝试将给定输入与其匹配。

调用此便捷方法的形式

Pattern.matches(regex, input);

Pattern.compile(regex).matcher(input).matches() ;

如果要多次使用一种模式，编译一次后重用此模式比每次都调用此方法效率更高。

参数：

regex - 要编译的表达式

input - 要匹配的字符序列

抛出：

PatternSyntaxException - 如果表达式的语法无效

find

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

此方法从匹配器区域的开头开始，如果该方法的前一次调用成功了并且从那时开始匹配器没有被重置，则从以前匹配操作没有匹配的第一个字符开始。

如果匹配成功，则可以通过 start、end 和 group 方法获取更多信息。

matcher.start() 返回匹配到的子字符串在字符串中的索引位置.

matcher.end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置.

matcher.group()返回匹配到的子字符串

返回：

当且仅当输入序列的子序列匹配此匹配器的模式时才返回 true。

java正则表达式效率的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java 正则性能、java正则表达式效率的信息别忘了在本站进行查找喔。

标签：