java包装类

包装类

基本类型包装类

基本类型包装类的作用：

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用的操作之一：用于基本数据类型与字符串之间的转换

基本类型对应的包装类：

package com.itheima.myinteger;

public class MyIntegerDemo1 {
    public static void main(String[] args) {
        //需求：我要判断一个整数是否在 int 范围内?
        //Integer  MAX_VALUE:最大值  MIN_VALUE：最小值
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }
}
1
2
3
4
5
6
7
8
9
10

Integer 类的概述和使用

Integer：该对象中包装了一个基本数据类型int的值

package com.itheima.myinteger;

public class MyIntegerDemo2 {
    public static void main(String[] args) {
//        public Integer(int value)   		根据int创建Integer对象(过时)
//public Integer(String s)    		根据String值创建Integer对象(过时)
        Integer i1 = new Integer(100);
        Integer i2 = new Integer("100");
        System.out.println(i1);
        System.out.println(i2);


//        public static Integer valueOf​(int i)    返回表示指定的int值的Integer实例
//        public static Integer valueOf​(String s) 返回一个保存指定值的Integer对象String

        Integer i3 = Integer.valueOf(200);
        Integer i4 = Integer.valueOf("200");
        System.out.println(i3);
        System.out.println(i4);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

自动装箱和自动拆箱

• 装箱：把基本数据类型转换为对应的包装类类型
• 拆箱：把包装类类型转换为对应的基本数据类型
• 实列代码

Integer i = 100;  // 自动装箱
i += 200;         // i = i + 200;  i + 200 自动拆箱；i = i + 200; 是自动装箱
1
2

注意：在使用包装类类型的时候，如果做操作，最好先判断是否为 null
我们推荐的是，只要是对象，在使用前就必须进行不为 null 的判断

案例：

package com.itheima.myinteger;

import java.util.ArrayList;

public class MyIntegerDemo3 {
    public static void main(String[] args) {
        Integer i1 = 100;
        //   对象      = 默认是一个基本数据类型

        //jdk1.5的特性 --- 自动装箱

        //装箱: 把一个基本数据类型 变量对应的包装类.
        //自动: Java底层会帮我们自动的调用valueof方法.
        System.out.println(i1);

        //jdk1.5的特性 --- 自动拆箱
        //拆箱: 把一个包装类型 变成对应的基本数据类型
        int i2 = i1;
        System.out.println(i2);

        Integer i3 = 100; //自动装箱机制
        i3 += 200;//i3 = i3 + 200;
                   //会把i3这个对象变成基本数据类型100.
                    //100 + 200 = 300
                //把基本数据类型300再次自动装箱变成Integer对象赋值给i3
        System.out.println(i3);


        //细节:
        Integer i4 = null;
        if(i4 != null){
            i4 += 200;
            System.out.println(i4);
        }


    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

Integer的成员方法

int 和 String 的相互转换

基本类型包装类的最常见操作就是：用于基本类型和字符串之间的相互转换

1. int 转换为 String
   方式一：加双引号即可
   方式二：public static String valueOf(int i)：返回 int 参数的字符串表示形式。该方法是 String 类中的方法

2. String 转换为 int
   public static int parseInt(String s)：将字符串解析为 int 类型。该方法是 Integer 类中的方法

package com.itheima.myinteger;

public class MyIntegerDemo4 {
    public static void main(String[] args) {
         //String --- int
        String s1 = "100";
        int i1 = 200;
        System.out.println(s1 + i1);//100200 --- 字符串+任意的数据类型 结果都是一个字符串
        
		//方式2：public static int parseInt(String s)
        int i2 = Integer.parseInt(s1);//可以将字符串类型的整数变成int类型的整数
        System.out.println(i2 + i1);


        //int  ---> String
        //方式一: +""
        int i3 = 100;
        String s2 = i3 + "";
        System.out.println(s2 + 100);

        //方式二: 可以调用String类中valueof方法
        String s3 = String.valueOf(i3);
        System.out.println(s3 + 100);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

案例：字符串中数据排序

需求：有一个字符串：“91 27 46 38 50”，把其中的每一个数存到int类型的数组中

思路：
定义一个字符串
把字符串中的数字数据存储到一个int类型的数组中
两个难点：如何获取到里面的每一个值
如何把每一值变成int类型再存入数组
遍历数组输出结果

package com.itheima.myinteger;

public class MyIntegerDemo5 {
    //需求：有一个字符串：“91 27 46 38 50”，把其中的每一个数存到int类型的数组中
    //步骤:
    //定义一个字符串
    //把字符串中的数字数据存储到一个int类型的数组中
    //遍历数组输出结果
    public static void main(String[] args) {
        String s = "91 27 46 38 50";
        //获取字符串中的每一个数字.
        String[] strArr = s.split(" ");

        //创建一个int类型的数组.
        int[] numberArr = new int[strArr.length];

        //把strArr中的数据进行类型转换并存入到int数组中
        for (int i = 0; i < strArr.length; i++) {
            int number = Integer.parseInt(strArr[i]);
            numberArr[i] = number;
        }
        //先排序，再遍历
        //遍历int类型的数组
        for (int i = 0; i < numberArr.length; i++) {
            System.out.println(numberArr[i]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28