Java字符串操作：比较Java中的相邻字符

我有以下问题
给定一个字符串，返回一个“清理”字符串，其中相同的相邻字符已减少为单个字符。所以

“yyzza”

产生

“yza”

stringClean("yyzzza") → "yza"      
stringClean("abbbcdd") → "abcd"       
stringClean("Hello") → "Helo"

我正在尝试输入代码

stringClean（“abbbcdd”）→ “abcd”

下面是我的代码。我在进行相邻字符比较后获得部分附加字符串，因此，从现在起，我获得附加的stringBuilder

“sb=abc”

，这不是正确的输出，我应该获得输出为

“abcd”

类清除字符串{
公共静态字符串stringClean（字符串str）{
int startIndex=str.indexOf（str）；
char startChar='\u0000'；
字符邻接字符='\u0000'；
System.out.println（“startIndex-->”+startIndex）；
最终StringBuilder sb=新StringBuilder（）；
对于（startIndex=0；startIndex”+str）；
str=str.substring（1）；
startIndex--；
System.out.println（“子字符串之后-->”+str）；
System.out.println（“IndexOf check-->”
+sb.toString（）.indexOf（startChar））；
if（sb.toString（）.indexOf（startChar）！=-1）{
某人附加（邻接字符）；
System.out.println（“如果部分-->则附加字符串”
+某人扭动绳子；
}
}否则{
str=str.substring（1）；
startIndex--；
某人追加（startChar）；
System.out.println（“附加字符串-->”+sb.toString（））；
}
}//循环结束
使某人返回字符串（）；
}
//我得到的输出为abc…这是部分附加字符串
公共静态void main（字符串…参数）{
String outputCleanString=新的cleanString（）.stringClean（“abbbcdd”）；
System.out.println（“清洁字符串-->”+输出清洁字符串）；
}      
}  

---

*观察：*在我得到附加字符串“abc”之后，当我移动到比较最后一组字符“dd”时，我面临这部分的问题。

如果基于正则表达式的解决方案是可以接受的，您可以做：

str = str.replaceAll("(.)\\1+","$1");

---

如果基于正则表达式的解决方案是可接受的，您可以执行以下操作：

str = str.replaceAll("(.)\\1+","$1");

