JAVA基本语法（2）

yuannaihe

已于 2023-02-20 21:56:02 修改

阅读量149

点赞数

分类专栏： JAVA 文章标签： java jvm 开发语言

于 2023-02-11 11:05:17 首次发布

本文链接：https://blog.csdn.net/weixin_44853907/article/details/128981304

版权

JAVA 专栏收录该内容

6 篇文章 1 订阅

订阅专栏

第二章.JAVA基本语法

2.7 日期工具类使用

2.7.1 时间戳概念

时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数，本质是一个long类型的整数，表示日期对象。

java 体系的时间戳是毫秒

import java.util.Date;
import java.util.Scanner;
public class Date1 {
    public static void main(String[] args) {
        long ss=System.currentTimeMillis();//执行前获得毫秒
        for (int i=0;i<10;i++){
            System.out.println(i);
        }
        long ee=System.currentTimeMillis();//执行后获得毫秒
        System.out.printf("ms:%d %n",ee-ss);//程序执行所运行的毫秒

        System.out.println(System.currentTimeMillis());//获取当前时间戳，一串数字
        System.out.printf("%tF %<tT%n" ,0L);
        System.out.printf("%tF %<tT%n" ,1675860448797L);//将时间戳转换成日期格式
    }
 运行结果：
0
1
2
3
4
5
6
7
8
9
ms:0 
1675863902655
1970-01-01 08:00:00
2023-02-08 20:47:28

2.7.2 java.util.Date

Date 类表示系统特定的时间戳，可以精确到毫秒。Date 对象表示时间的默认顺序是星期、月、日、小时、分、秒、年。

Date 类有如下两个构造方法。

Date()：此种形式表示分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒），使用该构造方法创建的对象可以获取本地的当前时间。
Date(long date)：此种形式表示从 GMT 时间（格林尼治时间）1970 年 1 月 1 日 0 时 0 分 0 秒开始经过参数 date 指定的毫秒数。

Date 类的无参数构造方法获取的是系统当前的时间，显示的顺序为星期、月、日、小时、分、秒、年。

Date 类带 long 类型参数的构造方法获取的是距离 GMT 指定毫秒数的时间，60000 毫秒是一分钟，而 GMT（格林尼治标准时间）与 CST（中央标准时间）相差 8 小时，也就是说 1970 年 1 月 1 日 00:00:00 GMT 与 1970 年 1 月 1 日 08:00:00 CST 表示的是同一时间。因此距离 1970 年 1 月 1 日 00:00:00 CST 一分钟的时间为 1970 年 1 月 1 日 00:01:00 CST，即使用 Date 对象表示为 Thu Jan 01 08:01:00 CST 1970。

方法	描述
boolean after(Date when)	判断此日期是否在指定日期之后
boolean before(Date when)	判断此日期是否在指定日期之前
int compareTo(Date anotherDate)	比较两个日期的顺序
boolean equals(Object obj)	比较两个日期的相等性
long getTime()	返回自 1970 年 1 月 1 日 00:00:00 GMT 以来，此 Date 对象表示的毫秒数
String toString()	把此 Date 对象转换为以下形式的 String: dow mon dd hh:mm:ss zzz yyyy。其中 dow 是一周中的某一天(Sun、Mon、Tue、Wed、Thu、Fri 及 Sat)

