常用API

API概述

API全称是应用程序编程接口，是Java写好的程序，程序员可以直接调用。

Object类：toString方法

Object是祖宗类，它里面的方法，一切子类对象都可以使用。

public String toString()

• 默认是返回当前对象的地址信息。

Student s = new Student("张三",'女', 23);

• System.out.println(s.toString());

  • 返回对象地址

• System.out.println(s);

  • 直接输出对象名，默认是调用toString方法的

toString存在的意义：

• 默认返回对象的地址其实是没有意义的

• 真实存在的意义是被子类重写，以便返回子类对象的内容。

Object类：equals方法

public boolean equals(Object o )

• 默认是比较2个对象的地址是否一样，返回true 或者false

equals存在的意义

• 默认比较对象的地址其实是没有意义的，因为== 号可以更简单的完成

• 存在的的真实意义是被子类重写，以便比较对象的内容。

Object类：clone方法

protected Object clone()

当某个对象调用这个方法时，这个方法会复制一个一模一样的新对象返回。

分类：

1. 浅克隆：拷贝出的新对象，与原对象中的数据一模一样（引用类型拷贝的只是地址）

2. 深克隆：

   对象中基本类型的数据直接拷贝。

   对象中的字符串数据拷贝的还是地址。

   对象中还包含的其他对象，不会拷贝地址，会创建新对象。

Objects

Objects是一个工具类，提供了更安全的方式比较2个对象。

Student s = null;

• s.equals(s2); 空指针异常

• Objects.equals(s, s2); 返回false

Objects常见方法：

方法名	说明
public static boolean equals(Object a, Object b)	比较两个对象的，底层会先进行非空判断，从而可以避免空指针异常。再进行equals比较
public static boolean isNull(Object obj)	判断变量是否为null ,为null返回true ,反之返回false

StringBuilder

StringBuilder称为可变字符串容器，操作字符串的性能优于String类。

StringBuilder拼接操作字符串的手段：性能好

String才是我们的目的：结果数据的类型

StringJoiner

JDK8开始才有的，跟StringBuilder一样，也是用来操作字符串的，也可以看成是一个容器，创建之后里面的内容是可变的。

好处：不仅能提高字符串的操作效率，并且在有些场景下使用它操作字符串，代码会更简洁

public static String getArrayData(int[] arr) {
    // 拼接最终的结果：[11, 22, 33, 44, 55]
    // 1.判断arr是否为null
    if (arr == null) {
        return null;
    }
    StringJoiner sj = new StringJoiner(", ", "[", "]");
    for (int i = 0; i < arr.length; i++) {
        sj.add(arr[i] + "");
    }
    return sj.toString();
}

 

Math

Math相当于是一个工具类，提供的方法全部是完成数学操作的静态方法，直接用类名调用即可。

目标：熟悉Math类的方法就行了。

// 目标：看看Math类的方法就行了。
// 1、取绝对值（拿到的结果一定是正数）
System.out.println(Math.abs(-12));
System.out.println(Math.abs(-12.2));
System.out.println(Math.abs(1443));
​
// 2、向上取整
System.out.println(Math.ceil(3.000001)); // 4.0
System.out.println(Math.ceil(4.0)); // 4.0
​
// 3、向下取整
System.out.println(Math.floor(3.9999999)); // 3.0
System.out.println(Math.floor(3.0)); // 3.0
​
// 4、四舍五入
System.out.println(Math.round(3.45555)); // 3
System.out.println(Math.round(3.500001)); // 4
​
// 5、取较大值
System.out.println(Math.max(10, 20));
​
// 6、取次方
System.out.println(Math.pow(2, 4)); // 16.0
System.out.println(Math.pow(3, 2)); // 9.0
​
// 7、取随机数（用的少）
System.out.println(Math.random()); // [0.0 , 1.0) (包前不包后)

 

System

System代表系统，也是一个工具类的形式，里面的方法都是与系统操作相关的静态方法。

// 目标：了解下System类的几个方法。
// 1、终止虚拟机（干掉全部Java程序的执行）
System.out.println("程序开始。。。");
// System.exit(0); // 0代表是人为认为的正常终止的 (慎用)
​
// 2、获取当前系统的时间信息的。(时间毫秒值：从1970-1-1 0:0:0开始走到此刻的总的毫秒值。1s = 1000ms)
long time = System.currentTimeMillis();
System.out.println(time);
​
// 通常用来统计程序执行的性能问题。
for (int i = 0; i < 2000; i++) {
    System.out.println("输出：" + i);
}
​
long time2 = System.currentTimeMillis();
System.out.println("耗时：" + (time2 - time) / 1000.0 + "s");

 

