凯哥带你从零学大数据系列之Java篇---第十章 包装类和常用类(1)

10.2. 装箱拆箱

10.2.1. 手动装箱

**概念：**由基本数据类型， 完成向对应的包装类型进行转换。

**方式1：**可以通过每一个包装类的构造方法来完成。 在每一个包装类的构造方法中，都有一个与之对应的基本数据类型作为参数的重载方法。 此时， 直接将需要包装起来的基本数据类型， 写到构造方法的参数中即可完成装箱。

Byte n1 = new Byte((byte)1);
Short n2 = new Short((short)2);		
Integer n3 = new Integer(3);
Long n4 = new Long(4L);
Float n5 = new Float(3.14f);
Double n6 = new Double(3.14);
Character n7 = new Character('a');
Boolean n8 = new Boolean(false);

**【推荐使用】方式2：**可以通过包装类的静态方法 valueOf() 完成装箱。 每一个包装类中， 都有一个静态方法 valueOf， 这个方法的参数是包装类型对应的基本数据类型的参数。 直接将需要包装起来的基本数据类型的数据， 写到这个方法的参数中， 即可完成对这个基本数据类型数据的装箱。

Byte n1 = Byte.valueOf((byte)1);
Short n2 = Short.valueOf((short)2);
Integer n3 = Integer.valueOf(3);
Long n4 = Long.valueOf(4);
Float n5 = Float.valueOf(3.14f);
Double n6 = Double.valueOf(3.14);
Character n7 = Character.valueOf('a');
Boolean n8 = Boolean.valueOf(true);

10.2.2. 手动拆箱

概念: 由包装类型， 完成向对应的基本数据类型进行转换。

方式： 使用每一个包装类对象的 xxxValue 可以实现。 这里的 xxx 就是需要转型的基本数据类型。 例如， 如果需要转型为int类型， 则直接调用 intValue 即可。

Byte i1 = Byte.valueOf((byte) 100);
byte n1 = i1.byteValue();

Short i2 = Short.valueOf((short) 100);
short n2 = i2.shortValue();

Integer i3 = Integer.valueOf(100);
int n3 = i3.intValue();

Long i4 = Long.valueOf(100);
long n4 = i4.longValue();

Float i5 = Float.valueOf(3.14f);
float n5 = i5.floatValue();

Double i6 = Double.valueOf(3.14);
double n6 = i6.doubleValue();

Character i7 = Character.valueOf('a');
char n7 = i7.charValue();

Boolean i8 = Boolean.valueOf(true); 
boolean n8 = i8.booleanValue();

**备注：**某些包装类对象， 除了可以拆箱成对应的基本数据类型的数据之外。 还可以将包装起来的数字转成其他的基本数据类型的数据。 例如， Integer，除了有 intValue 之外， 还有 byteValue 等方法。 其实， 就是将包装类中包装起来的int数据， 强转成byte类型返回结果。 在使用的时候， 找自己需要的方法去转型即可。

10.2.3. 自动装箱拆箱

概念： 所谓的自动装箱和自动拆箱， 指的是在进行装箱和拆箱的时候， 不用再使用上面的方法完成装箱和拆箱的操作。 在JDK1.5之后， 装箱和拆箱是可以自动完成的！ 只需要一个赋值语句即可!

方式: 没有什么特殊语法， 直接去进行赋值即可。

// 自动装箱：由一个基本数据类型，到对应的包装类型的转换。只需要一个赋值语句即可完成。
Integer i1 = 10;
// 自动拆箱：由一个包装类型，到对应的基本数据类型的转换。只需要一个赋值语句即可完成。
int a = i1;

**注意：**既然已经有了自动的装箱和拆箱， 为什么还要掌握手动的装箱和拆箱。 因为， 在有些情况下， 自动的装箱和拆箱是不能使用的。

**示例:**如果在一个类的重载方法中， 有两个方法的参数类型， 一个是基本数据类型， 一个是对应的包装类型。 此时， 将无法使用自动装箱和拆箱。 必须通过手动的装箱和拆箱完成对应的方法的调用。

/**
 * @Description      自动的装箱和拆箱不能完成的逻辑：
 */
