Java 如果子字符串可以强制转换为int，如何拆分以

我试图将一个字符串拆分为一个字符串列表，该列表根据字符是否可以以数字形式转换而定。换一种说法，我想把我的字符串分成不同的数字和字母组。为了增加乐趣，我还尝试从每组数字中删除任何前导的0。考虑下面的例子。

假设您得到了

“aoeu01234stnh0987”

作为您的输入。我想要的输出是

[“aoeu”、“1234”、“stnh”、“987”]

我在下面做了一个工作示例，但它有点长而且令人困惑。看来必须有更好、更简洁的方法来实现这一点

私有静态列表碎片字符串（字符串）{
char[]charArr=string.toCharArray（）；
StringBuilder tempStr=新建StringBuilder（）；
StringBuilder tempInt=新建StringBuilder（）；
List templast=new ArrayList（）；
布尔值wasPrevNum=false；
用于（字符c:charArr）{
布尔值isNum=Character.isDigit（c）；
if（isNum）{
tempInt.append（c）；
如果（！wasPrevNum）{
wasPrevNum=true；
add（tempStr.toString（））；
tempStr=新的StringBuilder（）；
}
}否则{
tempStr.append（c）；
if（wasPrevNum）{
while（tempInt.charAt（0）='0'）tempInt.deleteCharAt（0）；
add（tempInt.toString（））；
tempInt=新的StringBuilder（）；
wasPrevNum=false；
}
}
}
if（tempInt.length（）>0）while（tempInt.charAt（0）='0'）tempInt.deleteCharAt（0）；
add（wasPrevNum？tempInt.toString（）：tempStr.toString（））；
返回圣殿骑士；
}

---

我了解了如何使用

split（）

方法，但该解决方案只适用于他们非常特殊的情况，不适用于这里。

split（）。regex，
\p{L}+|[0-9]+
，表示字母序列或数字序列，可用于查找子字符串。然后，尝试解析找到的子字符串。如果它是一个整数，解析结果将删除前导零，如果解析失败，只需打印子字符串即可

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Main {
    public static void main(String[] args) {
        String str = "aoeu01234stnh0987";
        Matcher matcher = Pattern.compile("\\p{L}+|[0-9]+").matcher(str);
        while (matcher.find()) {
            String substring = matcher.group();
            try {
                System.out.println(Integer.parseInt(substring));
            } catch (NumberFormatException e) {
                System.out.println(substring);
            }
        }
    }
}

输出：

aoeu
1234
stnh
987

这个例子并不比OP发布的代码简洁多少。我能说的最好的一点是，我没有使用异常作为处理的一部分

以下是一次测试运行的结果

aoeu01234stnh0987
[aoeu, 1234, stnh, 987]

下面是完整的可运行示例代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StringSplitter {

    public static void main(String[] args) {
        StringSplitter ss = new StringSplitter();
        
        String input = "aoeu01234stnh0987";
        System.out.println(input);
        List<String> output = ss.splitString(input);
        String[] output2 = output.toArray(new String[output.size()]);
        System.out.println(Arrays.toString(output2));
    }
    
    public List<String> splitString(String input) {
        List<String> output = new ArrayList<>();
        
        if (input == null || input.length() < 1) {
            return output;
        }
        
        char c = input.charAt(0);
        boolean isDigit = Character.isDigit(c);
        StringBuilder builder = new StringBuilder();
        builder.append(c);
        
        for (int i = 1; i < input.length(); i++) {
            c = input.charAt(i);
            
            if (isDigit == Character.isDigit(c)) {
                builder.append(c);
            } else {
                addToList(output, builder, isDigit);
                builder.delete(0, builder.length());
                builder.append(c);
                isDigit = !isDigit;
            }
        }
        
        addToList(output, builder, isDigit);
        return output;
    }

    private void addToList(List<String> output, 
            StringBuilder builder, boolean isDigit) {
        if (isDigit) {
            output.add(Integer.toString(
                    Integer.valueOf(builder.toString())));
        } else {
            output.add(builder.toString());
        }
    }

}

import java.util.ArrayList；
导入java.util.array；
导入java.util.List；
公共类字符串拆分器{
公共静态void main（字符串[]args）{
StringSplitter ss=新StringSplitter（）；
字符串输入=“aoeu01234stnh0987”；
系统输出打印项次（输入）；
列表输出=ss.splitString（输入）；
String[]output2=output.toArray（新字符串[output.size（）]）；
System.out.println（Arrays.toString（output2））；
}
公共列表拆分字符串（字符串输入）{
列表输出=新的ArrayList（）；
if（input==null | | input.length（）<1）{
返回输出；
}
字符c=输入字符（0）；
布尔isDigit=字符isDigit（c）；
StringBuilder=新的StringBuilder（）；
附加（c）；
对于（int i=1；i
您可以向每组符号添加一些分隔符，然后围绕这些字符拆分字符串：

String str=“aoeu01234stnh0987”；
字符串[]arr=str.replaceAll（“\\d+\\\d+”，“$0:：”）.split（“：”，0）；
System.out.println（Arrays.toString（arr））；//[aoeu，01234，stnh，0987]

//从数字中修剪前导零，
//即解析整数值
//并将其返回到字符串
IntStream.range（0，arr.length）
.filter（i->arr[i].replaceAll（“\\d+”，”）.length（）==0）
.forEach（i->arr[i]=Integer.valueOf（arr[i]）.toString（）；
System.out.println（Arrays.toString（arr））；//[aoeu，1234，stnh，987]


另请参见：
我正在发布我在生产中使用的代码，以防它对任何人都有好处；我知道已经有一些很好的答案了，我利用了一些答案中的信息得出了这个结论

private static List fragmentArr（字符串[]inputArr）{
List fragArr=new ArrayList（）；
Arrays.stream（inputArr）.forEach（字符串->{
List listToAdd=新建ArrayList（）；
Matcher Matcher=Pattern.compile（“[^0-9]+|[0-9]+”）.Matcher（字符串）；
while（matcher.find（））{
StringBuilder子字符串=新的StringBuilder（matcher.group（））；
while（substring.charAt（0）='0'）substring.deleteCharAt（0）；
listToAdd.add（substring.toString（））；
}
FRAGAR.add（列表添加）；
});
返回弗拉格尔；
}

出于两个原因，我使用while循环来修剪0，而不是转换为int并转换回字符串

时间复杂性