页面导航：
→ 正文内容 替换HTML标签的方法
Java中替换HTML标签的方法代码
这篇文章主要介绍了Java中替换HTML标签的方法代码,需要的朋友可以参考下
1、替换HTML标签
代码如下:replaceAll("\\&[a-zA-Z]{0,9};", "").replaceAll("&[^&]*&", "\n\t")
源码如下：
代码如下:/**&* 字符串替换&*/package com.you.
/**&* HTML标签替换&* @author YHD&* @version&*/public class StrReplace {
&/**& * @param args& */&public static void main(String[] args) &{&&String str = " &table border='1' cellpadding='1' cellspacing='1'&&tr&&th rowspan='2'&序号&/th&&th colspan='2'&李四&/th&&th&赵六&/th&&/tr&&table&";&&/**&& * 替换HTML标签&& */&&String subStr = str.replaceAll("\\&[a-zA-Z]{0,9};", "").replaceAll("&[^&]*&", "\n\t");&&/**&& * 打印替换后的字符串&& */&&System.out.println("打印替换后的字符串：" + subStr);&}
2、运行结果如下
打印替换后的字符串：&&&& &&& 序号& &&& 李四& &&& 赵六&
您可能感兴趣的文章:
上一篇：下一篇：
最 近 更 新
热 点 排 行长沙java培训：Java编程中怎么写出好代码
责任编辑：admintk 11:22:49
& & 很多时候我们写出来的代码都是有感而发，并没有一定的规则和秩序，以致写出来的代码并没有一定的章法，别人看着也会觉得很杂乱，下面有十大规则是由整理收集的一位专业java编程人士写代码时的经验，教你怎样写出&优美&的代码来。
　　1、注释尽可能全面
　　对于方法的注释应该包含详细的入参和结果说明，有异常抛出的情况也要详细叙述;类的注释应该包含类的功能说明、作者和修改者。
　　2、多次使用的相同变量最好归纳成常量
　　多处使用的相同值的变量应该尽量归纳为一个常量，方便日后的维护。
　　3、尽量少的在循环中执行方法调用
　　尽量在循环中少做一些可避免的方法调用，这样可以节省方法栈的创建。例如：
　　1&for(int&i=0;i&&p=&&&style=&margin:&0px&&padding:&0&&
　　2&System.out.println(i);
　　可以修改为：
　　4&for(int&i=0,size=list.size();i&&p=&&&style=&margin:&0px&&padding:&0&&
　　5&System.out.println(i);
　　4、常量的定义可以放到接口中
　　在Java中，接口里只允许存在常量，因此把常量放到接口中声明就可以省去public&static&final这几个关键词。
　　5、ArrayList和LinkedList的选择
　　这个问题比较常见。通常程序员最好能够对list的使用场景做出评估，然后根据特性作出选择。ArrayList底层是使用数组实现的，因此随机读取数据会比LinkedList快很多，而LinkedList是使用链表实现的，新增和删除数据的速度比ArrayList快不少。
　　6、String，StringBuffer和StringBuilder
　　这个问题也比较常见。在进行字符串拼接处理的时候，String通常会产生多个对象，而且将多个值缓存到常量池中。例如：
　　7&String&a=&a&;
　　8&String&b=&b&;
　　9&a=a+b;
　　这种情况下jvm会产生&a&,&b&,&ab&三个对象。而且字符串拼接的性能也很低。因此通常需要做字符串处理的时候尽量采用StringBuffer和StringBuilder来。
　　7、包装类和基本类型的选择
　　在代码中，如果可以使用基本数据类型来做局部变量类型的话尽量使用基本数据类型，因为基本类型的变量是存放在栈中的，包装类的变量是在堆中，栈的操作速度比堆快很多。
　　8、尽早的将不再使用的变量引用赋给null
　　这样做可以帮助jvm更快的进行内存回收。当然很多人其实对这种做法并不感冒。
　　9、在finally块中对资源进行释放
　　典型的场景是使用io流的时候，不论是否出现异常最后都应该在finally中对流进行关闭。
　　10、在HashMap中使用一个Object作为key时要注意如何区分Object是否相同
　　在jdk的HashMap实现中，判断两个Object类型的key是否相同的标准是hashcode是否相同和equals方法的返回值。如果业务上需要对两个数据相同的内存对象当作不同的key存储到hashmap中就要对hashcode和equals方法进行覆盖。
& & 相关阅读：
欧柏泰克软件学院专注解决：:
请您文明上网理性发言并遵守相关规定。您评论后的内容需管理员审核后才能正常显示。Java中语句、分支和路径覆盖测试_单元测试代码_领测软件测试网
Java中语句、分支和路径覆盖测试
发表于：来源：作者：点击数：
代码覆盖是一种用来 度量 已执行的 软件测试 水平的方法 简介 代码覆盖是一种用来度量已执行的软件测试水平的方法。收集覆盖度量数据的过程很简单：监测您的代码，并对所监测的版本运行测试。这样就可以生成相关数据，展示已执行哪些代码，或者更重要的是，
　　代码覆盖是一种用来已执行的 水平的方法
　　代码覆盖是一种用来度量已执行的软件水平的方法。收集覆盖度量数据的过程很简单：监测您的代码，并对所监测的版本运行。这样就可以生成相关数据，展示已执行哪些代码，或者更重要的是，未执行哪些代码。覆盖测试是对的完美补充：可以显示出是否代码按预期执行，而代码覆盖可以表明还需要对哪些代码进行测试。
　　大多数人员都能理解这一过程，也赞同其价值主张，他们通常追求100%的覆盖率。尽管100%的覆盖率是个极好的目标，但类型不当的100%覆盖率依然会留下未知的问题。典型的软件是根据要测试的语句或分支的数量来度量覆盖率的。即便有着100%的语句或分支覆盖率，代码逻辑依然可能存在严重的逻辑，只能为开发人员和管理员带来虚假的感。
　　为何100%的覆盖率还不够?这是因为语句和分支覆盖率无法表明代码中的逻辑是否已执行。语句和分支覆盖对于未执行代码块中出现的明显问题来说很有用，但它们经常会错过与决策结构和决策交互相关的。而另一方面，路径覆盖则是一种有助于及早发现的更为健壮和全面的技术。
　　在了解路径覆盖之前，先关注一下语句和分支覆盖率方面的一些问题：
　　语句覆盖
　　语句覆盖可以识别在一个方法或类中执行了哪些语句。这是一种计算起来比较简单的量规，现在有许多 产品 都可以评测这种覆盖级别。最终，语句覆盖的获益在于其能够识别未执行代码块。然而语句覆盖也存在问题，其无法识别源代码中控制流结构导致的bug，例如复合条件或者连续开关标签。这意味着在您可以轻松获得100%覆盖率的同时，未发现的明显bug依然存在。
　　下例中显示了这种问题。此处，returnInput()方法由七条语句组成，它有一个简单的：输出应等于输入。
图1. 代码示例
　　接下来，您可以创建一个满足并且具有100%语句覆盖率的JUnit。
图2. 语句覆盖
原文转自：
评论列表（网友评论仅供网友表达个人看法，并不表明本站同意其观点或证实其描述）java中查找的代码怎么写_百度知道
java中查找的代码怎么写
另存为 与 查找的代码
提问者采纳
另存为要构建文件流，保存到本地，查找用正则表达式匹配。
其他类似问题
java的相关知识
其他1条回答
查找大了去了。你是想查找什么文件，？什么文件? 数据库 ?
您可能关注的推广回答者：回答者：
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁页面导航：
→ 正文内容 Java StringBuilder性能测试
Java中的StringBuilder性能测试
这篇文章主要介绍了Java中的StringBuilder性能测试,本文包含测试代码和测试结果,最后得出结论,需要的朋友可以参考下
在看KMP算法时,想要简单的统计一下执行时间和性能。
得出的结论是： Java的String的indexOf方法性能最好，其次是KMP算法，其次是传统的BF算法，当然，对比有点牵强，SUN的算法也使用Java来实现、用的看着不像是KMP，还需要详细研究一下。
测试代码如下所示：
package com.test.test.
import java.util.R
public class KMPTest {
public static void main(String[] args) {
public static void test() {
int allLen = 8000000;
int subLen = 11;
int charLen = 4;
String cl = buildString(charLen);
int times = 50;
testMatch(allLen, subLen, cl, times);
public static void testMatch(int allLen, int subLen, String cl, int times){
int allBF = 0;
int allString = 0;
int allKMP = 0;
int allGC = 0;
int allbuild = 0;
int alltoArray = 0;
long start = System.currentTimeMillis();
System.out.println("--------------------------");
for (int i = 0; i & i++) {
// 1. 构造字符串的损耗
long buildStart = System.currentTimeMillis();
String sub = buildString(subLen, cl);
String all = buildString(allLen, sub) +
long buildEnd = System.currentTimeMillis();
allbuild += (buildEnd - buildStart);
// 2. toCharArray的损耗
long toArrayStart = System.currentTimeMillis();
char[] allArray = all.toCharArray();
char[] subArray = sub.toCharArray();
long toArrayEnd = System.currentTimeMillis();
alltoArray += (toArrayEnd - toArrayStart);
long startBF = System.currentTimeMillis();
int indexBF = bfIndexOf(all, sub);
long endBF = System.currentTimeMillis();
long timeoutBF = endBF - startBF;
allBF += timeoutBF;
System.gc();
allGC += (System.currentTimeMillis() - endBF);
long startString = System.currentTimeMillis();
int indexString = stringIndexOf(all, sub);
long endString = System.currentTimeMillis();
long timeoutString = endString - startS
allString += timeoutS
System.gc();
allGC += (System.currentTimeMillis() - endString);
long startKMP = System.currentTimeMillis();
//int indexKMP = kmpIndexOf(all, sub);
int indexKMP = KMP_Index(allArray, subArray);
long endKMP = System.currentTimeMillis();
long timeoutKMP = endKMP - startKMP;
allKMP += timeoutKMP;
System.gc();
allGC += (System.currentTimeMillis() - endKMP);
//System.out.println("all="+all.substring(0,100)+" ......");
//System.out.println("sub="+sub);
//System.out.println("indexBF="+indexBF+";耗时: "+timeoutBF+"ms");
//System.out.println("indexString="+indexString+";耗时: "+timeoutString+"ms");
if(indexBF == indexString && indexKMP == indexString){
//System.out.println("!!!!对比相等。");
throw new RuntimeException("对比出错.");
if(i % 20 == 10){
System.out.println(i+"次bfIndexOf= "+allBF+"ms");
System.out.println(i+"次stringIndexOf= "+allString+"ms");
System.out.println(i+"次KMPIndexOf= "+allKMP+"ms");
System.out.println(i+"次allbuild= "+allbuild+"ms");
System.out.println(i+"次alltoArray= "+alltoArray+"ms");
System.out.println(i+"*3次,GC= "+allGC+"ms");
long end = System.currentTimeMillis();
long allTime = end-
long lossTime = allTime - (allBF+allString+allKMP+allGC);
System.out.println(i+"次,所有总计耗时: "+(allTime)+" 损耗:" + lossTime +" 损耗比: " +((0.0+lossTime)/allTime * 100)+"%");
System.out.println("--------------------------");
System.out.println(times+"次bfIndexOf;总计耗时: "+allBF+"ms");
System.out.println(times+"次stringIndexOf;总计耗时: "+allString+"ms");
System.out.println(times+"次KMPIndexOf;总计耗时: "+allKMP+"ms");
System.out.println(times+"次allbuild= "+allbuild+"ms");
System.out.println(times+"次alltoArray= "+alltoArray+"ms");
System.out.println(times+"*3次,GC;总计耗时: "+allGC+"ms");
long end = System.currentTimeMillis();
long allTime = end-
long lossTime = allTime - (allBF+allString+allKMP+allGC);
System.out.println(times+"次,所有总计耗时: "+(allTime)+" 损耗:" + lossTime +" 损耗比: " +((0.0+lossTime)/allTime * 100)+"%");
System.out.println("--------------------------");
// 构建字符
public static String buildString(int len){
return buildString(len, null);
public static String buildString(int len, String sub){
final int TYPE_NUMBER = 0;
final int TYPE_LOWERCASE = 1;
final int TYPE_UPPERCASE = 2;
long seed = System.nanoTime();
Random random = new Random(seed);
StringBuilder builder = new StringBuilder();
for (int i = 0; i & i++) {
int type = random.nextInt(3);// 0-2
int cvalue = 0;
if(TYPE_NUMBER == type){
cvalue = '0' + random.nextInt(10);// 0~(n-1)
} else if(TYPE_LOWERCASE == type){
cvalue = 'a' + random.nextInt(26);// 0~(n-1)
} else if(TYPE_UPPERCASE == type){
cvalue = 'A' + random.nextInt(26);// 0~(n-1)
throw new RuntimeException(Random.class.getName()+"#newxtInt(int);Wrong!");
//cvalue = 'A' + random.nextInt(26);// 0~(n-1)
char c = (char)
if(null != sub && sub.length() & 1){
int index = random.nextInt(sub.length());
c = sub.charAt(index);
//String s = String.valueOf(c);
builder.append(c);
return builder.toString();
* Java自带的方法,内部实现了
* @param all
* @param sub
public static int stringIndexOf(String all, String sub){
// 防御式编程
if(null == all || null== sub){
return -1;
// 调用Java的String方法
return all.indexOf(sub);
* @param all
* @param sub
public static int bfIndexOf(String all, String sub){
// 防御式编程
if(null == all || null== sub){
return -1;
int lenAll = all.length();
int lenSub = sub.length();
int i = 0;
while (i & lenAll) {
// 从i下标开始对比
int j = 0;
while (j & lenSub) {
char all_i = all.charAt(i);
char sub_j = sub.charAt(j);
if(all_i == sub_j){
// 相等则继续对比下一个字符
j++; // 这个增长很重要
// 否则跳出内层循环
// 如果 j 增长到和 lenSub相等,则匹配成功
if(lenSub == j){
return i - lenS
i = 1+i - // 回溯 i
return -1;
* KMP 算法
* @param all
* @param sub
public static int kmpIndexOf(String all, String sub){
char[] allArray = all.toCharArray();
char[] subArray = sub.toCharArray();
return KMP_Index(allArray, subArray);
* 获得字符串的next函数值
* @param t
* @return next函数值
public static int[] next(char[] t) {
int[] next = new int[t.length];
next[0] = -1;
int i = 0;
int j = -1;
while (i & t.length - 1) {
if (j == -1 || t[i] == t[j]) {
if (t[i] != t[j]) {
next[i] = next[j];
j = next[j];
* KMP匹配字符串
* @param allArray
* @param subArray
* @return 若匹配成功，返回下标，否则返回-1
public static int KMP_Index(char[] allArray, char[] subArray) {
int[] next = next(subArray);
int i = 0;
int j = 0;
while (i &= allArray.length - 1 && j &= subArray.length - 1) {
if (j == -1 || allArray[i] == subArray[j]) {
j = next[j];
if (j & subArray.length) {
return -1;
return i - subArray. // 返回模式串在主串中的头下标
测试的一个结果如下所示：
--------------------------
10次bfIndexOf= 94ms
10次stringIndexOf= 56ms
10次KMPIndexOf= 76ms
10次allbuild= 5870ms
10次alltoArray= 137ms
10*3次,GC= 155ms
10次,所有总计耗时: 6388 损耗:6007 损耗比: 94.42%
--------------------------
30次bfIndexOf= 365ms
30次stringIndexOf= 222ms
30次KMPIndexOf= 295ms
30次allbuild= 16452ms
30次alltoArray= 395ms
30*3次,GC= 452ms
30次,所有总计耗时: 18184 损耗:16850 损耗比: 92.87%
--------------------------
50次bfIndexOf;总计耗时: 550ms
50次stringIndexOf;总计耗时: 335ms
50次KMPIndexOf;总计耗时: 450ms
50次allbuild= 26501ms
50次alltoArray= 637ms
50*3次,GC;总计耗时: 734ms
50次,所有总计耗时: 29211 损耗:27142 损耗比: 92.47%
--------------------------
从中可以看出来，使用StringBuilder构造字符串，800万*50次append大约消耗了26秒。换算下来每秒钟是1600万次。。。
看来是需要写一个专门计时的函数，本来Junit是有自己的统计的，但是样本不太好做。
如此看来，数据的准备，也就是测试用例的选取很关键,可能需要先生成并写入到文本文件中。
您可能感兴趣的文章:
上一篇：下一篇：
最 近 更 新
热 点 排 行}