Question

这些是该方法的说明：

// Given a character, a String containing a word, and a String containing a 'guess'
// for that word, return a new String that is a modified version of the 'guess' 
// string where characters equal to the character inChar are uncovered.
// For example, given the following call:
//   modfiyGuess('G',"GEOLOGY", "**O*O*Y")
// This functions should return the String "G*O*OGY".

这是我的代码：

private static String modifyGuess(char inChar, String word, String currentGuess) {
    int count= 0;
    int occur= 0;
    while (count < word.length()-1)
    {
        if(!(word.charAt(count)== inChar)){

            count++;
        }
        else if(word.charAt(count)==inChar)
        {
            currentGuess= currentGuess.replace(currentGuess.charAt(count), inChar);
            occur++;
            count++;
        }
    }
    System.out.println("The character " +inChar +" occurs in " +occur +" positions");
    System.out.println(" ");
    return currentGuess;
}

由于某种原因，如果在字符串单词中找到char inChar，则currentGuess将返回为类似“GGGGGG”的字符串，用inChar替换字符串中的所有字符，而不是返回类似“G *** ” 感谢您的任何答案！

Answer 1

如果是我，我会选择使用for循环，而不是一段时间，它实际上是个人偏好，但因为你需要迭代整个字符串，它可以更直观，更容易理解读者使用for时。

似乎你的条件是彼此相反的。检查不是否等于char，然后检查是否。为什么不检查它是否是，那么你知道不是。这里的字符串构建器用于构建字符串。如果要替换它，如果不是，我们会追加结果（调整名称，这样你就必须来使用它。）

public static String modifyGuess(char letter, String word, String result) {
    int occurrences = 0;
    StringBuilder builder = new StringBuilder();
    for(int i = 0; i < word.length(); ++i) {
        if(word.charAt(i) == letter) {
            builder.append(letter);
            occurrences++;
        } else {
            builder.append(result.charAt(i));
        }
    }
    System.out.println("\nThe character " + letter +" occurs in " + occurrences +" positions\n");
    return builder.toString();
}

public static void main(String[] args){
    String word = "GEOLOGY";
    String result = "**OLO**";

    result = modifyGuess('G', word, result);
    System.out.println(result);
    result = modifyGuess('E', word, result);
    System.out.println(result);
    result = modifyGuess('Y', word, result);
    System.out.println(result);
}//SSCCE1

输出：

角色G出现在2个位置

G * OLOG *

字符E出现在1个位置

GEOLOG *

字符Y出现在1个位置

地质

Answer 2

有几种方法可以实现这一目标。最重要的是要记住String是不可变的，也就是说，它的内容是无法改变的。

在原始代码中，您正在使用

currentGuess= currentGuess.replace(currentGuess.charAt(count), inChar);

根据你的例子，就像说，用“G”代替“*”，这会产生"GGOGOGY"，而不是你想要的。

相反，您需要创建一种临时位置，您可以在其中构建新的“猜测”，例如......

public static String modifyGuess(char inChar, String word, String currentGuess) {
    String newGuess = "";
    for (int index = 0; index < word.length(); index++) {
        if (word.charAt(index) == inChar) {
            newGuess += word.charAt(index);
        } else {
            newGuess += currentGuess.charAt(index);
        }
    }
    return newGuess;
}

现在，虽然这有效，但这会产生很多临时String对象的问题。在一个小的，短暂的应用程序中，这可能不是问题，但在大型，运行时间较长的应用程序中，这会成为一个问题，因为它会随着时间的推移而降低性能，相反，您可以做一些事情......

public static String modifyGuess(char inChar, String word, String currentGuess) {
    char[] newGuess = new char[word.length()];
    for (int index = 0; index < word.length(); index++) {
        if (word.charAt(index) == inChar) {
            newGuess[index] = word.charAt(index);
        } else {
            newGuess[index] = currentGuess.charAt(index);
        }
    }
    return new String(newGuess);
}

每次创建时，这只会创建一个新的String。我可能遇到的唯一问题是，word可能会比currentGuess更长/您可以通过更改newGuess[index] = currentGuess.charAt(index);与newGuess[index] = "*"来防范这种情况。 ..

最后，我首选的方法是使用StringBuilder，因为它具有char数组的好处，因为它不会创建大量临时String s ，但没有char数组的限制，例如

public class GuessString {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        System.out.println(modifyGuess('G',"GEOLOGY", "**O*O*Y"));
    }

    public static String modifyGuess(char inChar, String word, String currentGuess) {
        StringBuilder sb = new StringBuilder(currentGuess);
        for (int index = 0; index < word.length(); index++) {
            if (word.charAt(index) == inChar) {
                sb.replace(index, index, Character.toString(inChar));
            }
        }
        return sb.toString();
    }

}

基本上，我使用currentGuess并使用StringBuilder创建它的副本。然后我继续执行匹配检查，在找到它们时替换各个匹配

Answer 3

我想我理解你的问题。如果我错了，请纠正我：你有一个正确答案的字符串和一串代表到目前为止的猜测的字符。我假设“*”是一个通配符，意思是任何字母。请在下次尝试更具体，以便我们更快地回答。试试这段代码（它可以正常使用你的例子）：

private static String modifyGuess(char inChar, String word, String currentGuess) {
    int occurences = 0;
    char[] wordArray = word.toCharArray();
    char[] guessArray = currentGuess.toCharArray();
    for (int i = 0; i < guessArray.length; i++) {
        if (guessArray[i] == '*') {
            if (wordArray[i] == inChar) {
                guessArray[i] = inChar;
                occurences++;
            }
        }
    }
    System.out.println("The character " + inChar + " occurs in " + occurences + " positions.");
    System.out.println(" ");
    return new String(guessArray);
}

此解决方案获取char和word的{{1}}数组。然后循环遍历数组或currentGuess并检查当前字符是否为通配符。如果是，则检查currentGuess中的相同位置是否与word相同。这意味着该字符的猜测是正确的。然后，它会更新inChar以将通配符更改为guess并增加出现次数。您也可以使用inChar，但我不确定您是否被允许使用。

顺便说一句，StringBuilder将所有“*”替换为“G”，无论它们在何处。

希望这有帮助！ :)

Answer 4

猜猜你做作业迟到了吗？

//The StringBuilder lets you set a character at a given index
StringBuilder b = new StringBuilder(currentGuess);

//Let's look at every single character in word...
for(int i = 0; i < word.length(); i++) {
    //If the character in word is equal to the character to be uncovered, ...
    if(word.charAt(i) == inChar) {
        //we change the character in the resulting word.
        b.setCharAt(i, inChar);
    }
}
//And return the result
return b.toString();

如何使用char作为输入替换“****”字符串中的某个字符？ Java的

4 个答案: