JavaSE进阶04：API中常用工具类

系列文章目录

JavaSE进阶01：继承、修饰符
JavaSE进阶02：多态、抽象类、接口
JavaSE进阶03：内部类、Lambda表达式
JavaSE进阶04：API中常用工具类
JavaSE进阶05：包装类、递归、数组的高级操作、异常
JavaSE进阶06：Collection集合、迭代器、List、ArrayList、LinkedList
JavaSE进阶07：泛型、Set集合、TreeSet、二叉树、红黑树
JavaSE进阶08：HashSet、Map集合、HashMap、TreeMap、可变参数、不可变集合
JavaSE进阶09：Stream流、File类
JavaSE进阶10：IO流、字节流、字节缓冲流
JavaSE进阶11：字符流、字符缓冲流、转换流、对象操作流、Properties集合
JavaSE进阶12：多线程、线程同步、线程池
JavaSE进阶13：网络编程入门、UDP通信程序、TCP通信程序、日志、枚举
JavaSE进阶14：类加载器、反射
JavaSE进阶15：XML、注解、单元测试
JavaSE进阶扩充：JDK8 HashMap底层分析（了解）
JavaSE进阶扩充：JDK8 ArrayList线程安全问题和源码分析、集合常见面试题
Java进阶作业

---

---

API回顾（了解）

什么是API：
API (Application Programming Interface) ：应用程序编程接口
java中的API
指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

API帮助文档常常被简说成API

如何使用API帮助文档

例子：

String

格式问题：

equals方法的参数问题：多态

SimpleDateFormat

格式问题：

格式化和解析的方法问题：来自父类

JFrame

格式问题：

添加方法的问题：来自于继承体系，并且参数是多态的形式

方法参数为什么不直接是：JButton，JLabel，JTextField，JTextArea呢？因为多态

Math（应用）

1、Math类概述
Math 包含执行基本数字运算的方法
2、Math中方法的调用方式
Math类中无构造方法，但内部的方法都是静态的，则可以通过 类名.进行调用
3、Math类的常用方法

方法名 方法名	说明
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)

public class MathDemo {
    public static void main(String[] args) {
        //返回参数绝对值
        System.out.println(Math.abs(-10));//10
        //向上取证
        System.out.println(Math.ceil(10.1));//11
        //向下取证
        System.out.println(Math.floor(10.1));//10
        //四舍五入
        System.out.println(Math.round(10.4));//10
        System.out.println(Math.round(10.5));//11
        //返回两个Int值中较大值
        System.out.println(Math.max(10, 20));//20
        //返回两个Int值中较小值
        System.out.println(Math.min(10, 20));//10
        //a的b次幂
        System.out.println(Math.pow(2, 3));//8.0
        //返回double的正直随机数[0.0,1.0)
        System.out.println(Math.random());//0.22540337963818047 随机数
    }
}

System（应用）

System类的常用方法：

方法名	说明
public static void exit(int status)	终止当前运行的 Java 虚拟机，非零表示异常终止
public static long currentTimeMillis()	返回当前时间(以毫秒为单位)
public static native void arraycopy(数据源数组, 起始索引,目的地数组, 起始索引,拷贝个数);	复制数组

public class SystemDemo {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();//开始时间

        int[] arr1={1,2,3,4,5};
        int[] arr2=new int[10];

        //拷贝全部
        System.arraycopy(arr1, 0, arr2, 0, arr1.length);
        System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
        //拷贝arr1最后两个元素到arr2的最后两个索引上
        System.arraycopy(arr1, (arr1.length-2), arr2, (arr2.length-2), 2);
        System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");//共耗时：1毫秒
        
        System.exit(0);//程序强制结束
        System.out.println("还能运行？");//不执行
    }
}

Object（应用）

Object类的toString方法

Object类概述：
Object 是类层次结构的根，每个类都可以将 Object 作为超类（父类）。所有类都直接或者间接的继承自该类，换句话说，该类所具备的方法，所有类都会有一份
查看方法源码的方式：
IDEA选中方法，按下Ctrl + B
重写toString方法的方式：
1.Alt + Insert 选择toString
2.在类的空白区域，右键 -> Generate -> 选择toString
toString方法的作用：
以良好的格式，更方便的展示对象中的属性值

总结：
1.Object是所有类的直接或间接父类
2.直接打印一个对象就是这个对象的toString方法的返回值
3.Object类的toString方法得到的是对象的地址
4.父类中的方法不满足子类需求，对方法进行重写

class Student extends Object {//extends Object不写就会默认有
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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;
    }
//    @Override
//    public String toString() {
//        return "Student{" +
//                "name='" + name + '\'' +
//                ", age=" + age +
//                '}';
//    }
}
class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student("李四",24);
        System.out.println(s);
        System.out.println(s.toString());
        /*
        * 重写父类toStirng()前，输出地址值
        *   leson040701.Student@b4c966a
        *   leson040701.Student@b4c966a
        * 重写父类toStirng()后
        *   Student{name='李四', age=24}
        *   Student{name='李四', age=24}
        * */
    }
}

Object类的equals方法

equals()

