Java 如何按字符串的顺序计算字符数？

我有一个

字符串

用于2D平台游戏中的编辑器，用户单击16x60矩形板创建自定义板。我在这些矩形中循环，得到一个我想要修剪的字符串。x是块，a是空白。我需要这个来画水平线

String s = "x1x1x1x1a1a1x1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1";

我想将其修剪为

x4a2x1a54

。基本上是把x和a加起来，它们就在后面

---

如何做到这一点？

只是想让您知道，stackoverflow不是获取代码的论坛，而是帮助您使用代码并指出错误或给出建议的论坛

我相当不喜欢一个要求，但由于这个问题吸引了我一点，这里是我的版本。不幸的是，我不能只使用流，不得不向其中添加一个Arraylist（可能使用一行中的reduce-and-collect-methode-of-Streams），但它可以按预期工作

    String s = "x1x1x1x1a1a1x1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1";
    ArrayList<String[]> map = new ArrayList<>();
    for(String c:s.split("(?<=\\G..)")){
        if(map.isEmpty()||!map.get(map.size()-1)[0].equals(c.substring(0,1))){
            map.add(new String[]{c.substring(0,1),c.substring(1)});
        } else{
            map.get(map.size()-1)[1]=(Integer.parseInt(map.get(map.size()-1)[1])+Integer.parseInt(c.substring(1)))+"";
        }
    }
    StringBuilder sb = new StringBuilder();
    map.forEach(x-> sb.append(x[0]).append(x[1]));
    System.out.println(sb.toString());

String s=“X1X1X1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1”；
ArrayList映射=新的ArrayList（）；
对于（字符串c:s.split（（？我建议的第一件事是将该字符串分解为以下更易于管理的部分：

    String s = "x1x1x1x1a1a1x1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1";
    String[] splitS = s.split("1");
    //Contents of the array are: [x, x, x, x, a, a, x, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a]
    //We can now loop through each string in the string array and count how many we have of what
    ArrayList<String> values = new ArrayList<String>();
    int start = 0, end = 0, grandCounter = 0;
    String current = splitS[0];
    for(int i = 1; i < splitS.length-1; i++){
        if(!splitS[i].equals("x") && current.equals("x")){
            end = i;
            values.add("x" + (end - start));
            grandCounter += (end-start);
            start = end;
            end = 0;
            current = "a";
        } else if(!splitS[i].equals("a") && current.equals("a")){
            end = i;
            values.add("a" + (end - start));
            start = end;
            end = 0;
            current = "x";
            grandCounter += (end-start);
        }
    }
    values.add( "a" + (splitS.length-grandCounter) + "");
    System.out.println(values.toString().replace("[", "").replace(",", "").replace("]", "").replace(" ", ""));

String s=“X1X1X1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1A1”；
字符串[]splitS=s.split（“1”）；
//数组的内容是：[x，x，x，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a，a]
//现在，我们可以循环字符串数组中的每个字符串，并计算有多少个字符串
ArrayList值=新的ArrayList（）；
int start=0，end=0，grandCounter=0；
串电流=分裂[0]；
对于（int i=1；i

当被告知在控制台中打印时，上述代码准确地返回了以下内容：x4a2x1a58

如果您在工作中还有任何问题，请告诉我！
这里有一个比已经发布的方法更简单的方法：

 public static String customTrim(String s){

String res = "";
String last = "";
int count = 0;

for (int i = 0; i < s.length() - 1; i+=2){

  String curr = "" + s.charAt(i) + s.charAt(i+1);

  if(!curr.equals(last)){
      count = 1;
      res += "" + s.charAt(i) + count;
  }

  else{
    int subLength = ("" + count).length();
    count++;
    res = res.substring(0, res.length()- subLength) + count;
  }

  last = curr;

}
return res;
}

公共静态字符串customTrim（字符串s）{
字符串res=“”；
字符串last=“”；
整数计数=0；
对于（int i=0；i
循环遍历字符并存储最后一个字母字符。对于每个字符，分析其后面的数字。如果字母字符与最后一个字符相同，则可以将此数字添加到计数中，否则将旧结果写入输出：

public static String compress(String input) {
    if (input == null || input.isEmpty()) {
        return input;
    }
    char type = ' ';
    int count = 0;
    StringBuilder output = new StringBuilder();
    int index = 0;
    final int length = input.length();
    while (index < length) {
        char elementType = input.charAt(index);

        // parse number
        int elementCount = 0;
        char c;
        for (index++; index < length && Character.isDigit(c = input.charAt(index)); index++) {
            elementCount = 10 * elementCount + (c - '0');
        }

        if (elementType == type) {
            count += elementCount;
        } else {
            // finish counting last type
            output.append(type).append(count);
            type = elementType;
            count = elementCount;
        }
    }
    output.delete(0, 2); // remove substring added for the initial count/type
    output.append(type).append(count); // append last entry
    return output.toString();
}

你可以按照fabian发布的方式来做，效果很好。不过，我自己通过三个简单的if就知道了

    StringBuilder sb = new StringBuilder();

    List<String> values = new ArrayList<>();

    String s = "x1x1x1x1a1a1x1x1a1a1a1";
    String[] splitString = s.split("1");
    // "xxxxaaxxaaa"
    // to x4a2x2a3

    String current = splitString[0];
    int occ = 0;

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

        if(!splitString[i].equals(current)){
            values.add(current+occ);
            occ = 0;
            current = splitString[i];
        }

        if(splitString[i].equals(current)){
            occ++;
        }

        if(i == splitString.length-1){
            values.add(current+occ);
        }

    }

    for (String str: values
         ) {
        sb.append(str);
    }

    System.out.println(sb);
}

StringBuilder sb=新建StringBuilder（）；
列表值=新的ArrayList（）；
字符串s=“X1X1X1A1X1A1X1A1A1”；
String[]splitString=s.split（“1”）；
//“xxxxaaxxaaa”
//至x4a2x2a3
字符串电流=拆分字符串[0]；
int-occ=0；
for（int i=0；i
在字符之间循环，记住您读取的最后一个字母和当前计数；如果当前字母与最后一个字母相同，则增加计数，否则输出最后一个字母和计数，并重置两者。您可能还应该注意此代码中的假设，因为规范不是很清楚，例如，您作为假设输入字符串只有
1
作为值，等等。只是为了使用流，您a）创建了一个不需要的列表b）使用了一个数组，该数组不适合存储您要存储的两种类型，并以字符串格式存储一个
整数
s，从字符串解析它们，并将它们转换回字符串以增加它们…我使用流来超越forloop，我更改了代码以便没有流，@James_D我添加了您的建议n谢谢你，千万不要在循环中串联字符串。@James\u D为什么不呢？因为性能太差了。每次修改字符串时，你都要创建一个新的字符串对象，并将字符从旧字符串复制到新字符串中。你基本上要复制O（n^2）个字符，其中n是结果字符串的长度。请参阅（举例来说）很多这似乎是多余的。例如，
String current=“x”；if（splitS[0].equals（“a”）{current=“a”}
：为什么不干脆做
String current=splitS[0]
？
continue
语句也是多余的。我很快编写了这段代码，因此我为冗余表示歉意，我现在就去修复它。另外，如果我读对了，您会认为最后一段是
语句
    StringBuilder sb = new StringBuilder();

    List<String> values = new ArrayList<>();

    String s = "x1x1x1x1a1a1x1x1a1a1a1";
    String[] splitString = s.split("1");
    // "xxxxaaxxaaa"
    // to x4a2x2a3

    String current = splitString[0];
    int occ = 0;

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

        if(!splitString[i].equals(current)){
            values.add(current+occ);
            occ = 0;
            current = splitString[i];
        }

        if(splitString[i].equals(current)){
            occ++;
        }

        if(i == splitString.length-1){
            values.add(current+occ);
        }

    }

    for (String str: values
         ) {
        sb.append(str);
    }

    System.out.println(sb);
}