Java 之經常使用API（二）

時間 2019-12-08

標籤 java 經常使用 api 欄目 Java 简体版

原文原文鏈接

Object類 & System類
日期相關類
包裝類 & 正則表達式

Object類 & System類java

1.1 Object類正則表達式

1.1.1 概述數組

Object類是Java語言中的根類，即全部類的父類。它中描述的全部方法子類均可以使用。全部類在建立對象的時候，最終找的父類就是Object。ide

在Object類衆多方法中，咱們先學習equals方法與toString方法，其餘方法後面課程中會陸續學到。工具

1.1.2 獲取字節碼對象的方式學習

1.經過Object類的getClass()方法獲取this

2.經過類名調用屬性class來獲取spa

3. 經過Class類的靜態方法forName()來獲取code

1.1.2.1 案例代碼一：orm

   package com.gao_01;

public class Teacher {    
    private String name;
    private int age;
    public Teacher() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Teacher(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
 

package com.itheima_01;
/*
 * 獲取字節碼對象的方式
 * 
 * 反射
 */
public class ClassDemo {
    public static void main(String[] args) throws ClassNotFoundException  {
        //方式1    經過Object類的getClass()方法獲取
        Teacher t = new Teacher();
        Class clazz = t.getClass();
        //System.out.println(clazz);//包含了全路徑的類名
        
        
        //方式2    經過類名調用屬性class來獲取
        Class clazz2 = Teacher.class;
        
        //方式3    經過Class類的靜態方法forName()來獲取
        Class clazz3 = Class.forName("com.itheima_01.Teacher");
        
        //System.out.println(clazz == clazz2);
        //System.out.println(clazz == clazz3);
        
        Teacher t2 = new Teacher();
        System.out.println(t.getClass() == t2.getClass());
        
    }
}

1.1.3 toString（）方法

toString （）返回該對象的字符串表示

因爲toString方法返回的結果是內存地址，而在開發中，常常須要按照對象的屬性獲得相應的字符串表現形式，所以也須要重寫它。

1.1.3.1 案例代碼二：

 package com.gao_01;
/*
 * String toString()  : 返回該對象的字符串表示
 *          return getClass().getName() + "@" + Integer.toHexString(hashCode());
 *          getClass():返回一個字節碼對象
 *          Integer.toHexString():返回指定參數的十六進制字符串形式
 *          hashCode()：返回該對象的哈希碼值（內部地址）
 * 
 *     
 * 
 * boolean equals(Object obj)  
 * 
 */
public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "zhangsan";
        s.age = 18;
        System.out.println(s.toString());//com.itheima_01.Student@737951b0
        System.out.println(s);//說明咱們輸出一個對象就是默認輸出這個對象的toString()方法
    }
}

class Student extends Object {
    String name;
    int age;
    /*
    public String toString() {
        return name + "@" + age;
    }
    */
    
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
}

1.1.4 equals（）方法

equals（Object obj）指示其餘某個對象是否與此對象「相等」。

equals方法，用於比較兩個對象是否相同，它其實就是使用兩個對象的內存地址在比較。Object類中的equals方法內部使用的就是==比較運算符。

在開發中要比較兩個對象是否相同，常常會根據對象中的屬性值進行比較，也就是在開發常常須要子類重寫equals方法根據對象的屬性值進行比較。

1.1.4.1 案例代碼三：

package com.gao_01;
import java.util.ArrayList;

/*
 * boolean equals(Object obj)  
 *         使用==來比較兩個對象是否相等，則比較地址值是否相等
 */
public class ObjectDemo2 {
    public static void main(String[] args) {
        Person p = new Person("zhangsan",18);
        Person p2 = new Person("zhangsan",19);
        
        //boolean flag = p.equals(p2);
        
        boolean flag = p.equals(new ArrayList());
        System.out.println(flag);
    }
}

