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数据类型" title="基本数据类型">基本数据类型
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 }
输出：
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);
输出：
Integer.valueOf(s)把字符串s（或int基本类型）解析成Integer对象类型，返回的integer 可以调用对象中的方法。
3、Integer.parseInt(s)与Integer.valueOf(s)的区别
1 //Integer.parseInt2 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 }
输出：
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 }
流程图：
结论：
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
以上是 Java基础类型之间的转换 的全部内容， 来源链接： utcz.com/z/393991.html
