常用的API

1.Math

• 一个帮助我们进行数学计算的工具类
• 它提供了大量的静态方法，涵盖了指数、对数、平方根、三角函数、取整、绝对值、最值、随机数等常用功能。因为它的所有方法都是 static 的，所以我们可以直接通过 Math.方法名() 来调用，无需创建 Math 类的实例。

package com.cqupt.mathapi;
import java.util.Random;

public class MathDemo {
    public static void main(String[] args) {
        //abs 获取绝对值,但是有bug，例如int类型 -2147483648 ~ 2147483647
        System.out.println(Math.abs(-88));
        System.out.println(Math.abs(-23.2));
        System.out.println(Math.abs(-2147483648)); //会输出--214748364

        //ceil向上取整
        System.out.println(Math.ceil(12.8)); //13.0
        System.out.println(Math.ceil(-12.58)); //-12.0

        //floor向下取整，往数轴的负方向退1
        System.out.println(Math.floor(12.8)); //12.0
        System.out.println(Math.floor(-12.58)); // -13.0

        //round四舍五入
        System.out.println(Math.round(12.8));  // 13
        System.out.println(Math.round(-12.58)); // -13
        System.out.println(Math.round(-12.28)); // -12

        //max获取两个整数之间的最大值
        System.out.println(Math.max(12, 23));

        //pow获得a的b次幂
        System.out.println(Math.pow(2, 3)); //8.0
        System.out.println(Math.pow(4, 0.5)); //2.0
        System.out.println(Math.pow(2, -2)); //0.25

        //sqrt开平方，cbrt开立方
        System.out.println(Math.sqrt(64)); //8.0
        System.out.println(Math.cbrt(8)); //2.0

        //random获取一个0-1.0的随机数,不怎么常用
        System.out.println(Math.random());
        System.out.println(Math.floor(Math.random()*100) + 1); //输出1-100的随机数
        
        //java获取随机数
        //创建一个Random的对象，调用nextInt方法
        Random random = new Random();
        System.out.println(random.nextInt(10));
    }
}

2. System

• 也是一个工具类，提供一些与系统相关的方法

package com.cqupt.mathapi;

public class SystemDemo {
    static void main(String[] args) {
        //0代表正常停止，非0代表告诉虚拟机异常停止
        //System.exit(0);

        //返回从时间原点（1970年1月1日零点，我国有八个小时时差，所以是8点开始算）到运行代码时之间的时间，用处:定义一个 long start 和一个 long end ，两者相减就是程序运行的时间
        System.out.println(System.currentTimeMillis());//1763261278570
        System.out.println(System.currentTimeMillis());//1763261298965

        //arraycopy方法
        //参数一：数据源
        //参数二：从第几个索引开始拷贝
        //参数三：目的地
        //参数四：目的地数组的索引
        //参数五：拷贝的个数
        int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
        int[] arr2 = new int[10];
        System.arraycopy(arr1,5,arr2,0,5);
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]+ " ");
            
        }

    }
}

• 数组拷贝的一些细节

3.Runtime

• 表示当前虚拟机的运行环境

package com.cqupt.mathapi;

public class RuntimeDemo {
    public static void main(String[] args) {
        //获取Runtime对象，构造方法私有化了，不能通过new创建。
        //保证外界不管怎么获取，获取的都是同一个对象，因为一个电脑只能有一个运行环境，多个对象没有意义。
        Runtime r = Runtime.getRuntime();

        // exit停止虚拟机
        //r.exit(0);

        //获取cpu线程数
        System.out.println(Runtime.getRuntime().availableProcessors());

        //JVM能从总内存获取的大小
        System.out.println(Runtime.getRuntime().maxMemory()/1024/1024); // 把单位转化成Mb  3932

        //JVM已经从系统的获取的内存的大小
        System.out.println(Runtime.getRuntime().totalMemory()/1024/1024); // 248

        //JVM剩余内存的大小
        System.out.println(Runtime.getRuntime().freeMemory()/1024/1024); // 242

        //运行cmd命令,jdk18之后就不用了
        //Runtime.getRuntime().exec("notepad");
    }
}

4.object

• 顶级父类，可以被所有子类访问。
• 构造方法只有空参。（因为子类太多，没有共性）

三个常见方法：

toString

• 如果我们打印一个对象想要看到属性值的话，就要对toString方法进行重写。

package com.cqupt.objectapi;

public class ObjectDemo {
    public static void main(String[] args) {
        // toString方法
        // 打印一个对象的时候，底层会调用对象的toString方法，把对象变成字符串，然后打印在控制台上。
        // 默认情况下，object类中的toString方法返回的是地址值，对我们来说没有意义。所以一般在子类中要改写toString方法。
        Object obj = new Object();
        String str = obj.toString();
        System.out.println(str); //java.lang.Object@f6f4d33

        Student student = new Student();
        System.out.println(student); //Student{name='null', age=0}
    }
}

