正则表达式

最新推荐文章于 2022-03-25 18:09:23 发布

cherry...a

最新推荐文章于 2022-03-25 18:09:23 发布

阅读量144

点赞数

本文链接：https://blog.csdn.net/qq_46466568/article/details/107731097

版权

基本类型与包装类型

byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

Integer类

integer类在对象中包装了一个基本类型int的值

还提供了多个方法，能在int类型和string类型之间互相转换

public Integer(int value)
public Integer(String s)//要一个字面上是数字的字符串，如果不是救护报错

引用类型相当于也是包装类型。

只有基本类型才可以实现相加减

interger 重写了tostring()方法，将int类型转换成了string方法。

int类型和Stirng类型之间的相互转换
int类型转换成string类型：
1.和""进行拼接
2.public static String valueof(int i)
3.先把int类型用Integer类进行包装，再转换成String
4.public static String toString(int i)


Stirng 转换成int类型
String -- Integer -- intValue();
public static int parseInt(String s)

 String s = "1";
        Integer i = new Integer(s);
        System.out.println(i.intValue());//方式1
        System.out.println(Integer.parseInt(s));//方式2

自动装箱和自动拆箱

自动装箱：把基本类型转换为包装类类型

Integer b = new Integer(num);
        System.out.println(b);
        Integer integernum = num;
        System.out.println(integernum);

自动拆箱：把包装类类型转换为基本类类型

Integer a = new Integer(100);
Integer b = new Integer(200);
int c = a+b;
System.out.println(c);

Integer ii = 100;//自动装箱
	ii += 200;//自动拆箱
	输出结果300

Integer i1 = new Integer(127);
	Integer i2 = new Integer(127);
	System.out.println(i1 == i2);//false
	//inteder重写了i1.equals(i2)方法，比较的是包装的俩内容是否相同
	System.out.println(i1.equals(i2));//true
	System.out.println("-----------");

	Integer i3 = new Integer(128);
	Integer i4 = new Integer(128);
	System.out.println(i3 == i4);//false
	System.out.println(i3.equals(i4));//true
	System.out.println("-----------");

	Integer i5 = 128;//自动装箱，它其实在调用valueof()方法，这种方法用到了integercache这个类，那么这个intergercache这个类是interger的静态内部类，在这个intergercache这个类中有一个静态代码块，当intergercache这个；类加载，这个静态代码=块就会执行。
	Integer i6 = 128;
	System.out.println(i5 == i6);//false
	System.out.println(i5.equals(i6));//true
	System.out.println("-----------");
//当我们采用Integer i5 = 128这种方法自动装箱时，会采用valueof()方法，范围[-128,127]
	Integer i7 = 127;
	Integer i8 = 127;
	System.out.println(i7 == i8);//true
	System.out.println(i7.equals(i8));//true

正则表达式

正确规则的表达式是一种独立的语法，很多语言都用它，就是校验数据符不符合我们定义的格式。其实就是一种特殊的规则，有自己特殊的应用。

字符：
'a'表示字符a；
\\反斜线字符
\n换行符
\r回车符

字符类：
[abc]a或b或c
[^abc]任意字符，除了a.b或c(表示否定)[^0-9]不是列表中的某一个
[a-zA-Z]a到z或A-Z两头的字母包括
[0-9]0-9的字符都包括

预定义字符类：
"."配置单个任意字符
“\\.”转义字符，这样的话.只代表自己本身。
"\\d" = "[0-9]"
"\\w" = "[0-9_a-zA-Z]"
\\s匹配空格字符


边界匹配器
^行的开头
$行的结尾
\b 单词边界



[0-9]+;0-9的数字可以出现一个或者多个。
[0-9]*;0-9的数字可以出现0个或者多个。
[0-9]？;0-9的数字可以出现0个或者一个。
[0-9]{6};0-9的数字可以出现6个。
[0-9]{6，};0-9的数字至少6个。
[0-9]{6，16};0-9的数字可以出现6-16个。含6,16

正则表达式的判断功能：

String类的功能：public boolean matches(String regex)

package cn.itcast.demo;

import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        //校验手机号的规则
        // 手机号 11 位 第一位是 1 第二位 3 5 7 8  其余位随意数字 手机号每一位都是数字。
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入的你的手机号");
        String phoneNumber = sc.nextLine();
        boolean flag = checkphoneNumber(phoneNumber);
        if (flag) {
            System.out.println("手机号规则正确");
        } else {
            System.out.println("手机号规则错误");
        }

    }

    private static boolean checkphoneNumber(String phoneNumber) {
        boolean flag = false;
        if (phoneNumber.length() == 11 && phoneNumber.startsWith("13") || phoneNumber.startsWith("15") || phoneNumber.startsWith("17") || phoneNumber.startsWith("18")) {
            for (int i = 0; i < phoneNumber.length(); i++) {
                char c = phoneNumber.charAt(i);
                if (!Character.isDigit(c)) {//判断是否是数字
                    flag = false;
                    break;
                } else {
                    flag = true;
                }


            }

        }
        return flag;

    }
}


package cn.itcast.demo;

import java.util.Scanner;

public class test2 {
    public static void main(String[] args) {
        //校验手机号的规则
        // 手机号 11 位 第一位是 1 第二位 3 5 7 8  其余位随意数字 手机号每一位都是数字。
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入的你的手机号");
        String phoneNumber = sc.nextLine();
        boolean flag = checkphoneNumber(phoneNumber);
        if (flag) {
            System.out.println("手机号规则正确");
        } else {
            System.out.println("手机号规则错误");
        }

    }

    private static boolean checkphoneNumber(String phoneNumber) {
        boolean m = phoneNumber.matches("[1][3,5,7,8][0-9]{9}");

        return m ;
    }

}

package cn.itcast.demo;
//6-18个字符。要求首字母必须大写，其他可以是】字母，数字，下划线，以@163.com结尾


import java.util.Scanner;

public class test1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要注册的邮箱号");
        String emilNumber = sc.nextLine();
        boolean flag = checkemilNumber(emilNumber);
        if (flag) {
            System.out.println("邮箱规则正确");
        } else {
            System.out.println("邮箱规则错误");
        }

    }

    private static boolean checkemilNumber(String emilNumber) {
        boolean flag = false;
        if (emilNumber.endsWith("@163.com")&&emilNumber.length() >= 14 && emilNumber.length() <= 26&&Character.isLetter(emilNumber.charAt(0))) {
            String s = emilNumber.substring(0, emilNumber.lastIndexOf("@"));
            System.out.println(s);
            for (int i = 1; i < s.length(); i++) {
                char c1 = s.charAt(i);
                if (!(Character.isDigit(c1) || c1 == '_' )) {
                    flag = false;
                    break;
                }else{
                    flag = true;
                }

            }


        }
        return flag;

    }
}



package cn.itcast.demo;

import java.util.Scanner;

public class test3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要注册的邮箱号");
        String emilNumber = sc.nextLine();
        boolean flag = checkemilNumber(emilNumber);
        if (flag) {
            System.out.println("邮箱规则正确");
        } else {
            System.out.println("邮箱规则错误");
        }

    }

    private static boolean checkemilNumber(String emilNumber) {
        boolean m = emilNumber.matches("[a-zA-Z]\\w{5,17}"+"@163.com");

        return  m;
    }
}

正则表达式的分割功能：

split切割字符串，返回的是一个字符串数组，根据正则来切割。split(这里写要切割掉的内容)
	String类的功能：public String[] split(String regex)

package cn.itcast.demo;

import java.util.Arrays;
//需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”

//分析：
/*
1.定义新的字符串
2，对其进行切割得到一个正常好看的字符串
3.将其转换成int类型
a.定义一个整形的数组，其长度为新的字符串的长度
b.循环遍历，将其每一个都装换成int类型的数组，并且放进去
4.排序
5.用Stringbuilder容器进行接收，
6.依次遍历，给其每一个后面都添加空格
8.把stringbuilder转换成string类型
8.去掉最后一个字符的空格。也就是去掉数组左右两边的空格
9.输出
*/



public class test8 {
    public static void main(String[] args) {
     String num = "91 27 46     38    50 0    1";
        String[] s = num.split("\\s+");
        int[] arr = new int[s.length];
        for(int i = 0;i<s.length;i++){
            arr[i] = Integer.parseInt(s[i]);
        }
        Arrays.sort(arr);
        StringBuilder sb = new StringBuilder();
        for(int i =0;i<arr.length;i++){
            sb.append(arr[i]).append(" ");
        }

        String s1 = sb.toString().trim();

        System.out.println(s1);
    }
}

package cn.itcast.demo;
//请编写程序，把给定字符串中的数字排序
给定的字符串是: "91 27 -45 46 38 50"
最终输出结果是: "-45 27 38 46 50 91"

import java.util.Arrays;

public class test14 {
    public static void main(String[] args) {
        String str = "91 27 -45 46 38 50";
        String[] s = str.split("\\s+");
        int[] arr = new int[s.length];
        for(int i=0;i<s.length;i++){
        arr[i] = Integer.parseInt(s[i]);
        }
        Arrays.sort(arr);
        StringBuilder sb = new StringBuilder();
        for(int i = 0;i<arr.length;i++){
            sb.append(arr[i]).append(" ");
        }
        String t = sb.toString().trim();
        System.out.println(t);


    }
}

