如何在java中对整数的数字求和？答案

【问题标题】：How to sum digits of an integer in java?如何在java中对整数的数字求和？
【发布时间】：2014-11-24 01:37:31
【问题描述】：

我很难找到解决这个问题的方法。我正在尝试用 Java 开发一个程序，该程序接受一个数字，例如 321，并找到数字的总和，在本例中为 3 + 2 + 1 = 6。我需要任何三位数字的所有数字将它们加在一起, 并使用 % 余数符号存储该值。这让我很困惑，我会很感激任何人的想法。

【问题讨论】：

您是否要计算任何三位数字的数字根？如果是这样，哪个部分给您带来了麻烦？
好吧，我只是想取任何数字，例如 480，并让它等于它的所有数字（4、8、1），然后使用 % 符号相加。我需要在 Java 中创建一个可以执行此操作的循环。
需要完成这段代码： Public static void main(String[] args) { int digits = 321; int sum..... System.out.printIn(sum); }
How to get the separate digits of an int number? 的可能重复项
@ShaneLarsen 看看答案

标签： java

【解决方案1】：

public static void main(String[] args) {
        int num = 321;
        int sum = 0;
        while (num > 0) {
            sum = sum + num % 10;
            num = num / 10;
        }
        System.out.println(sum); 
}

输出

【讨论】：

它在我的编译器中没有按原样运行。
这行得通。 @ShaneLarsen 预期的类、接口或枚举通常意味着您缺少大括号。
这是opiouds要求做他的功课，甚至没有把main函数放到一个类中。
其实我确实把它输入到了一个类中。

【解决方案2】：

使用流的简单解决方案：

int n = 321;
int sum = String.valueOf(n)
    .chars()
    .map(Character::getNumericValue)
    .sum();

【讨论】：

【解决方案3】：

递归总是比循环快！

最短和最好的：

public static long sumDigits(long i) {
    return i == 0 ? 0 : i % 10 + sumDigits(i / 10);
}

【讨论】：

你真的确定它们总是更快吗？还是更短？
如果您需要恒定时间解决方案，请查看我的答案。
递归总是更快 ahahahaha 真是个笑话！

【解决方案4】：

你可以使用递归来做到这一点

//Sum of digits till single digit is obtained
public int sumOfDigits(int num) 
        {
            int sum = 0;

            while (num > 0)
            {
                sum = sum + num % 10;
                num = num / 10;
            }

            sum = (sum <10) ? sum : sumOfDigits(sum);

            return sum;
        }

【讨论】：

【解决方案5】：

没有映射 ➜ 更快的 lambda 解决方案

Integer.toString( num ).chars().boxed().collect( Collectors.summingInt( (c) -> c - '0' ) );

…或与较慢的 % 运算符相同

Integer.toString( num ).chars().boxed().collect( Collectors.summingInt( (c) -> c % '0' ) );

…或 Unicode 兼容

Integer.toString( num ).codePoints().boxed().collect( Collectors.summingInt( Character::getNumericValue ) );

【讨论】：

这真的更快吗？或者只是 lambda 形式的更快版本？
是的，我认为它总是更快。映射需要时间，顺便说一句，这里是多余的。这并不意味着没有更快的非 lambda 解决方案——流的创建需要额外的时间。然而，在本示例中，惯用解决方案的速度优势应该更具顺势疗法的性质。

【解决方案6】：

你不应该像这样递归地做吗？我对编程有点陌生，但我发现了这一点，我认为它有效。

int sum(int n){
return n%10 + sum(n/10);
}

【讨论】：

我会在某处添加一个 if-check in，因为目前sum 将无限调用自身，从而导致该站点的主机错误；) (StackOverflowError)。类似int sum(int n){ if(n > 9){ return n%10 + sum(n/10); } return n;}

【解决方案7】：

如果你喜欢恒定的时间，试试这个：

double d = 10984.491;

// converting to String because of floating point issue of precision
String s = new String(d + "").replaceAll("\\D+","");
int i = Integer.parseInt(s);      

System.out.println(i % 9 == 0 ? 9 : i % 9);

逻辑是，如果您将任何数字加 9，则添加的数字将产生相同的数字。