class Person {
    String name;
    int age;
    
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }


    @Override
    public boolean equals(Object obj) {
        //提升效率
        if (this == obj)
            return true;
        
        if (obj == null)
            return false;
        //提升健壯性
        if (getClass() != obj.getClass())
            return false;
        
        //向下轉型
        Person other = (Person) obj;
        
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    
    
    /*@Override
    public boolean equals(Object o) {
        //提升效率 當前對象和傳遞進來的對象地址值同樣，則不用比較成員
        if(this == o) {
            return true;
        }
        
        //提升代碼的健壯性
        if(this.getClass() != o.getClass()) {
            return false;
        }
        
        //向下轉型
        Person other = (Person) o;
        
        if(!this.name.equals(other.name)) {
            return false;
        }
        
        if(this.age != other.age) {
            return false;
        }
        
        return true;
    }*/
}

1.2 System類

System 類包含一些有用的類字段和方法。它不能被實例化。

1.2.1 成員方法

static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) :
     從src源數組的srcPos索引開始,複製length個元素
從destPost位置開始將這些元素放至到dest數組中
  static long currentTimeMillis() 
      返回以毫秒爲單位的當前時間
  static void exit(int status) 
      終止當前正在運行的 Java 虛擬機

1.2.2 案例代碼四：

package com.gao_02;
/*
 * System:包含一些有用的類字段和方法。它不能被實例化。
 *         static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)  
 *         複製數組
 *         static long currentTimeMillis() 
 *         返回當前系統時間
 *         static void exit(int status)  
 *         終止虛擬機的運行
 * 
 * 
 * 
 * 系統
 * 
 */
public class SystemDemo {
    public static void main(String[] args) {
        //method();
        //method2();
        
        //static void exit(int status) 
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
            
            if(i == 50) {
                System.exit(0);
            }
            
        }
    
    }

    private static void method2() {
        /*
         * static long currentTimeMillis() ：以毫秒值返回當前系統時間（1970-1-1 0:0:0至今過了多少毫秒）
         * 1000毫秒 = 1秒
         * 相對於1970-1-1 0:0:0
         * 若是系統時間1970-1-1 0:0:0    0
         * 若是系統時間1970-1-1 0:0:1    1000
         * 若是系統時間1970-1-1 0:1:0    1000 * 60
         * 若是系統時間1970-1-1 1:1:0    1000 * 60 * 60 + 1000 * 60
         */
    
        //long now = System.currentTimeMillis();
        //System.out.println(now);
        
        
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println("hello world");
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    private static void method() {
        /*
         * static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)  
         * 數據源和目的地
         * 
         * src：源數組
         * srcPos:指定從哪一個索引位置開始複製        1
         * dest：目標數組
         * destPos：指定目標數組接收元素的索引位置
         * length：目標數組接收元素的個數
         */
        
        //源數組
        int[] src = {1,2,3,4,5};
        //目標數組
        int[] dest = new int[5];
        
        System.arraycopy(src, 2, dest, 0, 3);
        
        //遍歷目標數組
        for (int i = 0; i < dest.length; i++) {
            System.out.print(dest[i]);
        }
        
        //00000    --- 12345
        //00000 --- 12300
        //00000 --- 34500
    }

}

日期相關類

2.1 Date類

Date: 表示特定的瞬間，精確到毫秒，他能夠經過方法來設定本身所表示的時間，能夠表示任意的時間

2.1.2 案例代碼五：

package com.gao_03;

import java.util.Date;

/*
 * Date: 表示特定的瞬間，精確到毫秒，他能夠經過方法來設定本身所表示的時間，能夠表示任意的時間
 * System.currentTimeMillis():返回的是當前系統時間，1970-1-1至今的毫秒數
 * 
 * 構造方法：
 *         Date() ：建立的是一個表示當前系統時間的Date對象
        Date(long date) ：根據"指定時間"建立Date對象
 
 */
public class DateDemo {
    public static void main(String[] args) {
        //Date()
        //Date d = new Date();
        //System.out.println(d);//Thu Aug 26 14:17:28 CST 2049
        //System.out.println(d.toLocaleString());
        
        //Date(long date) 
        Date d2 = new Date(1000 * 60 * 60 * 24);//時區 有時差
        System.out.println(d2.toLocaleString());

    }
}

2.1.3 Date類經常使用方法

void setTime(long time)  
long getTime()

2.1.4 案例代碼六：

