Java如何在不使用数组的情况下反转int值

Question

有人能解释一下如何在不使用数组或字符串的情况下反转整数吗？我从网上得到了这段代码，但并不真正理解为什么要使用“+ input % 10”，然后再除以10。

while (input != 0) {
    reversedNum = reversedNum * 10 + input % 10;
    input = input / 10;   
}

怎样使用这个示例代码只反转奇数数字。比如我输入12345，那么它会将奇数数字反转为531。

- user236501

Answer 1

如何在Java中反转一个int值 - 原理

1. 使用模运算（%）提取出输入整数的最右边的数字。例如：(1234 % 10) = 4

2. 将整数乘以10会将其“向左移”，在该数字右边显示一个零，例如：(5 * 10) = 50

3. 将整数除以10将去除最右边的数字。(75 / 10) = 7

如何在Java中反转一个int值 - 伪代码：

a. 提取输入数字的最右边的数字。例如：(1234 % 10) = 4

b. 取出该数字（4）并添加到一个新的翻转数字中。

c. 将翻转数字乘以10（4 * 10）= 40，这在你的（4）右侧暴露出一个零。

d. 将输入除以10（去掉最右边的数字）。(1234 / 10) = 123

e. 再次从步骤a开始，使用123作为输入。

如何在Java中反转一个int值 - 工作代码

public int reverseInt(int input) {
    long reversedNum = 0;
    long input_long = input;

    while (input_long != 0) {
        reversedNum = reversedNum * 10 + input_long % 10;
        input_long = input_long / 10;
    }

    if (reversedNum > Integer.MAX_VALUE || reversedNum < Integer.MIN_VALUE) {
        throw new IllegalArgumentException();
    }
    return (int) reversedNum;
}

在真正的工作世界中，你永远不会做这样的事情。然而，通过自己解决问题的过程是区分能够解决问题的人和那些想要解决问题但除非得到博客上好心人的指导，否则无法解决问题的人的关键所在。

- Eric Leschinski

---

在实践中，您将把整数转换为字符串并反转它，但当然整数到字符串的转换就是这样发生的。 - Cruncher

链接已损坏！ - RBz

为什么你使用 long，却只返回一个 int？这与除法精度有关吗？ - Ghoti and Chips

这应该是被接受的答案。太棒了，谢谢！ - Metin Dagcilar

这是2005年至2010年期间一个流行的程序员面试问题，第三次在正式场合被问到后，我决定彻底解决它。我没想到它会像这样受欢迎。这主要是一道入门问题，因为程序员很少或从不需要像这样接近底层的位移操作。有一种理论认为，在2005年之前编码的程序员认为位移操作是圣杯，所以这是一种找出你是否已经编码超过15年的程序员的方法。伟大的编码人员的标志是每天练习10年。 - Eric Leschinski

Answer 2

我不是很清楚您的奇数指的是什么。 这段代码的工作方式是（它不是一个特定于Java的算法） 例如： 输入=2345 第一次进入while循环 rev = 5 input = 234 第二次 rev = 5 * 10 + 4 = 54 input = 23 第三次 rev = 54 * 10 + 3 input = 2 第四次 rev = 543 * 10 + 2 input = 0

因此，反转后的数字是5432。 如果只想要反转后数字中的奇数，则使用以下代码：

while (input != 0) {    
    last_digit = input % 10;
    if (last_digit % 2 != 0) {     
        reversedNum = reversedNum * 10 + last_digit;

    }
    input = input / 10; 
}

- sheki

---

你的代码有错误。应该是 reversedNum = reversedNum * 10 + input % 10;。 - Faisal Feroz

现在应该是正确的了。输入=input/10 会自动处理，不会出现无限循环。 - sheki

如果输入为1534236469，那么结果是什么？ - Amaresh Jana

01的反转是什么？ - Angad Singh

@AngadSingh，01不等同于1吗？ int a = 01; System.out.println(a); // 输出1 - user2977578

@AmareshJana 如果reversedNum是一个整数，那么在最后一步将964632435乘以10将导致整数溢出。你将无法得到预期的答案。 在Java中，int类型为32位，范围从-2,147,483,648到+2,147,483,647。 - Anurag Sidana

Answer 3

你可以简单地使用这个

    public int getReverseInt(int value) {
        int resultNumber = 0;
        for (int i = value; i !=0; i /= 10) {
            resultNumber = resultNumber * 10 + i % 10;
        }
        return resultNumber;        
    }

您可以使用此方法来反转您想要的给定值。

- Ganesa Vijayakumar

Answer 4

while (num != 0) {
    rev = rev * 10 + num % 10;
    num /= 10;
}

那是我用于解决这个问题的方法，它运行良好。 更多细节：

num % 10

这条语句将会获取原始数字的最后一位数字。

num /= 10

这个语句将从原始数字中删除最后一位数字，因此我们可以确信while循环将终止。

