java 基础类

阅读数: 次 2020-09-17

Main类

JVM运行Java应用程序的时候，首先会调用main方法，调用时不实例化这个类的对象,而是通过类名直接调用

因此需要是限制为 public static

main()方法定义：public static void main(String[] 字符串数组参数名)

jvm有限制，不能有返回值，因此返回值类型为void

public class Main {
    //主方法入口
    public static void main(String[] args) {
        //输出args数组的长度
        System.out.println(args.length);
        System.out.println("打印main方法中的输出参数");
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

Object类

Object类在java.lang包中，所有Java类都直接或间接扩展Object类，所有Java类都是Object类的子类Object类是所有类的超类。Object类本身没有超类，Object类的引用变量可以保存任何类的对象的引用；

Object类方法

方法	描述
`public String toString()`	我们可以自定义它，它返回对象的字符串表示形式通常它用于调试目的如果类中未重写该方法，则输出：”类名@十六进制的`hashcode`值”，若重写，则输出表述该对象信息的字符串
`System.out.println(xx)`	括号里面的“xx”对象如果不是String类型的话，就自动调用xx的`toString()`方法
`public boolean equals(Object obj)`	默认是比较对象的内存地址，但是个别的类重写了该方法，如String类
`public int hashCode()`	它返回对象的哈希码（整数）值, 根据一定的规则将与对象相关的信息（比如对象的存储地址，对象的字段等）映射成一个数值，这个数值称作为散列值
`protected void finalize() throws Throwable`	不是在Object类中实现它在对象被销毁之前被垃圾收集器调用
`public final Class getClass()`	返回对象的Class对象的引用即可以返回对象的父类等相关信息

public class ObjectTest {
    public static void main(String[] args) {
        String strObj = new String();
        ObjectTest obj = new ObjectTest();
        printClassInfo(strObj);
        printClassInfo(obj);
        String str1 = new String("123456");
        //调用hasCode方法输出对象的哈希值
        System.out.println("str字符串的哈希值为：" + str1.hashCode());
        equalsTest(str1);
        //调用toString方法返回str对象的字符串形式
        System.out.println("返回str对象的字符串形式：" + str1.toString());
    }

    //定义一个printClassInfo()方法来描述getClass()方法
    private static void printClassInfo(Object obj) {
        //获取类名
        System.out.println("类名：" + obj.getClass().getName());
        //获取父类名
        System.out.println("父类：" + obj.getClass().getSuperclass().getName());
        //获取接口信息并输出
        for (int i = 0; i < obj.getClass().getInterfaces().length; i++) {
            System.out.println(obj.getClass().getInterfaces()[i]);
        }
    }

    //定义一个equalsTest方法来描述equals()方法
    public static boolean equalsTest(String str) {
        String passworld = "123456";
        boolean con;
        if (str.equals(passworld)) con = true;
        else {
            con = false;
        }
        System.out.println(con);
        return con;
    }
}

运行结果：

类名：java.lang.String
父类：java.lang.Object
interface java.io.Serializable
interface java.lang.Comparable
interface java.lang.CharSequence
类名：com.rain.ObjectTest
父类：java.lang.Object
str字符串的哈希值为：1450575459
true
返回str对象的字符串形式：123456

String `StringBuffer` `StringBuilder`类

String 类一旦创建将不会改变，与String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象

StringBuffer用法和StringBuilder一样，不过，StringBuffer是线程安全的 ;StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder类

String类方法

char charAt(int index) :取字符串中的某一个字符，其中的参数index指的是字符串中序数,字符串的序数从0开始到length()-1;
int compareTo(String anotherString) :当前String对象与另一个String比较相等关系返回０；不相等时，从两个字符串第0个字符开始比较，返回第一个不相等的字符差 ,另一种情况，较长字符串的前面部分恰巧是较短的字符串，返回它们的长度差。

public static void main(String[] args) {
    //创建字符串
    String greeting = "hello world";
    System.out.println(greeting);
    //string和StringBuffer类的相互转换
    //注意：可以解决scanner类输入字符串进行修改的问题
    String aa = new String("123456");
    StringBuilder bb = new StringBuilder(aa);
    //初始化字符转
    char[] helloArray = {'a', 'b', 'c'};
    String arrayTest = new String(helloArray);
    System.out.println(arrayTest);
    //输出字符串的长度
    System.out.println(arrayTest.length());
    //取字符串中的特定字符
    System.out.println(arrayTest.charAt(1));
    //将两个字符串进行比较
    String str1 = new String("i love cat");
    String str2 = new String("i love cat");
    String str3 = new String("i love cat and dogs");
    System.out.println(str1.compareTo(str2));
    System.out.println(str1.compareTo(str3));
    //连接两个字符串的方法
    String str4 = "我的github网站：";
    String str5 = "https://github.com/hermit-rain";
    System.out.println(str1.concat(str2));
    //描述StringBuilder类中主要使用的方法
    StringBuilder str6 = new StringBuilder("hello ");
    //追加
    System.out.println(str6.append("java"));
    //反转
    System.out.println(str6.reverse());
    //移除
    System.out.println(str6.delete(1, 3));
    //替换
    System.out.println(str6.insert(0, "hello java"));
}

运行结果

hello world
abc
3
b
0
-9
i love cati love cat
hello java
avaj olleh
aj olleh
hello javaaj olleh

Scanner类

Scanner类包括文件输入和字符输入两种格式；
注意：Scanner类只能返回String类的对象不能返回StringBuffer类的对象,要想调用StringBuffer方法必须将String类型转化成StringBuffer类型

Scanner类方法

hasNext hasNextLine作为判断判否还有下一行输入
next nextLine 返回输入源中的下一行字符串

public static void main(String[] args) throws FileNotFoundException {
    //创建Scanner类对象
    Scanner sc = new Scanner(System.in);
    //用next返回输入源中的下一行字符串
    if (sc.hasNext()) {
        String str1 = sc.next();
        System.out.println("输出的数据是：" + str1);
    }
    //用 nextLine返回输入源中的下一行字符串
    if (sc.hasNextLine()) {
        String str2 = sc.nextLine();
        System.out.println("输入字符串str2：" + str2);
    }
    sc.close();
}

`nextInt()` `nextLine()` `next()` 方法分析

next()

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        System.out.println(str);
        System.out.println(str.length());
    }

}

