JavaSE第五章 java常用API

莉婭醬の胖次是我のぁ舔舔發表於2020-11-14
JavaAPI

文章目錄

5 第五章JavaAPI

是對java預先定義的類或介面, 功能 和方法功能的說明文件，目的是提供給開發人員進行使用幫助說明。

5.1 基本資料型別包裝類

Java是一門物件導向的語言，但是其八種基本資料型別卻是不物件導向的，這在實際使用中造成了很多不方便，為此引入了包裝類的概念。

用途：

  1. 方便涉及到物件時的操作
  2. 包含基本資料型別的相關屬性和操作
基本資料型別包裝類
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
characterCharacter
booleanBoolean

5.2 Object

java.lang.Object

方法作用
String toString()返回描述該物件值的字串。在自定義類中應覆蓋這個方法
boolean equals(Object otherObject)比較兩個物件是否相等。在自定義類中應覆蓋這個方法
Class getClass() int hashCode()返回包含物件資訊的類物件 返回物件的雜湊碼
static wait() static notify() static notifyAll()

轉成字串toString()

返回描述該物件值的字串

比較equals()

比較物件的地址是否相同 相當於 “==”

返回雜湊值hashCode()

返回地址的hash值

5.3 Arrays

方法作用
static String toString(type[] a)返回包含a中資料元素的字串
static void sort(type[] a)採用優化的快速排序演算法對陣列進行排序
static void binarySearch(type[] a, type v)使用二分搜尋演算法查詢值v
static Boolean equals(type[] a, type[] b)如果兩個數字相同，返回true

5.3.1 轉成字串toString()

	public static void main(String[] args) {
        int[] a = {1,2,3};
        int[] b = {1,2,3};

        System.out.println(Arrays.equals(a, b)); //比較值
        System.out.println(a == b);//比較物件（也就是地址）
    }

5.3.2 比較equals()

	public static void main(String[] args) {
        int[] a = {1,2,3};
        int[] b = {1,2,3};

        System.out.println(Arrays.equals(a, b)); //比較值
        System.out.println(a == b);//比較物件（也就是地址）
    }

5.3.3 排序 sort()（快速排序）

對普通型別的排序
public class SortDemo {
    public static void main(String[] args) {
        int[] a = {4,7,5,3,9,2,1,8};

//      Arrays.sort(a);//升序排序
        Arrays.sort(a,0,4);// 區間排序
        Integer[] b = {4,7,5,3,9,2,1,8};
        Arrays.sort(b); //也可以對Integer包裝類陣列進行排序
        System.out.println(Arrays.toString(b));
    }
}
物件陣列的排序
public class SortDemo2 {
    public static void main(String[] args) {

        Student s1 = new Student("jim1",101);
        Student s2 = new Student("jim2",102);
        Student s3 = new Student("jim3",103);
        Student s4 = new Student("jim4",104);

        Student[] stuArr = {s1,s4,s3,s2};

        Arrays.sort(stuArr); // 對物件陣列進行排序 
        /*
        	Student類實現了Comparator介面
        	sort排序呼叫了Student類中的compare()方法
        	要想用sort對物件陣列進行排序，必須先實現ComParactor介面中的compare()方法。
        */

        System.out.println(Arrays.toString(stuArr));
    }
}


public class Student implements Comparator<Student> {

    public String name;
    public int id;

    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public Student() {}

    /**
     * 基本資料型別的比較    用Comparator  介面
     * @param o1
     * @param o2
     * @return
     */
    @Override
    public int compare(Student o1, Student o2) {
//        return o1.id - o2.id;  // o1 - o2  正序
        return o2.id - o1.id; // 逆序
    }

    
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}
自定義排序

自定義排序 必須實現Comparator介面

用name對Student陣列進行排序

對字串的比較排序會使用到String類實現Comparable介面中的compareTo()方法

/**
*自定義排序  必須實現Comparator介面
*/
public class SortName implements Comparator<Student> {

    public SortName() {
    }

    @Override
    public int compare(Student o1, Student o2) {  // sort排序時會呼叫該函式
        return o2.name.compareTo(o1.name);  
    }
}

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

        Student s1 = new Student("jim1",101);
        Student s2 = new Student("jim2",102);
        Student s3 = new Student("jim3",103);
        Student s4 = new Student("jim4",104);

        Student[] stuArr = {s1,s4,s3,s2};
		
        //要把你寫好的自定義排序類的物件傳進去，這樣他會自動呼叫你的自定義排序compare()方法
        Arrays.sort(stuArr,new SortName()); 

        System.out.println(Arrays.toString(stuArr));
    }
}
用id對Student陣列進行排序
public class SortId implements Comparator<Student>  {
    public SortId() {
    }

    @Override
    public int compare(Student o1, Student o2) {
        return o1.id - o2.id;  // 正序 
    }
}

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

        Student s1 = new Student("jim1",101);
        Student s2 = new Student("jim2",102);
        Student s3 = new Student("jim3",103);
        Student s4 = new Student("jim4",104);

        Student[] stuArr = {s1,s4,s3,s2};
        
		//要把你寫好的自定義排序類的物件傳進去，這樣他會自動呼叫你的自定義排序compare()方法
        Arrays.sort(stuArr,new SortId());

        System.out.println(Arrays.toString(stuArr));
    }
}

5.3.4 查詢 binarySearch()（二分）

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

        //要使用二分查詢，必須先排序。
        int[] a = {5,6,3,8,7,9,2,4};
        Arrays.sort(a); //排序

        System.out.println(Arrays.toString(a));
        int index = Arrays.binarySearch(a,7); //把 陣列 和 查詢的值 傳進去
        System.out.println("index = " + index); // 返回下標， 如果為負數，就說明沒找到
    }
}
手撕二分查詢
/**
* 二分查詢的前提是 目前查詢的陣列有序。
* 把num和mid中間下標的值進行比較，如果num比mid處的值小，那說明目標num在mid的左邊。
* 如果大，則正好相反。每次迴圈都會砍掉一半，對剩下的另一半進行查詢
*/
    public static int search(int[] arr,int num){
        int low = 0,
            high = arr.length-1
            ,mid = 0;

        while (low<high){
            mid = (low+high) >>> 1;  //>>>1 位運算  右移一位，相當於除2
            if (arr[mid]>num){ //取左邊
                high = mid - 1;
            }else if (arr[mid]<num){ //去右邊
                low = mid + 1;
            }else {
                return mid;
            }
        }
        return -mid;
    }

5.4 String

方法作用
char charAt(int index)返回給定位置的程式碼單元
boolean equals(Object other)如果字串與other相等，返回true
boolean equalsIngoreCase(String other)忽略大小寫
int length()返回字串的長度
String substring(int beginIndex)返回一個新字串，包含原始字串從beginIndex到串尾或到endIndex-1的所有程式碼單元
String substring(int beginIndex, int endIndex)
String toLowerCase()返回小寫字串
String toUpperCase()返回大寫字串
int indexOf(String str[, int fromIndex])
int lastIndexOF(String str[, int fromIndex])		返回第一個/最後一個子串的位置,從起始位置或者fromIndex開始

5.4.1 字串的初始化

public class StringDemo {
    public StringDemo() {}
    public static void main(String[] args) throws UnsupportedEncodingException {
        /*
            字串初始化
         */
        char[] c = {'a','b','c'}; // 字元的預設值為 ' ' 空格字元
        String s = new String();  //預設值為 “”  空串
        String s1 = new String(c); //將字元陣列轉換成字串。
        String s2 = new String(c,0,2); //擷取字元陣列並轉換成字串
        System.out.println("s = " + s );
        System.out.println("s1 = " + s1);
        System.out.println("s2 = " + s2);

        byte[] b = s1.getBytes();//使用平臺的預設字符集將此 String 編碼為 byte 序列,並返回
        System.out.println(Arrays.toString(b));

        b = s1.getBytes("utf-8");
        System.out.println(Arrays.toString(b));//使用指定的字符集將此 String 編碼為 byte 序列

        String encode = new String(b); //解碼  使用平臺的預設字符集將此 byte序列解碼為String 
        System.out.println(encode);
        
        String encode1 = new String(b,"utf-8"); // 使用指定的字符集 進行解碼
        System.out.println(encode1);

        String encode2 = new String(b,"gbk"); // 使用指定的字符集 進行解碼
        System.out.println(encode2);
    }
}

