常用API

API

包裝類

Java提供了兩大類資料型別，基本型別與引用型別，使用基本型別在於效率，但是缺少像引用資料型別一樣的豐富API，那麼Java提供了針對基本資料型別的包裝類，以提供更加便捷的操作功能，包裝類就是把基本資料型別包裝成對應的引用資料型別。

序號	基本資料型別	包裝類（java.lang包）
1	byte	Byte
2	short	Short
3	int	Integer
4	long	Long
5	float	Float
6	double	Double
7	char	Character
8	boolean	Boolean

裝箱與拆箱

裝箱：把基本資料型別轉為包裝類物件。

轉為包裝類的物件，是為了使用專門為物件設計的API和特性

拆箱：把包裝類物件拆為基本資料型別。

轉為基本資料型別，一般是因為需要運算，Java中的大多數運算子是為基本資料型別設計的。比較、算術等

基本數值---->包裝物件

Integer i1 = new Integer(4);//使用建構函式函式
Integer i2 = Integer.valueOf(4);//使用包裝類中的valueOf方法
Integer i3 = 10; // 自動裝箱

包裝物件---->基本數值

Integer i1 = new Integer(4);

int num1 = i1.intValue(); 
int num2 = i1; //自動拆箱

JDK1.5之後，可以自動裝箱與拆箱。

注意：只能與自己對應的型別之間才能實現自動裝箱與拆箱。

Integer i = 4;//自動裝箱。相當於Integer i = Integer.valueOf(4);
i = i + 5;//等號右邊：將i物件轉成基本數值(自動拆箱) i.intValue() + 5;
//加法運算完成後，再次裝箱，把基本數值轉成物件。

Integer i = 1;
Double d = 1;//錯誤的，1是int型別

總結：物件（引用資料型別）能用的運算子有哪些？

（1）instanceof

（2）=：賦值運算子

（3）==和!=：用於比較地址，但是要求左右兩邊物件的型別一致或者是有父子類繼承關係。

（4）對於字串這一種特殊的物件，支援“+”，表示拼接。

包裝類的常用API

基本資料型別和字串之間的轉換

把基本資料型別轉為字串

int a = 10;
//方式一：
String str = a + "";
//方式二：
String str = String.valueOf(a);
//方式三：
Integer i=10;
String str=i.toString();

把字串轉為基本資料型別

String轉換成對應的基本型別 ，除了Character類之外，其他所有包裝類都具有parseXxx靜態方法可以將字串引數轉換為對應的基本型別，例如：

• public static int parseInt(String s)：將字串引數轉換為對應的int基本型別。
• public static long parseLong(String s)：將字串引數轉換為對應的long基本型別。
• public static double parseDouble(String s)：將字串引數轉換為對應的double基本型別

int a = Integer.parseInt("整數的字串");
double d = Double.parseDouble("小數的字串");
boolean b = Boolean.parseBoolean("true或false");

int a = Integer.valueOf("整數的字串");
double d = Double.valueOf("小數的字串");
boolean b = Boolean.valueOf("true或false");

資料型別的最大最小值

Integer.MAX_VALUE和Integer.MIN_VALUE
Long.MAX_VALUE和Long.MIN_VALUE
Double.MAX_VALUE和Double.MIN_VALUE

字元轉大小寫

Character.toUpperCase('x');
Character.toLowerCase('X');

整數轉進位制

Integer.toBinaryString(int i) //二進位制
Integer.toHexString(int i)    // 八進位制
Integer.toOctalString(int i)  // 十六進位制

數值比較

Double.compare(double b1,double b2);  //比較基本資料型別

compareTo(Double anotherDouble) ; //對兩個 Double 物件所表示的數值進行比較。
//new Double(d1).compareTo(new Double(d2))

包裝類物件的快取問題

​ 賦值問題:

Double num = 10  //報錯，10是int型別不能賦值給Double

​ 緩衝區問題:

包裝類的資料在快取數值範圍內時，直接從記憶體中取出物件，超過範圍會建立新的物件

