【Java SE】常用基础API

写在前面

• 关于文章

  本篇文章主要学习了JavaSE的基础进阶内容的常用基础API、String类等。由于Java 拥有丰富的类库，提供了许许多多的常用、使用类，每个类同时会有很多的API供我们使用，要想全部记住是不现实的，只能是熟能生巧，用的多了也就容易上手了，所以在这里，首先是学会一些常用类的基本API，重点是要学会查API文档。

• 我的站点

  网络云书签-理想 (imyjs.cn)

  理想智能云解析 (imyjs.cn)

  任务墙 (imyjs.cn)

  LiXiang's Blog (gitee.io) 不再更文

  学编程那点事儿 (imyjs.cn)

• 联系我

  🐧：2410685763

  WeChat：Super_Baby_00

  公众号：编程那点事儿

What is API

API（Application Programming Interface）应用程序接口，是一些预先定义的接口。其实我们类的方法，接口的方法在宏观上都能称之为接口。

Java 在线文档地址：https://www.matools.com/api/java8

包装类 Wrapper

Java针对八种基本数据类型定义了相应的引用类型—包装类（封装类）有了类的特点，就可以调用类中的方法。例如：Integer类型提供如下方法：

		int a = 20;
		System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.toBinaryString(a));
        System.out.println(Integer.toOctalString(a));
        System.out.println(Integer.toHexString(a));

 

基本数据类型	包装类
boolean	Boolean
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double

装箱

基本数据类型包装成包装类的实例

①使用对应包装类的构造器

		Integer num = new Integer(10);
        Boolean boo = new Boolean(true);
        Double doubleNum = new Double(15.23);
        Long longNum = new Long(131486464L);
        Character ch = new Character('a');
        Float floatNum = new Float(1.5f);
        short shortNum = 1;
        Short aShort = new Short(shortNum); //Short aShort = new Short(1); 报错 默认1是int类型
        byte b1 = 0;
        Byte b = new Byte(b1);//Byte b = new Byte(1); 报错 默认1是int类型

 

②使用对应包装类的静态方法 valueOf()

		byte b = 1;
        Byte aByte = Byte.valueOf(b);
        short s = 2;
        Short aShort = Short.valueOf(s);
        Integer integer = Integer.valueOf(20);
        Long aLong = Long.valueOf(453434456L);
        Float aFloat = Float.valueOf(1.52f); // 注意1.52后边加F/f 标识
        Double aDouble = Double.valueOf(5.2155231);
        Character f = Character.valueOf('f');
        Boolean aBoolean = Boolean.valueOf(false);

 

拆箱

获得包装类对象中包装的基本类型变量

①使用对应包装类提供的 xxxValue() 方法。 xxx ：代表对应的基本数据类型

		Integer num = 66;
        int i = num.intValue();
        Double num2 = 5.265452;
        double v = num2.doubleValue();
        Character ch = 'A';
        char c = ch.charValue();
        Long num3 = 15643434L;
        long l = num3.longValue();
        Boolean boo = true;
        boolean b = boo.booleanValue();
        Float num4 = 13.14F;
        float v1 = num4.floatValue();
        Byte b1 = 0;
        byte b2 = b1.byteValue();
        Short num5 = 12;
        short i1 = num5.shortValue();

 

public void test(){
        Integer num1 = 100; //自动装箱
        int a = num1; //自动拆箱
}

 

包装类的缓存

Integer 为我们提供了一个小的缓存，该缓存的取值范围(-128~127之间)，若需要装箱的值在该取值范围则从缓存中取一个实例，若超出该取值范围，则重新 new 一个 Integer 的实例（除了 float 和 double 都有缓存）

public void test(){
        Integer num1 = 100;
        Integer num2 = 100;
        System.out.println(num1 == num2);//true

        Integer num3 = 150;
        Integer num4 = 150;
        System.out.println(num3 == num4);//false
}

Integer实现源码

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
}

 

包装类常用方法

字符串转换成基本数据类型

①通过包装类的构造器实现

int i = new Integer(“12”);
String str2 = "true";
Boolean boo = new Boolean(str2);//转换时，除了 true 其余都为 false
System.out.println(boo);

②通过包装类的parseXxx(String s)静态方法

Float f = Float.parseFloat(“12.1”);

基本数据类型转换成字符串

①调用字符串重载的valueOf()方法

String fstr = String.valueOf(2.34f);

②其他方法

String intStr = 5 + “”

String类

String类：构造字符串对象