Runtime

public static void main(String[] args) throws IOException, InterruptedException {
    // 目标：了解下Runtime的几个常见方法。
​
    // 1、public static Runtime getRuntime() 返回与当前Java应用程序关联的运行时对象。
    Runtime r = Runtime.getRuntime();
​
    // 2、public void exit(int status) 终止当前运行的虚拟机,该参数用作状态代码; 按照惯例，非零状态代码表示异常终止。
    // r.exit(0);
​
    // 3、public int availableProcessors(): 获取虚拟机能够使用的处理器数。
    System.out.println(r.availableProcessors());
​
    // 4、public long totalMemory() 返回Java虚拟机中的内存总量。
    System.out.println(r.totalMemory() / 1024.0 / 1024.0 + "MB"); // 1024 = 1K     1024 * 1024 = 1M
​
    // 5、public long freeMemory() 返回Java虚拟机中的可用内存量
    System.out.println(r.freeMemory() / 1024.0 / 1024.0 + "MB");
​
    // 6、public Process exec(String command) 启动某个程序，并返回代表该程序的对象。
//        r.exec("C:\\SoftWare\\XMind2020\\XMind.exe");
    Process p = r.exec("QQ");
    Thread.sleep(5000); // 让程序在这里暂停5s后继续往下走！！
    p.destroy(); // 销毁！关闭程序！
}

 

BigDecimal

封装double类型的数据进行运算的，为了解决计算精度问题

目前：浮点型 double直接运算是不精准的。

• double a1 = 0.1

• double b1 = 0.2;

• double c1 = a1 + b1;

  c1: 0.3000000000000001

把浮点型数据进行封装后再运算

double a = 0.1;
double b = 0.2;
double c = a + b;
System.out.println(c);
System.out.println("--------------------------");
// 使用BigDecimal规避浮点数运算过程中可能出现的精度失真问题
BigDecimal a1 = BigDecimal.valueOf(a);
BigDecimal b1 = BigDecimal.valueOf(b);
// BigDecimal c1 = a1.add(b1);
// BigDecimal c1 = a1.subtract(b1);
// BigDecimal c1 = a1.multiply(b1);
BigDecimal c1 = a1.divide(b1);
System.out.println(c1); // 0.3
BigDecimal c2 = a1.divide(b1, 2, RoundingMode.Half_Up);

 

日期与时间

Date

• 作用：代表当前此刻日期和时间的。

• 构建对象和常用方法：

  Date d = new Date();
  long time = d.getTime();
  Date  d2 = new Date(time) // 把时间毫秒值转换成日期对象。
  ​
  public void setTime(long time): // 设计日期对象为当前时间毫秒值对应的日期。
  d2.setTime(time);

   

SimpleDateFormat

• 作用：格式化、解析时间的。

• 构建对象：public SimpleDateFormat(String pattern)

• 方法

  • public String format(Date d)

    • 格式化日期对象

  • public String format(Object o)

    • 格式化时间毫秒值

  • public Date parse(String date):

    • 把字符串时间解析成日期对象

  // 目标：掌握简单日期格式化类：SimpleDateFormat的使用。
  // 1、创建一个简单日期格式化对象：封装时间格式。
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss:SSS EEE a");
  ​
  // 2、创建日期对象
  Date d = new Date();
  System.out.println(d);
  ​
  // 3、开始使用简单日期格式化对象负责格式化日期成为我们喜欢的字符串时间形式
  String rs = sdf.format(d);
  System.out.println(rs);
  ​
  // 4、可以格式化时间毫秒值
  long time = d.getTime() + 121 * 1000;
  System.out.println(sdf.format(time));

   

  • 字符串日期解析

  public class SimpleDateFormatDemo2 {
      public static void main(String[] args) throws ParseException {
          // 目标2：掌握简单日期格式化的解析操作。
          // 需要：把字符串时间解析成日期对象
          String dateStr = "2022-11-11 11:11:12";
          // 1、创建简单日期格式化对象。
          // 注意、注意、注意: 解析时间的格式必须与被解析时间的格式一模一样，否则报错！
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  ​
          // 2、开始解析了(会报错的，把异常抛出去，什么意思，今天会详细讲解)
          Date d = sdf.parse(dateStr);
          System.out.println(d);
      }
  }

   

Calendar

• 作用：代表的是系统此刻时间对应的日历，通过它可以单独获取、修改时间中的年、月、日、时、分、秒等

