一、String類

1. String類在java.lang包中，專門處理字符序列，為final類，不可擴展。
2. String常量對象放在常量池中，有自己的引用和實體。
3. String對象放在動態區，可聲明和創建對象：

   String s = new String("we are student");
   String t = new String("we are student");

   對象變量s中存放著引用，所以s==t的值為false。用戶無法輸出對象的引用，只能輸出實體。

4. 也可以用已創建的String對象創建另一個String對象。

   String tom = new String(s);
5. 用字符數組創建String對象

   char a[] = {‘J‘,‘a‘,‘v‘,‘a‘};
   String s = new String(a);

   用String(char a[],int startIndex,int count)提取字符數組a中一部分字符創建String對象

   char a[] = {‘‘J,‘a‘,v‘‘a,‘s‘,c,‘r‘,‘i‘,‘p‘,‘t‘};
   String s = new String(a,2,4);

6. 將String常量的引用賦值給String對象

   String s1,s2;
   s1 = "你好";
   s2 = "你好"；

   s1,s2中存放的是常量池中

   "你好"的引用，故s1==s2為true。再進行s1 = "boy"的運算時，s1中的值發生變化。

字符串用“+”實現字符串並置，參與並置的字符串只要有一個為變量，新String對象的引用就存放到變量區。

public class Example8_1 {
    public static void main(String[] args) {
        String hello = "你好";
        //兩個常量進行並置，其引用在常量池
        String testOne = "你"+"好";
        //hello和testOne的引用均為"你好"在常量池中的引用
 

        System.out.println(hello==testOne);  //true
        System.out.println("你好"==testOne);  //true
        System.out.println("你好"==hello);    //true
        String you = "你";
        String hi = "好" ;
        //兩個變量進行並置，其引用在動態區
        String testTwo = you+hi;
        System.out.println(hello==testTwo);      //false
        //在動態區誕生新對象
        String testThree = you+hi;
        System.out.println(testTwo==testThree);  //false
    }
}

二、String類常用方法

1. public int length()：獲取String對象字符序列長度。
2. public boolean equals(String s)：比較兩個String對象的字符串是否相同。
3. public boolean equalsIgnoreCase(String s)：比較兩個String對象的字符串是否相同，忽略大小寫。
4. public boolean startsWith(String s)：判斷當前字符的前綴是否為s。
5. public boolean endsWith(String s)：判斷當前字符的後綴是否為s。
6. public int compareTo(String s)：按字典序判斷當前字符與s的序列比較大小，大於則返回正值，小於則返回負值，等於則返回0。
7. public int compareToIgnoreCase(String s)：按字典序判斷當前字符與s的序列比較大小，大於則返回正值，小於則返回負值，等於則返回0，忽略大小寫。
8. public static void sort(String [] a)：在java.util包中的Arrays類中，將String數組a按照字典序排列。
9. public boolean contains(String s)：當前對象是否包含s。
10. public int indexOf(String s)：從0索引位置檢索首次出現s的位置，返回該位置，若沒有檢索到，則返回-1。
11. public int lastIndexOf(String s) ：從0索引位置檢索最後一次出現s的位置，返回該位置，若沒有檢索到，則返回-1。
12. public int IndexOf(String s，int startpoint)：startpoint指定檢索的開始位置。
13. String對象的字符序列中如果使用目錄符，windows目錄符必須寫成"//"。
14. public String subString(int startpoint)：獲得新的String對象，復制當前對象startpoint位置至最後位置的字符序列。
15. public String subString(int start,int end)：獲得新的String對象，復制當前對象start位置至end-1位置的字符序列。
16. public String trim()：獲得新的String對象，為當前對象去掉前後空格的字符序列。

三、字符串轉化

1. public static int parseInt(String s)：在java.lang包中的Integer類中，可將數字字符轉化成int數據。
2. 類似的，有parseByte()、praseShort()等方法。
3. public static String valueOf(int/byte/long/float/double n)：在java.lang包中的String類中，可將int數據轉化成String。

   public class Example8_4 {
       public static void main(String[] args) {
           double sum = 0,item = 0;
           boolean computable = true;
           for (String s:args) {                 //應用程序的main方法中參數args能接受用戶從鍵盤輸入的字符序列
               try {
                   item = Double.parseDouble(s);
                   sum = sum + item;
               } catch (NumberFormatException e) {
                   System.out.println("您輸入了非法字符：" + e);
                   computable = false;
               }
           }
               if (computable)
                   System.out.println("sum = "+sum);
       }
   }

   

