15.常用API

1. Math类

Math包含执行基本数字运算的方法

1.1 常用方法

方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	返回大于或等于参数的最小double值，等于一个整数
public static double floor(double a)	返回小于或等于参数的最大double值，等于一个整数
public static int round(float a)	按照四舍五入返回最接近参数的int
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)

1.2 应用实例

public class MathDemo {
    public static void main (String[] args) {
        //返回参数的绝对值
		System.out.println(Math.abs(88));//88
        System.out.println(Math.abs(-88));//88
        
        //返回大于或等于参数的最小double值，等于一个整数
        System.out.println(Math.ceil(12.34));//13.0
        
        //返回小于或等于参数的最大double值，等于一个整数
        System.out.println(Math.floor(12.34));//12.0
        
        //按照四舍五入返回最接近参数的int
        System.out.println(Math.round(12.34F));//12
        System.out.println(Math.round(12.56F));//13
        
        //返回两个int值中的较大值
        System.out.println(Math.max(66,77));//77
        
        //返回两个int值中的较小值
        System.out.println(Math.min(66,77));//66
        
        //返回a的b次幂的值
        System.out.println(Math.pow(2.0,3.0));//8.0
        
        //返回值为double的正值随机数，默认的取值范围为[0.0,1.0)
        System.out.println(Math.random());//0.25232
        System.out.println(Math.random()*100);//25.232
        //可以强转为int类型数据
        System.out.println((int)(Math.random()*100));//25
    }
}

2. System类

System包含几个有用的类字段和方法，它不能被实例化

2.1 常用方法

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

2.2应用实例

2.2.1 exit(int status)方法

public class SystemDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        System.exit(0);//终止当前运行的Java虚拟机
        System.out.println("结束");
    }
}

• 运行发现只输出了“开始”，“结束”未被输出

2.2.2 currentTimeMillis()方法

public class SystemDemo {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());//输出一串毫秒值
    }
}

• 运行输出了当前时间与1970年1月1日之间的毫秒值

2.2.3 输出当前时间与1970年1月1日之间隔了多少年

public class SystemDemo {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis()* 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");//输出当前时间与1970年1月1日之间隔了多少年
    }
}

• 为了确精度，让数值乘1.0变为浮点数，1毫秒与1秒相差1000倍，所以让数值除以1000可以将数值转换为秒为单位，后面的除数原理相同，进而得到所需的年份距离。

2.2.4 输出执行某段代码所需的时间

public class SystemDemo {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i <10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时" + (end - start) + "毫秒");//共耗时90毫秒
    }
}

3. Object类

• Object类是类层次结构的根类，每个类都可以将其作为超类。所有类都直接或间接继承自该类。

• 其构造方法只有：

public Object()

• 因为该类只有无参构造方法，所以其子类的构造方法默认访问的是父类的无参构造方法。

3.1 常用方法

方法名	说明
public String toString()	返回对象的字符串表示形式。建议Object的子类全部重写该方法，方法的重写可以自动生成
public boolean equals(Object obj)	比较对象是否相等。默认比较对象的内存地址，重写可以比较对象内容，可以自动生成

3.2 应用实例

3.2.1 toString方法

学生类：

public class Student {
    //成员变量
    private String name;
    private int age;
    
    //无参构造方法
    public student(){}
    
    //有参构造方法
    public student(String name, int age){
        this.name = name;
        this.age = age;
    }
    
    //成员方法
    public void setName(String name){
        this.name = name;
    }
    
    public String getName(){
        return name;
    }
    
    public void setAge(int age){
        this.age = age;
    }
    
    public int getAge(){
        return age;
    }
    
}

测试类：

public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("阿夸");
        s.setAge(5);
        System.out.println(s);//输出com.liu.Student@3f3ae12，这是其在栈内存中的地址
    }
}

• 查看源码可以发现println()方法此处最终调用了Object类中的toString()方法。
• 为了方便阅读一般在Object的子类中重写子方法，可以自动生成toString()方法。

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

在测试类中调用该方法

public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("阿夸");
        s.setAge(5);
        System.out.println(s);//Student{name='阿夸','age=5'}
        System.out.println(s.toString());//Student{name='阿夸','age=5'}
    }
}

• 发现即使不去调用toString方法，直接输出对象的引用s也可以得到相同内容

3.2.2 equals()方法

• 继续使用上面的学生类

测试类：