5.4.2 判斷方法

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

        String s = "abcdefg";
        String ss = "abcdefg";
        String s1 = new String("abcdefg");
        String s2 = "AbcDefG";
        //當初始化是直接賦值時， ss會去常量池裡找有沒有“abcdefg” ,有就會指向它， 沒有就會建立一個新的。
        System.out.println(s == ss);
        System.out.println(s.equals(s1)); //重寫了Object的equals方法 ， 比較 字串裡的值
        System.out.println(s1.equalsIgnoreCase(s2)); //比較的時候忽略大小寫
        System.out.println("a".compareTo("b")); //-1  "a" < "b"
        System.out.println();

        String sub = "cde";
        System.out.println(s1.contains(sub)); //判斷是否包含目標子串
        System.out.println(s1.contains("abc"));
        System.out.println();

        System.out.println(s1.isEmpty());  //判斷是否為空字串
        System.out.println("".isEmpty());  //"" 和 null 不一樣
        System.out.println();

        System.out.println(s2.startsWith("ab")); //判斷是否以該字串開頭
        System.out.println(s.startsWith("ab", 3));  //判斷是否以該字串開頭，以指定的下標為開頭
        System.out.println(s.endsWith("g"));  //判斷是否以該字串結尾
        System.out.println();
    }
}

5.4.3 獲取方法

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

        String s = "abcdefghci";
                //  123456789
          /*陣列是array.length
            字串是 string.length() ,但是呼叫的length()方法中獲取的是字元陣列的length（chs.length）;   chs是字元陣列
            集合是 size()
         */
        System.out.println("長度 s.length() = " + s.length()); //陣列是array.length

        System.out.println(s.charAt(8)); //返回下標處的字元
        System.out.println(s.indexOf("c")); // 返回目標字串第一次出現時所在的下標  從前往後
        System.out.println(s.indexOf("c", s.indexOf("c"))); // 返回第二次出現的下標
        s.lastIndexOf("c"); //從後往前  返回第一次出現目標字串的下標

        System.out.println(s.substring(5));  // 從5開始擷取到字串末尾
        System.out.println(s.substring(5, 8)); //左閉右開
    }
}

5.4.4 轉換方法

public class StringTransmitDemo {

    public StringTransmitDemo() {
    }

    public static void main(String[] args) {

        char[] chs = "abcdefg".toCharArray(); //將字串轉換成字元陣列

        // 將其他型別轉換成字串
        System.out.println(String.valueOf(chs));   //將字元陣列 轉 字串
        System.out.println(new String(chs));  //將字元陣列 轉 字串

        String s = "AedFeggDW";
        System.out.println(s.toLowerCase());  //全部轉成小寫
        System.out.println(s.toUpperCase());  //全部轉成大寫

        s = "a:bc:def:ghij";
        System.out.println(s.concat("xxxxxxxxxxxxxx"));  //拼接  a:bc:def:ghijxxxxxxxxxxxxxx
        System.out.println(Arrays.toString(s.split(":"))); //分隔  並轉換成字串陣列 ，正規表示式
        //[a, bc, def, ghij]


        
    }

}

5.4.5 替換方法

		//替換
		String s = "a:bc:def:ghij";
        System.out.println(s.replace(':', '|')); // a|bc|def|ghij
        System.out.println(s.replaceAll(":", "")); // abcdefghij
        s = "a2b3cd4efghijk66";
        s.replaceAll("\\d","");  //正規表示式

5.4.6 正規表示式

public class Reg {
    public Reg() {}
    public static void main(String[] args) {
        String s = "33";

        System.out.println("1  " + s.matches("\\d"));
        System.out.println("2  " + s.matches("[2-4]"));
        System.out.println("3  " + s.matches("[245]"));
        System.out.println("4  " + s.matches("\\D"));  //非數字
        System.out.println("5  " + s.matches("[2-4]？")); //一次或一次也沒有
        System.out.println("6  " + s.matches("[2-4]*")); //零次或多次
        System.out.println("7  " + s.matches("[2-4]+")); //一次或多次
        System.out.println("8  " + s.matches("[2-4]{2}")); //恰好n次
        System.out.println("9  " + s.matches("[2-4]{3,}")); //至少n次
        System.out.println("10  " + s.matches("[2-4]{2,5}")); //至少n次，最多5次
        System.out.println();

        String ss = "abcdef";
        System.out.println("1  " + ss.matches("[A-z]*"));
        System.out.println("2  " + ss.matches("[A-z,1-9]{1,4}"));
        System.out.println();

        String sss = "";
        System.out.println("1  " + ss.matches("\\w"));//匹配字母和數字
        System.out.println("1  " + ss.matches("\\W"));
        System.out.println("2  " + ss.matches("\\s")); //匹配空白字元
        System.out.println("2  " + ss.matches("\\S"));
        System.out.println();

        //郵箱
        String str = "465asd844@qq.com";
        System.out.println(str.matches("\\w{1,16}@\\w{2,6}\\.(com|com\\.cn)"));

        //電話
        String mobile = "13279370686";
        System.out.println(mobile.matches("^1[3597]\\d{9}$"));

        //匹配以zh開頭 並以3結尾的且不含空白字元的字串
        String ssss = "zh16843444514";
        System.out.println(ssss.matches("^(zh)\\S*3$"));

    }

}