包裝類	快取物件
Byte	-128~127
Short	-128~127
Integer	-128~127
Long	-128~127
Float	沒有
Double	沒有
Character	0~127
Boolean	true和false

	@Test
	public void test3(){
        Integer i = 1;
        Integer j = 1;
        System.out.println(i == j);//true

        Integer i = 128;
        Integer j = 128;
        System.out.println(i == j);//false

        Integer i = new Integer(1);//新new的在堆中
        Integer j = 1;//這個用的是緩衝的常量物件，在方法區
        System.out.println(i == j);//false

        Integer i = new Integer(1);//新new的在堆中
        Integer j = new Integer(1);//另一個新new的在堆中
        System.out.println(i == j);//false
        
		Double d1 = 1.0;
		Double d2 = 1.0;
		System.out.println(d1==d2);//false 比較地址，沒有快取物件，每一個都是新new的
	}

​

不可變問題

   @Test
    public void test03(){
        Integer i =10;
        System.out.println(i); //10
        change(i);
        System.out.println(i); //10
    }

    private void change(Integer i) {
        i=20;
        System.out.println(i); //20
    }

​ 數值比較問題

 @Test
    public void test04(){
        Integer a =10;
        Integer b= 20;
        int p =20; 
        System.out.println(a==b);  //false
        System.out.println(b==20); //true
        System.out.println(b==p);  //true
    }

Math類

java.lang.Math 類包含用於執行基本數學運算的方法，如初等指數、對數、平方根和三角函式。類似這樣的工具類，其所有方法均為靜態方法，並且不會建立物件，呼叫起來非常簡單。

• public static final double PI：返回圓周率

double pi = Math.PI;

• public static double abs(double a) ：返回 double 值的絕對值。

double d1 = Math.abs(-5); //d1的值為5
double d2 = Math.abs(5); //d2的值為5

• public static double ceil(double a) ：返回大於等於引數的最小的整數。

double d1 = Math.ceil(3.3); //d1的值為 4.0
double d2 = Math.ceil(-3.3); //d2的值為 -3.0
double d3 = Math.ceil(5.1); //d3的值為 6.0

• public static double floor(double a) ：返回小於等於引數最大的整數。

double d1 = Math.floor(3.3); //d1的值為3.0
double d2 = Math.floor(-3.3); //d2的值為-4.0
double d3 = Math.floor(5.1); //d3的值為 5.0

• public static long round(double a) ：返回最接近引數的 long。(相當於四捨五入方法)

long d1 = Math.round(5.5); //d1的值為6.0
long d2 = Math.round(5.4); //d2的值為5.0

• 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 double max(double x, double y)：返回x,y中的最大值
• public static double min(double x, double y)：返回x,y中的最小值

double result = Math.pow(2,31);
double sqrt = Math.sqrt(256);
double rand = Math.random();

java.util.Random

用於產生隨機數

• public Random():建立一個新的隨機數生成器。此構造方法將隨機數生成器的種子設定為某個值，該值與此構造方法的所有其他呼叫所用的值完全不同。(沒有真正的隨機數，需要種子產生隨機數，同一個種子產生的偽隨機數序列相同)
• public Random(long seed):使用單個 long 種子建立一個新的隨機數生成器。該種子是偽隨機數生成器的內部狀態的初始值，該生成器可透過方法 next(int) 維護。

• boolean nextBoolean():返回下一個偽隨機數，它是取自此隨機數生成器序列的均勻分佈的 boolean 值。

• void nextBytes(byte[] bytes):生成隨機位元組並將其置於使用者提供的 byte 陣列中。

• double nextDouble():返回下一個偽隨機數，它是取自此隨機數生成器序列的、在 0.0 和 1.0 之間均勻分佈的 double 值。

• float nextFloat():返回下一個偽隨機數，它是取自此隨機數生成器序列的、在 0.0 和 1.0 之間均勻分佈的 float 值。

• int nextInt():返回下一個偽隨機數，它是此隨機數生成器的序列中均勻分佈的 int 值。

• int nextInt(int n):返回一個偽隨機數，它是取自此隨機數生成器序列的、在 0（包括）和指定值（不包括）之間均勻分佈的 int 值。

• long nextLong():返回下一個偽隨機數，它是取自此隨機數生成器序列的均勻分佈的 long 值。

	@Test
	public void test03(){
		Random r = new Random();
		System.out.println("隨機整數：" + r.nextInt());
		System.out.println("隨機小數：" + r.nextDouble());
		System.out.println("隨機布林值：" + r.nextBoolean());
	}

BigInteger

不可變的任意精度的整數。

• BigInteger(String val)
• BigInteger add(BigInteger val)
• BigInteger subtract(BigInteger val)
• BigInteger multiply(BigInteger val)
• BigInteger divide(BigInteger val)
• BigInteger remainder(BigInteger val)
• int intValue():將此 BigInteger 轉換為 int。
• long longValue():將此 BigInteger 轉換為 long。
• float floatValue():將此 BigInteger 轉換為 float。

	@Test
	public void test01(){
//		long bigNum = 123456789123456789123456789L;
		
		BigInteger b1 = new BigInteger("123456789123456789123456789");
		BigInteger b2 = new BigInteger("78923456789123456789123456789");
		
//		System.out.println("和：" + (b1+b2));//錯誤的，無法直接使用+進行求和
		
		System.out.println("和：" + b1.add(b2));
		System.out.println("減：" + b1.subtract(b2));
		System.out.println("乘：" + b1.multiply(b2));
		System.out.println("除：" + b2.divide(b1));
		System.out.println("餘：" + b2.remainder(b1));
	}

BigDecimal

不可變的、任意精度的有符號十進位制數。

• BigDecimal(String val)
• BigDecimal add(BigDecimal val)
• BigDecimal subtract(BigDecimal val)
• BigDecimal multiply(BigDecimal val)
• BigDecimal divide(BigDecimal val)
• BigDecimal divide(BigDecimal divisor, int roundingMode)
• BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)
• BigDecimal remainder(BigDecimal val)
• double doubleValue():將此 BigDecimal 轉換為 double。

@Test
	public void test02(){
		/*double big = 12.123456789123456789123456789;
		System.out.println("big = " + big);*/
		
		BigDecimal b1 = new BigDecimal("123.45678912345678912345678912345678");
		BigDecimal b2 = new BigDecimal("7.8923456789123456789123456789998898888");
		
//		System.out.println("和：" + (b1+b2));//錯誤的，無法直接使用+進行求和
		
		System.out.println("和：" + b1.add(b2));
		System.out.println("減：" + b1.subtract(b2));
		System.out.println("乘：" + b1.multiply(b2));
		System.out.println("除：" + b1.divide(b2,20,RoundingMode.UP));//divide(BigDecimal divisor, int scale, int roundingMode)
		System.out.println("除：" + b1.divide(b2,20,RoundingMode.DOWN));//divide(BigDecimal divisor, int scale, int roundingMode)
		System.out.println("餘：" + b1.remainder(b2));
	}
	//保留兩位小數的方式：
	@Test
	public void test02(){
        double f = 111231.5585;
		BigDecimal bg = new BigDecimal(f);
		double f1 = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
		System.out.println(f1);
    }

陣列工具類(Arrays)

java.util.Arrays陣列工具類，提供了很多靜態方法來對陣列進行操作，而且如下每一個方法都有各種過載形式，以下只列出int[]型別的，其他型別的陣列類推：

• static int binarySearch(int[] a, int key) ：要求陣列有序，在陣列中查詢key是否存在，如果存在返回第一次找到的下標，不存在返回負數

• static int[] copyOf(int[] original, int newLength) ：根據original原陣列複製一個長度為newLength的新陣列，並返回新陣列

• static int[] copyOfRange(int[] original, int from, int to) ：複製original原陣列的[from,to)構成新陣列，並返回新陣列

• static boolean equals(int[] a, int[] a2) ：比較兩個陣列的長度、元素是否完全相同

• static void fill(int[] a, int val) ：用val填充整個a陣列

• static void fill(int[] a, int fromIndex, int toIndex, int val)：將a陣列[fromIndex,toIndex)部分填充為val

• static void sort(int[] a) ：將a陣列按照從小到大進行排序

• static void sort(int[] a, int fromIndex, int toIndex) ：將a陣列的[fromIndex, toIndex)部分按照升序排列

• static String toString(int[] a) ：把a陣列的元素，拼接為一個字串，形式為：[元素1，元素2，元素3。。。]

import java.util.Arrays;
import java.util.Random;
public class Test{
    public static void main(String[] args){
    	int[] arr = new int[5];
        // 列印陣列,輸出地址值
  		System.out.println(arr); // [I@2ac1fdc4
  		// 陣列內容轉為字串
    	System.out.println("arr陣列初始狀態："+ Arrays.toString(arr));
    	
    	Arrays.fill(arr, 3);
    	System.out.println("arr陣列現在狀態："+ Arrays.toString(arr));
    	
    	Random rand = new Random();
    	for (int i = 0; i < arr.length; i++) {
			arr[i] = rand.nextInt(100);//賦值為100以內的隨機整數
		}
    	System.out.println("arr陣列現在狀態："+ Arrays.toString(arr));
    	
    	int[] arr2 = Arrays.copyOf(arr, 10);
    	System.out.println("新陣列：" + Arrays.toString(arr2));
    	
    	System.out.println("兩個陣列的比較結果：" + Arrays.equals(arr, arr2));
    	
    	Arrays.sort(arr);
    	System.out.println("arr陣列現在狀態："+ Arrays.toString(arr));
    }
}

日期時間API

java.util.Date

new Date()：當前系統時間

long getTime()：返回該日期時間物件距離1970-1-1 0.0.0 0毫秒之間的毫秒值

new Date(long 毫秒)：把該毫秒值換算成日期時間物件

	@Test
	public void test5(){
		long time = Long.MAX_VALUE;
		Date d = new Date(time);
		System.out.println(d);
	}
	
	@Test
	public void test4(){
		long time = 1559807047979L;
		Date d = new Date(time);
		System.out.println(d);
	}
	@Test
	public void test3(){
		Date d = new Date();
		long time = d.getTime();
		System.out.println(time);//1559807047979
	}
	
	@Test
	public void test2(){
		long time = System.currentTimeMillis();
		System.out.println(time);//1559806982971
		//當前系統時間距離1970-1-1 0:0:0 0毫秒的時間差，毫秒為單位
	}
	
	@Test
	public void test1(){
		Date d = new Date();
		System.out.println(d);//Sun May 12 08:11:15 CST(China Standard Time ) 2024 
	}

java.text.SimpleDateFormat

​ SimpleDateFormat用於日期時間的格式化。

@Test
	public void test10() throws ParseException{
		String str = "2019年06月06日 16時03分7秒 545毫秒  星期四 +0800";
		SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH時mm分ss秒 SSS毫秒  E Z");
		Date d = sf.parse(str);
		System.out.println(d);
	}
	
	@Test
	public void test9(){
		Date d = new Date();

		SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH時mm分ss秒 SSS毫秒  E Z");
		//把Date日期轉成字串，按照指定的格式轉
		String str = sf.format(d);
		System.out.println(str);
	}

jdk8後(推薦使用)

LocalDate、LocalTime、LocalDateTime

本地日期時間類

方法	描述
now() / now(ZoneId zone)	靜態方法，根據當前時間建立物件/指定時區的物件
of()	靜態方法，根據指定日期/時間建立物件
getDayOfMonth()/getDayOfYear()	獲得月份天數(1-31) /獲得年份天數(1-366)
getDayOfWeek()	獲得星期幾(返回一個 DayOfWeek 列舉值)
getMonth()	獲得月份, 返回一個 Month 列舉值
getMonthValue() / getYear()	獲得月份(1-12) /獲得年份
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)	將指定格式的字串解析為日期、時間

	@Test
	public void test7(){
		LocalDate now = LocalDate.now();
		LocalDate before = now.minusDays(100);
		System.out.println(before);//2019-02-26
	}
	
	@Test
	public void test06(){
		LocalDate lai = LocalDate.of(2019, 5, 13);
		LocalDate go = lai.plusDays(160);
		System.out.println(go);//2019-10-20
	}
	
	@Test
	public void test05(){
		LocalDate lai = LocalDate.of(2019, 5, 13);
		System.out.println(lai.getDayOfYear()); 
	}
	
	
	@Test
	public void test04(){
		LocalDate lai = LocalDate.of(2019, 5, 13);
		System.out.println(lai);
	}
	
	@Test
	public void test03(){
		LocalDateTime now = LocalDateTime.now();
		System.out.println(now);
	}
	
	@Test
	public void test02(){
		LocalTime now = LocalTime.now();
		System.out.println(now);
	}
	
	@Test
	public void test01(){
		LocalDate now = LocalDate.now();
		System.out.println(now);
	}