public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s.setName("阿夸");
        s.setAge(5);

        Student s2 = new Student();
        s.setName("阿夸");
        s.setAge(5);
        
        //比较两个对象内容是否相同
        System.out.println(s1 == s2);//false,此处s1与s2代表的是不同的地址值，不可能相同
        System.out.println(s1.equals(s2));//false,此处还是比较的地址值
    }
}

equals()方法源码

public boolean equals(Object obj) {
    return (this == obj);//this为s1,obj为s2
}

• equals()方法默认Object里比较的是地址值，需要重写该方法

• 在Student类中自动生成equals方法

	@Override
	public boolean equals(Object o) {
        //this代表s1,o代表s2
        
        //比较地址是否相同，若相同返回true
    	if (this == o) return true;
        
        //判断参数是否为空;判断两个对象是否来自同一个类
    	if (o == null || getClass() != o.getClass()) return false;
    
        //把o强转为Student,此处对象的引用student表示的是s2
    	Student student = (Student) o;
    
        //比较s1的age和s2的age，由于age是int类型的，启会直接使用==进行比较
    	if (age != student.age) return false;
        
        //三元表达式判断s1的name是否不为空，若不为空则对s1和s2进行比较，若为空则返回student.name == null;
        //s1调用equals方法和s2比较。
        /**由于s1和s2的name都是String类型的,所以使用String类中的equals()方法，String类中的equals()方法比较的是内容是否相同*/
    	return name != null ? name.equals(student.name) : student.name == null;
	}
}

• 再次运行

		System.out.println(s1.equals(s2));//true

• 发现在Object类中比较的是地址，由于官方重写了String类中的equals()方法，所以在String类中比较的是内容，不同类中的equals方法是不同的。所以我们使用该方法时需要进行重写。

4. Arrays类

• Arrays类包含用于操作数组的各种方法
• Arrays类本质上是工具类
• 工具类的设计思想：
  • 构造方法用 private 修饰（防止外界创建对象）
  • 成员用 public static 修饰（为了让外界用类名来访问该成员方法）

4.1 常用方法

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

4.2 应用实例

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = {24,69,80,57,13};
        System.out.println("排序前：" + Arrays.toString(arr));
        Arrays.sort(arr);//对数组排序
        System.out.println("排序后：" + Arrays.toString(arr));
    }
}

5. 基本类型包装类

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

5.1 Integer类的概述和使用

5.1.1 常用方法

方法名	说明
public Integer(int value)	根据int值创建Integer对象（过时）
public Integer(String s)	根据String值创建Integer对象（过时）
public static Integer valueOf(int i)	返回表示指定的int值的Integer实例
public static Integer valueOf(String s)	返回一个保存指定值的Integer对象String

5.1.2 应用实例

public class IntegerDemo {
    public static void main(String[] args) {
        //根据int值创建Integer对象
        Integer i1 = new Integer(100);
        System.out.println(i1);//100
        
        //根据String值创建Integer对象（过时）
        Integer i2 = new Integer("100");
        System.out.println(i2);//100
        
        //根据String值创建Integer对象（过时）
        Integer i2 = new Integer("abc");
        System.out.println(i2);//报错NumberFormatException,原因是字符串必须由纯数字组成
        
        //返回表示指定的int值的Integer实例
        Integer i1 = Integer.valueOf(100);
        System.out.println(i1);//100
        
        //返回一个保存指定值的Integer对象String
        Integer i2 = Integer.valueOf("100");
        System.out.println(i2);//100 
        
        //返回一个保存指定值的Integer对象String
        Integer i2 = Integer.valueOf("abc");
        System.out.println(i2);//报错NumberFormatException,原因是字符串必须由纯数字组成        
    }
}

• 基本类型包装类还有很多种，可查阅api文档进行了解

5.2 int和String的相互转换

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

5.2.1 常用方法

方法名	说明
public static String valueOf(int i)	将int转为String类型。返回int参数的字符串表示方式，该方法是String类中的方法，可以由类名直接调用
public static int parseInt(String s)	将String转为int类型。将字符串解析为int类型返回，该方法是Integer类中的方法，可以由类名直接调用

5.2.2 int转为String

public class IntegerDemo {
    public static void main(String[] args) {
        int number = 100;
        //方式1
        String s1 = "" + number;
        System.out.println(s1);//100，String类型
        
        //方式2,使用public static String valueOf (int i)方法
        String s2 = String.valueOf(number);
        System.out.println(s2);//100，String类型        
    }
}

• public static String valueOf (int i)方法为静态方法，由类名直接调用

