java--包装类

包装类简介

Java 是个面向对象语言，所有的操作都是基于对象。Object 类是 Java 中的对象基础，所有 Java 中的类都有个共同的始祖 Object 类，Object 类可以表示任意类型数据。但 Java 中的一些基本类型数据，并不是对象，没有对象的操作。如何让对象类型与基础联系数据联系起来，这时就需要一个过渡类型数据，称为包装类。

包装类是对基本类型数据的包装，让基本数据类型“伪装”成类，具有类的特性，可以进行类的方法操作。

下表是基本数据类型与对应的包装类型。

基本数据类型	包装类型
byte	Byte
boolean	Boolean
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double

Intege

Integer 类在对象中包装了一个基本类型 int 的值。Integer 类对象包含一个 int 类型的字段。此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

Integer 类中的构造方法有以下两个：

Integer(int value)：构造一个新分配的 Integer 对象，它表示指定的 int 值；
Integer(String s)：构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值

例如

Integer integer1 = new Integer(100);    // 以 int 型变量作为参数创Integer 对象
Integer integer2 = new Integer("100");    // 以 String 型变量作为参数创建 Integer 对象

主要方法

方法	返回值	功能
byteValue()	byte	以 byte 类型返回该 Integer 的值
shortValue()	short	以 short 类型返回该 Integer 的值
intValue()	int	以 int 类型返回该 Integer 的值
toString()	String	返回一个表示该 Integer 值的 String 对象
equals(Object obj)	boolean	比较此对象与指定对象是否相等
compareTo(anotherlnteger)	int	在数字上比较两个 Integer 对象，如相等，则返回 0；如调用对象的数值小于 anotherlnteger 的数值，则返回负值；如调用对象的数值大于 anotherlnteger 的数值，则返回正值
valueOf(String s)	Integer	返回保存指定的 String 值的 Integer 对象
parseInt(String s)	int	将数字字符串转换为 int 数值
toBinaryString(int i)	String	获取数字的二进制形式
toOctalString(int i)	String	获取数字的八进制形式
toHexString(int i)	String	获取数字的十六进制形式

使用方法

1. doubleValue()：可以将 Integer 对象类型变成 double 的基础数据类型；

public class TestDemo {  
	public static void main(String[] args) {      // 定义一个 Integer 对象类型的变量      
		Integer a = new Integer(10);      // 将 a 类型转变为 double 的基础数据类型      
		double i = a.doubleValue();      
		System.out.print(i);  
	}
}

输出
10.0

2. toString()：返回一个表示该 Integer 值的 String 对象；

// 定义一个 Integer 类型的变量
Integer i1 = new Integer(3);// 将 Integer 值转化为 String 类型
String s = i1.toString();
System.out.print(s);

输出
3

3. valueOf(String s)：返回保存指定的 String 值或数值型的 Integer 对象；

String a = "12";// 将 String 型的数据转换为 Integer 对象
Integer ai = Integer.valueOf(a);
System.out.println(ai);

输出
12

4. parseInt：将数字字符串转换为 int 数值。

String a = "12";      
int v = Integer.parseInt(a);      
System.out.print(v);

输出
12

上面的例子都需要手动实例化一个包装类，称为手动拆箱装箱。Java 1.5(5.0) 之前必须手动拆箱装箱。

Java 1.5 之后可以自动拆箱装箱，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进行，这将大大方便程序员的代码书写。

我们来看一下我们之前用的手动装箱的方法：

int i = 10;
Integer obj = new Integer(i); // 手动装箱

系统提供的自动装箱方法：

Integet i = 10; // 自动装箱

其实自动装箱的原理就是调用包装类的 valueOf 方法。

Integer i = Integer.valueOf(10);

与自动装箱相反，有装就有拆，自动拆箱即自动将包装类型转换成基本数据类型。把 i 赋值给 i1 就是实现的自动拆箱功能，自动装箱的原理就是调用包装类的 xxValue 方法。

Integet i = 10; // 自动装箱int 
i1 = i; // 自动拆箱

Integet i = 10; // 自动装箱
int i1 = i.intValue();

Integer 类包含以下 4 个常量：

MAX_VALUE：值为 231-1 的常量，它表示 int 类型能够表示的最大值；

MIN_VALUE：值为 -231 的常量，它表示 int 类型能够表示的最小值；

SIZE：用来以二进制补码形式表示 int 值的比特位数；

TYPE：表示基本类型 int 的 Class 实例

下面的代码演示了 Integer 类中常量的使用

int max_value = Integer.MAX_VALUE;    // 获取 int 类型可取的最大值
int min_value = Integer.MIN_VALUE;    // 获取 int 类型可取的最小值
int size = Integer.SIZE;    // 获取 int 类型的二进制位
Class c = Integer.TYPE;    // 获取基本类型 int 的 Class 实例

Long

Long 类是基本类型 long 的包装类，它包含若干方法来有效地处理一个长整型值，如将其转换为字符串表示形式，反之亦然。Long 类的一个对象可以保存一个长整型值。主要有两个构造函数来初始化一个 Long 对象：

Long（long b）：创建一个使用提供的值初始化的 Long 对象；

Long（String s）：使用字符串表示形式提供的 long 值创建一个 Long 对象。

例如

Long aLong = new Long(100); // 创建一个使用提供的值初始化的 Long 对象
Long bLong = new Long("100"); // 使用字符串表示形式提供的 long 值创建一个 Long 对象

在 Boolean 类内部包含了一些和 Boolean 操作有关的方法，见下表。

主要方法

方法	返回值	功能
byteValue()	byte	以 byte 类型返回该 Long 的值
doubleValue()	double	以 double 类型返回该 Long 的值
fioatValue()	float	以 float 类型返回该 Long 的值
intValue()	int	以 int 类型返回该 Long 的值（强制转换为 int 类型）
longValue()	long	以 long 类型返回该 Long 的值
shortValue()	short	以 short 类型返回该 Double 的值（强制转换为 short 类型）
toString()	String	返回一个表示该 Long 值的 String 对象
valueOf(String s)	Long	返回保存指定的 String 值的 Long 对象
parseLong(String s)	long	将数字字符串转换为 Long 数值
equals()	boolean	用于比较两个 Long 对象的相等性。如果两个对象都包含相同的 long 值，则此方法返回 true
compareTo()	int	用于比较两个 Long 对象的数值相等。如果相等返回 0，大于返回 1，小于返回 -1

使用方法

1. floatValue()：可以将 Long 对象类型变成 float 的基础数据类型；

// 定义一个 Long 对象类型的变量      
Long a = new Long(10);      
// 将 a 类型转变为 float 的基础数据类型   
float f = a.floatValue();      
System.out.print(f);

输出
10.0

2. toString()：返回一个表示该 Long 值的 String 对象；

// 定义一个 Long 类型的变量
Long l = new Long(3000);
// 将 Long 值转化为 String 类型
String s = l.toString();
System.out.print(s);

输出
3000

3. valueOf(String s)：返回保存指定的 String 值或数值型的 Long 对象；

String a = “12”;
int b = 18;
// 将 String 型的数据转换为 Long 对象
Long aLong = Long.valueOf(a);
// 将 int 型的数据转换为 Long 对象
Long bLong = Long.valueOf(b);
System.out.println(aLong);
System.out.println(bLong);

输出
12
18

4. parseLong：将数字字符串转换为 long 数值。

public class TestDemo {
    public static void main(String[] args) {
        String a = “12”;
        long v = Long.parseLong(a);
        System.out.print(v);
    }
}

输出
12

Short

Short 类在对象中包装了一个基本类型 short 的值。Short 类对象包含一个 short 类型的字段。此外，该类提供了多个方法，能在 short 类型和 String 类型之间互相转换，还提供了处理 short 类型时非常有用的其他一些常量和方法。

Short 类中的构造方法有以下两个：

Short(short value)：构造一个新分配的 Short 对象，用来表示指定的 short 值；

Short(String s)：构造一个新分配的 Short 对象，用来表示 String 参数所指示的 short 值。

可以传入基本类型 short 的参数，或者字符串参数。
例如，以下代码分别使用以上 2 个构造方法获取 Short 对象：

short a = 10;Short short1 = new Short(a);    // 以 short 类型的变量作为参数创建 Short 对象
Short short3 = new Short("7");    // 以 String 类型的变量作为参数创建 Short 对象

主要方法

方法	说明
shortValue()：	以 short 形式返回此 Short 的值；
byteValue()：	以 byte 形式返回此 Short 的值
intValue()：	以 int 形式返回此 Short 的值；
longValue()：	以 Long 形式返回此 Short 的值；
floatValue()：	以 float 形式返回此 Short 的值；
doubleValue()：	以 double 形式返回此 Short 的值。
hashCode()：	返回此 Short 的哈希码
toString()：	返回表示此 Short 的值的 String 对象；
equals(Object obj)：	将此对象与指定对象比较。返回的为boolean
compareTo( anotherShort)	比较两个 Short 对象所表示的数值，将两数相减后的结果返回。
parseShort(String s)：	将字符串参数解析为有符号的十进制 short；
toString()：	返回表示指定 Short 的一个新 String 对象。
decode(String nm)：	将 String 解码为 Short；
valueOf(String s)：	返回一个保持指定 String 所给出的值的 Short 对象。

使用方法

接下来，我们来讲解 Short 类的常用方法。

shortValue()：以 short 形式返回此 Short 的值；

转成其他基本类型: byte、int、long、float、double；

byte byteValue()：以 byte 形式返回此 Short 的值；

int intValue()：以 int 形式返回此 Short 的值；

long longValue()：以 Long 形式返回此 Short 的值；

float floatValue()：以 float 形式返回此 Short 的值；

double doubleValue()：以 double 形式返回此 Short 的值。

例如

// 定义一个 Short 对象类型的变量
Short a = new Short("10");// 将 a 类型转变为 int 的基础数据类型
int i = a.intValue();
System.out.print(i);

输出
10

Object 类的方法；

int hashCode()：返回此 Short 的哈希码；

String toString()：返回表示此 Short 的值的 String 对象；

boolean equals(Object obj)：将此对象与指定对象比较。

包装类 Short 对象比较大小的方法；

 int compareTo(Short anotherShort)
 比较两个 Short 对象所表示的数值，将两数相减后的结果返回。

如

short a = 10;Short short1 = new Short(a);    // 以 short 类型的变量作为参数创建 Short 对象
Short short2 = new Short("7");    // 以 String 类型的变量作为参数创建 Short 对象
int i = short1.compareTo(short2); // 返回 short1-short2 后的值
System.out.println(i);

输出
3

基本类型 short 和 String 相互转换的方法；

short parseShort(String s)：将字符串参数解析为有符号的十进制 short；

String toString()：返回表示指定 Short 的一个新 String 对象。

如

String str = "1000";
short shortValue = Short.parseShort(str);// 将字符串参数解析为有符号的十进制 
shortShort a = new Short((short)10);
String s = a.toString(); // 返回表示指定 Short 的一个新 String 对象。
System.out.println(shortValue);
System.out.println(s);

输出
1000
10

包装类 Short 和 String 相互转换的方法。

Short decode(String nm)：将 String 解码为 Short；

Short valueOf(String s)：返回一个保持指定 String 所给出的值的 Short 对象。

Short aShort = Short.valueOf("10");
System.out.println(aShort);

输出
10

Float

Float 类在对象中包装了一个基本类型 float 的值。Float 类对象包含一个 float 类型的字段。此外，该类提供了多个方法，能在 float 类型与 String 类型之间互相转换，同时还提供了处理 float 类型时比较常用的常量和方法.

Float 类中的构造方法有以下 3 个：

Float(double value)：构造一个新分配的 Float 对象，它表示转换为 float 类型的参数；

