【day16】Java开发常用API

模块15回顾

在深入探讨模块16之前，让我们回顾一下【day15】中的重点内容：

String类：
- 构造方法：String(), String(String s), String(char[] chars), String(byte[] bytes), String(char[] chars, int offset, int count), String(byte[] chars, int offset, int count)。
- 判断方法：equals, equalsIgnoreCase。
- 获取方法：length(), concat(String s), charAt(int index), indexOf(String s), substring(开始索引), substring(开始索引, 结束索引)。
- 转换方法：toCharArray(), getBytes(), getBytes(String charsetName), replace(c1, c2)。
- 分割方法：split(String regex)。
- 其他方法：contains(String s), endsWith(String s), startsWith(String s), toLowerCase(), toUpperCase(), trim()。
StringBuilder类：
- append(任意类型数据)：字符串拼接。
- reverse()：字符串反转。
- toString()：将StringBuilder转换为String。

模块十六重点

本模块将重点介绍以下几个常用的Java API：

BigInteger和BigDecimal操作。
Date和SimpleDateFormat的操作。
System中的常用方法，主要是数组复制。
Arrays中的常用方法。
利用包装类定义一个标准的JavaBean。
包装类和String之间的转换。

第一章：Math类

1. Math类介绍

Math类是一个数学工具类，主要用于数学运算，其特点如下：

构造方法私有，不能实例化。
方法都是静态的，可以直接通过类名调用。

2.Math类方法

以下是Math类的一些常用方法：

static int abs(int a)：求参数的绝对值。
static double ceil(double a)：向上取整。
static double floor(double a)：向下取整。
static long round(double a)：四舍五入。
static int max(int a, int b)：求两个数之间的较大值。
static int min(int a, int b)：求两个数之间的较小值。

public class Demo01Math {
    public static void main(String[] args) {
        System.out.println(Math.abs(-10));
        System.out.println(Math.ceil(3.6));
        System.out.println(Math.floor(3.6));
        System.out.println(Math.round(3.6));
        System.out.println(Math.round(-2.8));
        System.out.println(Math.max(10, 20));
        System.out.println(Math.min(10, 20));
    }
}

第二章：BigInteger

1.BigInteger介绍

BigInteger类用于处理超出long范围的超大整数。以下是其构造方法和常用操作：

BigInteger(String val)：参数必须是数字形式的字符串。
BigInteger add(BigInteger val)：返回两数之和。
BigInteger subtract(BigInteger val)：返回两数之差。
BigInteger multiply(BigInteger val)：返回两数之积。
BigInteger divide(BigInteger val)：返回两数之商。

public class Demo02BigInteger {
    public static void main(String[] args) {
        BigInteger b1 = new BigInteger("121212121212121212121212121212121212121");
        BigInteger b2 = new BigInteger("121212121212121212121212121212121212121");
        System.out.println(b1.add(b2));
        System.out.println(b1.subtract(b2));
        System.out.println(b1.multiply(b2));
        System.out.println(b1.divide(b2));
    }
}

第三章：BigDecimal类

1.BigDecimal介绍

BigDecimal类用于解决float和double运算中的精度损失问题。以下是其构造方法和常用操作：

BigDecimal(String val)：参数必须是数字形式的字符串。
static BigDecimal valueOf(double val)：初始化小数时可以传入double型数据。
BigDecimal add(BigDecimal val)：返回两数之和。
BigDecimal subtract(BigDecimal val)：返回两数之差。
BigDecimal multiply(BigDecimal val)：返回两数之积。
BigDecimal divide(BigDecimal val)：返回两数之商。
BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)：指定保留小数位数和取舍方式的除法。

public class Demo03BigDecimal {
    public static void main(String[] args) {
        BigDecimal b1 = new BigDecimal("3.55");
        BigDecimal b2 = new BigDecimal("2.12");
        BigDecimal divide = b1.divide(b2, 2, BigDecimal.ROUND_UP);
        System.out.println("divide = " + divide);
        double v = divide.doubleValue();
        System.out.println("v = " + v);
    }
}

第四章：Date日期类

1.Date类的介绍

Date类用于表示特定的瞬间，精确到毫秒。以下是其构造方法和常用方法：

Date()：获取当前系统时间。
Date(long time)：获取指定时间，传递毫秒值。

private static void date01() {
    Date date1 = new Date();
    System.out.println("date1 = " + date1);
    Date date2 = new Date(1000L);
    System.out.println("date2 = " + date2);
}