• 构建对象和常用方法：

  // 目标：掌握日历类的使用。
  // 1、得到日历对象
  Calendar c = Calendar.getInstance();
  System.out.println(c);
  
  // 2、获取信息：public int get(int field):
  int year = c.get(Calendar.YEAR);
  System.out.println(year);
  
  int days = c.get(Calendar.DAY_OF_YEAR);
  System.out.println(days);
  
  // 3、获取日期对象（了解）
  Date d = c.getTime();
  System.out.println(d);
  
  long time0 = d.getTime();
  
  // 4、时间毫秒值（了解）
  long time = c.getTimeInMillis();
  System.out.println(time);
  
  // 5、修改日历的时间（需求：问89天后是什么日子）
  // 参数一：信息字段：一年中的第几天
  // 参数二：往后加多少天。
  c.add(Calendar.DAY_OF_YEAR, 89);
  Date d1 = c.getTime();
  System.out.println(d1);
  
  c.set(Calendar.DAY_OF_YEAR, 364); // 直接修改日历到某一天！
  Date d2 = c.getTime();
  System.out.println(d2);

   

JDK8新增日期类

LocalDate、LocalTime、LocalDateTime

LocalDate：代表本地日期(年、月、日、星期) LocalTime：代表本地时间(时、分、秒、纳秒) LocalDateTime：代表本地日期、时间(年、月、日、星期、时、分、秒、纳秒)

ZoneId、ZonedDateTime

提供了一些带时区的相关方法。

Instant

代表时间线上的某个时刻/时间戳

通过获取Instant的对象可以拿到此刻的时间，该时间由两部分组成：从1970-01-01 00:00:00 开始走到此刻的总秒数 + 不够1秒的纳秒数

DateTimeFormatter

可以用来格式化或者解析日期时间

public class Demo {
    // 目标：掌握JDK 8新增的DateTimeFormatter格式化器的用法。
    public static void main(String[] args) {
        // 1、创建一个日期时间格式化器对象出来。
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

        // 2、对时间进行格式化
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);

        String rs = formatter.format(now); // 正向格式化
        System.out.println(rs);

        // 3、格式化时间，其实还有一种方案。
        String rs2 = now.format(formatter); // 反向格式化
        System.out.println(rs2);

        // 4、解析时间：解析时间一般使用LocalDateTime提供的解析方法来解析。
        String dateStr = "2029年12月12日 12:12:11";
        LocalDateTime ldt = LocalDateTime.parse(dateStr, formatter);
        System.out.println(ldt);
    }
}

 

Period、Duration

Period（一段时期）

l可以用于计算两个 LocalDate对象 相差的年数、月数、天数。

public class PeriodDemo1 {
    public static void main(String[] args) {
        //张二狗的生日是1998年12月3日,请问到今天张二狗活了多长时间? => 基于Period进行差值计算
        LocalDate ergouBirthday = LocalDate.of(1998, 12, 3);
        LocalDate now = LocalDate.now();

        //public static Period between(LocalDate l1,LocalDate l2)
        Period period = Period.between(ergouBirthday, now);

        //基于get方法获取差额信息的数据信息 getMonths:获取的差额信息中的月份【必须和年搭配在一起看】
        //如果想查看总月份可以基于toTotalMonth进行获取
        int years = period.getYears();
        int months = period.getMonths();
        int days = period.getDays();

        System.out.println(years + " " + months + " " + days);
    }
}

 

Duration（持续时间）

可以用于计算两个时间对象相差的天数、小时数、分数、秒数、纳秒数；支持LocalTime、LocalDateTime、Instant等时间。

public class DurationDemo1 {
    public static void main(String[] args) {
        //晚上7:30开始考试,小明9:25:30秒交卷了 【计算小明总共答卷的耗时时间】
        LocalTime startTime = LocalTime.of(19, 30, 0);
        LocalTime mingTime = LocalTime.of(21, 25, 30);

        //获取两个时间的差值
        Duration duration = Duration.between(startTime, mingTime);

        //可以基于get方法来获取差值中的相关信息
        long seconds = duration.getSeconds();
        System.out.println("【seconds】:" + seconds);

        //可以基于to方法来获取差值中的不同单位的总信息【总共几小时】【总共多少分钟】【总共多少秒】
        long hours = duration.toHours();
        System.out.println("【hours】:" + hours);
        long minutes = duration.toMinutes();
        System.out.println("【minutes】:" + minutes);
        long millis = duration.toMillis();
        System.out.println("【millis】:" + millis);
    }
}