常量对象：字符串常量对象是用双引号括起的字符序列。例如："你好"、"12.97"、"boy"等。

字符串的字符使用Unicode字符编码，一个字符占两个字节

String类较常用构造方法:

String  s1 = new String();
String  s2 = new String(String original);
String  s3 = new String(char[] a);
String  s4 =  new String(char[] a,int startIndex,int count)

public void test5(){
        String str  = "abc"; //代表一个对象，至少在内存中开辟一块内存空间
        String str1 = new String("abc"); //代表两个对象，至少在内存中开辟两块内存空间
        String str2  = "abc";

        System.out.println(str == str1); // false
        System.out.println(str1 == str2); // false
        System.out.println(str == str2); // true

}

 

String的特性

• String是一个final类，代表不可变的字符序列
• 字符串是不可变的。一个字符串对象一旦被配置，其内容是不可变的。

String常用方法

/* 1. 获取字符串的方法：
 * 		①String concat(String str)：串接字符串
 * 		②String substring(int beginIndex)：获取字符串的子串
 * 		  String substring(int beginIndex, endIndex) : 包含头不包含尾
 * 		③String toLowerCase()和String toUpperCase()：转换为小写/大写
 * 		④String trim()：删除首尾空格或制表符
 * 2. 搜索方法：
 * 		①int indexOf(int ch) : 获取指定字符在字符串中的位置,若没有指定的字符，返回 -1
 * 		 int indexOf(int ch, int fromIndex) : 从指定位置开始搜索
 * 		 int indexOf(String str)
 * 		 int indexOf(String str, int fromIndex)
 * 		 int lastIndexOf(int ch) : 反向获取指定字符位置
 * 3. 判断方法：
 *  	① boolean equals(Object obj)：判断是否相等
 *  	   boolean equalsIgnoreCase(String str)：判断是否相等,不考虑大小写
 *  	② boolean contains(String str) :判断是否包含某字符串
 *	   	③ boolean startsWith(String str)和 boolean endsWith(String str)：判断是否以指定字符串开始/结尾
 *	   	④ boolean isEmpty():判断字符串是否为空
 4. 其它方法：
 * 		①length()：返回字符串长度
 * 		②char charAt(int index):返回索引处的字符
 * 		③将字符数组转换为字符串
 * 			构造器：
 * 				  String(char[] ch)
 * 				  String(char[] ch, offset, count) : 将数组中一部分转换为字符串，从第几个索引位置开始转换，转换几个
 * 			静态方法：
 * 				  static String copyValueOf(char[] ch)
 * 				  static String copyValueOf(char[] ch, offset, count)
 * 				  static String valueOf(char[])
 * 		 将字符串转换字符数组: char[] toCharArray()
 * 		④String replace(char oldCahr, char newCahr) ： 替换字符串中字符
 * 		  String replace(String oldStr, String oldStr)：替换字符串中字符串
 *		⑤String[] split(String r):根据指定符号切割
 */

String与字符、字节数组

字符串与字符数组

• String 类的构造方法：String(char[]) 和 String(char[]，int offset，int length) 分别用字符数组中的全部字符和部分字符创建字符串对象
• String类提供了将字符串存放到数组中的方法：
  public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
• 将字符串中的全部字符存放在一个字符数组中的方法：
  public char[] toCharArray()

字符串与字节数组

• String(byte[])用指定的字节数组构造一个字符串对象。
• String(byte[]，int offset，int length)用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。
• public byte[] getBytes() 方法使用平台默认的字符编码，将当前字符串转化为一个字节数组。
• public byte[] getBytes(String charsetName)使用参数指定字符编码，将当前字符串转化为一个字节数组。

字符串算法练习

1.模拟一个trim方法，去除字符串两端的空格。

// 1.模拟一个trim方法，去除字符串两端的空格。
    public static String MyTrim(String oriStr){
       int frontIndex = 0;
       int lastIndex = oriStr.length() - 1;
       while (oriStr.charAt(frontIndex) == ' ' && frontIndex < lastIndex){
           frontIndex++;
       }
       while (oriStr.charAt(lastIndex) == ' '&& frontIndex < lastIndex){
           lastIndex--;
       }
       return oriStr.substring(frontIndex, lastIndex + 1);
    }

 

2.将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为”abfedcg”

// 2.将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为”abfedcg”
    private static String reverseStr(String oriStr, int beginIndex, int endIndex){
        char[] chars = oriStr.toCharArray();
        for (;beginIndex < endIndex; beginIndex++, endIndex--){
            char ch = chars[beginIndex];
            chars[beginIndex] = chars[endIndex];
            chars[endIndex] = ch;
        }
        return String.valueOf(chars);
    }

 

3.获取一个字符串在另一个字符串中出现的次数。比如：获取“ ab”在 “abkkcadkabkebfkabkskab” 中出现的次数

// 3.获取一个字符串在另一个字符串中出现的次数。比如：获取“ab”在 “abkkcadkabkebfkabkskab” 中出现的次数
    private static int getCounts(String oriStr, String tarStr){
        int fromIndex = 0;
        int index = -1;
        int count = 0;
        while ((index = oriStr.indexOf(tarStr, fromIndex)) != -1){
            count++;
            fromIndex = index + tarStr.length();
        }
        return count;
    }

 

4.获取两个字符串中最大相同子串。比如：str1 = “abcwerthelloyuiodef“;str2 =”cvhellobnm”（提示：将短的那个串进行长度依次递减的子串与较长的串比较。）

	// 4.获取两个字符串中最大相同子串。比如：str1 = “abcwerthelloyuiodef“;str2 =”cvhellobnm”
    // （提示：将短的那个串进行长度依次递减的子串与较长的串比较。）
    private static String getMaxSameStr(String oriStr, String compareStr) {
        String longStr = oriStr.length() > compareStr.length() ? oriStr : compareStr;
        String shortStr = longStr.equals(oriStr) ? compareStr : oriStr;

        for (int x = 0; x < shortStr.length(); x++) {
            for (int y = 0, z = shortStr.length() - x; z <= shortStr.length(); y++, z++) {
                String str = shortStr.substring(y, z);
                if (longStr.contains(str)) {
                    return str;
                }
            }
        }
        return "";
    }

 

5.对字符串中字符进行自然顺序排序。

提示：

①字符串变成字符数组。

②对数组排序，选择，冒泡，Arrays.sort();

③将排序后的数组变成字符串。

    // 5.对字符串中字符进行自然顺序排序。
    //  提示：
    //  字符串变成字符数组。
    //  对数组排序，选择，冒泡，Arrays.sort();
    //  将排序后的数组变成字符串。
    private static String sortStr(String oriStr){
        if (oriStr == null || oriStr.length() == 0) return "";
        char[] chars = oriStr.toCharArray();
        Arrays.sort(chars);
        return new String(chars);
    }

 

StringBuffer类

• java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。
• 很多方法与String相同，但StingBuffer是可变长度的。
• StringBuffer是一个容器。

StringBuffer类有三个构造方法：

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

StringBuffer类的常用方法

StringBuffer append(String s)
StringBuffer append(int n)
StringBuffer append(Object o)
StringBuffer append(char n)
StringBuffer append(long n)
StringBuffer append(boolean n)
StringBuffer insert(int index, String str) 
public StringBuffer reverse() 
StringBuffer delete(int startIndex, int endIndex) 
public char charAt(int n )
public void setCharAt(int n ,char ch)
StringBuffer replace( int startIndex ,int endIndex, String str)
public int indexOf(String str)
public String substring(int start,int end)
public int length()

StringBuilder类

StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且方法也一样

• String：不可变字符序列
• StringBuffer：可变字符序列、效率低、线程安全
• StringBuilder(JDK1.5)：可变字符序列、效率高、线程不安全

String、StringBuffer与StringBuilder 性能比较

String text = "";
long startTime = 0L;
long endTime = 0L;
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));

System类

/**
 *         //用于垃圾回收
 *         public static void gc()
 *
 *         //终止正在运行的java虚拟机。参数用作状态码，根据惯例，非0表示异常终止
 *         public static void exit(int status)
 *
 *         //System.out.println(System.currentTimeMillis());
 *         //返回从1970年1月1日到现在时间的毫秒数（协调时间）
 *         public static native long currentTimeMillis();
 *         public static native long nanoTime();
 *
 *         public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
 *         //src - 源数组。
 *         //srcPos - 源数组中的起始位置。
 *         //dest - 目标数组。
 *         //destPos - 目的地数据中的起始位置。
 *         //length - 要复制的数组元素的数量。
 */

时间类

时间戳:时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总毫秒数。时间戳在全世界都是固定的。

日期 Date类

java.util.Date类表示特定的瞬间，精确到毫秒

构造方法：

