foochane ：https://foochane.cn/article/2019122001.html

API（Application Programming Interface），應用程序編程接口。Java API是一本程序員的 字典 ，是JDK中提供給我們使用的類的說明文檔。這些類將底層的代碼實現(xiàn)封裝了起來，我們不需要關心這些類是如何實現(xiàn)的，只需要學習這些類如何使用即可。所以我們可以通過查詢API的方式，來學習Java提供的類，并得知如何使用它們。

1 Scanner類

1.1 引用類型的使用步驟

1. 導包

使用import關鍵字導包，在類的所有代碼之前導包，引入要使用的類型，java.lang包下的所有類無需導入。 格式：

import 包名.類名;

示例：

java.util.Scanner;

2. 創(chuàng)建對象

使用該類的構造方法，創(chuàng)建一個該類的對象。 格式：

數據類型  變量名  =  new 數據類型(參數列表);

示例：

Scanner sc = new Scanner(System.in);

3. 調用方法

調用該類的成員方法，完成指定功能。 格式：

變量名.方法名();

示例：

int i = sc.nextInt(); // 接收一個鍵盤錄入的整數

1.2 Scanner使用

使用Scanner類，完成接收鍵盤錄入數據的操作，代碼如下：

//1. 導包
import java.util.Scanner;
public class Demo01_Scanner {
   public static void main(String[] args) {  
     //2. 創(chuàng)建鍵盤錄入數據的對象   
       //System.in代表從鍵盤進行輸入
     Scanner sc = new Scanner(System.in);    
     //3. 接收數據    
     System.out.println("請錄入一個整數：");    
     int i = sc.nextInt();    
     //4. 輸出數據    
     System.out.println("i:"+i);    
   }  
}

2 Random類

此類的實例用于生成偽隨機數。

使用Random類，完成生成3個10以內的隨機整數的操作，代碼如下：

//1. 導包
import java.util.Random;
public class Demo01_Random {
   public static void main(String[] args) {  
        //2. 創(chuàng)建鍵盤錄入數據的對象
        Random r = new Random();
        for(int i = 0; i < 3; i++){
            //3. 隨機生成一個數據
            int number = r.nextInt(10);
            //4. 輸出數據
            System.out.println("number:"+ number);
        }      
    }
}

3 ArrayList類

java.util.ArrayList 是大小可變的數組的實現(xiàn)，存儲在內的數據稱為元素。此類提供一些方法來操作內部存儲的元素。 ArrayList 中可不斷添加元素，其大小也自動增長。

3.1 常用方法和遍歷

對于元素的操作,基本體現(xiàn)在——增、刪、查。常用的方法有：

• public boolean add(E e)：將指定的元素添加到此集合的尾部。
• public E remove(int index)：移除此集合中指定位置上的元素。返回被刪除的元素。
• public E get(int index) ：返回此集合中指定位置上的元素。返回獲取的元素。
• public int size() ：返回此集合中的元素數。遍歷集合時，可以控制索引范圍，防止越界。

3.2 如何存儲基本數據類型

ArrayList對象不能存儲基本類型，只能存儲引用類型的數據。類似 <int>不能寫，但是存儲基本數據類型對應的包裝類型是可以的。所以，想要存儲基本類型數據， <>中的數據類型，必須轉換后才能編寫，轉換寫法如下：

3 String類

java.lang.String 類代表字符串。Java程序中所有的字符串文字（例如 "abc" ）都可以被看作是實現(xiàn)此類的實例。

類String中包括用于檢查各個字符串的方法，比如用于比較字符串，搜索字符串，提取子字符串以及創(chuàng)建具有翻譯為大寫或小寫的所有字符的字符串的副本。

• 特點

1. 字符串不變：字符串的值在創(chuàng)建后不能被更改。

String s1 = "abc";
s1 += "d";
System.out.println(s1); // "abcd"
// 內存中有"abc"，"abcd"兩個對象，s1從指向"abc"，改變指向，指向了"abcd"。

2. 因為String對象是不可變的，所以它們可以被共享。

String s1 = "abc";
String s2 = "abc";
// 內存中只有一個"abc"對象被創(chuàng)建，同時被s1和s2共享。

3. "abc" 等效于 char[] data={ 'a' , 'b' , 'c' }。

例如：
String str = "abc";
相當于：
char data[] = {'a', 'b', 'c'};    
String str = new String(data);
// String底層是靠字符數組實現(xiàn)的。

2.1 字符串創(chuàng)建

構造方法：

• public String() ：初始化新創(chuàng)建的 String對象，以使其表示空字符序列。
• public String(char[] value) ：通過當前參數中的字符數組來構造新的String。
• public String(byte[] bytes) ：通過使用平臺的默認字符集解碼當前參數中的字節(jié)數組來構造新的String。

// 1. 使用空參構造
String str1 = new String(); // 小括號留空，說明字符串什么內容都沒有。

// 2. 根據字符數組創(chuàng)建字符串
char[] charArray = { 'A', 'B', 'C' };
String str2 = new String(charArray);

// 3. 根據字節(jié)數組創(chuàng)建字符串
byte[] byteArray = { 97, 98, 99 };
String str3 = new String(byteArray);

// 4. 直接創(chuàng)建
String str4 = "Hello";

