JavaSE---常用类
JAVAAPI概述
API(Application Programming Interface)应用程序编程接口
是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明.
API—>语言中提供的类,接口
API–>对类,接口功能的说明文档
基本数据类型包装类
基本类型：结构简单 int short long byte char boolean double float
每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类.
包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作方法。
| 基本数据类型 | 对应的类 |
|---|---|
| byte | Byte |
| int | Integer |
| long | Long |
| shor | Short |
| double | Double |
| float | Float |
| char | Character |
| boolean | Boolean |
对于包装类来说，这些类的用途主要包含两种：
作为和基本数据类型对应的类类型存在。
包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。
以Integer为例
public static void main(String[] args) {
int num = 10;//只表示一个具体的值
System.out.println(num);
//构造方法
Integer num1 = new Integer(10);//把10包装在Integer这个类的对象中
Integer num2 = new Integer("10");//把String类型转为int，只能传入String类型的数字，否则会报错
//Integer类包装一个对象中的原始类型int的值。 类型为Integer的对象包含一个单一字段，其类型为int 。
//Integer类提供了方法来对int类型进行操作
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);//获取最大值和最小值
System.out.println(Integer.BYTES);
System.out.println(Integer.SIZE);
System.out.println(Integer.toBinaryString(4));//二进制
System.out.println(Integer.toHexString(100));//十六进制
System.out.println(Integer.toOctalString(78));//八进制
System.out.println(num1.compareTo(num2));//比较，-1(前面的num1小)0(相等)1(前面的num1大)
System.out.println(Integer.max(10,50));
System.out.println(num1.equals(num2));//true，equals()比较的是两个对象的值
System.out.println(num1==num2);//false,==比较的是两个对象在内存中的地址
Integer num3 = new Integer(10);
int num4 = num3.intValue();//取出对象中包含的具体的值
long num5 = num3.longValue();//转换为long类型
int num6 = Integer.parseInt("11");//把字符串类型转为int型
Integer num7 = Integer.valueOf(12);//把基本类型的10封装成引用类型Integer
Integer num8 = Integer.valueOf(12);
//把数值转为字符串类型
System.out.println(num8.toString());
System.out.println(Integer.toString(10));
自动装箱和自动拆箱
自动装箱：把基本类型转为引用类型，自动调用valueOf()
自动拆箱：引用类型转为基本类型，自动调用intValue()方法
/*
自动装箱：把基本类型转为引用类型
*/
int n = 10;
Integer n1 = n;//自动调用valueOf()
/*
自动拆箱：引用类型转为基本类型
*/
int n2 = n1;//自动调用intValue()方法
public static void main(String[] args) {
Integer num0 = new Integer(10);
Integer num1 = new Integer(10);
System.out.println(num0.equals(num1));//true
System.out.println(num0 == num1);//false
Integer num2 = Integer.valueOf(10);
Integer num3 = Integer.valueOf(10);
System.out.println(num2.equals(num3));//true
System.out.println(num2 == num3);//true
/*
使用装箱(valueOf)在创建对象时，值如果在-128---127之间，如果多个值相同，指向的是内存中同一个地址
使用new+构造方法()方式，不管值是否在此区间相同，都会创建新的对象
*/
Integer num4 = Integer.valueOf(128);
Integer num5 = Integer.valueOf(128);
System.out.println(num4 == num5);//false
}
Object类
Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类（父类）。所有对象（包括数组）都实现这个类的方法。
如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类
public class Person { ... }
/*等价于：
public class Person extends Object {
...
}*/
1-toString方法
Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息。
在进行String与其它类型数据的连接操作时（如：System.out.println(“info”+person）），
将自动调用该对象类的 toString()方法
可以根据需要在用户自定义类型中重写toString()方法。
public class ObjectDemo {
public static void main(String[] args) {
Person p = new Person("admin",18);
/*
将对象输出时，就会调用toString()
当类中没有定义toString()时，会默认调用父类(Object)中的toString()
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
本地方法，java语言不实现，调用操作系统实现
public native int hashCode();
Object类中toString()将对象地址转为16进制的字符串输出，
在类中重写toString()
*/
System.out.println(p);//day08.Person@1540e19d
//重写后：Person{姓名='admin'年龄=18}
}
}
public class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"姓名='" + name + '\'' +
"年龄=" + age +
'}';
}
}
2-equals方法
public boolean equals(Object obj)方法
提供定义对象是否“相等”的逻辑。
Object 的 equals 方法 定义为：x.equals ( y ) ，当 x 和 y是同一个对象的引用时返回 true 否则返回 false
JDK提供的一些类，如String，Date等，重写了Object的equals方法，调用这些类的equals方法， x.equals (y) ,
x和y所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回 true 否则返回 false。
public class ObjectDemo2 {
public static void main(String[] args) {
Person p1 = new Person("admin",18);
Person p2 = new Person("admin",18);
//Object中equal方法比较的是创建的对象在内存中的地址是否相等，等同于==
//其他类都重写了equal方法，比较的是内容是否相等
System.out.println(p1.equals(p2));//false，重写后输出false，比较的是对象中包含的内容
System.out.println(p1==p2);//false
}
}
public class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
String类
字符串是由多个字符组成的一串数据(字符序列)的字符串常量(值不能改变),java中所有字符串都是String类的实例.
String s = “abc”;
有两种创建形式：
第一种:
String s = “abc”;
先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找有没有"abc", 如果没有则在常量池中
添加”abc”, s引用变量指向常量池中的”abc”，如果常量池中有,则直接指向该地址即可,不用重新创建.
String s = "abc";
String s1 = "abc";
System.out.println(s.equals(s1));//true
System.out.println(s==s1);//true
第二种:
使用new+构造方法()
一概在堆中创建新对象，值存储在堆内存的对象中。
String s = new String(“abc”);
/*
只要是new出来的对象，在内存中一定是一个独一无二的对象空间
*/
String s2 = new String("abc");
String s3 = new String("abc");
System.out.println(s2.equals(s3));//true
System.out.println(s2==s3);//false
字符串特点
public class StringDemo2 {
public static void main(String[] args) {
/*
字符串值是常量，不能改变，一旦改变是在内存中重新创建了一个对象
字符串底层是数组存储(单个字符存储)，final修饰，值不能改变吧
*/
String s = "abc";
s += "def";
s += "aaa";
System.out.println(s);
}
}
构造方法
/*
String类中常用方法
构造方法：
String();
String(String s);
*/
//创建一个String对象，值为""
String s = new String();
判断功能
//判断功能
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1.equals(s2));//true
System.out.println(s1.equalsIgnoreCase("aBc"));//true,不区分大小写比较内容1是否相等
System.out.println(s1.contains("ab"));//true,包含
System.out.println(s1.isEmpty());//false,是否为空(" ")
System.out.println(s1.startsWith("a"));//true,以 开头
System.out.println(s1.endsWith("c"));//true,以 结尾
System.out.println("a".compareTo("b"));//-1,a对应97，b对应98，返回-1，a与c则返回-2，比较大小，用于排序
获取功能
//获取功能
System.out.println(s1.length());//获取字符串长度
System.out.println(s.charAt(2));//把字符串当作数组，返回2对应位置的字符c(abc---012)
System.out.println(s.indexOf("c"));//找到对应的位置2，只能找到第一个c对应的位置
System.out.println(s.indexOf("c",3));//给指定位置开始找字符首次出现的位置
System.out.println(s.lastIndexOf("c"));//从后往前找字符首次出现的位置
System.out.println(s.lastIndexOf("c",10));//从指定位置开始从后往前找字符首次出现的位置
//若字符不存在则返回-1
System.out.println(s.substring(2));//从指定位置截取字符串到结束，返回一个新的字符串，原字符串不变
System.out.println(s.substring(2,6));//区间截取，包含开始的字符，不包含结束的那个字符
替换功能
//替换功能
String s = new String(" abcde ");
System.out.println(s.replace('c','C'));//原来的字符串不会变，替换后会返回一个新的字符串
System.out.println(s.replace("ab","AB"));
System.out.println(s.replaceAll("ab","AB"));//把所有的ab替换为AB，返回新的字符串
System.out.println(s.replaceFirst("ab","ABC"));//用ABC替换ab中的第一个字符a，返回新的字符串
System.out.println(s.trim());//去掉前后的空格，不能消除中间的空格
转换功能
/*
构造方法
public String(byte[] bytes)
public String(char[] value)
*/
//转换功能
//byte[] getBytes()
// char[] toCharArray()
String s = "abc";
byte [] b = s.getBytes();//编码：字符转为字节
System.out.println(Arrays.toString(b));//[97, 98, 99]
String s1 = new String(b);//解码：字节转为字符
System.out.println(s1);//abc
String s2 = "中文";
byte [] b2 = s2.getBytes("utf-8");
System.out.println(Arrays.toString(b2));//[-28, -72, -83, -26, -106, -121]
String s3 = new String(b2,"utf-8");
System.out.println(s3);//中文
String s4 = new String(b2,3,3,"utf-8");
System.out.println(s4);//文
String s5 = "abc";
char [] c = s5.toCharArray();//转为char数组
System.out.println(Arrays.toString(c));//[a, b, c]
String s6 = new String(c);
String s7 = String.valueOf(c);//char转为String
String s8 = "abcdEFG";
System.out.println(s8.toLowerCase());//全部小写abcdefg
System.out.println(s8.toUpperCase());//全部大写ABCDEFG
//contact()效率高于"+"
String s9 = s8.concat("xxxx");//拼接，返回新的字符串
System.out.println(s9);//abcdEFGxxxx
String s10 = s8+"xxxx";//效率最低的字符串拼接
String s11 = "ab:cd:ef:g";//分割
String [] arr = s11.split(":");
System.out.println(Arrays.toString(arr));//[ab, cd, ef, g]
StringBuffer类和StringBuilder类
线程安全的可变字符序列
只能通过new+构造方法（）创建
//无参的构造方法，默认底层创建一个长度为16的char数组 char[] value
StringBuffer s = new StringBuffer();
StringBuffer s1 = new StringBuffer(10);//创建一个容量为10的数组
StringBuffer s2 = new StringBuffer("abc");//在abc的基础上容量加16
s2.append("def");
s2.append("hijk");
System.out.println(s2);//直接添加在原来的数组里，不创建新的对象
/*
大量的字符串拼接，使用StringBuffer,不会创建新的对象
*/
s2.insert(1,"xxx");//从指定位置插入字符串
s2.delete(0,5);//删除指定区间，包含0，不包含5
s2.deleteCharAt(3);//删除指定位置的字符，从0开始数
s2.replace(0,3,"B");//把指定区间的字符替换，包含0不3
s2.reverse();//逆序输出
s2.substring(3);
s2.substring(0,3);//截取
/*
除截取返回值类型为String，其余返回值均为StringBuffer
*/
StringBuffer类StringBuilder类String类区别
public static void main(String[] args) {
/*
StringBuilder 适用于单线程下在字符缓冲区进行大量操作，内容可变
StringBuffer 适用于多线程在字符缓冲区下进行大量操作线程安全，内容可变
String 字符常量，适用于少量字符串的操作，内容不可变
*/
StringBuilder s = new StringBuilder();
s.append("aaa");
}
Arrays类
java.util.Arrays;
用于操作数组工具类，里面定义了常见操作数组的静态方法。
equals()方法
比较两个非同一数组是否相等，而数组本身的equals判断另一个数组是否它本身。
声明：public static boolean equals(type[]a,type[]a2)
参数的类型可以是原生数据类型和引用类型的任意一种类型。
返回：如果两个相等，则返回true，否则返回false
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));//比较两个数组包含元素是否一致
sort排序
作用于数组的所有元素public static void sort(type[] a)
作用于数组指定范围内的元素public static void sort(type[] a, int fromIndex(包括), int toIndex(不包括))将指定的类型（除boolean以外的任意原生数据类型）数组所有元素（或指定范围内的元素）按数字升序进行排序。object型数组，根据元素的自然顺序，对指定对象数组进行升序排序。（fromIndex==toIndex，则排序范围为空）
自定义对象排序
自定义类实现Comparable接口
public static void main(String[] args) {
int [] a = {2,3,1,42,6,8};
Arrays.sort(a);//排序
Arrays.sort(a,0,3);//指定区间排序，包含0不包含5
System.out.println(Arrays.toString(a));
//对引用类型数组排序，
Student s1 = new Student("bim",70,50,120);
Student s2 = new Student("cim",80,60,140);
Student s3 = new Student("aim",60,50,110);
Student [] students = new Student[3];
students[0] = s1;
students[1] = s2;
students[2] = s3;
Arrays.sort(students);//对学生数组排序
System.out.println(Arrays.toString(students));
//排序接口，要重写CompareTo()方法
public class Student<CompareTo> implements Comparable<Student>{
String name;
int bs;
int sj;
int sum;
/*
用于排序比较的方法，在sort()方法中调用
*/
@Override
public int compareTo(Student o) {
return this.sum-o.sum;//自定义排序规则，用哪个属性比较，用哪个属性排序
//return this.name.compareTo(o.name);
}
toString() 方法
声明：public static String toString(type[] a)
描述：返回指定数组内容的字符串表示形式。
基本数组，字符串表示形式由数组的元素列表组成，括在[]，相邻元素用“, ”(逗号加空格)分隔。
System.out.println(Arrays.toString(a));
泛型
/*
泛型：参数化类型
类型不确定，传参时可以将类型作为参数传入，只能传入引用类型，如果不传，默认是Object
*/
public class TypeDemo<T,M> {
T p;
M x;
public String test(String a){
return null;
}
public static void main(String[] args) {
//TypeDemo t = new TypeDemo<>();
//t.p;
TypeDemo<Integer,String> t,x = new TypeDemo<>();
}
}
二分查找
声明：
public static int binarySearch(type[] a, type key)
public static int binarySearch(long[] a,int fromIndex,int toIndex,long key)
描述：使用二分搜索算法搜索指定的type型数组，以获得指定的值。
参数：a - 要搜索的数组。
key - 要搜索的值。
fromIndex - 要排序的第一个元素的索引（包括）。
toIndex -
要排序的最后一个元素的索引（不包括）。
type -byte、double、float、object、long、int、short、char
如果key在数组中，则返回搜索值的索引；否则返回-1或者”-“(插入点)
public static void main(String[] args) {
int [] a = {5,2,3,1,1};
//二分折半，前提是排序后的数组
Arrays.sort(a);
int index = Arrays.binarySearch(a,1);//折半，要找的值小于中间值在前一部分找，大于中间值在后半部分找，找到返回0，没找到返回1
int index1 = Arrays.binarySearch(a,0,3,1);//指定区间查找
System.out.println(index);
}
数组复制
int [] a = {1,2,3,4,5};
int [] b = Arrays.copyOf(a,10);//会创建一个新的数组,复制原来的数组，后面值为初始化的默认值
Math类
java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。
abs 绝对值
sqrt 平方根
pow(double a, double b) a的b次幂
max(double a, double b)
min(double a, double b)
random() 返回 0.0 到 1.0 的随机数
long round(double a) double型的数据a转换为long型（四舍五入）
public static void main(String[] args) {
System.out.println(Math.PI);
System.out.println(Math.abs(-98));//绝对值
System.out.println(Math.sqrt(9));
System.out.println(Math.pow(2,3));//2的3次方
System.out.println(2<<2);
System.out.println(Math.ceil(11.2));//12，向上取整
System.out.println(Math.floor(11.6));//11向下取整
System.out.println(Math.round(11.2));//四舍五入取整
System.out.println(Math.random());//返回0-1之间的随机数，可能为0但不会为1
}
Random类
Random类
此类用于产生随机数
构造方法
public Random()
成员方法
public int nextInt()
public int nextInt(int n)
import java.util.Arrays;
import java.util.Random;
public static void main(String[] args) {
Random r = new Random();
System.out.println(r.nextBoolean());//true或false随机返回
System.out.println(r.nextInt());//在int取值范围内随机返回
System.out.println(r.nextInt(10));//在0-10之间随机返回，不包含10
byte [] b = new byte[5];
r.nextBytes(b);//括号里面要传byte数组，向里面装入数组.length个byte随机数
System.out.println(Arrays.toString(b));
}
System类
System类
System 类包含一些有用的类字段和方法。它不能被实例化。
成员方法
public static void exit(int status)
public static long currentTimeMillis()
public static void main(String[] args) {
//public final static PritStream out = null
//println()是PritStream中的方法
System.out.println();
System.out.println(System.getenv());//环境
System.out.println(System.getenv("Path"));//环境里面path的值
System.out.println(System.getProperties());//属性
System.out.println(System.getProperty("jav.runtime.version"));
// System.exit(0);//关闭程序
System.out.println("aaaaaa");//关闭后这句不执行
long s = System.currentTimeMillis();//1970 1.1 0.0.0--到今天的毫秒差，在1970年1月1日UTC之间的当前时间和午夜之间的差异，以毫秒为单位。//1608206306537
for (int i = 0; i < 100000; i++) {
System.out.println(i);
}
System.out.println(System.currentTimeMillis()-s);
// int a[] = {1,2,3,4,5};
// int []b = Arrays.copyOf(a,10);
int a[] = {1,2,3,4,5};
int b[] = new int[10];
System.arraycopy(a,0,b,0,a.length);
System.out.println(Arrays.toString(b));
Date类/Calendar类/ SimpleDateFormat类
Date类
使用Date类代表当前系统时间
Date d = new Date();
Date d = new Date(long d);
//构造方法
Date date = new Date();//获得当前运行时间
System.out.println(date);
Date date0 = new Date(1608206306537L);
// date.setTime(1608206306537L);//括号里面要传long类型的时间
Date date1 = new Date();
System.out.println(date1.getYear()+1900);//过期方法不建议使用@Deprecate
System.out.println(date1.getMonth()+1);
System.out.println(date1.getDate());
System.out.println(date1.getDay());//0 星期天 1 2 3 4 5 6
System.out.println(date1.getHours());
System.out.println(date1.getTime());//==System.currentTimeMillis()
Calendar类
Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需
要使用getInstance方法创建即可。
Calendar c1 = Calendar.getInstance();
c1.get(Calendar. YEAR);
//Calendar类是一个抽象类,在实际使用时实现特定的子类的对象，
// 创建对象的过程对程序员来说是透明的，
// 只需要使用getInstance方法创建即可。
//Calendar rightNow = Calendar.getInstance();
Calendar rightNow = new GregorianCalendar();
rightNow.set(2022,5,1);
System.out.println(rightNow.get(Calendar.DAY_OF_YEAR));//日历字段
System.out.println(rightNow.get(Calendar.YEAR));
System.out.println(rightNow.get(Calendar.MONTH)+1);
System.out.println(rightNow.getTime());
System.out.println(rightNow.getTimeInMillis());
SimpleDateFormat 日期格式化类
构造方法
SimpleDateFormat(格式); // yyyy-MM-dd
日期转字符串
Date now=new Date();
myFmt.format(now);
字符串转日期
myFmt.parse(“2018-02-10”);
字符串日期格式与 指定格式必须一致
例如:String s = “2018-03-15”;
new SimpleDateFormat(“yyyy-MM-dd”)
public static void main(String[] args) {
//1.日期对象转为指定格式的字符串
Date date = new Date();
System.out.println(date);
SimpleDateFormat sdf = new SimpleDateFormat("YYYY年MM月ddd日 HH:mm:ss E", Locale.FRANCE);
String str = sdf.format(date);
System.out.println(str);
//2.字符串转为日期对象
String birthday = "1999-12-17";
SimpleDateFormat sdf1 = new SimpleDateFormat("YYYY-MM-dd");
try {
Date date1 = sdf1.parse(birthday);
System.out.println(date1);
} catch (ParseException e) {
e.printStackTrace();
}
}
BigInteger类
在 Java 中，有许多数字处理的类，比如 Integer类，但是Integer类有一定的局限性。
我们都知道 Integer 是 Int 的包装类，int 的最大值为 2^31-1。若希望描述更大的整数数据时，使用Integer 数据类
型就无法实现了，所以Java中提供了BigInteger 类。
BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算
中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息。
BigInteger类位于java.math包中
构造方法
BigInteger(String val) /BigInteger(byte[] val) …
基本运算方法
add()，subtract()，multiply()，divide()
BigInteger b1 = new BigInteger("1608206306537456789023456789");
BigInteger b2 = new BigInteger("1608206306537456789023456789");
BigInteger b3 = b1.add(b2);//新创建一个对象
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b1.subtract(b2));//减，可以得到负数
System.out.println(b1.multiply(b2));//乘
System.out.println(b1.divide(b2));//除
BigDecimal类
在计算机中不论是float 还是double都是浮点数，而计算机是二进制的，浮点数会失去一定的精确度。
根本原因是:十进制值通常没有完全相同的二进制表示形式;十进制数的二进制表示形式可能不精确。只能无限接近
于那个值.
double a = 1.0-0.9;
double b = 0.8-0.7;
System.out.println(a==b); // 结果?
但是，在项目中，我们不可能让这种情况出现，特别是金融项目，因为涉及金额的计算都必须十分精确，你想想，
如果你的支付宝账户余额显示193.99999999999998，那是一种怎么样的体验？
Java在java.math包中提供的API类BigDecimal
构造方法
BigDecimal(String val)
基本运算方法
add()，subtract()，multiply()，divide()
System.out.println(12-11.9==0.1);//false
System.out.println(12-11.9);//0.09999999999999964
BigDecimal b1 = new BigDecimal("11.9");
BigDecimal b2 = new BigDecimal("11.8");
System.out.println(b1.subtract(b2));//0.1
BigDecimal b3 = new BigDecimal("10");
BigDecimal b4 = new BigDecimal("3");
//System.out.println(b3.divide(b4));//会报错，出现无限循环小数时就会报错
//如果不能表示确切的商（因为它具有非终止的十进制扩展），则抛出一个ArithmeticException 。
System.out.println(b3.divide(b4,4,BigDecimal.ROUND_CEILING));//4表示保留4位小数,ROUND_CEILING表示向上进一位
System.out.println(b3.divide(b4,5,BigDecimal.ROUND_FLOOR));//ROUND_FLOOR表示直接剪掉后面的小数
正则表达式
/*
正则表达式 regular-expression 简称：regex
是一种模式匹配语法，由许多特定字符组成，每种字符匹配一种规则
使用这些特定字符匹配某一个字符串，判断字符串是否满足规则需求
从各终端向程序中输入数据时，需要对象输入的数据格式进行验证（长度，格式（手机格式，邮箱格式，qq格式，网址，数字....）)
*/
public static void main(String[] args) {
String s = "wsY hdh@# %$";
if(s.length()>10||s.length()<3){
// for (int i = 0; i < s.toCharArray().length; i++) {
// if(i==0){
// s.toCharArray()[0]!=1;
// }
// }
boolean res;
res = s.matches("\\d");//\\d-是否都是数字，只能匹配一个数字，最终的返回值是布尔类型
res = s.matches("\\d?");//？-数量词，一次或一次也没有，控制数量。
res = s.matches("\\d*");//*-零次或多次
res = s.matches("\\d+");//+-一次或多次
res = s.matches("\\d{11}");//{n}-固定n次
res = s.matches("\\d{3,}");//至少3次，上不封顶
res = s.matches("\\d{3,6}");//3-6位，包含3和6
res = s.matches("\\D");//\\D-非数字
res = s.matches("[0-9]{3,6}");//[0-9]-0-9的数字，3-6位
res = s.matches("[1357]{3,6}");//只包含1357，3-6位
res = s.matches("[^1357]{3,6}");//非1357，3-6位
res = s.matches("\\w*");//\\w-单词字符，大小写字母，0-9数字
res = s.matches("[a-z]*");//小写字母
res = s.matches("[A-Za-z]*");//大小写字母
res = s.matches("[A-z]*");//大小写字母
res = s.matches("[A-z0-9]*");//大小写字母，0-9数字
System.out.println(res);//false
}
}