java中字符串与数字的转换，parseInt()、parseDouble()方法和valueOf()区别(这里包括力扣一道整数反转题目)

区别

• Integer.parseInt(s) 的作用就是把字符串 s 解析成有符号基本类型的 int；
• Integer.valueOf(s) 把字符串 s 解析成 Integer 对象类型，返回的对象可以调用 Integer 中的方法；

接下来我们看看Java源码，进行分析，这里大家直接跟着源码一步一步来，我都有写注释的，可以深入理解方法，当然不想看的可以直接到下方去看实例演示，并不难，就是可以更多了解底层知识。

Integer.ParseInt()

这里CTRL点击进入源码：

    public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }

可以看到，这个被我们调用的 parseInt() 方法返回了一个重载方法：

 public static int parseInt(String s, int radix)
                throws NumberFormatException
    {
        /*
         * WARNING: This method may be invoked early during VM initialization
         * before IntegerCache is initialized. Care must be taken to not use
         * the valueOf method.
         */

        //这里肯定要满足基本要求
        if (s == null) {//字符串为空 抛出异常
            throw new NumberFormatException("null");
        }

        if (radix < Character.MIN_RADIX) {//进制数小余2 抛出异常
            throw new NumberFormatException("radix " + radix +
                                            " less than Character.MIN_RADIX");
        }

        if (radix > Character.MAX_RADIX) {//进制数大于36 抛出异常
            throw new NumberFormatException("radix " + radix +
                                            " greater than Character.MAX_RADIX");
        }

        boolean negative = false;//纪录整数符号
        int i = 0, len = s.length();
        int limit = -Integer.MAX_VALUE;//边界

        if (len > 0) {
            char firstChar = s.charAt(0);//首个字符 数字？正负号？还是其他？
            if (firstChar < '0') { // Possible leading "+" or "-"
                if (firstChar == '-') {
                    negative = true;//标记负数
                    limit = Integer.MIN_VALUE;//最小负数边界
                } else if (firstChar != '+') {
                    throw NumberFormatException.forInputString(s);
                }

                if (len == 1) { // Cannot have lone "+" or "-"
                    throw NumberFormatException.forInputString(s);
                }
                i++;
            }
            int multmin = limit / radix;//根据进制来调整边界 以防越界
            int result = 0;
            while (i < len) {
                // Accumulating negatively avoids surprises near MAX_VALUE
                //Character.digit() 用于将字符转为为对应进制的整数
                //如果该字符不是进制内的就返回-1，例如输入的字符是9，但是进制是2，那么就不符合，则会返回-1；
                int digit = Character.digit(s.charAt(i++), radix);
                if (digit < 0 || result < multmin) {
                    throw NumberFormatException.forInputString(s);
                }
                result *= radix;
                if (result < limit + digit) {
                    throw NumberFormatException.forInputString(s);
                }
                result -= digit;
            }
            return negative ? result : -result;//正负数
        } else {//字符串长度小余0 那不是闹吗
            throw NumberFormatException.forInputString(s);
        }
    }

Integer.Valueof()

这里CTRL点击进入源码：

    public static Integer valueOf(String s, int radix) throws NumberFormatException {
        return Integer.valueOf(parseInt(s,radix));
    }    

    public static Integer valueOf(String s) throws NumberFormatException {
        return Integer.valueOf(parseInt(s, 10));
    }

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

可以看出 valueOf(String s, int radix) 和 valueOf(String s) 都是直接调用返回了 parseInt 方法，而 valueOf(int i) 则是一个 int 转成 Integer 的自动装箱。

Double.parseDouble()、Double.Valueof():

    public static double parseDouble(String s) throws NumberFormatException {
        return FloatingDecimal.parseDouble(s);
    }
    
    public static Double valueOf(String s) throws NumberFormatException {
        return new Double(parseDouble(s));
    }

 这里就不过多讲解了，两者关系与Integer类中两者关系所差不多

无论是double还是int，转换为字符串只需要用到类中toString()方法

这里代码基本演示一下功能：

package com.zzu.parse;

public class parseIntDemo1 {
    public static void main(String[] args) {
        String str1 = "5201314";
        String str2 = "3.1415926";

        System.out.println(Integer.parseInt(str1));
        System.out.println(Integer.valueOf(str1));

        System.out.println(Double.parseDouble(str2));
        System.out.println(Double.valueOf(str2));

        double num1 = 1314520.1;
        System.out.println(Double.toString(num1));

        int num2 = 1314520;
        System.out.println(Integer.toString(num2));

    }
}

5201314
5201314
3.1415926
3.1415926
1314520.1
1314520

这有一道现成的题目：

【LeetCode】7.整数反转：

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

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

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

示例 1：

输入：x = 123
输出：321

示例 2：

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

示例 3：

输入：x = 120
输出：21

示例 4：

输入：x = 0
输出：0

提示：

• -231 <= x <= 231 - 1

class Solution {
    public int reverse(int x) {
        boolean flag = true;
        int res = 0;
        if(x<0) {//负数要特殊注意一下
            flag = false;
            x = -x;
        }
        try{
            res = Integer.parseInt(new StringBuilder(Integer.toString(x)).reverse().toString());
            if(!flag) res = -res;
        }catch(NumberFormatException  e){//越界处理
        }finally{
            return res;
        }
        
    }
}