示例：6 + 9 = 15 然后 1 + 5 = 6（你又得到了 6）。

如果是小数点，请将其删除并添加结果数字。

下面的代码可以解决问题：

i % 9 == 0 ? 9 : i % 9

【讨论】：

这不是问题的答案，因为这个解决方案递归求和，例如：456 -> 4+5+6 = 15 -> 1+5 = 6，而不是456 -> 4+5+6 = 15 但它适合我的情况，所以+1 :)
我看不到任何递归。这个解决方案是错误的。

【解决方案8】：

这应该适用于任何位数，它会返回单个数字的总和

public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    System.out.println("enter a string");
    String numbers = input.nextLine();  //String would be 55
    int sum = 0;
    for (char c : numbers.toCharArray()) {
        sum += c - '0';
    }
    System.out.println(sum); //the answer is 10
}

【讨论】：

【解决方案9】：

不管数字的大小，对所有数字求和。

private static int sumOfAll(int num) {
    int sum = 0;

    if(num == 10) return 1;

    if(num > 10) {
        sum += num % 10;
        while((num = num / 10) >= 1) {
            sum += (num > 10) ? num%10 : num;
        }
    } else {
        sum += num;
    }
    return sum;
}

【讨论】：

@Kaplan 真的。谢谢。改变了。

【解决方案10】：

以下方法将完成任务：

public static int sumOfDigits(int n) {
    String digits = new Integer(n).toString();
    int sum = 0;
    for (char c: digits.toCharArray())
        sum += c - '0';
    return sum;
}

你可以这样使用它：

System.out.printf("Sum of digits = %d%n", sumOfDigits(321));

【讨论】：

new Integer(n) 是浪费。只需致电Integer.toString(n) 或String.valueOf(n)。

【解决方案11】：

可能有点晚了..但这里是递归的方法

public int sumAllDigits(int number) {
    int sum = number % 10;

    if(number/10 < 10){
        return sum + number/10;
    }else{
        return sum + sumAllDigits(number/10);
}

【讨论】：

【解决方案12】：

在 Java 8 中，

public int sum(int number) {
  return (number + "").chars()
                      .map(digit -> digit % 48)
                      .sum();
}

将数字转换为字符串，然后通过减去 '0' (48) 的 ascii 值并将每个字符映射到其数字值并添加到最终总和中。

【讨论】：

【解决方案13】：

Click here to see full program

示例代码：

public static void main(String args[]) {
    int number = 333;
    int sum = 0;
    int num = number;
    while (num > 0) {
        int lastDigit = num % 10;
        sum += lastDigit;
        num /= 10;
    }
    System.out.println("Sum of digits : "+sum);
}

【讨论】：

【解决方案14】：

如果您需要单线，我想这是一个非常好的解决方案：

int sum(int n){
  return n >= 10 ? n % 10 + sum(n / 10) : n;
}

【讨论】：

【解决方案15】：

在 Java 8 中，这可以在一行代码中实现，如下所示：

int sum = Pattern.compile("")
        .splitAsStream(factorialNumber.toString())
        .mapToInt(Integer::valueOf)
        .sum();

【讨论】：

【解决方案16】：

Java 8 递归解决方案，如果您不想使用任何流。

UnaryOperator<Long> sumDigit = num -> num <= 0 ? 0 : num % 10 + this.sumDigit.apply(num/10);

如何使用

Long sum = sumDigit.apply(123L);

上述解决方案适用于所有正数。如果您想要数字的总和，无论是正数还是负数，也可以使用以下解决方案。

UnaryOperator<Long> sumDigit = num -> num <= 0 ? 
         (num == 0 ? 0 : this.sumDigit.apply(-1 * num)) 
         : num % 10 + this.sumDigit.apply(num/10);

【讨论】：

【解决方案17】：

Java 8 解决方案：

int n= 29;    
String.valueOf(n).chars().map(Character::getNumericValue).sum()

【讨论】：

@saurabhkumar 为什么你说不起作用..？我添加了屏幕截图..
抱歉在错误的地方添加了评论
你可以删除截图

【解决方案18】：

可能为时已晚，但我看到这里发布的许多解决方案都使用 O(n^2) 时间复杂度，这对于小输入是可以的，但是当您继续使用大输入时，您可能希望降低时间复杂度.这是我在线性时间复杂度方面所做的工作。

注意：Arunkumar 发布的第二个解决方案是恒定时间复杂度。

    private int getDigits(int num) {
    int sum =0;
    while(num > 0) { //num consists of 2 digits max, hence O(1) operation
        sum = sum + num % 10;
        num = num / 10;
    }   
    return sum;
}
public int addDigits(int N) {
    int temp1=0, temp2= 0;
    while(N > 0) {
        temp1= N % 10;
        temp2= temp1 + temp2;
        temp2= getDigits(temp2); // this is O(1) operation
        N = N/ 10;
    }
    return temp2;
}

请忽略我的变量命名约定，我知道这并不理想。让我用示例输入解释代码，例如“12345”。在一次遍历中，输出必须为 6。

基本上我正在做的是从 LSB 到 MSB ，并在每次迭代中添加找到的总和的数字。

值如下所示

最初 temp1 = temp2 = 0

N     | temp1 ( N % 10)  | temp2 ( temp1 + temp2 )
12345 | 5                | 5   
1234  | 4                | 5 + 4 = 9 ( getDigits(9) = 9)
123   | 3                | 9 + 3 = 12 = 3 (getDigits(12) =3 )
12    | 2                | 3 + 2 = 5 (getDigits(5) = 5)
1     | 1                | 5 + 1 = 6 (getDigits(6) = 6 )

答案是 6，我们避免了一个额外的循环。希望对你有帮助。

【讨论】：

“这是 O(1) 操作”：不，不是。

【解决方案19】：

我的比其他的更简单，希望你能理解这一点，如果你是一个像我这样的新程序员。

import java.util.Scanner;
import java.lang.Math;

public class DigitsSum {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        int digit = 0;
        System.out.print("Please enter a positive integer: ");
        digit = in.nextInt();
        int D1 = 0;
        int D2 = 0;
        int D3 = 0;
        int G2 = 0;
        D1 = digit / 100;
        D2 = digit % 100;
        G2 = D2 / 10;
        D3 = digit % 10;


        System.out.println(D3 + G2 + D1);

    }
}

