API常用类

想不到id

已于 2022-01-27 01:17:32 修改

阅读量1k

点赞数 3

文章标签： java 开发语言后端

于 2022-01-27 01:13:30 首次发布

本文链接：https://blog.csdn.net/weixin_51720882/article/details/121882463

版权

Java API概述

API(Application Programming Interface)应用程序接口。

API ——> Java语言中实际提供的类和接口；

API文档 ——> 对Java中提供的类和接口中的功能进行说明的文档。

Object类

Object类是所有类的基类（超类或祖宗类）；

所有类直接简介继承Object，为实现多态性；

在类中如果没有声明使用extends关键字指明基类，则默认基类为Object类；

public class Car{
}
public class Car extends Object{
}

toString方法

toString()返回对象的字符串表示形式

public class ShoesDemo {
    public static void main(String[] args) {
        Shoes shoes = new Shoes("篮球鞋",500);
       /*
       输出一个对象时，默认回调用类中toString(),我们的类中如果没有定义toString(),找父类中toString()
       */  System.out.println(shoes);//com.ffyc.javaAPI.stringdemo.objectdemo.Shoes@16d3586
    }
class Shoes {
    private  String name;
    private  float price;

    Shoes(String name, float price){
        this.name = name;
        this.price = price;
    }
    
public class Shoes {
    private  String name;
    private  float price;

    Shoes(String name, float price){
        this.name = name;
        this.price = price;
    }
//将对象以字符串形式输出
    @Override
    public String toString() {
        return "Shoes{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

在没有进行方法重写之前，输出：

com.ffyc.javaAPI.stringdemo.objectdemo.Shoes@16d3586

得不到我们想要的信息，且测试需要所以需要方法的重写：

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

可以根据需要在用户自定义类型中重写toString()方法。并将对象以字符串形式输出

如果在类的声明中未使用extends关键字指明其基类，则默认基类为

Object类

equals方法

public class Equals {
    public static void main(String[] args) {
        Shoes shoes1 = new Shoes("篮球鞋",500);
        Shoes shoes2 = new Shoes("篮球鞋",500);
        Shoes shoes3 = shoes2;
        /*
        shoes1.equals(shoes2)由于ShoesDemo类中没有重写equals()，那么调用Object类中的equals方法
        equals底层源码：
        public boolean equals(Object obj) {
        return (this == obj);
    }

        */
        System.out.println(shoes1.equals(shoes2));//输出false
        System.out.println(shoes2.equals(shoes3));//输出true

        String str1 = new String("asd");
        String str2 = new String("asd");
        System.out.println(str1.equals(str2));//输出true
    }
}

字符串中重写了equals方法，实现是比较两个字符串中每一个字母是否相等；所以一般默认为equals()方法比较的是对象中内容是否相等；底层源码如下：

在这里插入图片描述

==解释：

==用于基本类型比较比较的值是否相等

==用于引用类型比较比较的是引用地址（对象地址）是否相等

Arrays类

toString() 方法

● 声明：public static String toString(type[] a)

● 描述：返回指定数组内容的字符串表示形式。

● 基本数组，字符串表示形式由数组的元素列表组成，括在[]，相邻元素

用“, ”(逗号加空格)分隔

equals方法

● 比较两个非同一数组是否相等，而数组本身的equals判断另一个数组是否它本身。

● 声明：public static boolean equals(type[]a,type[]a2)

● 参数的类型可以是原生数据类型和引用类型的任意一种类型。

● 返回：如果两个相等，则返回true，否则返回false

package com.ffyc.javaAPI.stringdemo.arrys;

import java.util.Arrays;

public class EqualsDemo {

    /*
      Arrays类中包含了许多关于数组操作的静态方法
    */
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5};
        int[] b = {1,2,3,4,5};
        System.out.println(Arrays.equals(a,b));
        /*
          Arrays.equals(a,b)比较的是数组中的内容是否相等
        */
    }
}

sort －排序

import java.util.Arrays;

public class SortDemo2 {
    public static void main(String[] args) {
        User user1 = new User("222222", "1111111", 30000);
        User user2 = new User("222223", "1111112", 30000);
        User user3 = new User("222224", "1111113", 30000);
        User user4 = new User("222225", "1111114", 30000);
        User user5 = new User("222226", "1111115", 30000);
        User[] users = {user1, user2, user3, user4, user5};
        Arrays.sort(users);
        System.out.println(Arrays.toString(users));
        Arrays.sort(users);
//        Arrays.sort(demo3s,1,3);
        System.out.println(Arrays.toString(users));
    }
}

●自定义对象排序

自定义类实现Comparable接口

重写compareTo方法

import java.util.Comparator;
public class User implements Comparable<User> {

