凯哥带你从零学大数据系列之Java篇---第十章 包装类和常用类(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);
    }
}

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

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

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

System.out.println(calendar);
}
}

[外链图片转存中...(img-Ub1JioMN-1714286835007)]
[外链图片转存中...(img-D69yjyim-1714286835008)]
[外链图片转存中...(img-Wmh5ZGj9-1714286835008)]

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

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

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