JavaAPI-常用类汇总
1.API
API(Application Programming Interface)应用程序编程接口
- 语言中提供的类、接口;
- 对类、接口功能的说明文档。
2.基本数据类型包装类
Java语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的,这在实际使用时存在很多的不便,为了解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八个和基本数据类型对应的类统称为包装类。
即Java为每种基本类型提供了一个类,这些类被称为包装类。
/*
基本数据类型 对应的包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
*/
这些包装类分别封装了一个相应的基本数据类型,并为其提供了一系列操作方法。
以Integer包装类为例:
public static void main(String[] args) {
int num = 10;//一个int型整数
//构造方法
Integer num1 = new Integer(10);//把int型整数作为参数包装到Integer类的对象中
System.out.println(num1.doubleValue());//输出转为double型
Integer num2 = new Integer("15");//将字符串类型的值转换为int型
System.out.println(num2);
/*
Integer类中提供很多的方法来对int类型进行操作
*/
//转换进制方法
System.out.println(Integer.toBinaryString(3));//十进制的整数转换为2进制
System.out.println(Integer.toHexString(17));//十进制的整数转换为16进制
System.out.println(Integer.toOctalString(12));//十进制的整数转换为8进制
System.out.println(Integer.MAX_VALUE);//int型常量保持的最大值
System.out.println(Integer.MIN_VALUE);//int型常量保持的最小值
System.out.println(Integer.BYTES);//用于表示二进制补码二进制形式的 int值的字节数。
System.out.println(Integer.SIZE);//用于表示二进制补码二进制形式的 int值的位数。
//比较方法
/*
Integer num3 = Integer.valueOf(23);//
Integer num4 = Integer.valueOf(22);
*/
Integer num3 = new Integer(23);//创建一个Integer对象
Integer num4 = new Integer(22);
System.out.println(num3==num4);//== 用于引用类型比较时,比较的是对象内存地址是否相等
System.out.println(num3.equals(num4));//equals()方法比较的是两个对象中具体包含的值是否相等 相等为true, 不相等为false
System.out.println(num3.compareTo(num4));//值为-1 0 1,前者大输出1,相等输出0,前者小输出-1
System.out.println(Integer.max(num3,num4));//取较大值
System.out.println(Integer.min(num3,num4));//取较小值
Integer n1 = new Integer(10);
int n2 = n1.intValue();//取出对象中包含的具体的值
long n3 = n1.longValue();
System.out.println(n3);
int n4 = Integer.parseInt("11");//parseInt(String s)将字符串参数解析为带符号的十进制整数。
System.out.println(n4);
//基本类型 转换为 引用类型
Integer num7 = Integer.valueOf(10);
Integer num8 = Integer.valueOf("10");
System.out.println(num7==num8);//true
//把数值转为字符串
System.out.println(num8.toString());
System.out.println(Integer.toString(10));
//引用类型 转换为 基本类型
int num5 = Integer.valueOf(num3);
int num6 = num4.intValue();
}
装箱和拆箱:
装箱
- 自动将基本类型装换为包装类类型
- 装箱的时候自动调用的是Integer的valueOf()方法
拆箱
- 自动将包装类类型装换为基本数据类型
- 拆箱的时候自动调用的是Integer的intValue()方法
public static void main(String[] args) {
//构造方法
Integer num1 = new Integer(10);//创建一个Integer对象,把int型整数作为参数包装到Integer类的对象中
Integer num2 = Integer.valueOf(10);//基本类型 转换为 引用类型
int num3 = num1.intValue();//取出对象中包含的具体的值
int num4 = Integer.parseInt("10");//parseInt(String s)将字符串参数解析为带符号的十进制整数。
/*
自动装箱:把基本类型转为引用类型
*/
int n = 10;
Integer n1 = n;//自动调用valueOf()方法,valueOf():基本类型 转换为 引用类型
/*
自动拆箱:把引用类型转为基本类型
*/
int n2 = n1;//自动调用intValue()方法,intValue():取出对象中包含的具体的值
/*
使用装箱(valueOf()) 在创建对象时,值如果在 -128~+127 之间,如果多个值相同,指向的是同一个地址;
如果值不在范围区内,则创建新对象。
使用 new + 构造方法() 不管制是否在此区间,都会创建新对象
*/
}
3.Object类
Object类是java中所有类的父类。
常用方法:
- 将对象输出时,会调用toString()方法
- 做比较时,会调用equals()方法,等同于 ==
public static void main(String[] args) {
/*
Object类是java中所有类的父类
*/
/*
将对象输出时,会调用 toString()方法
当类中没有定义toString()时,会默认调用父类(Object)中的toString。
父类(Object)中的toString,将对象地址转为16进制的字符串输出,可以在类中重写Object类中的toString()
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
public native int hashCode();
native:调用本地方法,java语言不实现,调用操作系统实现
*/
//创建一个People类,并重写Object类中的toString()方法
People p = new People("jam",22);
//调用People类中重写后的toString(),输出想要的 字符串
System.out.println(p+"hello");
/*
Object类中的 equals() 比较对象地址是否相等,等同于 ==
public boolean equals(Object obj) {
return (this == obj);
}
*/
People p1 = new People("jam",22);
People p2 = new People("jam",22);
System.out.println(p1.equals(p2));
System.out.println(p1==p2);
/*
其他类基本上都是重写了 equals() 比较的是内容是否相等
*/
Integer a1 = 128;
Integer a2 = 128;
System.out.println(a1.equals(a2));//调用的是Integer类的equals(),比较的是值
System.out.println(a1==a2);//128不在Integer范围区内,会创建Integer对象
}
4.String类/StringBuffer类/StringBuilder类
String类
字符串是多个字符组成的字符序列,是常量(值是不能改变的)。
有两种创建形式:
- String s = “abc”;
2.使用 new + 构造方法()创建
public static void main(String[] args) {
/*
String s = "abc";
String s1 = "abc";
第一次创建时,在字符串常量池中检测有没有,有则指向,没有就在字符串常量池中创建一个对象,再指向对象
第二次创建时,字符串常量池中有,则直接指向
*/
String s = "abc";
String s1 = "abc";
System.out.println(s.equals(s1));//true,
System.out.println(s==s1);//true
/*
使用 new + 构造方法()创建
在堆中创建新对象,值存储在对内存的对象中
只要是new创建的对象,在内存中一定是独一无二的对象空间
*/
String s2 = new String("abc");
String s3 = new String("abc");
System.out.println(s2.equals(s3));//true
System.out.println(s==s3);//false
}
字符串值是常量,值不能改变,一旦改变就是在内存中重新创建一个新对象来保存这个新的值。
/*
private final char value[];
字符串底层是char数组存储,单个字符存储
final修饰 所以是常量不可改变
*/
String类中常用的方法:
1.判断功能的方法
public static void main(String[] args) {
/*
判断功能
*/
String s = "abcdefg";
String s1= "abcdefg";
System.out.println(s.equals(s1));//true 判断字符串值是否相等
System.out.println(s.equalsIgnoreCase("aBCD"));//不区分大小写,判断字符串是否相同
System.out.println(s.contains("a"));//判断字符串中是否包含子串
System.out.println(s.contains("abc"));
System.out.println(s.isEmpty());//判断字符串是否为空
System.out.println(s.startsWith("ab"));//判断字符串是否是以指定前缀开头
System.out.println(s.endsWith("fg"));//判断字符串是否是以指定后缀结尾
System.out.println("c".compareTo("a"));//2 比较值(ASCLL/Unicode值相减)大小,用于排序比较
System.out.println("a".compareTo("a"));//0
System.out.println("a".compareTo("c"));//-2
}
2.获取功能的方法
public static void main(String[] args) {
/*
获取功能
*/
String s2 = "abcdefgcd";
//字符串下标:012345678
System.out.println(s2.length());//返回字符串长度
System.out.println(s2.charAt(2));//返回指定下标出处的字符
System.out.println(s2.indexOf("d"));//从下标0处向后找,返回指定字符第一次出现的下标
System.out.println(s2.indexOf("v"));//如果字符串中不包含指定字符,则返回-1
System.out.println(s2.indexOf("c",3));//从指定位置(下标)向后找 字符首次出现的位置
System.out.println(s2.indexOf("d",s2.indexOf("d")+1));//返回指定字符第二次出现的下标
System.out.println(s2.lastIndexOf("c"));//从后往前找字符首次出现的位置
System.out.println(s2.lastIndexOf("c",5));//从指定位置向前找 字符首次出现的位置
System.out.println(s2.substring(2));//返回字符串从指定下标处开始到字符串结束的新字符串
System.out.println(s2.substring(2,6));//返回字符串从指定下标开始到制定下标结束的新字符串
}
3.替换功能的方法
/*
替换功能
*/
public static void main(String[] args) {
String s = "abcdefgbcfes";
System.out.println(s.replace('e','E'));//参数为两个字符,用后面的字符替换前面的字符
System.out.println(s.replace("bc","BC"));//用后面的字符串替换前面的字符串
System.out.println(s);//字符串的值不可改变
String s1 = "bcde1fbc3g";
System.out.println(s1.replaceAll("\\d","BC"));//"\\d" 用指定字符串字符串替换原字符串中的数字
System.out.println(s1.replaceFirst("\\d","BC"));//"\\d" 用指定字符串字符串替换原字符串中的第一个数字
String s2 = " ab c ";
System.out.println(s2.length());//长度为6
String s3 = s2.trim();//去除字符串两端的空格
System.out.println(s3.length());//长度为4
String s4 = s2.replace(" ","");
System.out.println(s4.length());
}
4.转换功能的方法
/*
转换功能方法:
*/
public static void main(String[] args) {
String s = "abc";
byte[] b = s.getBytes();//字符串转换为字节数组 编码 字符——>字节
String s1 = new String(b);//字节数组转换为字符串 解码 字节-->字符
System.out.println(s1);
String ss = "中文";
try {
//使用给定的字符集将该字符串编码为字节序列,
byte[] bb = ss.getBytes("gbk");//gbk 规定一个中文对应两个字节
System.out.println(Arrays.toString(bb));
//通过 给定的字符集 将字节序列 解码为字符串
String sb1 =new String(bb,"gbk");
System.out.println(sb1);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
try {
byte[] bb1 = ss.getBytes("utf-8");//utf-8 规定一个中文对应三个字节
System.out.println(Arrays.toString(bb1));
String sb2 =new String(bb1,0,3,"utf-8");//取从第0位开始的三个字节
System.out.println(sb2);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
String s2 ="abc";
char[] c = s2.toCharArray();//字符串转换为字符数组
System.out.println(Arrays.toString(c));
String s3 = new String(c);//字符数组转换为字符串
System.out.println(s3);
String s4 = "abcdEFGH";
System.out.println(s4.toUpperCase());//字符串全部转大写
System.out.println(s4.toLowerCase());//字符串全部转小写
/*
String s5 = s4.concat("hello");
String s6 = s4+"I"+"am"+"OK";
concat() 连接方法 效率高于 “ ”+“ "
*/
String s5 = s4.concat("hello");//字符串连接 将指定的字符串连接到该字符串的末尾。
String s6 = s4+"I"+"am"+"OK";//字符串连接,效率最低的字符串拼接
String s7 = "ab:cvafa:asdf:asfd:s";
String[] s8 = s7.split(":");//将字符串用指定的字符分割为字符串数组
System.out.println(Arrays.toString(s7));
String s9= "ab5cvafa4asdf3asfd2s";
String[] s10 = s9.split("\\d");//将字符串用指定的正则表达式分割为字符串数组
System.out.println(Arrays.toString(s6));
}
StringBuffer类
当我们对字符串进行拼接是,每次拼接,都会构建一个新的String对象,既耗时又浪费空间。而StringBuffer就可以解决这个问题。
StringBuffer:线程安全的可变字符序列
package day16;
public class StringBufferDemo {
public static void main(String[] args) {
/*
StringBuffer类
线程安全 的可变字符序列
对字符串进行拼接,每次拼接,不会创建新对象
*/
/*
无参的构造方法,底层创建一个长度为16的char数组 char[] value;
*/
StringBuffer s1 = new StringBuffer();
//有参的构造方法
StringBuffer s2 = new StringBuffer(10);//参数为底层创建数组的容量,即数组长度
StringBuffer s3 = new StringBuffer("hello");//总长度为: 字符串长度+16
/*
大量的字符串拼接,建议使用StringBuffer,不会创建新的对象
*/
s3.append("world");//字符串的拼接
s3.append("asdmd");
// s3.insert(4,"xxx");//在指定位置插入新的字串
// s3.delete(0,4);//删除从指定起始位置到指定结束的字符串
// s3.deleteCharAt(3) ;//删除指定位置的字符
// s3.replace(0,5,"BB");//替换
// s3.reverse();//字符串逆序/字符串反转
// s3.substring(2);
s3.substring(2,6);
// System.out.println(s3.length());
System.out.println(s3);
System.out.println( s3.substring(2,6));
}
}
StringBuilder类
public static void main(String[] args) {
/*
StringBuilder 内容可变
StringBuffer 线程安全 内容可变
String 内容不可变
*/
StringBuilder s = new StringBuilder();
//方法与StringBuffer相同
s.append("hhh");
System.out.println(s);
}
5.Arrays类
java.util.Arrays类
用于操作数组工具类,里面定义了常见操作数组的静态方法。
1.equals方法
比较两个非同一数组是否相等,而数组本身的equals判断另一个数组是否是它本身。
public static void main(String[] args) {
/*
java.util.Arrays类
equals 方法
比较两个非同一数组是否相等,而数组本身的equals判断另一个数组是否它本身
*/
int [] a = {1,2,3,4,5};
int [] b = {1,2,3,4,5};
int [] c = {1,2,4,3,5};
//比较数组内容是否一致
System.out.println(Arrays.equals(a,b));//true
System.out.println(Arrays.equals(a,c));//false
//equal()为Object类中的方法 判断是否是它本身
System.out.println(a.equals(a));//true
System.out.println(a.equals(b));//false
System.out.println(a.equals(c));//false
}
2.sort–排序
public static void main(String[] args) {
/*
sort -排序
*/
int[] d = {1,3,2,5,4};
对基本类型数组元素进行排序
// Arrays.sort(d);//[1, 2, 3, 4, 5]
System.out.println(Arrays.toString(d));
//对指定数组的指定部分的元素进行排序
Arrays.sort(d,0,3);//[1, 2, 3, 5, 4]
System.out.println(Arrays.toString(d));
/*
对引用类型进行排序
自定义对象排序
自定义类实现Comparable接口: implements Comparable
重写compareTo方法
*/
Student s1 = new Student("aim",60,90,150);
Student s2 = new Student("cim",70,90,160);
Student s3 = new Student("bim",60,60,120);
Student[] starray = {s1,s2,s3};
Arrays.sort(starray);
System.out.println(Arrays.toString(starray));
}
3.数组复制
public static void main(String[] args) {
int [] a = {5,2,4,3,1};
//数组复制,当数组长度不够用,将原来的内容复制到一个新数组中,指定新数组长度
int [] b = Arrays.copyOf(a,10);
System.out.println(Arrays.toString(b));//[5, 2, 4, 3, 1, 0, 0, 0, 0, 0]
}
4.二分折半查找
public static void main(String[] args) {
int[] a = {5,2,3,4,1};
//二分折半查找 前提:数组有序
Arrays.sort(a);//对数组进行排序 从小到大
System.out.println(Arrays.toString(a));
int index = Arrays.binarySearch(a,1);
System.out.println(index);//查找完返回下标
int index2 = Arrays.binarySearch(a,5);
System.out.println(index2);
int index1 = Arrays.binarySearch(a,0,3,2);//在数组的指定部分进行查找
System.out.println(index1);
}
6.Math类
java.lang.Math提供了一系列静态方法用于科学计算。
public static void main(String[] args) {
/*
Math类
java.lang.Math类提供了一系列静态方法用于科学计算
*/
System.out.println(Math.PI);//Math类中的常量
System.out.println(Math.abs(-23));//取绝对值
System.out.println(Math.sqrt(16));//取平方根
System.out.println(Math.pow(2,3));//2的3次幂
System.out.println(2<<2);//左移 2<<2==Math.pow(2,3)
System.out.println(Math.ceil(5.3));//向上取整
System.out.println(Math.floor(4.8));//向下取整
System.out.println(Math.round(6.1));//四舍五入
System.out.println(Math.round(6.9));
System.out.println(Math.random());//返回[0,1)的随机数(包含0,不包含1)
}
7.Random类
java.util.Random类用于产生随机数。
public static void main(String[] args) {
/*
Random类:用于产生随机数
*/
Random r = new Random();
System.out.println(r.nextBoolean());//获取一个随机的boolean值
r.nextInt();//产生一个int范围的随机数
System.out.println(r.nextInt());
r.nextInt(10);//给一个指定值,产生一个[0,指定值)范围的随机数(包含0,不包含指定值)
System.out.println(r.nextInt(10));
byte[] b = new byte[10];
r.nextBytes(b);//向数组中装入数组 .length 个byte随机数,值的范围为byte类型的范围
System.out.println(Arrays.toString(b));
}
8.System类
java.lang.System类包含一些有用的类字段和方法。它不能被实例化。
public static void main(String[] args) {
/*
System类:System类包含一些有用的类字段和方法。不能被实例化
*/
/*
public final static PrintStream out = null;
println() 是PrintStream中的方法
*/
System.out.println("你好");
long s = System.currentTimeMillis();
System.out.println(System.currentTimeMillis());//1608208114102 返回当前时间(以毫秒为单位)。
// 在1970年1月1日UTC之间的当前时间和午夜之间的差异,以毫秒为单位。
//1970 1.1 0.0.0 ---至今的毫秒值差
for (int i = 0; i <1000000; i++) {
System.out.println(i);
}
System.out.println(System.currentTimeMillis()-s);//for 循环运行时间 单位为毫秒
/* System.exit(0);//关闭退出虚拟机
System.out.println("hello world");//不执行*/
System.out.println(System.getenv());//返回当前系统环境的不可修改的字符串映射视图。
System.out.println(System.getenv("Path"));//获取指定环境变量的值。
System.out.println(System.getProperties());//确定当前的系统属性。
System.out.println(System.getProperty("java.runtime.version"));//当前运行版本 获取指定键指示的系统属性。
/*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));
}
9.Date类/Calendar类/ SimpleDateFormat类
Date类
java.util.Date类:使用Date类代表当前系统时间。
public static void main(String[] args) {
/*
Data 类:使用Date类代表当前系统时间
*/
/*Date date = new Date();//date对象表示当前程序运行的那一刻时间
System.out.println(date);//输出当前时间 Thu Dec 17 21:04:45 CST 2020
*/
/*Date date1 = new Date(1608208114102l);//传入一个long型 参数时间
System.out.println(date1);
System.out.println(date1.getTime());// == System.currentTimeMillis()
*/
Date date = new Date(1608208114102l);
System.out.println(date);
date.setTime(1608208114102l);//修改时间
date.setDate(15);//修改日期
System.out.println(date.getYear()+1900);//getYear()==120,输出2020=120+1900,今年
System.out.println(date.getMonth()+1);//月份从零开始,所以求当前月份要加1
System.out.println(date.getDate());//获取日期,DayOfMonth
System.out.println(date.getDay());//0(星期天) 1 2 3 4 5 6
System.out.println(date.getHours());//一天中的第几个小时
System.out.println(date.getMinutes());//一小时中的第几分钟
}
Calendar类
java.util.Calendar类:Calendar类是一个抽象类,在实际使用时实现特定的子类的对象。
public static void main(String[] args) {
/*
Calendar类:Calendar类是一个抽象类,在实际使用时实现特定的子类的对象
*/
// Calendar rightnow = new Calendar.getInstance();
Calendar rightnow = new GregorianCalendar();//GregorianCalendar是的具体子Calendar ,并提供了世界上大多数国家使用的标准日历系统。
System.out.println(rightnow.getTime());//获取当前时间
System.out.println(rightnow.getTimeInMillis());// == System.currentTimeMillis()
// == date.getTime()
rightnow.set(2023,6,1);//自定义一个日期
//获取自定义日期的信息,如年、月、DAY_OF_MONTH、DAY_OF_WEEK(星期)等
System.out.println(rightnow.get(Calendar.YEAR));
System.out.println(rightnow.get(Calendar.MONTH));
System.out.println(rightnow.get(Calendar.DAY_OF_MONTH));
System.out.println(rightnow.get(Calendar.DAY_OF_WEEK));
System.out.println(rightnow.get(Calendar.DAY_OF_YEAR));
System.out.println(rightnow.get(Calendar.WEEK_OF_YEAR));
}
SimpleDateFormat类
java.text.SimpleDateFormat类:日期格式化类。
public static void main(String[] args) {
/*
SimpleDateFormat 日期格式化类
*/
//1.日期对象 转为 指定格式的字符串
Date date = new Date();
System.out.println(date);// Sat Dec 19 10:57:53 CST 2020
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E", Locale.FRANCE);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E", Locale.FRANCE);
String str = sdf.format(date);
System.out.println(str);// 2020-12-19 10:57:53 sam.
//2.字符串 转为 日期对象
String birthday = "2000-3-21";
System.out.println(birthday); // 2000-3-21
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
try {
Date date1 = sdf1.parse(birthday);//从字符串中解析文本以产生一个 Date 。
System.out.println(date1); //Tue Mar 21 00:00:00 CST 2000
} catch (ParseException e) {
e.printStackTrace();
}
}
10.BigInteger类
java.math.BigInteger 类:不可变的任意精度整数。
BigInteger类型的数字范围较Integer,Long类型的数字范围要大得多,它支持任意精度的整数,也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息。
public static void main(String[] args) {
/*
BigInteger类 不可变的任意精度整数。
*/
BigInteger a = new BigInteger("111111111111111111111111111111111111111111111");
System.out.println(a);
BigInteger b = new BigInteger("11111111111111111111111111111111111111111111111");
BigInteger c = a.add(b);//加, a.add(b)是一个新的 BigInteger对象
System.out.println(c);
System.out.println(a);
System.out.println(b);
System.out.println(a.subtract(b));//减
System.out.println(a.multiply(b));//乘
System.out.println(a.divide(b));//除
}
11.BigDecimal类
java.math.BigDecimal类:不变的,任意精度的带符号的十进制数字。
在计算机中不论是float还是double都是浮点数,而计算机是二进制的,浮点数会失去一定的精确度。
根本原因是:十进制值通常没有完全相同的二进制表现形式;十进制数的二进制表现形式可能不精确。只能无限接近于那个值。
double a = 1.0-0.9;
System.out.println(a);//0.09999999999999998
double b = 0.8-0.7;
System.out.println(b);//0.10000000000000009
System.out.println(a==b);//false
所以,Java在java.math包中提供的API类BigDecimal。
public static void main(String[] args) {
/*
BigDecimal类 不变的,任意精度的带符号的十进制数字。
*/
System.out.println(10.9-10.8 );//0.09999999999999964
System.out.println(10.9-10.8 == 0.1);//false
BigDecimal b1 = new BigDecimal("10");
System.out.println(b1);
BigDecimal b2 = new BigDecimal("3");
// BigDecimal.ROUND_CEILING 圆形模式向正无穷大转弯。
// System.out.println(b1.divide(b2));
System.out.println(b1.divide(b2,15,BigDecimal.ROUND_CEILING));// 3.333333333333334
// BigDecimal.ROUND_FLOOR 舍入模式向负无穷大转弯。
System.out.println(b1.divide(b2,6,BigDecimal.ROUND_FLOOR));// 3.333333
}
12.补充:正则表达式
正则表达式:rexgular-expression 简称:regex
正则表达式是一种模式匹配语法,有雨多特定字符组成,每种字符匹配一种规则。
我们使用这些特定的字符,匹配某个字符串,判断字符串中是否满足规则需求
public static void main(String[] args) {
/*
正则表达式:
\d [0-9] 匹配数字
\D [^0-9] 匹配非数字
\w [a-zA-Z_0-9] 匹配单词字符
[a-zA-Z] [A-z] 匹配英文字母
数量词:
?:一次或一次也没有
*:0次或多次
+:一次或多次
{n}:恰好nci/固定n次
{n,}:至少n次
{n,m}:至少n次,至多m次
*/
String str = "adb";
//匹配字符串时,要用符合有需求的 regex + 数量词 。无数量词时,默认匹配一位
//System.out.println(str.matches("\\d"));// \d 匹配数字(默认匹配一位)
//System.out.println(str.matches("[0-9]*"));// [0-9]* 匹配数字0次或多次 *(数量词)
//System.out.println(str.matches("\\d?"));// \d? 匹配数字一次或一次也没有
//System.out.println(str.matches("\\D*"));// \D* 匹配非数字0次或多次
//System.out.println(str.matches("\\w*"));// \w* 匹配单词字符0次或多次
//System.out.println(str.matches("[A-z]*")); // [A-z]* 匹配英文大小写字母0次或多次
//System.out.println(str.matches("\\D{3,6}"));// \D{3,6} 匹配非数字,至少3次至多6次
//System.out.println(str.matches("[0-9]{3,6}"));//[0-9]{3,6} 匹配数字0-9,至少3次至多6次
//System.out.println(str.matches("[3157]{3,6}"));//[3157]{3,6} 匹配数字1357,至少3次至多6次
System.out.println(str.matches("[a-zA-Z]{3,8}"));// [a-zA-Z]{3,8} 匹配英文大小写字母,至少3次至多8次
}