Day17-常用API

AIains

已于 2023-10-18 17:00:05 修改

阅读量264

点赞数 1

分类专栏：黑马程序员Java基础学习笔记文章标签： java 学习

于 2023-03-09 09:17:14 首次发布

本文链接：https://blog.csdn.net/AIains/article/details/127210593

版权

黑马程序员Java基础学习笔记专栏收录该内容

17 篇文章 34 订阅

订阅专栏

API就是Java帮我们写好的各种功能的Java类，只需要记住类名和类的作用就行，然后查阅API帮助文档。

1、Math

是一个帮助我们用于进行数学计算的工具类。

里面的方法都是静态的。私有化构造方法，所有的方法都是静态的。

Math类的常用方法如下：

实践案例代码如下：

package MathTest01;

public class MathDome01 {
    public static void main(String[] args) {
        System.out.println(Math.abs(-88));
        System.out.println(Math.max(20,30));
    }
}

2、System

System也是一个工具类，提供了一些与系统相关的方法。

System中常用的方法如下：

currentTimeMillis()方法返回的时间是从时间原点开始到代码运行的时间有多少毫秒

实践案例代码如下：

package MathTest;

//测试exit方法
public class Test {
    public static void main(String[] args) {
        //方法的形参：（状态码）
        //0：表示当前虚拟机是正常停止
        //非0（一般填写1）：表示当前虚拟机异常停止，在学生管理系统中和拼图游戏中进行程序的关闭时用过
        System.exit(0);
        System.out.println("看看我执行了吗");
    }
}
//输出结果为空，因为虚拟机结束运行之后，后面的代码就不再运行了，因此下面的那个输出语句不再执行

package MathTest;

//测试 currentTimeMillis()方法
public class Test {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        int count = 0;
        for (int i = 0; i < 100000; i++) {
            if(i%3==0)
                count++;
        }
        long end = System.currentTimeMillis();
        System.out.println("程序执行了" + (end -start ) + "毫秒");
        System.out.println(count);//输出统计后的个数
    }
}
//说明：可以用来统计程序运行了多少毫秒

package MathTest;

//测试arraycopy()方法

/**细节：
 * 1、如果数据源数据和目的数据数组都是基本数据类型，那么两者的类型必须保持一致，否则会报错
 * 2、在拷贝的时候需要考虑数组长度，如果截取的数据长度大于目标数组的长度，则会报错
 * 3、如果数据源数据和目的数据数组都是引用数据类型，那么子类类型可以赋值给父类类型
 *
 */
public class Test {
    public static void main(String[] args) {
        //对细节1进行测试
        int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
        int[] arr2 = new int[10];
        //参数1：数据源，要拷贝的数据从哪个数组中来
        //参数2：从原数组中的第几个索引开始拷贝
        //参数3：目标数组，要把数据拷贝到哪个数组里面
        //参数4：把数据放进目标数组时，从目标数组的哪个索引开始放置
        //参数5：拷贝的数据的个数
        System.arraycopy(arr1,0,arr2,5,5);

        //输出数组arr2，验证结果
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");
        }
        System.out.println();
        //输出结果为：0 0 0 0 0 1 2 3 4 5


        //对细节3进行测试
        Student s1 = new Student("张三",23);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("王五",25);
        Student[] sarr1 = {s1,s2,s3};
        Student[] sarr2 = new Student[3];
        //把sarr1中的数据拷贝到sarr2中
        System.arraycopy(sarr1,0,sarr2,0,3);
        //遍历数组sarr2检测结果
        for (int i = 0; i < sarr2.length; i++) {
            Student stu  = sarr2[i];
            System.out.println(stu.getName()+","+stu.getAge());
        }

        System.out.println("-----------");

        Person[] sarr3 = new Person[3];
        //把sarr1中的数据拷贝到sarr3中
        System.arraycopy(sarr1,0,sarr3,0,3);
        //遍历数组sarr3检测结果
        for (int j = 0; j < sarr3.length; j++) {
            //子类类型可以赋值给父类类型,只不过需要进行强制转换
            Student stu1  = (Student) sarr3[j];
            System.out.println(stu1.getName()+","+stu1.getAge());
        }

    }
}
//创建父类Person类
class Person {
    private String name;
    private int age;
    public Person() { }
    public Person(String name, int age) {
        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; }
}
//创建student类调用父类Person
class Student extends Person {
    public Student() { }
    public Student(String name, int age) {super(name, age); }
}

