Java中最基本的常用类（数学类 /字符串类/时间类/格式化类）

最新推荐文章于 2024-04-28 23:09:36 发布

码ming

最新推荐文章于 2024-04-28 23:09:36 发布

阅读量672

点赞数 1

分类专栏： javase基础文章标签： java 类字符串时间类 Data

本文链接：https://blog.csdn.net/weixin_46168350/article/details/108609504

版权

javase基础专栏收录该内容

17 篇文章 0 订阅

订阅专栏

java类一般查文档api文档
一下是比较常用的类

数字相关类

– 整数 Short, Int, Long
– 浮点数 Float, Double
– 大数类 BigInteger(大整数), BigDecimal(大浮点数)
– 随机数类 Random
– 工具类 Math
• java.math包

整数类型

short，16位，2个字节，有符号的以二进制补码表示的整数
–(-32768-32767, -2^15-215-1)，默认值0

int, 32位，4个字节,有符号的以二进制补码表示的整数
–(-2147483648–2147483647, -2^31-231-1)，默认值0

long, 64位，8个字节,有符号的以二进制补码表示的整数
–-9,223,372,036,854,775,808（-2^63）
–9,223,372,036,854,775,807（2^63 -1），默认值0L

浮点数

• float，单精度，32位，4个字节，符合IEEE 754标准的浮点数，默认值0.0f。float的范围为1.40129846432481707e-45 to 3.40282346638528860e+38 (无论正负)。
• double，双精度，32位，4个字节，符合IEEE 754标准的浮点数，默认值0.0d。double的范围为4.94065645841246544e-324d to 1.79769313486231570e+308d (无论正负) 。
• float和double都不能用来表示很精确的数字。

大数字类

• 大整数类BigInteger
– 支持无限大的整数运算
• 大浮点数BigDecimal
– 支持无限大的小数运算
– 注意精度和截断

随机数类

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

在这里插入图片描述

数字工具类

• java.lang.Math
– 绝对值函数abs
– 对数函数log
– 比较函数max、min
– 幂函数pow
– 四舍五入函数round等
– 向下取整floor
– 向上取整ceil
在这里插入图片描述

字符串相关类

String的特性

• String类：代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
• String是一个final类，代表不可变的字符序列。
• 字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。
• String对象的字符内容是存储在一个字符数组value[]中的。

