Java 每x位后拆分字符串

我有个小问题。我需要把一个字符串分成x个部分，然后把它加在一起。编辑：如果我想用x=3分割它，那么我需要4个部分，但是如果我想用x=4分割它，那么我需要3个部分。所以我的硬编码代码不好。 我的x始终是我的stringlength的倍数（3是009056737152-长度12的倍数）

示例：字符串：“009056737152”，地址长度=3；意味着我必须在3个数字后拆分字符串。009 056 737 152，然后我必须从右到左将其相加：251+737+650+009=1647。我的代码实际上无法正常工作。还有其他想法吗

    int adresslength = 3;
    String str = "009056737152"; System.out.println(str);
    String result = str.substring(0,str.length() - adresslength - adresslength - adresslength );
    String result2 = str.substring(adresslength,str.length() + -adresslength -adresslength );
    String result3 = str.substring(adresslength + adresslength,str.length() +  -adresslength  );
    String result4 = str.substring(adresslength + adresslength + adresslength,str.length()  );
    System.out.println(result); System.out.println(result2);System.out.println(result3);System.out.println(result4);

---

也许，这段代码可以解决您的问题

    int adresslength = 3;
    String str = "009056737152";
    System.out.println(str);
    String[] result = new String[str.length() / adresslength];
    int j = 0;
    for (int i = 0; i < str.length();) {
        result[j] = str.substring(i, (i + adresslength));
        char[] aux = new char[adresslength];
        int k2 = 0;
        for (int k = aux.length - 1; k >= 0; k--) {
            if ((j == 0)) {
                aux[k2] = result[j].charAt(k2);
                k2++;
            }else{
                aux[k2] = result[j].charAt(k);
                k2++;
            }

        }
        result[j] = String.copyValueOf(aux);
        i = i + adresslength;
        System.out.println(result[j]);
        j++;
    }

    int aux = 0;
    for (String string : result) {
        aux += Integer.valueOf(string);
    }
    System.out.println(aux);

int-addresslength=3；
字符串str=“009056737152”；
系统输出打印项次（str）；
字符串[]结果=新字符串[str.length（）/addressLength]；
int j=0；
对于（int i=0；i=0；k--）{
如果（（j==0））{
aux[k2]=结果[j]。字符（k2）；
k2++；
}否则{
aux[k2]=结果[j]。字符（k）；
k2++；
}
}
结果[j]=String.copyValueOf（aux）；
i=i+地址长度；
System.out.println（结果[j]）；
j++；
}
int aux=0；
for（字符串：结果）{
aux+=整数。valueOf（字符串）；
}
系统输出打印项次（辅助）；

如果首先计算零件尺寸，则可以轻松计算零件范围

public static String[] partitionByCount(String input, int count) {
    if (count <= 0)
        throw new IllegalArgumentException("Invalid count: " + count);
    int size = input.length() / count;
    if (size * count != input.length())
        throw new IllegalArgumentException("String of length " + input.length() +
                " cannot be split into " + count + " equally-sized parts");
    String[] parts = new String[count];
    for (int i = 0; i < count; i++)
        parts[i] = input.substring(i * size, (i + 1) * size);
    return parts;
}

输出

[0090567352]
[0090, 5673, 7152]
[009, 056, 737, 152]

如果要指定分区大小而不是分区计数，则可以轻松调整代码：

public static String[] partitionBySize(String input, int size) {
    if (size <= 0)
        throw new IllegalArgumentException("Invalid size: " + size);
    int count = input.length() / size;
    if (count * size != input.length())
        throw new IllegalArgumentException("String of length " + input.length() +
                " cannot be split into equally-sized parts of length " + size);
    String[] parts = new String[count];
    for (int i = 0; i < count; i++)
        parts[i] = input.substring(i * size, (i + 1) * size);
    return parts;
}

输出

[00,90,56,73,71,52]
[009, 056, 737, 152]
[0090, 5673, 7152]

然后对反转的部分求和，更容易的方法是反转输入，对其进行分区，然后求和：

public static int sumReversedPartitions(String input, int size) {
    String reversed = new StringBuilder(input).reverse().toString();
    String[] parts = partitionBySize(reversed, size);
    return Arrays.stream(parts).mapToInt(Integer::parseInt).sum();
}

试验

输出

publicstaticvoidmain（String[]main）{
int地址长度=3；
字符串str=“009056737152”；System.out.println（str）；
int结果=0；
对于（int i=0；i=0；j--）{
nSString+=子字符串.charAt（j）；
}
结果+=整数.valueOf（nSString）；
}
系统输出打印项次（结果）；
}

---

您可以将地址长度更改为2,4,5，并根据需要额外添加约束，例如地址长度将按字符串长度进行模块化等。

下面是使用Java 8 streams的较短版本

public static int splitNumber(String s, int length) {
    s = new StringBuilder(s).reverse().toString();
    return IntStream.iterate(0, i -> i + length)
            .mapToObj(start -> s.substring(start, start + length))   // Take the i-th substring
            .mapToInt(Integer::parseInt)                             // Turn into int
            .limit(s.length() / length)                              // Limit the number of parts
            .sum();
}

---

哪个部分不工作？拆分？字符串的长度总是地址长度的倍数吗？是的，总是倍数，当我更改int addressLength时，它不起作用。它只适用于int-addresslength=3

stringresult3=str.substring（addresslength+addresslength，str.length（）+addresslength-6）如果更改长度时它不起作用，因为这里您硬编码了
6
，只有当地址长度为
3
时它才起作用，谢谢我更正了它，但它仍然只起作用3或2个字节：D这太好了。如果数字超过我的地址长度，您知道如何剪切结果。示例：AddressLength=3，但结果是1647（长度4）。我怎样才能减少第一个数字，只得到647Humm。。。在final String
sumString=String.valueOf（aux）中添加这些行；while（sumString.length（）>addresslength）{sumString=sumString.substring（1，sumString.length（））；}
public static int sumReversedPartitions(String input, int size) {
    String reversed = new StringBuilder(input).reverse().toString();
    String[] parts = partitionBySize(reversed, size);
    return Arrays.stream(parts).mapToInt(Integer::parseInt).sum();
}

System.out.println(sumReversedPartitions("009056737152", 2));
System.out.println(sumReversedPartitions("009056737152", 3));
System.out.println(sumReversedPartitions("009056737152", 4));

153         // 25 + 17 + 37 + 65 + 09 + 00
2538        // 251 + 737 + 650 + 900
7182        // 2517 + 3765 + 0900

    public static void main(String[] main){
         int adresslength = 3;
         String str = "009056737152"; System.out.println(str);
         int result = 0;
         for(int i=0;i<str.length();i+=adresslength){
             String subString = str.substring(i , i+adresslength);
             String nSString = new String();
             for(int j=subString.length()-1;j>=0;j--){
                 nSString += subString.charAt(j);
             }
             result+=Integer.valueOf(nSString);
         }
         System.out.println(result);
    }

public static int splitNumber(String s, int length) {
    s = new StringBuilder(s).reverse().toString();
    return IntStream.iterate(0, i -> i + length)
            .mapToObj(start -> s.substring(start, start + length))   // Take the i-th substring
            .mapToInt(Integer::parseInt)                             // Turn into int
            .limit(s.length() / length)                              // Limit the number of parts
            .sum();
}