    private String account;
    private String password;
    private int money;
    public User(String account, String password, int money) {
        this.account = account;
        this.password = password;
        this.money = money;
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public String getPassword() {
        return password;
    }

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

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    /*
     compareTo:
       为我们的引用类型提供一个自定义排序规则,
       方法会在Arrays类中的sort()方法底层调用
       结果是用来判断大小 (有三种情况): 
       小于0  等于0  大于0
       也可用字符串排序：return  this.account.compareTo(o.account);
    */
    @Override
    public int compareTo(User o) {
     return this.money - o.money;//-->int类型
        //return  this.account.compareTo(o.account);//-->String类型
    }
    

    @Override
    public String toString() {
        return "User{" +
                "account='" + account + '\'' +
                ", password='" + password + '\'' +
                ", money=" + money +
                '}';
    }
}

运行结果：

[User{account=‘222222’, password=‘1111111’, money=30000}, User{account=‘222223’, password=‘1111112’, money=30000}, User{account=‘222224’, password=‘1111113’, money=30000}, User{account=‘222225’, password=‘1111114’, money=30000}, User{account=‘222226’, password=‘1111115’, money=30000}]

compareTo:
为我们的引用类型提供一个自定义排序规则,方法会在Arrays类中的sort()方法底层调用
结果是用来判断大小 (有三种情况):
小于0 等于0 大于0
也可用字符串排序：return this.account.compareTo(o.account);

binarySearch -使用二分搜索算法搜索指定数组

二分查找的前提：是有序的

在对无序数组进行二分查找时若输出返回为负数则表示没有找到，所以需将数组进行排序方可进行二分查找

● 声明：

public static int binarySearch(type[] a, type key)

public static int binarySearch(long[] a,int fromIndex,int toIndex,long key)

● 参数：

a - 要搜索的数组。

key - 要搜索的值。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

type -byte、double、float、object、long、int、short、char

import java.util.Arrays;

public class SortDemo3 {
    public static void main(String[] args) {
        int[] a = {5,6,9,7,3,2,1};
        Arrays.sort(a);
        System.out.println(Arrays.binarySearch(a,3));
        System.out.println(Arrays.binarySearch(a,0,3,7));
         /*
          在对数组没有排序之前，寻找3时返回为-1
          数组排序后：1 2 3 5 6 7 9
          在对数组排序后，寻找3时返回2
        */
    }
}

数组赋值：传入原数组获得新数组的长度 -->Arrays.copyOf(a,10)

返回一个新数组并将原数组值复制到新数组中–>int[] b = Arrays.copyOf(a,10);

import java.util.Arrays;
public class SortDemo4 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5};
        int[] b = Arrays.copyOf(a,10);
        System.out.println(Arrays.toString(b));
    }
}

String类

String类概述

字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字符串都是String类的实例.

public class StringDemo1 {
    /*
      String类
        由多个字符组成的一串数据，值一旦创建不可改变,一旦值改变就创建一个新对象
            private final char value[];
    */
    public static void main(String[] args) {
        String s = "abc";
        s+="qwe";
    }
}

用Debug调试会更易于理解

● 有两种创建形式：

● 第一种:

简化的创建方式：

String s = “abc”;

先在字符串常量池中查找有没有abc，如果没有就在字符串常量中创建一个对象（abc），如果字符串常量中已经存在abc，那么直接指向已有的对象即可.

String s = "abc";
String s1 = "abc";
System.out.println(s==s1);//true
System.out.println(s.equals(s1));//true

● 第二种:

一概在堆中创建新对象，值存储在堆内存的对象中。

String s = new String(“abc”);

    /*
       new + 构造方法
       凡是new 出来的，在内存空间中时独一无二的
    */