next() 从开始接收到遇到空格结束接收–> 空格换行符跳出结束

并且next()从第一个非空格字符开始接收

nextLine()

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    String str2 = sc.nextLine();
    System.out.println(str2);
    System.out.println(str2.length());
}

nextLine() 可以接收空格遇到回车换行符结束接收并退出

同时nextLine() 可以从空格开始接收，所以其只是遇到换行结束并退出。

nextInt()

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int a = sc.nextInt();
    System.out.println(a);
}

nextInt()并不会自动判断规避字符而选择性的读取整型数据

但是仅当数字前有空格时nextInt() 并不会报错—> nextInt() 从第一个非空格数字读取一直到非数字字符结束遇到回车换行才跳出结束。

当有多个接收对象时候

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int a = sc.nextInt();
    int b = sc.nextInt();
    System.out.println(a);
    System.out.println(b);
}

只有当所有的接收对象的值都接收到才退出程序 –> 否则始终等键盘输入

当所有对象接收完毕后 —> 回车换行才退出结束

当`nextInt()` `nextLine()`同时存在时

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int a = sc.nextInt();
    int b = sc.nextInt();
    String s = sc.nextLine();
    System.out.println(a);
    System.out.println(b);
    System.out.println("s = " + s);
    System.out.println(s.length());
}

通过下图我们发现，当我们刚输入完两个数字还没来得及输入字符串程序就已经退出了–> 这是为什么呢？？

下面的输入可以描述为

5\n2\n

我们一共需要接收三个变量分别是 a b s，我们所有的输入首先会存入缓冲池中，当输入5时，变量a的nextInt() 判断是整型数字–> 开始接收遇到 \n 结束，然后变量 b 的nextInt() 判断2是数字开始读取直到读取到空格或者是字符即结束读入 ,此时遇到的是 \n 所以结束读入，当变量s开始读入的时候nextLine() 判断当前的字符为 \n所以结束读取，读取内容为null，并退出程序。

那我们会好奇那第一个 \n跑哪里去了呢？？

因为当第一个变量a读取完后，变量b是整型变量，它并不关心当前是否有\n –> 我只想拿到整型数据就走人\n与空格 都会被自定越过，但是当我没有先接收数字而是字符等等那我就要报错了…

那么nextInt() 与 nextLine() 到底能否同时使用呢？

