JAVA入门-023（常用API）-优快云博客

本文深入探讨了Java基础类库中的Math、System和Object类，包括它们的常用方法和实际应用。此外，还详细介绍了Arrays类的排序、字符串转换以及基本类型包装类的功能。同时，讲解了日期类Date和SimpleDateFormat的使用，以及Calendar类对日期的处理。最后，通过案例展示了如何处理特定日期问题，如计算二月天数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Math

Math概述

在这里插入图片描述

Math包含执行基本数字运算的方法
Math没有构造方法
看类的成员是否都是静态的，如果是，通过类名直接调用类中的成员

Math类的常用方法

方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	返回大于或等于参数的最小（最接近负无穷大） double值，等于一个数学整数。向上取整
public staticdouble floor(double a)	返回小于或等于参数的最大（最接近正无穷大） double值，等于一个数学整数。向下取整
public static int round(double a)	long四舍五入
public static int max(int a, int b)	返回两个 int值中的较大值。
public static int min(int a, int b)	返回两个 int的较小值。
public static double pow(double a, double b)	返回a的b次幂
public static double random()	返回值为double的正值，[0.0,1.0)

代码测试：

public class MathDemo {
    public static void main(String[] args) {
        //绝对值
        System.out.println(Math.abs(88));
        System.out.println(Math.abs(-88));
        System.out.println(Math.abs(-88.88));
        System.out.println("========");

        //向上取整 但返回的double类型
        System.out.println(Math.ceil(12.45));
        System.out.println(Math.ceil(-13.45));
        System.out.println("========");

        //向下取整 但返回的double类型
        System.out.println(Math.floor(12.45));
        System.out.println(Math.floor(-13.45));
        System.out.println("========");

        //四舍五入
        System.out.println(Math.round(12.35F));
        System.out.println(Math.round(13.55F));
        System.out.println("========");

        //比大小
        System.out.println(Math.max(66,88));
        System.out.println(Math.min(66,88));
        System.out.println("========");

        //幂
        System.out.println(Math.pow(5,7.1));
        System.out.println("========");

        //随机值
        System.out.println(Math.random()*100+"%");
    }
}

运行结果：
在这里插入图片描述

System

System概述

在这里插入图片描述
System包含几个有用的类字段和方法，他不能被实例化

System类的常用方法

方法名	Value
public static void exit(int status)	终止当前运行的Java虚拟机，非零表示异常终止
public static long currentTimeMillis()	返回当前时间（以毫秒为单位）

代码测试：

package JavaTest0004;

public class SystemDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        System.exit(0);
        System.out.println("结束");
    }
}

运行结果：
在这里插入图片描述
运行结果并没有输出结束，因为System.exit(0)结束了java虚拟机的运行。

代码测试：

public class SystemDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        //System.exit(0);
        //当前时间与1970-01-01之间的毫秒值
        System.out.println(System.currentTimeMillis());

        System.out.println("结束");
    }
}

运行结果：
在这里插入图片描述
currentTimeMillis的一些用法：
代码测试：

public class SystemDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        //System.exit(0);
        //当前时间与1970-01-01之间的毫秒值
        System.out.println(System.currentTimeMillis());
        //估算当前时间与1970年隔了多少年
        System.out.println(System.currentTimeMillis()*1.0/1000/60/60/24/365);
        //计算循环用了多少时间
        long start = System.currentTimeMillis();
        for (int i = 0;i < 10000;i++){
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时："+(end-start)+"ms");
        System.out.println("结束");
    }
}

运行结果：
在这里插入图片描述

Object

Object类的概述

在这里插入图片描述
类Object是类层次结构的根。每个类都有Object作为超类。所有对象（包括数组）都实现了这个类的方法。
构造方法：public Object()
子类的构造方法为什么默认访问的是父类的无参构造方法？
因为他们的顶级父类只有无参构造方法。

Object.toString()

代码测试：

package JavaTest0005;

public class Student {
    private String name;
    private int age;