正则表达式的替换功能

public String replaceAll(String regex,String replacement)

pattern和matcher

指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher
对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。

典型的调用顺序
Pattern p = Pattern.compile("a*b")；//首先编译为此类的实例，将给定的正则表达式编译到模式中
Matcher m = p.matcher("aaaaab");//创建matcher对象，也就是创建匹配给定输入与此模式的匹配器
boolean b = m.matches();//依照正则表达式，该对象可以和任意字符序列匹配

在仅使用一次正则表达式时，可以方便地通过此类定义 [matches](…/…/…/java/util/regex/Pattern.html#matches(java.lang.String, java.lang.CharSequence)) 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句

 boolean b = Pattern.matches("a*b", "aaaaab");

boolean find ()
尝试查找与该模式匹配的输入序列的下一个子序列。
String group ()
返回由以前匹配操作所匹配的输入子序列。
先使用find才能使用Group；

//需求：获取下面这个字符串中由三个字符组成的单词 正则表达式 \\b[a-z]{3}\\b
	da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?
//分析：创建模式匹配器，用该模式匹配器作为标准使用find方法进行匹配，然后用group返回匹配操作所匹配到的子序列
package cn.itcast.demo;

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

public class test9 {
    public static void main(String[] args) {
        String str="da jia ting wo shuo, jin tian yao xia yu, bu shang wan zi xi, gao xing bu?";
        String regx = "\\b[a-z]{3}\\b" ;
        Pattern p = Pattern.compile(regx);
        Matcher m = p.matcher(str);
        boolean b = m.matches();
while (m.find()){
    String group = m.group();
    System.out.println(group);

}

    }
}

match类的概述和方法使用

概述：math类包含用于执行基本数学运算的方法，例如初等指数，对数，平方根和三角函数。

成员变量
public static final double E : 		自然底数
public static final double PI:		圆周率
成员方法
public static int abs(int a)		取绝对值
public static double ceil(double a)	向上取整
public static double floor(double a)	向下取整
public static int max(int a,int b)      获取最大值
public static int min(int a, int b)	获取最小值
public static double pow(double a,double b) 获取a的b次幂
public static double random()	获取随机数 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
public static int round(float a) 四舍五入
public static double sqrt(double a)获取正平方根

package cn.itcast.demo;

public class test11 {
    public static void main(String[] args) {
        System.out.println(Math.E);//自然底数
        System.out.println(Math.PI);//圆周率
        System.out.println(Math.abs(-3));//取绝对值
        System.out.println(Math.ceil(3.1));//向上取整
        System.out.println(Math.floor(3.6));//向下取整
        System.out.println(Math.max(2, 5));//获取最大值
        System.out.println(Math.min(10, 8));//获取最小值
        System.out.println(Math.pow(2, 3));//获取2的3次幂，得到的是浮点型，8.0
        System.out.println(Math.random());//获取随机数 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
        System.out.println(Math.round(3.1));//四舍五入
        System.out.println(Math.sqrt(4));//获取4的根号 也就是2.0，得到的是浮点型数据
    }
}

Random类

此类用于产生随机数如果用相同的种子创建两个Random实例，则对每个实例进行相同的方法调用序列，他们将生成并返回相同的数字序列。

构造方法
public Random()			      没有给定种子,使用的是默认的(当前系统的毫秒值)
public Random(long seed)	  给定一个long类型的种子,给定以后每一次生成的随机数是相同的

成员方法
public int nextInt()//没有参数 表示的随机数范围 是int类型的范围
public int nextInt(int n)//可以指定一个随机数范围 
void nextBytes(byte[] bytes)  生成随机字节并将其置于用户提供的空的 byte 数组中。

package cn.itcast.demo;

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

public class test10 {
    public static void main(String[] args) {
        Random r = new Random();
        System.out.println(r.nextInt(100));
        byte[] bytes = new byte[100];
        System.out.println(Arrays.toString(bytes));

        Random r1 = new Random(10L);
        

    }
}

System类

概述：System类包含一些有用的类字段和方法，它不能被实例化，




成员方法
public static final InputStream in //标准输入流，此流以打开并准备提供输入数据，通常对应于键盘输入或者由主机环境或用户指定的另一个输入源。
public static final InputStream out //标准输出流，此流以打开并准备接受数据，通常此流对应于显示器输出或者由主机环境或者用户指定的另一个输出目标。
public static void gc()//调用垃圾回收器   
public static void exit(int status)//退出java虚拟机 0 为正常退出 非0为异常退出，System.exit格式。
public static long currentTimeMillis()//获取当前时间的毫秒值
//1s = 1000ms;

ctr+alt+空格强制自动提示