答案是肯定的 –> 当然要在同一行输入 –> 避免在字符串还没接收的情况下就先遇到 \n

注意下图中的love 其前面是有空格的，也就是说当数字变量a,b接收完毕后，字符串变量会判断从第一个字符开始接收(包括空格)；

当`nextInt()` `next()`同时存在时

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int a = sc.nextInt();
    int b = sc.nextInt();
    String s = sc.next();
    System.out.println(a);
    System.out.println(b);
    System.out.println("s = " + s);
    System.out.println(s.length());
}

与nextLine()不同的是 next() 会等待输入，因为其并不是遇到\n就结束，而是遇到空格结束读取，遇到\n退出程序

同时其读取依旧是从非空格开始读取—> 当我们同时需要接收整型和字符串变量时我们优先考虑 nextInt() + next()的组合。

System类

System类中包括类有 3 个静态成员变量 ->分别是 PrintStream out、InputStream in 和 PrintStream err

System类方法

arrayCopy() ：数组复制，即从指定源数组中复制一个数组
currentTimeMillis() ：返回当前的计算机时间
identityHashCode(Object x) ：返回指定对象的精确hashCode值

`identityHashCode(Object x)`与`hashCode()`两种方法的区别

Object的hashCode()默认是返回内存地址的，但是hashCode()可以重写，所以hashCode()不能代表内存地址的不同 System.identityHashCode(Object x)方法可以返回对象的内存地址,不管该对象的类是否重写了hashCode()方法，该方法返回指定对象的精确hashCode值，也就是根据该对象的地址计算得到的hashCode值，可以唯一地标识一个对象，判断两个对象是否是指向同一地址，应该用System.identityHashCode(Object x)方法进行判断

public static void main(String[] args) {
    //类方法arrayCopy
    // public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
    //src 表示源数组，srcPos 表示从源数组中复制的起始位置
    //dest 表示目标数组，destPos 表示要复制到的目标数组的起始位置，length 表示复制的个数。
    char[] srcArray = {'A', 'B', 'C', 'D'};
    char[] destArray = new char[4];
    System.arraycopy(srcArray, 1, destArray, 1, 2);
    System.out.println("输出原数组：");
    for (int i = 0; i < srcArray.length; i++) {
        System.out.println(srcArray[i]);
    }
    System.out.println("输出目标数组");
    for (int j = 0; j < destArray.length; j++) {
        System.out.println(destArray[j]);
    }
    //currentTimeMillis() 方法
    //该方法的作用是返回当前的计算机时间，
    // 时间的格式为当前计算机时间与 GMT 时间（格林尼治时间）1970 年 1 月 1 日 0 时 0 分 0 秒所差的毫秒数
    long startTime = System.currentTimeMillis();
    System.out.println(startTime);
    int i;
    long trem = 0;
    for (i = 0; i < 100000000; i++) {
        trem = trem + i;
    }
    System.out.println(trem);
    long endTime = System.currentTimeMillis();
    long soTime = endTime - startTime;
    System.out.println(soTime);
    // identityHashCode(Object x)与hashCode()方法返回相同的哈希值
    String str1 = "hello";
    String str2 = "hello";
    System.out.println(str1.hashCode() + "--------" + str2.hashCode());
    System.out.println(System.identityHashCode(str1) + "-----" + System.identityHashCode(str2));
    String str3 = new String("Hello");
    String str4 = new String("Hello");
    //不同对象通过重写的hashCode()方法返回的值可能相同
    System.out.println(str3.hashCode() + "------" + str4.hashCode());
    //因为str3和str4为两种不同的对象所以他们通过identityHashCode方法返回的内存地址不相同；
    System.out.println(System.identityHashCode(str3) + "-----" + System.identityHashCode(str4));
}

运行结果

输出原数组：
A
B
C
D
输出目标数组
 
B
C
 
1627717227029
4999999950000000
36
99162322--------99162322
1349393271-----1349393271
69609650------69609650
1338668845-----159413332

Math类

提供了两个静态变量：PI和E，值分别为：π和e

包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数等

Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用

public static void main(String[] args) {
    int a, b;
    a = 9;
    b = -10;
    System.out.println(Math.abs(b));
    //计算乘方
    System.out.println(Math.pow(a, b));
    //计算自然对数
    System.out.println(Math.log(a));
    //找出最大值
    System.out.println(Math.max(7, 12));
    //输出90度的正弦值
    //调用Math中的静态变量PI
    System.out.println("90度的正弦值为：" + Math.sin(Math.PI / 2));
}