    public Student(){}

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package JavaTest0005;

public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setAge(30);
        s.setName("陆璃");
        System.out.println(s);  //JavaTest0005.Student@7ef20235
        System.out.println(s.toString());  //JavaTest0005.Student@7ef20235
        //默认调用了Object的toString方法

        /*public void println(Object x) {
            String s = String.valueOf(x);
            if (getClass() == PrintStream.class) {
                // need to apply String.valueOf again since first invocation
                // might return null
                writeln(String.valueOf(s));
            } else {
                synchronized (this) {
                    print(s);
                    newLine();
                }
            }
        }*/
        /*public static String valueOf(Object obj) {
            return (obj == null) ? "null" : obj.toString();
        }*/
        /*public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }*/
    }
}

经过追踪对象的方法，发现println最终调用了Object类的toString方法。
在这里插入图片描述
重写同String方法：

    //重写toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

运行结果：
在这里插入图片描述

Object.equals()

代码测试：

public class ObjectDemo {
   public static void main(String[] args) {
       Student s1 = new Student();
       s1.setAge(30);
       s1.setName("陆璃");

       Student s2 = new Student();
       s2.setName("陆璃");
       s2.setAge(30);

       //比较两个对象内容是否相同
       System.out.println(s1 == s2);   //false s1 s2是地址值 两个对象都是new出来的，不会相同
       System.out.println(s1.equals(s2));
       /*public boolean equals(Object obj) {
           return (this == obj);
       }*/
       //equal默认方法比较的还是对象本身。
   }
}

为了比较内容，需要重写equals方法：

@Override
   public boolean equals(Object o) {
       //比较对象，对象相同则为true 否则继续
       if (this == o) return true;
       //对象不同则判断参数是否为空或是否来自同一类，为空或不为同一类则为false 否则继续
       if (o == null || getClass() != o.getClass()) return false;
       //把Object类型的o向下转型为Student
       Student student = (Student) o;
       //判断对象的内容 返回判断结果
       return age == student.age && Objects.equals(name, student.name);
   }

运行结果：
在这里插入图片描述

Arrays

冒泡排序

排序：将一组数据按照固定的规则进行排列
冒泡排序：一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序

如果有n个数据进行排序，总共需要比较n-1次
每一次比较完毕，下一次的比较就会少一个数据参与

代码测试：