equals方法的作用：
1.用于对象之间的比较，返回true和false的结果
2.默认与==相同，引用数据类型比较地址值，重写可以比较内容。
重写equals方法的场景：
不希望比较对象的地址值，想要结合对象属性进行比较的时候。
重写equals方法的方式：
1.alt + insert 选择equals() and hashCode()，IntelliJ Default，一路next，finish即可
2.在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，后面的同上。

class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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;
    }
    @Override
    public boolean equals(Object o) {
        //this -- s1
        //o -- s2
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o; //student -- s2

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }
}
public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        
        Student s2 = new Student();
        s2.setName("林青霞");
        s2.setAge(30);
        
        //需求：比较两个对象的内容是否相同
        System.out.println(s1==s2);//false , 引用数据类型比较地址值
        System.out.println(s1.equals(s2));//true ，重写父类的equals()后比较属性值
    }
}

面试题

看程序分析结果：

String s = “abc”;
StringBuilder sb = new StringBuilder(“abc”);
s.equals(sb); 
sb.equals(s); 

public class InterviewTest {
    public static void main(String[] args) {
        String s1 = "abc";
        StringBuilder sb = new StringBuilder("abc");
        //1.此时调用的是String类中的equals方法.
        //保证参数也是字符串,否则不会比较属性值而直接返回false
        System.out.println(s1.equals(sb)); // false

        //StringBuilder类中是没有重写equals方法,用的就是Object类中的==判断
        System.out.println(sb.equals(s1)); // false

        System.out.println(s1.equals(sb.toString())); // true  将sb转为Stirng类型
    }
}

Objects（应用）

常用方法

方法名	说明
public static String toString(对象)	返回参数中对象的字符串表示形式。
public static String toString(对象, 默认字符串)	返回对象的字符串表示形式，对象为Null，返回默认字符串。
public static Boolean isNull(对象)	判断对象是否为空
public static Boolean nonNull(对象)	判断对象是否不为空

package leson040701;

import java.util.Objects;

public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

class MyObjectsDemo {
    public static void main(String[] args) {

        //public static String toString(对象): 返回参数中对象的字符串表示形式。
        Student s1 = new Student("小罗同学",50);
        System.out.println(Objects.toString(s1));//结果：Student{name='小罗同学', age=50}
        System.out.println(s1);//结果：Student{name='小罗同学', age=50}

        //public static String toString(对象, 默认字符串): 返回对象的字符串表示形式。如果对象为空,那么返回第二个参数.
        Student s2 = new Student("小花同学",23);
        s2 = null;
        System.out.println(Objects.toString(s2, "随便写一个"));//结果：随便写一个

        //public static Boolean isNull(对象): 判断对象是否为空
        Student s3 = null;
        System.out.println(Objects.isNull(s3));//结果：true
        s3 = new Student();
        System.out.println(Objects.isNull(s3));//结果：false

        //public static Boolean nonNull(对象): 判断对象是否不为空
        Student s4 = null;
        System.out.println(Objects.nonNull(s4));//结果：false
        s4 = new Student();
        System.out.println(Objects.nonNull(s4));//结果：true
    }
}

BigDecimal（应用）

计算机进行算数运算时，会把十进制转为二进制进行计算，再转回十进制进行展示。若小数转二进制时只会用一个无限接近的二进制数，造成数据丢失。
作用：
可以用来进行精确计算
构造方法：

方法名	说明
BigDecimal(double val)	参数为double
BigDecimal(String val)	参数为String

常用方法：

方法名	说明
public BigDecimal add(另一个BigDecimal对象)	加法
public BigDecimal subtract (另一个BigDecimal对象)	减法
public BigDecimal multiply (另一个BigDecimal对象)	乘法
public BigDecimal divide (另一个BigDecimal对象)	除法
public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式)	除法

参数1：表示参与运算的BigDecimal 对象。
参数2：表示小数点后面精确到多少位
参数3：舍入模式
              BigDecimal.ROUND_UP  进一法
              BigDecimal.ROUND_FLOOR 去尾法
              BigDecimal.ROUND_HALF_UP 四舍五入

注意：
1.如果想要进行精确运算，使用字符串的构造方法
2.四则运算中的除法，如果除不尽请使用divide的三个参数的方法。

