第二章 常用API

1. 常用API一

1.1 API课程介绍

API(Application Programming interface)：应用程序编程接口
就是Java帮我们已经写好一些程序，如：类、方法等，我们直接拿过来用就可以解决一些问题。

1.2 API:Object类的toString、equals方法

Object类是Java中所有类的祖宗类，因此，Java中所有类的对象都可以直接使用Object类中提供的一些方法。

Student类：

package com.itheima.object;import java.util.Objects;/*** @ClassName Student* @Description 学生类* @Author 孙克旭* @Date 2025/3/18 7:57*/
public class Student {private String name;private int age;/*** 比较两个对象内容是否相同** @param o* @return*/@Overridepublic boolean equals(Object o) {if (this == o) { //比较的对象是同一个对象return true;}if (o == null || getClass() != o.getClass()) { //比较的对象是null，或者两个对象的数据类型不同return false;}Student student = (Student) o;//比较两个对象的内容return age == student.age && Objects.equals(name, student.name);}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}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;}
}

测试类：

package com.itheima.object;/*** @ClassName Test1* @Description 测试类* @Author 孙克旭* @Date 2025/3/18 8:00*/
public class Test1 {public static void main(String[] args) {Student s1 = new Student("孙克旭", 20);System.out.println(s1);
//        System.out.println(s1.toString());Student s2 = new Student("孙克旭", 20);System.out.println(s1.equals(s2)); //trueSystem.out.println(s1 == s2); //false，比较的是两个对象的地址}
}

1.3 API-Object的克隆方法

1.4 API-Objects类

Objects是一个工具类，提供了很多操作对象的静态方法给我们使用。

package com.itheima.objects;import java.util.Objects;public class Test {public static void main(String[] args) {String s1 = "孙克旭";String s2 = null;System.out.println(s1.equals(s2)); //false
//        System.out.println(s2.equals(s1)); 报错//使用Objects工具类更方便、更安全System.out.println(Objects.equals(s1, s2)); //falseSystem.out.println(Objects.isNull(s1)); //falseSystem.out.println(Objects.isNull(s2)); //trueSystem.out.println(Objects.nonNull(s1)); //trueSystem.out.println(Objects.nonNull(s2)); //false}
}

1.5 API-包装类

包装类就是把基本类型的数据包装成对象。

基本数据类型	对应的包装类（引用数据类型）
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

package com.itheima.integer;import java.util.ArrayList;public class Test {public static void main(String[] args) {//自动装箱：基本数据类型自动转换成引用数据类型Integer a1 = 12;//自动拆箱：引用数据类型自动转换成基本数据类型int a2 = a1;//集合和泛型只能使用引用数据类型ArrayList<Integer> list = new ArrayList<>();list.add(10); //自动装箱int a3 = list.get(0); //自动拆箱System.out.println("-------------------------");//1.将数值转为字符串Integer a = 100;String s = Integer.toString(a);System.out.println(s);//2.将字符串转换为数字int i = Integer.parseInt(s);System.out.println(i);Integer value = Integer.valueOf(s); //推荐System.out.println(value);}
}

1.6 单元练习8

1.6.1 Object 类的作用是什么？它有哪些常用方法？

Object 类是所有 Java 类的父类，它定义了所有对象都具有的基本属性和方法。
Object 类的作用是为其他类提供一个通用的对象类型，并提供一些通用的方法，
例如 equals、clone、toString 等。Object 类中最常用的方法包括：equals(Object obj)：用于判断当前对象是否与指定对象相等；
toString()：用于返回当前对象的字符串表示形式；
clone(): 克隆当前对象，返回一个新对象

1.6.2 Objects 类是什么？它与 Object 类有什么区别？

Objects 类是一个工具类，用于操作对象，提供了一些方便的方法，例如 equals、isNull、nonNull等。
equals(Object a,Object b)：先做非空判断，在比较两个对象是否相等；
isNull()：判断对象是否为null，为null返回true，反之false；
nonNull(): 判断对象是否不为null，不为null返回true，反之false

1.6.3 基本类型包装类有哪些？它们有什么作用？

Java 中提供了 8 个基本类型，分别是 byte、short、int、long、float、double、boolean 和 char。
每个基本类型都有对应的包装类，用于将基本类型转换为对象，以便能够在面向对象的环境中使用。
这些基本类型包装类分别是：Byte、Short、Integer、Long、Float、Double、Boolean 和 Character。

1.6.4 编码题1

编写一个测试类
① 演示 Object 类中的 equals 方法、toString 方法
② 演示 Person 类（属性：name,age） 重写Object中的 equals 方法、toString 方法和 clone 方法，并在测试类中进行演示
③ 演示 Objects 类中的 equals 方法、isNull 方法和 nonNull 方法的使用

---

Person类：

package com.itheima.object;import java.util.Objects;/*** @ClassName Person* @Description Person类* @Author 孙克旭* @Date 2025/3/18 10:57*/
public class Person implements Cloneable {private String name;private int age;@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {if (this == o) {return true;}if (o == null || getClass() != o.getClass()) {return false;}Person person = (Person) o;return age == person.age && Objects.equals(name, person.name);}public Person() {}public Person(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;}
}

测试类：

package com.itheima.object;import java.util.Objects;/*** @ClassName Test2* @Description 测试类* @Author 孙克旭* @Date 2025/3/18 11:01*/
public class Test2 {public static void main(String[] args) throws CloneNotSupportedException {Person p1 = new Person("孙克旭", 24);Person p2 = new Person("老男孩", 45);System.out.println(p1.equals(p2)); //falseSystem.out.println(p1); //Person{name='孙克旭', age=24}Person clone = (Person) p1.clone();System.out.println(clone); //Person{name='孙克旭', age=24}System.out.println("-----------------------");System.out.println(Objects.equals(p1, p2)); //falseSystem.out.println(Objects.isNull(p1)); //falseSystem.out.println(Objects.nonNull(p1)); //true}
}

1.6.5 编码题2

设计一个购物车系统，其中涉及到以下两个类：
Product类，表示一个商品，包含商品的编号（id）、名称（name）、价格（price）等属性；
ShoppingCart类，表示一个购物车，包含多个商品（Product对象）。
请完成以下任务：
①在Product类中重写equals方法，判断两个商品是否相同时，只需要比较它们的编号id。
②在Product类中重写toString方法，使得打印出一个Product对象时，输出该商品的编号、名称、价格等信息。
③在Product类中实现Cloneable接口，并重写clone方法，使得可以复制一个Product对象。
④在ShoppingCart类中实现以下方法：
void addProduct(Product product)：向购物车中添加一个商品；
void removeProduct(Product product)：从购物车中移除一个商品；
double calculateTotalPrice()：计算购物车中所有商品的总价。
⑤新建一个测试类
1.测试自定义equals方法
2.测试自定义toString方法
3.测试clone方法
4.测试添加方法
5.测试删除方法

---

商品类：

package com.itheima.object.work;/*** @ClassName Product* @Description 商品类* @Author 孙克旭* @Date 2025/3/18 11:10*/
public class Product implements Cloneable {private int id; //编号private String name; //名称private double price; //价格@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}@Overridepublic String toString() {return "Product{" +"id=" + id +", name='" + name + '\'' +", price=" + price +'}';}@Overridepublic boolean equals(Object o) {if (this == o) {return true;}if (o == null || getClass() != o.getClass()) {return false;}Product product = (Product) o;return id == product.id;}public Product() {}public Product(int id, String name, double price) {this.id = id;this.name = name;this.price = price;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}
}

购物车类：

package com.itheima.object.work;import java.util.ArrayList;/*** @ClassName ShoppingCart* @Description 购物车类* @Author 孙克旭* @Date 2025/3/18 11:14*/
public class ShoppingCart {private ArrayList<Product> products = new ArrayList<>();/*** 向购物车中添加一个商品** @param product*/void addProduct(Product product) {products.add(product);}/*** 从购物车中移除一个商品** @param product*/void removeProduct(Product product) {products.remove(product);}/*** 计算购物车中所有商品的总价** @return*/double calculateTotalPrice() {double sum = 0;for (int i = 0; i < products.size(); i++) {sum += products.get(i).getPrice();}return sum;}
}

测试类：

package com.itheima.object.work;/*** @ClassName Test* @Description 测试类* @Author 孙克旭* @Date 2025/3/18 11:19*/
public class Test {public static void main(String[] args) throws CloneNotSupportedException {Product p1 = new Product(100, "电脑", 1000);Product p2 = new Product(101, "手机", 800);System.out.println(p1.equals(p2)); //falseSystem.out.println(p1.toString()); //Product{id=100, name='电脑', price=1000.0}Product p3 = (Product) p2.clone();ShoppingCart cart = new ShoppingCart();cart.addProduct(p1);cart.addProduct(p2);cart.addProduct(p3);cart.removeProduct(p3);System.out.println(cart.calculateTotalPrice()); //1800.0}
}

1.6.6 编码题3

实现一个简单的图书管理系统，其中涉及以下两个类：
Book类，表示一本书，包含书名（title）、作者（author）、出版社（publisher）和价格（price）等属性；
Library类，表示一个图书馆，包含多本书（Book对象）。
请完成以下任务：
①在Book类中重写equals方法，判断两本书是否相同时，只需要比较它们的书名和作者；
②在Book类中重写toString方法，使得打印出一个Book对象时，输出该书的书名、作者、出版社和价格等信息；
③在Book类中实现Cloneable接口，并重写clone方法，使得可以复制一本Book对象；
④在Library类中实现以下方法：
void addBook(Book book)：向图书馆中添加一本书；
void removeBook(Book book)：从图书馆中移除一本书；
List searchBook(String keyword)：根据关键词在图书馆中搜索书籍，返回符合条件的所有书籍的列表。
⑤在测试类中，新建一个 Library对象，并向Library中添加三本书籍。然后测试查找、测试删除、测试克隆
提示：可以使用List集合存储图书馆中的所有书籍。

---

图书类：

package com.itheima.object.work;import java.util.Objects;/*** @ClassName Book* @Description 图书类* @Author 孙克旭* @Date 2025/3/18 11:30*/
public class Book implements Cloneable {private String title; //书名private String author; //作者private String publisher; //出版社private double price; //价格@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}@Overridepublic String toString() {return "Book{" +"title='" + title + '\'' +", author='" + author + '\'' +", publisher='" + publisher + '\'' +", price=" + price +'}';}@Overridepublic boolean equals(Object o) {if (this == o) {return true;}if (o == null || getClass() != o.getClass()) {return false;}Book book = (Book) o;return Objects.equals(title, book.title) && Objects.equals(author, book.author);}public Book() {}public Book(String title, String author, String publisher, double price) {this.title = title;this.author = author;this.publisher = publisher;this.price = price;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public String getPublisher() {return publisher;}public void setPublisher(String publisher) {this.publisher = publisher;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}
}

图书馆类：

package com.itheima.object.work;import java.util.ArrayList;/*** @ClassName Library* @Description 图书馆类* @Author 孙克旭* @Date 2025/3/18 11:32*/
public class Library {private ArrayList<Book> books = new ArrayList<>();/*** 向图书馆中添加一本书** @param book*/void addBook(Book book) {books.add(book);}/*** 从图书馆中移除一本书** @param book*/void removeBook(Book book) {books.remove(book);}/*** 根据关键词在图书馆中搜索书籍，返回符合条件的所有书籍的列表。** @param keyword* @return*/ArrayList<Book> searchBook(String keyword) {ArrayList<Book> books = new ArrayList<>();for (int i = 0; i < this.books.size(); i++) {Book book = this.books.get(i);if (book.getTitle().contains(keyword)) {books.add(book);}}return books;}public ArrayList<Book> getBooks() {return books;}public void setBooks(ArrayList<Book> books) {this.books = books;}
}

测试类：

package com.itheima.object.work;import java.util.ArrayList;/*** @ClassName Test2* @Description 测试类* @Author 孙克旭* @Date 2025/3/18 11:40*/
public class Test2 {public static void main(String[] args) {Library library = new Library();library.addBook(new Book("三国演义", "罗贯中", "人民出版社", 52));library.addBook(new Book("三国杀", "A", "网易出版社", 5200));library.addBook(new Book("红楼梦", "曹雪芹", "人民出版社", 52));ArrayList<Book> books = library.searchBook("三国");System.out.println(books);System.out.println(library.getBooks());}
}

2. 常用API二

2.1 API-StringBuilder

StringBuilder代表可变字符串对象，相当于是一个容器，它里面装的字符串是可以改变的，就是用来操作字符串的。

好处：StringBuilder比String更适合做字符串的修改操作，效率会更高，代码也会更简洁。

package com.itheima.stringBuilder;public class Demo1 {public static void main(String[] args) {StringBuilder s1 = new StringBuilder();System.out.println(s1); //""StringBuilder s = new StringBuilder("孙克旭");//1.字符串拼接s.append("喜欢");//支持链式编程s.append("Java").append('和').append("Linux").append(666);System.out.println(s); //孙克旭喜欢Java和Linux666//2.反转字符串s.reverse();System.out.println(s); //666xuniL和avaJ欢喜旭克孙//3.字符串的长度System.out.println(s.length()); //18//4.把StringBuilder对象转换成Strings.reverse();String s2 = s.toString();System.out.println(s2); //孙克旭喜欢Java和Linux666}
}

2.2 API-StringBuilder拼接案例

package com.itheima.stringBuilder;/*** @ClassName Demo2* @Description 案例* @Author 孙克旭* @Date 2025/3/18 21:04*/
public class Demo2 {public static void main(String[] args) {System.out.println(getArrayData(new int[]{1, 2, 3}));}/*** 获取数组数据** @param arr* @return*/public static String getArrayData(int[] arr) {//判断数组对象是否为nullif (arr == null) {return null;} else {StringBuilder sb = new StringBuilder();sb.append("[");for (int i = 0; i < arr.length; i++) {if (i == arr.length - 1) {sb.append(arr[i]);} else {sb.append(arr[i]).append(",");}}sb.append("]");return sb.toString();}}
}

2.3 API-StringJoiner

JDK8开始才有的，跟StringBuilder一样，也是用来操作字符串的，也可以看成是一个容器，创建之后里面的内容是可变的。
好处：不仅能提高字符串的操作效率，并且在有些场景下使用它操作字符串，代码会更简洁。

package com.itheima.stringJoiner;import java.util.StringJoiner;public class Demo1 {public static void main(String[] args) {//                                       间隔符    前缀         后缀StringJoiner sj = new StringJoiner(",", "[", "]");sj.add("孙克旭");sj.add("老男孩").add("图灵机");System.out.println(sj); //[孙克旭,老男孩,图灵机]System.out.println("---------------------");System.out.println(getArrayData(new int[]{10, 20, 30})); //[10,20,30]}/*** 获取数组数据** @param arr* @return*/public static String getArrayData(int[] arr) {//判断数组对象是否为nullif (arr == null) {return null;} else {StringJoiner sj = new StringJoiner(",", "[", "]");for (int i = 0; i < arr.length; i++) {sj.add(String.valueOf(arr[i]));}return sj.toString();}}
}

2.4 API-Math、System

2.4.1 Math

代表数学，是一个工具类，里面提供的都是对数据进行操作的一些静态方法。

package com.itheima.math;public class Demo1 {public static void main(String[] args) {//1.取绝对值System.out.println(Math.abs(0)); //0System.out.println(Math.abs(10)); //10System.out.println(Math.abs(-10)); //10//2.向上取整System.out.println(Math.ceil(2)); //2.0System.out.println(Math.ceil(2.0001));  //3.0//3.向下取整System.out.println(Math.floor(2));  //2.0System.out.println(Math.floor(2.999999));   //2.0//4.四舍五入System.out.println(Math.round(2.4999)); //2System.out.println(Math.round(2.55));   //3//5.取较大值、较小值System.out.println(Math.max(10, 20));   //20System.out.println(Math.min(10, 20));   //10//6.取次方System.out.println(Math.pow(2, 3)); //2的3次方：8.0System.out.println(Math.pow(3, 2)); //3的2次方：9.0//7.取随机数 [0.0,1.0) 包前不包后System.out.println(Math.random());}
}

2.4.2 System

System代表程序所在的系统，也是一个工具类。

package com.itheima.math;public class SystemTest {public static void main(String[] args) {//1.终止JVM
//        System.exit(0);//2.获取系统的时间：从1970 1-1 00:00:00到现在的毫秒值long time = System.currentTimeMillis();System.out.println(time);}
}

2.5 API-Runtime

Runtime是一个单例类,代表程序所在的运行环境。

package com.itheima.math;import java.io.IOException;public class RuntimeTest {public static void main(String[] args) throws IOException, InterruptedException {//1.获取runtime对象Runtime runtime = Runtime.getRuntime();//2.终止JVM;systems.exit()和这个方法一样
//        runtime.exit(0);//3.获取JVM能够使用的处理器数量System.out.println(runtime.availableProcessors());  //8//4.获取JVM总内存，单位是字节System.out.println(runtime.totalMemory() / 1024.0 / 1024.0 + "MB");//5.获取JVM的可用内容System.out.println(runtime.freeMemory() / 1024.0 / 1024.0 + "MB");//6.启动其他程序Process process = runtime.exec("E:\\Program\\BaiduNetdisk\\BaiduNetdisk.exe");Thread.sleep(5000);//7.销毁程序process.destroy();}
}

2.6 API-BigDecimal讲解

用于解决浮点型运算时，出现结果失真的问题。

package com.itheima.bigDecimal;import java.math.BigDecimal;
import java.math.RoundingMode;public class Demo1 {public static void main(String[] args) {double a = 0.1, b = 0.2, c = 0.3;//这样得到的BigDecimal对象不能进行精确的浮点数运算，不推荐使用BigDecimal b1 = new BigDecimal(a);//可以的构造器，但是官方不推荐BigDecimal a1 = new BigDecimal(Double.toString(a));//1.官方推荐使用的构造器;底层原理和上面一样，都是传递字符串类型的参数BigDecimal bigDecimal1 = BigDecimal.valueOf(a);BigDecimal bigDecimal2 = BigDecimal.valueOf(b);BigDecimal bigDecimal3 = BigDecimal.valueOf(c);//2.加法System.out.println(bigDecimal1.add(bigDecimal2)); //0.3//3.减法System.out.println(bigDecimal1.subtract(bigDecimal2)); //-0.1//4.乘法System.out.println(bigDecimal1.multiply(bigDecimal2)); //0.02//5.除法System.out.println(bigDecimal1.divide(bigDecimal2)); //0.5
//        System.out.println(bigDecimal1.divide(bigDecimal3)); //程序报错，因为big decimal只能做精确运算//6.除法，保留两位小数，使用四舍五入模式System.out.println(bigDecimal1.divide(bigDecimal3, 2, RoundingMode.HALF_UP)); //0.33//7.将BigDecimal对象转变成double对象double d = bigDecimal1.doubleValue();System.out.println(d); //0.1}
}

2.7 单元练习9

2.7.1 StringBuilder类和String类有什么区别？

StringBuilder类和String类都用于存储字符串，但是它们的区别在于String类是不可变的，
也就是说，一旦String对象被创建，它的值就不能被修改，如果需要修改它的值，就需要重新创建一个新的String对象；
而StringBuilder类是可变的，它允许对字符串进行修改，而不需要创建新的对象，因此在需要频繁修改字符串的情况下，
使用StringBuilder会更加高效。

2.7.2 StringJoiner类是用来做什么的？

StringJoiner类是Java 8新增的一个类，用于连接多个字符串。它提供了add()方法用于添加字符串，
还提供了setDelimiter()方法用于设置分隔符，setPrefix()方法用于设置前缀，setSuffix()方法用于设置后缀。
使用StringJoiner可以方便地将多个字符串连接成一个字符串，例如用于生成CSV文件。

2.7.3 BigDecimal类和double类型有什么区别？

BigDecimal类和double类型都可以用于表示浮点数，但是它们的区别在于精度和运算方式。double类型是基本数据类型，
它的精度有限，只能保留15-16位有效数字，并且在进行浮点数计算时会存在精度损失的问题，
而BigDecimal类可以表示任意精度的十进制数，它的精度不受限制，并且在进行浮点数计算时可以保证精度不会丢失。
因此在需要精确计算货币、税收等场景下，应该使用BigDecimal类来代替double类型。

2.7.4 编码题1

请使用StringBuilder类、StringJoiner类、Math类、BigDecimal类中的常用方法实现以下功能：
①输入两个数，分别用BigDecimal表示
②计算它们的乘积并对结果进行四舍五入
③最后用StringBuilder将结果输出为如下格式的字符串：“数字1与数字2的乘积为XXX”
其中，数字1、数字2和XXX分别为对应的数值。

提示：使用Math中的round方法对结果进行四舍五入，使用BigDecimal的multiply方法计算乘积，使用StringBuilder的append方法进行字符串拼接。

---

package com.itheima.work;import java.math.BigDecimal;/*** @ClassName Test1* @Description 编码题* @Author 孙克旭* @Date 2025/3/20 10:05*/
public class Test1 {public static void main(String[] args) {
//        ①输入两个数，分别用BigDecimal表示BigDecimal b1 = BigDecimal.valueOf(2.5);BigDecimal b2 = BigDecimal.valueOf(3.4);
//②计算它们的乘积并对结果进行四舍五入double v = b1.multiply(b2).doubleValue();System.out.println(Math.round(v));
//③最后用StringBuilder将结果输出为如下格式的字符串："数字1与数字2的乘积为XXX"
//        其中，数字1、数字2和XXX分别为对应的数值。StringBuilder sb = new StringBuilder();System.out.println(sb.append(b1).append("与").append(b2).append("的乘积为").append(v));}
}

2.7.5 编码题2

实现一个掷骰子的小游戏，记录六次投掷的结果，并计算6次结果的平均值，使用ArrayList，存储多个整数。
①使用Math中的random方法生成6个在1~6之间的随机整数，将它们添加到ArrayList中。
②使用BigDecimal类中的divide方法计算这些整数的平均值。
③将结果四舍五入到小数点后两位。
④最后使用StringBuilder将结果输出为如下格式的字符串：“生成的随机数为X,X,X，平均值为YYY”
其中，X,X,X为生成的随机数列表，YYY为计算出的平均值。

提示：使用StringBuilder的append方法进行字符串拼接，使用StringJoiner将随机数列表转化为字符串，使用BigDecimal的setScale方法设置小数点位数，使用BigDecimal的divide方法获取平均值。（方法的具体使用自行查看api文档）

---

package com.itheima.work;import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;/*** @ClassName Test2* @Description 编码题* @Author 孙克旭* @Date 2025/3/20 10:12*/
public class Test2 {public static void main(String[] args) {ArrayList<Double> list = new ArrayList<>();for (int i = 0; i < 6; i++) {list.add(Math.floor(Math.random() * 6 + 1));}BigDecimal sum = new BigDecimal(0);for (int i = 0; i < list.size(); i++) {sum = sum.add(BigDecimal.valueOf(list.get(i)));}BigDecimal avg = sum.divide(BigDecimal.valueOf(list.size()), 2, RoundingMode.HALF_UP);StringBuilder sb = new StringBuilder();sb.append("生成的随机数为：");for (int i = 0; i < list.size(); i++) {if (i == list.size() - 1) {sb.append(Math.round(list.get(i)));} else {sb.append(Math.round(list.get(i)) + "、");}}sb.append(",平均值为：").append(avg);System.out.println(sb);}
}

2.7.6 编码题3

设计一个小程序，根据用户输入的身高体重，计算出BMI指数，并根据BMI指数输出相应的健康建议。最后使用StringBuilder将结果输出为如下格式的字符串：

“您的身高为XXX m，体重为XXX kg，BMI指数为XXX，健康建议为XXX。”

其中，XXX为对应的数值和文字描述。

提示：使用BigDecimal的divide方法计算BMI指数，使用compareTo方法进行BMI指数比较，BMI指数保留1位小数及四舍五入，使用StringBuilder的append方法进行字符串拼接，根据BMI指数输出相应的信息。并给出测试代码

---

package com.itheima.work;import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Scanner;/*** @ClassName Test3* @Description 编码题* @Author 孙克旭* @Date 2025/3/20 10:33*/
public class Test3 {public static void main(String[] args) {BMI();}public static void BMI() {Scanner scanner = new Scanner(System.in);System.out.println("请输入您的身高(m)：");BigDecimal height = BigDecimal.valueOf(scanner.nextDouble());System.out.println("请输入您的体重(kg)：");BigDecimal weight = BigDecimal.valueOf(scanner.nextDouble());//计算BMI指数double BMI = weight.divide(BigDecimal.valueOf(Math.pow(height.doubleValue(), 2)), 1, RoundingMode.HALF_UP).doubleValue();//判断体型，并给出建议String suggestion = compareTo(BMI);StringBuilder sb = new StringBuilder();
//        您的身高为XXX m，体重为XXX kg，BMI指数为XXX，健康建议为XXX。sb.append("您的身高为").append(height + "m,体重为").append(weight + "kg,BMI指数为").append(BMI + ",健康建议为" + suggestion);System.out.println(sb);}private static String compareTo(double bmi) {String sug = "";if (bmi < 18.5) {sug = "偏瘦---多吃";} else if (bmi <= 23.9) {sug = "正常---保持现状";} else if (bmi <= 27.9) {sug = "过重---少吃零食多睡觉";} else {sug = "肥胖---别吃了";}return sug;}}

3. 时间日期类

3.1 传统时间：Date日期类

Date代表日期和时间。

package com.itheima.time.date;import java.util.Date;public class Demo1 {public static void main(String[] args) {Date date = new Date();System.out.println(date); //Thu Mar 20 11:40:46 CST 2025//获取时间戳long time = date.getTime();//把时间戳转换成日期对象：查看2秒后的时间Date date1 = new Date(time + 2 * 1000);System.out.println(date1); //Thu Mar 20 11:40:48 CST 2025//修改日期对象的时间date1.setTime(time);System.out.println(date1);}
}

3.2 传统时间：SimpleDateFormat

代表简单日期格式化，可以用来把日期对象、时间毫秒值格式化成我们想要的形式。

package com.itheima.time.date;import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;public class SimpleDateFormatDemo1 {public static void main(String[] args) throws ParseException {Date date = new Date();//1.创建格式化日期对象SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE");//2.将日期格式化String s = format.format(date);String s1 = format.format(System.currentTimeMillis()); //可以接收时间戳System.out.println(s);System.out.println(s1);//3.将日期字符串解析成日期格式,模板格式必须和日期字符串格式相同String dateStr = "2020-09-10 15:12:10";SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date parse = format1.parse(dateStr);System.out.println(parse); //Thu Sep 10 15:12:10 CST 2020}
}

3.3 传统时间：秒杀案例

package com.itheima.time.date;import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;/*** @ClassName Demo2* @Description 日期案例* @Author 孙克旭* @Date 2025/3/20 13:34*/
public class Demo2 {public static void main(String[] args) throws ParseException {String start = "2023年11月11日 0:0:0";String end = "2023年11月11日 0:10:0";String xj = "2023年11月11日 0:01:18";String xp = "2023年11月11日 0:10:51";//1.将日期字符串解析成日期对象SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");Date startDate = sdf.parse(start);Date endDate = sdf.parse(end);Date xjDate = sdf.parse(xj);Date xpDate = sdf.parse(xp);//2.根据日期对象获取时间戳long startTime = startDate.getTime();long endTime = endDate.getTime();long xjTime = xjDate.getTime();long xpTime = xpDate.getTime();//3.判断System.out.println("小贾" + isSuccess(startTime, endTime, xjTime));System.out.println("小皮" + isSuccess(startTime, endTime, xpTime));}private static String isSuccess(long startTime, long endTime, long time) {if (time >= startTime && time <= endTime) {return "秒杀成功";} else {return "秒杀失败";}}
}

3.4 传统时间：Calendar

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

package com.itheima.time.date;import java.util.Calendar;
import java.util.Date;public class CalenderDemo {public static void main(String[] args) {//1.获取日历对象Calendar calendar = Calendar.getInstance();System.out.println(calendar);//2.获取日历中的某个字段System.out.println(calendar.get(Calendar.YEAR)); //年System.out.println(calendar.get(Calendar.DAY_OF_YEAR)); //一年中的第几天System.out.println(calendar.get(Calendar.DAY_OF_MONTH)); //几号//3.获取日期对象Date time = calendar.getTime();System.out.println(time);//4.获取时间戳long timeInMillis = calendar.getTimeInMillis();System.out.println(timeInMillis);//5.修改日历中的某个信息calendar.set(Calendar.MONTH, 6); //将月份改为6月System.out.println(calendar.get(Calendar.MONTH));//6.为日历中的某个信息增加或减少calendar.add(Calendar.DAY_OF_YEAR, 10); //10天之后System.out.println(calendar);calendar.add(Calendar.DAY_OF_YEAR, -10); //10天之前System.out.println(calendar);}
}

3.5 为啥要学习JDK8新增的时间

3.6 课后练习

3.6.1 请用代码实现:获取当前的日期,并把这个日期转换为指定格式的字符串,如2088-08-08 08:08:08。

package com.itheima.work;import java.text.SimpleDateFormat;
import java.util.Date;public class Test4 {public static void main(String[] args) {Date date = new Date();SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");System.out.println(sdf.format(date)); //2025-03-20 19:48:56}
}

3.6.2 使用SimpleDateFormat类,把2018-03-04转换为2018年03月04日。

package com.itheima.work;import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;public class Test4 {public static void main(String[] args) throws ParseException {String date = "2018-03-04";SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日");Date parse = sdf.parse(date);System.out.println(sdf2.format(parse)); //2018年03月04日}
}

3.6.3 题目3

请编写程序，获取当前系统日期，并将结果打印到控制台，要求展示格式为：xxxx年xx月xx日
运行结果：
2088年2月15日

【训练目标】：
能够使用SimpleDateFormat格式化日期对象
【思路分析】：
使用SimpleDateFormat，将当前日期对象，转换为xxxx年xx月xx日模式的字符串，注意模式的格式
【参考步骤】：
1、使用空参构造，创建Date对象，该对象即表示当前系统日期
2、创建SimpleDateFormat对象，在构造方法内部传入格式：yyyy年MM月dd日
3、调用format方法，将日期格式化为指定字符串
4、输出结果

---

package com.itheima.work;import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;public class Test4 {public static void main(String[] args) throws ParseException {Date date = new Date();SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日");System.out.println(sdf2.format(date)); //2025年03月20日}
}

3.6.4 题目4

某共公司产品经理要求App需要有3款主题样式，用户选择不同的主题，展示时间的格式也要有不同的风格，请编写代码实现该功能。
运行结果：
请选择主题：1.xxxx年xx月xx日，2.xxxx-xx-xx，3.xxxx/xx/xx
1
主题切换成功,当前时间为：2018年12月10日

请选择主题：1.xxxx年xx月xx日，2.xxxx-xx-xx，3.xxxx/xx/xx
4
很抱歉，操作有误，已为您切换默认主题
主题切换成功,当前时间为：2018年12月10日

【训练目标】：
能够熟练运用SimpleDateformat控制日期格式
【思路分析】：

1. 主题编号需要输入，用什么技术解决？
2. 使用switch控制输入编号对应的逻辑代码
3. 在case块中，当前的时间如何获取，应该获取的是毫秒值还是对象？
4. 获取到的时间对象该怎样转换为指定格式的字符串？
5. 转换的代码的时候重复度过高，唯一变化的也就只有模式，如何优化？

【参考步骤】：

1. 创建Scanner对象，调用nextInt方法获取主题编号
2. 使用switch语句区管理代码逻辑，分别在case1 case2 case3来编辑切换主题格式的代码逻辑，并给出default提高程序的安全性
3. 创建Date类的空参构造，就是当前时间的对象表示形式，对象的形式便于稍后格式的转换
4. 创建SimpleDateFormat对象，传入转换模式，并调用其fotmat方法完成格式转换
5. 将转换代码的逻辑抽取到一个方法，模式作为字符串参数，随后在各个case块中调用该方法

---

package com.itheima.work;import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;public class Test4 {public static void main(String[] args) throws ParseException {switchTheme();}public static void switchTheme() {Scanner scanner = new Scanner(System.in);Date date = new Date();SimpleDateFormat sdf;String s = "主题切换成功，当前时间为：";System.out.println("请选择主题：");System.out.println("1.xxxx年xx月xx日,2.xxxx-xx-xx,3.xxxx/xx/xx");int i = scanner.nextInt();switch (i) {case 2:sdf = new SimpleDateFormat("yyyy-MM-dd");System.out.println(s + sdf.format(date));break;case 3:sdf = new SimpleDateFormat("yyyy/MM/dd");System.out.println(s + sdf.format(date));break;default:System.out.println("很抱歉，操作有误，已为您切换至默认主题。");case 1:sdf = new SimpleDateFormat("yyyy年MM月dd日");System.out.println(s + sdf.format(date));break;}}
}

3.7 单元练习10

3.7.1 Date类的作用是什么？它的构造函数和常用方法有哪些？

Date类是Java中表示日期和时间的类之一，它提供了以毫秒为单位的时间和日期的精确表示方式。
构造函数：
1.Date()：创建一个表示当前时间的Date对象
2.Date(long date)：使用从1970年1月1日00:00:00 GMT起的指定毫秒数创建一个Date对象
3.Date(String s)：使用指定的字符串创建一个Date对象，该字符串必须是可解析的日期字符串
常用方法：
1.getTime()：返回表示此Date对象的日期和时间的毫秒数。
2.setTime(long time)：设置此Date对象的日期和时间，参数为从1970年1月1日00:00:00 GMT起的指定毫秒数。

3.7.2 SimpleDateFormat类的作用是什么？它的构造函数和常用方法有哪些？常用格式有哪些？

SimpleDateFormat类是Java中用于格式化日期和时间的类，它可以将Date对象转换为指定格式的日期字符串，也可以将日期字符串解析为Date对象。
构造函数：
1 .SimpleDateFormat()：创建一个默认的SimpleDateFormat对象，使用默认的日期和时间格式。
2 .SimpleDateFormat(String pattern)：使用指定的日期和时间格式创建一个SimpleDateFormat对象。其中，pattern是一个字符串，用于指定日期和时间格式。
常用方法：format(Date date)：将日期格式化成日期/时间字符串
format(Object time) ：将时间毫秒值式化成日期/时间字符串
parse(String source)：将指定的日期字符串解析为Date对象。
常用格式："yyyy-MM-dd"：表示年-月-日格式的日期字符串，例如"2023-05-06"
"yyyy-MM-dd HH:mm:ss"：表示年-月-日 时:分:秒格式的日期字符串，例如"2023-05-06 10:30:00"
需要注意的是，SimpleDateFormat是非线程安全的，因此在多线程环境下使用时需要进行同步处理或使用ThreadLocal进行线程间隔离。

3.7.3 编码题1

编写一个程序，实现日期、时间的格式化功能
①使用Date类和Calendar类输出当前日期格式为"yyyy-MM-dd HH:mm:ss"。
②计算在当前日期的基础上加上10天后的日期，格式为"yyyy-MM-dd HH:mm:ss"。

---

package com.itheima.work;import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;public class Test5 {public static void main(String[] args) {Date date = new Date();SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");System.out.println(sdf.format(date)); //2025-03-20 20:17:37Calendar calendar = Calendar.getInstance();StringBuilder sb = new StringBuilder();sb.append(calendar.get(Calendar.YEAR) + "-").append(calendar.get(Calendar.MONTH) + "-").append(calendar.get(Calendar.DAY_OF_MONTH) + " ").append(calendar.get(Calendar.HOUR) + ":").append(calendar.get(Calendar.MINUTE) + ":").append(calendar.get(Calendar.SECOND));System.out.println(sb); //2025-2-20 8:23:12calendar.add(Calendar.DAY_OF_YEAR, 10);Date time = calendar.getTime();System.out.println(sdf.format(time)); //2025-03-30 20:25:02}
}

3.7.4 编码题2

公司周日周一要求必须有两个人值班，现在要进行排班，编写一个程序，实现一个星期计算器，计算出某个日期的周日和周一是哪一天。
①要求使用Calendar类和SimpleDateFormat类
②根据用户输入的日期字符串，计算出该日期所在周的周一和周日的日期
③并输出格式为"yyyy-MM-dd"的日期字符串。
提示：java里面星期日是一周的开始

---

package com.itheima.work;import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;public class Test6 {public static void main(String[] args) throws ParseException {findSunAndMonday("2025-03-20");
/*        sunday:2025-03-16monday:2025-03-17*/}public static void findSunAndMonday(String date) throws ParseException {SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");Calendar calendar = Calendar.getInstance();calendar.setTime(sdf.parse(date));Calendar c1 = calendar;calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);Date sunday = calendar.getTime();System.out.println("sunday:" + sdf.format(sunday));c1.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);Date monday = c1.getTime();System.out.println("monday:" + sdf.format(monday));}
}

4. JDK8新时间

4.1 JDK8新时间:LocalDate、LocalTime、LocalDateTime

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

LocalDateDemo:

package com.itheima.time.date;import java.time.LocalDate;public class LocalDateDemo {public static void main(String[] args) {//1.获取日期对象(不可变对象)LocalDate ld = LocalDate.now();System.out.println(ld); //年月日//2.获取信息System.out.println(ld.getYear()); //年System.out.println(ld.getMonth().getValue()); //月System.out.println(ld.getDayOfMonth()); //日System.out.println(ld.getDayOfWeek().getValue()); //周几//3.修改信息LocalDate ld2 = ld.withYear(2026);System.out.println(ld2); //2026-03-21LocalDate ld3 = ld.withMonth(5);System.out.println(ld3); //2025-05-21//4.将某个信息增加或减少LocalDate ld4 = ld.plusDays(12);System.out.println(ld4); //2025-04-02LocalDate ld5 = ld.minusMonths(1);System.out.println(ld5); //2025-02-21//5.获取指定日期的LocalDate对象LocalDate ld6 = LocalDate.of(2026, 5, 10);System.out.println(ld6); //2026-05-10//6.判断日期对象是否相同，哪个在前，哪个在后System.out.println(ld.equals(ld6)); //falseSystem.out.println(ld.isBefore(ld6)); //trueSystem.out.println(ld.isAfter(ld6)); //false}
}

LocalTime、LocalDateTime与LocalDate用法基本相同。

package com.itheima.time.date;import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;public class LocalDateTimeDemo {public static void main(String[] args) {LocalDateTime ldt = LocalDateTime.now();System.out.println(ldt); //2025-03-21T15:05:55.576//LocalDate、LocalTime与LocalDateTime相互转换LocalDate ld = ldt.toLocalDate();System.out.println(ld);LocalTime lt = ldt.toLocalTime();System.out.println(lt);LocalDateTime ldt2 = LocalDateTime.of(ld, lt);System.out.println(ldt2);}
}

4.2 JDK8新时间：ZoneId、ZonedDateTime

package com.itheima.time.date;import java.time.Clock;
import java.time.ZoneId;
import java.time.ZonedDateTime;public class ZoneDemo {public static void main(String[] args) {//1.获取系统默认时区ZoneId zoneId = ZoneId.systemDefault();System.out.println(zoneId.getId()); //Asia/Shanghai//2.获取java支持的全部时区idSystem.out.println(ZoneId.getAvailableZoneIds());//3.把某个时区Id封装成ZoneId对象ZoneId id1 = ZoneId.of("Asia/Shanghai");System.out.println(id1);//4.获取某个时区的当前时间ZonedDateTime now = ZonedDateTime.now(id1);System.out.println(now); //2025-03-22T09:42:18.357+08:00[Asia/Shanghai]//5.获取世界标准时间ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());System.out.println(now1); //2025-03-22T01:45:29.733Z//6.获取系统默认时区时间ZonedDateTime now2 = ZonedDateTime.now();System.out.println(now2); //2025-03-22T09:49:02.412+08:00[Asia/Shanghai]}
}

4.3 JDK8新时间：Instant

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

package com.itheima.time.date;import java.time.Instant;public class InstantDemo {public static void main(String[] args) {//1.获取当前的时间信息Instant now = Instant.now();System.out.println(now); //2025-03-22T01:57:36.572Z//2.获取总秒数long epochSecond = now.getEpochSecond();System.out.println(epochSecond); //1742608723//3.获取不够1秒的纳秒数int nano = now.getNano();System.out.println(nano); //265000000//4.增加或减少时间Instant instant = now.plusNanos(100);Instant instant1 = instant.minusNanos(10000);System.out.println(instant1); //2025-03-22T05:36:59.773990100Z}
}

4.4 JDK8新时间：DateTimeFormatter

package com.itheima.time.date;import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;public class DateTimeFormatterDemo {public static void main(String[] args) {//1.创建日期格式化对象DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");LocalDateTime ldt = LocalDateTime.now();System.out.println(ldt); //2025-03-22T13:57:50.104//2.对日期对象格式化（正向格式化）System.out.println(formatter.format(ldt)); //2025-03-22 13:57:50//3.反向格式化System.out.println(ldt.format(formatter)); //2025-03-22 14:01:32//4.解析日期String dateStr = "2025-06-12 14:12:22";LocalDateTime ldt2 = LocalDateTime.parse(dateStr, formatter);System.out.println(ldt2); //2025-06-12T14:12:22}
}

4.5 JDK8新时间：Period、Duration

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

package com.itheima.time.date;import java.time.LocalDate;
import java.time.Period;public class PeriodDemo {public static void main(String[] args) {LocalDate start = LocalDate.of(2025, 3, 22);LocalDate end = LocalDate.of(2025, 6, 30);//1.创建Period对象Period period = Period.between(start, end);//2.获取两个日期间隔的时间System.out.println(period.getYears());System.out.println(period.getMonths());System.out.println(period.getDays());}
}

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

package com.itheima.time.date;import java.time.Duration;
import java.time.LocalDateTime;public class DurationDemo {public static void main(String[] args) {LocalDateTime start = LocalDateTime.now();LocalDateTime end = LocalDateTime.of(2025, 6, 30, 12, 0, 0);//1.创建Duration对象Duration duration = Duration.between(start, end);//2.计算间隔时间System.out.println(duration.toDays());System.out.println(duration.toHours());System.out.println(duration.toMinutes());System.out.println(duration.toMillis()); //毫秒System.out.println(duration.toNanos()); //纳秒}
}

4.6 单元练习11

4.6.1 请简要介绍一下Java 8中新增的日期时间API。

Java 8中新增了一组全新的日期时间API，
其中包括 LocalDate、LocalTime、LocalDateTime、ZoneId、ZonedDateTime、Instant等类。
相较于旧有的Date、Calendar等类，新增的API提供了更为简洁易用的日期时间处理方式，同时也避免了一些旧有API中的常见问题，
如线程安全性、可变性等。

4.6.2 什么是ZoneId类和ZoneDateTime类？它的常用方法有哪些？

ZoneId是Java 8中用于表示时区信息的类，它包含了时区的标识符、名称、偏移量等信息。
ZoneId类的常用方法包括of()、getAvailableZoneIds()。
其中，of()方法用于获取指定时区标识符的ZoneId实例，getAvailableZoneIds()方法返回所有可用的时区标识符ZonedDateTime是Java 8中引入的一个类，它是一个带有时区的日期和时间类。它包含了日期、时间和时区信息，可以表示世界上任何一个时区中的时间。
常用方法如下：
now()：返回当前时区的日期时间。
now(ZoneId zone)：返回指定时区的日期时间。

4.6.3 DateTimeFormatter是什么？它提供了哪些常用的格式化/解析方法？

DateTimeFormatter是Java 8中新引入的一个日期时间格式化工具类，用于将日期时间对象格式化为指定的字符串，或将指定的字符串解析为日期时间对象。
常用方法：
DateTimeFormatter ofPattern(时间格式)：获取格式化器对象
String format(时间对象)：格式化时间
String format(DateTimeFormatter formatter)：格式化时间
LocalDateTime parse(CharSequence text ,DateTimeFormatter formatter):解析时间

4.6.4 编码题1

编写一个Java程序，使用LocalDate、LocalTime、LocalDateTime、ZoneId、ZonedDateTime和Instant类完成以下操作：

①获取当前日期和时间，并输出当前日期，当前时间，当前日期和时间；
②获取当前时区，并打印输出；
③获取指定时区的指定时间（例如纽约时区），并打印输出；
④将当前日期时间转换成指定时区（例如纽约时区）的日期时间，并打印输出；
⑤获取当前时间戳，并打印输出；
⑥将当前时间戳转换成指定日期时间和时区（例如上海时区）的日期时间，并打印输出。

---

package com.itheima.time.dateWork;import java.time.*;/*** @ClassName Test1* @Description 编码题* @Author 孙克旭* @Date 2025/3/22 14:55*/
public class Test1 {public static void main(String[] args) {
//        ①获取当前日期和时间，并输出当前日期，当前时间，当前日期和时间；LocalDate ld = LocalDate.now();LocalTime lt = LocalTime.now();LocalDateTime ldt = LocalDateTime.now();System.out.println(ld); //2025-03-22System.out.println(lt); //14:57:51.661System.out.println(ldt); //2025-03-22T14:57:51.661
//②获取当前时区，并打印输出；ZoneId zoneId = ZoneId.systemDefault();System.out.println(zoneId.getId()); //Asia/Shanghai
//③获取指定时区的指定时间（例如纽约时区），并打印输出；
//        System.out.println(ZoneId.getAvailableZoneIds());ZoneId id = ZoneId.of("America/New_York");System.out.println(ZonedDateTime.now(id)); //2025-03-22T03:01:59.469-04:00[America/New_York]
//④将当前日期时间转换成指定时区（例如纽约时区）的日期时间，并打印输出；ZonedDateTime zonedDateTime = ldt.atZone(zoneId);ZonedDateTime zonedDateTime1 = zonedDateTime.withZoneSameInstant(id);System.out.println(zonedDateTime1); //2025-03-22T03:06:11.535-04:00[America/New_York]
//⑤获取当前时间戳，并打印输出；Instant now = Instant.now();System.out.println(now); //2025-03-22T07:08:02.383Z
//⑥将当前时间戳转换成指定日期时间和时区（例如上海时区）的日期时间，并打印输出。ZonedDateTime zonedDateTime2 = now.atZone(zoneId);System.out.println(zonedDateTime2); //2025-03-22T15:09:10.803+08:00[Asia/Shanghai]}
}

4.6.5 编码题2

编写一个程序，该程序应用于需要展示多个时区时间，要求使用LocalDateTime类和ZoneId类实现一个能显示多时区的电子时钟，要求如下：

①获取当前时区日期时间
②将当前日期时间转换成纽约时区的日期时间
③将当前日期时间转换成东京时区的日期时间
④显示当前日期时间和纽约时区的日期时间之间的时间差（以小时为单位）
⑤显示当前日期时间和东京时区的日期时间之间的时间差（以小时为单位）
要求输出以上操作的结果。

提示：可以使用Duration类来计算时间差。

---

package com.itheima.time.dateWork;import java.time.Duration;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;/*** @ClassName Test2* @Description 编码题* @Author 孙克旭* @Date 2025/3/22 15:11*/
public class Test2 {public static void main(String[] args) {// ①获取当前时区日期时间LocalDateTime localDateTime = LocalDateTime.now();System.out.println("当前时区日期时间：" + localDateTime);System.out.println("*************************");// 将当前日期时间转换成纽约时区的日期时间ZoneId zoneId = ZoneId.systemDefault();System.out.println(zoneId);// 构建当前时区的ZonedDateTime对象ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, zoneId);// 转换成纽约时区的日期时间ZonedDateTime NYTime = zonedDateTime.withZoneSameInstant(ZoneId.of("America/New_York"));System.out.println("纽约时区日期时间：" + NYTime);System.out.println("*************************");// 将当前日期时间转换成东京时区的日期时间ZonedDateTime TKTime = zonedDateTime.withZoneSameInstant(ZoneId.of("Asia/Tokyo"));System.out.println("东京市区日期时间：" + TKTime);System.out.println("*************************");// 显示当前日期时间和纽约时区的日期时间之间的时间差（以小时为单位）Duration d1 = Duration.between(zonedDateTime, zonedDateTime.withZoneSameLocal(ZoneId.of("America/New_York")));long h1 = d1.toHours();System.out.println("当前日期时间和纽约时区的日期时间之间的时间差为：" + h1 + "小时");System.out.println("*************************");// 显示当前日期时间和东京时区的日期时间之间的时间差（以小时为单位）Duration d2 = Duration.between(zonedDateTime, zonedDateTime.withZoneSameLocal(ZoneId.of("Asia/Tokyo")));long h2 = d2.toHours();System.out.println("当前日期时间和东京时区的日期时间之间的时间差为：" + h2 + "小时");}
}

4.6.6 编码题3

编写一个程序计算机票到达的目的地的当地时间
1.输入出发日期和时间、目的地时区、旅行时间（小时数）
2.计算并格式化输出到达目的地的当地日期和时间，时间格式为：yyyy-MM-dd HH:mm:ss
代码实现可以使用DateTimeFormatter类、ZoneId类、ZonedDateTime类的相关方法。

---

package com.itheima.time.dateWork;import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Scanner;/*** @ClassName Test3* @Description 编码题* @Author 孙克旭* @Date 2025/3/22 15:42*/
public class Test3 {public static void main(String[] args) {// 1, 获取用户输入的出发日期和时间Scanner scanner = new Scanner(System.in);System.out.println("请输入当前时区出发日期和时间，格式为 yyyy-MM-dd HH:mm:ss");String startStr = scanner.nextLine();// 获取用户输入的旅行时间(单位小时)System.out.println("请输入旅行时间（小时数）：");String travelHours = scanner.nextLine();// 获取用户输入的目的地时区System.out.println("请输入目的地时区（例如 America/New_York）：");String targetZoneId = scanner.nextLine();//2,根据目的 出发时间，旅行时长，目的地时区，计算目的地时间，格式化输出 yyyy-MM-dd HH:mm:ssDateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");ZonedDateTime startTime = ZonedDateTime.of(LocalDateTime.parse(startStr, dtf), ZoneId.systemDefault());ZonedDateTime endTime = startTime.withZoneSameInstant(ZoneId.of(targetZoneId)).plusHours(Long.parseLong(travelHours));System.out.println("到达目的地的时间为:"+dtf.format(endTime));}
}

5. Arrays类

5.1 Arrays类：基本使用

Arrays是用来操作数组的一个工具类。

package com.itheima.arrays;import java.util.Arrays;
import java.util.function.IntToDoubleFunction;public class Demo1 {public static void main(String[] args) {int[] arr = {10, 20, 30, 40, 50};//1.返回数组内容System.out.println(Arrays.toString(arr)); //[10, 20, 30, 40, 50]//2.拷贝数组int[] arr2 = Arrays.copyOfRange(arr, 1, 4); //包前不包后System.out.println(Arrays.toString(arr2)); //[20, 30, 40]//3.拷贝数组，指定新数组长度int[] arr3 = Arrays.copyOf(arr, 10);System.out.println(Arrays.toString(arr3)); //[10, 20, 30, 40, 50, 0, 0, 0, 0, 0]//4.将原数据改为新数据并存入原数组double[] prices = {10, 20, 30, 40, 50}; //将价格打八折Arrays.setAll(prices, new IntToDoubleFunction() {@Overridepublic double applyAsDouble(int value) { //value表示数组下标return prices[value] * 0.8;}});System.out.println(Arrays.toString(prices)); //[8.0, 16.0, 24.0, 32.0, 40.0]//5.排序，默认是升序排序int[] arr4 = {14, 20, 2, 13, 24};Arrays.sort(arr4);System.out.println(Arrays.toString(arr4)); //[2, 13, 14, 20, 24]}
}

5.2 Arrays类：自定义排序规则的方式一

学生类：

package com.itheima.arrays;public class Student implements Comparable<Student> {private String name;private double height;private int age;@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", height=" + height +", age=" + age +'}';}public Student() {}public Student(String name, double height, int age) {this.name = name;this.height = height;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getHeight() {return height;}public void setHeight(double height) {this.height = height;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}/*** 定义对象比较规则* 比较对象：this o* 按照年龄升序排序** @param o* @return*/@Overridepublic int compareTo(Student o) {/* if (this.age > o.age) {return 1;} else if (this.age < o.age) {return -1;}*/
//        return this.age - o.age; //升序return o.age - this.age; //降序}
}

测试类：

package com.itheima.arrays;import java.util.Arrays;public class SortDemo1 {public static void main(String[] args) {Student[] students = new Student[5];students[0] = new Student("孙克旭", 172, 25);students[1] = new Student("老男孩", 168, 45);students[2] = new Student("马林思维", 175, 34);students[3] = new Student("刘风凌", 162, 36);students[4] = new Student("图灵机", 170, 32);Arrays.sort(students);System.out.println(Arrays.toString(students));/*      [Student{name='老男孩', height=168.0, age=45}, Student{name='刘风凌', height=162.0, age=36},Student{name='马林思维', height=175.0, age=34}, Student{name='图灵机', height=170.0, age=32}, Student{name='孙克旭', height=172.0, age=25}]*/}
}

5.3 Arrays类：自定义排序规则的方式二

        Arrays.sort(students, new Comparator<Student>() { //按身高升序排序@Overridepublic int compare(Student o1, Student o2) {return Double.compare(o1.getHeight(), o2.getHeight());}});System.out.println(Arrays.toString(students));/*  [Student{name='刘风凌', height=162.0, age=36},Student{name='老男孩', height=168.0, age=45},Student{name='图灵机', height=170.0, age=32},Student{name='孙克旭', height=172.0, age=25},Student{name='马林思维', height=175.0, age=34}]*/

5.4 单元练习12

5.4.1 Arrays类的作用是什么？

Arrays类是Java中一个工具类，它提供了一系列静态方法，用于对数组进行各种操作，
如排序、搜索、填充等。使用Arrays类可以方便地操作数组，提高代码的效率和可读性。

5.4.2 Arrays类的常用方法有哪些？

Arrays类提供了多个常用的方法，其中一些包括：
1、public static String toString(类型[] arr): 返回数组的内容
2、public static 类型[] copyOfRange(类型[] arr, 起始索引, 结束索引) ：拷贝数组（指定范围，包前不包后）
3、public static copyOf(类型[] arr, int newLength)：拷贝数组，可以指定新数组的长度。
4、public static setAll(double[] array, IntToDoubleFunction generator)：把数组中的原数据改为新数据又存进去
5、public static void sort(类型[] arr)：对数组进行排序(默认是升序排序)

5.4.3 使用Arrays.sort()方法进行排序时，自定义排序规则的写法有几种呢？

在使用 Arrays.sort() 方法进行排序时，可以通过实现 Comparator 接口来自定义排序规则。具体来说，有以下两种方式：
1.让类实现Comparable接口，同时重写compareTo方法。
Arrays的sort方法底层会根据compareTo方法的返回值是正数、负数、还是0来确定谁大、谁小、谁相等。
2.在调用Arrays.sort(数组,Comparator比较器);时，除了传递数组之外，传递一个Comparator比较器对象。
Arrays的sort方法底层会根据Comparator比较器对象的compare方法方法的返回值是正数、负数、还是0来确定谁大、谁小、谁相等。

5.4.4 编码题1

定义一个类，实现以下操作
①定义一个长度为10的整数数组，使用随机数对数组进行初始化。随机数范围是1-100
②使用Arrays类的sort方法进行升序排序，并输出排序后的结果。
③接着使用Arrays类的binarySearch方法，查找数组中值为5的元素，并输出其在数组中的位置。

提示：可以使用Random类生成随机数。

---

package com.itheima.work2;import java.util.Arrays;
import java.util.Random;/*** @ClassName Test1* @Description 编码题* @Author 孙克旭* @Date 2025/3/22 19:53*/
public class Test1 {public static void main(String[] args) {Random random = new Random();
//①定义一个长度为10的整数数组，使用随机数对数组进行初始化。随机数范围是1-100int[] arr = new int[10];for (int i = 0; i < arr.length; i++) {arr[i] = random.nextInt(100) + 1;}
//②使用Arrays类的sort方法进行升序排序，并输出排序后的结果。Arrays.sort(arr);System.out.println(Arrays.toString(arr)); //[4, 5, 14, 16, 25, 25, 36, 41, 78, 94]
//③接着使用Arrays类的binarySearch方法，查找数组中值为5的元素，并输出其在数组中的位置。int i = Arrays.binarySearch(arr, 5);System.out.println(i); //1}
}

5.4.5 编码题2

开发一个在线考试系统，要求对考生的成绩进行排名。
①考生信息存储在一个数组中，每个元素包含考生姓名和成绩两个属性。
②编写一个方法，能够接收一个考生信息数组，并按照成绩从高到低进行排序，然后输出每个考生的排名和姓名。

提示：可以使用Arrays类的sort方法进行排序，使用Comparator接口自定义排序规则，然后遍历排序后的数组，输出每个考生的排名和姓名。

---

考生类：

package com.itheima.work2;
/**  * @ClassName Candidate  * @Description 考生类  * @Author 孙克旭  * @Date 2025/3/22 20:17*/
public class Candidate {private String name;private double score;public Candidate() {}public Candidate(String name, double score) {this.name = name;this.score = score;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getScore() {return score;}public void setScore(double score) {this.score = score;}@Overridepublic String toString() {return "Candidate{" +"name='" + name + '\'' +", score=" + score +'}';}
}

测试类：

package com.itheima.work2;import java.util.Arrays;
import java.util.Comparator;/*** @ClassName Test2* @Description 编码题* @Author 孙克旭* @Date 2025/3/22 19:58*/
public class Test2 {public static void main(String[] args) {Candidate[] arr = new Candidate[5];arr[0] = new Candidate("孙克旭", 100);arr[1] = new Candidate("老男孩", 1000);arr[2] = new Candidate("马林思维", 999);arr[3] = new Candidate("刘风凌", 800);arr[4] = new Candidate("图灵机", 900);Arrays.sort(arr, new Comparator<Candidate>() {@Overridepublic int compare(Candidate o1, Candidate o2) {return Double.compare(o2.getScore(), o1.getScore());}});for (int i = 0; i < arr.length; i++) {Candidate c = arr[i];System.out.println("第" + (i + 1) + "名：" + c.getName());}/*   第1名：老男孩第2名：马林思维第3名：图灵机第4名：刘风凌第5名：孙克旭*/}
}