小结：

3、Runtime

Runtime表示当前虚拟机的运行环境

这个类里面的方法不是静态的，所以要调用方法就得先获取到Runtime的对象，但是这个类的对象我们不能直接new，而是通过一个getRuntime()方法获取得到

Runtime类中常用的方法如下：

使用方法举例如下：

package MathTest;

public class Test {
    public static void main(String[] args) {
        //获取Runtime的对象
        Runtime r1 = Runtime.getRuntime();
        //测试exit方法
        r1.exit(0);
    }
}

4、Object

Object是Java中的顶级父类。所有的类都直接或间接地继承于Object类。

Object类中的方法可以被所有子类访问，所以我们要学习Object类和其中的方法。

Object类只有空参构造，没有带参数的构造方法，因为Object是所有类的父类，并不是所有的类之间都有共性，所以Object无法对它们进行抽取。

Object类常用的成员方法如下：

package MathTest;

/**toString方法
 * 默认返回：全类名（包名+类名）+@+哈希值的十六进制
 */

/**输出语句System.out.println();中的细节如下：
 * System：类名
 * out：静态变量
 * System.out：获取打印的对象
 * println()：方法
 * 参数：表示打印的内容
 * 核心逻辑：
 * 当我们打印一个对象的时候，底层会调用对象toString方法，把对象变成字符串。
 * 然后再打印在控制台上，打印完毕换行处理
 *
 * 思考：默认情况下，因为Object类中的toString方法返回的是地址值
 * 所以，默认情况下，打印一个对象打印的是地址值
 * 但是地址值对于我们是没有什么意义的
 * 我想要看到对象内部的属性值？我们该怎么办？
 * 解决办法：重写父类Object类中的toString方法
 */

/**toString方法的结论：
 * 如果打印一个对象，想要看到属性值的话，那么久重写toString方法就可以了。
 * 再重写方法中，把对象的属性值进行拼接
 */

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

        Object obj = new Object();
        String str1 = obj.toString();
        System.out.println(str1);//输出结果为java.lang.Object@1540e19d
        /*//不重写toString方法的情况下
        Student stu = new Student();
        String str2 = stu.toString();
        System.out.println(str2);//输出结果为MathTest.Student@677327b6*/

        //重写toString方法的情况下
        Student stu = new Student();
        String str2 = stu.toString();
        System.out.println(str2);输出为  null,0
        Student stu11 = new Student("张三",23);//输出为  张三,23
        System.out.println(stu11);
    }
}
class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        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;
    }

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

package MathTest;
import java.util.Objects;
/**测试equals方法
 * 作用：比较两个对象是否相等
 *
 * 结论：
 * 1、如果没有重写equals方法，那么默认使用Object中的方法进行比较，比较的是地址值是否相等
 * 2、一般来讲地址值对于我们的意义不大，所以我们会重写，重写之后比较的就是对象内部的属性值了
 */
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三",23);
        Student s2 = new Student("张三",23);
        //没有重写方法之前，比较的是两个对象的地址值
        //重写方法之后，比较的是两个对象的属性值
        boolean result1 = s1.equals(s2);
        System.out.println(result1); //输出结果为true
    }
}
class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        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;
    }

    //重写之后的equals方法比较的是对象内部的属性值
    @Override//创建方式：alt+Insert 然后一直默认确定即可
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

}

package MathTest;
import java.util.Objects;
/**
 * equals方法有关的大厂面试题及解析
 * 题目：思考下面的输出结果及原理
 */
public class Test {
    public static void main(String[] args) {
        String s = "abc";
        StringBuilder sb = new StringBuilder("abc");
        System.out.println(s.equals(sb));   //false
        /**解析：
         * equals方法是被s调用的，而s是字符串，所以equals要看String类中的
         * String类中的equals方法先判断参数是否为字符串
         * 如果是字符串，再比较内部的属性
         * 但是如果参数不是字符串，直接返回false
         */
        System.out.println(sb.equals(s));   //false
        /**解析：
         * equals方法是被sb调用的，而sb是StringBuilder，所以equals要看StringBuilder类中的
         * 那么在StringBuilder类中，没有重写equals方法，所以使用的是其父类Object中的equals方法
         * 在Object中默认是使用“==”号比较两个对象的地址值
         * 而这里的s和sb记录的地址值是不一样的，所以结果返回false
         */

    }
}