equals

• equals同理，也要重写，要不然比较的是地址值。
• 参考下面的面试题

package com.cqupt.objectapi;

import java.util.Objects;

public class ObjectDemo2 {
    public static void main(String[] args) {
        // equals 比较两个对象是否相同
        // object类中默认比较的是地址值，但对于我们来说意义不大，所以还是要进行重写

        Student student1 = new Student();
        Student student2 = new Student();

        boolean result = student1.equals(student2);
        System.out.println(result); //true

        //Student类中重写了equals方法
        /* @Override
        public boolean equals(Object o) {
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return age == student.age && Objects.equals(name, student.name);
        } */


    }
}

对象克隆

• 首先要重写object中的clone方法
• 然后让javabean类实现Cloneable接口（这个接口没有抽象方法，作用是标记）
• 这时这个类就可以被克隆了 Person original = new Person("张三", 25); Person copy = original.clone(); // 克隆一份Person original = new Person("张三", 25);

5.BigInteger

• 转化为十进制也就19位，那么大于这个的数就要用BigInteger
• 对象一旦创建，里面的数据不能发生改变。所以只要进行计算，都会产生一个新的BigInteger对象。
• -16~16不用重新new了

构造方法

package com.cqupt.biginteger;

import java.math.BigInteger;
import java.util.Random;

public class BigIntegerDemo {
    static void main(String[] args) {
        //随机获取一个整数[0,2^4-1]
        Random r = new Random();
        BigInteger b1 = new BigInteger(4,r);
        System.out.println(b1);

        //指定一个大整数
        BigInteger b2 = new BigInteger("99999999999999999999999999999999999999999999999999999");
        System.out.println(b2);

        //指定进制的大整数
        BigInteger b3 = new BigInteger("10010",2);
        System.out.println(b3);

        //使用静态方法
        //这个范围比较小，在long范围之内·。
        BigInteger b4 = BigInteger.valueOf(100789);
        System.out.println(b4);
    }
}

成员方法

6.BigDecimal

构造方法

• 小数运算时不够精确，因为小数的二进制很长。double只能舍弃部分二进制位了。
• 有些场景必须精确运行（金融，火箭，医疗）
• BigDecimal可以帮我们精确计算，还能表示很大的数。

package com.cqupt.bigdecimalapi;

import java.math.BigDecimal;

public class BigDecimalDemo {
    public static void main(String[] args) {
        //1.通过构造方法public BigDecimal(double val)获取BigDecimal对象
        //但是这样子获取可能是不精确的
        BigDecimal b1 = new BigDecimal(0.01);
        BigDecimal b2 = new BigDecimal(0.09);
        System.out.println(b1);//0.01000000000000000020816681711721685132943093776702880859375
        System.out.println(b2);

        //2.通过构造方法public BigDecimal(String val)获取BigDecimal对象
        BigDecimal b3 = new BigDecimal("0.01");
        BigDecimal b4 = new BigDecimal("0.09");
        BigDecimal b5 = b3.add(b4);
        System.out.println(b3);//0.01
        System.out.println(b4);
        System.out.println(b5);//精确答案 0.10

        //通过静态方法获取对象  public static BigDecimal valueOf(double val)
        BigDecimal bd6 = BigDecimal.valueOf(9.98);
        System.out.println(bd6);

        //如果要表示的数字不大，没有超出double，建议用静态方法获取。
        //传递0-10之间的整数，那么方法会返回已经创建好的对象，不会重新new
        //BigInteger是-16~16不用重新new

    }
}

成员方法

7.正则表达式

作用1：检验字符串是否满足规则

• 注意/代表转义字符，所以要使用/d就要用//d。

例如：要求qq号需要6到20位之间，0不能开头，必须全部是数字。

String qq = "1234a56789";

System.out.println(qq.matches([1-9]\\d{5,19}));//输出false

package com.cqupt.regexapi;

public class RegexDemo {
    public static void main(String[] args) {
        //邮箱号码
        //3232323@qq.com      zhangsan@163.com  xzx0000@itcast.cnn   xsxs@pci.com.cn
        // 思路
        //第一部分：@的左边 \w+  表示任意的字母数字下划线，至少出现一次就可以了。
        //第二部分 @只能出现一次
        //第三部分
        //3.1 .的左边   [\w&&[^—]]{2，6}   表示任意的字母数字要出现2-6次（不能出现下划线）
        //3.2 .   要使用\.  因为.代表任意字符
        //3.3  .的右边   [a-zA-Z]{2,3}       表示大小写字母都可以，只能出现2-3次
        //最后我们可以把3.2和3.3看成一组，这一组可以出现1次或者2次

        String regex = "\w+@[\w&&[^_]]{2,6}(\.[a-zA-Z]{2,3}){1,2}";
        System.out.println("2894536499@qq.com".matches(regex));
        System.out.println("zhangsan@163.com".matches(regex));
        System.out.println("xzx0000@itcast.cnn".matches(regex));
        System.out.println("xsxs@pci.com.cn".matches(regex));

    }
}