String s2 = new String("abc");
String s3 = new String("abc");
System.out.println(s2 == s3);//false
System.out.println(s2.equals(s3));//true

构造方法

String();

public String() {
this.value = “”.value;
}
String(“字符串”);

  String s1 = new String();

   String s2 = new String("abc");

在这里插入图片描述

判断功能

public class StringDemo2 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "Abc";
        System.out.println(s1.equals(s2));//比较字符串的内容是否相等
        System.out.println(s1.equalsIgnoreCase(s2));//比较字符串的内容是否相等(忽略其大小写)

        System.out.println(s1.contains("a"));//是否包含指定的字符串
        System.out.println(s1.isEmpty());//判断是否为空
        System.out.println(s2.startsWith("A"));//判断是否以指定字符串开始
        System.out.println(s2.endsWith("c"));//判断是否以指定字符串结尾

        String s3 = "a";
        String s4 = "b";
        System.out.println(s3.compareTo(s4));//字符串比大小
    }
}

compareTo底层源代码实现方法：
在这里插入图片描述

获取功能

public class StringDemo3 {
    /*
      获取功能
    */
    public static void main(String[] args) {

        String s = "abcdefd";
        System.out.println(s.length());

        char c = s.charAt(2);
        System.out.println(c);//获取指定位置（索引）的字符

        int in = s.indexOf("d");//从前向后找，只找首次出现的位置
        System.out.println(in);

        int in2 = s.indexOf("f",in+1);//从前向后找，从指定的位置开始找
        System.out.println(in2);

        int in3 = s.lastIndexOf("a");//从后向前查找,首次出现的位置
        System.out.println(in3);

        String s1 = "abcdefd";
        //           0123456

        String s2 =  s1.substring(3);//从指定的为开始截取字符串,直接到最后一位,最终返回一个新的字符串对象
        System.out.println(s1);
        System.out.println(s2);

        String s3 = s1.substring(2,6);//截取指定区间,包含开始位置,不包含结束位置
        System.out.println(s3);
    }
}

转换功能

byte[] getBytes()

getBytes()
使用默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中。

getBytes(Charset charset)
使用给定的charset将该String编码为字节序列，将结果存储到新的字节数组中。

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringDemo4 {

    public static void main(String[] args) throws UnsupportedEncodingException {

        /*
          getBytes()
          使用默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中。
          getBytes(Charset charset)
          使用给定的charset将该String编码为字节序列，将结果存储到新的字节数组中。
        */
        String s = "你好";//默认为UTF-8编码，在UTF-8编码中，一个汉字占三个字节
        byte[] bytes = s.getBytes("UTF-8");//编码
        System.out.println(Arrays.toString(bytes));
        //输出为[-28, -67, -96, -27, -91, -67]
        /*
        String(byte[] bytes, int offset, int length, String charsetName)
        通过使用指定的字符集解码指定的字节子阵列。
        */
        String s1 = new String(bytes,3,3,"UTF-8");//解码
        System.out.println(s1);
        //其指定的字节字节子阵列为-27, -91, -67]-->输出为：好
        
        /*
          若解码和编码的编码不同会出现乱码
           String s = "你好";//默认为UTF-8编码，在UTF-8编码中，一个汉字占三个字节
        byte[] bytes = s.getBytes("UTF-8");//编码
        System.out.println(Arrays.toString(bytes));

        String s1 = new String(bytes,"GBK");//解码
        System.out.println(s1);
        输出-->浣犲ソ
        */
    }
}

char[] toCharArray()

        String s2 = "abcd";
        char[] chars = s2.toCharArray();//将字符串转换为一个新的char数组
        System.out.println(Arrays.toString(chars));

        String s3 = new String(chars);//将char数组转为字符串
        System.out.println(s3);
        String s4 = String.valueOf(chars);
        System.out.println(s4);

String toLowerCase() --转小写
String toUpperCase() --转大写

        String s5 = "abcQWEEF你";
        System.out.println(s5.toUpperCase());//转大写
        System.out.println(s5.toLowerCase());//转小写

String concat(String str)

        String s6 = s5.concat("-qwerty");//可连接其他类型
        System.out.println(s6);

