Java基础类型之间的转换

 一、基础类型间的转换

public class TransferTest {
    public static void main(String[] args) {

        //String转为int: 两种方法
        String str = "100";
        int a1 = Integer.valueOf(str);
        int a2 = Integer.parseInt(str);

        //int转为String: 三种方法
        int a = 100;
        String str1 = String.valueOf(a);
        String str2 = Integer.toString(a);
        String str3 = "" + a;

        //long/Long转为String
        long l1 = 1001L;
        Long l2 = 100L;
        String s1 = String.valueOf(l1);//String.valueOf(l2)
        String s2 = Long.toString(l1);//Long.toString(l2);

        //long转为Long
        l2 = l1;//自动装箱拆箱
        System.out.println(l2);
        l2 = Long.valueOf(l1);

        //Long转为long
        l1 = l2.longValue();

        //String转为long
        String number = "1234567890";
        //方法一：调用Long类型的parseLong方法
        long num1 = Long.parseLong(number);
        //方法二：强制转换
        long num2 = new Long(number);
        //方法三：先转换Long类型，再使用longValue方法转为long
        long num3 = Long.valueOf(number).longValue();

        /**
         * Long.ValueOf("String")与Long.parseLong("String")的区别：
         * Long.ValueOf("String")返回Long包装类型
         * Long.parseLong("String")返回long基本数据类型
         */

        //long转为int
        Long n1 = 1000 * 100 * 85900L;
        int m1 = n1.intValue();

        //或者
        long n2 =1000 * 100 * 85900L;
        int m2 = (int)n2;
        int m3 = Math.toIntExact(n2);//long向int强转可能会出现数据溢出，Math.toIntExact()方法更为安全，在溢出的情况下会抛出ArithmeticException

        //int和Integer互换
        //convert i(int) to j(Integer)
        int i = 0;
        Integer j = Integer.valueOf(i);

        //convert t(Integer) to n (int)
        Integer t = 10;
        int n = t.intValue();

        //char转为int
        char ch = '8';
        int b1 = ch - '0';
        int b2 = ch - 48;
        //使用包装类:
        Character ch2 = new Character(ch);
        int b3 = Integer.parseInt(ch2.toString());
        int b4 = Integer.parseInt(Character.toString(ch2));

        //int转为char
        char ch1 = (char) (a + 48);

        //String转为char数组
        String s = "abcd";
        char[] chs = s.toCharArray();
        //String取单个字母
        s.charAt(0);

        //char转为String
        String str10 = String.valueOf(ch);
        String str20 = Character.toString(ch);

        //char数组转为String
        char[] chars = {'a', 'b', 'c', 'd'};
        String str11 = String.valueOf(chars);
        String str21 = String.valueOf(chars[0]);


    }
}

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

1、Integer.parseInt(s)用法

    String s1 = "1000";
    String s2 = "1000";
    int n1 = Integer.parseInt(s1);
    int n2 = Integer.parseInt(s2);
    if (n1 == n2) {
        System.out.println(true);
    }

输出：

 

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

2、Integer.valueOf(s)用法

    String s = "123";
    Integer integer1 = Integer.valueOf(s);

    int i = 345;
    Integer integer2 = Integer.valueOf(i);
    System.out.println("integer1 : " + integer1);
    System.out.println("integer2 : " + integer2);

输出：

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

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

    //Integer.parseInt
    String s3 = "10000";
    if (Integer.parseInt(s3) == Integer.parseInt(s3)) {
        System.out.println(true);
    }

    //Integer.valueOf：当字符串对应的整数值在 -128~127之间
    String s4 = "100";
    Integer i1 = Integer.valueOf(s4);
    Integer i2 = Integer.valueOf(s4);
    if (i1 == i2) { //两个对象相等
        System.out.println("i1 == i2");
    }
    if (i1.equals(i2)) { //两个对象中的value值相等
        System.out.println("i1.equals(i2)");
    }


    //Integer.valueOf：当字符串对应的整数值不在-128~127之间
    String s5 = "1000";
    Integer i3 = Integer.valueOf(s5);
    Integer i4 = Integer.valueOf(s5);
    if (i3 != i4) { //两个对象不相等
        System.out.println("i3 != i4");
    }
    if (i1.equals(i2)) { //两个对象中的value值相等
        System.out.println("i3.equals(i4)");
    }

输出：

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中源码可以看出：

    /**
    * 对外提供的Integer.valueOf方法
    */
    public static Integer valueOf(String s) throws NumberFormatException {
        return Integer.valueOf(parseInt(s, 10));
    }

    public static Integer valueOf(int i) {
        //IntegerCache.low为 -128; IntegerCache.high默认为127，但可以在JVM进行配置，一般默认就是127
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            //如果i在-128~127之间，从缓存中取对象
            return IntegerCache.cache[i + (-IntegerCache.low)];
        //如果i不在-128~127之间，重新创建一个对象
        return new Integer(i);
    }

流程图：

  

结论：

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