Random类

Random类专门用于生成一个随机数，它有两个构造器，一个是使用默认的种子（以当前时间为种子），另一个是显式传入一个long整型的种子

使用相同的种子可以产生相同的随机数，为了避免产生相同的随机数常推荐使用当前时间作为 Random对象的种子 Random rand = new Random (System.currentTimeMills());

相比于Math的random()方法，Random类提供了更多的方式来生成各种伪随机数，既可以生成浮点类型的伪随机数，也可以生成整数类型的伪随机数，还可以指定生成随机数的范围，ThreadLocalRandom类是Random的增强版，在并发访问的环境下，使用ThreadLocalRandom来代替Random可以减少多线程资源竞争，保证线程安全，它提供了一个静态方法current( )方法来获取对象，然后调用各种nextXxx( )方法来获取各种基本类型的随机数

public static void main(String[] args) {
    Random rand = new Random();
    //随机产生布尔类型的随机数
    System.out.println(rand.nextBoolean());
    // 生成0.0~1.0之间的伪随机double数
    System.out.println(rand.nextDouble());
    // 生成一个处于int整数取值范围的伪随机整数
    System.out.println(rand.nextInt());
    // 生成0~26之间的伪随机整数
    System.out.println(rand.nextInt(26));
    //使用相同的种子产生相同的随机数
    Random rand1 = new Random(50);
    Random rand2 = new Random(50);
    System.out.println(rand1.nextInt());
    System.out.println(rand2.nextInt());
    //使用当前时间作为种子产生随机数
    Random rand3 = new Random(System.currentTimeMillis());
    Random rand4 = new Random(System.currentTimeMillis() + 1000);
    System.out.println(rand3.nextInt());
    System.out.println(rand4.nextInt());
    //通过ThreadLocalRandom类来生成随机数
    ThreadLocalRandom rand5 = ThreadLocalRandom.current();
    ThreadLocalRandom rand6 = ThreadLocalRandom.current();
    int val = rand5.nextInt(10);
    long va2 = (long) rand6.nextDouble(10.00);
    System.out.println(val);
    System.out.println(va2);
}

运行结果

true
0.7226187365742542
136905558
11
-1160871061
-1160871061
-1341298478
-150115883
3
6

Runtime类

Runtime类描述Java程序的运行时环境，每个Java程序都有一个与之对应的Runtime实例，该类会被自动创建，我们可以通过Runtime.getRuntime() 方法来获取当前程序的Runtime实例，应用程序通过该对象与其运行的环境相连接可以访问JVM的相关信息，如处理器数量、内存信息等

Runtime类方法

public static Runtime getRuntime（）：此方法返回与当前Java应用程序关联的实例或Runtime对象。
public long freeMemory（）：此方法返回JVM（Java虚拟机）中的可用内存量
public long totalMemory（）：此方法返回JVM（Java虚拟机）中的总内存量
public long maxMemory（）：此方法返回Java虚拟机将尝试使用的最大内存量
public Process exec（String command）抛出IOException：此方法在单独的进程中执行给定的命令
public void gc（）：此方法运行垃圾收集器。调用此方法表明Java虚拟机花费了大量精力来回收未使用的对象，以使其当前占用的内存可用于快速重用

public static void main(String[] args) throws IOException {
    //创建一个实例化对象
    Runtime run = Runtime.getRuntime();
    //调用Runtime中的方法获取jvm的相关信息
    System.out.println("jvm中可用的内存数：" + run.freeMemory());
    System.out.println("jvm中总内存数：" + run.totalMemory());
    System.out.println("jvm尝试使用最大的内存数：" + run.maxMemory());
    //通过exec方放来调用jvm单独启用一个进程来执行操作命令
    run.exec("notepad.exe");
    //调用Runtime中gc()方法进行垃圾回收
    run.gc();
}

运行结果

1
2
3

jvm中可用的内存数：130560456
jvm中总内存数：134217728
jvm尝试使用最大的内存数：2116026368

Date类

Data类共有两种构造器分别是无参和有参数的构造器

Date() 生成一个代表当前日期时间的对象
Date(long date) 根据指定的long型整数来生成一个Date对象

Date类方法