Float(float value)：构造一个新分配的 Float 对象，它表示基本的 float 参数；

Float(String s)：构造一个新分配的 Float 对象，它表示 String 参数所指示的 float 值。

例如，以下代码分别使用以上 3 个构造方法获取 Float 对象：

Float float1 = new Float(3.156);    // 以 double 类型的变量作为参数创建 Float 对象

Float float2 = new Float(5.7896);    // 以 float 类型的变量作为参数创建 Float 对象

Float float3 = new Float("7.179");    // 以 String 类型的变量作为参数创建 Float 对象

常用方法

方法	返回值	功能
byteValue()	byte	以 byte 类型返回该 Float 的值
doubleValue()	double以 double 类型返回该 Float 的值
floatValue()	float	以 float 类型返回该 Float 的值
intValue()	int	以 int 类型返回该 Float 的值（强制转换为 int 类型）
longValue()	long	以 long 类型返回该 Float 的值（强制转换为 long 类型）
shortValue()	short	以 short 类型返回该 Float 的值（强制转换为 short 类型）
isNaN()	boolean	如果此 Float 值是一个非数字值，则返回 true，否则返回 false
isNaN(float v)	boolean	如果指定的参数是一个非数字值，则返回 true，否则返回 false
toString()	String	返回一个表示该 Float 值的 String 对象
valueOf(String s)	Float	返回保存指定的 String 值的 Float 对象
parseFloat(String s)	float	将数字字符串转换为 float 数值

示例

1. intValue()：可以将 Float 对象类型变成 int 的基础数据类型；

// 定义一个 Float 对象类型的变量      
Float a = new Float(10.0);      // 将 a 类型转变为 int 的基础数据类型      
int i = a.intValue();      
System.out.print(i);

输出
10

2. isNaN(float v)：如果指定的参数是一个非数字值，则返回 true，否则返回 false

// 定义一个 float 型的变量
float d = 32.0f;
// 判断该参数是否是非数字值
System.out.print(Double.isNaN(d));

输出
false

3. toString()：返回一个表示该 Float 值的 String 对象；

// 定义一个 Float 类型的变量
Float f1 = new Float(3.25);
// 将 Float 值转化为 String 类型
String s = f1.toString();
System.out.print(s);

输出
3.25

4. valueOf(String s)：返回保存指定的 String 值或数值型的 Float 对象；

String a = “12.50”;
float b = 10.0f;
int c = 18;
// 将 String 型的数据转换为 Float 对象
Float aFloat = Float.valueOf(a);
// 将 float 型的数据转换为 Float 对象
Float bFloat = Float.valueOf(b);
// 将 int 型的数据转换为 Double 对象
Float cFloat = Float.valueOf(c);
System.out.println(aFloat);
System.out.println(bFloat);
System.out.print(cFloat);

输出
12.5
10.0
18.0

5. parseDouble：将数字字符串转换为 float 数值。

String a = “12.50”;
// 将数字字符串转换为 float 数值
double v = Double.parseDouble(a);
System.out.print(v);

输出
12.5

在 Float 类中包含了很多常量，其中较为常用的常量如下：

- MAX_VALUE：值为 1.4E38 的常量，它表示 float 类型能够表示的最大值；
- - 
- MIN_VALUE：值为 3.4E-45 的常量，它表示 float 类型能够表示的最小值；
- - 
- MAX_EXPONENT:有限 float 变量可能具有的最大指数；- 
- 
- MIN_EXPONENT：标准化 float 变量可能具有的最小指数；-
- 
- MIN_NORMAL：保存 float 类型数值的最小标准值的常量，即 2-126；- 
- 
- NaN：保存 float 类型的非数字值的常量；- 
- 
- SIZE：用来以二进制补码形式表示 float 值的比特位数；- 
- 
- TYPE：表示基本类型 float 的 Class 实例。

使用方法

float max_value = Float.MAX_VALUE;    // 获取 float 类型可取的最大值

float min_value = Float.MIN_VALUE;    // 获取 float 类型可取的最小值

