用了两种解法
第一种朴素思路，将数字转化成大字符串，然后进行字符串颠倒，最后转回数字。如果转换出错，代表溢出（之前别的题解里看到的奇怪套路...）
第二种稍微高效写的写法，利用取余公式获取最后一位数字，然后添加到另一个数字的个位上

Code-1

class Solution {
    public int reverse(int x) {
	// 数字转化为字符串 
        String ss = Integer.toString(x);
        boolean postitive = true;
	// 判断是整数还是负数
        if (ss.startsWith("-")) {
            postitive = false;
        }
        char[] chs; 
        chs = postitive ? ss.toCharArray() : ss.substring(1).toCharArray();
        int len = chs.length;
        // 双指针对调字符
        for(int start = 0, end = len -1 ; start < end; start++, end--) {
            char tmp = chs[end];
            chs[end] = chs[start];
            chs[start] = tmp;
        }
        Integer ans ;
        // 比较离谱的做法，利用异常捕获来判断是否会转换溢出🤣
        try {
            ans = postitive ? Integer.parseInt(new String(chs)) : Integer.parseInt("-" + new String(chs));
        } catch(Exception e) {
	    // 转换溢出时
            return 0;
        }
        return ans;
    }

Code-2

// 常见的颠倒数字
class Solution {
    public int reverse(int x) {
        if (x == 0) return 0; 
        int b = 0;
        boolean positive = true;
        if (x < 0) {
            positive = false;
            x = x * -1;
        } 

        int carry;
        while(x > 0) {
            // 个位数
            carry = x % 10;
            // 这里是方法2的精华，
            // 如果b已经大于Integer正数值/10，则下一步 b * 10必定溢出，更何况还加上了一个数。可以用数学证明
            if (b > Integer.MAX_VALUE / 10) return 0;
            b = b * 10 + carry;
            x /= 10;
        }

        return b = positive ? b : -b;
    }
}

Q.E.D.