2.2 判斷功能的方法

• public boolean equals (Object anObject) ：將此字符串與指定對象進行比較。
• public boolean equalsIgnoreCase (String anotherString)：將此字符串與指定對象進行比較，忽略大小寫

示例：

// 創(chuàng)建字符串對象
String s1 = "hello";
String s2 = "hello";
String s3 = "HELLO";

// boolean equals(Object obj):比較字符串的內容是否相同
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");

//boolean equalsIgnoreCase(String str):比較字符串的內容是否相同,忽略大小寫
System.out.println(s1.equalsIgnoreCase(s2)); // true
System.out.println(s1.equalsIgnoreCase(s3)); // true
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");

2.3 獲取功能的方法

• public int length ()：返回此字符串的長度。
• public String concat (String str) ：將指定的字符串連接到該字符串的末尾。
• public char charAt (int index) ：返回指定索引處的 char值
• public int indexOf (String str)：返回指定子字符串第一次出現(xiàn)在該字符串內的索引。
• public String substring (int beginIndex)：返回一個子字符串，從beginIndex開始截取字符串到字符
  串結尾。
• public String substring (int beginIndex, int endIndex)：返回一個子字符串，從beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

示例：

//創(chuàng)建字符串對象
String s = "helloworld";

// int length():獲取字符串的長度，其實也就是字符個數
System.out.println(s.length());
System.out.println("‐‐‐‐‐‐‐‐");

// String concat (String str):將將指定的字符串連接到該字符串的末尾.
String s = "helloworld";
String s2 = s.concat("**hello");
System.out.println(s2);// helloworld**hello

// char charAt(int index):獲取指定索引處的字符
System.out.println(s.charAt(0));
System.out.println(s.charAt(1));
System.out.println("‐‐‐‐‐‐‐‐");

// int indexOf(String str):獲取str在字符串對象中第一次出現(xiàn)的索引,沒有返回‐1
System.out.println(s.indexOf("l"));
System.out.println(s.indexOf("owo"));
System.out.println(s.indexOf("ak"));
System.out.println("‐‐‐‐‐‐‐‐");

// String substring(int start):從start開始截取字符串到字符串結尾
System.out.println(s.substring(0));
System.out.println(s.substring(5));
System.out.println("‐‐‐‐‐‐‐‐");

// String substring(int start,int end):從start到end截取字符串。含start，不含end。
System.out.println(s.substring(0, s.length()));
System.out.println(s.substring(3,8));

2.4 轉換功能的方法

• public char[] toCharArray () ：將此字符串轉換為新的字符數組。
• public byte[] getBytes () ：使用平臺的默認字符集將該 String編碼轉換為新的字節(jié)數組。
• public String replace (CharSequence target, CharSequence replacement)：將與target匹配的字符串使用replacement字符串替換。

示例：

//創(chuàng)建字符串對象
String s = "abcde";

// char[] toCharArray():把字符串轉換為字符數組
char[] chs = s.toCharArray();
for(int x = 0; x < chs.length; x++) {
    System.out.println(chs[x]);
}
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");

// byte[] getBytes ():把字符串轉換為字節(jié)數組
byte[] bytes = s.getBytes();
for(int x = 0; x < bytes.length; x++) {
    System.out.println(bytes[x]);
}
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");

//world替換為WORLD
String str = "hello world";
String replace = str.replace("world", "WORLD");
System.out.println(replace); // hello WORLD
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");

2.4 分割功能的方法

• public String[] split(String regex) ：將此字符串按照給定的regex（規(guī)則）拆分為字符串數組。

示例：

String str1 = "aaa,bbb,ccc";
String[] array1 = str1.split(",");
for (int i = 0; i < array1.length; i++) {
    System.out.println(array1[i]);
}
System.out.println("===============");

String str2 = "aaa bbb ccc";
String[] array2 = str2.split(" ");
for (int i = 0; i < array2.length; i++) {
    System.out.println(array2[i]);
}
System.out.println("===============");

String str3 = "XXX.YYY.ZZZ";
String[] array3 = str3.split("\\.");
System.out.println(array3.length); // 0
for (int i = 0; i < array3.length; i++) {
    System.out.println(array3[i]);
}

注意事項：

• split方法的參數其實是一個“正則表達式”
• 如果按照英文句點“.”進行切分，必須寫"\\."（兩個反斜杠）

4 Arrays類

java.util.Arrays類包含用來操作數組的各種方法，比如排序和搜索等。其所有方法均為靜態(tài)方法。

4.1 toString

• public static String toString(int[] a)：返回指定數組內容的字符串表示形式。

示例：

public static void main(String[] args) {
  // 定義int 數組
  int[] arr  =  {2,34,35,4,657,8,69,9};
  // 打印數組,輸出地址值
  System.out.println(arr); // [I@2ac1fdc4
  // 數組內容轉為字符串
  String s = Arrays.toString(arr);
  // 打印字符串,輸出內容
  System.out.println(s); // [2, 34, 35, 4, 657, 8, 69, 9]
}

4.2 sort

• public static void sort(int[] a)：對指定的 int 型數組按數字升序進行排序。

示例：