 //定义输出格式
SimpleDateFormat s=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//将字符串转化为日期
Date date=s.parse("2000-12-16 10:23:43");
System.out.println(date);

Date date1=new Date();
//将日期转化为字符串
SimpleDateFormat sss=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
String s1=sss.format(date1);
System.out.println(s1);

var now=new Date();//创建一个date对象，获取当前时间
//指定格式化格式
var f=new SimpleDateFormat("今天是"+"yyyy 年 MM 月 dd 日 E HH 点 mm 分 ss 秒");
System.out.println(f.format(now));//将当前时间格式化为指定的格式
运行结果：
Sat Dec 16 10:23:43 CST 2000
2023/02/08 21:58:06
今天是2023 年 02 月 08 日 周三 21 点 58 分 06 秒

import java.util.Date;
public class Date2 {
    public static void main(String[] args) {
        Date date=new Date();
        Date date1=new Date(System.currentTimeMillis());
        Date date2=new Date(1675860448797L);//过去的时间戳
        System.out.printf("%tF %<tT%n",date);
        System.out.printf("%tF %<tT%n",date1);
        System.out.printf("%tF %<tT%n",date2);
        //常用方法
        long now=date.getTime();
        date.setTime(now+(1000*60*60*24*10));//十天后的日期
        System.out.printf("%tF %<tT%n",date);//格式化输出

        //计算两个日期之间的天数 1989-10-15出生到目前生存的时间
        Date ss=new Date(1989-1900,10-1,15,20,30,50);
        long t1=ss.getTime();
        //System.out.printf("%tF %<tT%n",ss);
        long t2=System.currentTimeMillis();
        System.out.println((t2-t1)/(1000*60*60*24));

        //给一个日期，计算出前五天的日期，和后七天的日期
        Date aa=new Date(1989-1900,10-1,15,20,30,50);//1989-10-15
        long t3=aa.getTime();
        aa.setTime(t3+(1000*60*60*24*7));
        System.out.printf("%tF %<tT%n",aa);//七天后的日期
        aa.setTime(t3-(1000*60*60*24*5));
        System.out.printf("%tF %<tT%n",aa);//五天前的日期
    }
}
运行结果：
2023-02-08 21:59:49
2023-02-08 21:59:49
2023-02-08 20:47:28
2023-02-18 21:59:49
12169
1989-10-22 20:30:50
1989-10-10 20:30:50

2.7.3 java.util.Calendar

Calendar 类是一个抽象类，它为特定瞬间与 YEAR、MONTH、DAY_OF—MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（如获得下星期的日期）提供了一些方法。创建 Calendar 对象不能使用 new 关键字，因为 Calendar 类是一个抽象类，但是它提供了一个 getInstance() 方法来获得 Calendar类的对象。getInstance() 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化。

Calendar c = Calendar.getInstance();

当创建了一个 Calendar 对象后，就可以通过 Calendar 对象中的一些方法来处理日期、时间。 Calendar 类的常用方法如表 2 所示。

方法	描述
void add(int field, int amount)	根据日历的规则，为给定的日历字段 field 添加或减去指定的时间量 amount
boolean after(Object when)	判断此 Calendar 表示的时间是否在指定时间 when 之后，并返回判断结果
boolean before(Object when)	判断此 Calendar 表示的时间是否在指定时间 when 之前，并返回判断结果
void clear()	清空 Calendar 中的日期时间值
int compareTo(Calendar anotherCalendar)	比较两个 Calendar 对象表示的时间值（从格林威治时间 1970 年 01 月 01 日 00 时 00 分 00 秒至现在的毫秒偏移量），大则返回 1，小则返回 -1，相等返回 0
int get(int field)	返回指定日历字段的值
int getActualMaximum(int field)	返回指定日历字段可能拥有的最大值
int getActualMinimum(int field)	返回指定日历字段可能拥有的最小值
int getFirstDayOfWeek()	获取一星期的第一天。根据不同的国家地区，返回不同的值
static Calendar getInstance()	使用默认时区和语言坏境获得一个日历
static Calendar getInstance(TimeZone zone)	使用指定时区和默认语言环境获得一个日历
static Calendar getInstance(TimeZone zone, Locale aLocale)	使用指定时区和语言环境获得一个日历
Date getTime()	返回一个表示此 Calendar 时间值（从格林威治时间 1970 年 01 月 01 日 00 时 00 分 00 秒至现在的毫秒偏移量）的 Date 对象
long getTimeInMillis()	返回此 Calendar 的时间值，以毫秒为单位
void set(int field, int value)	为指定的日历字段设置给定值
void set(int year, int month, int date)	设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值
void set(int year, int month, int date, int hourOfDay, int minute, int second)	设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、 MINUTE 和 SECOND 的值
void setFirstDayOfWeek(int value)	设置一星期的第一天是哪一天
void setTimeInMillis(long millis)	用给定的 long 值设置此 Calendar 的当前时间值

Calendar 对象可以调用 set() 方法将日历翻到任何一个时间，当参数 year 取负数时表示公元前。Calendar 对象调用 get() 方法可以获取有关年、月、日等时间信息，参数 field 的有效值由 Calendar 静态常量指定。

Calendar 类中定义了许多常量，分别表示不同的意义。

Calendar.YEAR：年份。
Calendar.MONTH：月份。
Calendar.DATE：日期。
Calendar.DAY_OF_MONTH：日期，和上面的字段意义完全相同。
Calendar.HOUR：12小时制的小时。
Calendar.HOUR_OF_DAY：24 小时制的小时。
Calendar.MINUTE：分钟。
Calendar.SECOND：秒。
Calendar.DAY_OF_WEEK：星期几。

例如，要获取当前月份可用如下代码：

int month = Calendar.getInstance().get(Calendar.MONTH);

如果整型变量 month 的值是 0，表示当前日历是在 1 月份；如果值是 11，则表示当前日历在 12 月份。

使用 Calendar 类处理日期时间的实例如下：

import java.util.Calendar;
import java.util.Date;

public class Calendars {
    public static void main(String[] args) {
        //获取实例对象
        Calendar c= Calendar.getInstance();
        //c.set()
        c.set(2008,Calendar.FEBRUARY,16);
        System.out.println(c.getTime());
        //c.get()
        System.out.println(c.get(Calendar.HOUR_OF_DAY));
        //System.out.println(new Date().getHours());

        //c.add() 设置七天前的时间
        c.add(Calendar.DATE,-7);
        System.out.printf("%tF %<tT%n",c.getTime());

        //日历类转换成date类
        Date d=c.getTime();
        System.out.println(d);
        //日历类获取时间戳
        long ts=c.getTimeInMillis();
        System.out.printf("%tF %<tT%n",ts);
        //计算2023 1 1 日星期几
        Calendar cc=Calendar.getInstance();//实例化
        cc.set(2023,Calendar.JANUARY,1);
        System.out.printf("%tF %<tT%<tA%n",cc.getTime());//2023-01-01  20:17:35  星期日  输出格式
        System.out.println(cc.get(Calendar.DAY_OF_WEEK));


    }
}
运行结果：
Sat Feb 16 21:39:46 CST 2008
21
2008-02-09 21:39:46
Sat Feb 09 21:39:46 CST 2008
2008-02-09 21:39:46
2023-01-01 21:39:46星期日
1

import java.util.Calendar;
public class Calendar2 {
    public static void main(String[] args) {
        var c= Calendar.getInstance();
        //五年前 add
        c.add(Calendar.YEAR,-5);
        c.add(Calendar.DATE,10);
        //get
        int yyyy=c.get(Calendar.YEAR);
        System.out.println(yyyy);
        int mm=c.get(Calendar.MONTH)+1;//从0开始
        System.out.println(mm);
        int dd=c.get(Calendar.DATE);
        System.out.println(dd);
    }
}
运行结果：
2018
2
19

2.7.4 java8 DateAPI

LocalDate

jdk1.8 新的日期API java.time.LocalDate类 java.util.Date Calendar

此类只有年月日

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.TextStyle;
import java.time.temporal.ChronoUnit;
import java.util.Locale;

public class LocalDateDemo {
    public static void main(String[] args) {
        //实例化
        var now=LocalDate.now();
        System.out.println(now);
        System.out.printf("%tF%n ",now);

        var d=LocalDate.of(2022,5,1);
        System.out.println(d);
        DayOfWeek dayOfWeek=d.getDayOfWeek();
        System.out.println(dayOfWeek.getDisplayName(TextStyle.FULL, Locale.CHINA));
        System.out.println(dayOfWeek.getDisplayName(TextStyle.SHORT, Locale.UK));
        System.out.println(dayOfWeek.getDisplayName(TextStyle.FULL, Locale.US));
        System.out.printf("%tA%n", System.currentTimeMillis());

        //月份的格式的输出
        Month month=d.getMonth();
        System.out.println(month.getDisplayName(TextStyle.FULL, Locale.CHINA));
        System.out.println(month.getDisplayName(TextStyle.SHORT, Locale.CHINA));
        //判断是否是闰年
        System.out.println(d.isLeapYear());

        //五天后的日期
        System.out.println(d.plusDays(5));
        //五天前
        System.out.println(d);
        System.out.println(d.minus(5, ChronoUnit.YEARS));//五年前
        System.out.println(d.minusDays(5));
        System.out.println(d.minus(5,ChronoUnit.DAYS));
        //二十五的月后的日期
        System.out.println(d.plus(25, ChronoUnit.MONTHS));
        System.out.println(d.plusMonths(25));

        //计算两个日期之间的天数
        System.out.println("------------------------------------");
        LocalDate day1=LocalDate.of(2000,1,1);
        LocalDate day2=LocalDate.now();
        long days=ChronoUnit.DAYS.between(day1,day2);
        System.out.printf("%s 到 %s 之间有 %d 天%n",day1,day2,days);
        System.out.println("------------------------------------");

        //格式输出
        System.out.println(day1);
        System.out.println(day2);
        System.out.printf("%tF%n",day1);
        System.out.printf("%tF%n",day2);
        System.out.printf("%tY年%<tm月%<td日 %<tA%n",day1);
        System.out.printf("%tY年%<tm月%<td日 %<tA%n",day2);
        System.out.println(day1.isLeapYear());

        //专业的格式工具类 java.time.DateTimeFormatter
        var fmt= DateTimeFormatter.ofPattern("yyyy年MM月dd日 E  L",Locale.CHINA );
        // E ：星期几 L ：几月
        System.out.println(fmt.format(day1));
        System.out.println(fmt.format(day2));


        LocalTime time=LocalTime.now();
        System.out.println(time);
        System.out.printf("%tT%n",time);

    }
}
运行结果：
2023-02-09
2023-02-09
2022-05-01
星期日
Sun
Sunday
星期四
五月
5月
false
2022-05-06
2022-05-01
2017-05-01
2022-04-26
2022-04-26
2024-06-01
2024-06-01
------------------------------------
2000-01-01 到 2023-02-09 之间有 8440 天
------------------------------------
2000-01-01
2023-02-09
2000-01-01
2023-02-09
2000年01月01日 星期六
2023年02月09日 星期四
true
2000年01月01日 周六  1
2023年02月09日 周四  2
21:45:57.380257800
21:45:57

LocalTime java.time.LocalTime

LocalTime 本地化时间只有时分秒…没有日期

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class LocalTimeDemo {
    public static void main(String[] args) {
        //LocalTime本地化时间只有时分秒，没有其他的日期
        //LocalTime实例化
        var t1= LocalTime.now();
        var t2=LocalTime.of(14,30,20);
        var t3=LocalTime.parse("20:52:23", DateTimeFormatter.ofPattern("HH:mm:ss"));
        //简单输出
        System.out.println(t1);
        System.out.printf("%tT%n", t1);
        System.out.println(t2);
        System.out.println(t3);
        //格式化输出
        DateTimeFormatter df=DateTimeFormatter.ofPattern("HH时mm分ss秒");
        System.out.println(df.format(t1));
        System.out.println(df.format(t2));
        System.out.println(df.format(t3));
        System.out.println(t1.plusSeconds(1000));
        var sns=t1.plusSeconds(1000).format(DateTimeFormatter.ofPattern("HH时mm分ss秒"));
        System.out.println(sns);
    }
}
运行结果
21:48:45.159054900
21:48:45
14:30:20
20:52:23
21时48分45秒
14时30分20秒
20时52分23秒
22:05:25.159054900
22时05分25秒

LocalDateTIme java.time.LocalDateTime

此类包含了年月日时分秒相关信息，相当于LocalDateTime = LocalDate + LocalTime 了相当于以前的java.util.Date，也相当于java.util.Calendar类

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.TextStyle;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

public class LocalTimeDateDemo {
    public static void main(String[] args) {
        var now= LocalDateTime.now();
        System.out.println(now);
        System.out.printf("%tF %<tT%n", now);
        System.out.printf("%tF%n", LocalDate.now());
        System.out.printf("%tY年%<tm月%<td日 %<tH:%<tM:%<tS %<tA %<tp %s %n",now,now.getMonth().getDisplayName(TextStyle.FULL, Locale.CHINA));
        //now.plus()
        //now.minus()
        System.out.println(now.toLocalDate().isLeapYear());//判断闰年
        //将字符串转换为LocalDateTime
        var d2=LocalDateTime.of(2023,12,16,4,6,34);
        System.out.println(d2);
        System.out.println(d2.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        System.out.println("---------------------------------------");
        String str="2023-12-16 12:23:45";
        var dd=LocalDateTime.parse(str,DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println(dd);
        //格式化
        //java.time.DateTimeFormatter 格式化类主要用于格式化java 1.8 新日期工具
        //DateTimeFormatter.ofLocalizedDateTime("yyyy年MM月dd日 HH时mm分ss秒")
        //DateTimeFormatter dt2=DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL);
        //System.out.println(dt2.format(LocalDateTime.now()));
        System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒")));

        var n=LocalDateTime.now();
        String  info=n.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒  a E M L e c"));
        System.out.println(info);
        String  fn=n.format(DateTimeFormatter.ofPattern("yyyyMMddHHmmssMLec")).concat(".jpg");
        System.out.println(fn);
        //获取一天的开始时间

        var ss=LocalDateTime.of(d2.toLocalDate(), LocalTime.MIN);
        System.out.println(ss);
        System.out.println(ss.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        //获取一天的结束时间
        var sss=LocalDateTime.of(d2.toLocalDate(),LocalTime.MAX);
        System.out.println(sss);
        System.out.println(sss.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));

        //将LocalDateTime对象 获取毫秒时间戳
        long ms=LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
        System.out.println(ms);
        System.out.println(System.currentTimeMillis());
        System.out.printf("%tF %<tT%n",LocalDateTime.now());

        //获取系统毫秒 时间戳
        long mm= Instant.now().toEpochMilli();
        System.out.println(mm);
        System.out.printf("%tF %<tT%n",mm);
        Date date=new Date();
        System.out.printf("%tF %<tT%n",date);
        //将时间戳格式输出
        Calendar calendar=Calendar.getInstance();
        calendar.setTimeInMillis(1676078847660L);
        System.out.printf("%tF %<tT",calendar);

    }
}
运行结果：
2023-02-11T09:32:31.596019600
2023-02-11 09:32:31
2023-02-11
2023年02月11日 09:32:31 星期六 上午 二月 
false
2023-12-16T04:06:34
2023-12-16 04:06:34
---------------------------------------
2023-12-16T12:23:45
2023年02月11日 09时32分31秒
2023年02月11日 09时32分31秒  上午 周六 2 2 7 7
202302110932312277.jpg
2023-12-16T00:00
2023-12-16 00:00:00
2023-12-16T23:59:59.999999999
2023-12-16 23:59:59
1676079151675
1676079151676
2023-02-11 09:32:31
1676079151676
2023-02-11 09:32:31
2023-02-11 09:32:31
2023-02-11 09:27:27

2.8 格式化

2.8.1 格式化字符串

System.out.printf(…);
String.format(…);


%s %S	字符串s小字，S大写
%x %X	十六进制整数
%d	十进制整数
%o	八进制整数
%c	字符类型
%b	boolean类型
%f	浮点数
%n %%	换行，百分号
%tF	%tH:%<tM:%<tS
%tT	%tY年%<tm月%<td日 %<tp %<tA %<ta %<tb %<tB

$C:\Users\Dell-pc\AppData\Roaming\Typora\typora-user-images\image-20230211094038568.png$

package cn.yuan;
public class FormatDemo {
    public static void main(String[] args) {
        //+号的使用
        String str;
        str =String.format("数字的正负表示：%+d %d %+d %d",2,3,-2,-3);
        System.out.println(str);
        //-号的使用
        str=String.format("左对齐： %-6d",8);
        System.out.println(str);
        //0的用法
        str=String.format("缺位补零：%06d",8);
        System.out.println(str);
        //   空格的用法
        str=String.format("缺位补空格：%6d",8);
        System.out.println(str);
        str=String.format("缺位补空格：%-6d",8);
        System.out.println(str);
        //，的用法
        str=String.format("数字分组：%,d",123456);
        System.out.println(str);
        //（的用法
        str=String.format("括号用法：%(d",-2222);
        System.out.println(str);
        str=String.format("括号用法：%(d",2222);
        System.out.println(str);
        //#的用法
        str=String.format("#号的用法(十六进制)：%#x",12);
        System.out.println(str);
        str=String.format("#号的用法(八进制)：%#o",12);
        System.out.println(str);
        //<的用法
        str=String.format("<的用法：%f  %<3.1f",1.0);
        //"%<3.1f"作用的对象是前一个"%f"所作用的对象
        System.out.println(str);
    }
}
运行结果：
数字的正负表示：+2 3 -2 -3
左对齐： 8     
缺位补零：000008
缺位补空格：     8
缺位补空格：8     
数字分组：123,456
括号用法：(2222)
括号用法：2222
#号的用法(十六进制)：0xc
#号的用法(八进制)：014
<的用法：1.000000  1.0

package cn.yuan;
public class FormatString {
    public static void main(String[] args) {
        String name="张三丰";
        int age=20;
        String adress="新乡";
        String str="姓名："+name+",年龄："+ age+"岁，家庭地址：" +adress+".";
        System.out.println(str);
        //格式化字符串
        String str2=String.format("姓名：%s,年龄：%d岁，家庭地址：%s。" ,name,age,adress);
        System.out.println(str2);
        //printf 格式直接输出
        System.out.printf("姓名：%s年龄：%d岁，家庭地址：%s%n",name,age,adress);
        //格式化小数 float double
        System.out.println(Math.random());
        System.out.printf("%f%n",Math.random());//格式化小数 float double %f
        System.out.printf("%.1f  %1$.2f  %2$.3f  %<.4f  %<.0f%n",Math.random(),2.333);//%2$代表第二个参数，对其进行格式化。 %<代表跟前一个要格式化的参数一样。
        //格式化日期   %tF :2023-02-10年月日， %<tT :10:19:56 时分秒
        System.out.printf("%tF %<tT%n",System.currentTimeMillis() );
        // 年月日 tp 上下午 ta 星期几 tb 几月份
        System.out.printf("%tY年%<tm月%<td日  %<tp %<tA %<tb %<tB%n",System.currentTimeMillis());
        //时分秒格式化
        System.out.printf("%tH:%<tM:%<ts%n",System.currentTimeMillis());
        //格式化整数
        System.out.printf("%d %<05d %2$05d%n",123,12);//05d 五位 不够左边补零
        System.out.printf("%d %n",23047);
        System.out.printf("%-30d%n",34215);
    }
}
运行结果：
姓名：张三丰,年龄：20岁，家庭地址：新乡.
姓名：张三丰,年龄：20岁，家庭地址：新乡。
姓名：张三丰年龄：20岁，家庭地址：新乡
0.10877453057556896
0.056326
1.0  1.00  2.333  2.3330  2
2023-02-11 10:13:06
2023年02月11日  上午 星期六 2月 二月
10:13:1676081587
123 00123 00012
23047 
34215

2.8.2 格式化数字

NumberFormat

java.text.NumberFormat

package cn.yuan;

import java.text.NumberFormat;
import java.util.Locale;

public class FormatNumberDemo {
    public static void main(String[] args) {
        //格式百分比
        double a=Math.random();
        System.out.println(a);
        System.out.printf("格式化：%.2f%n",a);
        NumberFormat nf=NumberFormat.getPercentInstance();
        System.out.println("百分比："+nf.format(a));
        //格式化+小数
        nf.setMinimumFractionDigits(2);
        System.out.println("百分比："+nf.format(a));
        //格式化货币
        double money=12323.23;
        NumberFormat nff=NumberFormat.getCurrencyInstance();
        nff.setMinimumFractionDigits(2);
        System.out.println(nff.format(100));
        NumberFormat nff2=NumberFormat.getCurrencyInstance(Locale.US);
        System.out.println(nff2.format(100));
        System.out.printf("￥%.2f%n",money);

        //格式化千分位
        long n=2344253443667L;
        double nn=Math.random();
        NumberFormat nff3=NumberFormat.getNumberInstance();
        System.out.println(nff3.format(n));
        System.out.println(nn);
        System.out.println(nff3.format(nn));
        nff3.setMinimumFractionDigits(4);//设置所保留的小数位数
        System.out.println(nff3.format(nn));
        System.out.printf("%.4f%n",nn);
    }
}
运行环境：
0.5586229546908142
格式化：0.56
百分比：56%
百分比：55.86%
¥100.00
$100.00
￥12323.23
2,344,253,443,667
0.9566234131208255
0.957
0.9566
0.9566

2.8.3 格式化日期

LocalDate d1=LocalDate.now();
System.out.printf("%tY年%<tm月%<td日 %<ta %<tA %n", d1);
System.out.printf("%tA%n", System.currentTimeMillis());//%tA 星期格式
System.out.printf("%tA", LocalDate.of(2000, 5, 1));

运行结果：
2023年02月09日 周四 星期四 
星期四
星期一

在这里插入图片描述

SimpleDateFormat

import java.text.SimpleDateFormat

在这里插入图片描述

package cn.yuan;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;

public class DateFormatTest {
    public static void main(String[] args) {
        Date d=new Date();
        System.out.printf("%tF %<tT %<Ta %<tb %<tB %<tp%n",d);
        System.out.printf("%tH: %<tM: %<ts%n",d);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat sdf2=new SimpleDateFormat("yyyyMMddHHmmss");
        String str=sdf.format(d);
        //String str=sdf.format(Calendar.getInstance().getTime());//必须返回date类
        System.out.println(str);
        System.out.println(sdf2.format(d));

        var sd1=new SimpleDateFormat("MM月dd日 E a M");//月日 星期 上午 月份
        System.out.println(sd1.format(d));

        //请输出今日的日期格式 年月日 时分秒 星期几
        Date dd=new Date();
        SimpleDateFormat ss=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
        System.out.println(ss.format(dd));

        //java.time.DateTimeFormatter
        LocalDate d1=LocalDate.now();
        DateTimeFormatter df1=DateTimeFormatter.ofPattern("yyyy-MM-dd");//没有时分秒只有年月日
        System.out.println(d1);
        System.out.println(df1.format(d1));

        LocalDateTime d2=LocalDateTime.now();//有年月日时分秒
        System.out.println(d2);
        System.out.printf("%tF %<tT%n",d2);
        System.out.println(d2.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss")));
        //System.out.printf("%tF %<tT%n",LocalDate.now()); //LocalDate没有时分秒，不能这样使用

    }
}
运行结果：
2023-02-11 10:29:22 周六 2月 二月 上午
10: 29: 1676082562
2023-02-11 10:29:22
20230211102922
02月11日 周六 上午 2
2023-02-11 10:29:22 周六
2023-02-11
2023-02-11
2023-02-11T10:29:22.415996200
2023-02-11 10:29:22
2023年02月11日 10:29:22

2.9 随机Random类

package cn.yuan;
import java.util.Random;
public class Random1 {
    public static void main(String[] args) {
        for (int i=0;i<5;i++){
            System.out.println(Math.random());
        }
        Random random=new Random();
        System.out.println(random.nextBoolean());
        System.out.println(random.nextDouble());
        System.out.println(random.nextInt());
        for (int i=0;i<5;i++) {
            System.out.printf("%d%n" , random.nextInt(5));//0-4
            System.out.println(random.nextInt(10, 16));//10-15
        }
        int t=random.nextInt(6)+10;//10-15
        System.out.println(t);

    }
}
运行结果：
0.22444993236312039
0.3168139533342561
0.3103066135099315
0.6262719663031618
0.7842354365392906
false
0.7425521680035012
1290908014
0
11
4
10
4
10
0
14
1
12
12

一个%30几率中奖的案例：

package cn.yuan;
import java.util.Random;
import java.util.UUID;
public class Random2 {
    public static void main(String[] args) {
        //抽奖程序 30%
        Random rand=new Random();
        int t=rand.nextInt(1,101);//1-100
        //int i=rand.nextInt(100)+1;//0--99 +1==1--100
        if (t<=30){
            System.out.println("中奖");
        }else {
            System.out.println("未中奖");
        }
        System.out.println(UUID.randomUUID());//随机生成UUID
    }
}
运行结果：
未中奖
8a98e945-e652-4fe0-84e9-bd73cee35dab

随机抽取一个学生：

 //有十个学生，随机抽取一个幸运学生 数组下载是10 即0-9
var sts= new String[]{"张三", "李四", "王五", "马六", "陈七", "刘八", "关羽", "赵云", "卢九", "曹操"};
 int index = (int)Math.round(Math.random()*9);
 System.out.println(sts.length);
 System.out.printf("幸运学生：%s%n",sts[index]);
运行结果：
10
幸运学生：刘八

//1 四舍五入取整数，返回long类型的整数
System.out.println(Math.round(.555));
//0
System.out.println(Math.round(.444));
//0
System.out.println(Math.round(.111));
//0
System.out.println(Math.round(.009));
//1
System.out.println(Math.round(1.2));
运行结果：
1
0
0
0
1