My-Notes

011.常用类和基础 API

45分钟阅读

字符串相关类之不可变字符序列：String

String 的特性

java.lang.String 类代表字符串。Java 程序中所有的字符串文字（例如 "hello"）都可以看作是实现此类的实例。

字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。

字符串 String 类型本身是 final 声明的，意味着我们不能继承 String。

String 对象的字符内容是存储在一个字符数组 value[] 中的。"abc" 等效于 char[] data = {'h', 'e', 'l', 'l', 'o'}。

// jdk8 中的 String 源码：
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[]; // String 对象的字符内容是存储在此数组中
 
    /** Cache the hash code for the string */
    private int hash; // Default to 0
  • private 意味着外面无法直接获取字符数组，而且 String 没有提供 value 的 getter 和 setter 方法
  • final 意味着字符数组的引用不可改变，而且 String 也没有提供方法来修改 value 数组某个元素值
  • 因此字符串的字符数组内容也不可变的，即 String 代表着不可变的字符序列。即，一旦对字符串进行修改，就会产生新对象。
  • JDK9：底层变成 byte[] 数组。
// JDK9 底层数组变成 byte[]
public final class String implements java.io.Serializable, Comparable<String>, CharSequence { 
    @Stable
    private final byte[] value;
}
 
//官方说明：... that most String objects contain only Latin-1 characters. Such characters require only one byte of storage, hence half of the space in the internal char arrays of such String objects is going unused.
 
//细节：... The new String class will store characters encoded either as ISO-8859-1/Latin-1 (one byte per character), or as UTF-16 (two bytes per character), based upon the contents of the string. The encoding flag will indicate which encoding is used.

Java 语言提供对字符串串联符号（“+”）以及将其他对象转换为字符串的特殊支持（toString() 方法）

String 的内存结构

概述

因为字符串对象设计为不可变，那么所以字符串有常量池来保存很多常量对象。

JDK6 中，字符串常量池在方法区。JDK7 开始，就移到堆空间，直到目前 JDK17 版本。

举例内存结构分配：

字面量

String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2);
// 内存中只有一个 "hello" 对象被创建，同时被 s1 和 s2 共享

对应内存结构为：（以下内存结构以 JDK6 为例绘制）

Person p1 = new Person();
p1.name = "Tom";
 
Person p2 = new Person();
p2.name = "Tom";
 
System.out.println(p1.name.equals(p2.name)); // true
System.out.println(p1.name == p2.name); // true
System.out.println(p1.name == "Tom"); // true

new

String str1 = "abc"; 与 String str2 = new String("abc"); 的区别？

str2 首先指向堆中的一个字符串对象，然后堆中字符串的 value 数组指向常量池中常量对象的 value 数组。

  • 字符串常量存储在字符串常量池，目的是共享。
  • 字符串非常量对象存储在堆中。

练习：

String s1 = "javaEE";
String s2 = "javaEE";
String s3 = new String("javaEE");
String s4 = new String("javaEE");
 
System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // false
System.out.println(s1 == s4); // false
System.out.println(s3 == s4); // false

题目：String str2 = new String("hello"); 在内存中创建了几个对象？

答：2 个，一个堆中的 String 对象，一个字符串常量池中的 "hello" 字符串常量

+ 和 intern()

String s1 = "a";

说明：在字符串常量池中创建了一个字面量为 "a" 的字符串。

s1 = s1 + "b";

说明：从指向原来的 "a" 字符串常量池对象，变成在堆空间中产生了一个字符串 "ab"。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。

String s2 = "ab";

说明：直接在字符串常量池中创建一个字面量为 "ab" 的字符串。

String s3 = "a" + "b";

说明：s3 指向字符串常量池中已经创建的 "ab" 的字符串。

String s4 = s1.intern();

说明：堆空间的 s1 对象在调用 intern() 之后，会将常量池中已经存在的 "ab" 字符串赋值给 s4

结论：

  1. 常量 + 常量（或字面量）：结果是常量池。且常量池中不会存在相同内容的常量。因为编译期间就可以确定
  2. 常量与变量或变量与变量：结果在堆中
  3. 拼接后调用 intern 方法：返回值在常量池中
  4. concat 方法拼接，哪怕是两个常量对象拼接，结果也是在堆

String 的常用 API

说明：xx 代表有多个重载方法

构造器

public String() // 初始化新创建的 String 对象，以使其表示空字符序列
 
String(String original)
// 初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；
// 换句话说，新创建的字符串是该参数字符串的副本。
 
public String(char[] value) // 通过当前参数中的字符数组来构造新的 String
 
public String(char[] value, int offset, int count) // 通过字符数组的一部分来构造新的 String
 
public String(byte[] bytes) // 通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String
 
public String(byte[] bytes, String charsetName)
// 通过使用指定的字符集解码当前参数中的字节数组来构造新的 String

String 与其他结构间的转换

字符串 → 基本数据类型、包装类：

  • Integer 包装类的 public static int parseInt(String s) 可以将由“数字”字符组成的字符串转换为整型
  • 类似地，使用 java.lang 包中的 Byte、Short、Long、Float、Double 类调相应的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型

基本数据类型、包装类 → 字符串：

  • 调用 String 类的 public String valueOf(int n) 可将 int 型转换为字符串
  • 相应的 valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(double d)、valueOf(boolean b) 可由参数的相应类型到字符串的转换

字符数组 → 字符串：

  • String 类的构造器 String(char[]) 和 String(char[]，int offset，int length) 分别用字符数组中的全部字符和部分字符创建字符串对象

字符串 → 字符数组：

  • public char[] toCharArray()：将字符串中的全部字符存放在一个字符数组中的方法
  • public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)：提供了将指定索引范围内的字符串存放到数组中的方法

字符串 → 字节数组：（编码）

  • public byte[] getBytes()：使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
  • public byte[] getBytes(String charsetName)：使用指定的字符集将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组

字节数组 → 字符串：（解码）

  • String(byte[])：通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String
  • String(byte[]，int offset，int length)：用指定的字节数组的一部分，即从数组起始位置 offset 开始取 length 个字节构造一个字符串对象
  • String(byte[], String charsetName) 或 new String(byte[], int, int, String charsetName)：解码，按照指定的编码方式进行解码

代码示例：

@Test
public void test01() throws Exception {
    String str = "中国";
    System.out.println(str.getBytes("ISO8859-1").length); // 2
    // ISO8859-1 把所有的字符都当做一个 byte 处理，处理不了多个字节
    System.out.println(str.getBytes("GBK").length); // 4 每一个中文都是对应 2 个字节
    System.out.println(str.getBytes("UTF-8").length); // 6 常规的中文都是 3 个字节
 
    /*
     * 不乱码：1. 保证编码与解码的字符集名称一样 2. 不缺字节
     */
    System.out.println(new String(str.getBytes("ISO8859-1"), "ISO8859-1")); // 乱码
    System.out.println(new String(str.getBytes("GBK"), "GBK")); // 中国
    System.out.println(new String(str.getBytes("UTF-8"), "UTF-8")); // 中国
}

常用方法

boolean isEmpty() // 字符串是否为空
 
int length() // 返回字符串的长度，字符数
 
String concat(xx) // 拼接
 
boolean equals(Object obj) // 比较字符串是否相等，区分大小写
 
boolean equalsIgnoreCase(Object obj) // 比较字符串是否相等，不区分大小写
 
int compareTo(String other) // 比较字符串大小，区分大小写，按照 Unicode 编码值比较大小（字典序）
 
int compareToIgnoreCase(String other) // 比较字符串大小，不区分大小写
 
String toLowerCase() // 将字符串中大写字母转为小写
 
String toUpperCase() // 将字符串中小写字母转为大写
 
String trim() // 去掉字符串前后空白符
 
public String intern() // 结果在常量池中共享

查找

boolean contains(xx) // 是否包含 xx
 
int indexOf(xx)
// 从前往后找当前字符串中 xx，如果有返回第一次出现的下标，要是没有返回 -1
 
int indexOf(String str, int fromIndex)
// 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始找
 
int lastIndexOf(xx) // 从后往前找
 
int lastIndexOf(String str, int fromIndex)：// 从后往前找，从最后找到指定位置止

字符串截取

String substring(int beginIndex)
// 返回一个新的字符串，它是此字符串的从 beginIndex 开始截取到最后的一个子字符串
 
String substring(int beginIndex, int endIndex)
// 返回一个新字符串，它是此字符串从 beginIndex 开始截取到 endIndex（不包含）的一个子字符串
// 包头不包尾

和字符/字符数组相关

char charAt(index) // 返回 [index] 位置的字符
 
char[] toCharArray() // 将此字符串转换为一个新的字符数组返回
 
static String valueOf(char[] data) // 返回指定数组中表示该字符序列的 String
 
static String valueOf(char[] data, int offset, int count)
// 返回指定数组中表示该字符序列的 String
 
static String copyValueOf(char[] data) // 返回指定数组中表示该字符序列的 String
 
static String copyValueOf(char[] data, int offset, int count)
// 返回指定数组中表示该字符序列的 String

开头与结尾

boolean startsWith(xx) // 测试此字符串是否以指定的前缀开始
 
boolean startsWith(String prefix, int toffset)
// 测试此字符串从指定索引开始的子字符串是否以指定前缀开始
 
boolean endsWith(xx) // 测试此字符串是否以指定的后缀结束

替换

String replace(char oldChar, char newChar)
// 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
// 不支持正则
 
String replace(CharSequence target, CharSequence replacement)
// 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串
 
String replaceAll(String regex, String replacement)
// 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
 
String replaceFirst(String regex, String replacement)
// 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串