public static void main(String[] args) {
  // 定義int 數組
  int[] arr  =  {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
  System.out.println("排序前:"+ Arrays.toString(arr)); // 排序前:[24, 7, 5, 48, 4, 46, 35, 11, 6,
2]
  // 升序排序
  Arrays.sort(arr);
  System.out.println("排序后:"+ Arrays.toString(arr));// 排序后:[2, 4, 5, 6, 7, 11, 24, 35, 46,
48]
}

備注：

1. 如果是數值，sort默認按照升序從小到大
2. 如果是字符串，sort默認按照字母升序
3. 如果是自定義的類型，那么這個自定義的類需要有Comparable或者Comparator接口的支持。

5 Math類

java.lang.Math 類包含用于執(zhí)行基本數學運算的方法，如初等指數、對數、平方根和三角函數。類似這樣的工具類，其所有方法均為靜態(tài)方法，并且不會創(chuàng)建對象，調用起來非常簡單。

5.1 絕對值

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

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

5.2 向上取整

• 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

5.3 向下取整

• 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

5.4 四舍五入

• 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

6 Object類

6.1 概述

java.lang.Object類是Java語言中的根類，即所有類的父類。它中描述的所有方法子類都可以使用。在對象實例化的時候，最終找的父類就是Object。

如果一個類沒有特別指定父類， 那么默認則繼承自Object類。例如：

public class MyClass /*extends Object*/ {
    // ...
}

根據JDK源代碼及Object類的API文檔，Object類當中包含的方法有11個。主要學習其中的2個：

• public String toString()：返回該對象的字符串表示。
• public boolean equals(Object obj)：指示其他某個對象是否與此對象“相等”。

6.2 toString方法

方法摘要

• public String toString()：返回該對象的字符串表示。

toString方法返回該對象的字符串表示，其實該字符串內容就是對象的類型+@+內存地址值。

由于toString方法返回的結果是內存地址，而在開發(fā)中，經常需要按照對象的屬性得到相應的字符串表現(xiàn)形式，因此也需要重寫它。

覆蓋重寫

如果不希望使用toString方法的默認行為，則可以對它進行覆蓋重寫。例如自定義的Person類：

public class Person {  
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }

    // 省略構造器與Getter Setter
}

在IntelliJ IDEA中，可以點擊Code菜單中的Generate...，也可以使用快捷鍵alt+insert，點擊toString()選項。選擇需要包含的成員變量并確定。

6.3 equals方法

方法摘要

• public boolean equals(Object obj)：指示其他某個對象是否與此對象“相等”。

調用成員方法equals并指定參數為另一個對象，則可以判斷這兩個對象是否是相同的。這里的“相同”有默認和自定義兩種方式。

默認地址比較

如果沒有覆蓋重寫equals方法，那么Object類中默認進行==運算符的對象地址比較，只要不是同一個對象，結果必然為false。

對象內容比較

如果希望進行對象的內容比較，即所有或指定的部分成員變量相同就判定兩個對象相同，則可以覆蓋重寫equals方法。例如：

import java.util.Objects;

public class Person {   
    private String name;
    private int age;
    
    @Override
    public boolean equals(Object o) {
        // 如果對象地址一樣，則認為相同
        if (this == o)
            return true;
        // 如果參數為空，或者類型信息不一樣，則認為不同
        if (o == null || getClass() != o.getClass())
            return false;
        // 轉換為當前類型
        Person person = (Person) o;
        // 要求基本類型相等，并且將引用類型交給java.util.Objects類的equals靜態(tài)方法取用結果
        return age == person.age && Objects.equals(name, person.name);
    }
}

這段代碼充分考慮了對象為空、類型一致等問題，但方法內容并不唯一。大多數IDE都可以自動生成equals方法的代碼內容。在IntelliJ IDEA中，可以使用Code菜單中的Generate…選項，也可以使用快捷鍵alt+insert，并選擇equals() and hashCode()進行自動代碼生成。

6.4 Objects類

在剛才IDEA自動重寫equals代碼中，使用到了java.util.Objects類，那么這個類是什么呢？

在JDK7添加了一個Objects工具類，它提供了一些方法來操作對象，它由一些靜態(tài)的實用方法組成，這些方法是null-save（空指針安全的）或null-tolerant（容忍空指針的），用于計算對象的hashcode、返回對象的字符串表示形式、比較兩個對象。

在比較兩個對象的時候，Object的equals方法容易拋出空指針異常，而Objects類中的equals方法就優(yōu)化了這個問題。方法如下：

• public static boolean equals(Object a, Object b):判斷兩個對象是否相等。

我們可以查看一下源碼，學習一下：

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}

7 日期時間類

7.1 Date類

概述

java.util.Date類 表示特定的瞬間，精確到毫秒。

繼續(xù)查閱Date類的描述，發(fā)現(xiàn)Date擁有多個構造函數，只是部分已經過時，但是其中有未過時的構造函數可以把毫秒值轉成日期對象。

• public Date()：分配Date對象并初始化此對象，以表示分配它的時間（精確到毫秒）。
• public Date(long date)：分配Date對象并初始化此對象，以表示自從標準基準時間（稱為“歷元（epoch）”，即1970年1月1日00:00:00 GMT）以來的指定毫秒數。