boolean after(Date date)：判断当前日期是否在date之后
boolean before(Date date)：判断当前日期是否在date之前
long getTime()：返回该时间对应的long型整数，即从1970年1月1日00:00:00到当前对象之间的时间差
int compareTo(Date date) ：比较当调用此方法的Date对象和指定日期->两者相等时候返回0，调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数

public static void main(String[] args) {
    Date date = new Date();
    System.out.println(date.toString());
    Date date1 = new Date(System.currentTimeMillis());
    //注意参数的设置：  Date类的年份是以1900开头，以0月开头的；
    Date date2 = new Date(2020 - 1900, 6 - 1, 12);
    System.out.println(date1);
    System.out.println(date2);
    //返回当前时间对应的long型整数
    System.out.println(date.getTime());
    System.out.println(date.before(date2));
    System.out.println(date.after(date2));
    System.out.println(date.compareTo(date2));
}

运行结果

Sat Jul 31 15:50:36 CST 2021
Sat Jul 31 15:50:36 CST 2021
Fri Jun 12 00:00:00 CST 2020
1627717836019
false
true
1

Calendar类

Calendar类是一个抽象类，因此不能用构造器来创建对象，必须通过静态方法getInstance( )方法来获取Calendar对象 Calendar类可以直接对date的年份，月份或者日期进行更改

roll以及add的区别

add方法的月份增加年份会进行递增
roll方法月份的增加只会自身进行循环1

public static void main(String[] args) {
    // 创建一个代表系统当前日期的Calendar对象
    Calendar c1 = Calendar.getInstance();
    Date date = c1.getTime();
    //创建一个指定时间的Calendar对象
    Calendar c2 = Calendar.getInstance();
    c2.set(2008, 9, 3);
    System.out.println(date);
    System.out.println(c2.getTime());
    //取出某个时间对象的具体年份月份以及日
    System.out.println(c2.get(Calendar.YEAR));
    System.out.println(c2.get(Calendar.MONTH));
    System.out.println(c2.get(Calendar.DATE));
    //更改年月日
    c1.add(Calendar.YEAR, 2);
    //添加的月份数满12个月后年份会自动增加一位
    c1.add(Calendar.MONTH, 10);
    // roll方法的月份增加只会改变月份，如果满12则会进行迭代
    c2.roll(Calendar.MONTH, 10);
    c1.add(Calendar.DATE, 10);
    System.out.println(c1.get(Calendar.YEAR));
    System.out.println(c1.get(Calendar.MONTH));
    System.out.println(c1.get(Calendar.DATE));
    System.out.println(c2.get(Calendar.MONTH));
    System.out.println(c1.get(Calendar.DATE));
    //Date类与Calendar类的相互转换
    //Date类转Calendar类
    Calendar cal1 = Calendar.getInstance();
    Date date1 = cal1.getTime();
    //Calendar类转Date类
    Date date2 = new Date();
    Calendar cal2 = Calendar.getInstance();
    cal2.setTime(date2);
}

运行结果

Sat Jul 31 15:53:13 CST 2021
Fri Oct 03 15:53:13 CST 2008
2008
9
3
2024
5
10
7
10

BigDecimal类

float和double类型的主要设计目标是为了科学计算和工程计算，因在于我们的计算机是二进制的浮点数没有办法是用二进制进行精确表示商业计算往往要求结果精确，这时候BigDecimal就派上大用场。

BigDecimal类的常用构造方法

public BigDecimal(double val)：将double表示形式转换为BigDecimal 不建议使用
public BigDecimal(int val)：将int表示形式转换成BigDecimal
public BigDecimal(String val)：将String表示形式转换成BigDecimal

注意：参数类型为double的构造方法的结果有一定的不可预知性 String 构造方法是完全可预知的所以BigDecimal类最好使用String类的构造器

BigDecimal类的常用方法

public BigDecimal add(BigDecimal value)：加法
public BigDecimal subtract(BigDecimal value)：减法
public BigDecimal multiply(BigDecimal value)：乘法
public BigDecimal divide(BigDecimal value)：除法

