String 与 int 类型之间的互相转换

1 如何将字串 String 转换成整数 int?

A. 有两个方法:

1). int i = Integer.parseInt([String]); 或

i = Integer.parseInt([String],[int radix]);

2). int i = Integer.valueOf(my_str).intValue();

注: 字串转成 Double, Float, Long 的方法大同小异.

2 如何将整数 int 转换成字串 String ?

A. 有叁种方法:

1.) String s = String.valueOf(i);

2.) String s = Integer.toString(i);

3.) String s = "" + i;

注: Double, Float, Long 转成字串的方法大同小异.

 

int -> String 

int i=12345;
String s="";
第一种方法：s=i+"";
第二种方法：s=String.valueOf(i);
这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？

String -> int 

s="12345";
int i;
第一种方法：i=Integer.parseInt(s);
第二种方法：i=Integer.valueOf(s).intValue();
这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？

以下是答案：

第一种方法：s=i+""; //会产生两个String对象
第二种方法：s=String.valueOf(i); //直接使用String类的静态方法，只产生一个对象

第一种方法：i=Integer.parseInt(s);//直接使用静态方法，不会产生多余的对象，但会抛出异常
第二种方法：i=Integer.valueOf(s).intValue();//Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s))，也会抛

异常，但会多产生一个对象

1.问题思考：

需要明确的是String是引用类型，int是基本类型，所以两者的转换并不是基本类型间的转换，这也是该问题提出的意义所在，SUN公司提供了相应的类库供编程人员直接使用。

2.Integer.parseInt(str) 与 Integer.valueOf(Str).intValue() ：

其实查看Java源码不难发现后者的实现是基于parseInt函数来实现的，所以很有必要分析parseInt源码。

3.Integer.parseInt(str) 源码分析：

[java]  view plain  copy

1. public static int parseInt(String s, int radix)  
2.                throws NumberFormatException  
3.    {  
4.        /* 
5.         * WARNING: This method may be invoked early during VM initialization 
6.         * before IntegerCache is initialized. Care must be taken to not use 
7.         * the valueOf method. 
8.         */  
9.   
10.        if (s == null) {  
11.            throw new NumberFormatException("null");  
12.        }  
13.   
14.        if (radix < Character.MIN_RADIX) {  
15.            throw new NumberFormatException("radix " + radix +  
16.                                            " less than Character.MIN_RADIX");  
17.        }  
18.   
19.        if (radix > Character.MAX_RADIX) {  
20.            throw new NumberFormatException("radix " + radix +  
21.                                            " greater than Character.MAX_RADIX");  
22.        }  
23.   
24.        int result = 0;  
25.        boolean negative = false;  
26.        int i = 0, len = s.length();  
27.        int limit = -Integer.MAX_VALUE;  
28.        int multmin;  
29.        int digit;  
30.   
31.        if (len > 0) {  
32.            char firstChar = s.charAt(0);  
33.            if (firstChar < '0') { // Possible leading "+" or "-"  
34.                if (firstChar == '-') {  
35.                    negative = true;  
36.                    limit = Integer.MIN_VALUE;  
37.                } else if (firstChar != '+')  
38.                    throw NumberFormatException.forInputString(s);  
39.   
40.                if (len == 1) // Cannot have lone "+" or "-"  
41.                    throw NumberFormatException.forInputString(s);  
42.                i++;  
43.            }  
44.            multmin = limit / radix;  
45.            while (i < len) {  
46.                // Accumulating negatively avoids surprises near MAX_VALUE  
47.                <span style="color:#ff0000;">digit = Character.digit(s.charAt(i++),radix);</span>  
48.                if (digit < 0) {  
49.                    throw NumberFormatException.forInputString(s);  
50.                }  
51.                if (result < multmin) {  
52.                    throw NumberFormatException.forInputString(s);  
53.                }  
54.                result *= radix;  
55.                if (result < limit + digit) {  
56.                    throw NumberFormatException.forInputString(s);  
57.                }  
58.                result -= digit;  
59.            }  
60.        } else {  
61.            throw NumberFormatException.forInputString(s);  
62.        }  
63.        return negative ? result : -result;  
64.    }  

加红源码如下：

[java]  view plain  copy

1. public static int digit(char ch, int radix) {  
2.         return digit((int)ch, radix);  
3.     }  

[html]  view plain  copy