tips: 由于我們處于東八區(qū)，所以我們的基準時間為1970年1月1日8時0分0秒。

簡單來說：使用無參構造，可以自動設置當前系統(tǒng)時間的毫秒時刻；指定long類型的構造參數，可以自定義毫秒時刻。例如：

import java.util.Date;

public class Demo01Date {
    public static void main(String[] args) {
        // 創(chuàng)建日期對象，把當前的時間
        System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018
        // 創(chuàng)建日期對象，把當前的毫秒值轉成日期對象
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
    }
}

tips:在使用println方法時，會自動調用Date類中的toString方法。Date類對Object類中的toString方法進行了覆蓋重寫，所以結果為指定格式的字符串。

常用方法

Date類中的多數方法已經過時，常用的方法有：

• public long getTime() 把日期對象轉換成對應的時間毫秒值。

7.2 DateFormat類

java.text.DateFormat 是日期/時間格式化子類的抽象類，我們通過這個類可以幫我們完成日期和文本之間的轉換,也就是可以在Date對象與String對象之間進行來回轉換。

• 格式化：按照指定的格式，從Date對象轉換為String對象。
• 解析：按照指定的格式，從String對象轉換為Date對象。

構造方法

由于DateFormat為抽象類，不能直接使用，所以需要常用的子類java.text.SimpleDateFormat。這個類需要一個模式（格式）來指定格式化或解析的標準。構造方法為：

• public SimpleDateFormat(String pattern)：用給定的模式和默認語言環(huán)境的日期格式符號構造SimpleDateFormat。

參數pattern是一個字符串，代表日期時間的自定義格式。

格式規(guī)則

常用的格式規(guī)則為：

備注：更詳細的格式規(guī)則，可以參考SimpleDateFormat類的API文檔0。

創(chuàng)建SimpleDateFormat對象的代碼如：

import java.text.DateFormat;
import java.text.SimpleDateFormat;

public class Demo02SimpleDateFormat {
    public static void main(String[] args) {
        // 對應的日期格式如：2018-01-16 15:06:38
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }    
}

常用方法

DateFormat類的常用方法有：

• public String format(Date date)：將Date對象格式化為字符串。
• public Date parse(String source)：將字符串解析為Date對象。

format方法

使用format方法的代碼為：

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把Date對象轉換成String
*/
public class Demo03DateFormatMethod {
    public static void main(String[] args) {
        Date date = new Date();
        // 創(chuàng)建日期格式化對象,在獲取格式化對象時可以指定風格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = df.format(date);
        System.out.println(str); // 2008年1月23日
    }
}

parse方法

使用parse方法的代碼為：

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把String轉換成Date對象
*/
public class Demo04DateFormatMethod {
    public static void main(String[] args) throws ParseException {
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = "2018年12月11日";
        Date date = df.parse(str);
        System.out.println(date); // Tue Dec 11 00:00:00 CST 2018
    }
}

【練習】

請使用日期時間相關的API，計算出一個人已經出生了多少天。

思路：

1.獲取當前時間對應的毫秒值

2.獲取自己出生日期對應的毫秒值

3.兩個時間相減（當前時間– 出生日期）

代碼實現(xiàn)：

public static void function() throws Exception {
    System.out.println("請輸入出生日期 格式 YYYY-MM-dd");
    // 獲取出生日期,鍵盤輸入
    String birthdayString = new Scanner(System.in).next();
    // 將字符串日期,轉成Date對象
    // 創(chuàng)建SimpleDateFormat對象,寫日期模式
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    // 調用方法parse,字符串轉成日期對象
    Date birthdayDate = sdf.parse(birthdayString);  
    // 獲取今天的日期對象
    Date todayDate = new Date();    
    // 將兩個日期轉成毫秒值,Date類的方法getTime
    long birthdaySecond = birthdayDate.getTime();
    long todaySecond = todayDate.getTime();
    long secone = todaySecond-birthdaySecond;   
    if (secone < 0){
        System.out.println("還沒出生呢");
    } else {
        System.out.println(secone/1000/60/60/24);
    }
}

7.3 Calendar類

概念

java.util.Calendar是日歷類，在Date后出現(xiàn)，替換掉了許多Date的方法。該類將所有可能用到的時間信息封裝為靜態(tài)成員變量，方便獲取。日歷類就是方便獲取各個時間屬性的。

獲取方式

Calendar為抽象類，由于語言敏感性，Calendar類在創(chuàng)建對象時并非直接創(chuàng)建，而是通過靜態(tài)方法創(chuàng)建，返回子類對象，如下：

Calendar靜態(tài)方法

• public static Calendar getInstance()：使用默認時區(qū)和語言環(huán)境獲得一個日歷

例如：

import java.util.Calendar;

public class Demo06CalendarInit {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
    }    
}

常用方法

根據Calendar類的API文檔，常用方法有：

• public int get(int field)：返回給定日歷字段的值。
• public void set(int field, int value)：將給定的日歷字段設置為給定值。
• public abstract void add(int field, int amount)：根據日歷的規(guī)則，為給定的日歷字段添加或減去指定的時間量。
• public Date getTime()：返回一個表示此Calendar時間值（從歷元到現(xiàn)在的毫秒偏移量）的Date對象。