第五章：Calendar日历类

1.Calendar介绍

Calendar是一个抽象类，用于操作日历相关的操作。以下是其常用方法：

static Calendar getInstance()：获取Calendar实例。
int get(int field)：返回给定日历字段的值。
void set(int field, int value)：将给定的日历字段设置为指定的值。
void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
Date getTime()：将Calendar转换为Date对象。

private static void calendar02() {
    Calendar calendar = Calendar.getInstance();
    int year = calendar.get(Calendar.YEAR);
    System.out.println("year = " + year);
    calendar.add(Calendar.YEAR, -1);
    System.out.println(calendar.get(Calendar.YEAR));
    Date date = calendar.getTime();
    System.out.println("date = " + date);
}

需求: 键盘录入一个年份,判断这一年是闰年,还是平年

创建Calendar对象
创建Scanner对象,键盘录入一个年份
调用set方法,传递年,月,日，set(年,2,1) -> 国外是0-11,所以设置成2月就是代表3月
将day减1天(3月1日减1天,就是2月最后一天,知道2月最后一天了,就知道是平年还是闰年了)
获取day判断平年还是闰年,输出结果

private static void calendar03() {
     //1.创建Calendar对象
     Calendar calendar = Calendar.getInstance();
     //2.创建Scanner对象,键盘录入一个年份
     Scanner sc = new Scanner(System.in);
     int year = sc.nextInt();
     //3.调用set方法,传递年,月,日
     //set(年,2,1) -> 国外是0-11,所以设置成2月就是代表3月
     calendar.set(year,2,1);
     //4.将day减1天(3月1日减1天,就是2月最后一天,知道2月最后一天了,就知道是平年还是闰年了)
     calendar.add(Calendar.DATE,-1);
     int day = calendar.get(Calendar.DATE);
     //5.获取day判断平年还是闰年,输出结果
     if (day==29){
         System.out.println("闰年");
     }else{
         System.out.println("平年");
     }

 }

第六章：SimpleDateFormat日期格式化类

1.SimpleDateFormat介绍

SimpleDateFormat类用于格式化和解析日期。以下是其构造方法和常用方法：

SimpleDateFormat(String pattern)：指定日期格式。
String format(Date date)：将Date对象按照指定的格式转换为字符串。
Date parse(String source)：将符合日期格式的字符串转换为Date对象。

时间字母表示	说明
y	年
M	月
d	日
H	时
m	分
s	秒

public class Demo03SimpleDateFormat {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time1 = sdf.format(new Date()); // 将Date对象按照指定的格式转成String
        System.out.println("time1 = " + time1);
        String time2 = "2000-10-10 10:10:10";
        Date date = sdf.parse(time2); // 将符合日期格式的字符串转成Date对象
        System.out.println("date = " + date);
    }
}

第七章：JDK8新日期类

1.LocalDate本地日期

LocalDate是一个不可变的日期时间对象，表示日期，通常被视为年月日。以下是其常用方法：

static LocalDate now()：创建LocalDate对象。
static LocalDate of(int year, int month, int dayOfMonth)：创建LocalDate对象，设置年月日。

public class Demo04LocalDate {
    public static void main(String[] args) {
        LocalDate localDate = LocalDate.now();
        System.out.println("localDate = " + localDate);
        // //static LocalDate of(int year, int month, int dayOfMonth)  -> 创建LocalDate对象,设置年月日
        LocalDate localDate1 = LocalDate.of(2000, 10, 10);
        System.out.println("localDate1 = " + localDate1);
    }
}

1.2.LocalDateTime对象

LocalDateTime是一个不可变的日期时间对象，代表日期时间，通常被视为年-月-日-时-分-秒。以下是其常用方法：

static LocalDateTime now()：创建LocalDateTime对象。
static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second)：创建LocalDateTime对象，设置年月日时分秒。

public class Demo05LocalDateTime {
    public static void main(String[] args) {
        LocalDateTime
 localDateTime = LocalDateTime.now();
        System.out.println("localDateTime = " + localDateTime);
        // //static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second) 创建LocalDateTime对象,设置年月日时分秒
        LocalDateTime localDateTime1 = LocalDateTime.of(2000, 10, 10, 10, 10, 10);
        System.out.println("localDateTime1 = " + localDateTime1);
    }
}

1.3.获取日期字段的方法

以下是获取日期字段的常用方法：

int getYear()：获取年份。
int getMonthValue()：获取月份。
int getDayOfMonth()：获取月中的第几天。