【讨论】：

【解决方案20】：

除了这里的答案，我可以稍微解释一下。这实际上是一个数学问题。

321 是 300 + 20 + 1 的总和。

如果将 300 除以 100，则得到 3。

如果将 20 除以 10，则得到 2。

如果将 1 除以 1，则得到 1。

在这些操作结束时，你可以将它们全部相加，你会得到 6。

public class SumOfDigits{

public static void main(String[] args) {
    int myVariable = 542;
    int checker = 1;
    int result = 0;
    int updater = 0;

    //This while finds the size of the myVariable
    while (myVariable % checker != myVariable) {
        checker = checker * 10;
    }

    //This for statement calculates, what you want.
    for (int i = checker / 10; i > 0; i = i / 10) {

        updater = myVariable / i;
        result += updater;
        myVariable = myVariable - (updater * i);
    }

    System.out.println("The result is " + result);
}
}

【讨论】：

【解决方案21】：

这是一个简单的程序，用于计算数字 321 的位数。

  import java.math.*;

        class SumOfDigits {
            public static void main(String args[]) throws Exception {
                int sum = 0;
                int i = 321;
                    sum = (i % 10) + (i / 10);
                        if (sum > 9) {
                            int n = (sum % 10) + (sum / 10);
                            System.out.print("Sum of digits of " + i + " is " + n);

                        }else{
                           System.out.print("Sum of digits of " + i + " is " + sum );     

    }

                }
        }


Output:

Sum of digits of 321 is 6

或者简单的你可以使用这个..检查下面的程序。

public class SumOfDigits {

public static void main(String[] args) 
{
    long num = 321;

/*  int rem,sum=0;
    while(num!=0)
    {
        rem = num%10;
        sum = sum+rem;
        num=num/10;
    }
    System.out.println(sum);

    */
    if(num!=0)
    {
        long sum = ((num%9==0) ? 9 : num%9);
        System.out.println(sum);
    }

}

【讨论】：