package com.gao_03;

import java.util.Date;

/*
 * Date的經常使用用方法
        毫秒值 --- Date
            設置
            返回值是void，參數long
            void setTime(long time)  
            Date(long date)
        Date --- 毫秒值
            獲取
            返回long，無參數
            long getTime()  
 */
public class DateDemo2 {
    public static void main(String[] args) {
        Date d = new Date();//默認當前系統時間
        //d.setTime(1000 * 60 * 60 * 24 * 2);
        System.out.println(d.toLocaleString());
        System.out.println(d.getTime());//172800000
        
        
        d.setTime(172800000L);
        System.out.println(d.toLocaleString());
    }
}

2.2 DateFormat類 & SimpleDateFormat

DateFormat 是日期/時間格式化子類的抽象類，它以與語言無關的方式格式化並解析日期或時間。日期/時間格式化子類（如 SimpleDateFormat類）容許進行格式化（也就是日期 -> 文本）、解析（文本-> 日期）和標準化。

咱們經過這個類能夠幫咱們完成日期和文本之間的轉換。

繼續閱讀API，DateFormat 可幫助進行格式化並解析任何語言環境的日期。對於月、星期，甚至日曆格式（陰曆和陽曆），其代碼可徹底與語言環境的約定無關。

2.2.1 DateFormat&SimpleDateFormat的經常使用方法

要格式化一個當前語言環境下的日期也就是日期 -> 文本），要經過下面的方法來完成。DateFormat是抽象類，咱們須要使用其子類SimpleDateFormat來建立對象。

A:SimpleDateFormat構造方法

SimpleDateFormat（）用默認的模式和默認語言環境的日期格式符號構造

SimpleDateFormat（String pattern）用給定的模式和默認語言環境的日期格式符號構造

B:DateFormat類方法

format（Date date）將一個Date格式化爲日期/時間字符串

parse（String source）從給定字符串的開始解析文本，以生成一個日期。

2.2.2 案例代碼七：

package com.gao_04;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
 * SimpleDateFormat:
 *         格式化：
 *             Date --- String
 *             2049-8-26 2049年8月26日
 *             String format(Date date) 
 *         解析：
 *             String --- Date
 *             "2049-8-26"
 *             Date parse(String source) 
 * 
 * 構造方法：
 *         SimpleDateFormat() ：使用默認的模式進行對象的構建
 *         SimpleDateFormat(String pattern) ：使用的指定的模式進行對象的構建
 * 
 * 注意：Exception in thread "main" java.text.ParseException: Unparseable date: "49年9月26日  下午1:29"
 *         解析的字符串，模式必須和構建對象的模式同樣
 *
 */
public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        //method();
        //method2();
        //使用指定的模式進行對象的構建
        //1999年9月1日 10:10:10
        //4個小姨2個大美眉和2個小弟弟
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        
        //格式化
        Date date = new Date();
        String s = sdf.format(date);
        System.out.println(s);//2049年08月26日 13:39:12

        
        //解析
        Date d = sdf.parse("2049年08月26日 13:39:12");
        System.out.println(d.toLocaleString());


        

    }

    private static void method2() throws ParseException {
        //使用指定的模式進行對象的構建
        //1999年9月1日
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        //格式化
        Date date = new Date();
        String s = sdf.format(date);
        System.out.println(s);//2049年08月26日
        
        //解析
        Date d = sdf.parse("2049年08月26日");
        System.out.println(d.toLocaleString());
    }

    private static void method() throws ParseException {
        //使用默認模式進行對象的構建
        SimpleDateFormat sdf = new SimpleDateFormat();
        //建立日期對象
        Date date = new Date();
        
        //格式化 把日期對象轉換成字符串
        String s = sdf.format(date);
        System.out.println(s);//49-8-26 下午1:29
        
        //解析 把字符串轉換成日期對象
        Date d = sdf.parse("49年9月26日  下午1:29");
        System.out.println(d.toLocaleString());
    }

}

2.2.3 案例代碼八：

package com.gao_04;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
 * 需求：求出你來這個世界上多少天
 */