5.2.3 String转为int

public class IntegerDemo {
    public static void main(String[] args) {
        String s = "100";
        //方式1，先将String转为integer，再转为int
        Integer i = Integer.valueOf(s);
        //调用public int intValue()方法
        int x = i.intValue();//用对象i调用方法
        System.out.println(x);//100，int类型
        
        //方式2，调用public static int parseInt (String s)方法
        int y = Integer.parseInt(s);
        System.out.println(y);//100，int类型
    }
}	

• public int intValue ()方法为非静态方法，需要用对象调用
• public static int parseInt (String s)方法为静态方法，由类名直接调用

5.3 自动装箱和拆箱

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

public class IntegerDemo {
    public static void main(String[] args) {
        //装箱
        Integer i = Integer.valueOf(100);
        //自动装箱，隐藏了valueOf()方法的调用
        Integer ii = 100;
        
        //拆箱
        ii = ii.intValue() + 200;//包装类型无法进行运算，故需要用拆箱操作把类型变为基本数据类型来完成运算，最后自动装箱赋值给ii
        System.out.println(ii);//300
    }
}

public class IntegerDemo {
    public static void main(String[] args) {
        //装箱
        Integer i = Integer.valueOf(100);
        //自动装箱，隐藏了valueOf()方法的调用
        Integer ii = 100;
        
        //自动拆箱
        ii += 200;//不是包装类型直接和基本数据类型进行了运算，而是其中隐藏了intValue()方法的调用
        System.out.println(ii);//300
        
        Integer iii = null;//自动装箱
        iii += 300;//报错NullPointerException，这里iii调用了intValue()方法，但是自身为null，所以报错空指针
    }
}

• 空指针问题：

public class IntegerDemo {
    public static void main(String[] args) {
        Integer iii = null;//自动装箱
        iii += 300;//报错NullPointerException，这里iii调用了intValue()方法，但是自身为null，所以报错空指针
    }
}

为了避免这个问题，一般在使用包装类型前会进行判断

public class IntegerDemo {
    public static void main(String[] args) {
        Integer iii = null;//自动装箱
        if(iii != null) {
        iii += 300;//报错NullPointerException，这里iii调用了intValue()方法，但是自身为null，所以报错空指针    
        }
    }
}

• 在使用包装类类型时，如果做操作最好先判断是否为null，推荐只要是对象，在使用前必须进行不为null的判断

6. 日期类

6.1 Date类

• Date代表了一个特点的时间，精确到毫秒

6.1.1 构造方法

• 导包时注意是util包下的Date类

方法名	说明
public Date()	分配一个Date对象，并初始化，以便它代表被分配的时间，精确到毫秒
public Date(long date)	分配一个Date对象，并将其初始化为表示从标准基准时间（1970年1月1日）开始指定的毫秒数，相当于把传入的参数和标准基准时间相加并存入对象引用中

public class DateDemo {
    public static void main(String[] args) {
        //使用构造方法public Date()实例化对象
        Date d1 = new Date();
        System.out.println(d1);//Sun Aug 09:28:09 CST 2048, 发现输出的内容不是内存中的地址信息，说明Date类重写了父类的toString方法
        
        //使用构造方法public Date(long date)实例化对象
        long date = 1000*60*60;//设置long类型变量date的值为1小时（因为标准时间以毫秒为单位，而1000毫秒为1秒，60秒为1分钟，60分钟为1小时，故用以上方式相乘来代表1小时对应的毫秒数）
        Date d2 = new Date(date);
        System.out.println(d2);//Thu jan 01 09:00:00 CST 1970，成功输出数据，数据表示时间为中国时间1970年1月1日9时，我们将其时间设定的是1970年1月1日1时，但是中国处于东八区，时间要再加上8小时
    }
}

6.1.2 常用方法

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

/**getTime()方法*/
public class DateDemo2 {
    public static void main(String[] args) {
        //创建日期对象
        Date d = new Date();
        
        //调用public long getTime()方法
        System.out.println(d.getTime());//2323232323123
        //将毫秒值转化为年
        System.out.println(d.getTime()* 1.0 /1000 / 60 / 60 / 24 / 365 + "年");//82.1231231231232年
    }
}

/**setTime()方法*/
public class DateDemo2 {
    public static void main(String[] args) {
        //创建日期对象
        Date d = new Date();
        //直接输出时间对象d
		System.out.println(d);//Sun Aug 09:28:09 CST 2048,输出的是当前时间
        
        long time = 1000*60*60;//传入1小时对应的毫秒值
        //调用public void setTime(long time)方法
        d.setTime(time);
        System.out.println(d);//Thu jan 01 09:00:00 CST
    }
}