• Date( )使用Date类的无参数构造方法创建的对象可以获取本地当前时间。

  创建一个当时的时间对象，就是new的那一瞬间，精确到毫秒。

• 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是时间标准。

• boolean after(Date when)

  测试此日期是否在指定日期之后

• boolean before(Date when)

  测试此日期是否在指定日期之前

import java.util.Date;

public class DateTest {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println("今天是：" + date);  // Sun Feb 27 19:54:27 CST 2022   这是美国表示时间的方法
        long time = date.getTime();
        // System.out.println(time);  // 1645962867643

        Date date2 = new Date(1645962867643L);  // 注意是long类型
        // System.out.println(date2);  // Sun Feb 27 19:54:27 CST 2022

        // 仅仅使用Date类，计算七天后是哪一天：
       Date date3 = new Date(time + (1000 * 60 * 60 * 24 * 7));
        System.out.println("七天后：" + date3);
    }
}

日历 Calendar类

java.util.Calendar(日历)类:Calendar是一个抽象基类，主用用于完成日期字段之间相互操作的功能。

Calendar类是一个日历抽象类，提供了一组对“年月日时分秒星期”等日期信息的操作的函数，并针对不同国家和地区的日历提供了相应的子类，即本地化。比如公历GregorianCalendar，佛历BuddhistCalendar，日本帝国历JapaneseImperialCalendar等。在设计上，Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。

获取Calendar实例的方法

• 使用Calendar.getInstance()方法
• 调用它的子类GregorianCalendar的构造方法。

常用的方法

calendar.get(int field)

一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、MINUTE、SECOND,其实参数就是一堆静态常量，1、2、3...所以你使用calendar.get(1) 也是能够获取到年份的。

add(int field, int amount)
根据日历的规则，将指定的时间量添加或减去给定的日历字段。
    
after(Object when)
返回 Calendar是否 Calendar指定时间之后的时间 Object 。
    
before(Object when)
返回此 Calendar是否 Calendar指定的时间之前指定的时间 Object 。
    
Date	getTime()
返回一个 Date表示此物体 Calendar的时间值（毫秒从偏移 Epoch “）。
    
long	getTimeInMillis()
以毫秒为单位返回此日历的时间值。
    
TimeZone	getTimeZone()
获取时区。
    
int	getWeeksInWeekYear()
返回由这个 Calendar表示的星期内的星期 Calendar 。
    
int	getWeekYear()
返回这个 Calendar 。
    
void	setTime(Date date)
使用给定的 Date设置此日历的时间。
    
void	setTimeInMillis(long millis)
从给定的长值设置此日历的当前时间。
    
void	setTimeZone(TimeZone value)
以给定的时区值设置时区。
    
Instant	toInstant()
将此对象转换为Instant 。

使用示例

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

public class CalendarTest {
    public static void main(String[] args) {
        // 从一个 Calendar 对象中获取 Date 对象
        Calendar calendar = Calendar.getInstance();
        /**
         * java.util.GregorianCalendar[time=1645964076212,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],
         * firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2022,MONTH=1,WEEK_OF_YEAR=10,WEEK_OF_MONTH=5,DAY_OF_MONTH=27,DAY_OF_YEAR=58,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=8,HOUR_OF_DAY=20,MINUTE=14,SECOND=36,MILLISECOND=212,ZONE_OFFSET=28800000,DST_OFFSET=0]
         */
        System.out.println(calendar);


        //使用给定的 Date 设置此 Calendar 的时间
        Date date = calendar.getTime();

        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, 8);
        System.out.println("当前时间日设置为8后,时间是:" + calendar.getTime());
        calendar.add(Calendar.HOUR, 2);
        System.out.println("当前时间加2小时后,时间是:" + calendar.getTime());
        calendar.add(Calendar.MONTH, -2);
        System.out.println("当前日期减2个月后,时间是:" + calendar.getTime());

        // 显示2020年10月1号的时间戳！
        calendar.set(2020, 10, 1);
        long timeInMillis = calendar.getTimeInMillis();
        System.out.println(timeInMillis); // 1604233191552
    }
}

时区TimeZone

时区也是通过静态方法获取

System.out.println(TimeZone.getDefault());

输出为：

// sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null]

static String[]	getAvailableIDs()获取支持的所有可用ID。
static String[]	getAvailableIDs(int rawOffset)根据给定的时区偏移（以毫秒为单位）获取可用ID。
static TimeZone	getDefault()获取Java虚拟机的默认值 TimeZone 。
static TimeZone	getTimeZone(String ID)获取给定ID的 TimeZone 。
static TimeZone	getTimeZone(ZoneId zoneId)获取 TimeZone对于给定 zoneId 。
static void	setDefault(TimeZone zone)设置 TimeZone由返回 getDefault方法。

比如现在想获取美国的时间：

注：美国本土横跨西五区至西八区，共四个时区，每个时区对应一个标准时间。以华盛顿的西五区为例，西五区的id就是（GMT-05:00）；

public static void main(String[] args) {
    System.out.println(new Date());
    Calendar calendar = Calendar.getInstance();
    calendar.setTimeZone(TimeZone.getTimeZone("GMT-08:00"));
    System.out.println(calendar.get(Calendar.HOUR_OF_DAY));
}

ZoneId

ZoneId是指区域ID，可以这样表示 Europe/London Asia/Shanghai America/New_York Japan

也可以这样 GMT+8:00 也行

就是地区的表示方法

Calendar calendar = Calendar.getInstance();
calendar.setTimeZone(TimeZone.getTimeZone("America/New_York"));
calendar.setTimeZone(TimeZone.getTimeZone(ZoneId.of("America/New_York")));
System.out.println(calendar);

simpleDateFormat

Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。

它允许进行格式化（日期->文本）、解析（文本->日期）

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

时间模式其实就是一种时间显示的格式：

• yyyy 代表年 yy只显示后两位
• MM 代表月
• dd 代表日
• HH代表小时 24小时制 hh 12小时
• mm代表分钟
• ss代表秒

yyyy年MM月dd日 HH小时mm分ss秒 就是一种日期时间模式。

public void test2(){
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        String format = sdf.format(date); 
        System.out.println(format);  //2022/02/27 20:34:23
}

 

主要方法

applyPattern(String pattern) 

给定的模式字符串应用于此日期格式。

String format(Date date) 

将日期格式化成日期/时间字符串。–进行了重写

Date parse(String source) 

从给定字符串的开始解析文本以生成日期。–进行了重写

JDK8时间类

在JDK8之前，处理日期时间，我们用的都是上边几个类，即使上边几个类的方法大面积过时，同时还存在一些问题，比如SimpleDateFormat 不是线程安全的，比如 Date 和 Calendar 获取到的月份是0到11，而不是现实生活中的1到12，我们还是能在绝大部分代码中看到它的影子。

阿里巴巴规约中这样说，如果是jdk8的应用，可以使用Instant代替date，LocalDateTime代替Canlendar，DateTimeFormatter代替SimpleDateFormat。

Instant

• 在时间线上的瞬间点。

  该类在时间线上建立单个瞬时点。 这可能用于在应用程序中记录事件时间戳。

通过观察源代码发现他的构造器是私有化的：

private Instant(long epochSecond, int nanos) {
        super();
        this.seconds = epochSecond;
        this.nanos = nanos;
}

Instant获取实例

事实上它给我们提供了很多静态方法，方便我们使用：

既然Instant可以代替Date类，那它肯定可以获取当前时间：

public void test1(){
        // 获取当前时间
        Instant instant = Instant.now();
        // 这个时间比北京时间少了8个小时，如果要输出北京时间，可以加上默认时区：
        System.out.println(instant);  // 2022-02-27T12:52:12.454Z

        // 如果要输出北京时间，可以加上默认时区
        System.out.println(instant.atZone(ZoneId.systemDefault()));  
       // 2022-02-27T20:56:09.086+08:00[Asia/Shanghai]
}

 

获取时间戳

public void test2(){
        // 获取当前时间
        Instant instant = Instant.now();
        // 获取当前时间戳:单位为秒
        long epochSecond = instant.getEpochSecond(); // 1645966750
        System.out.println(epochSecond);
        // 获取当前时间戳:单位为毫秒
        long l = instant.toEpochMilli();  // 1645966750083
        System.out.println(l);
}

 

将时间戳转换为Instant

• 根据秒数时间戳转换
• 根据毫秒数时间戳转换

public void test3(){
        Instant instant = Instant.now();
        System.out.println(instant);  // 2022-02-27T13:07:03.262Z
        long epochSecond = instant.getEpochSecond();  
        System.out.println(epochSecond);  // 1645967223
        // 将时间戳转换为Instant
        // 根据秒数时间戳转换：
        // 使用从1970-01-01T00：00：00Z的时代开始的秒数获得一个 Instant的实例。
        Instant instant1 = Instant.ofEpochSecond(epochSecond);
        System.out.println(instant1);  // 2022-02-27T13:07:03Z
        // 使用从1970-01-01T00：00：00Z的时期开始的秒数获得 Instant的实例， Instant获得秒的纳秒分数。
        Instant instant2 = Instant.ofEpochSecond(epochSecond, instant.getNano());  
        System.out.println(instant2);  // 2022-02-27T13:07:03.262Z


        // 根据毫秒数时间戳转换：
        long l = instant.toEpochMilli();
        System.out.println(l);  // 1645967223262

        Instant instant3 = Instant.ofEpochMilli(l);
        System.out.println(instant3);  // 2022-02-27T13:07:03.262Z

}

 

将表达式转换为Instant

public void test4(){
        String text = "2022-02-28T08:50:01.967Z";
        Instant parseInstant = Instant.parse(text);
        System.out.println("秒时间戳:" + parseInstant.getEpochSecond());
        System.out.println("毫秒时间戳:" + parseInstant.toEpochMilli());
        System.out.println("纳秒:" + parseInstant.getNano());
}

 

Duration

Duration（持续时间）是TemporalAmount（时间量）的子类。

主要用在，instant的日期计算

public void test1(){
        // 获取当前时间
        Instant instant = Instant.now();
        // 当前的时间加7天
        Instant plus = instant.plus(Duration.ofDays(7));
        System.out.println(LocalDateTime.ofInstant(plus, ZoneId.systemDefault()));
}

 

我们可以轻易的通过of方法获取一段持续的时间，用来做计算。

Duration.ofDays(3);
Duration.ofHours(3);
Duration.ofMinutes(3);
Duration.ofSeconds(3);
Duration.ofMillis(3);

// 次方法时通用的，第一个参数是数字，第二个是单位，ChronoUnit是一个枚举类，就是枚举了一堆的时间单位：年月日时分秒。
Duration.of(3, ChronoUnit.YEARS);

LocalDate

• LocalDate是一个不可变的日期时间对象，表示日期，通常被视为年月日。 也可以访问其他日期字段，例如日期，星期几和星期。 例如，值“2007年10月2日”可存储在LocalDate 。

  该类不存储或表示时间或时区。 相反，它是日期的描述，用于生日。 它不能代表时间线上的即时信息，而没有附加信息，如偏移或时区。

• 这个类是不可变的和线程安全的。

获取当前日期

使用LocalDate获取当前日期非常简单，如下所示：

LocalDate now = LocalDate.now();
System.out.println(now);  // 2022-02-27

不用任何格式化，输出结果就非常友好，如果使用Date，输出这样的格式，还得配合SimpleDateFormat指定yyyy-MM-dd进行格式化。

获取年月日

public class LocalDateTest {
    public static void main(String[] args) {
        LocalDate now = LocalDate.now();
        System.out.println(now);  // 2022-02-27


        int year = now.getYear();
        int monthValue = now.getMonthValue();
        int dayOfMonth = now.getDayOfMonth();

        System.out.println(year);  // 2022
        System.out.println(monthValue);  // 2
        System.out.println(dayOfMonth);  // 27
    }
}

我们发现Month是一个枚举类，而且LocalDate的月份居然是从1开始的，从此月份的困扰就解决了。

指定日期

LocalDate birthday = LocalDate.of(1999,6, 12);
System.out.println("birthday: " + birthday); // birthday: 1999-06-12

如果确定月份，推荐使用另一个重载方法，使用枚举指定月份：

LocalDate specifiedDate = LocalDate.of(1999, Month.JULY, 16);

比较日期是否相等

LocalDate localDate1 = LocalDate.now();
        LocalDate localDate2 = LocalDate.of(1999,6,12);
        if (localDate1.equals(localDate2)) {
            System.out.println("====");
}

获取日期是本周/本月/本年的第几天

LocalDate today = LocalDate.now();
System.out.println("Today:" + today);  // Today:2022-02-27
System.out.println("Today is:" + today.getDayOfWeek());  // Today is:SUNDAY
System.out.println("今天是本周的第" + today.getDayOfWeek().getValue() + "天");  // 今天是本周的第7天
System.out.println("今天是本月的第" + today.getDayOfMonth() + "天");  //  今天是本月的第27天
System.out.println("今天是本年的第" + today.getDayOfYear() + "天");  // 今天是本年的第58天

判断是否为闰年

System.out.println(today.getYear() + " is leap year:" + today.isLeapYear());