public class SimpleDateFormatTest {
    public static void main(String[] args) throws ParseException {
        //出生日期
        String birthday = "1998-01-01";
        //今天日期
        String now = "2000-01-01";
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //將字符串轉換成日期對象
        Date d1 = sdf.parse(birthday);
        Date d2 = sdf.parse(now);
        
        //將日期對象轉換成long類型
        long l = d1.getTime();
        long l2 = d2.getTime();
        
        System.out.println((l2 - l) / 1000 / 60 / 60 / 24);
        
    }
}

2.3 Calendar類

2.3.1 Calendar類概述

Calendar是日曆類，在Date後出現，替換掉了許多Date的方法。該類將全部可能用到的時間信息封裝爲靜態成員變量，方便獲取。

Calendar爲抽象類，因爲語言敏感性，Calendar類在建立對象時並不是直接建立，而是經過靜態方法建立，將語言敏感內容處理好，再返回子類對象，以下：

Calendar類靜態方法

getInstance（）使用默認時區和語言環境得到一個日曆。

Calendar c = Calendar.getInstance(); //返回當前時間

2.3.2 Calendar 類經常使用方法

2.3.3 案例代碼九：

package com.gao_05;

import java.util.Calendar;

/*
 * Calendar：日曆，提供了一些操做年月日時的方法
 * 
 * 獲取
 * 修改
 * 添加
 * 
 * 
 */
public class CalendarDemo {
    public static void main(String[] args) {
        //static Calendar getInstance()  
        Calendar c = Calendar.getInstance();
        
        //void set(int field, int value) ：把指定的字段修改爲指定的值
        //c.set(Calendar.DAY_OF_MONTH, 20);
        
        //void add(int field, int amount): 在指定的字段上加上指定的值
        c.add(Calendar.DAY_OF_MONTH, -1);
        
        //int get(int field) // 返回給定日曆字段的值
        //public static final int YEAR 1 
        //System.out.println(Calendar.YEAR);
        
        //int year = c.get(1);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int day = c.get(Calendar.DAY_OF_MONTH);
        
        
        System.out.println(year + "年" + month + "月" + day + "日");
         
    }
}

包裝類 & 正則表達式

3.1 包裝類

在實際程序使用中，程序界面上用戶輸入的數據都是以字符串類型進行存儲的。而程序開發中，咱們須要把字符串數據，根據需求轉換成指定的基本數據類型，如年齡須要轉換成int類型，考試成績須要轉換成double類型等。那麼，想實現字符串與基本數據之間轉換怎麼辦呢？

Java中提供了相應的對象來解決該問題，基本數據類型對象包裝類：java將基本數據類型值封裝成了對象。封裝成對象有什麼好處？能夠提供更多的操做基本數值的功能。

8種基本類型對應的包裝類以下：

其中須要注意int對應的是Integer，char對應的Character，其餘6個都是基本類型首字母大寫便可。

3.2 包裝類的經常使用方法

3.2.1 案例代碼十：

package com.gao_06;
/*
 * 需求：判斷一個數是否符合int類型的範圍
 * 因爲基本數據類型只能作一些簡單的操做和運算，因此Java爲咱們封裝了基本數據類型，爲每種基本數據類型提供了包裝類
 * 包裝類就是封裝了基本數據類型的類，爲咱們提供了更多複雜的方法和一些變量
 * 
 * byte        Byte
 * short    Short
 * char        Character
 * int        Integer
 * long        Long
 * float    Float
 * double    Double
 * boolean    Boolean
 * 
 * Integer:
 *         String --- int
 *             方式1：int intValue()
 *             方式2： static int parseInt(String s) 
 *         int --- String
 *             方式1： + ""
 *             方式2：String toString()
 * 
 * 構造方法：
 *         Integer(int value) 
 *         Integer(String s) 

 
 */
public class IntegerDemo {
    public static void main(String[] args) {
        /*int n = 10;
        if(n >= Math.pow(-2, 31) && n <= Math.pow(2, 31) -1) {
            System.out.println("符合");
        }
        else {
            System.out.println("不符合");
        }*/
        
         
        Integer i = new Integer("10");
        System.out.println(i);
        
     
        int a = i.intValue();
        System.out.println(a + 10 );
        
 
        int b = Integer.parseInt("20");
        System.out.println(b + 30);
        
        
         
        Integer i2 = new Integer(40);
        String s = i2.toString();
        System.out.println(s);
        
         
        String s2 = Integer.toString(50);
        System.out.println(s2);
        
    }
}

