我必须比较两个字符串数组。如果myArray中的任何字符与argArray中的字符匹配，那么我需要交换myArray中的字符的大小写。我几乎做到了，但是得到了额外的输出。
到目前为止，我的代码如下 -
```java
public class Main {
    public static void main(String[] args) {
        Main ob = new Main();
        ob.reverse("bcdxyz@3210.");
    }
    public String reverse(String arg) {
        String reverseCap = "";
        String myStr = "abc, XYZ; 123.";
        char[] argArray = arg.toCharArray();
        char[] myArray = myStr.toCharArray();
        for (int i =0; i < myArray.length; i++) {
            for (int j =0; j < argArray.length; j++){
                if (myArray[i] == argArray[j] && Character.isLowerCase(myArray[i])){
                    reverseCap += Character.toUpperCase(myArray[i]);
                } else if (myArray[i] == argArray[j] && Character.isUpperCase(myArray[i])){
                    reverseCap += Character.toLowerCase(myArray[i]);
                } else {
                    reverseCap += myArray[i];
                }
            }
        }
        System.out.println(reverseCap);
        return null;
    }
}

"aBC, xyz, 123."

<details>
<summary>英文:</summary>
I have to compare two string arrays. If the any of the characters in myArray match a character in argArray then I need to swap the case of the character in myArray. I&#39;m almost there but am getting extra output. 
This is what I have so far - 

    Main ob = new Main();
    ob.reverse("bcdxyz@3210.");
}
public String reverse(String arg) {
    String reverseCap = "";
    String myStr = "abc, XYZ; 123.";
    char[] argArray = arg.toCharArray();
    char[] myArray = myStr.toCharArray();
    for (int i =0; i < myArray.length; i++) {
        for (int j =0; j < argArray.length; j++){
            if (myArray[i] == argArray[j] && Character.isLowerCase(myArray[i])){
                reverseCap += Character.toUpperCase(myArray[i]);
            } else if (myArray[i] == argArray[j] && Character.isUpperCase(myArray[i])){
                reverseCap += Character.toLowerCase(myArray[i]);
            } else {
                reverseCap += myArray[i];
            }
        }
    }
    System.out.println(reverseCap);
    return null;
}

I want reverseCap to be "aBC, xyz, 123." but am getting the following - 

I've been staring at this for hours so I figured it was time to ask for help before I pluck my eyes out. 
</details>
# 答案1
**得分**: 0
你正在每次迭代时都向`reverseCap`添加一个字符，无论字符是否匹配。在你的特定示例中，你可以直接去掉这部分，因为`myStr`中的每个字符也出现在`arg`中，但如果你想要添加字符到`reverseCap`，即使它们不在`arg`中出现，你需要一种方法来检查是否已经向`reverseCap`添加了字符。
<details>
<summary>英文:</summary>
With this part
    } else {
        reverseCap += myArray[i];
    }
you&#39;re adding a character to `reverseCap` with every iteration, regardless if the characters match or not.
In your specific example, you could just leave that out, since every character in `myStr` also appears in `arg`, but if you want to add characters to `reverseCap`, even if they don&#39;t appear in `arg`, you&#39;ll need a way of checking if you already added a character to `reverseCap`.
</details>
# 答案2
**得分**: 0
Sure, here's the translated code:
更改
```java
String reverseCap = "";

char[] reverseCap = new char[myStr.length()];

reverseCap +=

reverseCap[i] =

String result = String.valueOf(reverseCap);

/**
 * 示例：对于字符串 "bcdxyz@3210."
 * 查找映射如下
 * {B=b, b=B, C=c, c=C, D=d, d=D, X=x, x=X, Y=y, y=Y, Z=z, z=Z}
 * <p>
 * 使用映射来获取字符的逆比重复循环字符串要快。
 * </p>
 * @param arg
 * @return
 */
public String reverse2(String arg) {
    Map<Character, Character> inverseLookup = createInverseLookupMap(arg);
    
    String myStr = "abc, XYZ; 123.";
    String result = myStr.chars()
        .mapToObj(ch -> Character.toString(inverseLookup.getOrDefault(ch, (char) ch)))
        .collect(Collectors.joining());
    return result;
}
private Map<Character, Character> createInverseLookupMap(String arg) {
    Map<Character, Character> lookupMap = arg.chars()
        .filter(ch -> Character.isLetter(ch))
        .mapToObj(this::getPairs)
        .flatMap(List::stream)
        .collect(Collectors.toMap(Pair::key, Pair::value));
    System.out.println(lookupMap);
    return lookupMap;
}
private List<Pair> getPairs(int ch) {
    char upperVariant = (char) Character.toUpperCase(ch);
    return List.of(
        new Pair(upperVariant, Character.toLowerCase(upperVariant)),
        new Pair(Character.toLowerCase(upperVariant), upperVariant));
}
static record Pair(Character key, Character value) {
}

public class Main {
    public static void main(String[] args) {
        Main ob = new Main();
        String testStr = "abc, XYZ; 123.";
        String testArg = "bcdxyz@3210.";
        System.out.println(testStr + " using " + testArg + " =>");
        System.out.println(ob.reverse(testStr, testArg));
    }
    public String reverse(String myStr, String myArg) {
        char[] myArray = myStr.toCharArray();
        char[] argArray = myArg.toCharArray();
        for (int i = 0; i < myArray.length; i++) {
            for (int j = 0; j < argArray.length; j++) {
                if (Character.toLowerCase(myArray[i]) == argArray[j]) {
                    if (Character.isLowerCase(myArray[i])) {
                        myArray[i] = Character.toUpperCase(myArray[i]);
                    } else if (Character.isUpperCase(myArray[i])) {
                        myArray[i] = Character.toLowerCase(myArray[i]);
                    }
                    break;
                }
            }
        }
        return String.valueOf(myArray);
    }
}