Java 在不使用数组的情况下删除字符串中的重复项 String input=“AAAB”； 字符串输出=”； 对于（int index=0；index

但如果我的输入是“ABABAB”或仅仅是“AAAA”，它就不起作用。有什么想法吗？

使用数据结构来了解是否已找到字符，例如。例如，您可以使用其方法并检查其返回值

也可以考虑使用重复级联，这样效率更高。

    String input = "AAAB";

    String output = "";
    for (int index = 0; index < input.length(); index++) {
        if (input.charAt(index % input.length()) != input
                .charAt((index + 1) % input.length())) {

            output += input.charAt(index);

        }
    }
    System.out.println(output);

Set characters=newhashset（）；
字符串输入=“AAAB”；
StringBuilder输出=新的StringBuilder（）；
对于（int index=0；index

使用数据结构了解是否已找到字符，例如。例如，您可以使用其方法并检查其返回值

也可以考虑使用重复级联，这样效率更高。

    String input = "AAAB";

    String output = "";
    for (int index = 0; index < input.length(); index++) {
        if (input.charAt(index % input.length()) != input
                .charAt((index + 1) % input.length())) {

            output += input.charAt(index);

        }
    }
    System.out.println(output);

Set characters=newhashset（）；
字符串输入=“AAAB”；
StringBuilder输出=新的StringBuilder（）；
对于（int index=0；index

（我希望你指的是重复，而不是重复。）

不带重复项的公共静态字符串（字符串s）{
对于（int i=0；i=1；
--重复长度）{
如果（发现重复（s、i、重复长度））{
s=s.子串（0，i）+s.子串（i+长度）；
removedDuplicate=true；
打破
}
}
如果（！removedDuplicate）{
++一,；
}
}
返回s；
}
私有静态布尔foundDuplicate（字符串s、int i、int duplicateLength）{
寻找的字符串=s.子字符串（i，i+重复长度）；
返回s.indexOf（已寻道，i+duplicateLength）！=-1；
}

---

更正：重复长度初始化值超出范围。

（我希望您指的是重复，而不是重复。）

不带重复项的公共静态字符串（字符串s）{
对于（int i=0；i=1；
--重复长度）{
如果（发现重复（s、i、重复长度））{
s=s.子串（0，i）+s.子串（i+长度）；
removedDuplicate=true；
打破
}
}
如果（！removedDuplicate）{
++一,；
}
}
返回s；
}
私有静态布尔foundDuplicate（字符串s、int i、int duplicateLength）{
寻找的字符串=s.子字符串（i，i+重复长度）；
返回s.indexOf（已寻道，i+duplicateLength）！=-1；
}

---

---

更正：重复长度初始化值超出范围。

针对速度版本进行了优化

public static String withoutDuplicates(String s) {
    for (int i = 0; i < s.length(); ) {
        boolean removedDuplicate = false;
        for (int duplicateLength = (s.length() - i) / 2; duplicateLength >= 1; 
                --duplicateLength) {
            if (foundDuplicate(s, i, duplicateLength)) {
                s = s.substring(0, i) + s.substring(i + duplicateLength);
                removedDuplicate = true;
                break;
            }
        }
        if (!removedDuplicate) {
            ++i;
        }
    }
    return s;
}

private static boolean foundDuplicate(String s, int i, int duplicateLength) {
    String sought = s.substring(i, i + duplicateLength);
    return s.indexOf(sought, i + duplicateLength) != -1;
}

publicstaticvoidmain（字符串[]args）{
字符串输入=“AAAB”；
StringBuilder输出=新的StringBuilder（）；
对于（int i=0；i

针对速度版进行了优化

public static String withoutDuplicates(String s) {
    for (int i = 0; i < s.length(); ) {
        boolean removedDuplicate = false;
        for (int duplicateLength = (s.length() - i) / 2; duplicateLength >= 1; 
                --duplicateLength) {
            if (foundDuplicate(s, i, duplicateLength)) {
                s = s.substring(0, i) + s.substring(i + duplicateLength);
                removedDuplicate = true;
                break;
            }
        }
        if (!removedDuplicate) {
            ++i;
        }
    }
    return s;
}

private static boolean foundDuplicate(String s, int i, int duplicateLength) {
    String sought = s.substring(i, i + duplicateLength);
    return s.indexOf(sought, i + duplicateLength) != -1;
}

publicstaticvoidmain（字符串[]args）{
字符串输入=“AAAB”；
StringBuilder输出=新的StringBuilder（）；
对于（int i=0；i

让我们看看您的循环在做什么：

public static void main(String[] args) {
    String input = "AAAB";
    StringBuilder output = new StringBuilder();
    for (int i = 0; i < input.length(); i++) {
        if (!contains(output, input.charAt(i))) {
            output.append(input.charAt(i));
        }
    }
    System.out.println(output);
}

private static boolean contains(StringBuilder output, char c) {
    for(int i = 0; i < output.length();  i++) {
        if (output.charAt(i) == c) {
            return true;
        }
    }
    return false;
}

1） 首先，您应该认识到执行“%input.length（）”操作是在浪费时间和处理能力，因为索引总是小于input.length（），所以索引%input.length（）总是等于index

让我们继续忽略%input.length（）

2） 当您将input.charAt（索引）与input.charAt（索引+1）进行比较时，您只是将当前字符与下一个字符进行比较。如果我理解正确，原始问题要求您删除所有重复项，而不仅仅是相邻的重复项

3） 您的算法很可能会引发IndexOutOfBounds异常，因为当您到达字符串末尾（当index==input.length（）-1）检查input.charAt（index+1）时，字符串中的一个字符看起来太远

---

正如第一个答案所建议的，您需要利用某种形式的数据结构来存储遇到的所有不同字符。每当您点击一个新字符时，您都会希望a）将其添加到数据结构中，b）将其添加到输出的末尾。

让我们看看您的循环在做什么：

public static void main(String[] args) {
    String input = "AAAB";
    StringBuilder output = new StringBuilder();
    for (int i = 0; i < input.length(); i++) {
        if (!contains(output, input.charAt(i))) {
            output.append(input.charAt(i));
        }
    }
    System.out.println(output);
}

private static boolean contains(StringBuilder output, char c) {
    for(int i = 0; i < output.length();  i++) {
        if (output.charAt(i) == c) {
            return true;
        }
    }
    return false;
}

if (input.charAt(index % input.length()) != input
  .charAt((index + 1) % input.length()))

1） 首先，您应该认识到执行“%input.length（）”操作是在浪费时间和处理能力，因为索引总是小于input.length（），所以索引%input.length（）总是等于index