public class Program2 {
    public static void main(String[] args) {
        // 此时，10会最优先匹配到int类型的参数
        show(10);
        show(Integer.valueOf(10));
    }
    public static void show(int a) {
        System.out.println(a);
    }
    public static void show(Integer a) {
        System.out.println(a);
    }
}

10.2.4. 享元原则

概念： 是程序设计的一个基本原则。 当我们需要在程序中频繁的用到一些元数据的时候， 此时， 我们可以提前将这些元数据准备好， 当需要的时候， 直接拿过来使用即可。 使用完成之后， 也不进行销毁， 以便下次继续使用。

**包装类中的享元：**将常用到的基本数据类型对应的包装类对象，预先存储起来。 当使用到这些基本数据类型对应的包装类对象的时候， 可以直接拿过来使用， 不用再实例化新的对象了。

**示例:**Integer类中， 将 [-128, 127] 范围内的数字对应的包装类对象预存到了一个 Integer.cache 数组中， 每当我们用到这个范围内的数字的时候， 可以直接从这个数组中获取到元素。 如果用到了不在这个范围内的数字， 再去进行新的包装类对象的实例化。 这样， 不用频繁的开辟空间、销毁空间， 节省了CPU资源。

Integer i1 = Integer.valueOf(10);
Integer i2 = Integer.valueOf(10);
System.out.println(i1 == i2);		// 此时， 由于10在缓存范围内， 因此可以直接从数组中获取包装类对象。 true。

Integer i3 = Integer.valueOf(200);
Integer i4 = Integer.valueOf(200);
System.out.println(i3 == i4);		// 此时， 由于200不在缓存范围内， 因此这个方法会返回一个新的包装类对象。 false。

10.3. 字符串与基本数据类型的转换

10.3.1. 基本数据类型转型字符串类型

概念： 基本数据类型， 转成字符串， 希望得到的结果是这个数值转成字符串的样式。 其实， 就是直接给这个数值添加上双引号。

**方式1:**可以利用字符串拼接运算符完成。 当加号两端有任意一方是字符串的时候， 此时都会自动的把另一方也转成字符串， 完成字符串的拼接。 所以， 当需要把一个基本数据类型的数据转成字符串的时候， 只需要在另一端拼接上一个空的字符串即可。

int a = 10;
String str = a + "";

**【推荐使用】方式2：**使用字符串的静态方法 valueOf 完成。

String str = String.valueOf(10);

**方式3：**借助包装类的实例方法 toString 方法。

String str = Integer.valueOf(10).toString();

**方式4：**借助包装类的静态方法 toString 方法。

String str = Integer.toString(10);

10.3.2. 字符串类型转型基本数据类型

概念： 字符串类型转基本数据类型， 其实就是解析出这个字符串中的内容，转型成对应的基本数据类型的表示。

**注意事项1：**基本数据类型转字符串肯定是没问题的， 但是由字符串类型转到基本数据类型的时候， 可能会出现问题。字符串中的内容， 不一定能够转成希望转换的基本数据类型。 如果转换失败， 会出现 NumberFormatException 异常。

**注意事项2:**对于整数来说，字符串中如果出现了其他的非数字的字符， 都会导致转整数失败， 即便是小数点， 也不可以转。 这里并没有转成浮点数字， 再转整数的过程。

**方式1:**使用包装类的静态方法 valueOf 方法

Integer num = Integer.valueOf("123");

**方式2：**使用包装类的静态方法 parseXXX 方法。 这里的XXX就是要转换的基本数据类型。

int number = Integer.parseInt("123");

**备注：**以上两种方式，都可以完成字符串类型到基本数据类型之间的转换。 如果希望直接转成基本数据类型， 推荐使用方式2； 如果希望转成包装类型， 推荐使用方式1。

关于字符类型的特殊说明：

字符串类型， 没有类似于上面的方式， 可以直接转成字符类型。 如果一个字符串， 要转成字符， 需要使用字符串的一个实例方法 charAt() 方法。 使用这个方法， 获取字符串中的指定下标位的字符。

10.4. 常用类Math

10.4.1. 概念

