Java 替换字符串中的字符，而不使用string Replace（）方法

我有一个字符串，

String originalString=“这辆车就是我的车”

我想将“car”替换为“bike”，而不使用字符串
replace（）
方法

class StringTest{
   public static void main(String[] args){
      String originalString = "This car is my car";
      String replacedString = replaceMethod(original, "car", "bike");
      System.out.println(replacedString);
   }  
}
static String replaceMethod( String original, String toReplace, String replacedWith){
    // enter code here
    return "";
}

您可以在“car”上拆分，然后通过添加“bike”连接

输出

This bike is my bike

感谢Polywhir先生的帮助。
这不是一个好方法，但我们也可以这样做

 public static void main(String[] args) {
      String org= "This car is my car";
      String [] temp=org.split(" ");
      int len=temp.length;
      String ne = "";
      for(int i=0;i<len;i++)
      {
          if(temp[i].matches("car"))
              temp[i]="bike";
          ne=ne+temp[i]+" ";

      }
        System.out.println(ne);
    }

publicstaticvoidmain（字符串[]args）{
String org=“这辆车是我的车”；
字符串[]temp=org.split（“”）；
int len=温度长度；
字符串ne=“”；
对于（inti=0；i试试这个

static String replaceMethod(String original, String toReplace,
        String replacedWith) {
    for(;;) {
        int i = original.indexOf(toReplace);
        if (i == -1) {
            break;
        }
        original = original.substring(0, i) + replacedWith + original.substring(i + toReplace.length());
    }
    return original;
}

或者更简单地复制粘贴Apache的StringUtils方法

public static String replace(String text, String searchString, String replacement, int max) {
    if (isEmpty(text) || isEmpty(searchString) || replacement == null || max == 0) {
        return text;
    }
    int start = 0;
    int end = text.indexOf(searchString, start);
    if (end == INDEX_NOT_FOUND) {
        return text;
    }
    int replLength = searchString.length();
    int increase = replacement.length() - replLength;
    increase = increase < 0 ? 0 : increase;
    increase *= max < 0 ? 16 : max > 64 ? 64 : max;
    StringBuilder buf = new StringBuilder(text.length() + increase);
    while (end != INDEX_NOT_FOUND) {
        buf.append(text.substring(start, end)).append(replacement);
        start = end + replLength;
        if (--max == 0) {
            break;
        }
        end = text.indexOf(searchString, start);
    }
    buf.append(text.substring(start));
    return buf.toString();
}

公共静态字符串替换（字符串文本、字符串搜索字符串、字符串替换、int max）{
if（isEmpty（text）| | isEmpty（searchString）| | replacement==null | | max==0）{
返回文本；
}
int start=0；
int end=text.indexOf（searchString，start）；
if（end==未找到索引）{
返回文本；
}
int replLength=searchString.length（）；
int increase=replacement.length（）-replLength；
增加=增加<0？0：增加；
增加*=最大值<0？16：最大值>64？64：最大值；
StringBuilder buf=新的StringBuilder（text.length（）+增加）；
while（end！=未找到索引）{
buf.append（text.substring（start，end））.append（replacement）；
开始=结束+长度；
如果（--max==0）{
打破
}
end=text.indexOf（searchString，start）；
}
buf.append（text.substring（start））；
返回buf.toString（）；
}
另一种选择

import java.util.*;

class Replace {
    public static void main (String[] args) {
        String originalString = "This car is my car";
        String replacedString = replaceMe(originalString, "car", "bike");
        System.out.println(replacedString);
    }

    public static String replaceMe(String str, String from, String to) {
        String[] arr = str.split(" ");
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].equals(from)) {
                arr[i] = to;
            }
        }
        return join(arr, " ");
    }

    public static String join(String[] arr, String delim) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            sb.append(arr[i]);

            if (i < arr.length - 1)
                sb.append(delim);
        }
        return sb.toString();
    }
}

import java.util.*；
类替换{
公共静态void main（字符串[]args）{
String originalString=“这辆车是我的车”；
字符串replacedString=replaceMe（原始字符串“car”、“bike”）；
系统输出打印项次（替换字符串）；
}
公共静态字符串替换名（字符串str、字符串from、字符串to）{
字符串[]arr=str.split（“”）；
对于（int i=0；i
假设这是一个家庭作业，您正在寻找一个算法（这就是为什么您不使用String.replace），请记住字符串和数组基本上是相同的，并且都可以迭代

一个简单（低效）的算法：

1.创建一个子方法，使子字符串与主字符串中的当前索引相匹配

private boolean matchAt(String inputString, String target, int index){
    // YOUR CODE HERE - returns 'true' if the target string occurs in the 
    // inputString at the specified index.
}

2.迭代输入字符串，测试每个字母是否找到目标单词

3.根据是否找到目标单词，每次向StringBuilder追加输出一个字符

要获得更高效的算法，请查看以下关于如何使用后缀匹配实现字符串搜索的链接：
只需使用
string.replace
。或使用匹配器和正则表达式（直接替换或使用appendReplacement/appendTail重建）。或者使用其他一次性的
索引/substring/split
并手动生成结果。我会坚持使用
字符串。除非有“好”字符，否则请替换
没有理由。它是
split
，而不是
splite
。谢谢@Polywhill先生，我刚刚更新了它。我刚刚验证了两次，我用输出更新了帖子哦，我明白了。它的工作原理是错误的输入巧合。试试：
“这辆车是我的车，我爱它”
不适用于“这辆车是我的车，哥们。”它会打印“这辆自行车是我的自行车，伙计。自行车”我会用StringBuilder来做这个。连接太多了。。。
import java.util.*;

class Replace {
    public static void main (String[] args) {
        String originalString = "This car is my car";
        String replacedString = replaceMe(originalString, "car", "bike");
        System.out.println(replacedString);
    }

    public static String replaceMe(String str, String from, String to) {
        String[] arr = str.split(" ");
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].equals(from)) {
                arr[i] = to;
            }
        }
        return join(arr, " ");
    }

    public static String join(String[] arr, String delim) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            sb.append(arr[i]);

            if (i < arr.length - 1)
                sb.append(delim);
        }
        return sb.toString();
    }
}

private boolean matchAt(String inputString, String target, int index){
    // YOUR CODE HERE - returns 'true' if the target string occurs in the 
    // inputString at the specified index.
}