常用API(Math,System,Runtime,Object,Objects,BigInteger,BigDecimal,正则表达式)
多使用帮助文档
类型取值范围和默认值
Math类:
概念: 帮助我们进行数学计算的工具类,里面的方法都是静态的,所以无需实例化这个类
常用方法:
abs:：获取绝对值 absExact：获取绝对值 round：四舍五入 max：获取最大值 min：获取最小值
pow：获取a的b次幂 sqrt：开平方根 cbrt：开立方根 random：获取[0.0，1.0)之间的随机数
ceil：向上取整(往数轴的正无穷方向距离最近的整数) floor：向下取整(往数轴的负无穷方向距离最近的整数)
例子：
package com.caihongjia.mathdemo01;
public class TestMathDemo02 {
public static void main(String[] args) {
System.out.println(isPrime(50));
a();
System.out.println("===================================================");
b();
System.out.println("===================================================");
c();
System.out.println("===================================================");
d();
}
//判断是否为质数：质数只能被1和它自己整除
public static boolean isPrime(int a){
/*一个数的因子，一个因子小于等于平方根，另一个因子大于等于平方根，所以只要知道其中一半是否可以被整除就可以求出是否为质数*/
//这样可以减少循环次数，提升程序效率
for (int i = 2; i < Math.sqrt(a) ; i++) {
if (a % i == 0){
return false;
}
}
return true;
}
//自幂数：如果在一个固定的进制中，一个n位自然数等于自身各个数位上数字的n次幂之和，则称此数为自幂数。
//例如：在十进制中，153是一个三位数，各个数位的3次幂之和为1^3+5^3+3^3=153，所以153是十进制中的自幂数。
//一位自幂数：独身数
//两位自幂数：没有
//三位自幂数：水仙花数
//四位自幂数：四叶玫瑰数
//五位自幂数：五角星数
//六位自幂数：六合数
//七位自幂数：北斗七星数
//八位自幂数：八仙数
//九位自幂数：九九重阳数
//十位自幂数：十全十美数
//分别有多少水仙花数，分别是什么
public static void a(){
int count = 0;
for (int i = 100; i <= 999; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 ;
double sum = Math.pow(ge,3) + Math.pow(shi,3) + Math.pow(bai,3);
if (sum == i){
count++;
System.out.println(i);
}
}
System.out.println(count);
}
//证明一下为什么没有两位自幂数
public static void b(){
int count = 0;
for (int i = 10; i <= 99; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
double sum = Math.pow(ge,2) + Math.pow(shi,2);
if (sum == i){
count++;
System.out.println(i);
}
}
System.out.println(count);
}
//分别统计有多少四叶玫瑰数和五角星数，分别是什么
//四叶玫瑰数
public static void c(){
int count = 0;
for (int i = 1000; i <= 9999; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10 ;
int qian = i / 1000 ;
double sum = Math.pow(ge,4) + Math.pow(shi,4) + Math.pow(bai,4) + Math.pow(qian,4);
if (sum == i){
count++;
System.out.println(i);
}
}
System.out.println(count);
}
//五角星数
public static void d(){
int count = 0;
for (int i = 10000; i <= 99999; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10 ;
int qian = i / 1000 % 10 ;
int wan = i / 10000 ;
double sum = Math.pow(ge,5) + Math.pow(shi,5) + Math.pow(bai,5) + Math.pow(qian,5) + Math.pow(wan,5);
if (sum == i){
count++;
System.out.println(i);
}
}
System.out.println(count);
}
}
System类
概念：System属于工具类，提供了与系统相关的方法；System里的方法属于静态方法，直接用类名调用；
常用方法：
1.exit：终止当前运行的Java虚拟机,将整个程序关闭可以使用这个方法；
状态码：参数为0时，表示当前虚拟机为正常关闭；
参数为非0时，表示当前虚拟机为异常关闭；
例子：
//终止当前运行的Java虚拟机,将整个程序关闭可以使用这个方法
//状态码：
//参数为0时：表示当前虚拟机为正常关闭
//参数为非0时：表示当前虚拟机为异常关闭
System.exit(0);
2.currentTimeMillis：返回当前系统的时间毫秒形式，从1970年1月1日 00:00:00 开始，中国从1970年1月1日 08:00:00 开 始；
可用于查看程序运行的时间，在程序首尾都调用这个方法（1秒=1000毫米）；
例子：
//返回当前系统的时间毫秒形式，从1970年1月1日 00:00:00 开始，在中国从1970年1月1日 08:00:00 开始
//可用于查看程序运行的时间，在程序首尾都调用这个方法
long l = System.currentTimeMillis();
System.out.println(l);
3.arraycopy：数组拷贝
参数：参数一：数据源，要拷贝的数据从哪个数组而来；
参数二：从数据源数组中的第几个索引开始拷贝；
参数三：目的地，我要把数据拷贝到哪个数组中；
参数四：目的地数组的索引；
参数五：拷贝的个数；
细节：1、如果数据源数组和目的地数组都是基本数据类型，那么两者的类型必须保持一致，否则会报错；
2、在拷贝的时候需要考虑数组的长度，如果超出范围也会报错；
3、如果数据源数组和目的地数组都是引用数据类型，那么子类类型可以赋值给父类类型；
例子：
//数组拷贝
int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
int[] arr2 = new int[10];
//把arr1数组中的数据拷贝到arr2中
//参数一：数据源，要拷贝的数据从哪个数组而来
//参数二：从数据源数组中的第几个索引开始拷贝
//参数三：目的地，我要把数据拷贝到哪个数组中
//参数四：目的地数组的索引
//参数五：拷贝的个数
System.arraycopy(arr1,0,arr2,0,10);
//验证
for (int i = 0; i < arr2.length; i++) {
System.out.println(i);
}
Runtime类
概念：表示当前虚拟机的运行环境，构造方法属于私有的，无法直接实例化，只能通过getRuntime()方法来调用；
//1.获取Runtime的对象：使用getRuntime方法
Runtime r1 = Runtime.getRuntime();
Runtime r2 = Runtime.getRuntime();
System.out.println(r1==r2);//true，记录的是同一个对象，Runtime的对象是唯一的
常用方法：
1.exit：终止当前运行的Java虚拟机,将整个程序关闭可以使用这个方法，是System类中exit方法的底层；
例子：
//2.exit 停止虚拟机
Runtime.getRuntime().exit(0);
System.out.println("看看我执行了吗？");
2.availableProcessors：用来获取CPU的线程数
例子：
//3.获得CPU的线程数
System.out.println(Runtime.getRuntime().availableProcessors());
3.maxMemory：JVM(Java虚拟机)可以获得的总内存大小，单位为byte字节
例子：
//4.JVM(Java虚拟机)可以获得的总内存大小，单位为byte字节
System.out.println(Runtime.getRuntime().maxMemory() / 1024 / 1024);//3934 将其转换为MB
4.totalMemory：JVM(Java虚拟机)已经获取的总内存大小，单位byte字节
例子：
//5.JVM(Java虚拟机)已经获取的总内存大小，单位byte字节
System.out.println(Runtime.getRuntime().totalMemory() / 1024 / 1024);//246MB 将其转换为MB
5.freeMemory：JVM(Java虚拟机)剩余内存大小，单位byte字节
· 例子：
//6.JVM(Java虚拟机)剩余内存大小，单位byte字节
System.out.println(Runtime.getRuntime().freeMemory() / 1024 / 1024);//241MB 将其转换为MB
6.exec：运行cmd命令
常用命令：shutdown：关机，-s ：默认再1分钟之后关机，-s -t 指定时间 ：指定关机时间，-a ：取消关机操作
-r ：关机并重启
例子：
//7.运行cmd命令
//shutdown：关机
//加上参数才能执行
//-s ：默认再1分钟之后关机
//-s -t 指定时间 ：指定关机时间
//-a ：取消关机操作
//-r ：关机并重启
try {
Runtime.getRuntime().exec("");
} catch (IOException e) {
e.printStackTrace();
}
恶搞程序：
package com.caihongjia.runtimedemo;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
public class TestRuntimeDemo02 {
public static void main(String[] args) {
new MyJframe();
}
public static class MyJframe extends JFrame implements ActionListener{
JButton yesBut = new JButton("一小时后自动关机");
JButton noBut = new JButton("取消自动关机");
public MyJframe(){
initJFrame();
initView();
this.setVisible(true);
}
@Override
public void actionPerformed(ActionEvent e) {
Object obj = e.getSource();
if (obj == yesBut){
//点击一小时后自动关机
try {
Runtime.getRuntime().exec("shutdown -s -t 3600");
} catch (IOException ioException) {
ioException.printStackTrace();
}
}else if (obj == noBut){
//取消自动关机
try {
Runtime.getRuntime().exec("shutdown -a");
} catch (IOException ioException) {
ioException.printStackTrace();
}
}
}
private void initView(){
this.getContentPane().removeAll();
JLabel text = new JLabel("自动关机");//设置标签
text.setFont(new Font("微软雅黑",0,30));
text.setBounds(120,150,300,50);
yesBut.setBounds(200,250,100,30);
noBut.setBounds(200,325,100,30);
yesBut.addActionListener(this);
noBut.addActionListener(this);
this.getContentPane().add(text);
this.getContentPane().add(yesBut);
this.getContentPane().add(noBut);
this.getContentPane().repaint();
}
private void initJFrame(){
//设置宽高
this.setBounds(500,500,500,600);
//设置标题
this.setTitle("关机程序");
//设置关闭模式
this.setDefaultCloseOperation(3);//直接关闭程序
//置顶
this.setAlwaysOnTop(true);
//取消内部默认布局
this.setLayout(null);
}
}
}
Object类
概念：Object类是Java中的顶级父类，所有类都间接或者直接的继承Object类，Object类是没有有参构造的，只有无参构造；
常用方法：
1.toString：返回对象的字符串表示形式，默认返回对象的地址值，属于一般方法；
结论：1、如果我们打印一个对象，想要看属性值的话，那么要重写toString方法就可以了；
2、在重写的方法中，把对象的属性值进行拼接；
例子(包含System.out.println的核心)：
//1.toString() 返回对象的字符串表示形式
Object obj = new Object();
String str1 = obj.toString();
System.out.println(str1);//java.lang.Object@16b98e56 返回地址值
Student stu = new Student();
String str2 = stu.toString();
System.out.println(str2);//com.caihongjia.objectdemo.Student@27d6c5e0
//细节：
//System：类名
//out：静态变量
//System.out：获取打印的对象
//println：方法
//参数：表示打印的内容
//核心逻辑：
//当我们打印一个对象的时候，底层会调用对象的toString方法，把对象变成字符串
//然后打印在控制台上，打印完毕换行处理
System.out.println(stu);//com.caihongjia.objectdemo.Student@27d6c5e0
//结论：
//如果我们打印一个对象，想要看属性值的话，那么要重写toString方法就可以了
//在重写的方法中，把对象的属性值进行拼接
2.equals：比对两个对象是否相同，属于一般方法；
结论：1、如果没有重写equals方法，那么默认使用Object类中的方法进行比较，比较的是地址值是否相等；
2、一般来讲地址值对我们意义不大，所以我们会重写，重写之后比较的就是对象内部的属性值；
3、谁调用的equals方法，那么就看这个变量类型中的equals方法；
例子：
package com.caihongjia.objectdemo;
public class ObjectDemo02 {
public static void main(String[] args) {
//2.equals方法：比对两个对象是否相同
Student s1 = new Student();
Student s2 = new Student();
System.out.println(s1.equals(s2));
//结论
//1、如果没有重写equals方法，那么默认使用Object类中的方法进行比较，比较的是地址值是否相等
//2、一般来讲地址值对我们意义不大，所以我们会重写，重写之后比较的就是对象内部的属性值
//3、谁调用的equals方法，那么就看这个变量类型中的equals方法
}
}
3.clone：把A对象的属性值，完全拷贝给B对象，也叫对象拷贝，对象复制，它是用protection修饰，所以需要重写才能使 用，属于一般方法；
结论：1、浅克隆：不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝过来，默认为浅克隆，如果修 改A对象的属性值，B对象的属性值也可能会更改；
2、深克隆：基本数据类型完全拷贝过来，字符串复用，引用数据类型会重新常见新的；深克隆可以用方法重 写，也可以用第三方工具；
3、让javabean类实现Cloneable接口，创建原对象并调用clone就可以了；
例子：
public static void main(String[] args) throws CloneNotSupportedException {
//protected Object clone(int a) 对象克隆
//1、先创建一个对象
int[] data = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0};
User u1 = new User("zhangsan", "123456", "girl11", data);
//2、克隆对象
User u2 = (User) u1.clone();
//验证Object中的克隆是浅克隆
int[] arr = u1.getData();
arr[0] = 100;
System.out.println(u1);
System.out.println(u2);
}
//重写方法：从浅克隆变为深克隆
@Override
protected Object clone() throws CloneNotSupportedException {
//调用父类的clone方法
//相当于让Java帮我们看了一个对象，并把克隆之后说的对象返回出去；
//先把被克隆对象中的数据获取出来
int[] data = this.data;
//创建新的数组
int[] newDate = new int[data.length];
//拷贝数组中的数据
for (int i = 0; i < data.length; i++) {
newDate[i] = data[i];
}
//调用父类中的方法克隆对象
User u = (User) super.clone();
//因为父类中的克隆方法是浅克隆，替换克隆出来对象中的数组地址值
u.data = newDate;
return u;
}
Objects类
概念：属于Java中的工具类
常用方法：
1.equals：比较两个对象是否相同；先做非空判断，再比较对象，属于静态方法；
结论：1、方法的底层会判断s1是否为null，如果为null，直接返回false；
2、如果s1不为null，那么就利用s1再次调用equals方法；
3、此时s1是Student类型，所以最终还是会调用Student02中的equals方法；
4、如果没有重写，比较地址值，如果重写了，就比较属性值；
例子：
//equals：先做非空判断，比较两个对象
//1.创建学生类的对象
Student02 s1 = null;
Student02 s2 = new Student02("zhangsan", 23);
//2.比较两个对象的属性值是否相同
// if (s1 != null){
// boolean result = s1.equals(s2);
// System.out.println(result);
// }else{
// System.out.println("调用者为空");
// }
boolean result = Objects.equals(s1,s2);
System.out.println(result);
//细节
//1、方法的底层会判断s1是否为null，如果为null，直接返回false
//2、如果s1不为null，那么就利用s1再次调用equals方法
//3、此时s1是Student类型，所以最终还是会调用Student02中的equals方法
//如果没有重写，比较地址值，如果重写了，就比较属性值
//Student02类：
package com.caihongjia.objectdemo;
import java.util.Objects;
public class Student02 {
private String name;
private int age;
public Student02(){}
public Student02(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
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student02 student02 = (Student02) o;
return age == student02.age && Objects.equals(name, student02.name);
}
@Override
public String toString() {
return "Student02{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
2.isNull：判断对象是否为null，为null返回true，反之为false；
3.nonNull：判断对象是否为null，为null返回false，反之为true；
例子：
//isNull：判断对象是否为null，为null返回true，反之为false
Student02 s3 = new Student02();
Student02 s4 = null;
System.out.println(Objects.isNull(s3));
System.out.println(Objects.isNull(s4));
//nonNull：判断对象是否为null，为null返回false，反之为true；
System.out.println(Objects.nonNull(s3));
System.out.println(Objects.nonNull(s4));
BigInteger类
概念：表示一个大整数，一个可存放超过long类型取值范围的值的类；通过参数来调用该类中不同的构造方法
常用构造和静态方法：
1.public BigInteger(int num,Random rnd)：获取一个随机的大整数,范围：[0~2的num次方-1]；属于构造方法；
例子：
//1.public BigInteger(int num,Random rnd)：获取一个随机的大整数,范围：[0~2的num次方-1]
Random r = new Random();
for (int i = 0;i < 100; i++){
BigInteger bd1 = new BigInteger(4, r);//0~2的4次方-1
System.out.println(bd1);
}
2.public BigInteger(String val)：获取指定的大整数；属于构造方法；
结论：字符串必须是整数，否则会报错；
例子：
//2.public BigInteger(String val)：获取指定的大整数
//细节：字符串必须是整数，否则会报错
BigInteger bd2 = new BigInteger("555");
System.out.println(bd2);
3.public BigInteger(String val,int radix)：获取指定进制的大整数,第一个是字符串，第二个是进制；属于构造方法；
结论：1.字符串中的数字必须是整数；
2.字符串中的数字必须要跟进制吻合；
3.比如二进制中，那么只能写0和1，写其他的就会报错；
例子：
//3.public BigInteger(String val,int radix)：获取指定进制的大整数,第一个是字符串，第二个是进制
//细节：
//1.字符串中的数字必须是整数
//2.字符串中的数字必须要跟进制吻合
//比如二进制中，那么只能写0和1，写其他的就会报错
BigInteger bg3 = new BigInteger("001", 2);
BigInteger bg4 = new BigInteger("1505", 10);
System.out.println(bg3);
System.out.println(bg4);
4.valueOf：静态方法获取BigInteger的对象，内部有优化
结论：1.能表示范围比较小，只能在long的取值范围之内，如果超过long的范围就不行了；
2.在内部对常用的数字：-16~16进行了优化；
3.提前把-16~16先创建好BigInteger的对象，如果多次获取不会重写创建新的对象；
4.对象一旦创建内部的数据不能发生改变；
例子：
//4.静态方法获取BigInteger的对象，内部有优化
//细节：
//1.能表示范围比较小，只能在long的取值范围之内，如果超过long的范围就不行了
//2.在内部对常用的数字：-16~16进行了优化
//提前把-16~16先创建好BigInteger的对象，如果多次获取不会重写创建新的对象
BigInteger bd5 = BigInteger.valueOf(16);
BigInteger bd6 = BigInteger.valueOf(16);
System.out.println(bd5 == bd6);
//对象一旦创建内部的数据不能发生改变；
BigInteger bd9 = BigInteger.valueOf(1);
BigInteger bd10 = BigInteger.valueOf(2);
BigInteger result = bd9.add(bd10);
System.out.println(result);
System.out.println(bd9 == result);
System.out.println(bd10 == result);
常用成员方法：
package com.caihongjia.bigInteger;
import java.math.BigInteger;
public class TestBigIntegerDemo02 {
public static void main(String[] args) {
//BigInteger中常见的一般方法
//创建两个BigInteger对象
BigInteger bd1 = BigInteger.valueOf(10);//bd1+bd2
BigInteger bd2 = BigInteger.valueOf(5);
//1.加法
BigInteger bd3 = bd1.add(bd2);
System.out.println(bd3);
//2.减法
BigInteger bd4 = bd1.subtract(bd2);//bd1-bd2
System.out.println(bd4);
//3.乘法
BigInteger bd5 = bd1.multiply(bd2);//bd1*bd2
System.out.println(bd5);
//4.除法，获取商
BigInteger bd6 = bd1.divide(bd2);//bd1/bd2
System.out.println(bd6);
//5.除法，获取商和余数，返回的是数组
BigInteger[] arr = bd1.divideAndRemainder(bd2);//bd1/bd2,bd1%bd2
System.out.println(arr.length);
System.out.println(arr[0]);
System.out.println(arr[1]);
//6.equals:比较对象里的属性是否相同,返回的是布尔值
boolean bd7 = bd1.equals(bd2);
System.out.println(bd7);
//7.次幂
BigInteger bd8 = bd1.pow(2);//bd1的2次幂
System.out.println(bd8);
//8.max
BigInteger bd9 = bd1.max(bd2);//比较两个对象的大小，返回最大值的对象
System.out.println(bd9);
System.out.println(bd9 == bd1);//true，没有改变里面的值，所以不会创建一个新的对象
System.out.println(bd9 == bd2);//false
//9.intValue:转为int类型整数，超出范围数据有误
BigInteger bd10 = BigInteger.valueOf(152000);
int i = bd10.intValue();
System.out.println(i);
//9.longValue:转为long类型整数，超出范围数据有误
BigInteger bd11 = BigInteger.valueOf(155000);
long l = bd11.longValue();
System.out.println(l);
//10.doubleValue:转为double类型整数，超出范围数据有误
BigInteger bd12 = BigInteger.valueOf(155000);
double v = bd12.doubleValue();
System.out.println(v);
}
}
BigDecimal类
概念：用于精确计算的小数类，表示很大的小数；通过参数来调用该类中不同的构造方法
常用构造和静态方法：
1.public BigDecimal(String val)：通过传递字符串表示的个数来创建对象，用来获得指定的小数；属于构造方法；
结论：如果要表示的数字比较大，超出了double的取值范围，建议使用构造方法
例子：
//1.通过传递字符串表示的个数来创建对象
BigDecimal bd1 = new BigDecimal("0.09");
BigDecimal bd2 = new BigDecimal("0.01");
BigDecimal bd3 = bd1.add(bd2);
System.out.println(bd1);
System.out.println(bd2);
System.out.println(bd3);
2.valueOf：静态方法获取BigDecimal的对象，内部有优化
结论：1..如果要表示的数字不大，没有超出double的取值方法，建议使用静态方法；
2.如果我们传递的是0~10之间的整数，包含0，包含10那么方法会返回已经创建好的对象，不会重写new，为了 节约内存；
例子：
//2.通过静态方法获取对象
//参数为long类型，返回BigDecimal类型
BigDecimal bd4 = BigDecimal.valueOf(10);
BigDecimal bd6 = BigDecimal.valueOf(10);
System.out.println(bd4);
System.out.println(bd4 == bd6);
//参数为double类型，返回BigDecimal类型
BigDecimal bd5 = BigDecimal.valueOf(10.5);
System.out.println(bd5);
//细节：
//1.如果要表示的数字不大，没有超出double的取值方法，建议使用静态方法
//2.如果要表示的数字比较大，超出了double的取值范围，建议使用构造方法
//3.如果我们传递的是0~10之间的整数，包含0，包含10那么方法会返回已经创建好的对象，不会重写new，为了节约内存
常用成员方法：
package com.caihongjia.a06bigdecimaldemo;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class TestBigDecimalDemo02 {
public static void main(String[] args) {
//BigDecimal中常见的一般方法
//创建两个BigInteger对象
BigDecimal bd1 = BigDecimal.valueOf(10.0);
BigDecimal bd2 = BigDecimal.valueOf(5.0);
//1.加法
BigDecimal bd3 = bd1.add(bd2);//bd1+bd2
System.out.println(bd3);
//2.减法
BigDecimal bd4 = bd1.subtract(bd2);//bd1-bd2
System.out.println(bd4);
//3.乘法
BigDecimal bd5 = bd1.multiply(bd2);//bd1*bd2
System.out.println(bd5);
//4.除法
BigDecimal bd6 = bd1.divide(bd2);//bd1/bd2
System.out.println(bd6);
//5.除法，带参数
BigDecimal bd11 = BigDecimal.valueOf(10.0);
BigDecimal bd22 = BigDecimal.valueOf(3.0);
BigDecimal bd7 = bd11.divide(bd22,2, RoundingMode.HALF_UP);//除不尽，保留小数点后两位，舍入模式为四舍五入
System.out.println(bd7);
}
}
RoundingMode(舍入模式)：
舍入模式：1.UP：远离零方向舍入的舍入模式；
2.DOWN：向零方向舍入的舍入模式；
3.CEILING：向正无限大方向舍入的舍入模式；
4.FLOOR：向负无限大方向舍入的舍入模式；
5.HALF_UP：四舍五入；
正则表达式
方法调用: 调用String类中的matches方法，方法参数里的为正则表达式
package com.caihongjia.a07regexdemo;
public class RegexDemo01 {
public static void main(String[] args) {
//string.matches(regex);
boolean matches = "]".matches("[^a-d]");
System.out.println(matches);
}
}
正则表达式写法：
练习：
package com.caihongjia.a07regexdemo;
public class RegexDemo01 {
public static void main(String[] args) {
// boolean matches = "]".matches("[^a-d]");
// System.out.println(matches);
/*
使用正则表达式练习:
验证手机号码 13112345678 13712345667 13945679027 1339456790271
验证座机电话号码 020-2324242 0212442 027-41414 0712-3242434
验证邮箱号码 [email protected] [email protected] [email protected] [email protected]
*/
//心得
//拿着一个正确的数据,从左到右依次去写
//13112345678
//分成三部分:
//第一部分: 1表示手机号码只能以1开头
//第二部分: [3-9] 表示手机号码第二位只能是3-9之间的
//第三部分: \\d{9} 表示任意数字可以出现+9次,也只能出现9次
String regex1 = "1[3-9][0-9]{9}";
// String regex1 = "1[3-9]\\d{9}";
System.out.println("13112345678".matches(regex1));//true
System.out.println("13712345667".matches(regex1));//true
System.out.println("13945679027".matches(regex1));//true
System.out.println("1339456790271".matches(regex1));//false
System.out.println("===========================================");
//座机电话号码
//020-2324242 0212442 027-41414 0712-3242434
//思路:
//在书写座机号正则的时候需要把正确的数据分为三部分
//一:区号 0\d{2,3}
// 0:表示区号一定是以0开头的
// \\d{2,3}:表示区号从第二位开始可以是任意的数字,可以出现2到3次
//二:- ?表示次数,0次或1次
//三:号码 号码的第一位也不能以0开头,从第二位开始可以是任意的数字,号码的总长度:5-10位
String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
System.out.println("020-2324242".matches(regex2));
System.out.println("0212442".matches(regex2));
System.out.println("027-41414".matches(regex2));
System.out.println("0712-3242434".matches(regex2));
System.out.println("===========================================");
//验证邮箱号码
//[email protected] [email protected] [email protected] [email protected]
//思路:
//在书写邮箱号码正则的时候需要把正确的数据分为三部分
//第一部分:@的左边，\\w+
// 任意的字母数字下划线，至少出现一次就可以了
//第二部分: @ 只能出现一次
//第三部分:
// 3.1 .的左边 [\\w&&[^_]]{2,6} \\w去掉下划线
// 任意的字母加数字,总共出现2-6次(此时不能出现下划线)
// 3.2 . \\.
// 3.3 大写字母,小写字母都可以,只能出现2-3次[a-zA-Z]{2，3}
// 我们可以把3.2和3.3看成一组,这一组可以出现1次或者2次
String regex3 = "\\w+@[\\w&&[^_]](\\.[a-zA-Z]{2,3}){1,2}";
System.out.println("[email protected]".matches(regex3));
System.out.println("[email protected]".matches(regex3));
System.out.println("[email protected]".matches(regex3));
System.out.println("[email protected]".matches(regex3));
String regex4 = "";
}
}
package com.caihongjia.a07regexdemo;
public class RegexDemo02 {
public static void main(String[] args) {
/*
正则表达式练习2:
需求
请编写正则表达式验证用户名是否满足要求.
要求:大小写字母,数字,下划线一共4-16位
请编写正则表达式验证身份证号码是否满足要求.
简单要求:18位，前17位任意数字，最后一位可以是数字可以是大写或小写的x
复杂要求:按照身份证号码的格式严格要求
身份证号码:
41080119930228457x
510801197609022309
15040119810705387X
130133197204039024
430102197606046442
*/
//用户名要求:大小写字母,数字,下划线一共4-16位
String regex1 = "\\w{4,16}";
System.out.println("zhangsan".matches(regex1));//true
System.out.println("lisi".matches(regex1));//true
System.out.println("123456789".matches(regex1));//true
System.out.println("$123".matches(regex1));//false
//身份证号码的简单校验:
//18位,前17位任意数字,最后一位可以是数字可以是大写或小写的x
String regex2 = "[1-9]\\d{16}(\\d||X||x)";
String regex3 = "[1-9]\\d{16}[\\dXx]";
String regex7 = "[1-9]\\d{16}(\\d||(?i)x)";
System.out.println("41080119930228457x".matches(regex3));//true
System.out.println("510801197609022309".matches(regex3));//true
System.out.println("130133197204039024".matches(regex3));//true
System.out.println("15040119810705387X".matches(regex3));//true
System.out.println("430102197606046442".matches(regex3));//true
//忽略大小写的书写方式
//在匹配的时候忽略abc的大小写
String regex4 = "(?i)abc";
//在匹配的时候忽略bc的大小写
String regex5 = "a(?i)bc";
//在匹配的时候忽略b的大小写
String regex6 = "a((?i)b)c";
System.out.println("-------------------------------");
System.out.println("abc".matches(regex6));//true
System.out.println("ABC".matches(regex6));//false
System.out.println("aBC".matches(regex6));//false
System.out.println("--------------------------------------");
//身份证号码的严格校验
//编写正则的小心得
//第一步:按照正确的数据进行拆分
//第二步:找每一部分的规律,并编写正则表达式
//第三步:把每一部分的正则拼接在一起,就是最终的结果
//书写的时候:从左到右去书写
//410801 1993 02 28 457x
//前面6为:省份,市区,派出所等信息 第一位不能是0,后面5位是任意数字 [1-9]\\d{5}
//年的前半段: 18 19 20 (18||19||20)
//年的后半段: 任意数字出现两次 \\d{2}
//月份: 01 ~ 09 10 11 12 (0[1-9]||1[0-2])
//日期: 01-31 (0[1-9]||[12][0-9]||3[01])
//后面四位: 任意数字出现3次 最后一位可以是数字也可以是大写x或者小写x \\d{3}[\\dXx]
String regex8 = "[1-9]\\d{5}(18||19||20)\\d{2}(0[1-9]||1[0-2])(0[1-9]||[12][0-9]||3[01])\\d{3}[\\dXx]";
System.out.println("41080119930228457x".matches(regex8));//true
System.out.println("510801197609022309".matches(regex8));//true
System.out.println("130133197204039024".matches(regex8));//true
System.out.println("15040119810705387X".matches(regex8));//true
System.out.println("430102197606046442".matches(regex8));//true
}
}
小结:
//编写正则的小心得
//第一步:按照正确的数据进行拆分
//第二步:找每一部分的规律,并编写正则表达式
//第三步:把每一部分的正则拼接在一起,就是最终的结果
//书写的时候:从左到右去书写