Calendar類中提供很多成員常量，代表給定的日歷字段：

get/set方法

get方法用來獲取指定字段的值，set方法用來設置指定字段的值，代碼使用演示：

import java.util.Calendar;

public class CalendarUtil {
    public static void main(String[] args) {
        // 創(chuàng)建Calendar對象
        Calendar cal = Calendar.getInstance();
        // 設置年 
        int year = cal.get(Calendar.YEAR);
        // 設置月
        int month = cal.get(Calendar.MONTH) + 1;
        // 設置日
        int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日");
    }    
}

import java.util.Calendar;

public class Demo07CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, 2020);
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2020年1月17日
    }
}

add方法

add方法可以對指定日歷字段的值進行加減操作，如果第二個參數為正數則加上偏移量，如果為負數則減去偏移量。代碼如：

import java.util.Calendar;

public class Demo08CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2018年1月17日
        // 使用add方法
        cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
        cal.add(Calendar.YEAR, -3); // 減3年
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2015年1月18日; 
    }
}

getTime方法

Calendar中的getTime方法并不是獲取毫秒時刻，而是拿到對應的Date對象。

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

public class Demo09CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        Date date = cal.getTime();
        System.out.println(date); // Tue Jan 16 16:03:09 CST 2018
    }
}

小貼士：

西方星期的開始為周日，中國為周一。

在Calendar類中，月份的表示是以0-11代表1-12月。

日期是有大小關系的，時間靠后，時間越大。

8 System類

java.lang.System類中提供了大量的靜態(tài)方法，可以獲取與系統(tǒng)相關的信息或系統(tǒng)級操作，在System類的API文檔中，常用的方法有：

• public static long currentTimeMillis()：返回以毫秒為單位的當前時間。
• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：將數組中指定的數據拷貝到另一個數組中。

8.1 currentTimeMillis方法

實際上，currentTimeMillis方法就是 獲取當前系統(tǒng)時間與1970年01月01日00:00點之間的毫秒差值

import java.util.Date;

public class SystemDemo {
    public static void main(String[] args) {
        //獲取當前時間毫秒值
        System.out.println(System.currentTimeMillis()); // 1516090531144
    }
}

示例：

驗證for循環(huán)打印數字1-9999所需要使用的時間（毫秒）

public class SystemTest1 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗時毫秒：" + (end - start));
    }
}

8.2 arraycopy方法

• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：將數組中指定的數據拷貝到另一個數組中。

數組的拷貝動作是系統(tǒng)級的，性能很高。System.arraycopy方法具有5個參數，含義分別為：

示例：

將src數組中前3個元素，復制到dest數組的前3個位置上復制元素前：src數組元素[1,2,3,4,5]，dest數組元素[6,7,8,9,10]復制元素后：src數組元素[1,2,3,4,5]，dest數組元素[1,2,3,9,10]

import java.util.Arrays;

public class Demo11SystemArrayCopy {
    public static void main(String[] args) {
        int[] src = new int[]{1,2,3,4,5};
        int[] dest = new int[]{6,7,8,9,10};
        System.arraycopy( src, 0, dest, 0, 3);
        /*代碼運行后：兩個數組中的元素發(fā)生了變化
         src數組元素[1,2,3,4,5]
         dest數組元素[1,2,3,9,10]
        */
    }
}

9 StringBuilder類

9.1 字符串拼接問題

由于String類的對象內容不可改變，所以每當進行字符串拼接時，總是會在內存中創(chuàng)建一個新的對象。例如：

public class StringDemo {
    public static void main(String[] args) {
        String s = "Hello";
        s += "World";
        System.out.println(s);
    }
}

在API中對String類有這樣的描述：字符串是常量，它們的值在創(chuàng)建后不能被更改。

根據這句話分析我們的代碼，其實總共產生了三個字符串，即"Hello"、"World"和"HelloWorld"。引用變量s首先指向Hello對象，最終指向拼接出來的新字符串對象，即HelloWord 。

由此可知，如果對字符串進行拼接操作，每次拼接，都會構建一個新的String對象，既耗時，又浪費空間。為了解決這一問題，可以使用java.lang.StringBuilder類。

9.2 StringBuilder概述

查閱java.lang.StringBuilder的API，StringBuilder又稱為可變字符序列，它是一個類似于 String 的字符串緩沖區(qū)，通過某些方法調用可以改變該序列的長度和內容。

原來StringBuilder是個字符串的緩沖區(qū)，即它是一個容器，容器中可以裝很多字符串。并且能夠對其中的字符串進行各種操作。

它的內部擁有一個數組用來存放字符串內容，進行字符串拼接時，直接在數組中加入新內容。StringBuilder會自動維護數組的擴容。

9.3 構造方法

根據StringBuilder的API文檔，常用構造方法有2個：

• public StringBuilder()：構造一個空的StringBuilder容器。
• public StringBuilder(String str)：構造一個StringBuilder容器，并將字符串添加進去。

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1); // (空白)
        // 使用帶參構造
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println(sb2); // hello
    }
}

9.4 常用方法

StringBuilder常用的方法有2個：

• public StringBuilder append(...)：添加任意類型數據的字符串形式，并返回當前對象自身。
• public String toString()：將當前StringBuilder對象轉換為String對象。