clone方法讲解

1、对象克隆：一区的玩家可以登录到二区，实现了对象克隆的缘故。

浅克隆

深克隆

浅克隆代码实现：

package MathTest01;

import java.util.Arrays;
import java.util.StringJoiner;

/**Cloneable
 * 如果一个接口里面没有抽象方法，表示当前的接口是一个标记性接口
 * 现在的Cloneable表示一旦实现了，那么当前类的对象就可以被克隆
 * 如果没有实现，当前类的对象就不能克隆
 */
public class User implements Cloneable{
    private int id;//游戏角色
    private  String username;//用户名
    private String password;//密码
    private String path;//游戏图片
    private int[] date;//游戏进度

    public User() {
    }

    public User(int id, String username, String password, String path, int[] date) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.path = path;
        this.date = date;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public int[] getDate() {
        return date;
    }

    public void setDate(int[] date) {
        this.date = date;
    }

    @Override//Object类中的toString方法
    public String toString() {
        return "游戏编号为：" + id + ", 用户名：" + username +", 密码：" + password +", 游戏图片：" + path +
                ", 进度：" + arrToString();
    }
    public String arrToString(){    //把数组转化为字符串，返回值类型为字符串
        StringJoiner sj = new StringJoiner(",","[","]");
        for (int i = 0; i < date.length; i++) {
            sj.add(date[i] + "");
        }
        return sj.toString();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //调用父类中的clone方法
        //相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回出去
        return super.clone();
    }
}

package MathTest01;

public class test {
    public static void main(String[] args) throws CloneNotSupportedException {
        //1、先创建一个对象
        int[] date = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0};
        User u1 = new User(1,"张三","1223456","gril33",date);

        //2、克隆对象
        //细节：方法在底层会帮我们创建一个对象，并把原对象中的数据拷贝过去
        /**书写细节：
         * 1、重写Object类中的clone方法
         * 2、让JavaBean类实现Cloneable接口
         * 3、创建原对象并调用clone方法就可以了
         */
        User u2 = (User) u1.clone();//相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回

        System.out.println(u1);
        System.out.println(u2);
        /**输出结果如下：
         * 游戏编号为：1, 用户名：张三, 密码：1223456, 游戏图片：gril33, 进度：[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0]
         * 游戏编号为：1, 用户名：张三, 密码：1223456, 游戏图片：gril33, 进度：[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0]
         */

    }
}

5、Objects类

Objects类是一个工具类，提供了一些方法去完成一些功能。

实践案例代码如下：

package Test03;

