Fatal编程技术网
  • java/
  • Java 字符串中字符替换的高效算法

Java 字符串中字符替换的高效算法

java algorithm

Java 字符串中字符替换的高效算法,java,algorithm,Java,Algorithm,我有两条线 111TTT0000TT11T00 001101 现在我想用字符串2中的字符替换字符串1中T的所有外观。比如第一个T带0，第二个T带0，第三个T带1等等 一种方法是使用while循环并比较每个字符，但从编程的角度来看，这并不是一种很好的实现方法。有人能用JAVA用更好的算法解决这个问题吗 public void DataParse(String point, String code) { //////////tln("Point:"+point); ////////

我有两条线

  • 111TTT0000TT11T00
  • 001101
    • 现在我想用字符串2中的字符替换字符串1中T的所有外观。比如第一个T带0，第二个T带0，第三个T带1等等

    一种方法是使用while循环并比较每个字符，但从编程的角度来看，这并不是一种很好的实现方法。有人能用JAVA用更好的算法解决这个问题吗

    public void DataParse(String point, String code)
{

    //////////tln("Point:"+point);
    //////////tln("code:"+code);
    //  //////////tln(baseString_temp);

    int counter=0;

    while(baseString_temp.contains(point))
    {      
        if(code!=null)
        {
            String input=String.valueOf(code.charAt(counter));
            //zzzzz(input);


            baseString_temp=baseString_temp.replaceFirst(point,input);
            counter=counter+1;
        }
    }

    ////////////System.out(baseString_temp);
}
    有几件事。因为字符串是不可变的

    baseString_temp=baseString_temp.replaceFirst(point,input);
    将始终创建一个新的
    字符串
    对象（同时，它从一开始就遍历字符串，查找
    点
    ）。如果使用
    StringBuilder
    ，则只需分配一次内存，然后就可以对其进行变异。实际上，使用Ken的答案中的数组会更好，因为它分配的资源更少，方法调用的开销也更少

    另外，我可以想象
    contains（）
    使用自己的循环，在最坏的情况下，循环到字符串的末尾。您只需要在字符串上迭代一次，并在继续时替换

    工作示例：

    public class Test {

  private static String replace(char what, String input, String repls) {
    StringBuilder sb = new StringBuilder(input);
    int replIdx = 0;
    for (int i = 0; i < input.length(); i++) {
      if (input.charAt(i) == what) {
        sb.setCharAt(i, repls.charAt(replIdx++));
      }
    }
    return sb.toString();
  }

  public static void main(String[] args) {
    System.out.println(replace('T', "111TTT0000TT11T00", "001101"));
  }
}

    公共类测试{
私有静态字符串替换（char what、字符串输入、字符串repls）{
StringBuilder sb=新的StringBuilder（输入）；
int replIdx=0；
对于（int i=0；i
    有几件事。因为字符串是不可变的

    baseString_temp=baseString_temp.replaceFirst(point,input);
    将始终创建一个新的
    字符串
    对象（同时，它从一开始就遍历字符串，查找
    点
    ）。如果使用
    StringBuilder
    ，则只需分配一次内存，然后就可以对其进行变异。实际上，使用Ken的答案中的数组会更好，因为它分配的资源更少，方法调用的开销也更少

    另外，我可以想象
    contains（）
    使用自己的循环，在最坏的情况下，循环到字符串的末尾。您只需要在字符串上迭代一次，并在继续时替换

    工作示例：

    public class Test {

  private static String replace(char what, String input, String repls) {
    StringBuilder sb = new StringBuilder(input);
    int replIdx = 0;
    for (int i = 0; i < input.length(); i++) {
      if (input.charAt(i) == what) {
        sb.setCharAt(i, repls.charAt(replIdx++));
      }
    }
    return sb.toString();
  }

  public static void main(String[] args) {
    System.out.println(replace('T', "111TTT0000TT11T00", "001101"));
  }
}

    公共类测试{
私有静态字符串替换（char what、字符串输入、字符串repls）{
StringBuilder sb=新的StringBuilder（输入）；
int replIdx=0；
对于（int i=0；i
    每次使用
    contains
    和
    replaceFirst
    时，都会强制程序从开头枚举字符串的字符。我相信最好是一次通过：

    public static String replaceToken(String primary, String secondary, char token) {

   char [] charArray =primary.toCharArray();

   int counter = 0;
   for(int i=0; i<charArray.length; i++){
       if(charArray[i]==token){
           charArray[i] = secondary.charAt(counter);
           counter++;
           if(counter>=secondary.length()) break;
       }
   }
   return new String(charArray);
}    


public static void main(String[] args) {       
   String result = replaceToken("111TTT0000TT11T00", "001101", 'T');
}

    publicstaticstringreplacetoken（stringprimary、stringsecondary、char-token）{
char[]charArray=primary.toCharArray（）；
int计数器=0；
对于（int i=0；i=secondary.length（））中断；
}
}
返回新字符串（charArray）；
}    
公共静态void main（字符串[]args）{
字符串结果=replaceToken（“111TTT0000TT11T00”，“001101”，“T”）；
}
    如果您真的非常想使用RegExp，那么您可以：

    public static String replaceSequence(String primary, String secondary, String sequence){

    Pattern pattern = Pattern.compile(sequence + "+");
    Matcher matcher = pattern.matcher(primary);

    int counter = 0;
    char [] charArray = primary.toCharArray();

    while(matcher.find() && counter<secondary.length()){
        for(int i = matcher.start(); i<matcher.end(); i++){
            charArray[i] = secondary.charAt(counter++);
            if(counter>=secondary.length()) break;
        }
    }
    return new String(charArray);
}

    publicstaticstringreplaceSequence（stringprimary、stringsecondary、stringsequence）{
Pattern=Pattern.compile（序列+“+”）；
Matcher Matcher=pattern.Matcher（主）；
int计数器=0；
char[]charArray=primary.toCharArray（）；

    而（matcher.find（）&&counter每次使用
    contains
    和
    replaceFirst
    时，都会强制程序从一开始就枚举字符串的字符。我相信最好是一次完成：
    

    public static String replaceToken(String primary, String secondary, char token) {

   char [] charArray =primary.toCharArray();

   int counter = 0;
   for(int i=0; i<charArray.length; i++){
       if(charArray[i]==token){
           charArray[i] = secondary.charAt(counter);
           counter++;
           if(counter>=secondary.length()) break;
       }
   }
   return new String(charArray);
}    


public static void main(String[] args) {       
   String result = replaceToken("111TTT0000TT11T00", "001101", 'T');
}

    

    publicstaticstringreplacetoken（stringprimary、stringsecondary、char-token）{
char[]charArray=primary.toCharArray（）；
int计数器=0；
对于（int i=0；i=secondary.length（））中断；
}
}
返回新字符串（charArray）；
}    
公共静态void main（字符串[]args）{
字符串结果=replaceToken（“111TTT0000TT11T00”，“001101”，“T”）；
}

    

    
如果您真的非常想使用RegExp，那么您可以：
    

    public static String replaceSequence(String primary, String secondary, String sequence){

    Pattern pattern = Pattern.compile(sequence + "+");
    Matcher matcher = pattern.matcher(primary);

    int counter = 0;
    char [] charArray = primary.toCharArray();

    while(matcher.find() && counter<secondary.length()){
        for(int i = matcher.start(); i<matcher.end(); i++){
            charArray[i] = secondary.charAt(counter++);
            if(counter>=secondary.length()) break;
        }
    }
    return new String(charArray);
}

    

    publicstaticstringreplaceSequence（stringprimary、stringsecondary、stringsequence）{
Pattern=Pattern.compile（序列+“+”）；
Matcher Matcher=pattern.Matcher（主）；
int计数器=0；
char[]charArray=primary.toCharArray（）；

    while（matcher.find（）&&counter）“但在编程意义上，这不是实现它的好方法”。为什么？另外，请先发布一些您尝试的代码，以便我们可以从那里为您提供指导。因为它涉及遍历整个字符串，读取每个字符，比较它，然后替换。如果有人能够更好地对其进行算法计算。没有理由避免循环。无论如何，您都需要读取每个字符。没有检查和更改数据的方法但是不要读它。如果不读它，我就不知道如何知道一个字符是“不是”。基本上，唯一的方法是遍历第一个字符串，并在第二个字符串中保留一个指针。任何搜索某个字符的高级函数调用都是非常昂贵的。它们也遍历字符串。因此，多个调用都会失败导致多次扫描。“但从编程的角度来看，这不是一个好的实现方式”。为什么？另外，请先发布一些您尝试的代码，以便我们可以从那里为您提供指导。因为它涉及遍历整个字符串，读取每个字符，比较它，然后替换。如果有人能够更好地对其进行算法计算。没有理由避免循环。无论如何，您都需要读取每个字符。没有检查和更改数据的方法但是不要读它。如果不读它，我就不知道如何知道一个角色是不是。基本上唯一的方法就是