Trust the process.

0%

Java数据类型转换

发表于 更新于 分类于 热度： °C Valine：
本文字数： 3.5k 阅读时长 ≈ 6 分钟

序言

锲而不舍，金石可镂。

今天来梳理Java数据类型转换，这部分很杂乱，顺便总结总结API，做个笔记。

类型种类

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能。

如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型 对应的包装类（位于java.lang包中）
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

经常使用的有4种基本类型：

  1. char
  2. byte
  3. String
  4. int(Integer)

一下主要讨论这四个类型的转换，会用到包装类。

char <-> int

先看代码：

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
        
        int i = 65;
        System.out.println((char)i);//result:A
        
        char c = 'A';
        System.out.println((int)c);//result:65
        
    }

可以看到，如果进行强制类型转换，char会和ASCII码进行互相转换。

char -> int

现在想要的是 char:’9’ -> int:9

转换代码：

1
2
3
char b = '4';
int numericValue = Character.getNumericValue(b);
System.out.println(numericValue);// 4 type:int

int -> char

现在想要的是 int:9 -> char:’9’

转换代码：

1
2
3
int a =4;
char intValue = Character.forDigit(a,10);
System.out.println(intValue);// 4 type:char

其他方法

直接将’0‘的ASCII码值加上一起转换

1
char c = (char)('0' + i);

int <-> byte

int -> byte

会发生高位截断：

1
2
3
int a = 234;
byte b = (byte)a;
System.out.println(b);//-22

byte -> int

1
2
3
4
5
6
7
8
public static int byteToInt(byte b) {
		//Java 总是把 byte 当做有符处理；我们可以通过将其和 0xFF 进行二进制与得到它的无符值
		return b & 0xFF;
	}
....

byte b = -22;
System.out.println(byteToInt(b));//234

char <-> String

这类就很常见了。

char -> String

直接上API，万物.valueOf()转一切。

1
2
3
char a = 'A';
String s = String.valueOf(a);
System.out.println(s);//A type:String

字符数组：

1
2
3
char[] c = new char[]{'A','B','C','D','E','F','G'};
String n = String.valueOf(c);
System.out.println(n);//ABCDEFG

String -> char

老熟面孔了：

1
2
3
//n = "ABCDEFG"
char[] chars = n.toCharArray();
System.out.println(Arrays.toString(chars));//[A, B, C, D, E, F, G]

String <->byte

这里默认就是byte[]字节数组。

String -> byte[]

直接上代码：

1
2
3
String str = "ABCDEFG";
byte[] strbyte = str.getBytes();
System.out.println(Arrays.toString(strbyte));//[65, 66, 67, 68, 69, 70, 71]

可以发现直接内容其实就是ASCII码。

byte[] -> String

直接用String的构造方法就行，直接上：

1
2
3
byte[] b= {-60,-29,-70,-61,-93,-84,-42,-48,-71,-6,13,10,-42,-48,-71,-6,-93,-84,-60,-29,-70,-61};
String s = new String(b);
System.out.println(s);//你好，中国，中国，你好

int <-> String

int[] -> String

可以用StringBuilder，直接上：

1
2
3
4
5
6
StringBuilder sb = new StringBuilder();
int[] test = {1,2,23,4,5};
for (int i = 0; i < test.length; i++) {
    sb.append(test[i]);
}
System.out.println(sb.toString());//122345

要是想转换为ASCII码对应的字符串，可以这么写：

1
2
3
4
5
6
StringBuilder sb = new StringBuilder();
int[] test = {65,66,67};
for (int i = 0; i < test.length; i++) {
    sb.append((char)test[i]);
}
System.out.println(sb.toString());//ABC

String -> int[]

1
2
3
4
5
6
7
8
String ss = "12345678";
char[] cc = ss.toCharArray();
int[] tar = new int[ss.length()];
for (int i = 0; i < cc.length; i++) {
    tar[i] = Integer.parseInt(String.valueOf(cc[i]))；
    //Interger.valueOf(cc[i].toString(),2)也可以。
}
System.out.println(Arrays.toString(tar));//[1, 2, 3, 4, 5, 6, 7, 8]

byte<->char

char[] -> byte[]

方法1:用String作为跳板

1
2
3
4
char[] cs = new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g' };
String scs = new String(cs);
byte[] bb= scs.getBytes();
System.out.println(Arrays.toString(bb));//[97, 98, 99, 100, 101, 102, 103]

方法2:循环+强制转型

1
2
3
4
5
6
char[] cs = new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g' };
byte[] bs2 = new byte[cs.length];
for(int i = 0; i < cs.length; i++) {//循环将char数组的每一个元素转换为byte并存在上面定义的byte数组中
		bs2[i] = (byte) cs[i];//将每一个char转换成byte
}
System.out.println(Arrays.toString(bs2));//[97, 98, 99, 100, 101, 102, 103]

byte[] -> char[]

1
2
3
4
5
6
7
8
9
10
11
12
13
private char[] getChars (byte[] bytes) {
	Charset cs = Charset.forName ("UTF-8");
	ByteBuffer bb = ByteBuffer.allocate (bytes.length);
  bb.put (bytes);
  bb.flip ();
  CharBuffer cb = cs.decode (bb);
  
  return cb.array();
}
//
byte[] bb = {97, 98, 99, 100, 101, 102, 103};
char[] result = getChars(bb);
System.out.println(Arrays.toString(result));//[a, b, c, d, e, f, g]