【深入了解Java常用类】

已于 2024-09-03 22:44:45 修改
阅读量1.1k 收藏 17
点赞数 24
分类专栏： JavaSE 文章标签： java 常用类
于 2024-09-03 21:08:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/themyth142857/article/details/141867056
版权

前言：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】直接使用，无需导包：

0065329d0c0647e3b310d7b82885660c.png

【2】类的继承关系：

be97120408504cec9c2620ffedc869a0.png
【3】实现接口：

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

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

6666761d73bf4f6284581c4effe0a7e7.png
【6】类的历史：

2baa087f43874068b9086677352f7bbd.png

【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
    }
}

1b14dad644624ea0a9824786eec6dad3.png

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

16ed5ffc028443c9a1a52f4d2e6a954b.png

c6887ad03d15428ab2b64b5f96bd5fd2.png

 

【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）自动装箱  自动拆箱 ：将基本数据类型和包装类进行快速的类型转换。 

验证：  bde509e58b84485585f81337bf735242.png

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

b40f9311ef4745a9bc793de2465c5190.png

【10】常用方法： 

valueOf方法的底层：

f9d78bd03c8642c6b0ce66c0b9ad291c.png

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】直接使用，无需导包：

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

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

38eed7303dfc483ba5313106bb1fb368.png

不能：

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

b4ad0f5447964538a6d56e0f063c9464.png

【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类帮助我们生成，这个类中有一个方法专门用来生成随机数：

92375220c46044e2a0ec950e9e5c78bb.png

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 值。
    }
}

b8659ab029c54d47b428979ac147baf5.png

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 的随机值

总结

  • Math.random(): 简单易用，适合快速生成 [0.0, 1.0) 范围内的随机 double 值。
  • Random类: 更加灵活且功能丰富，适合需要生成不同类型或特定范围随机数的场景，并支持通过种子值生成可重复的随机序列。

 

TheMythWS
关注
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

TheMythWS

你的鼓励，我的动力。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值