我很难找到解决这个问题的方法。我正在尝试用Java开发一个带有数字的程序，例如321，并找到数字的总和，在这种情况下3 + 2 + 1 = 6.我需要任何三位数字的所有数字将它们加在一起，并使用％余数符号存储该值。这让我很困惑，我会很感激任何想法。
答案 0 :(得分：34)
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);
}
<强>输出
6
答案 1 :(得分：3)
您可以使用递归
来完成//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;
}
答案 2 :(得分：3)
递归总是比循环快！
最短和最好：
public static long sumDigits(long i) {
return i == 0 ? 0 : i % 10 + sumDigits(i / 10);
}
答案 3 :(得分：2)
使用流的简单解决方案：
int n = 321;
int sum = String.valueOf(n)
.chars()
.map(Character::getNumericValue)
.sum();
答案 4 :(得分：1)
这应该适用于任意数量的数字，它将返回单个数字的总和
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
}
答案 5 :(得分：1)
你应该不能递归这样做吗？我对编程很陌生，但我追溯到这一点，我认为它有效。
int sum(int n){
return n%10 + sum(n/10);
}
答案 6 :(得分：1)
如果你喜欢不停的时间，试试这个：
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
答案 7 :(得分：0)
Java 8解决方案：
int n= 29;
String.valueOf(n).chars().map(Character::getNumericValue).sum()
答案 8 :(得分：0)
无映射->更快的lambda解决方案
Integer.toString( num ).chars().boxed().collect( Collectors.summingInt( (c) -> c - '0' ) );
...或Unicode兼容
Integer.toString( num ).codePoints().boxed().collect( Collectors.summingInt( Character::getNumericValue ) );
答案 9 :(得分：0)
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);
答案 10 :(得分：0)
如果您需要单线，我想这是一个非常好的解决方案：
int sum(int n){
return n >= 10 ? n % 10 + sum(n / 10) : n;
}
答案 11 :(得分：0)
对所有数字求和，而不考虑数字的大小。
private static int sumOfAll(int num) {
int sum = 0;
if(num > 10) {
sum += num % 10;
while((num = num / 10) >= 1) {
sum += (num > 10) ? num%10 : num;
}
}
return sum;
}
答案 12 :(得分：0)
在Java 8中，
public int sum(int number) {
return (number + "").chars()
.map(digit -> digit % 48)
.sum();
}
将数字转换为字符串，然后通过减去＆＃39; 0＆＃39;的ascii值将每个字符映射到它的数字值。 （48）并加入最后的总和。
答案 13 :(得分：0)
可能会迟到..但这是你如何递归地做到的
series: [
{
type : 'line',
<#--diagonal line-->
data :[[-10,-10], [30,40]], // to be calculated dynamically
lineWidth: 0.5,
marker : {
enabled : false
}
},
{
color: 'rgb(0,85,152)',
data: [[2,3],[6,7],[8,9]]
}
]
答案 14 :(得分：0)
可能为时已晚，但我发现此处发布的许多解决方案使用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;
}
请忽略我的变量命名约定，我知道它并不理想。让我用样本输入解释代码，例如＆＃34; 12345＆＃34 ;.在单次遍历中输出必须为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，我们避免了一个额外的循环。 我希望它有所帮助。
答案 15 :(得分：0)
在Java 8中，这可以在一行代码中实现，如下所示：
int sum = Pattern.compile("")
.splitAsStream(factorialNumber.toString())
.mapToInt(Integer::valueOf)
.sum();
答案 16 :(得分：0)
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);
}
答案 17 :(得分：0)
以下方法将执行任务：
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));
答案 18 :(得分：-1)
除了这里的答案，我可以解释一下。这实际上是一个数学问题。
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);
}
}
答案 19 :(得分：-1)
这是一个简单的程序，用于数字321的数字之和。
// HTML of the test
<div id="timespan"></div>或者很简单，您可以在程序下面使用此程序。
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