相比之下：JavaScript 的正则字面量太好用了、太优雅了

字符串相关类之可变字符序列：StringBuffer、StringBuilder

因为 String 对象是不可变对象，虽然可以共享常量对象，但是对于频繁字符串的修改和拼接操作，效率极低，空间消耗也比较高。因此，JDK 又在 java.lang 包提供了可变字符序列 StringBuffer 和 StringBuilder 类型。

StringBuffer 与 StringBuilder 的理解

java.lang.StringBuffer 代表可变的字符序列，JDK1.0 中声明，可以对字符串内容进行增删，此时不会产生新的对象。比如：

// 情况 1：
String s = new String("我喜欢学习");
 
// 情况 2：
StringBuffer buffer = new StringBuffer("我喜欢学习");
buffer.append("数学");

原理：底层是一个可变长字符数组

继承结构：

StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且提供相关功能的方法也一样。

区分 String、StringBuffer、StringBuilder

  • String：不可变的字符序列； 底层使用 char[] 数组存储
  • StringBuffer：可变的字符序列；线程安全（方法有 synchronized 修饰），效率低；底层使用 char[] 数组存储
  • StringBuilder：可变的字符序列； JDK1.5 引入，线程不安全的，效率高；底层使用 char[] 数组存储
  • JDK9 以前：底层使用 char[]；JDK9 以后：底层使用 byte[]

StringBuilder、StringBuffer 的 API

StringBuilder、StringBuffer 的 API 是完全一致的，并且很多方法与 String 相同。

StringBuffer append(xx) // 提供了很多的 append() 方法，用于进行字符串追加的方式拼接
 
StringBuffer delete(int start, int end) // 删除 [start, end) 之间字符
 
StringBuffer deleteCharAt(int index) // 删除 [index] 位置字符
 
StringBuffer replace(int start, int end, String str)
// 替换 [start, end) 范围的字符序列为 str
 
void setCharAt(int index, char c) // 替换 [index] 位置字符
 
char charAt(int index) // 查找指定 [index] 位置上的字符
 
StringBuffer insert(int index, xx) // 在 [index] 位置插入 xx
 
int length() // 返回存储的字符数据的长度
 
StringBuffer reverse() // 反转
 
int indexOf(String str) // 在当前字符序列中查询 str 的第一次出现下标，没有返回 -1
 
int indexOf(String str, int fromIndex)
 
int lastIndexOf(String str)
 
int lastIndexOf(String str, int fromIndex)
 
String substring(int start) // 截取当前字符序列 [start, 最后]
 
String substring(int start, int end) // 截取当前字符序列 [start, end)
 
String toString() // 返回此序列中数据的字符串表示形式
 
void setLength(int newLength) // 设置当前字符序列长度为 newLength

效率测试

// 初始设置
long startTime = 0L;
long endTime = 0L;
String text = "";
StringBuffer buffer = new StringBuffer("");
StringBuilder builder = new StringBuilder("");
 