是一个数学类， 这个类中封装了很多用来做数学计算的方法。 当我们需要使用到数学计算的时候， 要能够想到这个类。 这个类中有很多封装好的数学公式， 而且， 都是静态方法， 方便调用。

10.4.2. 常用静态常量

10.4.3. 常用方法

10.4.4. 示例代码

/**
 * @Description Math类
 */
public class MathUsage {
    public static void main(String[] args) {
        System.out.println(Math.abs(-3));		// 计算一个数字的绝对值
        System.out.println(Math.max(10, 20));	// 计算两个数字的最大值
        System.out.println(Math.min(10, 20));	// 计算两个数字的最小值

        System.out.println(Math.round(3.14));   // 四舍五入
        System.out.println(Math.floor(3.14));   // 向下取整，找到比这个数字小的第一个整数
        System.out.println(Math.ceil(3.14));    // 向上取整，找到比这个数字大的第一个整数

        System.out.println(Math.pow(2, 3));     // 计算2的3次方
        System.out.println(Math.sqrt(4));       // 计算4开平方
        // 需求：计算27的立方根
        System.out.println(Math.pow(27, 1/3.0));
        
        System.out.println(Math.random());              	// [0, 1)
        System.out.println((int)(Math.random() * 100)); 	// [0, 100) 整型随机数
    }
}

10.5. 常用类Random

10.5.1. 概念

是一个专门负责产生随机数的类。 在Java中， Random类在 java.util 包中。 在使用之前， 需要先导包。

其实， 随机数的产生， 是有一个固定的随机数算法的。 代入一个随机数种子， 能够生成一个随机数列。 但是由于算法是固定的， 因此会有一个“BUG”： 如果随机数的种子相同， 则生成的随机数列也完全相同。

10.5.2. 常用方法

10.5.3. 示例代码

/**
 * @Description Math类
 */
public class RandomUsage {
    public static void main(String[] args) {
        // 1. 实例化一个Random对象
        Random random = new Random(1);
        // 2. 产生随机数
        for (int i = 0; i < 20; i++) {
            // 产生 [0, 50) 范围内的随机数
            System.out.print(random.nextInt(50) + ", ");
        }
    }
}

10.6. 常用类BigInteger、BigDecimal

10.6.1. 概念

这两个类，都是用来表示数字的类。 BigInteger表示整型数字， BigDecimal表示浮点型数字。 这两个类， 可以用来描述非常、非常、非常大的数字。 例如整数， long是最大的表示范围， 但是即便是long型， 也有它表示不了的情况。 BigInteger就是可以表示任意大小的数字。

BigInteger: 表示整型数字， 不限范围。

**BigDecimal:**表示浮点型数字，不限范围， 不限小数点后面的位数。

10.6.2. 常用方法

10.6.3. 示例代码

/**
 * @Description BigInteger、BigDecimal
 */
public class BigIntegerAndBigDecimal {
    public static void main(String[] args) {
        // 1. BigInteger类
        BigInteger n1 = new BigInteger("12347328461827364812736481726348712643872634871263293413648273684716238746");
        BigInteger n2 = new BigInteger("38242374871238471987349872317623864716237591263875628764381239847198738763");

        // 2. 四则运算
        BigInteger add = n1.add(n2);                    // 加法
        System.out.println(add);

        BigInteger subtract = n1.subtract(n2);          // 减法
        System.out.println(subtract);

        BigInteger multiply = n1.multiply(n2);          // 乘法
        System.out.println(multiply);

        BigInteger divide = n1.divide(n2);              // 除法
        System.out.println(divide);

        // 用n1除n2, 保留商和余数
        // 将商存到结果数组的第0位
        // 将余数存到结果数组的第1位
        BigInteger[] bigIntegers = n1.divideAndRemainder(n2);
        System.out.println(bigIntegers[0]);     // 输出商
        System.out.println(bigIntegers[1]);     // 输出余数

        long ret = bigIntegers[0].longValue();
    }
}

10.7. 常用类Date

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

ngValue();
}
}

**10.7. 常用类Date**



[外链图片转存中...(img-ywquQ2o8-1714495132383)]
[外链图片转存中...(img-mtxdTnL6-1714495132384)]
[外链图片转存中...(img-kfoxhbVT-1714495132384)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**