2024年网络安全最新凯哥带你从零学大数据系列之Java篇---第十章 包装类和常用类

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

10.7.1. 概念

是一个用来描述时间、日期的类。 在 java.util 包中！！！

10.7.2. 常用方法

10.7.3. 示例代码

/*
 * @Description Date日期类
 */
public class DateUsage {
    public static void main(String[] args) {
        // 1. 实例化一个Date对象
        Date date = new Date();

        // 2. 获取一个日期的对应的时间戳 (从 1970年 1月 1日 0时开始的毫秒数)
        long timestamp = date.getTime();

        // 3. 实例化一个Date对象
        Date date1 = new Date(1586587414273L);
        System.out.println(date1);

        // 4. 通过设置一个时间戳，修改这个对象描述的时间
        date1.setTime(1586587414273L);

        System.out.println(date.equals(date1));     // 判断两个时间是否相同
        System.out.println(date.before(date1));     // 判断一个时间是否在另一个时间之前
        System.out.println(date.after(date1));      // 判断一个时间是否在另一个时间之后
    }
}

10.8. 常用类SimpleDateFormat

10.8.1. 概念

是一个用来格式化时间的类。 使用这个类， 一般有两种操作：

写在最后

在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。

需要完整版PDF学习资源私我

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

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

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！