每日一练---＞7. 整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。
 

示例 1：

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

输入：x = -123
输出：-321

解法1：

        将数组部分反转，然后利用StringBuffer的reverse()方法将字符串进行反转，然后比较反转后的字符串于Integer.MAX_VALUE反转形成的字符串进行比较，该比较利用的String类型的compareTo()方法。

介绍下compareTo()的用法：

算了，太晚了，明天早八，先粘代码：

解法一：

        我的思路就是将整数转为StringBuffer类型的值，然后通过StringBuffer类的reverse()将字符串反转过来，然后将其使用compareTo()方法将之与Integer.MAX_VALUE转成的字符串进行比较，当然先判断整数的正负，如果是负数，那么compareTo()的返回值可以为0，其余的返回值只要大于0就说明该整数反转形成的数不在[-Integer.MAX_VALUE,Integer.MAX_VALUE-1)范围内，直接返回零。 如果compareTo()方法的返回值小于零，说明该数的反转不会造成数据的溢出，然后判断是否要加负号，然后返回。

 public int reversal(int n){
        String str1=""+Integer.MAX_VALUE;
//        System.out.println(str1);
        String str=""+n;
        boolean isFu=false;
        if(str.charAt(0)=='-') {
            isFu = true;
            str = "" + new StringBuffer(str.substring(1)).reverse();
        }else{
            str="" + new StringBuffer(str).reverse();
        }
        //判断反转是否比Integer.MAX_VALUE大
        if(str.length()>=10){
            if(isFu&&str.compareTo(str1)==0){

            }else if(str.compareTo(str1)>=0){
//                System.out.println(">");
                return 0;
            }
        }
        if(isFu){
            str="-"+str;
        }
        Integer integer = Integer.parseInt(str);
        int num=integer;
        return num;
    }

解法二：通过除10取余的方法计算出该整数的反转。
     当然在反转的过程中是仍然可能出现溢出的，所以我们每一次都要进行提前比较，查看下次是否会溢出。
     上溢举例： 反转过程中的 result  ,  下次取余的值 remainder
     那么下次计算的result1=result*10+remainder，但是result1是有可能会溢出的
     那么怎么判断会不会不溢出呢？
     不溢出的条件为result1<=Integer.MAX_VALUE,  也就是result*10+remainder<=Integer.MAX_VALUE
     -->  result*10-Integer.MAX_VALUE<=-remainder
     这里可以不用这么细致，因为如果整数n 也是和最大整数位数一样，那么n的最高位一定是小于等于2的，也就是反转过后的最低位一定是小于7的，
     但是如果是字符串转数字就不一定了。
     InInteger.MAX_VALUE=(Integer.MAX_VALUE/10)*10+Integer.MAX_VALUE%10     Integer.MAX_VALUE%10=7
     -->result*10-(Integer.MAX_VALUE/10)*10<=7-remainder
     -->result-Integer.MAX_VALUE/10<=(7-remainder)/10
     因为remainder的值为0~9，所以
     -->  result-Integer.MAX_VALUE/10<0
     -->result<Integer.MAX_VALUE/10
     也就是说要满足result1不会向上溢出，只要满足result<Integer.MAX_VALUE/10就可以了
     那么不会下溢的条件为：result<Integer.MIN_VALUE/10

public int reverse1(int x){
        int result=0;
        while(x!=0){
            int num=x%10;
//            if(Integer.MAX_VALUE-num<result*10||Integer.MIN_VALUE-10>result*10){
//                return 0;
//            }
            if(result<Integer.MIN_VALUE/10||result>Integer.MAX_VALUE/10){
                return 0;
            }
            result=result*10+num;
            x/=10;
        }
        return result;
}