【深入了解Java常用类】

前言：Java中的常用类主要提供了广泛的工具和功能，用于简化开发任务，处理常见的编程需求。前面我们已经介绍过String类的一些基本使用方法，接下来我们再介绍一些其它常用类的使用，本文主要介绍以包装类Integer为例、Math类、Random类。后续再介绍其它常用类。

包装类

引入

【1】什么是包装类：
以前定义变量，经常使用基本数据类型，
对于基本数据类型来说，它就是一个数，加点属性，加点方法，加点构造器，将基本数据类型对应进行了一个封装，产生了一个新的类，---》包装类。
int,byte.....--->基本数据类型
包装类--->引用数据类型

【2】对应关系：
基本数据类型对应的包装类继承关系
byte Byte ---》Number---》Object
short Short ---》Number---》Object
int Integer ---》Number---》Object
long Long ---》Number---》Object
float Float ---》Number---》Object
double Double ---》Number---》Object
char Character Object
boolean Boolean Object

【3】已经有基本数据类型了，为什么要封装为包装类？
（1）java语言面向对象的语言，最擅长的操作各种各样的类。
（2）以前学习装数据的---》数组，int[] String[] double[] Student[]
以后学习的装数据的---》集合，有一个特点，只能装引用数据类型的数据
【4】是不是有了包装类以后就不用基本数据类型了？
不是。
对于集合来说要用包装类(引用数据类型)。
对于一般的类Student等只需要用基本数据类型，更简洁方便。

以Integer为例

【1】直接使用，无需导包：

【2】类的继承关系：

【3】实现接口：

【4】这个类被final修饰，那么这个类不能有子类，不能被继承：

【5】包装类是对基本数据类型的封装：对int类型封装产生了Integer

【6】类的历史：

【7】属性：

/**
 * @Auther: themyth
 */
public class Test01 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //属性：
        System.out.println(Integer.MAX_VALUE);//2147483647
        System.out.println(Integer.MIN_VALUE);//-2147483648
        //“物极必反”原理：
        System.out.println(Integer.MAX_VALUE+1);//-2147483648
        System.out.println(Integer.MIN_VALUE-1);//2147483647
    }
}

【8】构造器（发现没有空参构造器）

（1）int类型作为构造器的参数：

/**
 * @Auther: themyth
 */
public class Test02 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Integer integer = new Integer(12);
        System.out.println(integer.toString());//12
        System.out.println(new Integer(13));//13
    }
}

（2）String类型作为构造器的参数：

【9】包装类特有的机制：自动装箱自动拆箱：

/**
 * @Auther: themyth
 */
public class Test03 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //自动装箱：int---》Integer
        Integer i = 12;
        System.out.println(i);
        //自动拆箱：Integer---》int
        Integer i2 = new Integer(12);
        int num = i2;
        System.out.println(num);
    }
}

（1）自动装箱自动拆箱是从JDK1.5以后新出的特性
（2）自动装箱自动拆箱：将基本数据类型和包装类进行快速的类型转换。

验证：

可以自定打断点测试是否走入valueOf方法中：

【10】常用方法：

valueOf方法的底层：

import org.omg.CORBA.INTERNAL;
/**
 * @Auther: themyth
 */
public class Test04 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //compareTo:只返回三个值：0，-1，1
        Integer i1 =  new Integer(6);
        Integer i2 =  new Integer(12);
        System.out.println(i1.compareTo(i2));//return (x < y) ? -1 : ((x == y) ? 0 : 1);
        //equals：Integer对Object中的equals方法进行了重写，比较的是底层封装的那个value的值。
        //Integer对象是通过new关键字创建对象：
        Integer i3 = new Integer(12);
        Integer i4 = new Integer(12);
        System.out.println(i3 == i4);//false 因为比较的是两个对象的地址
        boolean flag = i3.equals(i4);
        System.out.println(flag);
        //Integer对象通过自动装箱来完成：
        Integer i5 = 12;
        Integer i6 = 12;
        System.out.println(i5.equals(i6));//true
        System.out.println(i5 == i6);//true
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7.equals(i8));//true
        System.out.println(i7 == i8);//false
        Integer i9 = -129;
        Integer i10 = -129;
        System.out.println(i9.equals(i10));//true
        System.out.println(i9 == i10);//false
        /**
         如果自动装箱在-128~127之间，那么比较的就是具体的数值
         否则比较的就是对象的地址
         */
        //intValue()的作用：将Integer--->int
        Integer i11 = 130;
        int i = i11.intValue();
        System.out.println(i);
        //parseInt(String s)：String--->int
        int i12 = Integer.parseInt("12");
        System.out.println(i12);
        //toString：Integer--->String
        Integer i13 = 13;
        System.out.println(i13.toString());
    }
}

