Java之String的那些操作会影响效率和Java正则

参考博客： String常用API详细描述

一、将基本类型转换为String类型，优先考虑toString()方法

Integer a = new Integer(1);
方法1：a.toString();
方法2：String.valueOf(a);
方法3：a+"";

效率比较：
方法1效率最快、其次到方法2、最后才是方法3；

1.a.toString()方法可以直接调用进行转换
2.String.valueOf(a)方法底层调用了Integer.toString()方法，但是会在调用前做空判断
3.a+""底层使用了StringBuilder实现，先用append方法拼接，再用toString()方法获取字符串

二、replace与replaceAll的坑

	String str1 = "{$var}您好";
    String str2 = "{$var}您好";
    // 普通文本
    str1 = str1.replace("{$var}", "猴哥"); 
    // 必须是正则表达式,否则编译器会报错
    str2 = str2.replaceAll("\\{\\$var\\}", "猴哥"); //此情况必须是正则
    System.out.println(str1);
    System.out.println(str2);

a、 replaceAll参数是regex，即基于规则表达式的替换，比如：可以通过replaceAll("\d", “*”)把所有数字字符都换成星号；

相同点：都是全部替换，即把源字符串中某一字符或字符串全部换成指定字符或字符串；
不同点：replaceAll支持正则表达式，因此会对参数进行解析（两个参数均是），如replaceAll("\d", “")，而replace则不会，replace("\d","”)就是替换"\d"的字符串，而不会解析为正则。

b、另外一个不同点：“\”在java中是一个转义字符，所以需要用两个代表一个。例如System.out.println( “\” ) ;只打印出一个""。
但是“\”也是正则表达式中的转义字符，需要用两个代表一个。所以：\\被java转换成\，\又被正则表达式替换为\。
因此用replaceAll替换“\”为"\"，就要用replaceAll("\\","\\\\")，而replace则replace("\","\\")。

三、String拼接字符串效率低

public static void main(String[] args) {
String a = “abc”;
String b = “def”;
String c = a + b;
System.out.Println©;
}
此时一个指针指向常量池中的“abc”，另一个指针指向常量池的“def”，
编译完成后，通过new一个StringBuilder，然后分别做了两次append操作，最后做一个toString()操作

当使用for时：
String s = “”;
for (int i = 0; i < 10; i++){
s += i；
}
编译器将"+"转换成了StringBuilder，创建StringBuilder对象的位置却在for语句内部，
执行一次循环，就会创建一个StringBuilder对象，本列创建了10个StringBuilder对象，
所以可以直接在程序中使用StringBuilder来连接字符串

四、java中split()特殊符号"." “|” “*” “” “]”

关于点的问题是用string.split("[.]") 解决。 关于竖线的问题用 string.split("\|")解决。 关于星号的问题用 string.split("\*")解决。 关于斜线的问题用 sring.split("\\")解决。 关于中括号的问题用 sring.split("\[\]")解决。

五、Java 正则表达式和Js正则

Java 正则实现同一业务

public static String test(String in) {
	StringBuilder sb = new StringBuilder();
	//***0***05000 替换 ***0***0
	in = in.replaceAll("\\*\\*\\*0\\*\\*\\*05000", "\\*\\*\\*0\\*\\*\\*0");
	//按***0***0分割
	String[] lines = in.split("\\*\\*\\*0\\*\\*\\*0");
	
	//创建 Pattern 对象,正则表达式   §<<(.*)>>§***1
	Pattern pattern = Pattern.compile("§<<(.*)>>§\\*\\*\\*1");
	String str = "";
	int start = 0;
	int end = 0;
	boolean hint = false;
	for (String line : lines) {
		Matcher m = pattern.matcher(line);//现在创建 matcher 对象
		hint = false;
		while (m.find()) {//find()尝试查找与该模式匹配的输入序列的下一个子序列
			hint = true;
			start = m.start();//第一次匹配出现位置
			end = m.end();//最后一次匹配出现配置
			str = m.group(1);//对括号内的字符分组来创建，获取第一个组

			sb.append(line.substring(0, start));//取第一次匹配之前的数据
			String[] combo = str.split("##");
			if (combo.length > 0) {
				sb.append(combo[1]);//取组内 ## 后的数据
			}
			sb.append(line.substring(end, line.length()));//取最后一次匹配后的数据
		}
		if (!hint) {
			sb.append(line).append(System.getProperty("line.separator"));//获取操作系统对应的换行符
		}
	}	
	return sb.toString().replaceAll("&#xd; ", "").replaceAll("\\*\\*\\*0", "");//替换 ***0 为空
}

Js 正则实现同一业务

function processValue(content) {
	content = content.replace(/\*\*\*0\*\*\*05000/g, '***0***0');
	var lines = content.split('***0***0');
	
	var pattern = /§<<|>>§|>>§\*\*\*1/;
	var resStr = '';
	for (var i = 0; i < lines.length; i++) {
		var line = lines[i];
		if(pattern.test(line)) {
			var start = line.search(pattern);
			if(start > 0) {
				resStr += line.substring(0, start);
			}
			
			var res = /§<<([^§<<|>>§]*)>>§/.exec(line);
			if(res) {
				var combo = res[1].split("##");
				if(combo.length > 0) {
					resStr += combo[1];
				}
			}
		} else {
			resStr += line + '\n';
		}
	}
	return resStr.replace(/\*\*\*0/g, '');
}