Java 如果相邻字符相同，则仅打印重复字符

我是java编程新手，我的要求是

输入：“aaabaccuou” 输出：“aaaccuuu”

仅返回重复字符，如果该字符与前一个字符不相邻，则避免

我已经尝试了下面的代码。但它的输出是“aaaabccuuuuo”

这不考虑相邻字符。请帮助我

import java.util.LinkedHashSet;
import java.util.Set;

public class Sort {




              public static void main(String[] args) {
                     String str = "aaavvvtccatz";
                     int i =0;
                     String o = "";
                     String lo = "";
                     int count = 0 ;

                     char[] chars = str.toCharArray();
                     Set<Character> charSet = new LinkedHashSet<Character>();
                     for (char c : chars) {
                         charSet.add(c);
                     }

                     StringBuilder sb = new StringBuilder();
                     for (Character character : charSet) {
                         sb.append(character);
                     }
                     /*System.out.println(sb.toString());*/


                     for(int j =0;j<sb.length();j++)
                     {

                           String a = sb.substring(j,j+1);

                           for(i=0;i<str.length();i++)
                           {

                                  String b = str.substring(i, i+1);
                                  if(b.equals(a) )
                                  {
                                         count = count +1;
                                         lo = lo + a;


                                  }
                                  else
                                  {
                                         count = count;



                                  }


                           }

                           /*System.out.println(a);*/
                           /*System.out.println(count);*/

                           if(count > 1 )
                           {
                                  for(int h =0; h <count ;h++)
                                  {
                                         o = o + a ;
                                  }


                           }


                           count = 0;



                     }
                     System.out.println(o);






              }
}

import java.util.LinkedHashSet；
导入java.util.Set；
公共类排序{
公共静态void main（字符串[]args）{
字符串str=“aaavvvtccatz”；
int i=0；
字符串o=“”；
字符串lo=“”；
整数计数=0；
char[]chars=str.toCharArray（）；
Set charSet=new LinkedHashSet（）；
for（char c:chars）{
添加（c）；
}
StringBuilder sb=新的StringBuilder（）；
for（字符：字符集）{
某人附加（字符）；
}
/*System.out.println（sb.toString（））*/
对于（int j=0；j我在编写以下代码时遵循的逻辑可以总结如下：


将接收到的字符串转换为可以迭代的格式
迭代时，将每个字符与前一个字符进行比较，并将其添加到输出字符串中
由于这将跳过已找到序列的第一个字符，因此我们必须跟踪是否已找到序列，以便添加其他字符。此字符表示已跳过的字符

代码：

publicstaticvoidmain（字符串[]args）{
System.out.println（getRepeatingChars（“aaabaccuuou”）；
}
公共静态字符串getRepeatingChars（字符串testString）{
if（testString==null | | testString.equals（“”| | testString.length（）==1）{
返回“”；
}
String resultString=新字符串（）；
char[]charArray=testString.toCharArray（）；
布尔isInSequance=false；
对于（inti=1；i
以下代码背后的总体思路是：


查看
index=0
是不相关的，因为它并不真正符合用例的标准
我们使用
StringBuilder
，以便改进字符串的压缩
如果上一个字母已经被追加，则重置旨在标记上一个字母。如果没有重置，我们将看到重复的字符
上一个字符==
字符[x-1]
和当前字符==
字符[x]

你可以试试这个

 public static void main(String[] args) {
        String str = "aaabaccuuuouu";
        StringBuilder builder = new StringBuilder();
        char[] chars = str.toCharArray();
        boolean unreset = true;
        for (int x = 1; x < chars.length; x++) {
            if (chars[x - 1] == chars[x]) {
                if (unreset) {
                    builder.append(chars[x - 1]);
                    unreset = false;
                }
                builder.append(chars[x]);
            } else {
                unreset = true;
            }
        }
        System.out.println(builder.toString());
 }

publicstaticvoidmain（字符串[]args）{
String str=“aaabaccuouu”；
StringBuilder=新的StringBuilder（）；
char[]chars=str.toCharArray（）；
布尔unset=true；
对于（int x=1；x

示例测试用例：输入：aabaccuuuu输出：aaacuuuu

欢迎使用Stack Overflow！看起来您需要学习使用调试器。请自便。如果之后您仍然有问题，请随时返回以演示您的问题。问题是关于某些
IndexOutOfBoundsException
？@RC。我没有收到任何错误作为IndexOutOfBoundException是什么你的问题？你是否面临任何异常，或者逻辑没有按预期工作？@Uma Kanth:是的，逻辑没有按预期工作。它没有考虑相邻字符进行比较。如果输入是：aaabaccuuuu，那么输出应该是aaaccuuu，但给出了aaaccuuu。最后一个字符被拒绝。你能解释一下吗测试用例？我想我没有正确回答这个问题。这是您的第一个示例
“aaabaccuuou”输出：“aaaccuuu”
然后您评论了另一个示例，如
aaabaccuuouu output:aaaccuuuu
，因此我希望
aaabuu
的输出是
aaauu
而不是aauu。@SanketMakani的目标是修剪没有相邻字母的字符串：）是的，明白了！谢谢。@Enzokie:是的，你是正确的，你的答案是正确的。我没有使用你使用过的布尔逻辑。所以当我附加字符时，我得到的是少一个。也就是说，我得到的是aau，而不是aaabu
 public static void main(String[] args) {
        String str = "aaabaccuuuouu";
        StringBuilder builder = new StringBuilder();
        char[] chars = str.toCharArray();
        boolean unreset = true;
        for (int x = 1; x < chars.length; x++) {
            if (chars[x - 1] == chars[x]) {
                if (unreset) {
                    builder.append(chars[x - 1]);
                    unreset = false;
                }
                builder.append(chars[x]);
            } else {
                unreset = true;
            }
        }
        System.out.println(builder.toString());
 }