在這裡插入圖片描述

在這裡插入圖片描述

5.4.7 可變字元序列（字串）

StringBuffer
  1. append()
  2. insert()
  3. delete()
  4. replace()
  5. reverse()
  6. substring()
/**
*可變字串的操作
*/
public static void main(String[] args) {

        StringBuffer s = new StringBuffer("asdccdff");
        s.append(6); //追加
        System.out.println(s);
        s.insert(0,"aa");  //插入 在指定下標處插入
        System.out.println(s);
        s.deleteCharAt(0);  //刪除指定下標的字元
        System.out.println(s);
        s.delete(0,3);    // 刪除指定區間的字元
        System.out.println(s);
        s.replace(0,2,"aaaaaaaaa"); //替換區間內的字串
        System.out.println(s);
        s.reverse();  //反轉字串
        System.out.println(s);

        System.out.println(s.substring(0, 5)); //擷取 指定區間的字串， 源字串s不變
        System.out.println(s);

    }
StringBuilder
public static void main(String[] args) {

        StringBuilder s = new StringBuilder("shddbfabfka");
        //基本操作和StringBuffer一樣
        /**
         * String：是字元常量,適用於少量的字串操作的情況
         * StringBuilder：適用於單執行緒下在字元緩衝區進行大量操作的情況
         * StringBuffer：適用多執行緒下在字元緩衝區進行大量操作的情況
         */

    }

5.5 Random

方法作用
Random()構建一個新的隨機數生成器
setSeed()重置種子數
int nextInt(int n)返回一個 0 ~ n-1之間的隨機數

5.6 Date 日期

5.6.1 Date

Date類代表當前系統時間

Date date = new Date();
Date date = new Date(long d);

5.6.2 Calendar

Calendar c = Calendar.getInstance();

Calendar calendar1 = new GregorianCalendar();
Calendar calendar = Calendar.getInstance(); //同上, 兩者一樣
        calendar.set(Calendar.YEAR,2050); //更改 年份
        System.out.println(calendar.getTime()); //時間戳
        System.out.println(calendar.getTimeInMillis()); //時間戳

        System.out.println(calendar.getWeekYear());
        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.WEEK_OF_YEAR));
        System.out.println(calendar.get(Calendar.WEEK_OF_MONTH));
        System.out.println(calendar.get(Calendar.YEAR)); //1
        System.out.println(calendar.get(Calendar.MONTH)+1); //2
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH)); //5
        System.out.println(calendar.get(Calendar.HOUR_OF_DAY)); //11
        System.out.println(calendar.get(Calendar.MINUTE)); // 12
        System.out.println(calendar.get(Calendar.SECOND)); // 13

5.6.3 SimpleDateFormat 日期格式化

SimpleDateFormat form = new SimpleDateFormat(String format) //format 格式 yyyy-MM-dd

日期轉換成字串

Date now = new Date();
form.format(now);

字串轉換成日期

form.parse("2000-12-25") //必須帶"-"格式

5.7 BigInteger

實現任意精度的整數運算.

不可變的任意精度的整數。所有操作中，都以二進位制補碼形式表示 BigInteger（如 Java 的基本整數型別）。BigInteger 提供所有 Java 的基本整數操作符的對應物，並提供 java.lang.Math 的所有相關方法。另外，BigInteger 還提供以下運算：模算術、GCD 計算、質數測試、素數生成、位操作以及一些其他操作。

在Java中，由CPU原生提供的整型最大範圍是64位long型整數。使用long型整數可以直接通過CPU指令進行計算，速度非常快。

如果我們使用的整數範圍超過了long型怎麼辦？這個時候，就只能用軟體來模擬一個大整數。java.math.BigInteger就是用來表示任意大小的整數。BigInteger內部用一個int[]陣列來模擬一個非常大的整數：

BigInteger bi = new BigInteger("1234567890");
System.out.println(bi.pow(5)); 
// 2867971860299718107233761438093672048294900000