4. public String toString()：在Object類中，可以被任意對象調用，返回的String對象的一般形式為：

   創建對象的類名字@對象引用的字符串表示

   Object的直接或間接子類也可以重寫toString()方法，如java.util包中的Date類就重寫了toString()方法。

四、字符串與字符數組、字節數組

1. public void getChars(int start,int end,char c[],int offset)：在String類中，將String從start到end-1位置上的字符復刻到參數c制定的數組中，從c的offset處開始存放這些字符。
2. public char[] toCharArray()：將String的全部字符存放在一個字符數組中。
3. String(byte[])：String類的構造方法，用指定的字節數組構造一個String對象。
4. String(byte[],int offset,int length)：用指定的字節數組的一部分，從offset開始取length個字節，構造String對象。
5. public byte[] getByte()：使用平臺默認字符編碼，將當前的String對象的字符序列存放到字節數組中，並返回數組引用。
6. public byte[] getByte(String charsetName)：使用參數指定字符編碼。

五、正則表達式及字符串的替換和分解

1. 正則表達式是String對象的字符序列，含有特殊意義字符（稱作元字符）。

   "0cat"、"1cat"、"2cat"、"3cat"等都是和正則表達式"\\dcat"匹配的字符序列

2. public boolean matches(String regex)：在String類中的方法，判斷當前String對象是否和正則表達式regex相匹配。
3. 常用元字符及其意義：

1. 在正則表達式可以使用限定修飾符：

   若regex = "@\\w{4}"，那麽"@abcd"、"@天道酬勤"、"@Java"、"@bird"都與正則表達式regex相匹配

1. public String replaceAll(String regex,String replacement)：返回一個新的String對象，將當前String對象的字符序列中所有和參數regex匹配的字符序列，用replacement的字符序列替換。

   String str = "12hello567bird".replaceAll("[a-zA-Z]+","你好");
   得到str字符序列是"12你好567你好"

2. public String[] spilt(String regex)：String類中，使用regex作為分隔標記，分解當前String對象，分解出的單詞存放在String數組。

   String str = "1949年10月1日是中華人民共和國成立的日子";
   String digitWord[] = str.spilt(regex);
   那麽，digitWord[0]、digitWord[1]、digitWord[2]分別是"1949"、"10"、"1"

   註意：split方法認為分隔標記的左右側都應該是單詞。

六、StringTokenizer類

1. 在java.util包中，有兩種構造方法。
2. StringTokenizer(String s)：為s構造一個分析器，使用默認的空格符、換行符、回車符、Tab符、進紙符作分隔標記。
3. StringTokenizer(String s，String delim)：為s構造一個分析器，使用delim中字符的任意排列作分隔標記。

   //分隔標記為空格
   StringTokenizer fenxi = new StringTokenizer("You are welcome");
   //分隔標記為#*的任意排列
   StringTokenizer fenxi = new StringTokenizer("You#*are*##welcome","#*");

4. 一個StringTokenizer對象為一個字符串分析器，可使用nextToken()方法逐個獲取String對象中的單詞，每調用一次nextToken()，獲得下一個單詞，分析器中負責計時的變量就減1，初始值為單詞個數。
5. 可運用while循環來獲取單詞，利用hasMoreTokens()方法，計數變量>0時，返回true，否則返回false。
6. countTokens()方法得到計數變量的值。

七、Scanner類

1. Scanner(String s)：構造一個Scanner對象。
2. useDelimiter(正則表達式)：Scanner調用此方法，將此正則表達式作為分隔標記。若不指定分隔標記，默認用空白字符作分隔標記。
3. Scanner對象調用next()方法返回被解析的單詞。
4. hasNext()：若單詞未全部返回，則返回true，否則返回false。
5. hasInt()、hasDouble()：將數字型單詞轉化為int、double返回。若發生InputMismatchException異常，可調用next()返回非數字單詞。

八、StringBuffer類