LocalTime

• LocalTime是一个不可变的日期时间对象，代表一个时间，通常被看作是小时 - 秒。 时间表示为纳秒精度。 例如，值“13：45.30.123456789”可以存储在LocalTime 。

  它不存储或表示日期或时区。 相反，它是在挂钟上看到的当地时间的描述。 它不能代表时间线上的即时信息，而没有附加信息，如偏移或时区。

• 这个类是不可变的和线程安全的。

获取当前时间

LocalTime time = LocalTime.now();
System.out.println(time);  // 21:31:10.531

LocalTime tiem2 = LocalTime.of(23, 45);
System.out.println(tiem2);  // 23:45

获取时、分

int hour = time.getHour();
int second = time.getSecond();
int minute = time.getMinute();

System.out.println(hour);  // 21
System.out.println(minute);  // 58
System.out.println(second);  // 43

LocalDateTime

• LocalDateTime是一个不可变的日期时间对象，代表日期时间，通常被视为年 - 月 - 日 - 时 - 分 - 秒。 也可以访问其他日期和时间字段，例如日期，星期几和星期。 时间表示为纳秒精度。 例如，值“2007年10月2日在13：45.30.123456789”可以存储在LocalDateTime 。
• 这个类是不可变的和线程安全的。

常用方法与LocalDate、LocalTime类类似。

DateTimeFormatter

JDK8中推出了java.time.format.DateTimeFormatter来处理日期格式化问题，《阿里巴巴Java开发手册》中也是建议使用DateTimeFormatter代替SimpleDateFormat，因为SimpleDateFormate不是线程安全的。

LocalDate today = LocalDate.now();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");

String format = today.format(dateTimeFormatter);
System.out.println(format);

类型相互转换

Instant和Date

JDK8中，Date新增了from()方法，将Instant转换为Date，代码如下所示：

Date date = Date.from(instant);

 

Instant dateToInstant = date.toInstant();

 

Instance和LocalDateTime

LocalDateTime localDateTime = LocalDateTime.ofInstant(instant)

 

Instant instant1 = LocalDateTime.now().toInstant(ZoneOffset.UTC);

Date和LocalDateTime

Date date = new Date();
Instant instant = date.toInstant();
LocalDateTime localDateTimeOfInstant = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());

 

LocalDateTime localDateTime = LocalDateTime.now();
Instant toInstant = localDateTime.atZone(ZoneId.systemDefault()).toInstant();
Date dateFromInstant = Date.from(toInstant);

数学类

Math

java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。

	double ceil(double d) : 返回不小于d的最小整数
    double floor(double d): 返回不大于d的最大整数
    int round(float f) : 返回最接近f的int型（四舍五入）
    long round(double d):返回最接近d的long型
    double abs(double d):
	double max(double d1, double d2) : 返回较大值
    int min(int i1, int i2) :　返回较小值
    double random() : 返回一个大于等于0.0并且小于1.0的随机数

 

System.out.println(Math.E);//比任何其他值都更接近 e（即自然对数的底数）的 double 值。
System.out.println(Math.PI);//比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。

System.out.println(Math.max(1, 2));//输出2
System.out.println(Math.min(1.9, -0.2));//输出-0.2
System.out.println((int)(Math.random()*100));//输出[0,100)间的随机数

//ceil(a) 返回大于a的第一个整数所对应的浮点数(值是整的，类型是浮点型)
//可以通过强制转换将类型换成整型
System.out.println(Math.ceil(1.3443));//输出2.0
System.out.println((int)Math.ceil(1.3443));//输出2

//floor(a) 返回小于a的第一个整数所对应的浮点数(值是整的，类型是浮点型)
System.out.println(Math.floor(1.3443));//输出1.0

//rint(a) 返回最接近a的整数的double值
System.out.println(Math.rint(1.2));//输出1.0
System.out.println(Math.rint(1.8));//输出2.0

System.out.println(Math.sqrt(4.0));//输出2.0
System.out.println(Math.cbrt(8.0));//输出2.0

System.out.println(Math.abs(-10));//输出10

BigInteger类

Integer类作为int的包装类，能存储的最大整型值为2^31-1，BigInteger类的数字范围较Integer类的数字范围要大得多，可以支持任意精度的整数。

在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是对象，我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。

构造方法