import java.math.BigDecimal;
public class MyBigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal bd1= new BigDecimal(0.1);
        BigDecimal bd2= new BigDecimal(0.2);
        System.out.println(bd1.add(bd2));//0.3000000000000000166533453693773481063544750213623046875
        System.out.println(0.1+0.2);//0.30000000000000004
        //如果想要进行精确运算，使用字符串的构造方法

        BigDecimal bd3= new BigDecimal("0.1");
        BigDecimal bd4= new BigDecimal("0.2");
        //public BigDecimal add(另一个BigDecimal对象)    加法
        System.out.println("加法"+bd3.add(bd4));//加法0.3
        //public BigDecimal subtract (另一个BigDecimal对象)  减法
        System.out.println("减法"+bd3.subtract(bd4));//减法-0.1
        //public BigDecimal multiply (另一个BigDecimal对象)  乘法
        System.out.println("乘法"+bd3.multiply(bd4));//乘法0.02
        //public BigDecimal divide (另一个BigDecimal对象)    除法
        System.out.println("除法"+bd3.divide(bd4));//除法0.5

		/*除不净的情况：*/
        BigDecimal bd5= new BigDecimal("10");
        BigDecimal bd6= new BigDecimal("3");
        //System.out.println("10/3="+bd5.divide(bd6));//报错
        System.out.println("10/3进一法："+bd5.divide(bd6,2,BigDecimal.ROUND_UP));//10/3四舍五入：3.33
        System.out.println("10/3去尾法："+bd5.divide(bd6,2,BigDecimal.ROUND_FLOOR));//10/3四舍五入：3.33
        System.out.println("10/3四舍五入："+bd5.divide(bd6,2,BigDecimal.ROUND_HALF_UP));//10/3四舍五入：3.33

        BigDecimal bd7= new BigDecimal("0.3");
        BigDecimal bd8= new BigDecimal("4");
        //精确结果：0.075
        System.out.println("0.3/4进一法："+bd7.divide(bd8,2,BigDecimal.ROUND_UP));//0.3/4进一法：0.08
        System.out.println("0.3/4去尾法法："+bd7.divide(bd8,2,BigDecimal.ROUND_FLOOR));//0.3/4去尾法法：0.07
        System.out.println("0.3/4四舍五入："+bd7.divide(bd8,2,BigDecimal.ROUND_HALF_UP));//0.3/4四舍五入：0.08
    }
}

时间日期类

Date类（应用）

• 计算机中时间原点

  1970年1月1日 00:00:00

• 时间换算单位

  1秒 = 1000毫秒

• Date类概述

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

• Date类构造方法

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

• 常用方法

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

import java.util.Date;
public class DateDemo02 {
    public static void main(String[] args) {
        //GMT为世界时，我们是用的北京时间，会在世界时间上加上8小时。
        //创建日期对象
        Date d1 = new Date();
        System.out.println(d1);//Sun Apr 10 10:03:32 GMT+08:00 2022

        Date d2 = new Date(0L);//计算机时间原点
        System.out.println(d2);//Thu Jan 01 08:00:00 GMT+08:00 1970

        Date d3 = new Date(2*60*60*1000L);//原点后推2小时
        System.out.println(d3);//hu Jan 01 10:00:00 GMT+08:00 1970

        System.out.println(d1.getTime());//1649556212645
        System.out.println(System.currentTimeMillis());//1649556212671
        //System.currentTimeMillis()和getTime()都是获取时间戳，但是前者不需要new对象，效率明显更高
        
        System.out.println("距离现在"+d1.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");//距离现在52.307084368499495年
        //设置时间为当前时间前1小时。
        d1.setTime(d1.getTime()-(1000*60*60));
        System.out.println(d1);//Sun Apr 10 09:03:32 GMT+08:00 2022
    }

SimpleDateFormat类（应用）

• SimpleDateFormat类概述

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

  ​ 我们重点学习日期格式化和解析

• SimpleDateFormat类构造方法

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

• SimpleDateFormat类的常用方法

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

package lesson0409;

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

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

        //从 String 到 Date
        String ss = "2048-08-09 11:11:11";
        //ParseException
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf3.parse(ss);
        System.out.println(dd);
    }
}
/*
2022/4/10 上午10:25
2022年04月10日 10:25:26
--------
Sun Aug 09 11:11:11 GMT+08:00 2048
 */

时间日期类练习 (应用)

• 需求

  秒杀开始时间是2020年11月11日 00:00:00,结束时间是2020年11月11日 00:10:00,用户小贾下单时间是2020年11月11日 00:03:47,用户小皮下单时间是2020年11月11日 00:10:11,判断用户有没有成功参与秒杀活动

• 实现步骤

  1. 判断下单时间是否在开始到结束的范围内
  2. 把字符串形式的时间变成毫秒值

public class Demo05 {
    public static void main(String[] args) throws ParseException {
        //开始时间 2020年11月11日 00:00:00
        //结束时间 2020年11月11日 00:10:00

        //小贾 2020年11月11日 00:03:47
        //小皮 2020年11月11日 00:10:11

        //1,判断两位同学的下单时间是够在范围之内就可以了
        //2,把每一个时间都换算成毫秒值
        String start = "2020年11月11日 00:00:00";
        String end = "2020年11月11日 00:10:00";

        String jia = "2020年11月11日 00:03:47";
        String pi = "2020年11月11日 00:10:11";

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date sparse = sdf.parse(start);
        Date eparse = sdf.parse(end);
        long startTime = sparse.getTime();
        long endTime = eparse.getTime();

        long jiaTime = sdf.parse(jia).getTime();
        long piTime = sdf.parse(pi).getTime();


        if(jiaTime >= startTime && jiaTime <= endTime){
            System.out.println("小贾同学参与上了秒杀活动");
        }else {
            System.out.println("小贾同学没有参与上了秒杀活动");

        }

        if(piTime >= startTime && piTime <= endTime){
            System.out.println("小pi同学参与上了秒杀活动");
        }else {
            System.out.println("小pi同学没有参与上了秒杀活动");
        }
    }
}