Java进阶-常用API(三)
一、API介绍
API(Application Programming Interface) : 应用程序编程接口
就是别人写好的一些类，我们直接拿来调用即可解决问题的
API帮助文档的使用流程
1. 在索引位置搜索自己要查看的类
2. 看包
目的: 是不是java.lang包(核心包), 不需要编写导包代码(import)
- 不是java.lang包, 都需要编写导包代码
3. 看这个类的介绍
目的: 搞清楚这个类的作用
4. 看这个类的构造方法
目的: 为了将该类的对象, 创建出来
5. 看这个类的成员方法(方法摘要)
1. 方法名
2. 参数
3. 返回值
4. 介绍
二、Scanner类
package com.itheima.scanner;
import java.util.Scanner;
public class ScannerDemo1 {
/*
Scanner键盘录入的三个步骤
1. 找符咒
代码: import java.util.Scanner;
位置: class的上面
含义: 能够让自己的类ScannerDemo, 从代码仓库中, 找到Scanner符咒
2. 召唤精灵
代码: Scanner sc = new Scanner(System.in);
位置: main方法里面
含义: 从符咒中召唤精灵, 给精灵起名字叫做 sc
3. 指挥精灵干活
代码:
int age = sc.nextInt(); 从键盘录入整数, 并使用int类型变量接收
double height = sc.nextDouble(); 从键盘录入小数, 并使用double类型变量接收
boolean flag = sc.nextBoolean(); 从键盘录入布尔, 并使用boolean类型变量接收
String name = sc.next(); 从键盘录入字符串, 并使用String类型变量接收
Scanner键盘录入字符串 :
String next() : 遇到了空格, 或者是tab键就不再录入了
String nextLine() : 以回车作为录入的结束标记
弊端:
1. next() : 数据可能录入不完整
2. nextLine() : 之前调用过nextInt(), nextDouble(), nextFloat()...
nextLine()方法, 就不干活了
解决方案: 不用解决
Scanner : 采集用户信息 (只在学习过程用的到)
目前的使用方案:
需求如果要键盘录入字符串
如果所有的数据, 全部都是字符串, 直接nextLine();
举例:
键盘录入用户名, 键盘录入用户密码
如果数据除了字符串, 还有其他类型, 需要调用next()方法
举例:
键盘录入用户名, 键盘录入用户年龄, 用户身高
*/
public static void main(String[] args) {
// 1. 召唤Scanner精灵
Scanner sc = new Scanner(System.in);
// 2. 键盘录入姓名
System.out.println("请输入您的姓名:");
String name = sc.next();
// 3. 键盘录入年龄
System.out.println("请输入您的年龄:");
int age = sc.nextInt();
// 4. 键盘录入性别
System.out.println("请输入您的性别:");
String gender = sc.next();
// 5. 键盘录入身高
System.out.println("请输入您的身高:");
double height = sc.nextDouble();
// 6. 键盘录入婚姻状况
System.out.println("请输入您的婚姻状况:");
boolean flag = sc.nextBoolean();
System.out.println("注册成功!");
System.out.println(name);
System.out.println(age);
System.out.println(gender);
System.out.println(height);
System.out.println(flag);
}
}
三、String类
1、String 类的特点
package com.itheima.string;
public class StringDemo1 {
/*
String类的特点 :
1. Java 程序中所有双引号字符串, 都是String这个类的对象
2. 字符串一旦被创建, 就不可更改, 字符串内容不可改变
如果想要更改, 只能使用新的对象, 做替换
3. String字符串虽然不可改变, 但是可以被共享
字符串常量池: 当我们使用双引号创建字符串对象时, 会检查常量池中是否存在该数据
不存在 : 创建
存在 : 复用
*/
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); // true
}
}
2、String 类的常见构造方法
package com.itheima.string;
public class StringDemo2 {
/*
String类常见构造方法 :
public String() : 创建一个空白字符串, 里面不含任何内容
public String(char[] chs) : 根据传入的字符数组, 创建字符串对象
public String(String original) : 根据传入的字符串, 来创建字符串对象
-----------------------------------------------------------------
1. 打印对象名, 会看到对象的内存地址, 这里打印字符串对象, 为什么没有看到地址值
回答: 暂不解释
TODO: 面向对象(继承), 方法重写, Object类, toString方法
2. 这三个构造方法, 创建字符串对象, 都没有双引号直接创建来的方便.
String s = "abc";
-----------------------------------------------------------------
字符串对象, 两种创建方式的区别
1. 双引号直接创建
2. 通过构造方法创建
*/
public static void main(String[] args) {
// public String() : 创建一个空白字符串, 里面不含任何内容
String s1 = new String();
System.out.println(s1); // ""
// public String(char[] chs) : 根据传入的字符数组, 创建字符串对象
char[] chs = {'a','b','c'};
String s2 = new String(chs);
System.out.println(s2); // "abc"
// public String(String original) : 根据传入的字符串, 来创建字符串对象
String s3 = new String("abc");
System.out.println(s3); // "abc"
String ss1 = "abc";
String ss2 = "a" + "b" + "c";
System.out.println(ss1 == ss2); // true
}
}
3、String 类的常见面试题
4、String 类用于比较的方法
package com.itheima.string.method;
public class StringMethodDemo1 {
/*
String类中用于比较的方法 :
public boolean equals(Object anObject) 将此字符串与指定的对象比较
public boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写
*/
public static void main(String[] args) {
String s1 = "abc";
String s2 = new String("abc");
System.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // true
System.out.println("---------------------");
String ss1 = "abc";
String ss2 = "ABC";
System.out.println(ss1.equals(ss2)); // false
System.out.println(ss1.equalsIgnoreCase(ss2)); // true
}
}
5、String 字符串的遍历
package com.itheima.string.method;
public class StringMethodDemo2 {
/*
String类用于遍历的方法:
public char[] toCharArray() 将此字符串转换为一个新的字符数组
public char charAt(int index) 返回指定索引处的 char 值
public int length() 返回此字符串的长度
*/
public static void main(String[] args) {
print();
}
/**
* 字符串遍历的第二种方式
*/
private static void print2() {
String s = "itheima";
for (int i = 0; i < s.length(); i++) {
// i = 0 1 2 3 4 5 6
char c = s.charAt(i);
System.out.println(c);
}
}
/**
* 字符串的第一种遍历方式
*/
private static void print1() {
String s = "itheima";
char[] chars = s.toCharArray();
for (int i = 0; i < chars.length; i++) {
System.out.println(chars[i]);
}
}
}
6、String 字符串的截取方法
package com.itheima.string.method;
public class StringMethodDemo3 {
/*
String类的截取方法 :
public String substring(int beginIndex) : 根据传入的索引开始做截取, 截取到字符串的末尾
public String substring(int beginIndex, int endIndex) : 根据传入的开始和结束索引, 对字符串做截取
- 包含头, 不包含尾
注意: 截取出来的内容, 是作为新的字符串返回, 别忘记找变量接收
*/
public static void main(String[] args) {
String s = "itheima";
String result = s.substring(0, 2);
System.out.println(result);
}
private static void method() {
String s = "itheima";
String result = s.substring(2);
System.out.println(result);
}
}
7、String 字符串的替换方法
package com.itheima.string.method;
public class StringMethodDemo4 {
/*
String类的替换方法 :
public String replace(CharSequence target, CharSequence replacement) :
参数1 : 旧值
参数2 : 新值
*/
public static void main(String[] args) {
String s = "itheima";
String result = s.replace("heima", "baima");
System.out.println(result);
}
}
8、String 字符串的切割方法
package com.itheima.string.method;
public class StringMethodDemo5 {
/*
String类的切割方法 :
public String[] split(String regex) : 根据传入的字符串作为规则, 切割当前字符串
建议: 先正常指定切割规则, 后来发现没有得到自己要的效果, 就可以尝试在规则前面, 加入 \\
*/
public static void main(String[] args) {
String s = "192+168+1+1";
String[] sArr = s.split("\\+");
for (int i = 0; i < sArr.length; i++) {
System.out.println(sArr[i]);
}
}
}
9、String字符串的替换方法
package com.itheima.regex;
public class StringRegexMethod {
/*
String类中与正则有关的常见方法 :
public String replaceAll(String regex,String newStr) : 按照正则表达式匹配的内容进行替换
*/
public static void main(String[] args) {
String s = "先帝1创业2未半而中道3崩殂4，今5天下三分6，益州疲弊7，此8诚危急存亡之秋也。然9侍卫之臣不懈于内，忠志之士忘身10于外者，盖追先帝之殊遇11，欲报之于陛下也。诚宜12开张圣听13，以光14先帝遗德，恢弘15志士之气，不宜妄自菲薄16，引喻失义17，以塞忠谏之路也18。\n" +
"宫中府中，俱为一体19；陟罚臧否20，不宜异同：若有作奸犯科21及为忠善者22，宜付有司23论其刑赏24，以昭陛下平明之理25；不宜偏私26，使内外异法也27。\n" +
"侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯28，是以先帝简拔以遗陛下29：愚以为宫中之事，事无大小，悉以咨之30，然后施行，必能裨补阙漏31，有所广益32";
s = s.replaceAll("\\d", "");
System.out.println(s);
}
}
四、StringBuilder 类
1、StringBuilder 介绍和构造方法
package com.itheima.stringbuilder;
public class StringBuilderDemo2 {
/*
StringBuilder的作用 : 提高字符串的操作效率
StringBuilder的介绍 :
1. 一个可变的字符序列
2. StringBuilder是字符串缓冲区, 将其理解是容器, 这个容器可以存储任意数据类型, 但是只要进入到这个容器, 全部变成字符串.
StringBuilder的构造方法 :
public StringBuilder() : 创建一个空白的字符串缓冲区(容器), 其初始容量为16个字符
public StringBuilder(String str) : 创建一个字符串缓冲区(容器), 容器在创建好之后, 就会带有参数的内容
*/
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("abc");
System.out.println(sb);
}
}
2、StringBuiler 常用成员方法
package com.itheima.stringbuilder;
public class StringBuilderDemo3 {
/*
StringBuilder常用成员方法 :
1. public StringBuilder append(任意类型) : 添加数据, 并返回对象自己
2. public StringBuilder reverse() : 将缓冲区中的内容, 进行反转
3. public int length() : 返回长度
4. public String toString() : 将缓冲区的内容, 以String字符串类型返回
*/
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
// 链式编程: 调用的方法, 返回的结果是对象, 就可以继续向下调用方法
sb.append("红色").append("绿色").append("蓝色");
System.out.println(sb); // 红色绿色蓝色
sb.reverse();
System.out.println(sb); // 色蓝色绿色红
System.out.println(sb.length()); // 6
// 情况: 我数据在StringBuilder当中, 我要调用的方法, StringBuilder没有, 但是String有
// 解决: 转换为String, 再调用
String[] sArr = sb.toString().split("色");
for (int i = 0; i < sArr.length; i++) {
System.out.println(sArr[i]);
}
}
}
3、String 和 StringBuilder 的拼接内存图
五、Object 类
1、toString 方法
package com.itheima.object.tostring;
import com.itheima.object.Student;
import java.util.ArrayList;
public class ToStringDemo {
/*
public String toString() 返回该对象的字符串表示
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
getClass().getName() : 类名称, 全类名(包名 + 类名)
Integer.toHexString() : 转十六进制
hashCode() : 返回的是对象内存地址 + 哈希算法, 算出来的整数 (哈希值)
-------------------------------------------------------
细节: 使用打印语句, 打印对象名的时候, println方法, 源码层面, 会自动调用该对象的toString方法.
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
*/
public static void main(String[] args) {
A a = new A();
System.out.println(a);
System.out.println(a.toString());
Student stu = new Student("张三",23);
System.out.println(stu);
ArrayList<String> list = new ArrayList<>();
list.add("abc");
list.add("abc");
list.add("abc");
System.out.println(list);
}
}
class A {
@Override
public String toString() {
return "大哥重写了toString方法";
}
}
2、equals 方法
package com.itheima.object.equals;
import com.itheima.object.Student;
import java.util.Objects;
public class EqualsDemo {
/*
Object类中的equals方法 :
public boolean equals(Object obj) : 对象之间进行比较, 返回true, 或者是false.
public boolean equals(Object obj) {
return (this == obj);
}
结论: Object类中的equals方法, 默认比较的是对象内存地址
- 通常会重写equals方法, 让对象之间, 比较内容
*/
public static void main(String[] args) {
Student stu1 = new Student("张三", 23);
Student stu2 = new Student("张三", 24);
System.out.println(stu1.equals(stu2));
}
}
----------------------------------------------------
package com.itheima.object;
public class Student {
private String name;
private int age;
// @Override
// public boolean equals(Object obj) {
// // this : stu1
// // obj : stu2
// if (obj instanceof Student) {
// Student stu2 = (Student) obj;
// return this.age == stu2.age && this.name.equals(stu2.name);
// } else {
// return false;
// }
// }
@Override
public boolean equals(Object o) {
// this : stu1
// o : stu2
if (this == o) {
// 两个对象做地址值的比较, 如果地址相同, 里面的内容肯定相同, 直接返回为true.
return true;
}
// 代码要是能够走到这里, 代表地址肯定不相同
// 代码要是能够走到这里, 代表stu1, 肯定不是null
// stu1不是null, stu2是null, 就直接返回false
// this.getClass() != o.getClass() : 两个对象的字节码是否相同
// 如果字节码不相同, 就意味着类型不相同, 直接返回false
if (o == null || this.getClass() != o.getClass()) {
return false;
}
// 代码要是能够走到这里, 代表字节码相同, 类型肯定相同.
// 向下转型
Student student = (Student) o;
// 比较
return this.age == student.age && Objects.equals(this.name, student.name);
}
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{name = " + name + ", age = " + age + "}";
}
}
六、Objects 类
package com.itheima.object.equals;
import com.itheima.object.Student;
import java.util.Objects;
public class EqualsDemo {
public static void main(String[] args) {
Student stu1 = null;
Student stu2 = new Student("张三",23);
System.out.println(Objects.isNull(stu1));
System.out.println(Objects.isNull(stu2));
// 问题: Objects.equals方法, 和 stu1.equals方法, 有什么区别?
// 细节: Objects.equals方法, 内部依赖于我们自己所编写的equals
// 好处: Objects.equals方法, 内部带有非null判断
/*
// a : stu1
// b : stu2
public static boolean equals(Object a, Object b) {
-----------------------------------------------------------------------------------------------
a == b : 如果地址相同, 就会返回为true, 这里使用的符号是短路 || , 左边为true, 右边就不执行了
- 结论: 如果地址相同, 方法直接返回为true
: 如果地址不相同, 就会返回false, 短路 || , 左边为false, 右边要继续执行.
-----------------------------------------------------------------------------------------------
a != null : 假设 a 是 null 值
null != null : false
&& : 左边为false, 右边不执行, 右边不执行, 记录着null值的a, 就不会调用equals方法
- 避免空指针异常 !
-----------------------------------------------------------------------------------------------
a != null : 假设 a 不是 null 值
stu1 != null : true
&& : 左边为true, 右边继续执行, a.equals(b), 这里就不会出现空指针异常
return (a == b) || (a != null && a.equals(b));
}
*/
System.out.println(Objects.equals(stu1, stu2));
System.out.println("看看我执行了吗?");
}
}
七、Math 类
package com.itheima.math;
public class MathDemo {
/*
Math类 : 包含执行基本数字运算的方法
--------------------------------------------------------------------
public static int abs (int a) : 获取参数绝对值
public static double ceil (double a) : 向上取整
public static double floor (double a) : 向下取整
public static int round (float a) : 四舍五入
public static int max (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 static void main(String[] args) {
System.out.println(Math.abs(-123)); // 123
System.out.println(Math.abs(-12.3)); // 12.3
System.out.println("---------------------");
System.out.println(Math.ceil(12.0));
System.out.println(Math.ceil(12.2));
System.out.println(Math.ceil(12.5));
System.out.println(Math.ceil(12.9));
System.out.println("---------------------");
System.out.println(Math.floor(12.0));
System.out.println(Math.floor(12.2));
System.out.println(Math.floor(12.5));
System.out.println(Math.floor(12.9));
System.out.println("---------------------");
System.out.println(Math.round(3.4)); // 3
System.out.println(Math.round(3.6)); // 4
System.out.println("---------------------");
System.out.println(Math.max(10, 20)); // 20
System.out.println(Math.min(10, 20)); // 10
System.out.println("---------------------");
System.out.println(Math.pow(2, 3)); // 8.0
System.out.println("---------------------");
System.out.println(Math.random());
}
}
八、Random随机数
package com.itheima.random;
// 1. 找符咒
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
randomTest();
}
/*
Random产生随机数
*/
public static void randomTest() {
// 2. 召唤精灵
Random r = new Random();
for (int i = 1; i <= 20; i++) {
// 3. 指挥精灵产生随机数
int num = r.nextInt(100) + 1;
System.out.println(num);
}
System.out.println("-----------------------");
// 需求: 产生20~80之间的随机数
for (int i = 1; i <= 20; i++) {
int num = r.nextInt(61) + 20;
System.out.println(num);
}
}
}
九、System 类
package com.itheima.system;
public class SystemDemo {
/*
System类常见方法 :
1. public static void exit (int status) : 终止当前运行的 Java 虚拟机，非零表示异常终止
2. public static long currentTimeMillis () : 返回当前系统的时间毫秒值形式
- 返回1970年1月1日 0时0分0秒, 到现在所经历过的毫秒值
3. public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) : 数组拷贝
1. 数据源数组
2. 起始索引
3. 目的地数组
4. 起始索引
5. 拷贝的个数
*/
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
int[] destArr = new int[3];
System.arraycopy(arr, 2, destArr, 0, 3);
for (int i = 0; i < destArr.length; i++) {
System.out.println(destArr[i]);
}
}
private static void method() {
long start = System.currentTimeMillis();
String s = "";
for(int i = 1; i <= 100000; i++){
s += i;
}
System.out.println(s);
long end = System.currentTimeMillis();
System.out.println(end - start);
}
}
十、BigDecimal 类
package com.itheima.bigdecimal;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalDemo {
/*
BigDecimal类 : 解决小数运算中, 出现的不精确问题
BigDecimal创建对象 :
public BigDecimal(double val) : 不推荐, 无法保证小数运算的精确
---------------------------------------------------------------
public BigDecimal(String val)
public static BigDecimal valueOf(double val)
BigDecimal常用成员方法 :
public BigDecimal add(BigDecimal b) : 加法
public BigDecimal subtract(BigDecimal b) : 减法
public BigDecimal multiply(BigDecimal b) : 乘法
public BigDecimal divide(BigDecimal b) : 除法
public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式) : 除法
注意: 如果使用BigDecimal运算, 出现了除不尽的情况, 就会出现异常
*/
public static void main(String[] args) {
BigDecimal bd1 = BigDecimal.valueOf(10.0);
BigDecimal bd2 = BigDecimal.valueOf(3.0);
System.out.println(bd1.divide(bd2, 2, RoundingMode.HALF_UP)); // 3.33 四舍五入
System.out.println(bd1.divide(bd2, 2, RoundingMode.UP)); // 3.34 进一法
System.out.println(bd1.divide(bd2, 2, RoundingMode.DOWN)); // 3.33 去尾法
BigDecimal result = bd1.divide(bd2, 2, RoundingMode.HALF_UP);
double v = result.doubleValue();
Math.abs(v);
}
private static void method() {
BigDecimal bd1 = BigDecimal.valueOf(0.1);
BigDecimal bd2 = BigDecimal.valueOf(0.2);
System.out.println(bd1.add(bd2));
System.out.println(bd1.subtract(bd2));
System.out.println(bd1.multiply(bd2));
System.out.println(bd1.divide(bd2));
}
}
十一、包装类
1、Integer 包装类
package com.itheima.integer;
public class IntegerDemo {
/*
包装类 : 将基本数据类型, 包装成类, 变成引用数据类型
------------------------------------------------------------------------------------------
手动装箱: 调用方法, 手动将基本数据类型, 包装成类
1. public Integer(int value) : 通过构造方法 (不推荐)
2. public static Integer valueOf(int i) : 通过静态方法
手动拆箱: 调用方法, 手动将包装类, 拆成(转换)基本数据类型
1. public int intValue() : 以 int 类型返回该 Integer 的值
------------------------------------------------------------------------------------------
JDK5版本开始, 出现了自动拆装箱 :
1. 自动装箱 : 可以将基本数据类型, 直接赋值给包装类的变量
2. 自动拆箱 : 可以将包装类的数据, 直接赋值给基本数据类型变量
结论: 基本数据类型, 和对应的包装类, 可以直接做运算了, 不需要操心转换的问题了
-------------------------------------------------------------------------------------------
Integer 常用方法 :
public static String toBinaryString (int i) : 转二进制
public static String toOctalString (int i) : 转八进制
public static String toHexString (int i) : 转十六进制
public static int parseInt (String s) : 将数字字符串, 转换为数字
*/
public static void main(String[] args) {
int num = 10;
// 手动拆箱装箱
Integer i1 = Integer.valueOf(num);
System.out.println(i1);
int i = i1.intValue();
System.out.println(i);
// 自动拆箱装箱
Integer i2 = num;
int i3 = i2;
method();
}
public static void method() {
int num = 100;
System.out.println(Integer.toBinaryString(num));
System.out.println(Integer.toOctalString(num));
System.out.println(Integer.toHexString(num));
String s = "123";
System.out.println(Integer.parseInt(s) + 100); // 223
}
}
---------------------------------------------------------------------
package com.itheima.integer;
public class IntegerTest {
/*
已知字符串 String s = "10,50,30,20,40";
请将该字符串转换为整数并存入数组
随后求出最大值打印在控制台
*/
public static void main(String[] args) {
String s = "10,50,30,20,40";
// 1. 根据逗号做切割
String[] sArr = s.split(",");
// 2. 准备一个整数数组, 准备存储转换后的数字
int[] nums = new int[sArr.length];
// 3. 遍历字符串数组
for (int i = 0; i < sArr.length; i++) {
// sArr[i] : 每一个数字字符串
// 4. 将数字字符串转换为整数, 并存入数组
nums[i] = Integer.parseInt(sArr[i]);
}
// 5. 求最大值
int max = nums[0];
for (int i = 1; i < nums.length; i++) {
if(nums[i] > max){
max = nums[i];
}
}
System.out.println("最大值为:" + max);
}
}
2、包装类面试题
package com.itheima.integer;
public class InterView {
/*
看程序说结果, 并说明原因
自动装箱的时候, 如果装箱的数据范围, 是-128~127, ==号比较的结果就是true, 反之都是false
-----------------------------------------------------------------------------------
自动装箱的原理 : 自动帮我们调用了 Integer.valueOf(127);
// i = 127
public static Integer valueOf(int i) {
if (i >= -128 && i <= 127) {
return IntegerCache.cache[255];
}
return new Integer(i);
}
如果装箱的数据, 不在 -128 ~ 127 之间, 会重新创建新的对象
如果装箱的数据, 在 -128 ~ 127 之间, 不会创建新的对象, 而是从底层的数组中, 取出一个提前创建好的Integer对象, 返回
- Integer类中, 底层存在一个长度为256个大小的数组, Integer[] cache
在数组中, 存储了256个Integer对象, 分别是 -128 ~ 127
*/
public static void main(String[] args) {
Integer i1 = 127;
Integer i2 = 127;
System.out.println(i1 == i2); // true
Integer i3 = 129;
Integer i4 = 129;
System.out.println(i3 == i4); // false
Long i11 = 129L;
Long i22 = 129L;
System.out.println(i11 == i22);
System.out.println(i11.equals(i22));
}
}
十二、Arrays 工具类
package com.itheima.arrays;
import java.util.Arrays;
public class ArraysDemo {
/*
Arrays类常用方法 :
-------------------------------------------------------------------------------------------
public static String toString (类型[] a) : 将数组元素拼接为带有格式的字符串
public static boolean equals (类型[] a, 类型[] b) : 比较两个数组内容是否相同
public static int binarySearch (int[] a, int key) : 查找元素在数组中的索引 (二分查找法: 保证数组的元素是排好序的)
- 如果查找的元素, 在数组中不存在: 返回 (-(插入点) - 1)
public static void sort (类型[] a) : 对数组进行默认升序排序
TODO: 后面学完了红黑树, 回头对这个方法做补充
-------------------------------------------------------------------------------------------
*/
public static void main(String[] args) {
int[] arr1 = {11, 22, 33, 44, 55};
int[] arr2 = {11, 22, 33, 44, 66};
// 将数组元素拼接为带有格式的字符串
System.out.println(Arrays.toString(arr1)); // [11, 22, 33, 44, 55]
// 比较两个数组内容是否相同
System.out.println(Arrays.equals(arr1, arr2)); // false
// 查找元素在数组中的索引
System.out.println(Arrays.binarySearch(arr1, 33)); // 2
System.out.println(Arrays.binarySearch(arr1, 66)); // -6
int[] nums = {22, 11, 55, 44, 33};
System.out.println(Arrays.binarySearch(nums, 11)); // -1
Arrays.sort(nums);
System.out.println(Arrays.binarySearch(nums, 11)); // 0
// 对数组进行默认升序排序
Arrays.sort(nums);
System.out.println(Arrays.toString(nums)); // [11, 22, 33, 44, 55]
}
}
十三、Collections 集合工具类
package com.heima.tools;
import com.heima.domain.Student;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class CollectionsDemo {
/*
Collections: 集合工具类
Collections并不属于集合，是用来操作集合的工具类
常用方法
public static boolean addAll(Collection c, T... elements) 给集合对象批量添加元素
public static void shuffle(List list) 打乱List集合元素的顺序
public static int binarySearch (List list, T key) 以二分查找法查找元素
public static void max/min(Collection coll) 根据默认的自然排序获取最大/小值
public static void swap(List list, int i, int j) 交换集合中指定位置的元素
public static void sort(List list) 将集合中元素按照默认规则排序
注意：本方式不可以直接对自定义类型的List集合排序，除非自定义类型实现了比较规则Comparable接口
public static void sort(List list，Comparator c) 将集合中元素按照指定规则排序
*/
public static void main(String[] args) {
// 批量添加
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "a", "b", "c", "d");
System.out.println(list); // [a, b, c, d]
// 二分查找
int c = Collections.binarySearch(list, "c");
System.out.println(c); // 2
// 洗牌
Collections.shuffle(list);
System.out.println(list); // [b, c, d, a]
// 从集合中找最值，依赖于 CompareTo方法
ArrayList<Integer> nums = new ArrayList<>();
Collections.addAll(nums, 1, 2, 3, 4, 5, 6, 7);
System.out.println(Collections.max(nums)); // 7
System.out.println(Collections.min(nums)); // 1
ArrayList<Student> stus = new ArrayList<>();
Collections.addAll(stus, new Student("张三", 23), new Student("李四", 26), new Student("王五", 24));
System.out.println(Collections.max(stus));
System.out.println(stus); // [Student{name = 张三, age = 23}, Student{name = 李四, age = 26}, Student{name = 王五, age = 24}]
// 对集合中的元素进行交换
Collections.swap(stus, 1, 2);
System.out.println(stus); // [Student{name = 张三, age = 23}, Student{name = 王五, age = 24}, Student{name = 李四, age = 26}]
// sort: 对集合进行排序
ArrayList<Integer> box = new ArrayList<>();
Collections.addAll(box, 1, 5, 3, 4, 2);
Collections.sort(box);
System.out.println(box); // [1, 2, 3, 4, 5]
Collections.sort(box, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
System.out.println(box); // [5, 4, 3, 2, 1]
}
}
十四、算法
1、冒泡排序
package com.itheima.test;
import java.util.Arrays;
public class BubbleSort {
/*
冒泡排序: 相邻的两个数进行比较, 如果第一个比第二个大, 就交换他们两个
第一轮 : arr[0]-arr[1] arr[1]-arr[2] arr[2]-arr[3] arr[3]-arr[4] 比较4次
第二轮 : arr[0]-arr[1] arr[1]-arr[2] arr[2]-arr[3] 比较3次
第三轮 : arr[0]-arr[1] arr[1]-arr[2] 比较2次
第四轮 : arr[0]-arr[1] 比较1次
*/
public static void main(String[] args) {
int[] arr = {22, 55, 44, 33, 11};
// 外循环: 比较的轮数
for (int i = 0; i < arr.length - 1; i++) {
// 内循环: 比较的次数
// -1: 避免索引越界
// -i: 提升效率
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
2、选择排序
package com.itheima.test;
import java.util.Arrays;
public class SelectSort {
/*
选择排序: 从 0 索引开始，拿着每一个索引上的元素跟后面的元素依次比较
第一轮 : arr[0]-arr[1] arr[0]-arr[2] arr[0]-arr[3] arr[0]-arr[4]
第二轮 : arr[1]-arr[2] arr[1]-arr[3] arr[1]-arr[4]
第三轮 : arr[2]-arr[3] arr[2]-arr[4]
第四轮 : arr[3]-arr[4]
*/
public static void main(String[] args) {
int[] arr = {22, 11, 44, 33, 55};
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i+1; j < arr.length; j++) {
if(arr[i] > arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
3、二分查找
package com.itheima.test;
public class BinarySearch {
/*
二分查找 (折半查找) :
前提: 数组元素必须是排好序的
思路:
1. 定义两个变量记录最小索引, 和最大索引
2. 折半的动作不止一次, 应该使用循环
条件 while(min <= max)
3. 循环中计算出中间索引
4. 加入判断
元素如果大于中间元素 : min = mid + 1;
元素如果小于中间元素 : max = mid – 1;
元素如果等于中间元素 : 将索引返回 (mid)
*/
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55, 66, 77, 88, 99};
int index = binarySearch(arr, 100);
System.out.println(index);
}
private static int binarySearch(int[] arr, int num) {
// 1. 定义两个变量记录最小索引, 和最大索引
int min = 0;
int max = arr.length - 1;
int mid;
// 2. 折半的动作不止一次, 应该使用循环
while (min <= max) {
// 3. 计算中间索引
mid = (min + max) / 2;
// 4. 比对
if (num > arr[mid]) {
min = mid + 1;
} else if (num < arr[mid]) {
max = mid - 1;
} else {
return mid;
}
}
// 5. 没找到, 返回-1
return -1;
}
}
十五、时间API
1、JDK8（-）时间API
1)、Date 类
package com.itheima.jdk7.date;
import java.util.Date;
public class DateDemo1 {
/*
Date类 : 表示时间的类
1. 构造方法 :
public Date() : 将当前时间, 封装为Date日期对象
public Date(long time) : 把时间毫秒值转换成Date日期对象
2. 常见方法 :
public long getTime() : 返回从1970年1月1日 00:00:00走到此刻的总的毫秒数
public void setTime(long time) : 设置日期对象的时间为当前时间毫秒值对应的时间
*/
public static void main(String[] args) {
// 将当前时间, 封装为Date日期对象
Date d1 = new Date();
System.out.println(d1);
// 把时间毫秒值转换成Date日期对象
Date d2 = new Date(1000L);
System.out.println(d2);
System.out.println(d1.getTime());
System.out.println(d2.getTime());
System.out.println("----------------------");
Date d3 = new Date();
d3.setTime(0L);
System.out.println(d3);
}
}
2)、SimpleDateFormat 类
package com.itheima.jdk7.format;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {
/*
SimpleDateFormat类 : 用于日期格式化
1. 构造方法 :
public SimpleDateFormat() : 创建一个日期格式化对象, 使用 [默认模式]
public SimpleDateFormat(String pattern) : 创建一个日期格式化对象, [手动指定模式]
2. 常用方法 :
public final String format(Date date) : 将日期对象, 转换为字符串
public final Date parse(String source) : 将日期字符串, 解析为日期对象
*/
public static void main(String[] args) throws ParseException {
String today = "2023年2月4日";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日");
Date date = simpleDateFormat.parse(today);
System.out.println(date);
}
private static void method() {
// 创建一个日期格式化对象, 使用 [默认模式]
// SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
// 创建一个日期格式化对象, [手动指定模式]
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日");
// 创建Date对象, 封装此刻的时间
Date date = new Date();
// 将日期对象, 转换为字符串
String result = simpleDateFormat.format(date);
System.out.println(result);
}
}
3)、Calendar 类
package com.itheima.jdk7.calendar;
import java.util.Calendar;
public class CalendarDemo {
/*
Calendar : 代表的是系统此刻时间对应的日历，通过它可以单独获取、修改时间中的年、月、日、时、分、秒等。
1. 创建对象 :
public static Calendar getInstance() : 获取当前时间的日历对象
2. 常用方法 :
public int get(int field) : 取日历中的某个字段信息
get方法的参数 : Calendar类中的静态常量
Calendar.YEAR : 获取年份信息
Calendar.MONTH : 月份是0~11, 记得做+1操作
Calendar.DAY_OF_MONTH : 获取日
Calendar.DAY_OF_WEEK : 获取星期, 获取星期的时候, 需要提前设计一个数组
Calendar.DAY_OF_YEAR : 获取一年中的第几天
public void set(int field,int value) : 修改日历的某个字段信息
public void add(int field,int amount) : 为某个字段增加/减少指定的值
public final void setTime(Date date) : 将日期对象, 转换为Calendar对象
public final Date getTime() : 拿到此刻的日期对象
*/
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
c.add(Calendar.YEAR, -1);
System.out.println(c.get(Calendar.YEAR));
}
private static void setMethod() {
Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR, 2022);
c.set(2008,8,8);
System.out.println(c.get(Calendar.YEAR));
}
private static void getMethod() {
// Calendar c : 抽象类
// Calendar.getInstance() : 获取的是子类对象
// 1. 获取当前时间的日历对象
Calendar c = Calendar.getInstance();
// 2. 调用get方法, 获取指定字段的信息
int year = c.get(Calendar.YEAR);
System.out.println(year);
// 注意Calendar类的月份是 0~11, 想要获取常规的月份, 需要对结果 + 1操作
int month = c.get(Calendar.MONTH);
System.out.println(month + 1);
int day = c.get(Calendar.DAY_OF_MONTH);
System.out.println(day);
char[] weeks = {' ', '日', '一', '二', '三', '四', '五', '六'};
// 0 1 2 3 4 5 6 7
int weekIndex = c.get(Calendar.DAY_OF_WEEK);
System.out.println(weeks[weekIndex]);
int dayOfYear = c.get(Calendar.DAY_OF_YEAR);
System.out.println(dayOfYear);
}
}
2、JDK8（+）时间API
1)、日历类
1.1、LocalDateTime 类
package com.itheima.jdk8.p1_local_date_time;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
public class LocalDateTimeDemo {
/*
------------------------------------------
LocalDate : 代表本地日期(年、月、日、星期)
LocalTime : 代表本地时间(时、分、秒、纳秒)
LocalDateTime : 代表本地日期、时间(年、月、日、星期、时、分、秒、纳秒)
对象的创建方式:
1. now() : 当前时间
2. of(...) : 设置时间
------------------------------------------
LocalDateTime 转换LocalDate, LocalTime
1. toLocalDate()
2. toLocalTime()
-------------------------------------------
注意点:
LocalDateTime 、LocalDate 、LocalTime 都是不可变的
调用修改的相关方法, 返回的都是新的对象
*/
public static void main(String[] args) {
// 获取此刻的时间对象(日期 时间)
LocalDateTime nowDateTime = LocalDateTime.now();
System.out.println("今天是：" + nowDateTime);
// 年
System.out.println(nowDateTime.getYear());
// 月
System.out.println(nowDateTime.getMonthValue());
// 日
System.out.println(nowDateTime.getDayOfMonth());
// 时
System.out.println(nowDateTime.getHour());
// 分
System.out.println(nowDateTime.getMinute());
// 秒
System.out.println(nowDateTime.getSecond());
// 纳秒
System.out.println(nowDateTime.getNano());
// 转换
LocalDate localDate = nowDateTime.toLocalDate();
LocalTime localTime = nowDateTime.toLocalTime();
// 日 : 当年的第几天
System.out.println("dayOfYear：" + nowDateTime.getDayOfYear());
// 星期
System.out.println("星期" + nowDateTime.getDayOfWeek());
System.out.println("星期" + nowDateTime.getDayOfWeek().getValue());
// 月份
System.out.println("月份" + nowDateTime.getMonth());
System.out.println("月份" + nowDateTime.getMonth().getValue());
// 获取指定的时间对象
LocalDateTime of = LocalDateTime.of(2008, 8, 8, 8, 8);
System.out.println(of);
}
}
1.2、LocalTime 类
package com.itheima.jdk8.p2_local_time;
import java.time.LocalTime;
public class LocalTimeDemo {
public static void main(String[] args) {
// 1、获取本地时间对象。
LocalTime nowTime = LocalTime.now();
// 今天的时间
System.out.println("今天的时间：" + nowTime);
// 时
int hour = nowTime.getHour();
System.out.println("hour：" + hour);
// 分
int minute = nowTime.getMinute();
System.out.println("minute：" + minute);
// 秒
int second = nowTime.getSecond();
System.out.println("second：" + second);
// 纳秒
int nano = nowTime.getNano();
System.out.println("nano：" + nano);
}
}
1.3、LocalDate 类
package com.itheima.jdk8.p3_local_date;
import java.time.LocalDate;
public class LocalDateDemo {
public static void main(String[] args) {
// 1、获取本地日期对象。
LocalDate nowDate = LocalDate.now();
System.out.println("今天的日期：" + nowDate);
int year = nowDate.getYear();
System.out.println("year：" + year);
int month = nowDate.getMonthValue();
System.out.println("month：" + month);
int day = nowDate.getDayOfMonth();
System.out.println("day：" + day);
// 当年的第几天
int dayOfYear = nowDate.getDayOfYear();
System.out.println("dayOfYear：" + dayOfYear);
// 星期
System.out.println("星期：" + nowDate.getDayOfWeek());
System.out.println("星期：" + nowDate.getDayOfWeek().getValue());
// 月份
System.out.println("月份：" +nowDate.getMonth());
System.out.println("月份：" + nowDate.getMonth().getValue());
}
}
1.4、修改方法
package com.itheima.jdk8.p4_update;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.MonthDay;
public class UpdateTimeDemo {
public static void main(String[] args) {
LocalDateTime nowTime = LocalDateTime.now();
// 当前时间
System.out.println(nowTime);
// minus : 减去
// minusYears(年), minusMonths(月), minusDays(日), minusWeeks(周), minusHours(时), minusMinutes(分), minusSeconds(秒), minusNanos(纳秒)
System.out.println("减一小时:" + nowTime.minusHours(1));
System.out.println("减一分钟:" +nowTime.minusMinutes(1));
System.out.println("减一秒钟:" +nowTime.minusSeconds(1));
System.out.println("减一纳秒:" +nowTime.minusNanos(1));
System.out.println("对比时间, 确定方法返回的都是新的实例 >>>>>> " +nowTime);
System.out.println("----------------");
// plus : 加
// plusYears(年), plusMonths(月), plusDays(日), plusWeeks(周), plusHours(时), plusMinutes(分), plusSeconds(秒), plusNanos(纳秒)
System.out.println("加一小时:" + nowTime.plusHours(1));
System.out.println("加一分钟:" + nowTime.plusMinutes(1));
System.out.println("加一秒钟:" + nowTime.plusSeconds(1));
System.out.println("加一纳秒:" + nowTime.plusNanos(1));
System.out.println("---------------");
// with : 这里体现出的是,设置效果
System.out.println("修改的效果:");
//withYear(年), withMonth(月), withDayOfMonth(日), withHour(时), withMinute(分), withSecond(秒), withNano(纳秒)
System.out.println(nowTime.withYear(2008));
System.out.println(nowTime.withMonth(8));
System.out.println(nowTime.withDayOfMonth(8));
System.out.println(nowTime.withHour(8));
System.out.println(nowTime.withMinute(8));
System.out.println(nowTime.withSecond(8));
System.out.println(nowTime.withNano(8));
System.out.println("---------------");
LocalDate myDate = LocalDate.of(2008, 8, 8);
LocalDate nowDate = LocalDate.now();
//2008-08-08是否在nowDate之前?
System.out.println(myDate + "是否在" + nowDate + "之前? " + myDate.isBefore(nowDate)); // true
//2008-08-08是否在nowDate之后?
System.out.println(myDate + "是否在" + nowDate + "之后? " + myDate.isAfter(nowDate)); // false
System.out.println("---------------------------");
// 判断两个时间是否相同
System.out.println(myDate.equals(nowDate)); // false
}
}
2)、日期格式化类
2.1、DateTimeFormatter 类
package com.itheima.jdk8.p5_date_time_formatter;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class DateTimeFormatterDemo {
/*
用于时间的格式化和解析:
1. 对象的获取 :
static DateTimeFormatter ofPattern(格式) : 获取格式对象
2. 格式化 :
String format(时间对象) : 按照指定方式格式化
3. 解析 :
LocalDateTime.parse("解析字符串", 格式化对象);
LocalDate.parse("解析字符串", 格式化对象);
LocalTime.parse("解析字符串", 格式化对象);
*/
public static void main(String[] args) {
LocalDateTime now = LocalDateTime.now();
System.out.println("格式化之前:" + now); // 2023-06-13T21:56:23.341793700
// 获取格式化对象
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
// 格式化
String result = formatter.format(now);
System.out.println("格式化之后:" + result); // 2023年6月13日
// 解析
String time = "2008年08月08日";
LocalDate parse = LocalDate.parse(time, formatter);
System.out.println(parse); // 2008-08-08
}
}
3)、时间类
3.1、Instant 类
package com.itheima.jdk8.p6_instant;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class InstantDemo2 {
/*
Instant类 : 用于表示时间的对象, 类似之前所学习的Date
Instant类常见方法 :
static Instant now() : 获取当前时间的Instant对象（标准时间）
static Instant ofXxxx(long epochMilli) : 根据（秒/毫秒/纳秒）获取Instant对象
ZonedDateTime atZone(ZoneId zone) : 指定时区
boolean isXxx(Instant otherInstant) : 判断系列的方法
Instant minusXxx(long millisToSubtract) : 减少时间系列的方法
Instant plusXxx(long millisToSubtract) : 增加时间系列的方法
*/
public static void main(String[] args) {
// 获取当前时间的Instant对象（标准时间）
Instant now = Instant.now();
System.out.println("当前时间为(世界标准时间):" + now);
System.out.println("------------------");
// 根据（秒/毫秒/纳秒）获取Instant对象
Instant instant1 = Instant.ofEpochMilli(1000);
Instant instant2 = Instant.ofEpochSecond(5);
System.out.println(instant1);
System.out.println(instant2);
System.out.println("------------------");
// 指定时区
ZonedDateTime zonedDateTime = Instant.now().atZone(ZoneId.systemDefault());
System.out.println("带时区的时间:" + zonedDateTime);
System.out.println("------------------");
// 判断系列的方法
System.out.println(now.isBefore(instant1));
System.out.println(now.isAfter(instant1));
System.out.println("------------------");
// 减少时间系列的方法
System.out.println("减1000毫秒:" + now.minusMillis(1000));
System.out.println("减5秒钟:" + now.minusSeconds(5));
System.out.println("------------------");
// 增加时间系列的方法
System.out.println("加1000毫秒:" + now.plusMillis(1000));
System.out.println("加5秒钟:" + now.plusSeconds(5));
System.out.println("------------------");
}
}
3.2、ZoneId 类
package com.itheima.jdk8.p7_Zone;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Set;
public class ZoneIdDemo {
/*
ZoneId类 : 时区类
常见方法 :
1. static Set getAvailableZoneIds() : 获取Java中支持的所有时区
2. static ZoneId systemDefault() : 获取系统默认时区
3. static ZoneId of(String zoneId) : 获取一个指定时区
*/
public static void main(String[] args) {
// 获取Java中支持的所有时区
Set<String> set = ZoneId.getAvailableZoneIds();
System.out.println(set);
System.out.println(set.size()); // 600
System.out.println("-----------------------");
// 获取系统默认时区
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId); // Asia/Shanghai
System.out.println("-----------------------");
// 获取一个指定时区
ZoneId of = ZoneId.of("Africa/Nairobi");
System.out.println(of); // Africa/Nairobi
ZonedDateTime zonedDateTime = Instant.now().atZone(of);
System.out.println(zonedDateTime); // 2023-06-13T17:04:04.213260400+03:00[Africa/Nairobi]
}
}
3.3、ZonedDateTime 类
package com.itheima.jdk8.p7_Zone;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class ZoneDateTimeDemo {
/*
ZoneDataTime 带时区的时间对象 :
static ZonedDateTime now() : 获取当前时间的ZonedDateTime对象
static ZonedDateTime ofXxxx(...) : 获取指定时间的ZonedDateTime对象
ZonedDateTime withXxx(时间) : 修改时间系列的方法
ZonedDateTime minusXxx(时间) : 减少时间系列的方法
ZonedDateTime plusXxx(时间) : 增加时间系列的方法
*/
public static void main(String[] args) {
// 获取当前时间的ZonedDateTime对象
ZonedDateTime now = ZonedDateTime.now();
System.out.println(now);
System.out.println("--------------------------");
// 获取指定时间的ZonedDateTime对象
ZonedDateTime of = ZonedDateTime.of
(2008, 8, 8, 8, 8, 8, 8,
ZoneId.systemDefault());
System.out.println(of);
System.out.println("--------------------------");
// 修改时间系列的方法
System.out.println(now.withYear(2008));
System.out.println(now.withMonth(8));
System.out.println(now.withDayOfMonth(8));
System.out.println("--------------------------");
// 减少时间系列的方法
System.out.println(now.minusYears(1));
System.out.println(now.minusMonths(1));
System.out.println(now.minusDays(1));
System.out.println("--------------------------");
// 增加时间系列的方法
System.out.println(now.plusYears(1));
System.out.println(now.plusMonths(1));
System.out.println(now.plusDays(1));
}
}
4)、工具类
4.1、Period 类
package com.itheima.jdk8.p8_interval;
import java.time.LocalDate;
import java.time.Period;
/**
* Period计算日期间隔 (年月日)
*/
public class PeriodDemo {
public static void main(String[] args) {
// 此刻年月日
LocalDate today = LocalDate.now();
System.out.println(today);
// 昨天年月日
LocalDate otherDate = LocalDate.of(2023, 2, 4);
System.out.println(otherDate);
//Period对象表示时间的间隔对象
Period period = Period.between(today, otherDate); // 第二个参数减第一个参数
System.out.println(period.getYears()); // 间隔多少年
System.out.println(period.getMonths()); // 间隔的月份
System.out.println(period.getDays()); // 间隔的天数
System.out.println(period.toTotalMonths()); // 总月份
}
}
4.2、Duration 类
package com.itheima.jdk8.p8_interval;
import java.time.Duration;
import java.time.LocalDateTime;
/**
* Duration计算日期间隔 (时分秒)
*/
public class DurationDemo {
public static void main(String[] args) {
// 此刻日期时间对象
LocalDateTime today = LocalDateTime.now();
System.out.println(today);
// 昨天的日期时间对象
LocalDateTime otherDate = LocalDateTime.of(2023, 2
, 4, 0, 0, 0);
System.out.println(otherDate);
Duration duration = Duration.between(otherDate, today); // 第二个参数减第一个参数
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.3、ChronoUnit 类
package com.itheima.jdk8.p8_interval;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
/**
* ChronoUnit可用于在单个时间单位内测量一段时间，这个工具类是最全的了，可以用于比较所有的时间单位
*/
public class ChronoUnitDemo {
public static void main(String[] args) {
// 本地日期时间对象：此刻的
LocalDateTime today = LocalDateTime.now();
System.out.println(today);
// 生日时间
LocalDateTime birthDate = LocalDateTime.of(2023, 2, 4,
0, 0, 0);
System.out.println(birthDate);
System.out.println("相差的年数：" + ChronoUnit.YEARS.between(birthDate, today));
System.out.println("相差的月数：" + ChronoUnit.MONTHS.between(birthDate, today));
System.out.println("相差的周数：" + ChronoUnit.WEEKS.between(birthDate, today));
System.out.println("相差的天数：" + ChronoUnit.DAYS.between(birthDate, today));
System.out.println("相差的时数：" + ChronoUnit.HOURS.between(birthDate, today));
System.out.println("相差的分数：" + ChronoUnit.MINUTES.between(birthDate, today));
System.out.println("相差的秒数：" + ChronoUnit.SECONDS.between(birthDate, today));
System.out.println("相差的毫秒数：" + ChronoUnit.MILLIS.between(birthDate, today));
System.out.println("相差的微秒数：" + ChronoUnit.MICROS.between(birthDate, today));
System.out.println("相差的纳秒数：" + ChronoUnit.NANOS.between(birthDate, today));
System.out.println("相差的半天数：" + ChronoUnit.HALF_DAYS.between(birthDate, today));
System.out.println("相差的十年数：" + ChronoUnit.DECADES.between(birthDate, today));
System.out.println("相差的世纪（百年）数：" + ChronoUnit.CENTURIES.between(birthDate, today));
System.out.println("相差的千年数：" + ChronoUnit.MILLENNIA.between(birthDate, today));
System.out.println("相差的纪元数：" + ChronoUnit.ERAS.between(birthDate, today));
}
}
5)、案例
package com.itheima.test;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Scanner;
public class CalculateAgeTest {
/*
需求 : 键盘录入用户生日, 计算出用户的实际年龄.
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的生日: ");
String birthday = sc.nextLine();
// 1. 将键盘录入的日期字符串, 转换为日期对象 (生日那一天的)
LocalDate birthdayDate = LocalDate.parse(birthday, DateTimeFormatter.ofPattern("yyyy年M月d日"));
// 2. 获取今天的日期对象
LocalDate now = LocalDate.now();
// 3. 计算时间间隔
long result = ChronoUnit.YEARS.between(birthdayDate, now);
System.out.println(result);
}
}