float min_normal = Float.MIN_NORMAL;    // 获取 float 类型可取的最小标准值

float size = Float.SIZE;    // 获取 float 类型的二进制位

Double

Double 类在对象中包装了一个基本类型 double 的值。Double 类对象包含一个 double 类型的字段。此外，该类还提供了多个方法，可以将 double 类型与 String 类型相互转换，同时还提供了处理 double 类型时比较常用的常量和方法。

Double 类中的构造方法有如下两个：

Double(double value)：构造一个新分配的 Double 对象，它表示转换为 double 类型的参数；

Double(String s)：构造一个新分配的 Double 对象，它表示 String 参数所指示的 double 值。

例如，以下代码分别使用以上两个构造方法获取 Double 对象：

Double double1 = new Double(3.25);    // 以 double 类型的变量作为参数创建 Double 对象
Double double2 = new Double("9.765");       // 以 String 类型的变量作为参数创建 Double 对象

常用方法

方法	返回值	功能
byteValue()	byte	以 byte 类型返回该 Double 的值
doubleValue()	double	以 double 类型返回该 Double 的值
fioatValue()	float	以 float 类型返回该 Double 的值
intValue()	int	以 int 类型返回该 Double 的值（强制转换为 int 类型）
longValue()	long	以 long 类型返回该 Double 的值（强制转换为 long 类型）
shortValue()	short	以 short 类型返回该 Double 的值（强制转换为 short 类型）
isNaN(double v)	boolean	如果指定的参数是一个非数字值，则返回 true，否则返回 false
toString()	String	返回一个表示该 Double 值的 String 对象
valueOf(String s)	Double	返回保存指定的 String 值或数值型的 Double 对象
parseDouble(String s)	double	将数字字符串转换为 double 数值

示例

1. intValue()：可以将 Double 对象类型变成 int 的基础数据类型；

// 定义一个 Double 对象类型的变量      
Double a = new Double(10.0);      // 将 a 类型转变为 int 的基础数据类型      
int i = a.intValue();      
System.out.print(i);

输出
10

2. isNaN(double v)：如果指定的参数是一个非数字值，则返回 true，否则返回 false；

// 定义一个 double 型的变量
double d = 1.8E307d / 15.2;// 判断该参数是否是非数字值
System.out.print(Double.isNaN(d));

输出
false

3. toString()：返回一个表示该 Double 值的 String 对象；

// 定义一个 Double 类型的变量
Double double1 = new Double(3.25);
// 将 Double 值转化为 String 类型
String s = double1.toString();System.out.print(s);

输出
3.25

4. valueOf(String s)：返回保存指定的 String 值或数值型的 Double 对象；

String a = “12.50”;
float b = 10.0f;
int c = 18;
// 将 String 型的数据转换为 Double 对象
Double aDouble = Double.valueOf(a);
// 将 float 型的数据转换为 Double 对象
Double bDouble = Double.valueOf(b);
// 将 int 型的数据转换为 Double 对象
Double cDouble = Double.valueOf(c);
System.out.println(aDouble);
System.out.println(bDouble);
System.out.print(cDouble);

输出
12.5
10.0
18.0

5. parseDouble：将数字字符串转换为 double 数值。

 String a = “12.50”;
        double v = Double.parseDouble(a);
        System.out.print(v);

输出
12.5

在 Double 类中包含了很多常量，其中较为常用的常量如下：

MAX_VALUE：值为 1.8E308 的常量，它表示 double 类型的最大正有限值的常量；

MIN_VALUE：值为 4.9E-324 的常量，它表示 double 类型数据能够保持的最小正非零值的常量；

NaN：保存 double 类型的非数字值的常量；

NEGATIVE_INFINITY：保持 double 类型的负无穷大的常量；

POSITIVE_INFINITY：保持 double 类型的正无穷大的常量；

SIZE：以二进制补码形式表示 double 值的比特位数；

TYPE：表示基本类型 double 的 Class 实例。