append方法

append方法具有多種重載形式，可以接收任意類型的參數。任何數據作為參數都會將對應的字符串內容添加到StringBuilder中。例如：

public class Demo02StringBuilder {
    public static void main(String[] args) {
        //創(chuàng)建對象
        StringBuilder builder = new StringBuilder();
        //public StringBuilder append(任意類型)
        StringBuilder builder2 = builder.append("hello");
        //對比一下
        System.out.println("builder:"+builder);
        System.out.println("builder2:"+builder2);
        System.out.println(builder == builder2); //true
        // 可以添加 任何類型
        builder.append("hello");
        builder.append("world");
        builder.append(true);
        builder.append(100);
        // 在我們開發(fā)中，會遇到調用一個方法后，返回一個對象的情況。然后使用返回的對象繼續(xù)調用方法。
        // 這種時候，我們就可以把代碼現(xiàn)在一起，如append方法一樣，代碼如下
        //鏈式編程
        builder.append("hello").append("world").append(true).append(100);
        System.out.println("builder:"+builder);
    }
}

備注：StringBuilder已經覆蓋重寫了Object當中的toString方法。

toString方法

通過toString方法，StringBuilder對象將會轉換為不可變的String對象。如：

public class Demo16StringBuilder {
    public static void main(String[] args) {
        // 鏈式創(chuàng)建
        StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
        // 調用方法
        String str = sb.toString();
        System.out.println(str); // HelloWorldJava
    }
}

10 包裝類

10.1 概述

Java提供了兩個類型系統(tǒng)，基本類型與引用類型，使用基本類型在于效率，然而很多情況，會創(chuàng)建對象使用，因為對象可以做更多的功能，如果想要我們的基本類型像對象一樣操作，就可以使用基本類型對應的包裝類，如下：

10.2 裝箱與拆箱

基本類型與對應的包裝類對象之間，來回轉換的過程稱為”裝箱“與”拆箱“：

• 裝箱：從基本類型轉換為對應的包裝類對象。

• 拆箱：從包裝類對象轉換為對應的基本類型。

用Integer與 int為例：（看懂代碼即可）

基本數值---->包裝對象

Integer i = new Integer(4);//使用構造函數函數
Integer iii = Integer.valueOf(4);//使用包裝類中的valueOf方法

包裝對象---->基本數值

int num = i.intValue();

10.3自動裝箱與自動拆箱

由于我們經常要做基本類型與包裝類之間的轉換，從Java 5（JDK 1.5）開始，基本類型與包裝類的裝箱、拆箱動作可以自動完成。例如：

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

10.4 基本類型與字符串之間的轉換

基本類型轉換為String

基本類型轉換String總共有三種方式，查看資料可以得知，這里只講最簡單的一種方式：

1. 基本類型的值+"" （最簡單的一種）

基本類型直接與””相連接即可；如：34+""

示例：

int i = 100;
String s = i+"";

2. 使用包裝類的toString方法

示例：

Integer i = 1;
String s = i.toString();

3. 使用String類的靜態(tài)方法valueOf(參數)

示例:

int i = 1;
String = s = String.valueOf(i)

String轉換成對應的基本類型

除了Character類之外，其他所有包裝類都具有parseXxx靜態(tài)方法可以將字符串參數轉換為對應的基本類型：

• public static byte parseByte(String s)：將字符串參數轉換為對應的byte基本類型。
• public static short parseShort(String s)：將字符串參數轉換為對應的short基本類型。
• public static int parseInt(String s)：將字符串參數轉換為對應的int基本類型。
• public static long parseLong(String s)：將字符串參數轉換為對應的long基本類型。
• public static float parseFloat(String s)：將字符串參數轉換為對應的float基本類型。
• public static double parseDouble(String s)：將字符串參數轉換為對應的double基本類型。
• public static boolean parseBoolean(String s)：將字符串參數轉換為對應的boolean基本類型。

代碼使用（僅以Integer類的靜態(tài)方法parseXxx為例）如：

public class Demo18WrapperParse {
    public static void main(String[] args) {
        int num = Integer.parseInt("100");
    }
}

注意:如果字符串參數的內容無法正確轉換為對應的基本類型，則會拋出java.lang.NumberFormatException異常。

11 File類

11.1 概述

java.io.File 類是文件和目錄路徑名的抽象表示，主要用于文件和目錄的創(chuàng)建、查找和刪除等操作。

11.2 構造方法

• public File(String pathname) ：通過將給定的路徑名字符串轉換為抽象路徑名來創(chuàng)建新的 File實例。
• public File(String parent, String child) ：從父路徑名字符串和子路徑名字符串創(chuàng)建新的 File實例。
• public File(File parent, String child) ：從父抽象路徑名和子路徑名字符串創(chuàng)建新的 File實例。

• 構造舉例，代碼如下：

// 文件路徑名
String pathname = "D:\\aaa.txt";
File file1 = new File(pathname); 

// 文件路徑名
String pathname2 = "D:\\aaa\\bbb.txt";
File file2 = new File(pathname2); 

// 通過父路徑和子路徑字符串
 String parent = "d:\\aaa";
 String child = "bbb.txt";
 File file3 = new File(parent, child);