公共静态字符串stringClean（字符串str）{
如果（str==null | |“”.equals（str））{
返回str；
}
char lastChar=str.charAt（0）；
StringBuilder resultBuilder=新建StringBuilder（）；
resultBuilder.append（lastChar）；
对于（int index=1；index

公共静态字符串stringClean（字符串str）{
如果（str==null | |“”.equals（str））{
返回str；
}
char lastChar=str.charAt（0）；
StringBuilder resultBuilder=新建StringBuilder（）；
resultBuilder.append（lastChar）；
对于（int index=1；index

首先，您的代码过于复杂。绝对没有必要

            str = str.substring(1);
            startIndex--;

在循环内部-您有效地将

startIndex

保持为0，并从字符串的开头截断字符。相反，您应该只遍历字符串的字符（如果希望查看剩下的处理内容，请打印

str.substring（startIndex）

）

还有，这里

            if(sb.toString().indexOf(startChar) != -1){
                sb.append(adjacentChar);
                System.out.println("Appended String in if part-->"
                    + sb.toString());
            }

如果同一字符在一行中重复两次以上，您的目标是防止再次添加该字符，但如果该字符已经在生成器中，代码实际上会阻止向生成器添加该字符，即“aba”之类的输入将产生错误的输出“ab”

事实上，你的错误也有根源。条件是错误的：

            if(sb.toString().indexOf(startChar) != -1){

当在

sb

包含的字符串中找到

startChar

时，产生

true

！如果您更改

=

到

==

，您将在输出中获得您的“d”（但是，您也将获得额外的“b”）

修正算法 当同一个字符在一行中重复两次以上时，始终将实际字符与下一个字符进行比较的方法将失败。更好的方法是只记住附加到缓冲区的最后一个字符，然后跳过，直到找到与它不同的字符：

public static String stringClean(String str){
    final StringBuilder sb = new StringBuilder();
    char lastAppendedChar = '\u0000';

    for(int index = 0; index < str.length(); index += 1){
        char actualChar = str.charAt(index);

        if (actualChar != lastAppendedChar){
            sb.append(actualChar);
            lastAppendedChar = actualChar;
        }
    }// end of for loop
    return sb.toString();
}

publicstaticstringclean（stringstr）{
最终StringBuilder sb=新StringBuilder（）；
char lastappendchar='\u0000'；
对于（int index=0；index

首先，您的代码过于复杂。绝对没有必要

            str = str.substring(1);
            startIndex--;

在循环内部-你是一个

public static String stringClean(String input) {
    Set<Character> result = new LinkedHashSet<Character>();

    for (char c : input.toCharArray()) {
        result.add(c);
    }

    StringBuilder sb  = new StringBuilder();
    for (char c : result)
        sb.append(c);
    return sb.toString();
}

public static String stringClean(String str) {
    if (str == null || "".equals(str))
        return str;
    StringBuffer buffer = new StringBuffer();
    char[] chars = str.toCharArray();
    buffer.append(chars[0]);
    for (int i = 1; i < chars.length; i++) {
        if (chars[i] != chars[i-1])
            buffer.append(chars[i]);
    }
    return buffer.toString();
}

public static String stringClean(String str){
    int startIndex = str.indexOf(str);
    char startChar = '\u0000';
    char adjacentChar = '\u0000';
    boolean flag = false; // added
    System.out.println("startIndex-->" + startIndex);
    final StringBuilder sb = new StringBuilder();

    for(startIndex = 0; startIndex < str.length(); startIndex++){
        startChar = str.charAt(startIndex);
        System.out.println("startIndex ::" + startIndex);
        System.out.println("startChar ::" + startChar);

        final int adjacentPosition = startIndex + 1;
        System.out.println("adjacentPosition ::" + adjacentPosition);
        if(adjacentPosition != str.length()){
            adjacentChar = str.charAt(adjacentPosition);
            System.out.println("adjacentChar ::" + adjacentChar);
        } else {
            flag = true;
        }
        if(startChar == adjacentChar){
            System.out.println("startChar ::" + startChar);
            System.out.println("adjacentChar::" + adjacentChar);

            System.out.println("Before Substring string --->" + str);
            str = str.substring(1);
            startIndex--;
            System.out.println("After Substring string --->" + str);
            System.out.println("IndexOf check ---->"
                + sb.toString().indexOf(startChar));
            if(sb.toString().indexOf(startChar) != -1){
                sb.append(adjacentChar);
                System.out.println("Appended String in if part-->"
                    + sb.toString());
            } else if(flag) {                   /* added */
                sb.append(adjacentChar);
            }
        } else{
            str = str.substring(1);
            startIndex--;
            sb.append(startChar);
            System.out.println("Appended String --->" + sb.toString());
        }
    }// end of for loop
    return sb.toString();
}

function cleanString(toClean){
    return toClean.replace(/(\S)\1(\1)*/g,"$1")
}

if(adjacentPosition != str.length()){
     adjacentChar = str.charAt(adjacentPosition);
     System.out.println("adjacentChar ::" + adjacentChar);
}

else {
     adjacentChar = '/u0000';
}

 if(sb.toString().indexOf(startChar) != -1){
      sb.append(adjacentChar);
      System.out.println("Appended String in if part-->"
         + sb.toString());
 }

public String stringClean(String str) {
  if (str.length() < 2)return str; 

  String nextStr = str.substring(1);

  if (str.charAt(0) == str.charAt(1)) {
    return stringClean(nextStr);
  }

  else return str.substring(0,1) +  stringClean(nextStr);
}

public String stringClean(String string){
    char sc[] = string.toCharArray();

    for(int i =0;i<sc.length;i++){
        if(i!=sc.length-1){
            if(sc[i]!=(sc[i+1])){
                output+=sc[i];
            }
        }else {
            output+=sc[i];
        }
    }
    return  output;
    //System.out.println(output);
}

public String stringClean(String str) {
  if (str.length() <= 1)
      return str;

  String adj1 = str.substring(0,1);
  String adj2 = str.substring(1,2);

  String rest = str.substring(1);

  if (adj1.equals(adj2)) {
      return stringClean(rest);
  } else
      return adj1 + stringClean(rest);
}