Stirng[] split(分割符);

        String s7 = "qwe;rty;uio";
        String[] strings = s7.split(";");//按照指定的分隔符(如此代码中指定的分隔符为：";"),将字符串拆分为数组
        System.out.println(Arrays.toString(strings));

StringBuffer类

概述

我们如果需要对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题。

添加功能

public StringBuffer append(String str) --向末尾追加内容

public class StringBufferDemo {

    public static void main(String[] args) {
        new StringBuffer();//默认底层char数组长度为16
        StringBuffer stringBuffer = new StringBuffer("abcd");
        stringBuffer.append("qwe111");
        stringBuffer.append("qwe2222");
        stringBuffer.append("qwe2222");//向末尾追加内容
        System.out.println(stringBuffer);//输出:abcdqwe111qwe2222qwe2222
    }
}

public StringBuffer insert(int offset,String str)

 StringBuffer strb = new StringBuffer("abcd");
 strb.insert(2, "xx");//向指定的位置插入字符串
 System.out.println(strb);//输出:abxxcd

删除功能

public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end)

        StringBuffer strb = new StringBuffer("abcd");
        strb.insert(2, "xx");//向指定的位置插入字符串
        strb.deleteCharAt(1);//删除指定位置上的索引
        strb.delete(0, 3);//删除指定区间的内容，包含开始，不包含结束
        System.out.println(strb);

替换功能

public StringBuffer replace(int start,int end,String str)

  StringBuffer strb = new StringBuffer("abcd");
  strb.replace(0,3,"yyy");
  System.out.println(strb);//输出:yyyd

反转功能

public StringBuffer reverse()

    StringBuffer strb = new StringBuffer("abcd123");
    strb.reverse();//逆序字符串
    System.out.println(strb);//输出:321dcba

截取功能

public String substring(int start)

public String substring(int start,int end)

        StringBuffer strb = new StringBuffer("abcd123");
          String s = strb.substring(2);
          String s1 = strb.substring(2,5);
          System.out.println(s);
          System.out.println(s1);

截取功能返回值类型是String类型，本身没有发生改变

String类,StringBuffer类,StringBuilder区别

String : String类是final类型的，底层都是数组实现，内容和长度不能改变,使用String定义的字符串是一个常量，改变后会创建一个新的对象
StringBuffer : 线程安全的，可变字符串；适用多线程下在字符缓冲区进行大量操作的情况
StringBuilder: 线程不安全，可变字符串；适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer类和StringBuilder类最大的区别就在于它的内容和长度是可以改变的

基本数据类型包装类

基本数据类型	包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

以java.lang.Integer为例

public static final int MAX_VALUE 最大的int型数（231-1）

public static final int MIN_VALUE 最小的int型数（-231）

构造方法

Integer(int a);

Integer(String a);

比较方法

static int compareTo(Integer a);

boolean equals(Object);

int max(int a,int b);

int min(int a,int b);

转换方法

static toBinaryString(int i);

static String toHexString(int i);

static String toOctalString(int i);

int intValue();

static int parseInt(String s);

String toString();

static Integer valueOf(int i)

static Integer valueOf(String s)

import org.omg.PortableInterceptor.INACTIVE;

public class IntegerDemo1 {

    /*
      基本类型包装类
        基本数据类型：Java中使用关键字直接说明，用法简单
        基本类型 没有面向对象的使用方式，所以Java为每种基本类型定义了一个类，来表示基本类型数据，这个类称为包装类
        通过包装类可以将基本数据类型的值包装为引用数据类型的对象，在Java中，每种基本类型都有对应的包装类
    */

    public static void main(String[] args) {
       System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.BYTES);
        System.out.println(Integer.SIZE);

        //构造方法
        Integer i1 = new Integer("20");
        Integer i2 = new Integer(20);
        //比较方法
        System.out.println(i1==i2);
        System.out.println(i1.equals(i2));
        System.out.println(Integer.max(10, 5));
        System.out.println(Integer.min(10,5));

        //转换方法
        System.out.println(Integer.toBinaryString(3));//二进制
        System.out.println(Integer.toHexString(17));//16进制
        System.out.println(Integer.toOctalString(9));//8进制

        Integer i3 = new Integer(10);//基本类型包装到对象中
        int i4 = i3.intValue();//把对象中的基本类型取出来
        
