包装类

• 1、包装类
• • 1.1 数值类型
  • • 1.1.1 数值类型的包装类都有共同的父类
    • 1.1.2 创建对象的方式相同
    • 1.1.3 基本数据类型与String类型之间的抓换
    • 1.1.4 其他常量与方法
• 1.2 Character类型
• • • 1.2.1 创建对象
    • 1.2.2 char类型和String类型之间的转换
  • 1.3 Boolean类型
  • • 1.3.1 创建对象
    • 1.3.2 boolean类型和String类型之间的转换
  • 1.4 装箱与拆箱
  • 1.5 案例：员工信息管理

1、包装类

  通过查看源码或API文档，我们可以知道包装类再java.lang包下，而且所有包装类都是final修饰的，即不能被继承。里面维护的基本数据类型的变量value，也是final修饰的，不能更改，即一旦创建对象，其内容就不能修改。包装类主要分为三种不同类型：数值类型(Byte、Short、Integer、Long、Float和Double)、Character类型、Boolean类型。

1.1 数值类型

  数值类型包括Byte、Short、Integer、Long、Float和Double，它们都有一些共同点。

1.1.1 数值类型的包装类都有共同的父类

  数值类型的包装类都继承自Number类，Number类是抽象类，要求它的子类必须实现如下六个方法。

• byte byteValue:将当前包装的对象转换为byte类型的数值。
• short shortValue():将当前包装的对象转换为short类型的数值。
• int intValue():将当前包装的对象转换为int类型的数值。
• long longValue():将当前包装的对象转换为long类型的数值。
• float floatValue():将当前包装的对象转换为float类型的数值。
• double doubleValue():将当前包装的对象转换为double类型的数值。

   通过这六个方法，数值类型的包装类可以互相转换这六种数值，但是需要注意的是当大范围的数值转换为小范围的数值时，可能会溢出或损失精度。

1.1.2 创建对象的方式相同

  包装类是引用数据类型，数值类型的包装类创建对象的方式通常有两种。

方式一：通过调用构造器，每个数值类型的包装类都有两个构造器。以Integer类为例，Integer的构造器如下所示。

• Integer(int value):通过指定一个数值构造Integer对象。
• Integer(String s):通过指定一个字符串s构造对象(要求s是十进制字符串表示的数值，否则会报异常)。

示例代码：

Integer obj1=new Integer(100);
Integer obj2=new Integer("100");

方式二：从JDK1.5之后，可以通过调用包装类的valueOf静态方法，将一个基本数据类型的值或字符串转换为数值类型的包装类对象。以Integer类为例，Integer类的valueOf如下所示。

• Integer valueOf(int i):返回一个表示指定int值的Integer实例。
• Integer valueOf(String s):返回保存指定String值的Integer对象，要求s是十进制字符串表示的数值，否则会报异常。

示例代码：

Integer obj1=Integer.valueOf(100);
Integer obj2=Integer.valueOf("100");

1.1.3 基本数据类型与String类型之间的抓换

  (1)基本数据类型转为String类型通常有两种方式。

  方式一：直接拼接空字符串。在java中，任意数据类型与字符串拼接的结构都是字符串，如下所示。

int intValue=10;
String strValue=intValue+"";

  方式二：调用String类型的valueOf静态方法.

int intValue=10;
String strValue=String.valueOf(intValue);

  (2)String类型转为基本数据类型，需要调用包装类的静态方法parseXxx方法来实现。

String strValue1="521";
int i=Integer.parseInt(strValue1);

String strValue2="1.5";
double d=Double.parseDouble(strValue2);

1.1.4 其他常量与方法

  当我们想要在程序中表示某个数值类型不能超过该类型所能表示的最大值或最小值时，可以通过包装类来获取对应数值类型的最大值和最小值。

• MIN_VALUE:表示某数值类型的最小值。
• MAX_VALUE:表示某数值类型的最大值。

  当我们需要比较两个数值类型的大小时，可以使用包装类的compare方法代替“>”“<”"=="等运算符号，特别是浮点数。

• static int compare(int x,int y):Integer类中用于比较两个int值大小的静态方法，如果x大于y，则返回正整数；如果x小于y，则返回负整数；如果x等于y，则返回0.
• static int compare(double d1,double d2):Double类中用于比较两个double值大小的静态方法，建议double类型的数据在比较大小时使用它，而不是直接使用“>”“<”"=="运算符。如果d1大于d2,则返回正整数，如果d1小于d2,则返回负整数，如果d1等于d2，则返回0。

  Integer包装类中还有几个十进制和其他进制转换的方法。

• static String toBinaryString(int i):Integer类中用于返回某int值的二进制值。
• static String toOctalString(int i):Integer类中用于返回某int值的八进制值。
• static String toHexString(int i):Integer类中用于返回某int值的十六进制值。