1. String對象的字符序列的字符不能被修改、刪除，即String對象的實體不能再發生變化。
2. StringBuffer()類的對象的實體的內存空間可以自動改變大小，便於存放一個可變的字符序列。
3. StringBuffer對象可以調用append()方法追加字符序列。
4. StringBuffer()：分配的初始容量為16個字符，當實體的長度大於16時，自動增加。
5. StringBuffer(int size)：指定初始容量為size個字符。
6. StringBuffer(String s)：初始容量為s的長度加上16個字符。
7. length()：StringBuffer對象調用，獲取字符序列的長度。
8. capacity()：StringBuffer對象調用，當前實體的實際容量。
9. StringBuffer append(String s)：將s追加到當前StringBuffer對象後，返回當前StringBuffer對象的引用。
10. StringBuffer append(int n)：將n轉化為String對象，再追加到當前StringBuffer對象後，返回當前StringBuffer對象的引用。
11. StringBufferappend(Object o)：將Object對象o的字符序列表示追加到當前StringBuffer對象後，返回當前StringBuffer對象的引用。
12. public charcharAt(int n)：得到StringBuffer對象的位置n上的字符。
13. public char setCharAt(int n，char ch)：將StringBuffer對象的位置n上的字符替換為ch。
14. StringBuffer insert(int index,String str)：將str的字符序列插入到index指定的位置。
15. public StringBuffer reverse()：將當前對象的字符序列翻轉，返回當前對象的引用。
16. StringBuffer delete(int startIndex,int endIndex)：刪除startIndex位置到endIndex-1位置處的字符序列，返回當前對象的引用。
17. deleteCharAt()：刪除index位置上的一個字符。
18. StringBuffer replace(int startIndex,int endIndex,String str)：將startIndex位置到endIndex-1位置處的字符序列替換為str，返回當前對象的引用。

九、Date類與Calendar類

1. Date類在java.util包中，使用無參構造方法Date()可獲得本機當前的日期和時間。

   Date nowTime = new Date();
   System.out.println(nowTime);  //Date類重寫了Object類的toString方法，輸出實體而不是引用

   輸出 Sat Oct 01 14:39:22 CST 2016

2. 計算機系統自身的時間為“公元”，為1970年1月1日0時（格林威治時間），北京時間為08時。
3. 使用構造方法Date(long time)：負數為公元後time毫秒，正數為公元前time毫秒。

   Date date1 = new Date(1000);  //北京時間1970年1月1日08時00分01秒
   Date date2 = new Date(-1000); //北京時間1970年1月1日07時59分59秒

   可用System.currentTimeMillis()獲取當前系統時間，返回從“公元”走到現在的毫秒數。

4. Calendar類在java.util包中，使用此類的static方法getInstance()初始化一個日歷對象。
5. set(int year,int month,int date,[int hour,int minute,[int second]])：將日歷翻到任何時間，year為負標明是公元前（實際）。
6. public int get(int field)：獲取年份、月份、星期等信息，field為Calendar類的靜態常量：

   Calendar calendar = Calender.getInstance();
   calendar.get(Calendar.MONTH);            //獲取月份，0表示一月，1表示二月
   calendar.get(Calendar.DAY_OF_WEEK);  //獲取星期信息，1表示星期日，2表示星期一

   public long getTimeInMillis()返回當前對象的毫秒計時（與“公元”的差值）。

十、Math類、BigInteger類、Random類

1. Math類在java.lang包中，有兩個static常量E和PI。
2. public static long abs(double a)、double max(double,double)、min(double,double)、random()[產生0~1的隨機數，不包括1]、pow(double,double)、sqrt()、log()、sin()、asin()、ceil()、floor()、long round()[四舍五入]。
3. BigInteger類在java.math包中，其對象用來處理特別大的整數。
4. BigInteger(String val)：構造BigInteger類的對象，若val含有非數字，則發生NumberFormatException異常。
5. public BigInteger add/subtract/multiply/divide/remainder(BigInteger val)：返回當前對象與val的和/差/積/商/余。
6. public int compareTo(BigInteger val)：返回當前對象與val的比較結果，1（大於）、-1（小於）、0（等於）。
7. public BigInteger abs()：返回絕對值。
8. public BigInteger pows(int a)：當前對象的n次冪。
9. public String toString(int p)：當前對象的p進制的字符串表示，無參時，為十進制。
10. Random類在java.util包中，更靈活地獲得隨機數。
11. Random()或Random(long seed)：構造Random對象，即隨機數生成器,seed為種子，可調用nextInt()或nextInt(int m)返回一個隨機整數。

    Random random = new Random();
    random.nextInt();       //返回一個整數
    random.nextInt(int m);  //返回一個0~m的整數，不包括m