• BigDecimal 有很多重载的构造器，我们几乎可以将任何数字相关的类型转化为一个BigDecimal 对象。
  

  构造器
  BigDecimal(int)	创建一个具有参数所指定整数值的对象。
  BigDecimal(double)	创建一个具有参数所指定双精度值的对象。
  BigDecimal(long)	创建一个具有参数所指定长整数值的对象。
  BigDecimal(String)	创建一个具有参数所指定以字符串表示的数值的对象。

常用方法

• BigDecimal提供了大量的计算方法，我们举几个例子
  

  返回值	方法名	解释
  BigDecimal	add(BigDecimal)	BigDecimal对象中的值相加，然后返回这个对象。
  BigDecimal	subtract(BigDecimal)	BigDecimal对象中的值相减，然后返回这个对象。
  BigDecimal	multiply(BigDecimal)	BigDecimal对象中的值相乘，然后返回这个对象。
  BigDecimal	divide(BigDecimal)	BigDecimal对象中的值相除，然后返回这个对象。
  BigDecimal	maxopen in new window(BigDecimalopen in new window val)
  BigDecimal	min(BigDecimal val)

  我们可以从BigDecimal中获取对应的值：

  返回值	方法	描述
  double	doubleValue()	将BigDecimal对象中的值以双精度数返回
  float	floatValue()	将BigDecimal对象中的值以单精度数返回
  long	longValue()	将BigDecimal对象中的值以长整数返回
  int	intValue()	将BigDecimal对象中的值以整数返回

Random类

Random类位于java.util.Random包下，是产生随机数的类。

• 该类的实例用于生成伪随机数的流。 该类使用48位种子，其使用线性同余公式进行修改。
• 如果使用相同的种子创建两个Random Random ，并且对每个实例进行相同的方法调用序列，则它们将生成并返回相同的数字序列。

当然 Math类的Random方法可以生成随机数

 

构造方法

1.Random()：创建一个新的随机数生成器。

2.Random(long seed)：使用单个 long 种子创建一个新的随机数生成器。

我们可以在构造Random对象的时候指定种子。如：Random r1 = new Random(20);

也可以默认当前系统时间的毫秒数作为种子数:Random r1 = new Random();

常用方法

1.protected int next(int bits)：生成下一个伪随机数。

2.boolean nextBoolean()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的boolean值。

3.void nextBytes(byte[] bytes)：生成随机字节并将其置于用户提供的 byte 数组中。

4.double nextDouble()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的 double值。

5.float nextFloat()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布float值。

6.double nextGaussian()：返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的double值，其平均值是0.0 标准差是1.0。

7.int nextInt()：返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。

8.int nextInt(int n)：返回一个伪随机数，它是取自此随机数生成器序列的、在（包括和指定值（不包括）之间均匀分布的int值。

9.long nextLong()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。

Arrays 工具类

该类包含用于操作数组的各种方法（如排序和搜索）。 该类还包含一个静态工厂，可以将数组视为列表。

包含了大量的关于数组的工具方法，比如数组拷贝，排序，二分查找等。其实，这里边的每一个方法，我们都能自己实现。

更友好的显示数组

toString(int[] a)

System.out.println(Arrays.toString(nums));
[1, 2, 3, 5, 6, 9]
否则就是：I@1b6d3586

排序

这里的排序算法要远远的胜过我们写的

parallelSort(int[] a);
sort(int[] a);

int[] nums = {1,3,9,2,5,6};
Arrays.sort(nums);
System.out.println(Arrays.toString(nums));

[1, 2, 3, 5, 6, 9]

二分查找

binarySearch(int[] a, int key)

int[] nums = {1, 2, 3, 5, 6, 9};
int i = Arrays.binarySearch(nums, 5);
System.out.println(i);

结果：3   这是下标

数组拷贝

copyOf(int[] original, int newLength)

int[] nums = {1, 2, 3, 5, 6, 9};
nums = Arrays.copyOf(nums,10);
System.out.println(Arrays.toString(nums));

结果：[1, 2, 3, 5, 6, 9, 0, 0, 0, 0]

copyOfRange(int[] original, int from, int to)

int[] nums = {1, 2, 3, 5, 6, 9};
nums = Arrays.copyOfRange(nums,0,2);
System.out.println(Arrays.toString(nums));

结果：[1, 2]

两个数组的比较

equals(int[] a, int[] a2)

int[] nums = {1, 2, 3, 5, 6, 9};
int[] nums2 = {1, 2, 3, 5, 6, 9};
System.out.println(Arrays.equals(nums,nums2));

结果：true

微信关注