3.3 包裝類的自動裝箱與拆箱

在須要的狀況下，基本類型與包裝類型能夠通用。有些時候咱們必須使用引用數據類型時，能夠傳入基本數據類型。

好比：

基本類型可使用運算符直接進行計算，可是引用類型不能夠。而基本類型包裝類做爲引用類型的一種卻能夠計算，緣由在於，Java」偷偷地」自動地進行了對象向基本數據類型的轉換。

相對應的，引用數據類型變量的值必須是new出來的內存空間地址值，而咱們能夠將一個基本類型的值賦值給一個基本類型包裝類的引用。緣由一樣在於Java又」偷偷地」自動地進行了基本數據類型向對象的轉換。

自動拆箱：對象轉成基本數值

自動裝箱：基本數值轉成對象

3.3.1 案例代碼十一：

package com.gao_06;
import java.util.ArrayList;
/*
 * JDK1.5特性：自動裝箱和拆箱
 * 
 */
public class IntegerDemo2 {
    public static void main(String[] args) {
        //Integer i = new Integer(10);
        
        //自動裝箱
        //至關於： Integer i = new Integer(10);
        //Integer i = 10;
        
        //自動拆箱
        //至關於 int a = i.intValue();
        //Integer i = 10;
        //int a = i;
        
        Integer i = 10;
        Integer i2 = 20;
        Integer i3 = i + i2;
        /*
         * Integer i3 = new Integer(i.intValue() + i2.intValue());
         * 
         */
        
        ArrayList list = new ArrayList();
        list.add(1);//自動裝箱，list.add(new Integer(1));
    }
}

3.4 正則表達式

3.4.1 正則表達式概述

正則表達式是專門解決字符串規則匹配的工具。

正則表達式也是一個字符串，用來定義匹配規則。

參照幫助文檔，在Pattern類中有簡單的規則定義，能夠結合字符串類的方法使用。

3.4.2 正則表達式匹配規則

參照幫助文檔，在Pattern類中有正則表達式的的規則定義，正則表達式中明確區分大小寫字母。咱們來學習語法規則。

正則表達式的語法規則：

字符：x

含義：表明的是字符x

例如：匹配規則爲 "a"，那麼須要匹配的字符串內容就是」a」

字符：\\

含義：表明的是反斜線字符'\'

例如：匹配規則爲"\\" ，那麼須要匹配的字符串內容就是」\」

字符類：[abc]

含義：表明的是字符a、b 或 c

例如：匹配規則爲"[abc]" ，那麼須要匹配的內容就是字符a，或者字符b，或字符c的一個

字符類：[^abc]

含義：表明的是除了 a、b 或 c之外的任何字符

例如：匹配規則爲"[^abc]"，那麼須要匹配的內容就是否是字符a，或者不是字符b，或不是字符c的任意一個字符

字符類：[a-zA-Z]

含義：表明的是a 到 z 或 A 到 Z，兩頭的字母包括在內

例如：匹配規則爲"[a-zA-Z]"，那麼須要匹配的是一個大寫或者小寫字母

字符類：[0-9]

含義：表明的是 0到9數字，兩頭的數字包括在內

例如：匹配規則爲"[0-9]"，那麼須要匹配的是一個數字

字符類：[a-zA-Z_0-9]

含義：表明的字母或者數字或者下劃線(即單詞字符)

例如：匹配規則爲" [a-zA-Z_0-9] "，那麼須要匹配的是一個字母或者是一個數字或一個下滑線

預約義字符類：.

含義：表明的是任何字符

例如：匹配規則爲" . "，那麼須要匹配的是一個任意字符。若是，就想使用 . 的話，使用匹配規則"\\."來實現

預約義字符類：\d [0-9]

含義：表明的是 0到9數字，兩頭的數字包括在內，至關於[0-9]