public final class String
implements java.io.Serializable, Comparable<String>, CharSequence { /** The value is used for character storage. */
private final char value[];
/** Cache the hash code for the string */
private int hash; // Default to 0

String对象的创建

方式一：通过字面量定义的方式
方式二：通过new + 构造器的方式

String str = "hello";

//本质上this.value = new char[0];
String s1 = new String(); 

//this.value = original.value;
String s2 = new String(String original); 

//this.value = Arrays.copyOf(value, value.length);
String s3 = new String(char[] a); 

String s4 = new String(char[] a,int startIndex,int count);

内存空间地址：
在这里插入图片描述

注意
• 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
• 只要其中有一个是变量，结果就在堆中
例如：

String s1="java";
String s2="EE";
final String s3="Java";
String  s4=s1+"EE";
String  s5=s1+s2;
String  s6=s3+"EE";
String  s7=“JavaEE”;

System.out.print(s5==s7 );//false 只要其中有一个是变量，结果就在堆中
System.out.print(s4==s7 );//false 只要其中有一个是变量，结果就在堆中
System.out.print(s6==s7 );//true  ==final修饰了变成常量了，常量拼接在常量池==

• 如果拼接的结果调用intern()方法，返回值就在常量池中

String

String声明为final的，不可被继承
String实现了Serializable接口：表示字符串是支持序列化的。
实现了Comparable接口：表示String可以比较大小
String内部定义了final char[] value用于存储字符串数据
String:代表不可变的字符序列。简称：不可变性。
体现：
4.1 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
4.2 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
4.3 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
字符串常量池中是不会存储相同内容的字符串的。

• Java中使用频率最高的类
• 是一个不可变对象，加减操作性能较差
• 以下方法需要牢记：charAt, concat, contains, endsWith,equals, equalsIgnoreCase, hashCode, indexOf, length, matches, replace, replaceAll,
split, startsWith, subString, trim, valueOf

方法介绍：

String常用方法1

函数	功能
• `int length()`：	返回字符串的长度： return value.length
• `char charAt(int index)`：	返回某索引处的字符return value[index]
• `boolean isEmpty()`：	判断是否是空字符串：return value.length == 0
• `String toLowerCase()`：	使用默认语言环境，将 String 中的所有字符转换为小写
• `String toUpperCase()`：	使用默认语言环境，将 String 中的所有字符转换为大写
• `String trim()`：	返回字符串的副本，忽略前导空白和尾部空白
• `boolean equals(Object obj)`：	比较字符串的内容是否相同
• `boolean equalsIgnoreCase(String anotherString)`：	与equals方法类似，忽略大小写
• `String concat(String str)`：	将指定字符串连接到此字符串的结尾。等价于用“+”
• `int compareTo(String anotherString)`	：比较两个字符串的大小
• `String substring(int beginIndex)`：	返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
• `String substring(int beginIndex, int endIndex)`：	返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

String常用方法2

函数	功能
• `boolean endsWith(String suffix)`：	测试此字符串是否以指定的后缀结束
• `boolean startsWith(String prefix)`：	测试此字符串是否以指定的前缀开始
• `boolean startsWith(String prefix, int toffset)`：	测试此字符串从指定索引开始的子字符串是否以指定前缀开始
• `boolean contains(CharSequence s)`：	当且仅当此字符串包含指定的 char 值序列时，返回 true
• `int indexOf(String str)`：	返回指定子字符串在此字符串中第一次出现处的索引
• `int indexOf(String str, int fromIndex)`：	返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
• `int lastIndexOf(String str)`：	返回指定子字符串在此字符串中最右边出现处的索引
• `int lastIndexOf(String str, int fromIndex)`：	返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

注：indexOf和lastIndexOf方法如果未找到都是返回-1

String常用方法2

函数	功能
• `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 替换此字符串匹配给定的正则表达式的第一个子字符串。
• `boolean matches(String regex)`：	告知此字符串是否匹配给定的正则表达式。
• `String[] split(String regex)`：	根据给定正则表达式的匹配拆分此字符串。
• `String[] split(String regex, int limit)`：	根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

代码：
在这里插入图片描述

String与数组转换

String与字符数组转换:
字符数组=>字符串
String 类的构造器：String(char[]) 和 String(char[]，int offset，int length)分别用字符数组中的全部字符和部分字符创建字符串对象。

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

字节数组=>字符串
String(byte[])：通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。 String(byte[]，int offset，int length) ：用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。

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

可变字符串类

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

java.lang.StringBuffer代表可变的字符序列，JDK1.0中声明，可以对字符串内容进行增删，此时不会产生新的对象。
很多方法与String相同。
作为参数传递时，方法内部可以改变值。

value没有final声明,value可以不断扩容。
count记录有效字符的个数。

StringBuffer类不同于String，其对象必须使用构造器生成。有三个构造器：

StringBuffer()：初始容量为16的字符串缓冲区
StringBuffer(int size)：构造指定容量的字符串缓冲区
StringBuffer(String str)：将内容初始化为指定字符串内容

StringBuffer类的常用方法

函数	功能
`StringBuffer append(xxx)`：	提供了很多的append()方法，用于进行字符串拼接StringBuffer delete(int start,int end)：删除指定位置的内容
`StringBuffer replace(int start, int end, String str)`：	把[start,end)位置替换为str
`StringBuffer insert(int offset, xxx)`：	在指定位置插入xxx
`StringBuffer reverse()` ：	把当前字符序列逆转

还有：
public int indexOf(String str)
public String substring(int start,int end) 截取当前字符串中指定范围内的字符串
public int length()
public char charAt(int n )
public void setCharAt(int n ,char ch)
总结：
增：append(xxx)
删：delete(int start,int end)
改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
查：charAt(int n )
插：insert(int offset, xxx)
长度：length();
*遍历：for() + charAt() / toString()

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

StringBuilder(JDK 5.0)：可变字符序列、效率高、线程不安全
• StringBuffer/StringBuilder：方法一样，区别在同步
– append/insert/delete/replace/substring
– length 字符串实际大小，capacity字符串占用空间大小
– trimToSize(): 去除空隙，将字符串存储压缩到实际大小
– 如有大量append，事先预估大小，再调用相应构造函数

总结

– String(不可变对象，只读)
– StringBuffer（字符串加减，同步，性能好）
– StringBuilder（字符串加减，不同步，性能更好）
扩容问题:
如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。

时间相关类

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)

java.util.Date(基本废弃，Deprecated)

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

构造器：
Date()：使用无参构造器创建的对象可以获取本地当前时间。
Date(long date)
常用方法
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.sql.Date（和数据库对应的时间类）

java.sql.Date birthDate = new java.sql.Date(date.getTime());

Calendar

• Calendar是目前程序中最常用的，但是是抽象类
– 简单工厂模式

获取Calendar实例的方法

– Calendar gc=Calendar.getInstance();//(使用方法)
– Calendar gc= new GregorianCalendar();//(调用它的子类的构造器)

一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、 MINUTE、SECOND

    @Test
    public void testCalendar(){
        //1.实例化
        //方式一：创建其子类（GregorianCalendar）的对象
        //方式二：调用其静态方法getInstance()
        Calendar calendar = Calendar.getInstance();
//        System.out.println(calendar.getClass());

        //2.常用方法
        //get()
        int days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));

        //set()
        //calendar可变性
        calendar.set(Calendar.DAY_OF_MONTH,22);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);

        //add()
        calendar.add(Calendar.DAY_OF_MONTH,-3);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);

        //getTime():日历类---> Date
        Date date = calendar.getTime();
        System.out.println(date);

        //setTime():Date ---> 日历类
        Date date1 = new Date();
        calendar.setTime(date1);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);

    }

在这里插入图片描述
– get(Field)来获取时间中每个属性的值. 注意，月份0-11.
– getTime()，返回相应的Date对象
– getTimeInMillis(), 返回自1970.1.1以来的毫秒数
–set(Field)设置时间字段
– add(field, amount) 根据指定字段增加/减少时间
– roll(field, amount)根据指定字段增加/减少时间，但不影响上一的时间段

注意:
获取月份时：一月是0，二月是1，以此类推，12月是11
获取星期时：周日是1，周二是2 ，。。。。周六是7
[外链图片转存失败,源站可能有防盗在这里插入!链机制,建描述]议将图片上https://传(imbg.csdnJmg.cn/20200hNi3916130755444.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjE2ODM1MA==,size_16,color_FFFFFF,t_70#pic_center)https://img-blog.csd加粗样式nimg.cn/20200916130755444.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjE2ODM1MA==,size_16,color_FFFFFF,t_70#pic_center)]

总结

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

Java 8 推出新的时间API（java.time）

– java.time包
– 旧的设计不好（重名的类、线程不安全等）
– 新版本优点
• 不变性，在多线程环境下
• 遵循设计模式，设计得更好，可扩展性强

• Java 8 时间包概述
– java.time包：新的Java日期/时间API的基础包
– java.time.chrono包：为非ISO的日历系统定义了一些泛化的API，
– java.time.format包：格式化和解析日期时间对象的类
– java.time.temporal包：包含一些时态对象，可以用其找出关于日期/时间对象的某个特定日期或时间
– java.time.zone包：包含支持不同时区以及相关规则的类

• Java 8 java.time包主要类
– LocalDate：日期类
– LocalTime：时间类(时分秒-纳秒)
– LocalDateTime: LocalDate + LocalTime
– Instant: 时间戳

import org.junit.Test;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;
import java.util.Date;

/**
 * jdk 8中日期时间API的测试
 *
 */
public class JDK8DateTimeTest {

    @Test
    public void testDate(){
        //偏移量
        Date date1 = new Date(2020 - 1900,9 - 1,8);
        System.out.println(date1);//Tue Sep 08 00:00:00 GMT+08:00 2020
    }

    /*
    LocalDate、LocalTime、LocalDateTime 的使用
    说明：
        1.LocalDateTime相较于LocalDate、LocalTime，使用频率要高
        2.类似于Calendar
     */
    @Test
    public void test1(){
        //now():获取当前的日期、时间、日期+时间
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();

        System.out.println(localDate);
        System.out.println(localTime);
        System.out.println(localDateTime);

        //of():设置指定的年、月、日、时、分、秒。没有偏移量
        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43);
        System.out.println(localDateTime1);


        //getXxx()：获取相关的属性
        System.out.println(localDateTime.getDayOfMonth());
        System.out.println(localDateTime.getDayOfWeek());
        System.out.println(localDateTime.getMonth());
        System.out.println(localDateTime.getMonthValue());
        System.out.println(localDateTime.getMinute());

        //体现不可变性
        //withXxx():设置相关的属性
        LocalDate localDate1 = localDate.withDayOfMonth(22);
        System.out.println(localDate);
        System.out.println(localDate1);


        LocalDateTime localDateTime2 = localDateTime.withHour(4);
        System.out.println(localDateTime);
        System.out.println(localDateTime2);

        //不可变性
        LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
        System.out.println(localDateTime);
        System.out.println(localDateTime3);

        LocalDateTime localDateTime4 = localDateTime.minusDays(6);
        System.out.println(localDateTime);
        System.out.println(localDateTime4);
    }

    /*
    Instant的使用
    类似于 java.util.Date类

     */
    @Test
    public void test2(){
        //now():获取本初子午线对应的标准时间
        Instant instant = Instant.now();
        System.out.println(instant);//2019-02-18T07:29:41.719Z

        //添加时间的偏移量
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);//2019-02-18T15:32:50.611+08:00

        //toEpochMilli():获取自1970年1月1日0时0分0秒（UTC）开始的毫秒数  ---> Date类的getTime()
        long milli = instant.toEpochMilli();
        System.out.println(milli);

        //ofEpochMilli():通过给定的毫秒数，获取Instant实例  -->Date(long millis)
        Instant instant1 = Instant.ofEpochMilli(1550475314878L);
        System.out.println(instant1);
    }

    /*
    DateTimeFormatter:格式化或解析日期、时间
    类似于SimpleDateFormat

     */

    @Test
    public void test3(){
//        方式一：预定义的标准格式。如：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);//2019-02-18T15:42:18.797

        //解析：字符串 -->日期
        TemporalAccessor parse = formatter.parse("2019-02-18T15:42:18.797");
        System.out.println(parse);

//        方式二：
//        本地化相关的格式。如：ofLocalizedDateTime()
//        FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
        //格式化
        String str2 = formatter1.format(localDateTime);
        System.out.println(str2);//2019年2月18日 下午03时47分16秒


//      本地化相关的格式。如：ofLocalizedDate()
//      FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
        DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
        //格式化
        String str3 = formatter2.format(LocalDate.now());
        System.out.println(str3);//2019-2-18


//       重点： 方式三：自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
        DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        //格式化
        String str4 = formatter3.format(LocalDateTime.now());
        System.out.println(str4);//2019-02-18 03:52:09

        //解析
        TemporalAccessor accessor = formatter3.parse("2019-02-18 03:52:09");
        System.out.println(accessor);

    }

}

特殊

//4. TemporalAdjuster : 时间校正器
	@Test
	public void test4(){
	LocalDateTime ldt = LocalDateTime.now();
		System.out.println(ldt);
		
		LocalDateTime ldt2 = ldt.withDayOfMonth(10);
		System.out.println(ldt2);
		
		LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
		System.out.println(ldt3);
		
		//自定义：下一个工作日
		LocalDateTime ldt5 = ldt.with((l) -> {
			LocalDateTime ldt4 = (LocalDateTime) l;
			
			DayOfWeek dow = ldt4.getDayOfWeek();
			
			if(dow.equals(DayOfWeek.FRIDAY)){
				return ldt4.plusDays(3);
			}else if(dow.equals(DayOfWeek.SATURDAY)){
				return ldt4.plusDays(2);
			}else{
				return ldt4.plusDays(1);
			}
		});
		
		System.out.println(ldt5);
		
	}
	
	//3.
	//Duration : 用于计算两个“时间”间隔
	//Period : 用于计算两个“日期”间隔
	@Test
	public void test3(){
		Instant ins1 = Instant.now();
		
		System.out.println("--------------------");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
		}
		
		Instant ins2 = Instant.now();
		
		System.out.println("所耗费时间为：" + Duration.between(ins1, ins2));
		
		System.out.println("----------------------------------");
		
		LocalDate ld1 = LocalDate.now();
		LocalDate ld2 = LocalDate.of(2011, 1, 1);
		
		Period pe = Period.between(ld2, ld1);
		System.out.println(pe.getYears());
		System.out.println(pe.getMonths());
		System.out.println(pe.getDays());
	}

总结

• 当前多数程序还是使用Calendar类处理时间
• 学习Java 8 的时间新特性并应用

格式化(Format)相关类

• java.text包java.text.Format的子类
– NumberFormat：数字格式化，抽象类
• DecimalFormat

– MessageFormat：字符串格式化

– DateFormat：日期/时间格式化，抽象类
• SimpleDateFormat
• java.time.format包下
– DateTimeFormatter

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

– DecimalFormat 工厂模式
– 例如：将1234567格式化输出为1,234,567

DecimalFormaterRuleTest.java:
在这里插入图片描述

DecimalFormatTest.java:

在这里插入图片描述

• MessageFormat：字符串格式化

– 支持多个参数-值对位复制文本
– 支持变量的自定义格式
– 例如将”Hello {1}”根据变量值格式化为Hello World
在这里插入图片描述

时间格式化

DateFormat：时间格式化，抽象类

– 它允许进行格式化：日期=>文本、解析：文本=>日期
– SimpleDateFormat 工厂模式
– parse：将字符串格式化为时间对象
– format：将时间对象格式化为字符串
– 如将当前时间转为化YYYY-MM-DD HH24:MI:SS输出

格式化：
SimpleDateFormat()：默认的模式和语言环境创建对象
public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用：
public String format(Date date)：方法格式化时间对象date
解析：
public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期。

   @Test
    public void testSimpleDateFormat() throws ParseException {
        //实例化SimpleDateFormat:使用默认的构造器
        SimpleDateFormat sdf = new SimpleDateFormat();

        //格式化：日期 --->字符串
        Date date = new Date();
        System.out.println(date);

        String format = sdf.format(date);
        System.out.println(format);

        //解析：格式化的逆过程，字符串 ---> 日期
        String str = "19-12-18 上午11:43";
        Date date1 = sdf.parse(str);
        System.out.println(date1);

        //*************按照指定的方式格式化和解析：调用带参的构造器*****************
//        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa");
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//模板
      //SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 EEE HH:mm:ss");
        //格式化
        String format1 = sdf1.format(date);
        System.out.println(format1);//2019-02-18 11:48:27
        //解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现),
        //否则，抛异常
        Date date2 = sdf1.parse("2020-02-18 11:48:27");
        System.out.println(date2);
    }

java.time.format.DateFormatter：时间格式化

– JDK 8 发布，线程安全(vs SimpleDateFormat 线程不安全)
– ofPattern: 设定时间格式
– parse：将字符串格式化为时间对象
– format：将时间对象格式化为字符串
– 如将当前时间转为化YYYY-MM-DD HH24:MI:SS输出
在这里插入图片描述

总结

• 三种格式化
– 数字格式化
– 字符串格式化
– 时间格式化
• 学会查阅相关的API文档，并多进行代码练习

System类

[ ]
System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。
成员变量
System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。
成员方法
native long currentTimeMillis()：
该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
void exit(int status)：
该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
void gc()：
该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。
String getProperty(String key)：
该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示：

代码案例：

String javaVersion = System.getProperty("java.version");
System.out.println("java的version:" + javaVersion);
String javaHome = System.getProperty("java.home"); 
System.out.println("java的home:" + javaHome);
String osName = System.getProperty("os.name");
System.out.println("os的name:" + osName);
String osVersion = System.getProperty("os.version"); 
System.out.println("os的version:" + osVersion);
String userName = System.getProperty("user.name"); 
System.out.println("user的name:" + userName);
String userHome = System.getProperty("user.home");
System.out.println("user的home:" + userHome);
String userDir = System.getProperty("user.dir"); 
System.out.println("user的dir:" + userDir);