Math类

【1】直接使用，无需导包：

【2】final修饰类，这个类不能被继承：

【3】构造器私有化，不能创建Math类的对象：

不能：

【4】Math内部的所有的属性，方法都被static修饰：类名.直接调用，无需创建对象：

【5】常用方法：

/**
 * @Auther: themyth
 */
public class Test01 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //常用属性：
        System.out.println(Math.PI);
        //常用方法：
        System.out.println("随机数："+Math.random());//[0.0,1.0)
        System.out.println("绝对值："+Math.abs(-80));
        System.out.println("向上取值："+Math.ceil(9.1));
        System.out.println("向下取值："+Math.floor(9.9));
        System.out.println("四舍五入："+Math.round(3.5));
        System.out.println("取大的那个值："+Math.max(3, 6));
        System.out.println("取小的那个值："+Math.min(3, 6));
    }
}

【6】静态导入：

//静态导入：
import static java.lang.Math.*;
/**
 * @Auther: themyth
 */
public class Test01 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //常用属性：
        System.out.println(PI);
        //常用方法：
        System.out.println("随机数："+random());//[0.0,1.0)
        System.out.println("绝对值："+abs(-80));
        System.out.println("向上取值："+ceil(9.1));//天花板
        System.out.println("向下取值："+floor(9.9));//地板
        System.out.println("四舍五入："+round(3.5));
        System.out.println("取大的那个值："+max(3, 6));
        System.out.println("取小的那个值："+min(3, 6));
    }
    //如果跟Math中方法重复了，那么会优先走本类中的方法（就近原则）：
    public static int random(){
        return 100;
    }
}

随机数案例：

在java中依靠一个类：Math类帮助我们生成，这个类中有一个方法专门用来生成随机数：

Math.random() -------> [0.0,1.0)
Math.random()*6 ----->[0.0,6.0)
(int)(Math.random()*6) ----->[0,5]
(int)(Math.random()*6) +1 ----->[1,6]
应用到程序中：

int num = (int)(Math.random()*6) +1;

练习：
[32,98] -----> [0,66]+32 ----> (int)(Math.random()*67)+32
[-100,200] -----> [0,300] +(-100) ----> (int)(Math.random()*301)-100

Random类

/**
 * @Auther: themyth
 */
public class Test02 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //返回带正号的double值，该值大于等于0.0且小于1.0
        System.out.println("随机数："+Math.random());
        //学习Random类
        //（1）利用带参数的构造器创建对象：
        Random r1 = new Random(System.currentTimeMillis());
        int i = r1.nextInt();
        System.out.println(i);
        //（2）利用空参构造器创建对象：
        Random r2 = new Random();//表面是在调用无参构造器，实际底层还是调用了有参构造器
        System.out.println(r2.nextInt(10));//返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。
        System.out.println(r2.nextDouble());//返回一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 double 值。
    }
}

Math.random()和Random类的区别

Math.random()和Random类都是用于生成随机数的工具，但它们的使用方式和功能略有不同。以下是它们的主要区别：

Math.random()

定义: Math.random() 是一个静态方法，属于 java.lang.Math 类。
返回值: 生成一个在 [0.0, 1.0) 范围内的 double 型随机数，即大于等于 0.0 且小于 1.0。
种子控制: 不能显式设置种子。它使用一个全局的种子，无法手动控制或重置，因此随机序列不可重复生成。
常见用途: 简单的随机数生成需求，例如生成一个随机的小数或通过乘法生成指定范围内的整数。
示例代码:

double randomValue = Math.random(); // 返回 0.0 到 1.0 之间的随机数
int randomInt = (int) (Math.random() * 10); // 返回 0 到 9 之间的随机整数

Random类

定义: Random 是 java.util 包中的一个类，需要先创建 Random 类的实例。
返回值: 可以生成不同类型的随机数，如 int、long、float、double、boolean 等，还可以生成指定范围内的随机数。
种子控制: 可以在创建 Random 对象时指定种子值，这样每次使用相同的种子值时，生成的随机数序列都是相同的，便于测试和重现。
多功能性: 提供更多功能，如生成高效的随机整数、长整型数字、布尔值等。可以生成指定范围内的随机数。

示例代码:

Random random = new Random();
int randomInt = random.nextInt(); // 返回任意整数
int randomIntWithinRange = random.nextInt(10); // 返回 0 到 9 之间的随机整数
double randomDouble = random.nextDouble(); // 返回 0.0 到 1.0 之间的随机 double 数
boolean randomBoolean = random.nextBoolean(); // 返回 true 或 false 的随机值

总结