package JavaTest0006;

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = {43, 24, 67, 21, 89, 13};
        System.out.println("排序前:"+arrayToString(arr));
        System.out.println("排序后:"+arrayToString(bubbleSortMethod(arr)));
    }

    //冒泡排序
    public static int[] bubbleSortMethod(int[] arr){
        int temp=0;
        for(int i = arr.length-1;i >=0;i--){
            for(int j = 0;j < i;j++){
                if(arr[j]>arr[j+1]){
                    temp=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        return arr;
    }

    public static String arrayToString(int[] arr){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int i = 0;i < arr.length;i++){
            if(i == 0){
                sb.append(arr[i]);
            }else {
                sb.append(",").append(arr[i]);
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}

运行结果：
在这里插入图片描述

Arrays类的概述和常用方法

在这里插入图片描述
Arrays类包含用于操作数组的各种方法

方法名	说明
public static String toString(int[] a)	返回指定数组内容的字符串表现形式
public static void sort(int[] a)	按照数字顺序排列指定的数组

工具类设计思想：

构造方法用private修饰
成员用public static修饰

基本类型包装类

基本类型包装类概述

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用的操作之一：用于基本数据类型与字符串之间的转换

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

Integer

Integer:包装一个对象中的原始类型int值
构造方法：
在这里插入图片描述
建议使用valueOf将int类型转换为Integer对象

该类里定义了最大值和最小值

代码测试:

package JavaTest0007;
/*
    基本类型包装类
 */
public class IntegerDemo {
    public static void main(String[] args) {
        //需求：我要判断一个数据是否在int的范围内？
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

        //通过构造方法获得Integer 过时，不建议使用
        Integer i1 = new Integer(100);
        System.out.println(i1); //输出100 说明重写了toString方法
        //Integer i2 = new Integer("a");  //报错 字符串必须为数字组成的
        Integer i2 = new Integer("100");
        System.out.println(i2);

        //通过静态方法valueOf获得Integer对象
        Integer i3 = Integer.valueOf(100);
        System.out.println(i3);

        Integer i4 =Integer.valueOf("100");
        //Integer i4 = Integer.valueOf("zbc"); 同样会报错
        System.out.println(i4);
    }
}

运行结果:
在这里插入图片描述

int和String的相互转换

基本类型包装类的最常见操作就是:用于基本类型和字符串之间的相互转换

int转String
public sitatic String valueOf(int i):返回int参数的字符串表示形式.该方法是String类中的方法
String转int
public static int parseInt(String s):将字符串解析为int类型.该方法是Integer类中的方法

案例

字符串中数据的排序
需求:有一个字符串:“91 27 46 38 50”,请写出程序实现最终输出结果是:“27 38 46 50 91”
如何得到字符串中每一个数字的数据?
public String[] split(String regex)
代码测试:

package JavaTest0007;

import java.util.Arrays;

public class StringDemo {
    public static void main(String[] args) {
        String s = "91 27 46 38 50";
        //获取s的数组对象 新建int数组
        String[] strings = s.split(" ");
        int[] arr = new int[strings.length];
        //遍历字符串数组对象，将数据存入int数组中
        for (int i = 0;i < strings.length;i++){
            arr[i]=Integer.parseInt(strings[i]);
        }

        Arrays.sort(arr);
        //重写toString方法，将int对象转化为对应格式字符串
        System.out.println(toSting(arr));

    }
    public static String toSting(int[] arr){
        String s = "";
        for (int i = 0;i < arr.length;i++){
            if(i == 0){
                s = s + arr[i];
            }else {
                s = s + " "+arr[i];
            }
        }
        return s;
    }
}

运行结果:
在这里插入图片描述

自动装箱和拆箱

装箱:把基本数据类型转换为对应的包装类类型
拆箱:把包装类类型转换为对应的基本数据类型

代码测试:

package JavaTest0007;

public class IntegerDemo3 {
    public static void main(String[] args) {
        Integer i = Integer.valueOf(100);       //装箱
        Integer i2 = 100;                       //自动装箱

        i2 = i2.intValue() + 200;               //拆箱再自动装箱
        i2 = i2 + 200;                          //自动拆箱再自动装箱

        Integer i3 = null;
        if(i3 != null){                         //如果是引用类型变量 先判断非空
            i3 += 300;
        }
    }
}

注意:在使用包装类类型的时候,如果做操作,最好先判断是否为null
我们推荐的是,只要是对象,在使用前就必须进行不为null的判断

日期类

Date类概述和构造方法

API:
在这里插入图片描述

Date代表了一个特定的时间,精确到毫秒
两个构造方法:

方法名	说明
public Date()	分配一个Date对象,并初始化,一表示它代表它被分配的时间,精确到毫秒
public Date(long date)	分配一个Date对象,并将其初始化为表示从标准基准时间起指定的毫秒数

代码测试:

package JavaTest0008;

import java.util.Date;

public class DateDemo1 {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);   
        
        Date date1 = new Date(1000*60*60L);
        System.out.println(date1);
    }
}

运行结果:
在这里插入图片描述
Date重写了toString方法
由于CST是中国标准时间,所以基础时间加上1个小时后,需要根据时区计算中国时间,中国时区是东八区,所以为9点

Date类的常用方法

方法名	说明
public long getTime()	获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
public void setTime(long time)	设置时间,给的是毫秒值

代码测试:

package JavaTest0008;

import java.util.Date;

public class DateDemo2 {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d);
        System.out.println(d.getTime());
        long time = System.currentTimeMillis();
        d.setTime(time);
        System.out.println(d);

    }
}

运行结果:
在这里插入图片描述

SimpleDateFormat类概述

API:
在这里插入图片描述

SimpleDateFormat是一个具体的类,用于以区域设置敏感的方式格式化和解析日期.

SimpleDateFormat的构造方法

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat,使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