// 通過父級File對象和子路徑字符串
File parentDir = new File("d:\\aaa");
String child = "bbb.txt";
File file4 = new File(parentDir, child);

小貼士：

1. 一個File對象代表硬盤中實際存在的一個文件或者目錄。
2. 無論該路徑下是否存在文件或者目錄，都不影響File對象的創(chuàng)建。

11.3 常用方法

靜態(tài)常量

File類是一個與系統(tǒng)無關的類,任何的操作系統(tǒng)都可以使用這個類中的方法

• static String pathSeparator : 與系統(tǒng)有關的路徑分隔符，為了方便，它被表示為一個字符串。
• static char pathSeparatorChar : 與系統(tǒng)有關的路徑分隔符。
• static String separator : 與系統(tǒng)有關的默認名稱分隔符，為了方便，它被表示為一個字符串。
• static char separatorChar : 與系統(tǒng)有關的默認名稱分隔符。

不同的操作系統(tǒng)，路徑的表示是不一樣的

C:\develop\a\a.txt  windows
C:/develop/a/a.txt  linux

多平臺編程下，可以表示成如下形式：

"C:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"

public class Demo01File {
    public static void main(String[] args) {
        /*
            static String pathSeparator 與系統(tǒng)有關的路徑分隔符，為了方便，它被表示為一個字符串。
            static char pathSeparatorChar 與系統(tǒng)有關的路徑分隔符。

            static String separator 與系統(tǒng)有關的默認名稱分隔符，為了方便，它被表示為一個字符串。
            static char separatorChar 與系統(tǒng)有關的默認名稱分隔符。

            操作路徑:路徑不能寫死了
            C:\develop\a\a.txt  windows
            C:/develop/a/a.txt  linux
            "C:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"
         */
        String pathSeparator = File.pathSeparator;
        System.out.println(pathSeparator);//路徑分隔符 windows:分號;  linux:冒號:

        String separator = File.separator;
        System.out.println(separator);// 文件名稱分隔符 windows:反斜杠\  linux:正斜杠/
    }

}

獲取功能的方法

• public String getAbsolutePath() ：返回此File的絕對路徑名字符串。

• public String getPath() ：將此File轉換為路徑名字符串。

• public String getName() ：返回由此File表示的文件或目錄的名稱。

• public long length() ：返回由此File表示的文件的長度。

  方法演示，代碼如下：

  public class FileGet {
      public static void main(String[] args) {
          File f = new File("d:/aaa/bbb.java");     
          System.out.println("文件絕對路徑:"+f.getAbsolutePath());
          System.out.println("文件構造路徑:"+f.getPath());
          System.out.println("文件名稱:"+f.getName());
          System.out.println("文件長度:"+f.length()+"字節(jié)");
  
          File f2 = new File("d:/aaa");     
          System.out.println("目錄絕對路徑:"+f2.getAbsolutePath());
          System.out.println("目錄構造路徑:"+f2.getPath());
          System.out.println("目錄名稱:"+f2.getName());
          System.out.println("目錄長度:"+f2.length());
      }
  }
  輸出結果：
  文件絕對路徑:d:\aaa\bbb.java
  文件構造路徑:d:\aaa\bbb.java
  文件名稱:bbb.java
  文件長度:636字節(jié)
  
  目錄絕對路徑:d:\aaa
  目錄構造路徑:d:\aaa
  目錄名稱:aaa
  目錄長度:4096
  

API中說明：length()，表示文件的長度。但是File對象表示目錄，則返回值未指定。

絕對路徑和相對路徑

• 絕對路徑：從盤符開始的路徑，這是一個完整的路徑。
• 相對路徑：相對于項目目錄的路徑，這是一個便捷的路徑，開發(fā)中經常使用。

public class FilePath {
    public static void main(String[] args) {
        // D盤下的bbb.java文件
        File f = new File("D:\\bbb.java");
        System.out.println(f.getAbsolutePath());
        
        // 項目下的bbb.java文件
        File f2 = new File("bbb.java");
        System.out.println(f2.getAbsolutePath());
    }
}
輸出結果：
D:\bbb.java
D:\idea_project_test4\bbb.java

判斷功能的方法

• public boolean exists() ：此File表示的文件或目錄是否實際存在。
• public boolean isDirectory() ：此File表示的是否為目錄。
• public boolean isFile() ：此File表示的是否為文件。

方法演示，代碼如下：

public class FileIs {
    public static void main(String[] args) {
        File f = new File("d:\\aaa\\bbb.java");
        File f2 = new File("d:\\aaa");
        // 判斷是否存在
        System.out.println("d:\\aaa\\bbb.java 是否存在:"+f.exists());
        System.out.println("d:\\aaa 是否存在:"+f2.exists());
        // 判斷是文件還是目錄
        System.out.println("d:\\aaa 文件?:"+f2.isFile());
        System.out.println("d:\\aaa 目錄?:"+f2.isDirectory());
    }
}
輸出結果：
d:\aaa\bbb.java 是否存在:true
d:\aaa 是否存在:true
d:\aaa 文件?:false
d:\aaa 目錄?:true

創(chuàng)建刪除功能的方法