// 开始对比
startTime = System.currentTimeMillis();
for (int i = 0; i < 20000; i++) {
    buffer.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuffer 的执行时间：" + (endTime - startTime));
 
startTime = System.currentTimeMillis();
for (int i = 0; i < 20000; i++) {
    builder.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuilder 的执行时间：" + (endTime - startTime));
 
startTime = System.currentTimeMillis();
for (int i = 0; i < 20000; i++) {
    text = text + i;
}
endTime = System.currentTimeMillis();
System.out.println("String 的执行时间：" + (endTime - startTime));
StringBuffer 的执行时间：118  
StringBuilder 的执行时间：119  
String 的执行时间：309

题目

String str = null;
StringBuffer sb = new StringBuffer();
sb.append(str);
 
System.out.println(sb.length()); // 4
System.out.println(sb); // "null"
 
StringBuffer sb1 = new StringBuffer(str);
System.out.println(sb1); // Exception Cannot invoke "String.length()" because "str" is null

JDK8 之前：日期时间 API

java.lang.System 类的方法

System 类提供的 public static long currentTimeMillis()：用来返回当前时间与 1970 年 1 月 1 日 0 时 0 分 0 秒之间以毫秒为单位的时间差——时间戳

计算世界时间的主要标准有：

  • UTC(Coordinated Universal Time)
  • GMT(Greenwich Mean Time)
  • CST(Central Standard Time)

在国际无线电通信场合，为了统一起见，使用一个统一的时间，称为通用协调时（UTC, Universal Time Coordinated）。UTC 与格林尼治平均时（GMT, Greenwich Mean Time）一样，都与英国伦敦的本地时相同。这里，UTC 与 GMT 含义完全相同。

java.util.Date

表示特定的瞬间，精确到毫秒。

构造器：

  • Date()：使用无参构造器创建的对象可以获取本地当前时间
  • Date(long 时间戳)：把该毫秒值换算成日期时间对象

常用方法：

  • getTime(): 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数
  • toString(): 把此 Date 对象转换为以下形式的 String
    • dow mon dd hh:mm:ss zzz yyyy，其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)，zzz 是时间标准。
  • 其它很多方法都过时了。

java.text.SimpleDateFormat

java.text.SimpleDateFormat 类是一个不与语言环境有关的方式来格式化和解析日期的具体类。

  • 可以进行格式化：日期 -> 文本
  • 可以进行解析：文本 -> 日期

构造器：

  • SimpleDateFormat()：默认的模式和语言环境创建对象
  • SimpleDateFormat(String pattern)：该构造方法可以用参数 pattern 指定的格式创建一个对象

格式化：

  • public String format(Date date)：格式化时间对象 date

解析：

  • public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期

java.util.Calendar（日历）

Date 类的 API 大部分被废弃了，替换为 Calendar

Calendar 类是一个抽象类，主用用于完成日期字段之间相互操作的功能。

获取 Calendar 实例的方法：

  • 使用 Calendar.getInstance() 方法
  • 调用它的子类 GregorianCalendar（公历）的构造器

一个 Calendar 的实例是系统时间的抽象表示，可以修改或获取 YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY、MINUTE、SECOND 等日历字段对应的时间值。

  • public int get(int field)：返回给定日历字段的值
  • public void set(int field, int value)：将给定的日历字段设置为指定的值
  • public void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或者减去指定的时间量
  • public final Date getTime()：将 Calendar 转成 Date 对象
  • public final void setTime(Date date)：使用指定的 Date 对象重置 Calendar 的时间

常用字段：

字段值含义
YEAR年
MONTH月（从 0 开始）
DAY_OF_MONTH月中的天（几号）
HOUR时（12 小时制）
HOUR_OF_DAY时（24 小时制）
MINUTE分
SECOND秒
DAY_OF_WEEK周中的天（星期几，周日为 1）
  • 月份：一月是 0、二月是 1、……、十二月是 11
  • 星期：周日是 1、周一是 2 、……、周六是 7

JDK8：新的日期时间 API

如果我们可以跟别人说：“我们在 1502643933071 见面，别晚了！”那么就再简单不过了。但是我们希望时间与昼夜和四季有关，于是事情就变复杂了。JDK 1.0 中包含了一个 java.util.Date 类，但是它的大多数方法已经在 JDK 1.1 引入 Calendar 类之后被弃用了。而 Calendar 并不比 Date 好多少。它们面临的问题是：

  • 可变性：像日期和时间这样的类应该是不可变的。
  • 偏移性：Date 中的年份是从 1900 开始的，而月份都从 0 开始。
  • 格式化：格式化只对 Date 有用，Calendar 则不行。
  • 此外，它们也不是线程安全的；不能处理闰秒等。

闰秒，是指为保持协调世界时接近于世界时时刻，由国际计量局统一规定在年底或年中（也可能在季末）对协调世界时增加或减少 1 秒的调整。由于地球自转的不均匀性和长期变慢性（主要由潮汐摩擦引起的），会使世界时（民用时）和原子时之间相差超过到 ±0.9 秒时，就把协调世界时向前拨 1 秒（负闰秒，最后一分钟为 59 秒）或向后拨 1 秒（正闰秒，最后一分钟为 61 秒）；闰秒一般加在公历年末或公历六月末。

目前，全球已经进行了 27 次闰秒，均为正闰秒。

综上：对日期和时间的操作一直是 Java 程序员最痛苦的地方之一。

第三次引入的 API 是成功的，并且 Java 8 中引入的 java.time API 已经纠正了过去的缺陷，将来很长一段时间内它都会为我们服务。

Java 8 以一个新的开始为 Java 创建优秀的 API。新的日期时间 API 包含：

  • java.time：包含值对象的基础包
  • java.time.chrono：提供对不同的日历系统的访问
  • java.time.format：格式化和解析时间和日期
  • java.time.temporal：包括底层框架和扩展特性
  • java.time.zone：包含时区支持的类

说明：新的 java.time 中包含了所有关于时钟（Clock）、本地日期（LocalDate）、本地时间（LocalTime）、本地日期时间（LocalDateTime）、时区（ZonedDateTime）和持续时间（Duration）的类。

尽管有 68 个新的公开类型，但是大多数开发者只会用到基础包和 format 包，大概占总数的三分之一。

本地日期时间：LocalDate、LocalTime、LocalDateTime

方法描述
now() / now(ZoneId zone)静态方法，根据当前时间创建对象/指定时区的对象
of(xx, xx, xx, xx, xx, xxx)静态方法，根据指定日期/时间创建对象
getDayOfMonth()获得月份天数（1-31）
getDayOfYear()获得年份天数（1-366）
getDayOfWeek()获得星期几（返回一个 DayOfWeek 枚举值）
getMonth()获得月份, 返回一个 Month 枚举值
getMonthValue()获得月份（1-12）
getYear()获得年份
getHours() / getMinute() / getSecond()获得当前对象对应的时、分、秒
withDayOfMonth() / withDayOfYear() / withMonth() / withYear()将月份天数、年份天数、月份、年份修改为指定的值并返回新的对象
with(TemporalAdjuster t)将当前日期时间设置为校对器指定的日期时间
plusDays() / plusWeeks() / plusMonths() / plusYears() /plusHours()))向当前对象添加几天、几周、几个月、几年、几小时
minusMonths() / minusWeeks() / minusDays() / minusYears() / minusHours()从当前对象减去几月、几周、几天、几年、几小时
plus(TemporalAmount t) / minus(TemporalAmount t)添加或减少一个 Duration 或 Period
isBefore() / isAfter()比较两个 LocalDate
isLeapYear()判断是否是闰年（在 LocalDate 类中声明））
format(DateTimeFormatter t)格式化本地日期、时间，返回一个字符串
parse(Charsequence text)将指定格式的字符串解析为日期、时间

瞬时：Instant

Instant：时间线上的一个瞬时点。 这可能被用来记录应用程序中的事件时间戳。

时间戳是指格林威治时间 1970 年 01 月 01 日 00 时 00 分 00 秒（北京时间 1970 年 01 月 01 日 08 时 00 分 00 秒）起至现在的总秒数。

java.time.Instant 表示时间线上的一点，而不需要任何上下文信息，例如，时区。概念上讲，它只是简单的表示自 1970 年 1 月 1 日 0 时 0 分 0 秒（UTC）开始的秒数。

方法描述
now()静态方法，返回默认 UTC 时区的 Instant 类的对象
ofEpochMilli(long epochMilli)静态方法，返回在 1970-01-01 00:00:00基础上加上指定毫秒数之后的 Instant 类的对象
atOffset(ZoneOffset offset)结合即时的偏移来创建一个 OffsetDateTime
toEpochMilli()返回 1970-01-01 00:00:00 到当前时间的毫秒数，即为时间戳

中国大陆、中国香港、中国澳门、中国台湾、蒙古国、新加坡、马来西亚、菲律宾、西澳大利亚州的时间与 UTC 的时差均为 +8，也就是 UTC+8：instant.atOffset(ZoneOffset.ofHours(8));

整个地球分为二十四时区，每个时区都有自己的本地时间。北京时区是东八区，领先 UTC 八个小时，在电子邮件信头的 Date 域记为 +0800。如果在电子邮件的信头中有这么一行：

Date: Fri, 08 Nov 2002 09:42:22 +0800

说明信件的发送地的地方时间是二○○二年十一月八号，星期五，早上九点四十二分（二十二秒），这个地方的本地时领先 UTC 八个小时(+0800， 就是东八区时间)。电子邮件信头的 Date 域使用二十四小时的时钟，而不使用 AM 和 PM 来标记上下午。

日期时间格式化：DateTimeFormatter

该类提供了三种格式化方法：

  1. （了解）预定义的标准格式。如：ISO_LOCAL_DATE_TIME、ISO_LOCAL_DATE、ISO_LOCAL_TIME
  2. （了解）本地化相关的格式。如：ofLocalizedDate(FormatStyle.LONG)
// 本地化相关的格式。如：ofLocalizedDateTime()
// FormatStyle.MEDIUM / FormatStyle.SHORT: 适用于 LocalDateTime
 
// 本地化相关的格式。如：ofLocalizedDate()
// FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT: 适用于 LocalDate
  1. 自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
方 法描 述
ofPattern(String pattern)静态方法，返回一个指定字符串格式的 DateTimeFormatter
format(TemporalAccessor t)格式化一个日期、时间，返回字符串
parse(CharSequence text)将指定格式的字符序列解析为一个日期、时间

举例：

import org.junit.Test;
 
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
 
public class TestDatetimeFormatter {
    @Test
    public void test1() {
        // 方式一：预定义的标准格式。
        // 如：ISO_LOCAL_DATE_TIME; ISO_LOCAL_DATE; ISO_LOCAL_TIME
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
 
        // 格式化：日期 -> 字符串
        LocalDateTime localDateTime = LocalDateTime.now();
        String str1 = formatter.format(localDateTime);
        System.out.println(localDateTime);
        System.out.println(str1); // 2022-12-04T21:02:14.808
 
        // 解析：字符串 -> 日期
        TemporalAccessor parse = formatter.parse("2022-12-04T21:02:14.808");
        LocalDateTime dateTime = LocalDateTime.from(parse);
        System.out.println(dateTime);
    }
 
    @Test
    public void test2() {
        LocalDateTime localDateTime = LocalDateTime.now();
        // 方式二：本地化相关的格式。如：ofLocalizedDateTime()
        // FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT: 适用于LocalDateTime
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
        
        // 格式化
        String str2 = formatter1.format(localDateTime);
        System.out.println(str2); // 2022年12月4日 下午09时03分55秒
 
        // 本地化相关的格式。如：ofLocalizedDate()
        // FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT: 适用于 LocalDate
        DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
        // 格式化
        String str3 = formatter2.format(LocalDate.now());
        System.out.println(str3); // 2022年12月4日 星期日
    }
 
    @Test
    public void test3() {
        // 方式三：自定义的方式（关注、重点）
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
        // 格式化
        String strDateTime = dateTimeFormatter.format(LocalDateTime.now());
        System.out.println(strDateTime); // 2022/12/04 21:05:42
        // 解析
        TemporalAccessor accessor = dateTimeFormatter.parse("2022/12/04 21:05:42");
        LocalDateTime localDateTime = LocalDateTime.from(accessor);
        System.out.println(localDateTime); // 2022-12-04T21:05:42
    }
}

其它 API

指定时区日期时间 ：ZondId 和 ZonedDateTime

  • ZoneId：该类中包含了所有的时区信息，一个时区的 ID，如 Europe/Paris
  • ZonedDateTime：一个在 ISO-8601日历系统时区的日期时间，如 2007-12-03T10:15:30+01:00 Europe/Paris。
  • 其中每个时区都对应着 ID，地区 ID 都为“{区域}/{城市}”的格式，例如：Asia/Shanghai 等
  • 常见时区 ID：
    • Asia/Shanghai
    • UTC
    • America/New_York

获取所有可用的时区 ID：

import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Set;
 
public class TestZone {
    @Test
    public void test01() {
        // Set<String> 是一个集合，容器
        Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
        for (String availableZoneId : availableZoneIds) {
            System.out.println(availableZoneId);
        }
    }
 
    @Test
    public void test02() {
        ZonedDateTime t1 = ZonedDateTime.now();
        System.out.println(t1);
 
        ZonedDateTime t2 = ZonedDateTime.now(ZoneId.of("America/New_York"));
        System.out.println(t2);
    }
}

持续日期/时间 ：Period 和 Duration

  • 持续时间：Duration，用于计算两个“时间”间隔
  • 日期间隔：Period，用于计算两个“日期”间隔
import org.junit.Test;
 
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;
 
public class TestPeriodDuration {
    @Test
    public void test01() {
        LocalDate t1 = LocalDate.now();
        LocalDate t2 = LocalDate.of(2018, 12, 31);
        Period between = Period.between(t1, t2);
        System.out.println(between);
 
        System.out.println("相差的年数：" + between.getYears());
        System.out.println("相差的月数：" + between.getMonths());
        System.out.println("相差的天数：" + between.getDays());
        System.out.println("相差的总数：" + between.toTotalMonths());
    }
 
    @Test
    public void test02() {
        LocalDateTime t1 = LocalDateTime.now();
        LocalDateTime t2 = LocalDateTime.of(2017, 8, 29, 0, 0, 0, 0);
        Duration between = Duration.between(t1, t2);
        System.out.println(between);
 
        System.out.println("相差的总天数：" + between.toDays());
        System.out.println("相差的总小时数：" + between.toHours());
        System.out.println("相差的总分钟数：" + between.toMinutes());
        System.out.println("相差的总秒数：" + between.getSeconds());
        System.out.println("相差的总毫秒数：" + between.toMillis());
        System.out.println("相差的总纳秒数：" + between.toNanos());
        System.out.println("不够一秒的纳秒数：" + between.getNano());
    }
 
    @Test
    public void test03() {
        // Duration: 用于计算两个“时间”间隔，以秒和纳秒为基准
		LocalTime localTime = LocalTime.now();
		LocalTime localTime1 = LocalTime.of(15, 23, 32);
		// between(): 静态方法，返回 Duration 对象，表示两个时间的间隔
		Duration duration = Duration.between(localTime1, localTime);
		System.out.println(duration);
 
		System.out.println(duration.getSeconds());
		System.out.println(duration.getNano());
 
		LocalDateTime localDateTime = LocalDateTime.of(2016, 6, 12, 15, 23, 32);
		LocalDateTime localDateTime1 = LocalDateTime.of(2017, 6, 12, 15, 23, 32);
 
		Duration duration1 = Duration.between(localDateTime1, localDateTime);
		System.out.println(duration1.toDays());
    }
    
    @Test
    public void test4() {
        // Period: 用于计算两个“日期”间隔，以年、月、日衡量
		LocalDate localDate = LocalDate.now();
		LocalDate localDate1 = LocalDate.of(2028, 3, 18);
 
		Period period = Period.between(localDate, localDate1);
		System.out.println(period);
 
		System.out.println(period.getYears());
		System.out.println(period.getMonths());
		System.out.println(period.getDays());
 
		Period period1 = period.withYears(2);
		System.out.println(period1);
    }
}

Clock：使用时区提供对当前即时、日期和时间的访问的时钟。

TemporalAdjuster: 时间校正器

  • TemporalAdjuster: 时间校正器。有时我们可能需要获取例如：将日期调整到“下一个工作日”等操作。
  • TemporalAdjusters: 该类通过静态方法 firstDayOfXxx() / lastDayOfXxx() / nextXxx() 提供了大量的常用 TemporalAdjuster 的实现。
@Test
public void test1() {
    // TemporalAdjuster: 时间校正器
	// 获取当前日期的下一个周日是哪天？
	TemporalAdjuster temporalAdjuster = TemporalAdjusters.next(DayOfWeek.SUNDAY);
	LocalDateTime localDateTime = LocalDateTime.now().with(temporalAdjuster);
	System.out.println(localDateTime);
	// 获取下一个工作日是哪天？
	LocalDate localDate = LocalDate.now().with(new TemporalAdjuster() {
   	 	@Override
   	 	public Temporal adjustInto(Temporal temporal) {
        	LocalDate date = (LocalDate) temporal;
     	  	if (date.getDayOfWeek().equals(DayOfWeek.FRIDAY)) {
           		return date.plusDays(3);
        	} else if (date.getDayOfWeek().equals(DayOfWeek.SATURDAY)) {
            	return date.plusDays(2);
        	} else {
            	return date.plusDays(1);
        	}
    	}
	});
	System.out.println("下一个工作日是：" + localDate);
}

与传统日期处理的转换

类To 遗留类From 遗留类
java.time.Instant 与 java.util.DateDate.from(instant)date.toInstant()
java.time.Instant 与 java.sql.TimestampTimestamp.from(instant)timestamp.toInstant()
java.time.ZonedDateTime 与 java.util.GregorianCalendarGregorianCalendar.from(zonedDateTime)cal.toZonedDateTime()
java.time.LocalDate 与 java.sql.TimeDate.valueOf(localDate)date.toLocalDate()
java.time.LocalTime 与 java.sql.TimeDate.valueOf(localDate)date.toLocalTime()
java.time.LocalDateTime 与 java.sql.TimestampTimestamp.valueOf(localDateTime)timestamp.toLocalDateTime()
java.time.ZoneId 与 java.util.TimeZoneTimezone.getTimeZone(id)timeZone.toZoneId()
java.time.format.DateTimeFormatter 与 java.text.DateFormatformatter.toFormat()无

Java 比较器

我们知道基本数据类型的数据（除 boolean 类型外）需要比较大小的话，直接使用比较运算符即可，但是引用数据类型是不能直接使用比较运算符来比较大小的。那么，如何解决这个问题呢？

在 Java 中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题。

Java 实现对象排序的方式有两种：

  • 自然排序：java.lang.Comparable
  • 定制排序：java.util.Comparator

自然排序：java.lang.Comparable

Comparable 接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。

实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。如果当前对象 this 大于形参对象 obj，则返回正整数，如果当前对象 this 小于形参对象 obj，则返回负整数，如果当前对象 this 等于形参对象 obj，则返回零。

package java.lang;
 
public interface Comparable {
    int compareTo(Object obj);
}