public class DateDemo2 {
    public static void main(String[] args) {
		long time = System.currentTimeMillis();//传入系统获取到的当前时间对应的毫秒值
        d.setTime(time);
        System.out.println(d);//Sun Aug 09:28:09 CST 2048,输出的是当前时间
    }
}

6.2 SimpleDateFormat类

• SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。重点学习日期格式化和解析。

• 日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从‘A’到‘Z’以及从‘a’到‘z’引号的字母被解释为表示日期或时间字符串的组件的模式字母。

• 常用的模式字母及对应关系如下：

  • y 年
  • M 月
  • d 日
  • H 时
  • m 分
  • s 秒

6.2.1 构造方法以及格式化，解析日期的方法

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

• SimpleDateFormat的格式化方法（从Date到String）

//将日期格式化成日期/时间字符串
public final String formate(Date date);

• SimpleDateFormat的解析日期方法（从String到Date）

//从给定字符串的开始解析文本以生成日期
public Date parse(String source);

• 无参构造

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

public class SimpleDateFormatDemo {
    public static void main(String[] args) {
        Date date = new Date();//创建Date对象
        SimpleDateFormat sdf = new SimpleDateFormat();//使用无参构造创建SimpleDateFormat对象
        //格式化，从Date到String
        String s = sdf.formate(date);//SimpleDateFormat对象调用格式化方法
        System.out.println(s);//2022/5/8 上午10:52
    }
}

• 带参构造

//格式化

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

public class SimpleDateFormatDemo {
    public static void main(String[] args) {
        Date date = new Date();//创建Date对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");//使用带参构造创建SimpleDateFormat对象，自己编写输出时间的格式
        //格式化，从Date到String
        String s = sdf.formate(date);//SimpleDateFormat对象调用格式化方法
        System.out.println(s);//2022年5月8日 10:52:12
    }
}

//解析日期

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

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        String ss = "2022-05-08 10:52:12";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//使用带参构造创建SimpleDateFormat对象，自己编写输出时间的格式，格式要与字符串匹配，否则报错ParseException解析异常。
        //解析日期，从String到Date
        Date dd = sdf2.parse(ss);//SimpleDateFormat对象调用解析日期方法并赋值给对象dd。同时这里需要抛出ParseException解析异常
        System.out.println(dd);//Sun Aug 08 12:52:12 CST 2022
    }
}

6.3 Calendar（日历）类

• Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

• Calendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化：

  Calendar rightNow = Calendar.getInstance();
  

6.3.1 基本使用

测试类：

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
		//获取对象
        Calendar c = Calendar.getInstance();//多态的形式创建对象
        
        //public int get (int field)方法，根据给定的日历字段返回对应的值
        //获取年月日
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;//Calendar类中的月是从0算起的，需要+1
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");//2022年5月8日
    }
}

6.3.2 常用方法

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

测试类：

public abstract void add(int field,int amount)方法的使用

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
		//获取对象
        Calendar c = Calendar.getInstance();//多态的形式创建对象
        //调用方法public abstract void add(int field,int amount)
        //需求：三年前的今天
        c.add(Calendar.YEAR,-3);
        //public int get (int field)方法，根据给定的日历字段返回对应的值
        //获取年月日
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;//Calendar类中的月是从0算起的，需要+1
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");//2019年5月8日
    }
}

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
		//获取对象
        Calendar c = Calendar.getInstance();//多态的形式创建对象
        //调用方法public abstract void add(int field,int amount)
        //需求：十年后的五天前
        c.add(Calendar.YEAR,10);
        c.add(Calendar.DATE,-5);
        //public int get (int field)方法，根据给定的日历字段返回对应的值
        //获取年月日
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;//Calendar类中的月是从0算起的，需要+1
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");//2032年5月3日
    }
}

public final void set(int year,int month,int date)方法的使用

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
		//获取对象
        Calendar c = Calendar.getInstance();//多态的形式创建对象
        
		//调用public final void set(int year,int month,int date)方法
        //设置当前日历的年月日
        c.set(2022,11,11);//注意这里的月是从0开始的，输入11月会输出12
        
        //public int get (int field)方法，根据给定的日历字段返回对应的值
        //获取年月日
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;//Calendar类中的月是从0算起的，需要+1
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");//2022年12月11日
    }
}