LeetCode——第七题：反转整数

题目

给定一个 32 位有符号整数，将整数中的数字进行反转。注意：范围溢出，返回0。

示例

输入: 123
输出: 321

输入: -123
输出: -321

输入: 120
输出: 21

代码

自己写的。惨不忍睹，不知道什么玩意儿。

public static int reverse(int x) {
        boolean flag = x < 0;
        long y;
        String xx = String.valueOf(x);
        char[] x1 = xx.toCharArray();
        System.out.println(x1);
        int k;
        for(k = x1.length - 1;k >= 0;k--) {
            if((int)(x1[k]-48) != 0 || k == 0) {
                break;
            }
        }
        y = (int)(x1[k]-48);
        for(int i = k - 1;i>=0;i--) {
            y = y*10+(int)(x1[i]-48);
        }
        if(flag) {
            y = -y;
        }
        if(y > Integer.MAX_VALUE) {
            y = 0;
        }
        return (int) y;
    }

网上找的：
1。利用字符串反转

public static int reverse(int x) {
        String str = String.valueOf(Math.abs(x));
        StringBuffer str1 = new StringBuffer(str);
        String str2 = str1.reverse().toString();
        //溢出判断
        if(Long.parseLong(str2) > Integer.MAX_VALUE) {
            str2 = "0";
        }
        return x > 0 ? Integer.parseInt(str2) : -Integer.parseInt(str2);
    }

说明：第二次做这个题用这个字符串反转的方法，发下这个方法当传入Integer.MIN_VALUE时会报错。（因为Integer.MIN_VALUE在源码中给出说明是abs返回的还是原值，试了一下，用-1乘它也还是原值）因此需要对这个特殊值判断一下，见下方。
2。连续求余
1）用while循环

public static int reverse(int x) {
        long result = 0L;
        int temp = Math.abs(x);
        while(temp > 0) {
            result = result*10 + temp%10;
            if(result > Integer.MAX_VALUE) {
                return 0;
            }
            temp /= 10;
        }
        return x > 0 ? (int)result : -(int)result;
    }

2）用for循环

public static int reverse(int x) {
        long re = 0L;
        int temp = Math.abs(x);
        for(;temp > 0;temp/=10) {
            re = re*10 + temp%10;
            //溢出判断
            if(re > Integer.MAX_VALUE) {
                return 0;
        }

        }
        return (int)(x > 0 ? re : -re);
    }

最后

一开始没明白为啥会溢出，后来一问才知道。丢脸ing。
就比如说2147483649,这个数，反过来就是溢出了范围，比最大值还大。
接机复习一波

java基本类型范围

char： 0—2^8-1 (0—255)
boolean： true和false
byte： -2^7—2^7-1 （-128~127）
short： -2^15—2^15-1 （-32768~32767）
int： -2^31—2^31-1 （-2147483648~2147483647）
long： -2^63—2^63-1 （-9223372036854774808~9223372036854774807）
float： 1.4E-45—3.4028235E38
double： 4.9E-324—1.7976931348623157E308

第二次做：

package leetCode;
/**
 * 反转整数，二刷
 * @author dhc
 *
 */
public class SevenSecond {
    //转字符串，反转字符串,在转整数（不知道字符串转整数的函数可以自动忽略前面的0，而多此一举）  32ms
    public static int sub(int x,int flag) {
        StringBuffer sb = new StringBuffer(String.valueOf(x));
        String tem = sb.reverse().toString();
        /*int index = 0;
        for (int i = 0; i < tem.length(); i++) {
            if(tem.charAt(i) == '0') {
                continue;
            } else {
                index = i;
                break;
            }
        }
        String tem1 = tem.substring(index);*/
         //在这布莫名其妙的就把Integer.MIN_VALUE排除了，写的时候并没有考虑,本来考虑的是可能是一个超出int的数，
        //但是传出的数是int，所以这部凑巧，同时也可以用条件x==Integer.MIN_VALUE
        //同时用一个变量来标记正负，感觉也优点蠢，见reverse1（int x）方法
        if(tem.length() > 10) { 
            return 0;
        } else {
            long t = Long.parseLong(tem);
            if(flag == 1) {
                if(t > Integer.MAX_VALUE) {
                    return 0;
                } else {
                    return (int)t;
                }
            }else {
                if(-t < Integer.MIN_VALUE) {
                    return 0;
                } else {
                    return -(int)t;
                }
            }
        }
    }
    public static int reverse(int x) {
        int flag = x >= 0 ? 1: -1;
        return sub(Math.abs(x),flag);
    }
    public static int reverse1(int x) {
        //Integer.MIN_VALUE是个特殊情况，无法得到它的绝对值
        if(x == Integer.MIN_VALUE) {
            return 0;
        }
        StringBuffer sb = new StringBuffer(String.valueOf(Math.abs(x)));
        System.out.println(sb);
        String tem = sb.reverse().toString();
        long t = Long.parseLong(tem);
        if(t > Integer.MAX_VALUE) {
            return 0;
        }
        return x>0?(int)t:-(int)t;

    }

    public static void main(String[] args) {
        System.out.println(reverse(Integer.MIN_VALUE));
    }
}