Question

我最近在一次采访中被问到这个问题（Java编程阙）

从随机字符串返回所有整数的总和。

Answer 1

只需遍历字符串，一次处理一个数字。这正是正则表达式无论如何都会做的：

    String testStrings[] = { "-1a2b3c", "123ab!45c", "abcdef", "0123.4",
            "dFD$#23+++12@#T1234;/.,10" };

    for (String testString : testStrings) {
        String currentNumber = "";
        int sum = 0;
        for (int i = 0; i < testString.length(); i++) {
            char currentChar = testString.charAt(i);

            // Add digits or a leading minus to "currentNumber"
            if (Character.isDigit(currentChar)
                    || (currentNumber.equals("") && currentChar == '-')) {
                currentNumber += currentChar;
            } else {
                // We've stumbled across a non-digit char.
                //Try to parse the "currentNumber" we have so far
                if (!currentNumber.equals("") && !currentNumber.equals("-"))
                    sum += Integer.parseInt(currentNumber);
                currentNumber = "";
            }
        }

        // Add the last "currentNumber" in case the string ends with a
        // number
        if (!currentNumber.equals("") && !currentNumber.equals("-"))
            sum += Integer.parseInt(currentNumber);
        System.out.println(sum);
    }

输出：

Answer 2

public class Random {

    public  int SumofNumbers(String s){

        char[] str = s.toCharArray();
        String answer="";
        int sum = 0;
        List<String> al = new ArrayList();
        for (int i=0;i< str.length;i++){
            if (checkNumber(str[i])){
                answer=answer+str[i];
            }
            else
            {
                if(!answer.isEmpty()){
                    al.add(answer);
                    answer = "";
                }
            }

             if (i == str.length -1 && !answer.isEmpty()) {
                    al.add(answer);
                }
        }

        for (String a1 : al){
            sum = sum + Integer.valueOf(a1);
        }

        return sum;
    }

    private boolean checkNumber(char c) {
        if ((int)c > 47 &&  (int)c < 58){
            return true;
        }else if ((int)c == 45){
            return true;
        }
        return false;
    }

    public static void main(String [] args){
        Random r = new Random();
        String test = "123ab!45c";
        System.out.println(r.SumofNumbers(test));
    }

}

Answer 3

我在Java 8中有一种稍微'可爱'的方式来实现这一点：将其实现为Collector

public DigitCollector {
    private boolean negative = false;
    private int current = 0;
    private int total = 0;

    public int getTotal() {
        if (negative) {
            total -= current;
        } else {
            total += current;
        }
        current = 0;
        negative = false;
        return total;
    }

    public void accept(Character ch) {
        if (Character.isDigit(ch)) {
            current = 10 * current + Integer.parseInt(ch.toString());
        } else if (ch.equals('-')) {
            negative = true;
        } else {
            getTotal();
        }
    }
}

现在您可以收集一组字符：

text.chars().map(ch -> new Character((char)ch))
    .collect(DigitCollector::new, DigitCollector::accept, null)
    .getTotal();

我意识到映射ch -> new Character((char)ch))看起来很奇怪，但.chars()返回整数流而不是字符。请参阅here了解原因（尽管几乎每个人都认为这是一个错误）。

这是一种稍纵即逝的方式，但它非常灵活：您可以从任何地方获取角色流，并在收集之前进行任何您想要的操作。在我看来，这是一个问题的自然表示，而且，大多数情况下，我认为流比传统的迭代更酷： - ）

Answer 4

public class StringToIntAddition {

    public static void main(String[] args) throws Exception {
        String str = "2e40 ssdf 23-9", number="";
        int sum=0;
        for(int i=0; i<str.length() ;i++){

                if(Character.isDigit(str.charAt(i))){
                        number += str.charAt(i);
                }
                else if(!number.isEmpty()){
                    sum += Integer.parseInt(number);
                    number= "";
                }
                if (str.charAt(i) == '-'){
                    number = "-" ;  
                    }

        }
     if(!number.isEmpty()){
            sum += Integer.parseInt(number);
            }
        System.out.println("number= " + sum);
    }

}

Answer 5

已经有很多答案，但这个答案似乎很有趣。我有一个非常有效的不同解决方案：

public static int countString(String input) {
    if (input == null) return 0;

    int sum = 0;
    int accumulator = 0;
    boolean lastCharWasDigit = false;

    for (int i = 0, len = input.length(); ++i) {
        char c = input.charAt(i);

        // If a non-digit character is found, clear the 
        // accumulator and add it to the sum.
        if (c < '0' || c > '9') {
            sum += accumulator;
            accumulator = 0;
            lastCharWasDigit = false;
            continue;
        }

        // If the previous character was a digit, that means
        // this is a continuation. Multiply by ten to shift
        // it over one power of ten before adding the new value
        if (lastCharWasDigit) {
            accumulator *= 10;
        }

        // Add the integer value of the character
        int charValue = c - '0';
        accumulator += charValue;
        lastCharWasDigit = true;
    }

    // Finally, clear the accumulator for any ending digits,
    // and return the sum
    sum += accumulator;
    return sum;
}

不使用正则表达式从随机字符串返回所有整数的总和

5 个答案: