[Java核心技术] Java常用类

ieblYang 收录于 Java

2022-02-15 约 5387 字预计阅读 11 分钟次阅读

Java 核心技术读书笔记——Java常用类

1 Java类库概述

Java类库文档 https://docs.oracle.com/javase/8/docs/api/
包名以java开始的包是Java核心包（Java Core Package)
包名以javax开始的包是java扩展包（Java Extension Package）
java.lang包是每个类都默认调用的，可以不用import

2 数字相关类

2.1 Java数字类

整数 Short，Int，Long
浮点数 Float，Double

大数类 BigInteger（大整数），BigDecimal（大浮点数）

BigInteger 支持无限大的整数运算

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


import java.math.BigInteger;

public class BigIntegerTest {

  public static void main(String[] args) {
    BigInteger b1 = new BigInteger("123456789"); // 声明BigInteger对象
    BigInteger b2 = new BigInteger("987654321"); // 声明BigInteger对象
    System.out.println("b1: " + b1 +  ", b2:" + b2);
    System.out.println("加法操作：" + b2.add(b1)); // 加法操作
    System.out.println("减法操作：" + b2.subtract(b1)); // 减法操作
    System.out.println("乘法操作：" + b2.multiply(b1)); // 乘法操作
    System.out.println("除法操作：" + b2.divide(b1)); // 除法操作
    System.out.println("最大数：" + b2.max(b1)); // 求出最大数
    System.out.println("最小数：" + b2.min(b1)); // 求出最小数
    BigInteger result[] = b2.divideAndRemainder(b1); // 求出余数的除法操作
    System.out.println("商是：" + result[0] + "；余数是：" + result[1]);
    System.out.println("等价性是：" + b1.equals(b2));
    int flag = b1.compareTo(b2);
    if (flag == -1)
      System.out.println("比较操作: b1<b2");
    else if (flag == 0)
      System.out.println("比较操作: b1==b2");
    else
      System.out.println("比较操作: b1>b2");

  }
}

BigDecimal支持无线大的小数运算

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


import java.math.BigDecimal;
import java.math.BigInteger;

public class BigDecimalTest {
  public static void main(String[] args) {
    BigDecimal b1 = new BigDecimal("123456789.987654321"); // 声明BigDecimal对象
    BigDecimal b2 = new BigDecimal("987654321.123456789"); // 声明BigDecimal对象
    System.out.println("b1: " + b1 +  ", b2:" + b2);
    System.out.println("加法操作：" + b2.add(b1)); // 加法操作
    System.out.println("减法操作：" + b2.subtract(b1)); // 减法操作
    System.out.println("乘法操作：" + b2.multiply(b1)); // 乘法操作
    //需要指定位数，防止无限循环，或者包含在try-catch中
    System.out.println("除法操作：" + b2.divide(b1,10,BigDecimal.ROUND_HALF_UP)); // 除法操作

    System.out.println("最大数：" + b2.max(b1)); // 求出最大数
    System.out.println("最小数：" + b2.min(b1)); // 求出最小数

    int flag = b1.compareTo(b2);
    if (flag == -1)
      System.out.println("比较操作: b1<b2");
    else if (flag == 0)
      System.out.println("比较操作: b1==b2");
    else
      System.out.println("比较操作: b1>b2");

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

    //尽量采用字符串赋值
    System.out.println(new BigDecimal("2.3"));
    System.out.println(new BigDecimal(2.3));

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

    BigDecimal num1 = new BigDecimal("10");
    BigDecimal num2 = new BigDecimal("3");
    //需要指定位数，防止无限循环，或者包含在try-catch中
    BigDecimal num3 = num1.divide(num2, 3, BigDecimal.ROUND_HALF_UP);
    System.out.println(num3);
  }
}

随机数类 Random

nextInt() 返回一个随机int
nextInt(int a) 返回一个[0,a)之间的随机int
nextDouble() 返回一个[0.0,1.0]之间double
ints方法批量返回随机数数组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


import java.util.Random;

public class RandomTest {

  public static void main(String[] args) 
  {
    //第一种办法，采用Random类 随机生成在int范围内的随机数
    Random rd = new Random();
    System.out.println(rd.nextInt());
    System.out.println(rd.nextInt(100)); //0--100的随机数
    System.out.println(rd.nextLong());
    System.out.println(rd.nextDouble());    
    System.out.println("=========================");

    //第二种，生成一个范围内的随机数 例如0到时10之间的随机数
    //Math.random[0,1)
    System.out.println(Math.round(Math.random()*10));
    System.out.println("=========================");


    //JDK 8 新增方法
    rd.ints();  //返回无限个int类型范围内的数据
    int[] arr = rd.ints(10).toArray();  //生成10个int范围类的个数。
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
    System.out.println("=========================");

    arr = rd.ints(5, 10, 100).toArray();
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }

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

    arr = rd.ints(10).limit(5).toArray();
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
  }
}

2.2 工具类 `Math`

绝对值函数abs
对数函数log
比较函数max、min
幂函数pow
四舍五入函数round等
向下取整floor
向上取整ceil

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public class MathTest {
  public static void main(String[] args) {
    
    System.out.println(Math.abs(-5));    //绝对值
    System.out.println(Math.max(-5,-8)); //最大值
    System.out.println(Math.pow(-5,2));  //求幂
    System.out.println(Math.round(3.5)); //四舍五入
    System.out.println(Math.ceil(3.5));  //向上取整
    System.out.println(Math.floor(3.5)); //向下取整
  }
}

3 字符串相关类

3.1 String

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38



public class StringTest {

  public static void main(String[] args) {
    String a = "123;456;789;123 ";
    System.out.println(a.charAt(0)); // 返回第0个元素
    System.out.println(a.indexOf(";")); // 返回第一个;的位置
    System.out.println(a.concat(";000")); // 连接一个新字符串并返回，a不变
    System.out.println(a.contains("000")); // 判断a是否包含000
    System.out.println(a.endsWith("000")); // 判断a是否以000结尾
    System.out.println(a.equals("000")); // 判断是否等于000
    System.out.println(a.equalsIgnoreCase("000"));// 判断在忽略大小写情况下是否等于000
    System.out.println(a.length()); // 返回a长度
    System.out.println(a.trim()); // 返回a去除前后空格后的字符串，a不变
    String[] b = a.split(";"); // 将a字符串按照;分割成数组
    for (int i = 0; i < b.length; i++) {
      System.out.println(b[i]);
    }

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

    System.out.println(a.substring(2, 5)); // 截取a的第2个到第5个字符 a不变
    System.out.println(a.replace("1", "a"));
    System.out.println(a.replaceAll("1", "a")); // replaceAll第一个参数是正则表达式

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

    String s1 = "12345?6789";
    String s2 = s1.replace("?", "a");
    String s3 = s1.replaceAll("[?]", "a");
    // 这里的[?] 才表示字符问号，这样才能正常替换。不然在正则中会有特殊的意义就会报异常
    System.out.println(s2);
    System.out.println(s3);
    System.out.println(s1.replaceAll("[\\d]", "a")); //将s1内所有数字替换为a并输出，s1的值未改变。

  }
}

3.2 可变字符串

StringBuffer 字符串加减，同步，性能好

StringBuilder 字符串加减，不同步，性能更好

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public class StringBufferReferenceTest {

  public static void main(String[] args) {
    StringBuffer sb1 = new StringBuffer("123");
    StringBuffer sb2 = sb1;

    sb1.append("12345678901234567890123456789012345678901234567890");
    System.out.println(sb2);  //sb1 和 sb2还是指向同一个内存的
  }
}

StringBuffer/StringBuilder 方法一样，区别在同步

append/insert/delete/replace/substring
length字符串实际大小

capacity 字符串占用空间大小

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


public class StringBufferCapacityTest {

  public static void main(String[] args) {
    //StringBuffer的的初始大小为（16+初始字符串长度）即capacity=16+初始字符串长度
    //length 实际长度  capacity 存储空间大小
    StringBuffer sb1 = new StringBuffer();
    System.out.println("sb1 length: " + sb1.length());
    System.out.println("sb1 capacity: " + sb1.capacity());
    System.out.println("=====================");

    StringBuffer sb2 = new StringBuffer("123");
    sb2.append("456");
    System.out.println("sb2 length: " + sb2.length());
    System.out.println("sb2 capacity: " + sb2.capacity());
    System.out.println("=====================");

    sb2.append("7890123456789");
    System.out.println("sb2 length: " + sb2.length());
    System.out.println("sb2 capacity: " + sb2.capacity());
    System.out.println("=====================");

    sb2.append("0");
    System.out.println("sb2 length: " + sb2.length());
    System.out.println("sb2 capacity: " + sb2.capacity());
    //一旦length大于capacity时，capacity便在前一次的基础上加1后翻倍；
    System.out.println("=====================");

    //当前sb2length 20   capacity 40， 再append 70个字符 超过(加1再2倍数额)
    sb2.append("1234567890123456789012345678901234567890123456789012345678901234567890");
    System.out.println("sb2 length: " + sb2.length());
    System.out.println("sb2 capacity: " + sb2.capacity());
    //如果append的对象很长，超过(加1再2倍数额)，将以最新的长度更换

    System.out.println("=====================");
    sb2.append("0");
    System.out.println("sb2 length: " + sb2.length());
    System.out.println("sb2 capacity: " + sb2.capacity());
    sb2.trimToSize();
    System.out.println("=====after trime================");
    System.out.println("sb2 length: " + sb2.length());
    System.out.println("sb2 capacity: " + sb2.capacity());
  }
}

trimToSize() 去除空隙，将字符串压缩到实际大小

4 时间相关类

`java.util.Date`

基本废弃，Deprecated
getTime()，返回自1970.1.1以来的毫秒数

`java.sql.Date`

和数据库对应的时间类

`Calendar`

目前程序中最常用，但是是抽象类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


import java.util.Calendar;
import java.util.GregorianCalendar;

public class CalendarClassTest {

  public static void main(String[] args) {
    Calendar gc = Calendar.getInstance();
    System.out.println(gc.getClass().getName());  //java.util.GregorianCalendar
    //Calendar.getInstance();返回的是GregorianCalendar对象
    
    GregorianCalendar gc2 = new GregorianCalendar();
    System.out.println(gc2.getClass().getName()); //java.util.GregorianCalendar
  }
}

`get(Field)`

获取时间中每个属性的值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// 获取年
int year = calendar.get(Calendar.YEAR);
// 获取月，这里需要需要月份的范围为0~11，因此获取月份的时候需要+1才是当前月份值
int month = calendar.get(Calendar.MONTH) + 1;
// 获取日
int day = calendar.get(Calendar.DAY_OF_MONTH);

// 获取时
int hour = calendar.get(Calendar.HOUR);
// int hour = calendar.get(Calendar.HOUR_OF_DAY); // 24小时表示
// 获取分
int minute = calendar.get(Calendar.MINUTE);
// 获取秒
int second = calendar.get(Calendar.SECOND);

// 星期，英语国家星期从星期日开始计算
int weekday = calendar.get(Calendar.DAY_OF_WEEK);

`getTime()`

返回相应的Date对象

`getTimeInMillis()`

返回自1970.1.1以来毫秒数

`set(Field)`

设置时间字段

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


calendar.set(Calendar.YEAR, 2022);
System.out.println("现在是" + calendar.get(Calendar.YEAR) + "年");  //现在是2022年

calendar.set(2022, 0, 1);
// 获取年
int year = calendar.get(Calendar.YEAR);
// 获取月
int month = calendar.get(Calendar.MONTH)+1;
// 获取日
int day = calendar.get(Calendar.DAY_OF_MONTH);

System.out.println("现在是" + year + "年" + month + "月" + day + "日"); //现在是2022年2月1日

`add(field,amount)`

根据指定字段增加/减少时间

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12



// 同理换成下个月的今天calendar.add(Calendar.MONTH, 1);
calendar.add(Calendar.YEAR, 1);

// 获取年
int year = calendar.get(Calendar.YEAR);
// 获取月
int month = calendar.get(Calendar.MONTH) + 1;
// 获取日
int day = calendar.get(Calendar.DAY_OF_MONTH);

System.out.println("一年后的今天：" + year + "年" + month + "月" + day + "日");

`roll(field,amount)`

根据指定字段增加/减少时间，只影响当前字段，不影响进位。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


//add和roll的区别
public void test() {     

    calendar.set(2022, 0, 1);
    calendar.add(Calendar.DAY_OF_MONTH, -1);
    
    // 获取年
    int year = calendar.get(Calendar.YEAR);
    // 获取月
    int month = calendar.get(Calendar.MONTH)+1;
    // 获取日
    int day = calendar.get(Calendar.DAY_OF_MONTH);

    System.out.println("2022.1.1, 用add减少1天，现在是" + year + "." + month + "." + day);
    //2022.1.1, 用add减少1天，现在是2021.12.31

    
    calendar.set(2022, 0, 1);
    calendar.roll(Calendar.DAY_OF_MONTH, -1);
    
    // 获取年
    year = calendar.get(Calendar.YEAR);
    // 获取月
    month = calendar.get(Calendar.MONTH)+1;
    // 获取日
    day = calendar.get(Calendar.DAY_OF_MONTH);

    System.out.println("2022.1.1, 用roll减少1天，现在是" + year + "." + month + "." + day);
    //2022.1.1, 用roll减少1天，现在是2022.1.31
}

`java8` 新推出的时间API

java.time包（新的Java日期/时间API的基础包）
旧的设计不好（重名的类、线程不安全等）
新版本优点
- 不变性，在多线程环境下
- 遵循设计模式，设计得更好，可扩展性强

`java.time.chrono`

为非ISO的日历系统定义了一些泛化的API

`java.time.format`

格式化和解析日期时间对象的类

`java.time.temporal`

包含一些时态对象，可以用其找出相关日期/时间对象的某个特定日期或时间

`java.time.zone`

包含支持不同时区以及相关规则的类

`java.time.LocalDate`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


import java.time.LocalDate;
import java.time.Month;
import java.time.ZoneId;

public class LocalDateExample {

    public static void main(String[] args) {
 
        //当前时间
        LocalDate today = LocalDate.now();
        System.out.println("Current Date="+today);
 
        //根据指定时间创建LocalDate
        LocalDate firstDay_2022 = LocalDate.of(2022, Month.JANUARY, 1);
        System.out.println("Specific Date="+firstDay_2022);
 
        //给定错误时间参数，将报异常java.time.DateTimeException
        //LocalDate feb29_2014 = LocalDate.of(2014, Month.FEBRUARY, 29);
 
        //可以更改时区
        LocalDate todayBeijing = LocalDate.now(ZoneId.of("Asia/Shanghai"));
        System.out.println("Current Date in Shanghai="+todayBeijing);
 
        //从纪元日01/01/1970开始365天 
        LocalDate dateFromBase = LocalDate.ofEpochDay(365);
        System.out.println("365th day from base date= "+dateFromBase);
 
        //2022年的第100天 
        LocalDate hundredDay2022 = LocalDate.ofYearDay(20122, 100);
        System.out.println("100th day of 2022="+hundredDay2022);
    }
 
}

`java.time.LocalTime`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


import java.time.LocalTime;
import java.time.ZoneId;

public class LocalTimeExample {
 
    public static void main(String[] args) {
 
        //当前时间  时分秒 纳秒
        LocalTime time = LocalTime.now();
        System.out.println("Current Time="+time);
 
        //根据时分秒
        LocalTime specificTime = LocalTime.of(12,20,25,40);
        System.out.println("Specific Time of Day="+specificTime);
 
        //错误的时间参数 将报DateTimeException
        //LocalTime invalidTime = LocalTime.of(25,20);
 
        //上海时间
        LocalTime timeSH = LocalTime.now(ZoneId.of("Asia/Shanghai"));
        System.out.println("Current Time in SH="+timeSH);
 
        
        //一天当中第几秒
        LocalTime specificSecondTime = LocalTime.ofSecondOfDay(10000);
        System.out.println("10000th second time= "+specificSecondTime);
 
    }
 
}

`java.time.LocalDateTime`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;
import java.time.ZoneId;
import java.time.ZoneOffset;
 
public class LocalDateTimeExample {
 
    public static void main(String[] args) {
 
        //当前日期 时分秒
        LocalDateTime today = LocalDateTime.now();
        System.out.println("Current DateTime="+today);
 
        //根据日期， 时分秒来创建对象
        today = LocalDateTime.of(LocalDate.now(), LocalTime.now());
        System.out.println("Current DateTime="+today);
 
        //指定具体时间来创建对象
        LocalDateTime specificDate = LocalDateTime.of(2022, Month.JANUARY, 1, 10, 10, 30);
        System.out.println("Specific Date="+specificDate);
 
        //如时间不对，将报异常DateTimeException
        //LocalDateTime feb29_2022 = LocalDateTime.of(2022, Month.FEBRUARY, 28, 25,1,1);
        
        //上海时区
        LocalDateTime todayShanghai = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
        System.out.println("Current Date in Shanghai="+todayShanghai);
 
         
        //从01/01/1970 10000秒
        LocalDateTime dateFromBase = LocalDateTime.ofEpochSecond(10000, 0, ZoneOffset.UTC);
        System.out.println("10000th second time from 01/01/1970= "+dateFromBase); 
    } 
}

`java.time.Instant`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


import java.time.Duration;
import java.time.Instant;
import java.util.Date;
 
public class InstantExample {
 
    public static void main(String[] args) {
        //当前时间戳
        Instant timestamp = Instant.now();
        System.out.println("Current Timestamp = "+timestamp);
 
        //从毫秒数来创建时间戳
        Instant specificTime = Instant.ofEpochMilli(timestamp.toEpochMilli());
        System.out.println("Specific Time = "+specificTime);
 
        Date date = Date.from(timestamp); 
        System.out.println("current date = " + date);
    }
 
}

5 格式化相关类

`java.text`包`java.text.Format`的子类

`NumberFormat`：数字格式化，抽象类

DecimalFormat

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


DecimalFormat df1,df2;
         
System.out.println("整数部分为0的情况，0/#的区别");
// 整数部分为0 ， #认为整数不存在，可不写； 0认为没有，但至少写一位，写0
df1 = new DecimalFormat("#.00");
df2 = new DecimalFormat("0.00");
 
System.out.println(df1.format(0.1)); // .10  
System.out.println(df2.format(0.1)); // 0.10  
 
System.out.println("小数部分0/#的区别");
//#代表最多有几位，0代表必须有且只能有几位
df1 = new DecimalFormat("0.00");
df2 = new DecimalFormat("0.##");
 
System.out.println(df1.format(0.1)); // 0.10
System.out.println(df2.format(0.1)); // 0.1
 
System.out.println(df1.format(0.006)); // 0.01
System.out.println(df2.format(0.006)); // 0.01
 
System.out.println("整数部分有多位");
//0和#对整数部分多位时的处理是一致的 就是有几位写多少位
df1 = new DecimalFormat("0.00");
df2 = new DecimalFormat("#.00");
 
System.out.println(df1.format(2)); // 2.00
System.out.println(df2.format(2)); // 2.00
 
System.out.println(df1.format(20)); // 20.00
System.out.println(df2.format(20)); // 20.00
 
System.out.println(df1.format(200)); // 200.00
System.out.println(df2.format(200)); // 200.00

`MessageFOrmat`：字符串格式化

支持多个参数-值对位复制文本
支持变量的自定义格式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


import java.text.MessageFormat;

public class MessageFormatTest {

  public static void main(String[] args) {
    String message = "{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11}{12}{13}{14}{15}{16}";  
      
    Object[] array = new Object[]{"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q"};  
      
    String value = MessageFormat.format(message, array);  
      
    System.out.println(value);  //ABCDEFGHIJKLMNOPQ
    
    message = "oh, {0,number,#.##} is a good number";  
      
    array = new Object[]{new Double(3.1415)};  
      
    value = MessageFormat.format(message, array);  
      
    System.out.println(value);  //oh, 3.14 is a good number
  }
}

`DateFormat`：日期/时间格式化，抽象类

SimpleDateFormat 工厂模式
parse 将字符串格式化为时间对象
format 将时间对象格式化为字符串

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


String strDate = "2022-01-01 10:11:30.345" ;  
// 准备第一个模板，从字符串中提取出日期数字  
String pat1 = "yyyy-MM-dd HH:mm:ss.SSS" ;  
// 准备第二个模板，将提取后的日期数字变为指定的格式  
String pat2 = "yyyy年MM月dd日 HH时mm分ss秒SSS毫秒" ;  
SimpleDateFormat sdf1 = new SimpleDateFormat(pat1) ;        // 实例化模板对象  
SimpleDateFormat sdf2 = new SimpleDateFormat(pat2) ;        // 实例化模板对象  
Date d = null ;  
try{  
    d = sdf1.parse(strDate) ;   // 将给定的字符串中的日期提取出来  
}catch(Exception e){            // 如果提供的字符串格式有错误，则进行异常处理  
    e.printStackTrace() ;       // 打印异常信息  
}  
System.out.println(sdf2.format(d)) ;    // 将日期变为新的格式  

`java.time.format`包下

DateTimeFormatter

JDK8发布，线程安全（SimpleDateFormat线程不安全）
ofPattern：设定时间格式
parse 将字符串格式化为时间对象
format 将时间对象格式化为字符串

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


//将字符串转化为时间
String dateStr= "2022年01月01日";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
LocalDate date= LocalDate.parse(dateStr, formatter);
System.out.println(date.getYear() + "-" + date.getMonthValue() + "-" + date.getDayOfMonth());

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

//将日期转换为字符串输出
LocalDateTime now = LocalDateTime.now();
DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy年MM月dd日 hh:mm:ss");
String nowStr = now.format(format);
System.out.println(nowStr);

目录

[Java核心技术] Java常用类

1 Java类库概述

2 数字相关类

2.1 Java数字类

2.2 工具类 Math

3 字符串相关类

3.1 String

3.2 可变字符串

4 时间相关类

java.util.Date

java.sql.Date

Calendar

get(Field)

getTime()

getTimeInMillis()

set(Field)

add(field,amount)

roll(field,amount)

java8 新推出的时间API

java.time.chrono

java.time.format

java.time.temporal

java.time.zone

java.time.LocalDate

java.time.LocalTime

java.time.LocalDateTime

java.time.Instant