        int i5 = Integer.parseInt("10");//将String类型转换为int类型
        /*
        底层源码
          public static int parseInt(String s) throws NumberFormatException {
            return parseInt(s,10);
          }
        */

        i3.toString();//将int包装类型转为String类型
        int i6 = Integer.valueOf(10);//将基本类型转为引用类型
        Integer i7 = Integer.valueOf("10");//将String类型转为引用类型
    }
}

其他七种包装类方法与java.lang.Integer大同小异

装箱和拆箱

public class IntegerDemo2 {

    public static void main(String[] args) {
        /*
         自动装箱：将基本类型的变量a赋给Integer类型的变量i
         自动拆箱：将Integer类型的变量i赋给基本类型的变量a
        */
        int a = 10;
        Integer i = a;
        System.out.println(i);
        int b = i;
        System.out.println(b);
    }
}

Math类

java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型

public class MathDemo {

    /*
      Math类是一个工具类，主要用于完成复杂的数学运算
    */
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.abs(-1));//计算绝对值
        System.out.println(Math.sqrt(9));//计算平方根
        System.out.println(Math.cbrt(9));//计算立方根
        System.out.println(Math.pow(3, 3));//计算乘方-->3的3次方
        System.out.println(Math.ceil(9.9));//向上取整
        System.out.println(Math.floor(9.9));//向下取整
        System.out.println(Math.round(5.6));//四舍五入
        System.out.println(Math.random());//返回0-1之间的随机数
    }
}

Random类

此类用于产生随机数，可以在指定范围内随机产生数字

● 构造方法

public Random()

public Random(long seed) -->使用一个long型的seed（种子）创建伪随机数生成器，当seed相同时，每次实例化Random对象会生成相同的随机数

● 成员方法

public int nextInt()

public int nextInt(int n)

import java.util.Arrays;
import java.util.Random;

public class RandomDemo {

    public static void main(String[] args) {
        Random r = new Random();
        System.out.println(r.nextInt());//在int的范围内随机取出
        System.out.println(r.nextInt(4));//0--<4 在指定的区间随机取出
        System.out.println(r.nextBoolean());//生成boolean类型的随机数
        
        byte[] bytes = new byte[5];//随机取出 数组.length个随机数、
        r.nextBytes(bytes);
        System.out.println(Arrays.toString(bytes));
    }
}

System类

System类定义了一些与系统相关的属性和方法，它所提供的属性和方法都是静态的，不能被实例化，想要引用这些属性和方法，可以直接使用System类调用

成员方法均在如下代码中：

import java.util.Arrays;

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

        System.out.println(System.getenv());
        System.out.println(System.getenv("Path"));//获取指定的环境变量的值
        System.out.println(System.getProperties());//获取当前系统的全部属性
//        System.exit(0);//退出虚拟机
//        System.gc();//垃圾回收

        Long l = System.currentTimeMillis();
        System.out.println(l);
        /*
          currentTimeMillis()方法返回一个long类型的值，该值表示当前时间与1970年1月1日0点0分0秒之间的时间差（毫秒为单位）
        */
        System.out.println("==============");

        /*
        arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
        arraycopy()方法用于将一个数组中的元素快速拷贝到另一个数组中
            src - 源数组。
            srcPos - 源数组中的起始位置。
            dest - 目标数组。
            destPos - 目的地数据中的起始位置。
            length - 要拷贝的数组元素的数量。
            在进行数组拷贝时，目标数组须有足够的空间来存放拷贝的元素，否则会发生角标越界异常
          */
        int b[] = {1,2,3,4,5};
        int c[] = new int[10];
        System.arraycopy(b,0,c,0,5);
        System.out.println(Arrays.toString(c));
    }
}

Date类

●使用Date类用于表示日期和时间

Date d=new Date();

Date d=new Date(longd);

import javax.xml.crypto.Date;
import java.util.Date;

public class DateDemo {

    public static void main(String[] args) {

        Date date1 = new Date();//创建一个日期对象,里面包含了程序运行时的那一刻的时间
        System.out.println(date1);
        Date date2 = new Date(System.currentTimeMillis()+1000);//获取当前时间后1秒的时间
        System.out.println(date2);

        System.out.println(date1.getTime());
        System.out.println(date1.getYear()+1900);//getYear上的一条线称为过期方法，不建议使用，有新方法代替
        System.out.println(date1.getMonth()+1);//获得当前月
    }
}