1.2 Character类型

Character类型是char类型的包装类，用于处理字符数据。

1.2.1 创建对象

  将一个char类型的基本数据类型值包装为Character类型的对象通常有两种方式。

  方式一：通过构造器Character(char value)创建一个新的Character对象。

  方式二：通过调用静态方法Character valueOf(char value)返回该char值的Character对象。

Character obj1=new Character('a');
Character obj2=Character.valueOf('a');

1.2.2 char类型和String类型之间的转换

  (1)将char类型转换为String类型的方式通常有两种。

  方式一：直接拼接空字符串来实现，如下所示：

char cValue='a';
String str=cValue+"";

  方式二：通过调用String类型的valueOf方法来实现。

char cValue='a';
String str=String.valueOf(cValue);

  (2)将String类型转换为char类型则可以调用String类型的char charAt(int index)方法来获取字符串中的某个字符，其中index为某字符串中的索引下标，第一个字符的下标从0开始。

String sValue="hello";
char c=sValue.charAt(0);//c中获取的字符是'h'字符

1.3 Boolean类型

  Boolean类型是boolean类型的包装类，用来处理布尔值true或false。

1.3.1 创建对象

  将一个boolean值或“true”和“false”字符串抓换为Boolean类型的对象有如下两种方式。

方式一：通过构造器创建一个Boolean类型对象。

• Boolean(boolean value)：通过一个boolean值创建Boolean类型对象。
• Boolean(String s):将true和false字符串转化为Boolean类型对象。

方式二：通过Boolean类型的静态方法valueOf将一个boolean值或true和false字符串转为Boolean类型对象。

• Boolean valueOf(boolean b):将一个boolean值转换为Boolean类型对象。
• Boolean valueOf(String s):将true和false字符串转换为Boolean类型对象。

1.3.2 boolean类型和String类型之间的转换

  (1)将boolean转换为String类型的方式有两种。

  方式一：通过拼接空字符串

boolean bValue=true;
String s=bValue+"";

  方式二：通过调用String类型的静态方法valueOf实现

boolean bValue=true;
String s=String.valueOf(bValue);

  (2)将String类型转换为boolean类型

String sValue="true";
boolean b=Boolean.parseBoolean(sValue);

1.4 装箱与拆箱

  我们将基本数据类型转换成包装类的过程称为装箱。

  将包装类转换成基本数据类型的过程称为拆箱。

  在JDK5.0版本之前，需要通过调用构造器或静态方法valueOf实现，称为手动装箱或拆箱。

  (1)手动装箱的方式有两种，以Integer类型为例。

  方式一：通过调用构造器

int intValue=100;
Integer obj=new Integer(intValue);

  方式二：通过调用静态方法valueOf

int intValue=100;
Integer obj=Integer.valueOf(intValue);

  (2)手动拆箱直接调用对应包装类的xxValue()方法即可，以Integer为例：

Integer obj=new Integer(100);
int value=obj.intValue();

  JDK5.0版本提供了更为简单的方式实现包装类和对应基本数据类型之间的转换，称为自动装箱或自动拆箱。但是自动装箱与自动拆箱只能发生在对应的类型之间，如Integer类型只能与int类型实现自动装箱与自动拆箱。

  (1)自动装箱，以Integer类型和int类型为例

int intValue=100;
Integer obj=intValue;

  (2)自动拆箱，以Integer类型和int类型为例

Integer obj=new Integer(100);
int value=obj;

1.5 案例：员工信息管理

  员工类包含姓名、薪资、年龄等属性，请合理封装，重写toString方法。现在要求创建多个员工对象放在员工数组中，并按照薪资排序。另外，如果属性是基本数据类型，则请用对应的包装类代替。

public class TestEmployee {
    public static void main(String[] args) {
        //创建员工数组，并给数组元素赋值
        Employee[] arr = new Employee[3];
        arr[0]= new Employee("code", 32000.0, 35, '男');
        arr[1]= new Employee("leader", 11000.0, 18, '女');
        arr[2]= new Employee("top", 8000.0, 23, '男');

        //数组元素从小到大排序
        for (int i = 1; i <arr.length ; i++) {
            for(int j=0;j<arr.length-i;j++){
                if(Double.compare(arr[j].getSalary(),arr[j+1].getSalary())>0){
                   Employee temp= arr[j];
                   arr[j]=arr[j+1];
                   arr[j+1]=temp;
                }
            }
        }

        //遍历数组元素
        for (Employee employee : arr) {
            System.out.println(employee);
        }
    }
}
class Employee{
    private String name;
    private Double salary;
    private Integer age;
    private Character gender;

    public Employee(String name, Double salary, Integer age, Character gender) {
        this.name = name;
        this.salary = salary;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Character getGender() {
        return gender;
    }

    public void setGender(Character gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", salary=" + salary +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
}