對BigInteger做運算的時候，只能使用例項方法, 不能使用運算子，例如，加法運算：

BigInteger i1 = new BigInteger("1234567890");
BigInteger i2 = new BigInteger("12345678901234567890");
BigInteger sum = i1.add(i2); // 12345678902469135780

和long型整數運算比，BigInteger不會有範圍限制，但缺點是速度比較慢。

也可以把BigInteger轉換成long型：

BigInteger i = new BigInteger("123456789000");
System.out.println(i.longValue()); // 123456789000
System.out.println(i.multiply(i).longValueExact()); // java.lang.ArithmeticException: BigInteger out of long range

使用longValueExact()方法時，如果超出了long型的範圍，會丟擲ArithmeticException。

BigInteger和Integer、Long一樣，也是不可變類，並且也繼承自Number類。因為Number定義了轉換為基本型別的幾個方法：

  • 轉換為byte：byteValue()
  • 轉換為short：shortValue()
  • 轉換為int：intValue()
  • 轉換為long：longValue()
  • 轉換為float：floatValue()
  • 轉換為double：doubleValue()

因此，通過上述方法，可以把BigInteger轉換成基本型別。如果BigInteger表示的範圍超過了基本型別的範圍，轉換時將丟失高位資訊，即結果不一定是準確的。如果需要準確地轉換成基本型別，可以使用intValueExact()、longValueExact()等方法，在轉換時如果超出範圍，將直接丟擲ArithmeticException異常。

5.7.1 構造方法