1. /* @param   codePoint the character (Unicode code point) to be converted.  
2.  * @param   radix   the radix.  
3.  * @return  the numeric value represented by the character in the  
4.  *          specified radix.  
5.  * @see     Character#forDigit(int, int)  
6.  * @see     Character#isDigit(int)  
7.  * @since   1.5  
8.  */  
9. public static int digit(int codePoint, int radix) {  
10.     return CharacterData.of(codePoint).digit(codePoint, radix);  
11. }  

可以看出加红代码是将字符 => Unicode(字符统一编码) =>  Unicode(数字统一编码) => 数字。

从上面的分析可以发现源码是取出字符串中的每个字符，然后将字符转换为数字进行拼接，但是在拼接的过程中SUN公司的编程人员是将其先拼接为负数，再用三元运算转换选择输出。自己并不认同，因为这样的做法是不利于理解，当然作者可能有自己的考虑，值得揣摩。

4.自己动手，丰衣足食：

  思路：

化整为零 ->  将引用类型的String分解为char；

逐个击破 ->  进本数据类型之间的转换Character.digit(ch,radix) / Character.getNumericValue(ch) 原理相同;

    由点及线-> 将数字放到不同权值得相应位置上，组成int型数值。

 注：

    正负号判断，数值长度判断，数字合法性校验(0-9)...

 CODEING:

[java]  view plain  copy

1. public static int change(String s){  
2.         int result = 0;<span style="white-space:pre;">          </span>    //数值  
3.         int len = s.length();<span style="white-space:pre;">        </span>  
4.         int indexEnd = len - 1;             //控制由右及左取字符（数字）  
5.         int indexBegin = 0;<span style="white-space:pre;">      </span>    //起始位置（存在+ - 号）  
6.         boolean negative = false;<span style="white-space:pre;">    </span>    //确定起始位置及输出结果标志符  
7.         int position = 1;                   //权值：起始位置为个位  
8.         int digit = 0;<span style="white-space:pre;">           </span>    //数字  
9.           
10.     if(len > 0){  
11.         char firstChar = s.charAt(0);  
12.             if (firstChar < '0') {   
13.                 if (firstChar == '-') {  
14.                     negative = true;  
15.                     indexBegin = 1;  
16.                 }else if(firstChar == '+'){  
17.                     indexBegin = 1;  
18.                 }else if (firstChar != '+'){  
19.                     throw new NumberFormatException(s);  
20.                 }   
21.                 if (len == 1) throw new NumberFormatException(s);  
22.             }  
23.               
24.             while (indexEnd >= indexBegin) {  
25.                 //(int) s.charAt(indexEnd--);只是该字符的数字编码，十进制数字的Unicode码范围为48-57  
26.                 if(s.charAt(indexEnd) < 48 || s.charAt(indexEnd)> 57){  
27.                     throw new NumberFormatException(s);  
28.                 }  
29.                 //int temp = Character.getNumericValue(s.charAt(indexEnd--));  
30.                 int temp = Character.digit(s.charAt(indexEnd--), 10);  
31.                 digit = temp * position;  
32.                 result += digit;  
33.                 position *= 10;  
34.             }  
35.         }  
36.         return negative ? -result : result;  
37.     }  

5.学无止境，Java升级版：

[java]  view plain  copy

1. public static int myAtoi(String str) {  
2.         int index = 0, sign = 1, total = 0;  
3.         //1. Empty string  
4.         if(str.length() == 0) return 0;  
5.   
6.         //2. Remove Spaces  
7.         while(str.charAt(index) == ' ' && index < str.length()) // str = str.trim();  
8.             index ++;  
9.   
10.         //3. Handle signs  
11.         if(str.charAt(index) == '+' || str.charAt(index) == '-'){  
12.             sign = str.charAt(index) == '+' ? 1 : -1;  
13.             index ++;  
14.         }  
15.           
16.         //4. Convert number and avoid overflow  
17.         while(index < str.length()){  
18.             int digit = str.charAt(index) - '0';  
19.             if(digit < 0 || digit > 9) break;  
20.   
21.             //check if total will be overflow after 10 times and add digit  
22.             if(Integer.MAX_VALUE/10 < total || Integer.MAX_VALUE/10 == total && Integer.MAX_VALUE %10 < digit)  
23.                 return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;  
24.   
25.             total = 10 * total + digit;  
26.             index ++;  
27.         }  
28.         return total * sign;  
29.     }