rev = rev * 10 + num % 10

这里的 rev*10 操作会将数值向左移动一位，然后加上原始数值的最后一位。
如果原始数值是 1258，在运行过程中当 rev = 85、num = 12 时，执行以下步骤:
num%10 = 2
rev*10 = 850
rev*10 + num%10 = 852

- Ahmed Hamdy

Answer 5

int aa=456;
int rev=Integer.parseInt(new StringBuilder(aa+"").reverse());

- Abhishek Sahay

---

添加 "" 是必要的，否则 StringBuilder 会生成一个空输出，即使文档说构造函数接受一个整数值。 - Anvita Shukla

Answer 6

不使用循环的Java解决方案。响应更快。

int numberToReverse;//your number 
StringBuilder sb=new StringBuilder();
sb.append(numberToReverse);
sb=sb.reverse();
String intermediateString=sb.toString();
int reversedNumber=Integer.parseInt(intermediateString);

- bhargav kumar gunda

---

sb.reverse() 内部有一个循环。 - Steephen

你是对的 @Steephen 我写了一个简单的方法来获取结果 - bhargav kumar gunda

Answer 7

获取任何数字的最后一位，我们需要将它除以10，这样就可以得到一个位于最后的数字或零。如果我们持续地这样操作，我们会得到整个数字的反向整数。

    int number=8989,last_num,sum=0;
    while(number>0){
    last_num=number%10; // this will give 8989%10=9
    number/=10;     // now we have 9 in last and now num/ by 10= 898
    sum=sum*10+last_number; //  sum=0*10+9=9;
    }
    // last_num=9.   number= 898. sum=9
    // last_num=8.   number =89.  sum=9*10+8= 98
   // last_num=9.   number=8.    sum=98*10+9=989
   // last_num=8.   number=0.    sum=989*10+8=9898
  // hence completed
   System.out.println("Reverse is"+sum);

- Manish Choudhary

Answer 8

import java.util.Scanner;

public class Reverse_order_integer {
    private static Scanner scan;

    public static void main(String[] args) {
        System.out.println("\t\t\tEnter Number which you want to reverse.\n");
        scan = new Scanner(System.in);
        int number = scan.nextInt();
        int rev_number = reverse(number);
        System.out.println("\t\t\tYour reverse Number is = \"" + rev_number
                           + "\".\n");
    }

    private static int reverse(int number) {
        int backup = number;
        int count = 0;
        while (number != 0) {
            number = number / 10;
            count++;
        }
        number = backup;
        int sum = 0;
        for (int i = count; i > 0; i--) {
            int sum10 = 1;
            int last = number % 10;
            for (int j = 1; j < i; j++) {
                sum10 = sum10 * 10;
            }
            sum = sum + (last * sum10);
            number = number / 10;
        }
        return sum;
    }
}

- Harsh Kevadia

Answer 9

补充一下，希望能让解决方案更完整。

@sheki的逻辑已经给出了在Java中反转整数的正确方法。如果您假设您使用的输入和得到的结果始终在范围[-2147483648, 2147483647]内，那么您可以安全地使用@sheki的代码。否则，最好捕获异常进行练习。

Java 8引入了方法addExact、subtractExact、multiplyExact和toIntExact。这些方法将在溢出时抛出ArithmeticException。因此，您可以使用下面的实现来实现一个干净且稍微安全的方法来反转一个整数。通常，我们可以使用上述方法来进行数学计算并明确处理溢出问题，如果实际使用中存在溢出可能性，这是始终推荐的。

public int reverse(int x) {
    int result = 0;

    while (x != 0){
        try {
            result = Math.multiplyExact(result, 10);
            result = Math.addExact(result, x % 10);
            x /= 10;
        } catch (ArithmeticException e) {
            result = 0; // Exception handling
            break;
        }
    }

    return result;
}

- Isaac_Zhu

---

你的范围有误，2147483647 会导致输出 7463847412，即溢出。实际允许/不允许的数字集合要复杂得多。 - Brydon Gibson

Answer 10

public static void main(String args[]) {
    int n = 0, res = 0, n1 = 0, rev = 0;
    int sum = 0;
    Scanner scan = new Scanner(System.in);
    System.out.println("Please Enter No.: ");
    n1 = scan.nextInt(); // String s1=String.valueOf(n1);
    int len = (n1 == 0) ? 1 : (int) Math.log10(n1) + 1;
    while (n1 > 0) {
        rev = res * ((int) Math.pow(10, len));
        res = n1 % 10;
        n1 = n1 / 10;
        // sum+=res; //sum=sum+res;
        sum += rev;
        len--;
    }
    // System.out.println("sum No: " + sum);
    System.out.println("sum No: " + (sum + res));
}

这将返回整数的反转

- pankaj

---

最好您提供代码解释，以及说明为什么在这里涵盖了迄今未涵盖的其他要点。 - Ashish Kumar