BigInteger(byte[] val)` 將包含 BigInteger 的二進位制補碼錶示形式的 byte 陣列轉換為 BigInteger。
BigInteger(int signum, byte[] magnitude) 將 BigInteger 的符號-數量表示形式轉換為 BigInteger。
BigInteger(int bitLength, int certainty, Random rnd) 構造一個隨機生成的正 BigInteger，它可能是一個具有指定 bitLength 的素數。
BigInteger(int numBits, Random rnd) 構造一個隨機生成的 BigInteger，它是在 0 到 (2numBits - 1)（包括）範圍內均勻分佈的值。
BigInteger(String val) 將 BigInteger 的十進位制字串表示形式轉換為 BigInteger。
BigInteger(String val, int radix) 將指定基數的 BigInteger 的字串表示形式轉換為 BigInteger。

5.7.2 方法

方法作用例子
valueOf( )將普通的數值轉成BigIntegerBigInteger bigInt = BigInteger.valueOf(111);

5.8 BigDecimal

和BigInteger類似，BigDecimal可以表示一個任意大小且精度完全準確的浮點數。

BigDecimal bd = new BigDecimal("123.4567");
System.out.println(bd.multiply(bd)); // 15241.55677489

BigDecimal用scale()表示小數位數，例如：

BigDecimal d1 = new BigDecimal("123.45");
BigDecimal d2 = new BigDecimal("123.4500");
BigDecimal d3 = new BigDecimal("1234500");
System.out.println(d1.scale()); // 2,兩位小數
System.out.println(d2.scale()); // 4
System.out.println(d3.scale()); // 0

通過BigDecimal的stripTrailingZeros()方法，可以將一個BigDecimal格式化為一個相等的，但去掉了末尾0的BigDecimal：

BigDecimal d1 = new BigDecimal("123.4500");
BigDecimal d2 = d1.stripTrailingZeros();
System.out.println(d1.scale()); // 4
System.out.println(d2.scale()); // 2,因為去掉了00

BigDecimal d3 = new BigDecimal("1234500");
BigDecimal d4 = d3.stripTrailingZeros();
System.out.println(d3.scale()); // 0
System.out.println(d4.scale()); // -2

如果一個BigDecimal的scale()返回負數，例如，-2，表示這個數是個整數，並且末尾有2個0。

對BigDecimal做加、減、乘時，精度不會丟失，但是做除法時，存在無法除盡的情況，這時，就必須指定精度以及如何進行截斷：

BigDecimal d1 = new BigDecimal("123.456");
BigDecimal d2 = new BigDecimal("23.456789");
BigDecimal d3 = d1.divide(d2, 10, RoundingMode.HALF_UP); // 保留10位小數並四捨五入
BigDecimal d4 = d1.divide(d2); // 報錯：ArithmeticException，因為除不盡

還可以對BigDecimal做除法的同時求餘數, 呼叫divideAndRemainder()方法時，返回的陣列包含兩個BigDecimal，分別是商和餘數，其中商總是整數，餘數不會大於除數。

我們可以利用這個方法判斷兩個BigDecimal是否是整數倍數：

BigDecimal n = new BigDecimal("12.75");
BigDecimal m = new BigDecimal("0.15");
BigDecimal[] dr = n.divideAndRemainder(m);
if (dr[1].signum() == 0) {
    // n是m的整數倍
}

比較BigDecimal

在比較兩個BigDecimal的值是否相等時，要特別注意，使用equals()方法不但要求兩個BigDecimal的值相等，還要求它們的scale()相等：

BigDecimal d1 = new BigDecimal("123.456");
BigDecimal d2 = new BigDecimal("123.45600");
System.out.println(d1.equals(d2)); // false,因為scale不同
System.out.println(d1.equals(d2.stripTrailingZeros())); // true,因為d2去除尾部0後scale變為2
System.out.println(d1.compareTo(d2)); // 0

必須使用compareTo()方法來比較，它根據兩個值的大小分別返回負數、正數和0，分別表示小於、大於和等於。

總是使用compareTo()比較兩個BigDecimal的值，不要使用equals()！

如果檢視BigDecimal的原始碼，可以發現，實際上一個BigDecimal是通過一個BigInteger和一個scale來表示的，即BigInteger表示一個完整的整數，而scale表示小數位數：

public class BigDecimal extends Number implements Comparable<BigDecimal> {
    private final BigInteger intVal;
    private final int scale;
}

BigDecimal也是從Number繼承的，也是不可變物件。

小結

BigDecimal用於表示精確的小數，常用於財務計算；

比較BigDecimal的值是否相等，必須使用compareTo()而不能使用equals()。

5.9 System

public class SystemDemo {

    public SystemDemo() {
    }

    public static void main(String[] args) {
        //System.out;  //PrintStream
        //System.in
        System.out.println();
		
        //System.arraycopy() 陣列拷貝 
        //所謂的動態陣列就是用arraycopy()實現的
        int[] srcArr = {1,2,3,4,5,6,7,8,9};
        int[] desArr = new int[5];
        System.arraycopy(srcArr,2,desArr,0,3);
        System.out.println(Arrays.toString(desArr));

        //System.currentTimeMillis()  獲取當前系統時間
        System.out.println(System.currentTimeMillis());
//        Date date = new Date();

        //System.getenv("Path")  根據環境變數的名字獲取環境變數。
        System.out.println(System.getenv());
        System.out.println(Arrays.toString(System.getenv("Path").split(";")));

        //用於獲取系統的所有屬性。屬性分為鍵和值兩部分，它的返回值是Properties。
        System.out.println(System.getProperties());
        
//        System.exit(0); //停止虛擬機器

        //測試執行時間
        //測試 +  拼接字串
        String str = "";
        Long time = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            str += "a";
        }
        Long time1 = System.currentTimeMillis();
        System.out.println("測試 + 拼接1000次的效率  " + (time1-time) +" 毫秒");

        //測試  String.concat()
        str = "";
        time = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            str = str.concat("a");
        }
        time1 = System.currentTimeMillis();
        System.out.println("測試  String.concat()拼接1000次的效率  " + (time1-time) +" 毫秒");

        //測試  StringBuffer
        StringBuffer strbf = new StringBuffer("");
        time = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            strbf.append("a");
        }
        time1 = System.currentTimeMillis();
        System.out.println("測試  StringBuffer拼接1000次的效率  " + (time1-time) +" 毫秒");


        System.out.println(666);
    }
}

5.10 Class

方法作用
String getName()返回這個類的名字
static Class forName(String className)返回描述類名為className的Class物件
Object newInstance()返回這個類的一個新例項
Field[] getFields()
Field[] getDeclareFields() getFields()		getFields()返回一個包含Field物件的陣列，這些物件記錄了這個類或其超類的公有域
getDeclareFields()返回的Field物件記錄了這個類的全部域
Method[] getMethods()
Method[] getDeclareMethods()		getMethods()返回一個包含Method物件的陣列，這些物件記錄了這個類或其超類的公用方法
getDeclareMethods()返回的Field物件記錄了這個類的全部方法
Constructor[] getConstructors()
Constructor[] getDeclareConstructors()
getConstructors()返回一個包含Constructor物件的陣列，這些物件記錄了這個類的公有構造器
getDeclareConstructors()返回的Constructor物件記錄了這個類的全部構造器

相關文章