private static void get() {
    LocalDate localDate = LocalDate.now();
    // //int getYear()->获取年份
    System.out.println(localDate.getYear());
    // //int getMonthValue()->获取月份
    System.out.println(localDate.getMonthValue());
    //int getDayOfMonth()->获取月中的第几天
    System.out.println(localDate.getDayOfMonth());
}

1.4.设置日期字段的方法

以下是设置日期字段的常用方法：名字是with开头

LocalDate withYear(int year)：设置年份。
LocalDate withMonth(int month)：设置月份。
LocalDate withDayOfMonth(int day)：设置月中的天数。

    private static void with() {
        LocalDate localDate = LocalDate.now();
        //LocalDate withYear(int year):设置年份
        //LocalDate localDate1 = localDate.withYear(2000);
        //System.out.println(localDate1);

        //LocalDate withMonth(int month):设置月份
        //LocalDate localDate2 = localDate1.withMonth(10);
        //System.out.println("localDate2 = " + localDate2);
        //LocalDate withDayOfMonth(int day):设置月中的天数

        //LocalDate localDate3 = localDate2.withDayOfMonth(10);
        //System.out.println("localDate3 = " + localDate3);

        LocalDate localDate1 = localDate.withYear(2000).withMonth(10).withDayOfMonth(10);
        System.out.println("localDate1 = " + localDate1);
    }

1.5.日期字段偏移

以下是日期字段偏移的常用方法：

plus开头的方法：向后偏移。
minus开头的方法：向前偏移。

    /*
      向后偏移 -> plus开头方法
      向前偏移 -> minus开头方法
     */
    private static void plusAndMinus() {
        LocalDate localDate = LocalDate.now();
       // LocalDate localDate1 = localDate.plusYears(1L);
       // System.out.println("localDate1 = " + localDate1);
        LocalDate localDate1 = localDate.minusYears(1L);
        System.out.println("localDate1 = " + localDate1);

    }

2.Period和Duration类

2.1 Period计算日期之间的偏差

以下是Period类的常用方法：

static Period between(LocalDate d1, LocalDate d2)：计算两个日期之间的差值。
getYears()：获取相差的年。
getMonths()：获取相差的月。
getDays()：获取相差的天。

private static void period() {
    LocalDate local1 = LocalDate.of(2022, 12, 12);
    LocalDate local2 = LocalDate.of(2021, 11, 11);
    Period period = Period.between(local2, local1);
    System.out.println(period.getYears());
    System.out.println(period.getMonths());
    System.out.println(period.getDays());
}

2.2 Duration计算时间之间的偏差

以下是Duration类的常用方法：

static Duration between(Temporal startInclusive, Temporal endExclusive)：计算时间差。
toDays()：获取相差天数。
toHours()：获取相差小时。
toMinutes()：获取相差分钟。
toMillis()：获取相差秒（毫秒）。

参数需要传递 Temporal 的实现类对象, 注意要传递LocalDateTime，因为Duration计算精确时间偏差，所以需要传递能操作精确时间的 LocalDateTime

private static void duration() {
    LocalDateTime local1 = LocalDateTime.of(2022, 12, 12, 12, 12, 12);
    LocalDateTime local2 = LocalDateTime.of(2021, 11, 11, 11, 11, 11);
    Duration duration = Duration.between(local2, local1);
    System.out.println(duration.toDays());
    System.out.println(duration.toHours());
    System.out.println(duration.toMinutes());
    System.out.println(duration.toMillis());
}

如果计算年月日，就用Period

如果计算时分秒，就用Duration

3.DateTimeFormatter日期格式化类

DateTimeFormatter类用于格式化和解析日期。以下是其常用方法：

static DateTimeFormatter ofPattern(String pattern)：获取DateTimeFormatter对象，指定格式。
String format(TemporalAccessor temporal)：将日期对象按照指定的规则转换为字符串。
TemporalAccessor parse(CharSequence text)：将符合规则的字符串转换为日期对象。

private static void parse() {
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    String time = "2000-10-10 10:10:10";
    TemporalAccessor temporalAccessor = dtf.parse(time);
    LocalDateTime localDateTime = LocalDateTime.from(temporalAccessor);
    System.out.println("localDateTime = " + localDateTime);
}

第八章：System类

System类是一个系统相关工具类，其特点如下：

构造方法私有，不能实例化。
方法都是静态的，可以直接通过类名调用。

以下是System类的常用方法：

