Java 类型的相互转换

类型的相互转换

String和其它类型的相互转换

// String 转byte数组
String a = "1234";
byte[] bytes = a.getBytes(StandardCharsets.UTF_8);

// byte数组转String
String b = new String(bytes);

// String 转char数组
char[] chars = a.toCharArray();

// char数组转String
String c =  new String(chars);

List集合和数组的相互转换

@org.junit.Test
    public void exList() {
        ArrayList<Integer> arrayList = new ArrayList();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        arrayList.add(5);
        // 集合转换为对象数组
        System.out.println("----集合转换为数组----");
        Object[] objects = arrayList.toArray();
        for (Object object : objects) {
            System.out.print(object + " ");
        }
        System.out.println();
        //System.out.println(objects);

        // 集合转换为int数组
        // 方法一；先转换成Integer[]再转成int[]
        System.out.println("----集合转换为int数组方法1----");
        Integer[] int_array = (Integer[]) arrayList.toArray(new Integer[arrayList.size()]);
        int[] ints1 = Arrays.stream(int_array).mapToInt(Integer::valueOf).toArray();
        for (int i : ints1) {
            System.out.print(i + " ");
        }
        System.out.println();

        // 集合转换为int数组
        System.out.println("----集合转换为int数组方法2----");
        int array_num[] = new int[arrayList.size()];
        // 方法二:遍历List中的元素到int[]数组即可
        int i = 0;
        for (Integer num : arrayList) {
            array_num[i] = num;
            ++i;
        }

        for (int j : array_num) {
            System.out.print(j + " ");
        }
        System.out.println();


        // int数组转换为List
        // 方法一
        System.out.println("----数组转换为List----");
        int[] array = {1, 2, 4, 5, 7};
        List<Integer> ints = Arrays.asList(ArrayUtils.toObject(array)); // 需要导入包commons-lang3-3.12.0.jar
        for (Integer anInt : ints) {
            System.out.print(anInt + " ");
        }
        System.out.println();

        // int数组转换为List
        // 方法二
        System.out.println("----int数组转换为List方法二----");
        List<Integer> collect = Arrays.stream(array).boxed().collect(Collectors.toList());
        for (Integer integer : collect) {
            System.out.print(integer + " ");
        }
        System.out.println();

        // String数组转换为List
        System.out.println("----String数组转换为List----");
        String[] array_str = {"铿锵玫瑰", "可以的", "风雨彩虹"};
        List<String> strings = Arrays.asList(array_str);
        for (String str : strings) {
            System.out.println(str);
        }

    }

int 和 char 的相互转换

int → char 强制类型转换

@Test
/**
 * int → char
 */
public void charAndInt(){
int a = 65;
System.out.println((char)a);
}

char → int

方法一

/**
 * char → int
 * 方法一
 */
@Test
public void intAndChar() {
char a = '9';
if (Character.isDigit(a)) { // 判断字符是否是数字
int num = Integer.parseInt(String.valueOf(a)); // char → String → int
System.out.println(num);
}
}

方法二:

/**
 * char → int
 * 方法二
 */
@Test
public void intAndChar02() {
    char a = '9';
    if (Character.isDigit(a)) { // 判断字符是否是数字
        int num = (int) a - (int)'0'; // 用字符的数字值 - '0'的字符值
        System.out.println(num);
    }
}

Double 和 Long的相互转换

@Test
public void change(){
    // Double >  Long
    Double a = 12.33;
    Long b = a.longValue();
    System.out.println(b);

    // Long >  Double
    Long d = 17L;
    Double c = d.doubleValue();
    System.out.println(c);

}

三目运算符、算数运算符的一些类型转换

package com.choice.qusetion13;
	
	import org.junit.Test;
	import com.choice.question12.Exercise13;
	
	/**
	 * @author wty
	 * @date 2022/11/22 15:22
	 */
	public class Exercise17 {
	    @Test
	    public void getExercise17() {
	        byte b = 1;
	        char c = 1;
	        short s = 1;
	        int i = 1;
	        double d = 1.0;
	
	        /** 三目，一边为byte另一边为char，结果为int
	         * 其它情况结果为两边中范围大的。适用包装类型
	         */
	        // byte : char
	        Object o1 = true ? b : c;
	        System.out.println(o1 instanceof Integer);
	
	        // byte : byte
	        Object o2 = true ? b : b;
	        System.out.println(o2 instanceof Byte);
	
	        // int : double
	        Object o3 = true ? i : d;
	        System.out.println(o3 instanceof Double);
	
	        // byte : short
	        Object o4 = true ? b : s;
	        System.out.println(o4 instanceof Short);
	
	        /** 表达式，两边为byte,short,char，结果为int型
	         * 其它情况结果为两边中范围大的。适用包装类型
	         */
	
	        // byte + char
	        Object o5 = b + c;
	        System.out.println(o5 instanceof Integer);
	
	        // byte + short
	        Object o6 = b + s;
	        System.out.println(o6 instanceof Integer);
	
	
	        // char + short
	        Object o7 = c + s;
	        System.out.println(o7 instanceof Integer);
	
	
	        // int + double
	        Object o8 = i + d;
	        System.out.println(o8 instanceof Double);
	
	        /**
	         *  当 a 为基本数据类型时，a += b，相当于 a = (a) (a + b)
	         *  当 a 为包装类型时， a += b 就是 a = a + b
	         */
	        // (byte)byte + short
	        Object o9 = (b += s);
	        System.out.println(o9 instanceof Byte);
	
	        // (char)char + int
	        Object o10 = (c += i);
	        System.out.println(o10 instanceof Character);
	
	
	        /**
	         * 常量任君搞，long以上不能越
	         */
	        Object o11 = (char) 1 + (short) 1 + (int) 1;
	        System.out.println(o11 instanceof Integer);
	
	    }
	}