public static void main(String[] args) {
    //BigDecimal类的基础对象的构建
    BigDecimal doubleTest1 = new BigDecimal("0.01");
    BigDecimal doubleTest2 = new BigDecimal(0.01);
    BigDecimal intTest1 = new BigDecimal(178);
    //string 的构造器是完全预知的所以可以精确的表示0.01
    System.out.println(doubleTest1);
    //0.01无法精确的表示double所以系统会默认随机补位
    System.out.println(doubleTest2);
    System.out.println(intTest1);
    //BigDecimal类的基础方法的使用
    BigDecimal testNumber1 = new BigDecimal("0.15");
    BigDecimal testNumber2 = new BigDecimal("0.03");
    System.out.println(testNumber1.add(testNumber2));
    System.out.println(testNumber1.subtract(testNumber2));
    System.out.println(testNumber1.multiply(testNumber2));
    System.out.println(testNumber1.divide(testNumber2));
}

运行结果

0.01
0.01000000000000000020816681711721685132943093776702880859375
178
0.18
0.12
0.0045
5

正则表达式

正则表达式定义了字符串的模式，相当于构建了一个java字符串的自定义模板

java.util.regex 包主要包括以下两个类：

Pattern 类： pattern 对象是一个正则表达式的编译表示，Pattern 类没有公共构造方法要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数
Matcher 类：Matcher 对象是对输入字符串进行解释和匹配操作的引擎与Pattern 类一样，Matcher 也没有公共构造方法需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象

Matcher 类的方法

public int start() ：返回以前匹配的初始索引
public int end() ：返回最后匹配字符之后的偏移量
public boolean find()：尝试查找与该模式匹配的输入序列的下一个子序列

public static void main(String[] args) {
    String str = new String("请尽快联系我17824852705,我的电话是15143385727出售二手书籍16824852705");
    // 创建一个pattern字符串模板
    Pattern pat = Pattern.compile("((17\\d)|(15\\d))\\d{8}");
    //调用Pattern类的matcher方法创建一个Matcher对象
    Matcher m = pat.matcher(str);
    //将给定字符串与模板字符串进行比较
    while (m.find()) {
        //输出所有与模板字符串相匹配的字符串
        System.out.println(m.group());
    }
    //描述正则表达式的特殊字符
    Pattern pat2 = Pattern.compile("a*b");
    Matcher m2 = pat2.matcher("aab");
    boolean boo = m2.matches();
    System.out.println(boo);
    //Matcher类end()和start()方法
    String str2 = new String("java is very good ");
    System.out.println("目标字符串：" + str2);
    Matcher m3 = Pattern.compile("\\w+").matcher(str2);
    while (m3.find()) {
        System.out.println(m3.group() + "起始字符位置：" + m3.start() + "结尾字符位置：" + m3.end());
    }
    //通过正则表达式输出字符串数组
    String[] mails = {"kongyeeku@163.com", "kongyeeku@gmail.com", "ligang@crazyit.org", "wawa@abc.xx"};
    String mailRegEx = "\\w{3,20}@\\w+\\.(com|org|cn|net|gov)";
    Pattern mailPattern = Pattern.compile(mailRegEx);
    //用for循环for（：）方法对数组进行遍历输出
    Matcher matcher = null;
    for (String mail : mails) {
        if (matcher == null)
            //第一次匹配时创建matcher对象
            matcher = mailPattern.matcher(mail);
        //先重置目标字符串-避免后面重置时第一个数组会输出两次；
        matcher.reset(mail);
        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }
}

运行结果

17824852705
15143385727
true
目标字符串：java is very good 
java起始字符位置：0结尾字符位置：4
is起始字符位置：5结尾字符位置：7
very起始字符位置：8结尾字符位置：12
good起始字符位置：13结尾字符位置：17
kongyeeku@163.com
kongyeeku@gmail.com
ligang@crazyit.org

Main类

Object类

Object类方法

String StringBuffer StringBuilder类

String类方法

Scanner类

Scanner类方法

nextInt() nextLine() next() 方法分析

当nextInt() nextLine()同时存在时

当nextInt() next()同时存在时

System类

System类方法

identityHashCode(Object x)与hashCode()两种方法的区别

Math类

Random类

Runtime类

Runtime类方法

Date类

Date类方法

Calendar类

BigDecimal类

BigDecimal类的常用构造方法

BigDecimal类的常用方法

正则表达式

Matcher 类的方法

String `StringBuffer` `StringBuilder`类

`nextInt()` `nextLine()` `next()` 方法分析

当`nextInt()` `nextLine()`同时存在时

当`nextInt()` `next()`同时存在时

`identityHashCode(Object x)`与`hashCode()`两种方法的区别