作用2：在一段文本中查找满足要求的内容

• 类似于爬虫

8.JDK7时间

• 以前的世界标准时间为格林尼治时间，简称GMT
• 现在世界标准时间已经替换为：原子钟
• 中国标准时间 = 世界标准时间 + 8h

Date类

• 一个javabean类，用来描述时间，精确到毫秒。
• 利用空参构造创建的对象，默认表示系统当前的时间。
• 利用有参构造的对象，表示指定的时间。
• 输入Date对象时会调用toString方法

import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        /*
        public Date()
        Public Date(long date)

        public void setTime(long time)
        public long getTime() // 获取的是毫秒值
         */

        //1.创建对象
        Date d1 = new Date();
        System.out.println(d1);//Wed Nov 19 09:36:00 CST 2025

        //2.指定一个时间，0就代表从原点开始过了0ms后的时间
        Date d2 = new Date(0L);
        System.out.println(d2);//Thu Jan 01 08:00:00 CST 1970

        //3.setTime方法
        d2.setTime(1000L);
        System.out.println(d2);//Thu Jan 01 08:00:01 CST 1970

        //4.getTime方法
        long time = d2.getTime();
        System.out.println(time);//1000
    }
}

SimpleDateFormat类

• 格式化：把时间变成我们喜欢的格式
• 可以把字符串表示的时间变成Date对象

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

public class SimpleDateFormateDemo {
    public static void main(String[] args) throws ParseException {
        method(); //Date格式化成字符串

        //1.定义一个字符串表示时间
        String str = "2025-11-11 11:11:11";
        //创建SimpleDateFormat对象，格式要和字符串一致
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date  = sdf.parse(str);
        System.out.println("--------------------------------parse-----------------------------");
        System.out.println(date);//Tue Nov 11 11:11:11 CST 2025

    }

    private static void method() {
        //1.利用空参构造创建对象，默认格式
        SimpleDateFormat sdf = new SimpleDateFormat();
        Date d = new Date(0L);
        String str = sdf.format(d);
        System.out.println(str);//1970/1/1 08:00

        //2.利用带参构造创建对象，指定格式
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EE");
        String str2 = sdf2.format(d);
        System.out.println(str2);//1970年01月01日 08:00:00 周四

        //3.看一下今天的日期
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EE");
        Date today = new Date();
        String str3 = sdf3.format(today);
        System.out.println(str3);//2025-11-19 10:21:05 周三

    }
}

• 把2003-01-16转化为2003年1月16日

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

public class SimpleDateFormateDemo2 {
    public static void main(String[] args) throws ParseException {
        //把2003-01-16 转变成 2003年1月16日
        //把2003-01-16 转变成 2003年1月16日
        //把2003-01-16 转变成 2003年1月16日
        
        String str = "2003-01-16";
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf1.parse(str);
        
        
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日");
        str = sdf2.format(date);
        System.out.println(str);

    }
}

Calendar类

• 它代表了系统当时时间的日历对象，可以单独修改，获取时间中的年月日。
• Calendar是一个抽象类，不能直接创建对象。

9.JDK8时间

10.包装类

• 用一个对象，把基本数据类型给包起来。
• 或者说包装类就是基本数据类型的引用类型

为什么学习包装类

基本数据类型	包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

以Integer为例

一、JDK5以前创建方式(了解)

1.利用构造方法获取Integer对象：Integer i1 = new Integer（1）;

2.利用静态方法：Integer 3 = Integer。valueOf(123);

• 掌握两种方法的区别

1.使用valueOf方法时，如果创建的数据是-128~127时（实际开发用的多），不会新建对象，因为底层已经写好了这256个对象，要用的话直接返回给用户。

二、JDK5及之后，int和Integer可以看作是同一个东西，因为提出了自动装箱和拆箱机制，底层会帮我们调用valueOf方法。

Integer i1 = 10;//自动装箱

Integer i2 = new Integer（10）;

int i= i2;//自动拆箱

三、Integer成员方法

• 都是静态的，可以直接调用方法。
• String str = Integer.toBinaryString(100);
• 因为java是强类型语言：计算时必须转换成一样类型的才能计算。
• int i =Integer.parselnt("123");
• 除了character，其他包装类都有对应的parseXxx方法，所以我们以后在录入键盘数据的时候，都可以用nextLine来接收，然后再用包装类转换成基本数据类型。(因为next，nextInt遇到空格都会中断接收)