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

课程重点:

• 包装类(会用)
• 装箱拆箱(会用)
• 字符串与基本数据类型的转换(会用)
• 常用类Math(常用的几个方法会用)
• 常用类Random(会用)
• 常用类BigInteger,BigDecimal(会用)
• 常用类Date(会用)
• 常用类SimpleDateFormat(会用)(重点)
• 常用类Calendar(了解)

10.1. 包装类的简介

10.1.1. 包装类的概念

包装类， 就是在基本数据类型的基础上， 做一层包装。 每一个包装类的内部都维护了一个对应的基本数据类型的属性， 用来存储管理一个基本数据类型的数据。

包装类是一种引用数据类型， 使用包装类， 可以使得基本数据类型数据有着引用类型的特性。 例如， 可以存储在集合中。 同时， 包装类还添加了若干个特殊的方法。

10.1.2. 基本数据类型对应的包装类型

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

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. 概念

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

• 将一个 Date 对象， 转成指定格式的时间字符串。
• 将一个指定格式的时间字符串， 转成 Date 对象。

10.8.2. 常用时间格式

在时间格式中， 有几个常见的时间占位符。

10.8.3. 常用方法

parse 方法
会抛出一个编译时的异常。 在使用的时候， 目前， 直接使用一键修复(alt + Enter)， 用 try-catch 包围即可。
将一个字符串， 按照指定的格式进行解析。 如果字符串中的时间格式， 和对象实例化的时候给定的格式不同， 此时会出现异常。

10.8.4. 示例代码

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @Description
 */
public class SimpleDateFormatUsage {
    public static void main(String[] args) {
        // format();
        // parse();
        System.out.println(getDeltaDays("2002-09-28", "2020-04-11"));
    }

    // 将一个时间对象，转成指定格式的字符串
    private static void format() {
        // 1. 获取系统当前时间
        Date now = new Date();
        // 2. 指定一个时间格式，例如： 2020年4月11日 18:09:49
        String format = "yyyy年M月d日 HH:mm:ss";
        // 3. 通过一个时间格式，实例化一个SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        // 4. 转换成指定格式的字符串
        String str = sdf.format(now);
        System.out.println(str);
    }

    // 将一个指定格式的字符串，转成时间对象
    private static void parse() {
        // 1. 通过一个时间格式，实例化一个对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 2. 将一个指定格式的字符串，解析成Date对象
        try {
            Date date = sdf.parse("2019-09-27 22:18:05");
            System.out.println(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    // 小练习：设计方法，计算两个日期之间相差多少天
    private static int getDeltaDays(String from, String to) {
        // 1. 限定一个时间格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 2. 将两个时间转成Date对象
        try {
            Date fromDate = sdf.parse(from);
            Date toDate = sdf.parse(to);

            // 3. 计算相差多少天
            long days = (toDate.getTime() - fromDate.getTime()) / 1000 / 60 / 60 / 24;
            return (int)Math.abs(days);
        } catch (ParseException e) {
            e.printStackTrace();
        }

        return 0;
    }
}

10.9. 常用类Calendar

10.9.1. 概念

是一个用来描述时间、日期的类。 比Date的功能更加完善。 在Date类中， 有很方法都已经被废弃了。 用Caleendar类中的某些方法来替代。

10.9.2. 常用方法

10.9.3. 示例代码

import java.util.Calendar;
import java.util.Date;

/**
 * @Description Calendar类
 */
public class CalendarUsage {
    public static void main(String[] args) {
        // 1. Calendar是一个抽象类，无法直接进行实例化
        Calendar calendar = Calendar.getInstance();

        // 2. 通过指定的字段，获取对应的值。
        //    在 Calendar 类中，已经封装好了若干个静态常量，来表示不同的字段。
        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH));           // 在Calendar中，月份是从0开始的。
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
        System.out.println(calendar.get(Calendar.HOUR_OF_DAY));
        System.out.println(calendar.get(Calendar.MINUTE));
        System.out.println(calendar.get(Calendar.SECOND));

        // 3. 通过指定的字段，设置对应的值
        calendar.set(Calendar.YEAR, 2022);
        calendar.set(Calendar.DAY_OF_MONTH, 29);

        // 4. 同时设置年月日
        calendar.set(2021, Calendar.SEPTEMBER, 7);
        //    同时设置年月日时分
        calendar.set(2022, Calendar.NOVEMBER, 12, 23, 59);
        //    同时设置年月日时分秒
        calendar.set(2022, Calendar.NOVEMBER, 12, 23, 59, 59);

        // 5. 获取日期(Date对象)
        Date date = calendar.getTime();
        // 6. 设置日期(Date对象)
        calendar.setTime(new Date());
        // 7. 获取时间戳
        long timestamp = calendar.getTimeInMillis();
        // 8. 设置时间戳
        calendar.setTimeInMillis(timestamp);

        // 9. 判断一个日期是否在另外一个日期之前
        //    类似的方法还有 equals、after
        calendar.before(Calendar.getInstance());

        // 10. 对一个日期进行加法操作
        calendar.add(Calendar.MONTH, 3);
        calendar.add(Calendar.DAY_OF_MONTH, 21);

        System.out.println(calendar);
    }
}

看完啦,你需要接着看

凯哥带你从零学大数据系列之Java篇---第十一章:枚举 - 拥抱大数据的文章 - 知乎 https://zhuanlan.zhihu.com/p/137993874

继续加油吧!