12. public boolean nextBoolean()：得到ture或false。

十一、數字格式化

1. 數字格式化，就是按照指定的格式得到一個字符序列。
2. 使用String類調用format方法對數字進行格式化。

   例：
   String s = String.format("%.2f",3.141592);  //得到3.14

3. 加號修飾符“+”：強制加上正號。
4. 逗號修飾符“,”：格式化整數時，按“千”分組。
5. %e(%E)：格式化為科學記數法的十進制的浮點數。

十二、Class類與Console類

1. Class類在java.lang包中，幫助程序創建其他類的實例。
2. 使用Class的類方法public static Class forName(String className)創建一個和ClassName指定的類相關的Class對象

   public static Class forName(String className) throws ClassNotFoundException

   如果類在某個包中，className必須帶有包名，例：className = "java.util.Date"。

3. 使用public Object newInstance()方法得到一個className類的對象

   public Object newInstance() throws InstantiationException,IllegalAccessException

   className類必須有無參數的構造方法。

十三、Console類

1. Console類在java.io包中，在鍵盤輸入一行文本時，是文本不回顯（不再命令行顯示）。
2. 使用System類中的static方法console()返回Console類的一個對象

   Console cons = System.console();

   cons調用方法readPassword()方法讀取用戶在鍵盤上輸入的一行文本，將文本以char數組返回

   char [] passwd = cons.readPassword();

十四、Pattern類與Matcher類

1. Pattern類和Matcher類在java.util.regex包中，用來進行模式匹配，也就是檢索和指定模式匹配的字符序列。

   String input = "hello,good morning,this is a good idea";

   若想知道good出現在input的那個位置，需使用這兩個類。

2. 建立Pattern對象(模式對象)：

   String ergex = "good";
   pattern = Pattern.compile(regex);

   也可以調用compile(String regex,int flags)：flags取Pattern.CASE_INSENSITIVE時，模式匹配時忽略大小寫。

3. 利用Matcher類得到檢索String對象input的實例matcher（匹配對象）

   Matcher matcher = pattern.matcher(input);

   模式對象pattern調用matcher()方法創建Matcher類的對象。

4. boolean find()：返回boolean值，是否能將regex與input匹配，每次調用時，從上次結束的索引處開始。
5. start()/end()：返回regex出現在input中的開頭和結尾的索引。
6. matcher.group()：返回檢索到的與regex匹配的字符串。
7. public String replaceAll(String replacement)/public String replaceFirst(String replacement)：將regex匹配到的子字符序列替換為replacement/只替換第一個匹配到的子字符串。

習題

8.4.1

public class Practice8_4_1 {
    public static void main(String[] args) {
        String str1 = "I love you baby";
        String str2 = str1.toUpperCase();
        System.out.println(str2);
        str2 = str2.toLowerCase();
        System.out.println(str2);
        System.out.println(str1.concat(",I miss you."));
    }
}

8.4.3

import java.util.Calendar;

public class Practice8_4_3 {
    public static void main(String[] args) {
        String [] str = new String[7];
        int date [] = new int[7];
        for(int i = 1;i < str.length;i++) {
            str[i] = args[i-1];
            date[i] = Integer.parseInt(str[i]);
        }
        Calendar calendarOne = Calendar.getInstance();
        Calendar calendarTwo = Calendar.getInstance();
        calendarOne.set(date[1],date[2]-1,date[3]);
        calendarTwo.set(date[4],date[5]-1,date[6]);
        int day = (int)((calendarOne.getTimeInMillis()-calendarTwo.getTimeInMillis())/(1000*60*60*24));
        System.out.printf("還有%d天",day);
    }
}

8.4.5

import java.util.*;

public class Practice8_4_5 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        String regex = "[^0123456789]+";
        String [] s = str.split(regex);
        String fin = "";
        for(int i = 0;i < s.length;i++) {
            fin = fin + s[i];
        }
        System.out.println("fin");
    }
}

8.4.6

import java.util.Scanner;

public class Practice8_4_6 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner("數學87分，物理76分，英語96分");
        scanner.useDelimiter("[^0123456789.]+");
        double sum = 0;
        int count = 0;
        while(scanner.hasNext()) {
            sum = sum + scanner.nextDouble();
            count++;
        }
        System.out.printf("總分為：%.2f\n",sum);
        System.out.printf("平均分為：%.2f\n",sum/count);
    }
}

第八章 常用實用類