• public boolean createNewFile() ：當且僅當具有該名稱的文件尚不存在時，創(chuàng)建一個新的空文件。
• public boolean delete() ：刪除由此File表示的文件或目錄。
• public boolean mkdir() ：創(chuàng)建由此File表示的目錄。
• public boolean mkdirs() ：創(chuàng)建由此File表示的目錄，包括任何必需但不存在的父目錄。

方法演示，代碼如下：

public class FileCreateDelete {
    public static void main(String[] args) throws IOException {
        // 文件的創(chuàng)建
        File f = new File("aaa.txt");
        System.out.println("是否存在:"+f.exists()); // false
        System.out.println("是否創(chuàng)建:"+f.createNewFile()); // true
        System.out.println("是否存在:"+f.exists()); // true
        
        // 目錄的創(chuàng)建
        File f2= new File("newDir");    
        System.out.println("是否存在:"+f2.exists());// false
        System.out.println("是否創(chuàng)建:"+f2.mkdir()); // true
        System.out.println("是否存在:"+f2.exists());// true

        // 創(chuàng)建多級目錄
        File f3= new File("newDira\\newDirb");
        System.out.println(f3.mkdir());// false
        File f4= new File("newDira\\newDirb");
        System.out.println(f4.mkdirs());// true
      
        // 文件的刪除
        System.out.println(f.delete());// true
      
        // 目錄的刪除
        System.out.println(f2.delete());// true
        System.out.println(f4.delete());// false
    }
}

API中說明：delete方法，如果此File表示目錄，則目錄必須為空才能刪除。

11.4 目錄的遍歷

• public String[] list() ：返回一個String數組，表示該File目錄中的所有子文件或目錄。

• public File[] listFiles() ：返回一個File數組，表示該File目錄中的所有的子文件或目錄。

public class FileFor {
    public static void main(String[] args) {
        File dir = new File("d:\\java_code");
      
        //獲取當前目錄下的文件以及文件夾的名稱。
        String[] names = dir.list();
        for(String name : names){
            System.out.println(name);
        }
        //獲取當前目錄下的文件以及文件夾對象，只要拿到了文件對象，那么就可以獲取更多信息
        File[] files = dir.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }
}

小貼士：

調用listFiles方法的File對象，表示的必須是實際存在的目錄，否則返回null，無法進行遍歷。

11.5 文件過濾器

在File類中有兩個和ListFiles重載的方法,方法的參數傳遞的就是過濾器

• File[] listFiles(FileFilter filter)

  • java.io.FileFilter接口:用于抽象路徑名(File對象)的過濾器
    • 作用:用來過濾文件(File對象)
    • 抽象方法:boolean accept(File pathname),用來過濾文件的方法，測試指定抽象路徑名是否應該包含在某個路徑名列表中。
    • 參數:File pathname:使用ListFiles方法遍歷目錄,得到的每一個文件對象

• File[] listFiles(FilenameFilter filter)

• java.io.FilenameFilter接口:實現(xiàn)此接口的類實例可用于過濾器文件名。

  • 作用:用于過濾文件名稱

  • 抽象方法:boolean accept(File dir, String name) ，用來過濾文件的方法，測試指定文件是否應該包含在某一文件列表中。

  • 參數:

    • File dir:構造方法中傳遞的被遍歷的目錄
    • String name:使用ListFiles方法遍歷目錄,獲取的每一個文件/文件夾的名稱

注意:
兩個過濾器接口是沒有實現(xiàn)類的,需要我們自己寫實現(xiàn)類,重寫過濾的方法accept,在方法中自己定義過濾的規(guī)則

示例：

獲取某目錄下的所有.java文件

1. 使用 FileFilter接口

public class FileDemo {
    public static void main(String[] args) {

        File file = new File("E:\\code");
        getAllFiles(file);

    }

    public static void  getAllFiles( File file){

        //1 直接重載accept方法
//        File[] files = file.listFiles(new FileFilter() {
//            @Override
//            public boolean accept(File pathname) {
//                return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java");
//            }
//        });

        // 2 使用lambda表達式
//        File[] files = file.listFiles((File pathname)->{
//                return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java");
//            }
//        );

        // 3 lambda表達式簡化
//        File[] files = file.listFiles((File pathname)->pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java"));

        // 4 lambda表達式進一步簡化
        File[] files = file.listFiles((pathname)->pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".java"));

        for(File f :files){
            if(f.isDirectory()){
                getAllFiles(f);
            }else {
                System.out.println(f.toString());
            }

        }

    }
}

2. 使用FilenameFilter接口

public class FileDemo {
    public static void main(String[] args) {

        File file = new File("E:\\code");
        getAllFiles(file);

    }

    public static void  getAllFiles( File file){
        // 1 直接重載accept方法
//        File[] files = file.listFiles(new FilenameFilter() {
//            @Override
//            public boolean accept(File dir, String name) {
//                return new File(dir,name).isDirectory() || name.toLowerCase().endsWith(".java");
//            }
//        });

        // 2 使用lambda表達式
        File[] files = file.listFiles((dir, name) -> new File(dir,name).isDirectory() || name.toLowerCase().endsWith(".java"));

        for(File f :files){
            if(f.isDirectory()){
                getAllFiles(f);
            }else {
                System.out.println(f.toString());
            }

        }

    }
}