Java基础类型之间的转换

 一、基础类型间的转换

 1 public class TransferTest {
 2     public static void main(String[] args) {
 3 
 4         //String转为int: 两种方法
 5         String str = "100";
 6         int a1 = Integer.valueOf(str);
 7         int a2 = Integer.parseInt(str);
 8 
 9         //int转为String: 三种方法
10         int a = 100;
11         String str1 = String.valueOf(a);
12         String str2 = Integer.toString(a);
13         String str3 = "" + a;
14 
15         //long/Long转为String
16         long l1 = 1001L;
17         Long l2 = 100L;
18         String s1 = String.valueOf(l1);//String.valueOf(l2)
19         String s2 = Long.toString(l1);//Long.toString(l2);
20 
21         //long转为Long
22         l2 = l1;//自动装箱拆箱
23         System.out.println(l2);
24         l2 = Long.valueOf(l1);
25 
26         //Long转为long
27         l1 = l2.longValue();
28 
29         //String转为long
30         String number = "1234567890";
31         //方法一:调用Long类型的parseLong方法
32         long num1 = Long.parseLong(number);
33         //方法二:强制转换
34         long num2 = new Long(number);
35         //方法三:先转换Long类型,再使用longValue方法转为long
36         long num3 = Long.valueOf(number).longValue();
37 
38         /**
39          * Long.ValueOf("String")与Long.parseLong("String")的区别:
40          * Long.ValueOf("String")返回Long包装类型
41          * Long.parseLong("String")返回long基本数据类型
42          */
43 
44         //long转为int
45         Long n1 = 1000 * 100 * 85900L;
46         int m1 = n1.intValue();
47 
48         //或者
49         long n2 =1000 * 100 * 85900L;
50         int m2 = (int)n2;
51         int m3 = Math.toIntExact(n2);//long向int强转可能会出现数据溢出,Math.toIntExact()方法更为安全,在溢出的情况下会抛出ArithmeticException
52 
53         //int和Integer互换
54         //convert i(int) to j(Integer)
55         int i = 0;
56         Integer j = Integer.valueOf(i);
57 
58         //convert t(Integer) to n (int)
59         Integer t = 10;
60         int n = t.intValue();
61 
62         //char转为int
63         char ch = '8';
64         int b1 = ch - '0';
65         int b2 = ch - 48;
66         //使用包装类:
67         Character ch2 = new Character(ch);
68         int b3 = Integer.parseInt(ch2.toString());
69         int b4 = Integer.parseInt(Character.toString(ch2));
70 
71         //int转为char
72         char ch1 = (char) (a + 48);
73 
74         //String转为char数组
75         String s = "abcd";
76         char[] chs = s.toCharArray();
77         //String取单个字母
78         s.charAt(0);
79 
80         //char转为String
81         String str10 = String.valueOf(ch);
82         String str20 = Character.toString(ch);
83 
84         //char数组转为String
85         char[] chars = {'a', 'b', 'c', 'd'};
86         String str11 = String.valueOf(chars);
87         String str21 = String.valueOf(chars[0]);
88 
89 
90     }
91 }

 二、Integer.parseInt(s)与Integer.valueOf(s)的区别

1、Integer.parseInt(s)用法

1     String s1 = "1000";
2     String s2 = "1000";
3     int n1 = Integer.parseInt(s1);
4     int n2 = Integer.parseInt(s2);
5     if (n1 == n2) {
6         System.out.println(true);
7     }

输出:

Java基础类型之间的转换 

Integer.parseInt(s)的作用就是把字符串s解析成有符号的int基本类型。

2、Integer.valueOf(s)用法

1     String s = "123";
2     Integer integer1 = Integer.valueOf(s);
3 
4     int i = 345;
5     Integer integer2 = Integer.valueOf(i);
6     System.out.println("integer1 : " + integer1);
7     System.out.println("integer2 : " + integer2);

输出:

Java基础类型之间的转换

Integer.valueOf(s)把字符串s(或int基本类型)解析成Integer对象类型,返回的integer 可以调用对象中的方法。

3、Integer.parseInt(s)与Integer.valueOf(s)的区别

 1     //Integer.parseInt
 2     String s3 = "10000";
 3     if (Integer.parseInt(s3) == Integer.parseInt(s3)) {
 4         System.out.println(true);
 5     }
 6 
 7     //Integer.valueOf:当字符串对应的整数值在 -128~127之间
 8     String s4 = "100";
 9     Integer i1 = Integer.valueOf(s4);
10     Integer i2 = Integer.valueOf(s4);
11     if (i1 == i2) { //两个对象相等
12         System.out.println("i1 == i2");
13     }
14     if (i1.equals(i2)) { //两个对象中的value值相等
15         System.out.println("i1.equals(i2)");
16     }
17 
18 
19     //Integer.valueOf:当字符串对应的整数值不在-128~127之间
20     String s5 = "1000";
21     Integer i3 = Integer.valueOf(s5);
22     Integer i4 = Integer.valueOf(s5);
23     if (i3 != i4) { //两个对象不相等
24         System.out.println("i3 != i4");
25     }
26     if (i1.equals(i2)) { //两个对象中的value值相等
27         System.out.println("i3.equals(i4)");
28     }

输出:

Java基础类型之间的转换

Integer.parseInt(s)解析同一个字符串得到的int基本类型数据是相等的,可以直接通过“==”进行判断是否相等。

Integer.valueOf(s)多次解析相同的一个字符串时,得到的是Integer类型的对象,得到的对象有时是同一个对象,有时是不同的对象,需根据要解析字符串的整数值大小进行决定:如果字符串对应的整数值在 -128~127之间,则解析出的Integer类型的对象是同一个对象;如果字符串对应的整数值不在-128~127之间,则解析出的Integer类型的对象不是同一个对象。不管对象是否相等,对象中的value值是相等的。

另外,int是基本类型,不含有equals方法,所以只能用“==”比较,基本类型用“==”比较的是两个值的大小。

为什么Integer.valueOf(s)会出现这种情况呢?

这是由于JDK中源码已经定义好的。由于在-128~127之间的整数值用的比较频繁,当每次要创建一个value值在-128~127之间的Integer对象时,直接从缓存中拿到这个对象,所以value值相同的Integer对象都是对应缓存中同一个对象。-128~127之外的整数值用的不是太频繁,每次创建value值相同的Integer对象时,都是重新创建一个对象,所以创建的对象不是同一个对象。这个从JDK中源码可以看出:

 1     /**
 2     * 对外提供的Integer.valueOf方法
 3     */
 4     public static Integer valueOf(String s) throws NumberFormatException {
 5         return Integer.valueOf(parseInt(s, 10));
 6     }
 7 
 8     public static Integer valueOf(int i) {
 9         //IntegerCache.low为 -128; IntegerCache.high默认为127,但可以在JVM进行配置,一般默认就是127
10         if (i >= IntegerCache.low && i <= IntegerCache.high)
11             //如果i在-128~127之间,从缓存中取对象
12             return IntegerCache.cache[i + (-IntegerCache.low)];
13         //如果i不在-128~127之间,重新创建一个对象
14         return new Integer(i);
15     }

流程图:

 Java基础类型之间的转换 

结论:

1、Integer.valueOf返回包装好的Integer对象,且有-128~127会缓存的限制,Integer.parseInt只是返回int值

2、Integer.parseInt只接受String类型的参数,Integer.valueOf可以接收int和String(包装int为Integer)

 

参考:https://blog.csdn.net/u010502101/article/details/79162587

上一篇:Biginterger 解决多边形对角线点数问题


下一篇:Java随笔-大数