实现 Comparable 接口的对象列表（和数组）可以通过 Collections.sort 或 Arrays.sort 进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2) == 0 与 e1.equals(e2) 具有相同的 boolean 值时，类 C 的自然排序才叫做与 equals 一致。建议（虽然不是必需的）最好使自然排序与 equals 一致`。

Comparable 的典型实现：（默认都是从小到大排列的）

  • String：按照字符串中字符的 Unicode 值进行比较
  • Character：按照字符的 Unicode 值来进行比较
  • 数值类型对应的包装类以及 BigInteger、BigDecimal：按照它们对应的数值大小进行比较
  • Boolean：true 对应的包装类实例大于 false 对应的包装类实例
  • Date、Time 等：后面的日期时间比前面的日期时间大

定制排序：java.util.Comparator

思考：

  • 当元素的类型没有实现 java.lang.Comparable 接口而又不方便修改代码（例如：一些第三方的类，你只有 .class 文件，没有源文件）
  • 如果一个类，实现了 Comparable 接口，也指定了两个对象的比较大小的规则，但是此时此刻我不想按照它预定义的方法比较大小，但是我又不能随意修改，因为会影响其他地方的使用，怎么办？

JDK 在设计类库之初，也考虑到这种情况，所以又增加了一个 java.util.Comparator 接口。强行对多个对象进行整体排序的比较。

  • 重写 compare(Object o1,Object o2) 方法，比较 o1 和 o2 的大小：如果方法返回正整数，则表示 o1 大于 o2；如果返回 0，表示相等；返回负整数，表示 o1 小于 o2。
  • 可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。
package java.util;
 
public interface Comparator {
    int compare(Object o1, Object o2);
}

系统相关类

java.lang.System 类

System 类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于 java.lang 包。

由于该类的构造器是 private 的，所以无法创建该类的对象。其内部的成员变量和成员方法都是 static 的，所以也可以很方便的进行调用。

  • 成员变量
    • System 类内部包含 in、out 和 err 三个成员变量，分别代表标准输入流（键盘输入），标准输出流（显示器）和标准错误输出流（显示器）。
    • 如：Scanner scan = new Scanner(System.in);
  • 成员方法
    • static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。常用于数组的插入和删除。
    • native long currentTimeMillis()：该方法的作用是返回当前的计算机时间，时间戳。
    • void exit(int status)：该方法的作用是退出程序。其中 status 的值为 0 代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
    • void gc()：该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。
    • String getProperty(String key)： 该方法的作用是获得系统中属性名为 key 的属性对应的值。系统中常见的属性名以及属性的作用如下表所示：
属性名属性说明
java.versionJava 运行时环境版本
java.homeJava 安装目录
os.name操作系统的名称
os.version操作系统的版本
user.name用户名
user.home用户家目录
user.dir用户的当前工作目录

java.lang.Runtime 类

每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。

public static Runtime getRuntime()
// 返回与当前 Java 应用程序相关的运行时对象。应用程序不能创建自己的 Runtime 类实例。
 
public long totalMemory()
// 返回 Java 虚拟机中初始化时的内存总量。
// 此方法返回的值可能随时间的推移而变化，这取决于主机环境。
// 默认为物理电脑内存的 1/64。
 
public long maxMemory()
// 返回 Java 虚拟机中最大程度能使用的内存总量。默认为物理电脑内存的 1/4。
 
public long freeMemory()
// 返回 Java 虚拟机中的空闲内存量。调用 gc 方法可能导致 freeMemory 返回值的增加。

和数学相关的类

java.lang.Math

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

public static double abs(double a) // 返回 double 值的绝对值。
 
public static double ceil(double a) // 返回大于等于参数的最小的整数。（天花板）
 
public static double floor(double a) // 返回小于等于参数最大的整数。（地板）
 
public static long round(double a) // 返回最接近参数的 long。（相当于四舍五入）
 
public static double pow(double a, double b) // a^b
 
public static double sqrt(double a) // 返回 a 的平方根
 
public static double random() // 返回 [0,1) 的随机值
 
public static final double PI // 返回圆周率
 
public static double max(double x, double y) // 返回 x, y 中的较大值
 
public static double min(double x, double y) // 返回 x, y 中的较小值
 
// 其它：acos、asin、atan、cos、sin、tan 三角函数

java.math 包

BigInteger

Integer 类作为 int 的包装类，能存储的最大整型值为 ，Long 类也是有限的，最大为 。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。

java.math 包的 BigInteger 可以表示不可变的任意精度的整数。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

// 构造器
BigInteger(String val) // 根据字符串构建 BigInteger 对象
 
// 方法
BigInteger abs()
 
BigInteger add(BigInteger val) // +
 
BigInteger subtract(BigInteger val) // -
 
BigInteger multiply`(BigInteger val) // *
 
BigInteger divide(BigInteger val) // /，只保留整数部分
 
BigInteger remainder(BigInteger val) // %
 
BigInteger[] divideAndRemainder`(BigInteger val)
// 返回包含 (this / val) 后跟 (this % val) 的两个 BigInteger 的数组。
 
BigInteger pow(int exponent) // this ^ exponent

BigDecimal

一般的 Float 类和 Double 类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到 java.math.BigDecimal 类。

BigDecimal 类支持不可变的、任意精度的有符号十进制定点数。

// 构造器
public BigDecimal(double val)
 
public BigDecimal(String val) // 推荐
 
// 常用方法
public BigDecimal add(BigDecimal augend)
 
public BigDecimal subtract(BigDecimal subtrahend)
 
public BigDecimal multiply(BigDecimal multiplicand)
 
public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
// divisor 是除数
// scale 指明保留几位小数
// roundingMode 指明舍入模式
//     ROUND_UP: 向上加 1
//     ROUND_DOWN: 直接舍去
//     ROUND_HALF_UP: 四舍五入

java.util.Random

用于产生随机数

boolean nextBoolean() // 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 boolean 值
 
void nextBytes(byte[] bytes) // 生成随机字节并将其置于用户提供的 byte 数组中
 
double nextDouble() // 返回下一个伪随机数，它是取自此随机数生成器序列的、在 [0.0, 1.0) 之间均匀分布的 double 值
 
float nextFloat() // 返回下一个伪随机数，它是取自此随机数生成器序列的、在 [0.0, 1.0) 之间均匀分布的 float 值
 
double nextGaussian() // 返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的 double 值，其平均值是 0.0，标准差是 1.0
 
int nextInt() // 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值
 
int nextInt(int n) // 返回一个伪随机数，它是取自此随机数生成器序列的、在 [0, 指定值) 之间均匀分布的 int 值
 
long nextLong() // 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值

反向链接

关系图谱