Boolean

Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类的对象只包含一个类型为 boolean 的字段。此外，此类还为 boolean 和 String 的相互转换提供了很多方法，并提供了处理 boolean 时非常有用的其他一些常用方法。

Boolean 类有以下两种构造形式：

Boolean(boolean boolValue)；

Boolean(String boolString)。

其中 boolValue 必须是 true 或 false（不区分大小写），boolString 为字符串 true（不区分大小写），那么新的 Boolean 对象将包含 true；否则将包含 false。

例子

Boolean b1 = new Boolean(true); // 以 boolean 型变量作为参数创建 Boolean 对象
Boolean b2 = new Boolean("haha"); // 以 String 类型的变量为参数创建 
Boolean 类Boolean b3 = new Boolean("true"); // 以 String 类型的变量为参数创建 Boolean 类
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);

输出
true
false
true

操作方法

方法	返回值	功能
booleanValue()	boolean	将 Boolean 对象的值以对应的 boolean 值返回
equals(Object obj)	boolean	判断调用该方法的对象与 obj 是否相等。当且仅当参数不是 null，且与调用该方法的对象一样都表示同一个 boolean 值的 Boolean 对象时，才返回 true
parseBoolean(String s)	boolean	将字符串参数解析为 boolean 值
toString()	string	返回表示该 boolean 值的 String 对象
valueOf(String s)	boolean	返回一个用指定的字符串表示的 boolean 值

示例

1. booleanValue()：将 Boolean 对象的值以对应的 boolean 值返回；

Boolean b1 = new Boolean(true); // 以 boolean 型变量作为参数创建 Boolean 对象
boolean b = b1.booleanValue(); // 将 Boolean 对象转化为对应的 boolean 值
System.out.print(b);

输出
true

2. equals(Object obj)：判断调用该方法的对象与 obj 是否相等；

Boolean b1 = new Boolean(true);
boolean b2 = new Boolean("true");
boolean b3 = new Boolean("false");
System.out.println(b1.equals(b2)); // 比较 b1 和 b2 是否相等
System.out.println(b1.equals(b3)); // 比较 b1 和 b3 是否相等

输出
true
false

3. toString()：返回表示该 boolean 值的 String 对象；

Boolean b1 = new Boolean("ok");
String s = b1.toString(); // 将 b1 转换为 String 类型
System.out.println(s);

输出
false

4. valueOf(String s)：返回一个用指定的字符串表示的 Boolean 值。

String s = "true";
Boolean aBoolean = Boolean.valueOf(s); // 将一个字符串转换为 Boolean 类型。
System.out.println(aBoolean);

在 Boolean 类中包含了很多的常量，其中较为常用的常量如下：

TRUE：对应基值 true 的 Boolean 对象；

FALSE：对应基值 false 的 Boolean 对象；

TYPE：表示基本类型 boolean 的 Class 对象。

Byte

Byte 类将基本类型为 byte 的值包装在一个对象中。一个 Byte 类的对象只包含一个类型为 byte 的字段。此外，该类还为 byte 和 String 的相互转换提供了方法，并提供了一些处理 byte 时非常有用的常量和方法。

Byte 类提供了两个构造方法来创建 Byte 对象：

1. Byte(byte value)：通过这种方法创建的 Byte 对象，可以表示指定的 byte 值。

例如，下面的示例将 5 作为 byte 类型变量，然后再创建 Byte 对象；

byte my_byte = 5;
Byte b = new Byte(my_byte); // 以 byte 类型的变量为参数创建 Byte 类

2. Byte(String s)：通过这个方法创建的 Byte 对象,可表示 String 参数所指定的 byte 值。

例如，下面的示例将 5 作为 String 类型变量，然后再创建 Byte 对象。

String my_byte = "5";
Byte b = new Byte(my_byte); // 以 String 类型的变量为参数创建 Byte 类

注意：必须使用数值型的 String 变量作为参数才能创建成功，否则会抛出 NumberFormatException 异常。

操作方法

