枚举，正则表达式，Base64加密和解密
文章目录
- 一.枚举
- 二.正则表达式
- 1.正则表达式的概念及演示
- 2.正则表达式-字符类
- 3.正则表达式-逻辑运算符
- 4.正则表达式-预定义字符
- 5. 正则表达式-数量词
- 6.正则表达式-分组括号( )
- 7.String类中和正则表达式相关的方法
- 8.正则表达式生成网址:
- 三.Base64加密和解密(JDK8的新特性)
一.枚举
枚举:
1.概述:引用数据类型
类 数组 接口 注解 [枚举]
2.关键字:enum->java.lang.Enum类，是所有枚举的父类。
3.枚举：里面一般都定义常量(默认的修饰符 public static final但是定义的时候写上报错)
4.特点:定义的常量都是这个枚举类的对象
一个没枚举类中有多个对象(多例)
5.问题:我们定义出来的常量,数据类型应该是什么:本类类型
6.使用场景:一般用在表示状态上(如果用1234表示状态不太好,用枚举是最好的)
提交订单: 未付款
提交订单: 已付款
提交订单: 未发货
提交订单: 已发货(发货中)
提交订单: 派件中
提交订单: 已签收
7.枚举中定义构造:(了解)
a.无参构造:默认权限修饰符是private
b.有参构造:private,要是赋值的话,我们可以利用常量直接赋值 :RED("红色")
//枚举的定义
public enum Color{
RED,GREEN,YELLOW;//分号可写,可不写,但是建议写上,因为我们要后面写其他的代码
}
public enum Color {
//由于三个常量都是本类对象,直接往括号中写值,就相当于利用有参构造赋值
RED("红色"),GREEN("绿色"),YELLOW;
//定义一个空参构造
private Color(){
}
private String color;
private Color(String color){
this.color = color;
}
public String getColor() {
return color;
}
}
public class Test {
public static void main(String[] args) {
/*Color red = Color.RED;
System.out.println(red.toString());*/
System.out.println("-----------------------");
Color red = Color.RED;
System.out.println(red.getColor());
}
}
二.正则表达式
1.正则表达式的概念及演示
package com.itheima.demo04Regex;
import java.util.Scanner;
/*
正则表达式:
就是一个包含某些规则的字符串
用来对其他的字符串进行校验,校验其他的字符串是否满足正则表达式的规则
需求:
对QQ号进行校验
1.长度5-15位
2.全是数字
3.第一位不能是0
校验QQ号的正则表达式
"[1-9][0-9]{4,14}"
*/
public class Demo01Regex {
public static void main(String[] args) {
//获取一个用户输入的QQ号
System.out.println("请输入一个QQ号:");
String qq = new Scanner(System.in).nextLine();
boolean b1 = checkQQ(qq);
System.out.println("b1:"+b1);
boolean b2 = checkQQRegex(qq);
System.out.println("b2:"+b2);
}
//定义校验QQ号的方法,不使用正则表达式
public static boolean checkQQ(String qq){
//1.长度5-15位
if(qq.length()<5 || qq.length()>15){
return false;
}
//2.全是数字
char[] chars = qq.toCharArray();
for (char c : chars) {
//判断字符是否在'0'到'9'之间
if(c<'0' || c>'9'){
return false;
}
}
//3.第一位不能是0
if("0".equals(qq.charAt(0)+"")){
return false;
}
//满足所有的规则
return true;
}
/*
定义校验QQ号的方法,使用正则表达式
String类中的方法:
boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。
判断字符串是否满足正则表达式的规则
满足:返回true
不满足:返回false
*/
public static boolean checkQQRegex(String qq){
return qq.matches("[1-9][0-9]{4,14}");
}
}
2.正则表达式-字符类
package com.itheima.demo04Regex;
/*
java.util.regex.Pattern:正则表达式的编译表示形式。
正则表达式-字符类:[]表示一个区间,范围可以自己定义
语法示例：
1. [abc]：代表a或者b，或者c字符中的一个。
2. [^abc]：代表除a,b,c以外的任何字符。
3. [a-z]：代表a-z的所有小写字符中的一个。
4. [A-Z]：代表A-Z的所有大写字符中的一个。
5. [0-9]：代表0-9之间的某一个数字字符。
6. [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。
7. [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符
*/
public class Demo02Regex {
public static void main(String[] args) {
String str = "ead";//false
//1.验证str是否以h开头，以d结尾，中间是a,e,i,o,u中某个字符
String regex = "h[aeiou]d";
str = "hid";//true
str = "Hud";//false
boolean b1 = str.matches(regex);
System.out.println("b1:"+b1);
//2.验证str是否以h开头，以d结尾，中间不是a,e,i,o,u中的某个字符
regex = "h[^aeiou]d";
str = "h1d";//true
str = "had";//false
boolean b2 = str.matches(regex);
System.out.println("b2:"+b2);
//3.验证str是否a-z的任何一个小写字符开头，后跟ad
regex = "[a-z]ad";
str = "wad";//true
str = "1ad";//false
boolean b3 = str.matches(regex);
System.out.println("b3:"+b3);
//4.验证str是否以a-d或者m-p之间某个字符开头，后跟ad
regex = "[a-dm-p]ad";
str = "cad";//true
str = "ead";//false
boolean b4 = str.matches(regex);
System.out.println("b4:"+b4);
}
}
3.正则表达式-逻辑运算符
package com.itheima.demo04Regex;
/*
正则表达式-逻辑运算符
语法示例：
1. &&：并且
2. | ：或者
*/
public class Demo03Regex {
public static void main(String[] args) {
String str = "had";//true
str = "ead";//false
str = "Had";//false
//1.要求字符串是小写[a-z]和字符[^aeiou]开头，后跟ad
String regex = "[[a-z]&&[^aeiou]]ad";
boolean b1 = str.matches(regex);
System.out.println("b1:"+b1);
//2.要求字符串是aeiou中的某个字符开头，后跟ad
regex = "[a||e||i||o||u]ad";//"[a|e|i|o|u]ad"就相当于"[aeiou]" 或运算符是可以省略不写的
str = "aad";//true
str = "1ad";//false
boolean b2 = str.matches(regex);
System.out.println("b2:"+ b2);
}
}
4.正则表达式-预定义字符
package com.itheima.demo04Regex;
/*
正则表达式-预定义字符
语法示例：
1. "." ： 匹配任何字符。(重点)
2. "\\d"：任何数字[0-9]的简写；(重点)
3. "\\D"：任何非数字[^0-9]的简写；
4. "\\s"： 空白字符：[ \t\n\x0B\f\r] 的简写
5. "\\S"： 非空白字符：[^\s] 的简写
6. "\\w"：单词字符：[a-zA-Z_0-9]的简写(重点)
7. "\\W"：非单词字符：[^\w]
注意:
\本身就是转义字符,写正则表达式语法的时候,必须写\\,把有特殊含义的\转义为一个普通的\使用
*/
public class Demo04Regex {
public static void main(String[] args) {
//1.验证str是否3位数字
String str = "250";//true
str = "25a";//false
String regex = "[0-9][0-9][0-9]";
regex = "\\d\\d\\d";
boolean b1 = str.matches(regex);
System.out.println("b1:"+b1);
//2.验证手机号：1开头，第二位：3/5/8，剩下9位都是0-9的数字
regex = "1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d";
str = "13800138000";//true
str = "23800138000";//false
str = "138001380001";//false
str = "13800138a00";//false
boolean b2 = str.matches(regex);
System.out.println("b2:"+b2);
//3.验证字符串是否以h开头，以d结尾，中间是任何字符
regex = "h.d";
str = "h&d";//true
str = "h中d";//true
str = "1Ad";//false
boolean b3 = str.matches(regex);
System.out.println("b3:"+b3);
//4.验证str是否是:had.
//注意: .不是任意字符,就是一个普通的.需要使用转义字符把有特殊含义的.转换为普通的.
//注意:当.作为正则表达式规则的时候才需要转移,如果单纯的当做字符串操作,就是普通的字符.
regex = "had\\.";
str = "hadA";//false
str = "had.";//true
boolean b4 = str.matches(regex);
System.out.println("b4:"+b4);
}
}
5. 正则表达式-数量词
package com.itheima.demo04Regex;
/*
正则表达式-数量词
语法示例：
1. X? : x出现的数量为 0次或1次
2. X* : x出现的数量为 0次到多次 任意次
3. X+ : x出现的数量为 1次或多次 X>=1次
4. X{n} : x出现的数量为 恰好n次 X=n次
5. X{n,} : x出现的数量为 至少n次 X>=n次
6. X{n,m}: x出现的数量为 n到m次(n和m都是包含的) n=
public class Demo05Regex {
public static void main(String[] args) {
String str = "";//false
str = "123";//true
str = "1234";//false
//1.验证str是否是三位数字
String regex = "\\d{3}";
boolean b1 = str.matches(regex);
System.out.println("b1:"+b1);
//2.验证str是否是多位数字:1次以上的数字
regex = "\\d+";
str = "12312413221312";//true
str = "1";//true
str = "";//false
str = "111a";//false
boolean b2 = str.matches(regex);
System.out.println("b2:"+b2);
//3.验证str是否是手机号:1开头，第二位：3/5/8，剩下9位都是0-9的数字
regex = "1[358]\\d{9}";
str = "13800138000";//true
str = "1380013800a0";//false
boolean b3 = str.matches(regex);
System.out.println("b3:"+b3);
//4.验证小数:必须出现小数点，但是只能出现1次
System.out.println(d);
regex = "\\d*\\.\\d+";
str = "1.1";//true
str = ".1";//true
str = "1.";//true
str = "aa.1";
str = "1.1.1";
boolean b4 = str.matches(regex);
System.out.println("b4:"+b4);
//5.验证小数：小数点可以不出现，也可以出现1次
regex = "\\d*\\.?\\d*";
str = "10000";//true
str = "10000.13213123";//true
str = ".1212312";//true
str = "";//true
str = "a";//false
str = "a";//false
str = "11..11";//false
boolean b5 = str.matches(regex);
System.out.println("b5:"+b5);
//6.验证qq号码：1).5--15位；2).全部是数字;3).第一位不是0
regex = "[1-9]\\d{4,14}";
str = "11111";//true
str = "111";//false
str = "111111a";//false
boolean b7 = str.matches(regex);
System.out.println("b7:"+b7);
}
}
6.正则表达式-分组括号( )
package com.itheima.demo04Regex;
/*
正则表达式-分组括号( )
*/
public class Demo06Regex {
public static void main(String[] args) {
//校验字符串"abc"可以出现任意次
String regex = "(abc)*";
boolean b1 = str.matches(regex);
String str = "abc";//true
str = "";//true
str = "abcabc";//true
str = "abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc";//true
str = "abcaaabbbccc";//false
System.out.println("b1:"+b1);
str = "DG8FV-B9TKY-FRT9J-99899-XPQ4G";//b2:true
str = "DG8FV-B9TKY-FRT9J-99899-XPQ4G-";//b2:false
//验证这个序列号：分为5组，每组之间使用-隔开，每组由5位A-Z或者0-9的字符组成
regex = "([A-Z0-9]{5}-){4}[A-Z0-9]{5}";
boolean b2 = str.matches(regex);
System.out.println("b2:"+b2);
}
}
7.String类中和正则表达式相关的方法
package com.itheima.demo04Regex;
/*
String类中和正则表达式相关的方法
boolean matches(String regex) 判断字符串是否匹配给定的正则表达式。
String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
String replaceAll(String regex, String replacement)把满足正则表达式的字符串,替换为新的字符串
*/
public class Demo07Regex {
public static void main(String[] args) {
show04();
}
/*
String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
*/
private static void show01() {
String s = "11-22-33-44-55";
String[] arr = s.split("-");
for (String str : arr) {
System.out.println(str);
}
}
//正则表达式中.代表任意字符串
private static void show02() {
String s = "192.168.1.100";
String[] arr = s.split("\\.");
System.out.println(arr.length);
for (String str : arr) {
System.out.println(str);
}
}
private static void show03() {
String s = "192 168 1 100";
s = "192 168 1 100";
String[] arr = s.split(" +");//根据一个空格或者多个连续的空格切割字符串
System.out.println(arr.length);
for (String str : arr) {
System.out.println(str);
}
}
/*
String replaceAll(String regex, String replacement)把满足正则表达式的字符串,替换为新的字符串
*/
public static void show04(){
String s = "12312asfdsa12123asa11c1fzvs1v*&&3242fsfa11";
System.out.println("原字符串:"+s);
//需求:使用replaceAll方法把字符串中每一个数字替换为@_@
String reg = "\\d";
String s1 = s.replaceAll(reg, "@_@");
System.out.println("替换后的字符串:"+s1);
//需求:使用replaceAll方法把字符串中的连续的数字替换为@_@
reg = "\\d+";
String s2 = s.replaceAll(reg,"@_@");
System.out.println("替换后的字符串:"+s2);
}
}
8.正则表达式生成网址:
https://www.sojson.com/regex/generate
三.Base64加密和解密(JDK8的新特性)
java.util.Base64
该类仅由用于获得Base64编码方案的编码器和解码器的静态方法组成。
作用:
使用Base64里边的编码器对数据进行编码(加密)
使用Base64里边的解码器对数据进行解码(解密)
静态成员方法:
static Base64.Encoder getEncoder() 获取加密器
static Base64.Decoder getDecoder() 获取解密器
java.util.Base64.Encoder:是Base64的内部类,用于对数据进行加密
成员方法:(编码)
String encodeToString(byte[] src) 使用Base64编码方案将指定的字节数组编码为字符串。
java.util.Base64.Decoder:是Base64的内部类,用于对数据进行解密
成员方法:(解码)
byte[] decode(String src) 使用Base64编码方案将Base64编码的字符串解码为新分配的字节数组。
public class Demo01Base64 {
public static void main(String[] args) {
String s1 = "国家的绝密文件!";
System.out.println("原字符串:"+s1);//原字符串:国家的绝密文件!
//使用加密器Encoder中的方法encodeToString把字符串进行加密
String s2 = Base64.getEncoder().encodeToString(s1.getBytes());
System.out.println("加密后的字符串:"+s2);//加密后的字符串:5Zu95a6255qE57ud5a+G5paH5Lu2IQ==
//使用解密器Decoder中的方法decode把加密后的字符串进行解密
byte[] bytes = Base64.getDecoder().decode(s2);
String s3 = new String(bytes);
System.out.println("解密后的字符串:"+s3);
}
}