Reverse digits of an integer.
Example1: x = 123, return 321
Example2: x = -123, return -321
The input is assumed to be a 32-bit signed integer. Your function should return 0 when the reversed integer overflows.

反序输出整形，当数太大的时候要溢出返回0

My View

我想到的是很简单的反序，出于java优越的语言条件，写了一个调库的算法（调库就没意思了，所以就是写着玩玩）

class Solution {
    public int reverse(int x) { 
         try{
             int a = Integer.parseInt(new StringBuffer(String.valueOf(Math.abs(x))).reverse().toString());     
             if(x<0){
                 return a*-1;   
             }else{
                 return a;
             }   
         }catch(NumberFormatException e){
             return 0;
         }
    }
}

一层套一层……可读性就很差了，主要是把传进来的int值转换为绝对值，然后转换为字符串，通过StringBuffer构造，经过reverse函数反序，最后toString返回字符串，最后的最后，强转为整形。

在这里判断是否溢出用的是try catch，当数字溢出没法转换为整形的时候，就会抛出异常，然后在catch中捕获就ok了。

当然效率不是很高，打败了34%的用户。

同样，我们可以不借助API的reverse方法，来自己实现一个。

  public int reverse(int x) {
        try{
             int a = Integer.parseInt(reverse_my(String.valueOf(Math.abs(x))));
             if(x<0){
               return a*-1;   
             }
               return a;
         }catch(NumberFormatException e){
             return 0;
       }
    }
    
    public String reverse_my(String a){
        StringBuffer sb = new StringBuffer();
        for (int i = a.length() - 1; i >= 0; i--) {
            sb.append(a.charAt(i));
        }
        return sb.toString();
    }

效果是一样的哈，也是打败了34%的用户。

Solution

题目太简单……官方都没给优秀的方案，于是去社区看大神的方案。

一个七行的代码。

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

主要通过算术运算来达到反序的效果。

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

    while (x != 0)
    {
        int tail = x % 10;
        int newResult = result * 10 + tail;
        if ((newResult - tail) / 10 != result)
        { return 0; }
        result = newResult;
        x = x / 10;
    }

    return result;
}

这个也是如此，但是楼主的解决溢出方面和独特，利用溢出之后数值变化来辨别，

If overflow exists, the new result will not equal previous one.
No flags needed. No hard code like 0xf7777777 needed.

当整形（-xxxx - xxxx）溢出之后可能进入起始点或者终止点,那么此时返回去计算上一个值肯定是得不到原结果，那么这时候就认为是溢出。

这个方法确实很好，但是我还是喜欢显而易见的，比如第一种方法。