方法	返回值	功能
byteValue()	byte	以一个 byte 值返回 Byte 对象
compareTo(Byte bytel)	int	在数字上比较两个 Byte 对象，返回两者相减后的差值
doubleValue()	double	以一个 double 值返回此 Byte 的值
intValue()	int	以一个 int 值返回此 Byte 的值
parseByte(String s)	byte	将 String 型参数解析成等价的 byte 形式
toString()	String	返回表示此 byte 值的 String 对象
valueOf(String s)	Byte	返回一个保持指定 String 所给出的值的 Byte 对象
equals(Object obj)	boolean	此对象与指定对象比较，如果调用该方法的对象与 obj 相等，则返回 true，否则返回 false

示例

1. intValue()：可以将 Byte 对象类型变成 int 的基础数据类型；

// 定义一个 Byte 对象类型的变量     
Byte a = new Byte(10);      
// 将 a 类型转变为 int 的基础数据类型      
int i = a.intValue();      
System.out.print(i);

输出
10

2. toString()：返回一个表示该 Byte 值的 String 对象；

// 定义一个 Byte 类型的变量
Byte byte1 = new Byte(3);
// 将 Byte 值转化为 String 类型
String s = byte1.toString();
System.out.print(s);

输出
3

3. valueOf(String s)：返回保存指定的 String 值或数值型的 Byte 对象；

String a = "12";
// 将 String 型的数据转换为 Byte 对象
Byte aByte = Byte.valueOf(a);
System.out.println(aByte);

输出
12

4. parseByte：将数字字符串转换为 byte 数值。

public class TestDemo {
  public static void main(String[] args) {
        String a = "12";
        byte v = Byte.parseByte(a);      
        System.out.print(v);  
    }
}

输出
12

在 Byte 类中包含了很多的常量，其中较为常用的常量如下：

MIN_VALUE：byte 类可取的最小值；

MAX_VALUE：byte 类可取的最大值；

SIZE：用于以二进制补码形式表示的 byte 值的位数；

TYPE：表示基本类 byte 的 Class 实例。

Character

Character 类是字符数据类型 char 的包装类。Character 类的对象包含类型为 char 的单个字段，这样能把基本数据类型当对象来处理。

可以从 char 值中创建一个 Character 对象。例如，下列语句为字符 S 创建了一个 Character 对象。

Character character = new Character('S');

常用方法

方法	返回值	功能
Character(char value)	void	构造一个新分配的 Character 对象，用以表示指定的 char 值
charValue()	char	返回此 Character 对象的值，此对象表示基本 char 值
compareTo(Character anotherCharacter)	int	根据数字比较两个 Character 对象
equals(Character anotherCharacter)	boolean	将此对象与指定对象比较，当且仅当参数不是 null，而是一个与此对象包含相同 char 值的 Character 对象时， 结果才是 true
isDigit(char ch)	boolean	确定指定字符是否为数字，如果通过 Character. getType(ch) 提供的字符的常规类别类型为 DECIMAL_DIGIT_NUMBER，则字符为数字
isLetter(int codePoint)	boolean	确定指定字符（Unicode 代码点）是否为字母

示例

1. CompareTo(Character anotherCharacter)：方法将这个字符与其他字符 ，并且返回一个整型数组，这个值是两个字符比较后的标准代码差值；

Character character = new Character('A');
int result1 = character.compareTo(new Character('A'));
// 比较字符 A 与 A
System.out.println(result1)；
int result2 = character.compareTo(new Character('B'));
// 比较字符 A 与 B
System.out.println(result2);
int result3 = character.compareTo(new Character('D')); 
// 比较字符 A 与 D
System.out.println(result3);

输出
0
-1
-3

2. boolean isDigit(char ch)：确定指定字符是否为数字；

System.out.println(Character.isDigit('3'));
System.out.println(Character.isDigit('a'));
System.out.println(Character.isDigit('张'));
System.out.println(Character.isDigit('+'));

输出
true
false
false
false

3. char toLowerCase(char ch)：将字符转换为小写。

char a = Character.toLowerCase('A');
System.out.println(a);

输出
a