在 java 中使用字符串生成器反转数字

Question

问题陈述：给定一个 32 位有符号整数，反转整数的数字。

示例 1：

输入：123 输出：321 示例 2：

输入：-123 输出：-321

我的解决方案：

class Solution7{
public int reverse(int x) {
    if(x>Integer.MAX_VALUE || x<Integer.MIN_VALUE) {
        return 0;
    }


    StringBuilder S_rev = new StringBuilder();
    String S_r_v=S_rev.append(Math.abs(x)).reverse().toString();//.toString() String builder to String

   double reverse_no=Double.parseDouble(S_r_v);

    if (x < 0) {
        return -(int)reverse_no;
    }
    return (int)reverse_no;

}

}

我的解决方案适用于大多数测试用例。但是它无法通过一个测试用例，我得到了一个错误

Error：第 10 行：java.lang.NumberFormatException：对于输入字符串：“8463847412-”

如果有人知道这是什么类型的错误，请讨论。

提前谢谢你。

Answer 1

通过将数字转换为 String 并反转符号结束于值的末尾。这会使号码无效。

您不必转换为 String 或 double。您可以使用模块运算符 % 来提取数字：

public int reverse(int x) {
  long result = 0;
  while (x != 0) {
    result *= 10;
    result += x % 10;
    x /= 10;
  }
  if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
    throw new IllegalArgumentException(); // overflow
  }
  return result;
}

Answer 2

您似乎在尝试传入 Integer.MIN_VALUE

当您传入最小整数值时，Math.abs 似乎 return 此处所述的负数

https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html#abs-int-

 Note that if the argument is equal to the value of Integer.MIN_VALUE, the most negative representable int value, the result is that same value, which is negative.

如果 x 是 Integer.MIN_VALUE，您可以检查 x<=Integer.MIN_VALUE 和 return 0，或者处理 Integer.MIN_VALUE

的特殊情况

 if(x== Integer.MIN_VALUE)
      return -8463847412;

Answer 3

如果您一定要使用 StringBuilder 来实现它，这里是：

  public static void main(String[] args) {
    ReverseNum reverseNum = new ReverseNum();
    System.out.println(reverseNum.reverse(-123));
    System.out.println(reverseNum.reverse(123));
    System.out.println(reverseNum.reverse(0));
  }

  public int reverse(int x) {
    int res = 1;
    String xStr = String.valueOf(x);
    StringBuilder builder = null;

    if (xStr.startsWith("-")) {
      builder = new StringBuilder(xStr.substring(1));
      res = -1;
    } else {
      builder = new StringBuilder(xStr);
    }

    return res * Integer.valueOf(builder.reverse().toString());
  }

输出：

-321
321
0

P.S。如果你想避免整数溢出，那么你可以简单地使用 long 而不是 int，像这样：

  public long reverse(int x) {
    long res = 1;
    String xStr = String.valueOf(x);
    StringBuilder builder = null;

    if (xStr.startsWith("-")) {
      builder = new StringBuilder(xStr.substring(1));
      res = -1;
    } else {
      builder = new StringBuilder(xStr);
    }

    return res * Long.valueOf(builder.reverse().toString());
  }

Answer 4

public class ReverseString {
  public static void main(String args[]) {
    ReverseString rs = new ReverseString();
    System.out.println(rs.reverse(-84638));
    System.out.println(rs.reverse(5464867));
  }

  public long reverse(int number) {

    boolean isNegative = number < 0;

    StringBuilder reverseBuilder = new StringBuilder();
    String reversedString = reverseBuilder.append(Math.abs(number)).reverse().toString();
    long reversedStringValue = Long.parseLong(reversedString);

    if(isNegative) {
      return reversedStringValue * -1;
    } else {
      return reversedStringValue;
    }
  }
}

此代码提供了您在需求中提到的输出。并且它还支持整数溢出。您的要求是转换 int 值。因为转换值可能不在 int 范围内，所以以更高格式获取转换值是可以的。我已将反向方法 return 类型更改为 long.

我发现您的代码中存在一些问题。

public int reverse(int x) {
if(x>Integer.MAX_VALUE || x<Integer.MIN_VALUE) {
    return 0;
}

上面的代码段，不是检查值是否在 int 范围内的重点，因为它已经作为字符串接收到参数中。它应该在执行代码行之前抛出错误，因为它无法将较大的值放入 int 变量。

最后，您使用的int数不在int范围内。 (-8463847412)

Answer 5

这个呢？

public class ReverseNumber {
    public static void main(String[] args) {
        System.out.println(reverse(123456));
        System.out.println(reverse(0));
        System.out.println(reverse(-987654));
    }

    private static int reverse(int i) {
        final int signum;
        if(i < 0) {
            signum = -1;
        } else {
            signum = +1;
        }

        int reversedNumber = 0;
        int current = Math.abs(i);

        while(0 < current) {
            final int cipher = current % 10;

            reversedNumber = Math.addExact(Math.multiplyExact(reversedNumber, 10), cipher);
            current = current / 10;
        }

        return signum * reversedNumber;
    }
}

输出：

654321
0
-456789

这个解决方案避免了字符串并且可以处理负数。如果发生整数溢出，它会抛出算术异常。

在 java 中使用字符串生成器反转数字

Reverse a number using String builder in java

java

string

stringbuilder