import java.util.Objects;

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

    public Student() {
    }

    public Student(String name, int age) {
        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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

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

package Test03;

import java.util.Objects;

public class test {
    public static void main(String[] args) {
        //创建学生类对象
        Student s1 = new Student("张三",23);
        Student s2 = new Student("张三",23);
        Student s3 = null;
        //比较两个对象的属性值是否相等
        boolean result1 = s1.equals(s2);
        System.out.println(result1);//true

        boolean result2 = s2.equals(s3);
        System.out.println(result2);//false

        /*boolean result3 = s3.equals(s2);//null不能调用方法
        System.out.println(result2);//报错，*/

        boolean result4 = Objects.equals(s2,s3);
        System.out.println(result4);//false
        /**细节：
         * 1、方法的底层会判断s2是否为null，如果为null，直接返回false
         * 2、如果s2不为null，那么利用s2再次调用equals方法
         * 3、此时s2是Student了理性，所以最终还是会调用Student中的equals方法
         * 如果没有重写，比较地址值，如果重写了，就比较属性值
         *
         */

        Student stu1 = new Student();
        Student stu2 = null;
        System.out.println(Objects.isNull(stu1));//false
        System.out.println(Objects.isNull(stu2));//true

        System.out.println(Objects.nonNull(stu1));//true
        System.out.println(Objects.nonNull(stu2));//false

    }
}

6、BigInteger基本使用

6.1 BigInteger的构造方法

BigInteger可以创建特别特别大的整数，几乎相当于无上限。

package BigInteger;

import java.math.BigInteger;
import java.util.Random;

public class Dome01 {
    public static void main(String[] args) {
        //1、获取一个随机大整数
        BigInteger bd1 = new BigInteger(4,new Random());
        System.out.println(bd1);//   0 ~ 2的4次方-1       相当于[0~15]
        //2、获取一个指定的大整数(参数字符串中必须是整数，否则会报错)
        BigInteger bd2 = new BigInteger("999999999999999999999999");
        System.out.println(bd2);//999999999999999999999999
        //3、获取指定进制的大整数
        /**细节：
         * 1、字符串中的数字必须是整数
         * 2、字符串中的数字必须要跟进制吻合
         * 比如二进制中，那么只能写0和1，写其他就会报错
         */
        BigInteger bd3 = new BigInteger("14",16);
        System.out.println(bd3);//20
        //4、那个静态的方法
        /**细节：
         * 1、能表示的范围比较小，只能在long的取值范围之内，如果超出了long的取值范围就不行了
         * 2、在内部对常用的数字：-16 ~ 16 进行了优化
         * 提前把 -16 ~ 16 先创建好BigInteger的对象，如果多次获取不会重新创建新的
         */
        BigInteger bd5 = BigInteger.valueOf(16);
        BigInteger bd6 = BigInteger.valueOf(16);
        System.out.println(bd5 == bd6);//true
    }
}

小结：

6.2 BigInteger常见成员方法

BigInteger是一个对象，对象不能直接进行加减乘除运算，所有的操作必须通过调用方法进行

package BigInteger;

import java.math.BigInteger;

public class Dome02 {
    public static void main(String[] args) {
    //1、创建两个BigInteger对象
        BigInteger bd1 = BigInteger.valueOf(10);
        BigInteger bd2 = BigInteger.valueOf(5);
    //2、加法
        BigInteger bd3 = bd1.add(bd2);
        System.out.println(bd3);//15
    //3、除法，获取商和余数
        BigInteger[] arr = bd1.divideAndRemainder(bd2);
        System.out.println(arr.length);//数组长度为2
        System.out.println(arr[0]);//商为：2
        System.out.println(arr[1]);//余数为：0
    //4、比较是否相同
        //ctrl+alt+v自动生成左边的boolean result
        boolean result = bd1.equals(bd2);
        System.out.println(result);//false
        //5、次幂
        BigInteger bd4 = bd1.pow(2);
        System.out.println(bd4);//100
        //6、max
        BigInteger bd5 = bd1.max(bd2);
        System.out.println(bd5);//10
        //7、转为int类型整数，超出范围时会报错
        BigInteger bd6 = BigInteger.valueOf(1235465463511L);//数据超出int范围
        int i = bd6.intValue();
        System.out.println(i);//输出数据就会不符合预期
    }
}

小结：

7、BigDecimal基本使用

BigDecimal的作用：

1、用于小数的精确计算。

2、用来表示很大的小数。

package BigDecimal;
//BigDecimal的构造方法练习
import java.math.BigDecimal;

public class Dome01 {
    public static void main(String[] args) {
        //1、直接用下面的四种进行计算小数，结果是不精确的
        System.out.println(0.09 + 0.01);//输出：0.09999999999999999
        System.out.println(0.216 - 0.1);//输出：0.11599999999999999
        System.out.println(0.336 * 0.01);//输出：0.00336
        System.out.println(0.09 / 0.1);//输出：0.8999999999999999

        /**利用下面的方式
         * 构造方法获取BigDecimal对象
         *      public BigDecimal(double val)
         *      public BigDecimal(String val)
         *
         * 静态方法获取BigDecimal对象
         *      public static BigDecimal valueOf(double val)
         */
        //1、通过传递double类型的小数来创建对象
        //细节：这种方式可能是不精确的，所以不建议使用!!!!!!
        BigDecimal bd1 = new BigDecimal(0.01);
        BigDecimal bd2 =new BigDecimal(0.09);
        System.out.println(bd1);
        System.out.println(bd2);

        //2、通过传递字符串表示的小数来创建对象(常用)
        BigDecimal bd3 = new BigDecimal("0.01");
        BigDecimal bd4 = new BigDecimal("0.09");
        BigDecimal bd5 =bd3.add(bd4);
        System.out.println(bd3);//0.01
        System.out.println(bd4);//0.09
        System.out.println(bd5);//0.10

        //3、通过静态方法获取对象（常用）
        BigDecimal bd6 = BigDecimal.valueOf(10);
        System.out.println(bd6);//10

        /**细节：
         * 1、如果表示的数字不大，没有超出double的取值范围，建议使用静态方法
         * 2、如果表示的数字较大，超出了double的取值范围，建议使用构造方法（通过传递字符串的构造方法）
         * 3、如果我们传递的参数是 0 ~ 10 之间的整数，包含0，包含10，那么方法会返回已经创建好的对象，不会重新new
         */

    }
}

常见的成员方法如下：

package BigDecimal;

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Dome02 {
    public static void main(String[] args) {
        //获取两个对象
        BigDecimal bd1 = BigDecimal.valueOf(10.0);
        BigDecimal bd2 = BigDecimal.valueOf(4.0);
        BigDecimal bd3 = BigDecimal.valueOf(3.0);

        //1、加法
        BigDecimal bd4 = bd1.add(bd2);
        System.out.println(bd4);//14.0
        //2、除法
        BigDecimal bd5 = bd1.divide(bd2);
        System.out.println(bd5);//2.5

        BigDecimal bd6 = bd1.divide(bd3,2, RoundingMode.HALF_UP);//RoundingMode.HALF_UP为四舍五入
        System.out.println(bd6);//3.33


    }
}

小结：

8、正则表达式

正则表达式可以校验字符串是否满足一定的规则，并用来校验数据格式的合法性。

学前了解

package Regex;

/**QQ号要求
 * 长度在6~20位之间
 * 不能用0开头
 * 必须全部都是数字
 */
public class Dome01 {
    public static void main(String[] args) {
        //方法1：利用以前的知识就是定义方法，然后调用方法
        String qq = "1234567890";
        boolean result = checkQQ(qq);
        System.out.println(result);//true
        //方法2：正则表达式
        boolean re = qq.matches("[1-9]\\d{5,19}");
        System.out.println(re);//true
    }
    public static boolean checkQQ(String qq) {
        //核心思想：
        //先把异常数据进行过滤，下面就是满足要求的数据了
        //规则1：长度在6~20位之间
        int len = qq.length();
        if (len < 6 || len > 20) {
            return false;
        }
        //规则2：不能用0开头
        if (qq.startsWith("0")) {
            return false;
        }
        //规则3：必须全部都是数字
        for (int i = 0; i < qq.length(); i++) {
            char c = qq.charAt(i);
            if (c < '0' || c > '9') {
                return false;
            }
        }
        return true;
    }
}

正则表达式的作用：

作用1：检验字符串是否满足规则。

作用2：在一段文本中查找满足要求的内容。

注意：只匹配一个字符！！！

心得：拿着一个正确的数据，从左到右依次去写

package Regex;
//API帮助文档中搜索Pattern即可找到正则表达式的相关内容
public class Dome02 {
    public static void main(String[] args) {
        //public boolean matches(String regex):判断是否与正则表达式匹配，如果匹配则返回true
        //1、字符类
        //细节：
        //如果要求两个范围的交集，那么需要写符号 &&
        //如果写成了一个 & ，那么此时&表示的就不是交集了，而是一个简简单单的&符号
        //只能是a,b,c
        System.out.println("-------1------");
        System.out.println("a".matches("[abc]"));   //true
        System.out.println("z".matches("[abc]"));   //false
        System.out.println("ab".matches("[abc]"));  //false
        System.out.println("ab".matches("[abc][abc]")); //true
        //不能出现a,b,c
        System.out.println("-------2------");
        System.out.println("a".matches("[^abc]"));  //false
        System.out.println("z".matches("[^abc]"));  //true
        System.out.println("zz".matches("[^abc]")); //  false
        System.out.println("zz".matches("[^abc][^abc]"));   //true
        //a到z A到Z（包含头尾的范围）
        System.out.println("-------3------");
        System.out.println("a".matches("[a-zA-Z]"));    //true
        System.out.println("z".matches("[a-zA-Z]"));    //true
        System.out.println("aa".matches("[a-zA-Z]"));   //false
        System.out.println("zz".matches("[a-zA-Z][a-zA-Z]"));   //true

        //2、预定义字符
        // . 表示任意一个字符
        System.out.println("你".matches(".."));  //false
        System.out.println("你".matches("."));  //true
        System.out.println("你a".matches(".."));  //true

        //   \\d只能是任意一个数字
        //简单来记：两个 \ 表示一个 \
        System.out.println("a".matches("\\d"));  //false
        System.out.println("3".matches("\\d"));  //true
        System.out.println("333".matches("\\d"));  //false
        System.out.println("333".matches("\\d\\d\\d"));  //true

        //3、数量词
        //必须是数字，字母，下划线   至少出现6位
        System.out.println("2442dafde".matches("\\w{6,}"));//true
        System.out.println("244".matches("\\w{6,}"));//false
        //必须是数字和字母  必须是4位
        System.out.println("24gT".matches("[a-zA-Z0-9]{4,}"));//true
        System.out.println("24_f".matches("[a-zA-Z0-9]{4,}"));//false
        System.out.println("24yT".matches("[\\w&&[^_]]{4,}"));//true
        System.out.println("24_T".matches("[\\w&&[^_]]{4,}"));//false
    }
}

练习题：

请编写正则表达式验证用户输入的手机号是否满足要求。

请编写正则表达式验证用户输入的邮箱号是否满足要求。

请编写正则表达式验证用户输入的电话号码是否满足要求。

package Regex;
//切记：写正则表达式的时候，一定要拿着一个正确的数据，从左到右依次去写
public class Dome03 {
    public static void main(String[] args) {
        //1、手机号正确格式：16345678901
        /**分成三部分：
         * 第一部分：1 表示手机号码只能以1开头
         * 第二部分：[3-9] 表示手机号码第二位只能是3-9之间的数
         * 第三部分：\\{9} 表示任意数字可以出现9次，也只能出现9次
         */
        String regex1 = "1[3-9]\\d{9}";
        System.out.println("14725803691".matches(regex1));  //true
        System.out.println("24725803691".matches(regex1));  //false
        System.out.println("127203691".matches(regex1));    //false
        System.out.println("14725824503691".matches(regex1));   //false
        System.out.println("---------");
        //2、座机电话号码正确格式：020-2324242或者0712-3242434或者02122442
        /**分成三部分：
         * 第一部分：区号。    0 表示以0开头     \\d{2,3}  表示区号从第二位开始可以是任意数字，可以出现2次或3次
         * 第二部分：-。       -？ 表示 - 出现0次或者一次
         * 第三部分：号码。    [1-9]表示号码的第一位也不能以0开头   \\d{4,9}表示从第二位开始可以是任意的数字，号码的总长度为5~10位
         */
        String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
        System.out.println("020-2324242".matches(regex2));//true
        System.out.println("0712-3242434".matches(regex2));//true
        System.out.println("02122442".matches(regex2));//true
        System.out.println("020-2326966644242".matches(regex2));//false
        System.out.println("-----------------");
        //3、邮箱号码正确格式：740209936@qq.com     zhangsan@itcosst.cnn    daei0994@163.com   dauia99514@pci.com.cn
        /**分成三部分：
         * 第一部分：@的左边  \\w+  表示任意的字母、数字、下划线，至少出现一次
         * 第二部分：@  只能出现一次
         * 第三部分：
         *          3.1     . 的左边  [\\w&&[^_]]{2,6}  表示任意的字母加数字，总共出现2~6次（此时不能出现下划线）
         *          3.2     .   用 \\. 来表示
         *          3.3     大写字母，小写字母都可以，只能出现 2~3 次   [a-zA-Z]{2,3}
         *                  我们可以把3.2和3.3看成一组，这一组可以出现或者两次
         */
        String regex3 = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";    //小括号内表示一个组
        System.out.println("740209936@qq.com".matches(regex3));//true
        System.out.println("zhangsan@itcost.cnn".matches(regex3));//true
        System.out.println("daei0994@163.com".matches(regex3));//true
        System.out.println("dauia99514@pci.com.cn".matches(regex3));//true
        //在实际开发中，很少会自己写正则表达式
        //都是百度一个类似的，自己改成公司要求的。
        //在IDEA中安装any-rule插件，
        //定义一个变量，然后在双引号中，右击鼠标，选择AnyRule,就可以找到常用的正则表达式
        //String regex4 ="";
    }
}

练习2：