例如：匹配規則爲"\d "，那麼須要匹配的是一個數字

預約義字符類：\w [a-zA-Z_0-9]

含義：表明的字母或者數字或者下劃線(即單詞字符)，至關於[a-zA-Z_0-9]

例如：匹配規則爲"\w "，，那麼須要匹配的是一個字母或者是一個數字或一個下滑線

數量詞：X?

含義：表明的是X出現一次或一次也沒有

例如：匹配規則爲"a?"，那麼須要匹配的內容是一個字符a，或者一個a都沒有

數量詞：X*

含義：表明的是X出現零次或屢次

例如：匹配規則爲"a*" ，那麼須要匹配的內容是多個字符a，或者一個a都沒有

數量詞：X+

含義：表明的是X出現一次或屢次

例如：匹配規則爲"a+"，那麼須要匹配的內容是多個字符a，或者一個a

數量詞：X{n}

含義：表明的是X出現剛好 n 次

例如：匹配規則爲"a{5}"，那麼須要匹配的內容是5個字符a

數量詞：X{n,}

含義：表明的是X出現至少 n 次

例如：匹配規則爲"a{5, }"，那麼須要匹配的內容是最少有5個字符a

數量詞：X{n,m}

含義：表明的是X出現至少 n 次，可是不超過 m 次

例如：匹配規則爲"a{5,8}"，那麼須要匹配的內容是有5個字符a 到 8個字符a之間

3.4.3 案例代碼十二：

package com.gao_07;
/*
 *     校驗qq號碼
*         要求必須是5-15位
*         0不能開頭
*         必須都是數字
    
    正則表達式：就是一套規則，能夠用於匹配字符串
    
    boolean matches(String regex) ：判斷當前字符串是否匹配指定的正則表達式，若是匹配則返回true，不然返回false
* 
*  
 */
public class RegexDemo {
    public static void main(String[] args) {
        String qq = "12a345";
        /*boolean flag = checkQQ(qq);
        System.out.println(flag);*/
        
        
        boolean flag = qq.matches("[1-9][0-9]{4,14}");
        System.out.println(flag);
    }
    
    public static boolean checkQQ(String qq) {
        int length = qq.length();
        //要求必須是5-15位
        if(length < 5 || length > 15) {
            return false;
        }
        
        //0不能開頭
        if(qq.startsWith("0")) {
            return false;
        }
        
        //必須都是數字
        for (int i = 0; i < length; i++) {
            //獲得參數的每個字符
            char c = qq.charAt(i);
            if(c < '0' || c > '9') {
                return false;
            }
        }
        return true;//符合要求
    }
}

3.4.4 案例代碼十三：

package com.gao_07;
/*
 *  判斷字符串」qaq」中間的字符是不是元音 
 *  
 *  aeiou
 *  AEIOU
 *  
 */
public class RegexDemo2 {
    public static void main(String[] args) {
        boolean flag = check2("qbq");
        System.out.println(flag);
    }
    
    
    public static boolean check(String s) {
        s = s.toLowerCase();
        
        char ch = s.charAt(1);
        /*if(ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
            return true;
        }
        
        return false;*/
        
        String str = "aeiou";
        
        return str.contains(ch + "");
    }
    
    
    public static boolean check2(String s) {
        
        return s.matches("\\w[aeiouAEIOU]\\w");
    }

}

3.5.4 案例代碼十四：

package com.gao_07;
/*
 *  切割字符串"aa,bb,cc";
    切割字符串"-1 99 4 23";
    切割字符串"-1   99 4     23";
    
     String[] split(String regex) 根據給定正則表達式的匹配拆分此字符串。 
 *  
 */
public class RegexDemo3 {
    public static void main(String[] args) {
        //method();
        //method2();
        String s = "-1   99 4     23";
        String[] arr = s.split(" +");
        print(arr);
        
    }

    private static void method2() {
        String s = "-1 99 4 23";
        String[] arr = s.split(" ");
        print(arr);
    }

    private static void method() {
        String s = "aa,bb,cc";
        String[] arr = s.split(",");
        print(arr);
    }
    
    public static void print(String[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }


}