如何在Java字符串中保留匹配的子字符串并替换不匹配的子字符串

您好，我尝试打印字符串数组 以以下方式：

• 输入：big=“12xy34”，small=“xy”输出：**xy**
• 输入：大=“12xt34”，小=“xy”输出：******”
• 输入：big=“12xy34”，small=“1”输出：“1*****”
• 输入：big=“12xy34xyabcxy”，small=“xy”输出：“**xy**xy***xy”
• 输入：big=“78abcd78cd”，small=“78”输出：“78****78**”

我需要写一个条件来接收什么

 public static String stars(String big, String small) {
      //throw new RuntimeException("not implemented yet ");
     char[] arr = big.toCharArray();
    for (int i = 0; i < arr.length; i++) {
        if (big.contains(small) ) {
            arr[i] = '*';
        }
    }
        String a = Arrays.toString(arr);
     return big+""+a;

公共静态字符串星形（字符串大，字符串小）{
//抛出新的RuntimeException（“尚未实现”）；
char[]arr=big.toCharArray（）；
对于（int i=0；i

}

算法：

public class StringRetainer {

    public static void main(String args[]) {
        String big[] = {"12xy34", "12xt34", "12xy34", "12xy34xyabcxy", "78abcd78cd"};
        String small[] = {"xy", "xy", "1", "xy", "78"};
        for(int i = 0; i < big.length & i < small.length; i++) {
            System.out.println("Input: big = \"" + big[i] + "\", small = \"" + small[i] + "\" output : \"" + stars(big[i], small[i]) + "\"");
        }
    }

    public static String stars(String big, String small) {
        //String to char[] array conversions
        char[] bigC = big.toCharArray();
        char[] smallC = small.toCharArray();
        //iterate through every character of big String and selectively replace
        for(int i = 0; i < bigC.length; i++) {
            //flag to determine whether small String occurs in big String
            boolean possibleSubString = true;
            int j = 0;
            //iterate through every character of small String to determine
            //the possibility of character replacement
            for(; j < smallC.length && (i+j) < bigC.length; j++) {
                //if there is a mismatch of at least one character in big String
                if(bigC[i+j] != smallC[j]) {
                    //set the flag indicating sub string is not possible and break
                    possibleSubString = false;
                    break;
                }
            }
            //if small String is part of big String,
            //advance the loop index with length of small String
            //replace with '*' otherwise
            if(possibleSubString)
                i = i+j-1;
            else
                bigC[i] = '*';
        }
        big = String.copyValueOf(bigC);
        return big;
    }

}

将

big

和

small

字符串的分别转换为

char[]

数组的

bigC

和

smallC

迭代

big

字符串的每个字符

在迭代过程中的每个索引处，确定当前字符开头是否存在子字符串

如果存在子字符串的可能性，则将

big

字符串迭代中的索引提前

small

字符串的长度

否则，用替换字符*

代码：

public class StringRetainer {

    public static void main(String args[]) {
        String big[] = {"12xy34", "12xt34", "12xy34", "12xy34xyabcxy", "78abcd78cd"};
        String small[] = {"xy", "xy", "1", "xy", "78"};
        for(int i = 0; i < big.length & i < small.length; i++) {
            System.out.println("Input: big = \"" + big[i] + "\", small = \"" + small[i] + "\" output : \"" + stars(big[i], small[i]) + "\"");
        }
    }

    public static String stars(String big, String small) {
        //String to char[] array conversions
        char[] bigC = big.toCharArray();
        char[] smallC = small.toCharArray();
        //iterate through every character of big String and selectively replace
        for(int i = 0; i < bigC.length; i++) {
            //flag to determine whether small String occurs in big String
            boolean possibleSubString = true;
            int j = 0;
            //iterate through every character of small String to determine
            //the possibility of character replacement
            for(; j < smallC.length && (i+j) < bigC.length; j++) {
                //if there is a mismatch of at least one character in big String
                if(bigC[i+j] != smallC[j]) {
                    //set the flag indicating sub string is not possible and break
                    possibleSubString = false;
                    break;
                }
            }
            //if small String is part of big String,
            //advance the loop index with length of small String
            //replace with '*' otherwise
            if(possibleSubString)
                i = i+j-1;
            else
                bigC[i] = '*';
        }
        big = String.copyValueOf(bigC);
        return big;
    }

}

公共类{
公共静态void main（字符串参数[]）{
字符串大[]={“12xy34”、“12xt34”、“12xy34”、“12xy34xyabcxy”、“78abcd78cd”}；
字符串小[]={xy”，“xy”，“1”，“xy”，“78”}；
对于（int i=0；i

注意：

public class StringRetainer {

    public static void main(String args[]) {
        String big[] = {"12xy34", "12xt34", "12xy34", "12xy34xyabcxy", "78abcd78cd"};
        String small[] = {"xy", "xy", "1", "xy", "78"};
        for(int i = 0; i < big.length & i < small.length; i++) {
            System.out.println("Input: big = \"" + big[i] + "\", small = \"" + small[i] + "\" output : \"" + stars(big[i], small[i]) + "\"");
        }
    }

    public static String stars(String big, String small) {
        //String to char[] array conversions
        char[] bigC = big.toCharArray();
        char[] smallC = small.toCharArray();
        //iterate through every character of big String and selectively replace
        for(int i = 0; i < bigC.length; i++) {
            //flag to determine whether small String occurs in big String
            boolean possibleSubString = true;
            int j = 0;
            //iterate through every character of small String to determine
            //the possibility of character replacement
            for(; j < smallC.length && (i+j) < bigC.length; j++) {
                //if there is a mismatch of at least one character in big String
                if(bigC[i+j] != smallC[j]) {
                    //set the flag indicating sub string is not possible and break
                    possibleSubString = false;
                    break;
                }
            }
            //if small String is part of big String,
            //advance the loop index with length of small String
            //replace with '*' otherwise
            if(possibleSubString)
                i = i+j-1;
            else
                bigC[i] = '*';
        }
        big = String.copyValueOf(bigC);
        return big;
    }

}

这是一种可能的解决方案（传统做法）

似乎没有直接的方法可以使用内置的

String

/

StringBuffer

/

StringBuilder

方法实现这一点

---

您的java程序不完整，格式糟糕，无法真正解释事情应该如何进行。不清楚如何帮助你。