Java 如何从字符串中获取数字值？

如何拆分字符串

我有一个

字符串

：

String s = "1+2*3(30+4/2-(10+2))*2+1";

private static DigitStack getNumber(String convert) {
        String[] arr = convert.split("");
        digitStack = new DigitStack();

        try {
            for (int i = 0; i < arr.length ; i++) {
                while (arr[i].matches("\\d+")) {
                    digitStack.push(Double.valueOf(arr[i]));
                    i++;
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        
        return digitStack;

    }

获取从

字符串中获取数字值的方法：

String s = "1+2*3(30+4/2-(10+2))*2+1";

private static DigitStack getNumber(String convert) {
        String[] arr = convert.split("");
        digitStack = new DigitStack();

        try {
            for (int i = 0; i < arr.length ; i++) {
                while (arr[i].matches("\\d+")) {
                    digitStack.push(Double.valueOf(arr[i]));
                    i++;
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        
        return digitStack;

    }

预期产出：

   1.0; 2.0; 3.0; 30.0; 4.0; 2.0; 10.0; 2.0; 2.0; 1.0;

问题是方法计数每个符号，如分开，数字30和10。它可以转换为两个数字[3.0和0.0][1.0和0.0]

如何修复它？
最简单的方法是将字符串拆分为非数字，即

String s = "1+2*3(30+4/2-(10+2))*2+1";
String[] arr = s.split("\\D+");

这将返回一个数组

[1, 2, 3, 30, 4, 2, 10, 2, 2, 1]

然后您可以迭代并转换为double

import java.util.regex.Pattern;
import java.util.regex.MatchResult; 

private static DigitStack getNumber(String convert) {
    digitStack = new DigitStack();

    try {
        String numbers[] = Pattern.compile("\\d(\\d+|\\.)+")
                      .matcher(convert)
                      .results()
                      .map(MatchResult::group)
                      .toArray(String[]::new);

        for(String number : numbers ) digitStack.push(Double.valueOf(number));

    }catch (Exception e){
        e.printStackTrace();
    }
    
    return digitStack;

}

正如Rohit指出的，如果你有小数点的数字，或者你还想考虑负数，这种方法就不行了。
String[] digits = Pattern.compile("\\d+")
            .matcher("1+2*3(30+4/2-(10+2))*2+1")
            .results()
            .map(MatchResult::group)
            .toArray(String[]::new);


正则表达式中的
\d+
表示一个或多个数字

这将返回数组：

{ "1", "2", "3", "30", "4", "2", "10", "2", "2", "1" }

如果要将其转换为数字数组：

double[] matches = Arrays.stream(digits)
        .mapToDouble(Float::parseFloat)
        .toArray();

假设您使用的是Java9，只需获取正则表达式的所有匹配项并将其转换为double即可

import java.util.regex.Pattern;
import java.util.regex.MatchResult; 

private static DigitStack getNumber(String convert) {
    digitStack = new DigitStack();

    try {
        String numbers[] = Pattern.compile("\\d(\\d+|\\.)+")
                      .matcher(convert)
                      .results()
                      .map(MatchResult::group)
                      .toArray(String[]::new);

        for(String number : numbers ) digitStack.push(Double.valueOf(number));

    }catch (Exception e){
        e.printStackTrace();
    }
    
    return digitStack;

}

代码的问题是，您分别检查每个字符。您必须首先获取所有数字，然后将它们转换为双精度。
这将获取整数值和浮点值，前提是它们在语法上是正确的。忽略运算符、参数和变量

import java.util.regex.Pattern;
import java.util.regex.MatchResult; 

private static DigitStack getNumber(String convert) {
    digitStack = new DigitStack();

    try {
        String numbers[] = Pattern.compile("\\d(\\d+|\\.)+")
                      .matcher(convert)
                      .results()
                      .map(MatchResult::group)
                      .toArray(String[]::new);

        for(String number : numbers ) digitStack.push(Double.valueOf(number));

    }catch (Exception e){
        e.printStackTrace();
    }
    
    return digitStack;

}

String str = "1.9+.2*3(30.2+4./2-(10.23+2))*2+1";
String[] digits = str.split("[^\\d\\.]+");
System.out.println(Arrays.toString(digits));

印刷品

[1.9, .2, 3, 30.2, 4., 2, 10.23, 2, 2, 1]

我的答案有点不同，因为我假设您最终需要运算符和值

这是我一次测试的结果

Original Equation:            1+2*3(30+4/2-(10+2))*2+1
Expanded Equation:            1 + 2 * 3 ( 30 + 4 / 2 - ( 10 + 2 ) ) * 2 + 1

看起来我所做的只是在等式中添加空格。我实际做的是把方程分成几个部分，然后打印每个部分，后面是一个空格

下面是我编写的代码，用于根据原始等式创建零件的
列表

private List<String> parseEquation(String equation) {
    List<String> parts = new ArrayList<>();
    StringBuilder builder = new StringBuilder();
    String testCharacters = "+-*/()";
    char[] letters = equation.toCharArray();
    for (int i = 0; i < letters.length; i++) {
        if (letters[i] == ' ') {
            continue;
        }
        
        if (Character.isDigit(letters[i])) {
            builder.append(letters[i]);
            continue;
        }
        
        if (letters[i] == '.') {
            builder.append(letters[i]);
            continue;
        }
        
        if (contains(letters[i], testCharacters)) {
            addPart(parts, builder);
            parts.add(Character.toString(letters[i]));
        }
    }
    
    addPart(parts, builder);
    
    return parts;
}

private void addPart(List<String> parts, StringBuilder builder) {
    if (builder.length() > 0) {
        parts.add(builder.toString());
        builder.delete(0, builder.length());
    }
}

private boolean contains(char c, String text) {
    for (int i = 0; i < text.length(); i++) {
        char t = text.charAt(i);
        if (c == t) {
            return true;
        }
    }
    
    return false;
}

预期的输出是什么？您可能需要重新考虑
convert.split（“”
）。请尝试打印
arr
内容，并查看如何改进内容。这样，您可以获得两个运算符或符号之间的数字。字符串可能会更改，运算符和符号可能会更改2。