格式化(从Date到String)
public final String format(Date date):将日期格式化成日期/时间字符串
解析(从String到Date)
public Date parse(String source):从给定字符串的开始解析文本以生成日期

代码测试:

import java.util.Date;

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        Date d = new Date();
        //格式化
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
        String s = simpleDateFormat.format(d);
        System.out.println(s);
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        System.out.println(simpleDateFormat1.format(d));

        //解析
        String s1 = "2048-08-09 11:11:11";
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = simpleDateFormat2.parse(s1);
        System.out.println(dd);
    }
}

解析的时候字符串格式应与解析格式严格一致

案例:日期工具类

需求:定义一个日期工具类(DateUtils),包含两个方法:把日期转换为指定格式的字符串;把字符串解析为指定格式的日期,然后定义一个测试类(DateDemo),测试日期工具类

代码:

package JavaTest0008;

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

public class DateUtils {
    private  DateUtils(){}
    public static String DateToString(Date date,String format){
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
        String s = simpleDateFormat.format(date);
        return s;
    }

    public static Date StringToDate(String s,String format) throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
        Date date = simpleDateFormat.parse(s);
        return date;
    }
}

package JavaTest0008;

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

public class DateUtilsDemo {
    public static void main(String[] args) throws ParseException {
        //创建日期类对象
        Date d = new Date();
        String s = DateUtils.DateToString(d,"yyyy-MM-dd HH:mm:ss");
        System.out.println(s);

        String s1 = DateUtils.DateToString(d,"yyyy-MM");
        System.out.println(s1);

        String s2 = "2077-02-03 11:11:11";
        Date d1 = DateUtils.StringToDate(s2,"yyyy-MM-dd HH:mm:ss");
        System.out.println(d1);
    }
}

运行结果:
在这里插入图片描述

Calendar类概述

Api:
在这里插入图片描述
Calendar为某一时刻和一组日历字段之间的转换提供了一些方法,并为操作日历字段提供了一些方法

Calendar提供了一个类方法getInstance用于获取Calendar对象,其日历字段一使用当前日期和时间初始化:
Calendar rightNow = Calendar.getInstance()
代码测试:

package JavaTest0009;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance(); //多态的形式
        System.out.println(c);
        System.out.println(c.get(Calendar.YEAR));
        System.out.println(c.get(Calendar.MONTH)+1);    //月为什么要从0开始啊 讲道理
        System.out.println(c.get(Calendar.DATE));
    }
}

运行结果:
在这里插入图片描述

Calendar的常用方法

方法名	说明
public int get(int field)	返回给定日历字段的值
public abstract void add(int field,int amount)	根据日历的规则,将指定的时间量添加或减去给定的日历字段
public final void set(int year,int month,int date)	设置当前日历的年月日

代码测试:

package JavaTest0009;

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance(); //多态的形式
        System.out.println(c);
        System.out.println(c.get(Calendar.YEAR));
        System.out.println(c.get(Calendar.MONTH)+1);    //月为什么要从0开始啊 讲道理
        System.out.println(c.get(Calendar.DATE));

        c.add(Calendar.YEAR,-3);        //获取的当前年的三年前
        System.out.println(c.get(Calendar.YEAR));
        System.out.println(c.get(Calendar.MONTH)+1);    //月为什么要从0开始啊 讲道理
        System.out.println(c.get(Calendar.DATE));

        c.set(2077,11-1,11);
        System.out.println(c.get(Calendar.YEAR));
        System.out.println(c.get(Calendar.MONTH)+1);    //月为什么要从0开始啊 讲道理
        System.out.println(c.get(Calendar.DATE));
    }
}

运行结果:
在这里插入图片描述

案例:二月天

需求:获取任意一年的二月有多少天
代码:

package JavaTest0009;

import java.util.Calendar;
import java.util.Scanner;

public class CalendarDemo1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int year = scanner.nextInt();
        Calendar calendar =Calendar.getInstance();
        calendar.set(year,3-1,1);
        calendar.add(Calendar.DATE,-1);
        System.out.println("该年二月有："+calendar.get(Calendar.DATE)+"天");
    }
}