Calendar类

Calendar类是一个抽象类，不能被实例化，在程序中需调用其静态方法getInstance()得到一个Calendar对象。Calendar类用于完成日期和时间字段的操作。

import java.util.Calendar;
import java.util.GregorianCalendar;

public class CalendarDemo {

    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();//获取表示当前时间的Calendar对象
        Calendar calendar1 = new GregorianCalendar();//获得日历对象，实现子类
        System.out.println(calendar1);

        int year = calendar.get(Calendar.YEAR);//获取当前年份
        int month = calendar.get(Calendar.MONTH)+1;//获取当前月份
        int mothday = calendar.get(Calendar.DAY_OF_MONTH);//获取当日在本月第几天
        int data = calendar.get(Calendar.DATE);//获取当前日
        System.out.println(calendar.get(Calendar.WEEK_OF_YEAR));//本周是本年的第几周
        System.out.println(calendar.get(Calendar.WEEK_OF_MONTH));//本周是本月的第几周
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));//今天是本周第几天
    }
}

SimpleDateFormat类

SimpleDateFormat类是日期格式化类，是一个具体的类

● 构造方法

SimpleDateFormat(格式); – yyyy-MM-dd

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

public class SimpleDateFormatDemo {

    public static void main(String[] args) throws ParseException {
        /*
          日期格式化 yyyy-MM-dd  参考API
        */
        String birthday = "2000-10-10";
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        Date date1 = sdf1.parse(birthday);
        System.out.println(date1);

        Date date2 = new Date();
        SimpleDateFormat sdf2 = new SimpleDateFormat("今天是yyyy年MM月dd日 现在的时间为: HH:mm:ss SSS E");//HH:mm:ss --> 小时:分钟:秒
        String s = sdf2.format(date2);
        System.out.println(s);
    }
}

正则表达式

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo1 {
    /*
      正则表达式:规则表达式，使用一些特定的符号来制定一个规则
                         使用此规则与一个字符串进行模式匹配, 匹配成功返回true,否则返回false
        输入手机号，验证输入的内容是一个手机号格式（11位数字，规定由1开头）
        String s = "211132132123"  验证手机的格式，判断是否符合要求
    */

    public static void main(String[] args) {
/*
        Pattern pattern = Pattern.compile("a*b");//定义一个规则  a*b-->可以有多个a
        Matcher m = pattern.matcher("aaaaab");//输入内容
        boolean b = m.matches();//匹配
        System.out.println(b);
*/

        /*String s = "abc";
        boolean b = s.matches("a*b");
        System.out.println(b);
        */

        /*
           \d 数字：[0-9]
         */
        String s = "10004";
        System.out.println(s.matches("\\d?"));//? 表示一次或一次也没有
        System.out.println(s.matches("\\d*"));//* 表示多次或一次也没有
        System.out.println(s.matches("\\d+"));//+ 表示一次或多次
        System.out.println(s.matches("\\d{3}"));//{n} 恰好n次
        System.out.println(s.matches("\\d{3,}"));//{n,}至少n次
        System.out.println(s.matches("\\d{3,9}"));//{n,m}至少n次，至多m次

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

        String s1 = "123456789safVa";
        System.out.println(s1.matches("[0-9]+"));
        System.out.println(s1.matches("[^0-9]+"));//表示除0-9数以外的任何字符

        System.out.println("=============================");
        /*
          验证手机号及QQ号
        */

        String phone = "18585852116";
        System.out.println(phone.matches("1[35789]\\d{9}"));
        //-->1：代表第一位数字是1；[35789]：第二位数字是35789中的其中一个；\d{9}：表示0-9之间的数字且为9位数字

        String qq = "1801796820";
        System.out.println(qq.matches("[13]\\d{5,10}"));

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

        String s2 = "qweQWEa";
        System.out.println(s2.matches("[a-z]+"));
        System.out.println(s2.matches("[a-zA-Z]+"));
        System.out.println(s2.matches("[A-z]+"));
        System.out.println(s2.matches("\\w+"));//-->true
        System.out.println(s2.matches("\\W+"));//-->false  
    }
}