持續日期/時間：Period和Duration

Period:用於計算兩個“日期”間隔

public static void main(String[] args) {
		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());//1年
		System.out.println("相差的月數："+between.getMonths());//又7個月
		System.out.println("相差的天數："+between.getDays());//零25天
		System.out.println("相差的總數："+between.toTotalMonths());//總共19個月
	}

Duration:用於計算兩個“時間”間隔

	public static void main(String[] args) {
		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());
	}

瞬時：Instant

@Test
public void test03(){
    /*
    Instant代表時間線上的一個瞬時點，是自1970年1月1日0時0分0秒（UTC）以來的秒數（精確到納秒）。
    它主要用於需要高精度時間戳的場景，如記錄事件發生的時間點。
    */
    Instant t = Instant.now();
    System.out.println(t);
}

時區時間：ZondId和ZonedDateTime

import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Set;

public class TestZone {
    @Test
    public void test01() {
        //需要知道一些時區的id
        //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);
}

DateTimeFormatter：日期時間格式化

該類提供了三種格式化方法：

預定義的標準格式。如：DateTimeFormatter.ISO_DATE_TIME; ISO_DATE

	@Test
	public void test(){
		LocalDateTime now = LocalDateTime.now();
		//預定義的標準格式
		DateTimeFormatter df = DateTimeFormatter.ISO_DATE_TIME;//2019-06-06T16:38:23.756
        //格式化操作
		String str = df.format(now);
		System.out.println(str);
	}

本地化相關的格式。如：DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM)

	@Test
	public void test1(){
		LocalDateTime now = LocalDateTime.now();
		//本地化相關的格式
//		DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);//2019年6月6日 下午04時40分03秒
		DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);//19-6-6 下午4:40
        //格式化操作
		String str = df.format(now);
		System.out.println(str);
	}

自定義的格式。如：DateTimeFormatter.ofPattern(“yyyy-MM-dd hh:mm:ss”)

	@Test
	public void test2(){
		LocalDateTime now = LocalDateTime.now();
		//自定義的格式
		DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH時mm分ss秒  SSS毫秒  E 是這一年的D天");
         //格式化操作
		String str = df.format(now);
		System.out.println(str);
	}

把字串解析為日期物件(parse())

 public void test3(){
        //自定義的格式
        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy.MM.dd");
        //解析操作
        LocalDate parse = LocalDate.parse("2020.12.12", pattern);
        System.out.println(parse);
    }

系統相關類

java.lang.System類

系統類中很多好用的方法，其中幾個如下：

• static long currentTimeMillis() ：返回當前系統時間距離1970-1-1 0:0:0的毫秒值
• static void exit(int status) ：退出當前系統
• static void gc() ：執行垃圾回收器。
• static String getProperty(String key)：獲取某個系統屬性
• System.arraycopy（）；複製陣列

/*
        src:資料來源陣列
        srcPos: 資料來源陣列開始複製的下標
        dest:目標陣列
        destPos:目標陣列開始貼上的下標
        length:複製的數量
*/
static native void arraycopy(Object src,  int  srcPos,Object dest, int destPos,int length);

java.lang.Runtime類

每個 Java 應用程式都有一個 Runtime 類例項，使應用程式能夠與其執行的環境相連線。可以透過 getRuntime 方法獲取當前執行時。 應用程式不能建立自己的 Runtime 類例項。

public static Runtime getRuntime()： 返回與當前 Java 應用程式相關的執行時物件。

public long totalMemory()：返回 Java 虛擬機器中的記憶體總量。此方法返回的值可能隨時間的推移而變化，這取決於主機環境。

public long freeMemory()：回 Java 虛擬機器中的空閒記憶體量。呼叫 gc 方法可能導致 freeMemory 返回值的增加。

public long maxMemory(): 返回 Java 虛擬機器試圖使用的最大記憶體量。