static long currentTimeMillis()：返回以毫秒为单位的当前时间，可用于测量效率。
static void exit(int status)：终止当前正在运行的Java虚拟机。
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：数组复制。

方法	说明
static long currentTimeMillis()	返回以毫秒为单位的当前时间,可以测效率
static void exit(int status)	终止当前正在运行的 Java 虚拟机
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length	数组复制 src:源数组 srcPos:从源数组的哪个索引开始复制 dest:目标数组 ldestPos:从目标数组哪个索引开始粘贴 length:复制多少个元素

public class Demo01System {
    public static void main(String[] args) {
        arraycopy();
    }

    private static void arraycopy() {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = new int[10];
        System.arraycopy(arr1, 0, arr2, 0, 5);
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");
        }
    }
}

第九章：Arrays数组工具类

Arrays类是一个数组工具类，其特点如下：

构造方法私有，不能实例化。
方法都是静态的，可以直接通过类名调用。

以下是Arrays类的常用方法：

static String toString(int[] a)：按照格式打印数组元素。
static void sort(int[] a)：升序排序。
static int binarySearch(int[] a, int key)：二分查找（前提是升序）。
static int[] copyOf(int[] original, int newLength)：数组扩容。

方法	说明
static String toString(int[] a)	按照格式打印数组元素 [元素1, 元素2, …]
static void sort(int[] a)	升序排序
static int binarySearch(int[] a, int key)	二分查找(前提是升序)
static int[] copyOf(int[] original, int newLength)	数组扩容

public class Demo02Arrays {
    public static void main(String[] args) {
        int[] arr = {5, 3, 4, 6, 5, 4, 7};
        System.out.println(Arrays.toString(arr));

        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        int[] arr1 = {1, 2, 3, 4, 5, 6, 7};
        int index = Arrays.binarySearch(arr1, 3);
        System.out.println("index = " + index);

        int[] arr2 = {1, 2, 3, 4, 5};
        int[] newArr = Arrays.copyOf(arr2, 10);
        System.out.println(Arrays.toString(newArr));
    }
}

在这里插入图片描述

第十章：包装类

1.基本数据类型对应的引用数据类型（包装类）

包装类是基本数据类型对应的类，它们使得基本数据类型具有类的特性。以下是基本数据类型与其对应的包装类：

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

2.Integer的介绍及使用

2.1.Integer基本使用

Integer是int的包装类，以下是其构造方法和基本使用：

Integer(int value)：不推荐使用，但仍然可用。
Integer(String s)：s必须是数字形式的字符串。

public class Demo01Integer {
    public static void main(String[] args) {
        Integer i1 = new Integer(10);
        System.out.println("i1 = " + i1);

        Integer i2 = new Integer("10");
        System.out.println("i2 = " + i2);
    }
}

2.2.自动拆箱装箱

Integer类提供了自动拆箱和装箱的功能，使得基本类型和Integer之间的转换更加方便。

public class Demo04Integer {
    public static void main(String[] args) {
        Integer i = 10; // 发生了自动装箱
        Integer sum = i + 10; // 发生了自动拆箱装箱
        System.out.println("sum = " + sum);
    }
}

在这里插入图片描述

public class Demo05Integer {
	public static void main(String[] args) {
		Integer i1 = 100;
		Integer i2 = 100;
		System.out.println(i1==i2);

		Integer i3 = 128;
		Integer i4 = 128;
		System.out.println(i3==i4);
	}
}

在这里插入图片描述

3.基本类型和String之间的转换

3.1 基本类型往String转

以下是将基本类型转换为String的常用方法：

使用+拼接。
使用String中的静态方法valueOf。

private static void method01() {
    int i = 10;
    String s1 = i + "";
    System.out.println(s1 + 1);

    System.out.println("============");

    String s = String.valueOf(10);
    System.out.println(s + 1);
}

3.2 String转成基本数据类型

以下是将String转换为基本数据类型的常用方法：

每个包装类中都有一个类似的方法：parseXXX。

位置	方法	说明
Byte	static byte parseByte(String s)	将String转byte类型
Short	static short parseShort(String s)	将String转成short类型
Integer	static int parseInt(String s)	将String转成int类型
Long	static long parseLong(String s)	将String转成long类型
Float	static float parseFloat(String s)	将String转成float类型
Double	static double parseDouble(String s)	将String转成double类型
Boolean	static boolean parseBoolean(String s)	将String转成boolean类型

private static void method02() {
    int number = Integer.parseInt("1111");
    System.out.println(number + 1);
}