Java=枚举，正则表达式，JDK8新特性Base64

最新推荐文章于 2023-05-19 22:17:48 发布

hnbyboy

最新推荐文章于 2023-05-19 22:17:48 发布

阅读量824

点赞数 1

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/appandroid/article/details/105276248

版权

JAVA 专栏收录该内容

41 篇文章 0 订阅

订阅专栏

枚举

JDK8新特性-默认方法，Lambda，Stream流，方法引用，Base64用于字符串编码

正则表达式

一，枚举

1.不使用枚举存在的问题

public class TestPerson {
    public static void main(String[] args) {
        //1.创建对象
        Person p1 = new Person("张","xx");
        System.out.println(p1);
        //2.再创建对象
        Person p2 = new Person("王","xxx");
        System.out.println(p2);
        //此时,我们的性别由于是String类型,那么赋值任意的字符串均可
        //但是性别也有应该有要求,"男","女","xx"
        //这就是不使用枚举可能出现的问题
    }
}

不使用枚举存在的问题：可以给性别传入任意的字符串，导致性别是非法的数据，不安全。

2.枚举的作用与应用场景

枚举的作用：一个方法接收的参数是固定范围之内的时候，那么即可使用枚举。

枚举是一种特殊类。枚举是有固定实例个数的类型，我们可以把枚举理解成有固定个数实例的多例模式。

什么是枚举: 所谓的枚举就是把所有可能的情况一一
什么时候使用枚举: 当某个数据的值是固定有限的,那么我们就可以使用枚举把其值一一

3、枚举的基本语法

定义枚举的格式

public enum 枚举名{
    //枚举项
    枚举项1,枚举项2,...,枚举项n;
}

/**
 * 性别的枚举
 */
public enum Sex {
    /**
     * Male 男性
     * Female 女性
     * Qi 其性
     */
    Male,Female,Qi; 
}

案例：

public class Person {
    private String name;
    //以前的性别sex是String类型,导致任何值都可以
    //private String sex;
    //现在我们已经有枚举类型
    private Sex sex;
    public Person() {
    }
    public Person(String name, Sex sex) {
        this.name = name;
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Sex getSex() {
        return sex;
    }
    public void setSex(Sex sex) {
        this.sex = sex;
    }
}

public class TestPerson {
    public static void main(String[] args) {
        //1.创建对象
//        Person p1 = new Person("张","Qi");
        Person p1 = new Person("张",Sex.Male);
        System.out.println(p1);
        //2.再创建对象
//        Person p2 = new Person("王","xxx");
        Person p2 = new Person("王",Sex.Female);
        System.out.println(p2);
    }
}

枚举的本质：

枚举的本质是一个类，所以枚举中还可以有成员变量，成员方法等。

枚举的本质其实就是一个类,枚举项的本质其实当前类的一个对象
    /**
     * 性别的枚举
     */
    public enum Sex {
        Male,Female,Qi; 
    }

	本质===>
    public final class Sex extends java.lang.Enum<Sex>{
        public static final Sex Male = new Sex();
        public static final Sex Female = new Sex();
        public static final Sex Qi= new Sex();
        构造方法是私有化的
        private Sex(){}    
    }
枚举本质是一个类,那么我们就可以在枚举中添加各种成员变量,成员方法,构造方法等!!!
    成员变量和成员方法和普通类没有区别!!
    构造方法: a.必须是私有的 b.使用时 枚举项(参数);

	public enum Sex {
        Male(10),Female(20),Qi(30);
        //既然枚举是一个类,那么我们就可以添加我们喜欢的成员变量和成员方法和构造方法
        private int age;

        public void showAge(){
            System.out.println(age);
        }

        private Sex(){}

        private Sex(int age){
            this.age = age;
        }
}

应用场景等：

枚举的应用：枚举通常可以用于做信息的分类，如性别，方向，季度等。

枚举表示性别：
    public enum Sex { 
    	MAIL, FEMAIL; 
	}
枚举表示方向:
	public enum Orientation { 
        UP, RIGHT, DOWN, LEFT; 
    }
枚举表示季度:
	public enum Season { 
        SPRING, SUMMER, AUTUMN, WINTER; 
    }

总结：

枚举类在第一行罗列若干个枚举对象。（多例）

第一行都是常量，存储的是枚举类的对象。

枚举是不能在外部创建对象的，枚举的构造器默认是私有的。

枚举通常用于做信息的标志和分类。

二，JDK8新特性

1.方法的引用

所谓的方法引用,就是把已经存在的方法,直接拿过来用!!
当我们可以一个函数式接口类型赋值时,我们赋值该接口的实现类对象,
也可以赋值该接口的匿名内部类对象,也可以赋值符合接口的Lambda表达式,也可以使用方法引用

public class Dog {

    public static void bark() {
        System.out.println("方法执行了...汪汪汪..");
    }

    public void bark1() {
        System.out.println("方法执行了...汪汪汪..");
    }
}
public class MethodReferencesDemo {
    public static void main(String[] args) {
        //1.创建一个线程,使用实现的方法
        //a.使用接口的实现类对象,给Runnable接口类型赋值
        new Thread(new MyRunnable()).start();
        //b.使用接口的匿名内部类对象,给Runnable接口类型赋值
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程执行了...");
            }
        }).start();
        //c.使用Lambda,直接给Runnable接口类型赋值
        new Thread(()->System.out.println("线程执行了...")).start();
        //d.把已经存在的方法直接引用过来
        //new Thread(Dog::bark).start(); //通过类名引用静态方法
        Dog dd = new Dog();
        new Thread(dd::bark1).start(); //通过对象名引用成员方法
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("线程执行了...");
    }
}

方法引用基本使用格式：

通过类名引用其中的静态方法
    类名::静态方法名
通过对象引用其中的普通方法
    对象名::普通方法名
        
通过类名引用其构造方法:
	类名::new   Person o = new Person();
通过数组引用其构造方法:
	数据类型[]::new	  int[] arr = new int[10];

System.out.println这个方法引用

public class SystemOutPrintlnDemo {
    public static void main(String[] args) {
        List names = new ArrayList();
        names.add("大明");
        names.add("二明");
        names.add("小明");
        //.StreamAPI中
        names.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String o) {
                System.out.println(o);
            }
        });

        names.forEach(new Consumer<String>() {
            @Override
            public void accept(String o) {
                System.out.println(o);
            }
        });

        names.forEach(o -> System.out.println(o));

//        System.out.println("hello");
        names.forEach(System.out::println);
    }
}

2.Base64

一种常见的编码方案

Base64 是网络上最常见的用于传输 8Bit 字节码的编码方式之一， Base64 就是一种基于 64 个可打印字符来表示二进

制数据的方法。

在 Java 8 中， Base64 编码已经成为 Java 类库的标准。

Java 8 内置了 Base64 编码的编码器和解码器。

Base64 工具类提供了一套静态方法获取下面三种 BASE64 编解码器：

基本： 输出被映射到一组字符 A-Za-z0-9+/ ，编码不添加任何行标，输出的解码仅支持 A-Za-z0-9+/ 。

URL ：输出映射到一组字符 A-Za-z0-9+_ ，输出是 URL 和文件。

MIME ：输出隐射到 MIME 友好格式。输出每行不超过 76 字符，并且使用 '\r' 并跟随 '\n' 作为分割。编码输出最

后没有行分割。

Base64内嵌类和方法

static class Base64.Decoder 该类实现一个解码器用于，使用 Base64 编码来解码字节数据。

static class Base64.Encoder 该类实现一个编码器，使用 Base64 编码来编码字节数据

static Base64.Decoder getDecoder() 返回一个 Base64.Decoder ，解码使用基本型 base64 编码方案。

static Base64.Encoder getEncoder() 返回一个 Base64.Encoder ，编码使用基本型 base64 编码方案。

static Base64.Decoder getMimeDecoder() 返回一个 Base64.Decoder ，解码使用 MIME 型base64 编码方案。

static Base64.Encoder getMimeEncoder() 返回一个 Base64.Encoder ，编码使用 MIME 型base64 编码方案。

static Base64.Encoder getMimeEncoder(int lineLength, byte[] lineSeparator) 返回一个Base64.Encoder ，编码使用 MIME 型 base64 编码方案，可以通过参数指定每行的长度及行的分隔符。

static Base64.Decoder getUrlDecoder() 返回一个 Base64.Decoder ，解码使用 URL 和文件名安全型 base64 编码方案。

static Base64.Encoder getUrlEncoder() 返回一个 Base64.Encoder ，编码使用 URL 和文件名安全型 base64 编码方案。

注意： Base64 类的很多方法从 java.lang.Object 类继承。

Decoder和Encoder
UrlDecoder和UrlEncoder
MimeDecoder和MimeDecoder

String encodeToString(byte[] bs); //编码  
byte[] decode(String str);//解码

示例Coding：

public class Base64Demo {
    public static void main(String[] args) {
        //1.Base64提供了三种编码器和解码器
        //a.基本的编码和解码
        String encodeToString = Base64.getEncoder().encodeToString("HelloWorld".getBytes());
        System.out.println(encodeToString);

        byte[] bytes = Base64.getDecoder().decode(encodeToString);
        System.out.println(new String(bytes));


        //b.url的编码和解码
        String encodeToString1 = Base64.getUrlEncoder().encodeToString("www.baidu.com".getBytes());
        System.out.println(encodeToString1);

        byte[] bs1 = Base64.getUrlDecoder().decode(encodeToString1);
        System.out.println(new String(bs1));

        //c.MIME类型编码器和解码器
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10; i++) {
            UUID uuid = UUID.randomUUID();
            sb.append(uuid.toString());
        }
        String content = sb.toString();

//        String encodeToString2 = Base64.getMimeEncoder().encodeToString(content.getBytes());
//        System.out.println(encodeToString2);
        String encodeToString2 = Base64.getMimeEncoder(8,"-".getBytes()).encodeToString(content.getBytes());
        System.out.println(encodeToString2);

        byte[] bs2 = Base64.getMimeDecoder().decode(encodeToString2);
        System.out.println(new String(bs2));
    }
}

三,正则表达式

正则也是一个字符串,但是里面内容表示某种规则(规则是有具体语法含义)

在 Java 中，我们经常需要验证一些字符串，例如：年龄必须是 2 位的数字、用户名必须是 8 位长度而且只能包

含大小写字母、数字等。正则表达式就是用来验证各种字符串的规则。它内部描述了一些规则，我们可以验

证用户输入的字符串是否匹配这个规则

1.正则表达式-字符类

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 TestDemo02 {
    public static void main(String[] args) {
        String str = "aad";
        //1.验证str是否以h开头，以d结尾，中间是a,e,i,o,u中某个字符
        System.out.println("1." + str.matches("h[aeiou]d"));
        //2.验证str是否以h开头，以d结尾，中间不是a,e,i,o,u中的某个字符
        System.out.println("2." + str.matches("h[^aeiou]d"));
        //3.验证str是否a-z的任何一个小写字符开头，后跟ad
        System.out.println("3." + str.matches("[a-z]ad"));
        //4.验证str是否以a-d或者m-p之间某个字符开头，后跟ad
        System.out.println("4." + str.matches("[a-dm-p]ad"));
    }
}

2. 正则表达式-逻辑运算符

1. &&：并且
2. | ：或者
    
/**
 * 正则表达式逻辑运算符类
 */
public class TestDemo03 {
    public static void main(String[] args) {
        String str = "bad";
        //1.要求字符串是否是除a、e、i、o、u外的其它小写字符开头，后跟ad
        System.out.println("1." + str.matches("[a-z&&[^aeiou]]ad"));
        //2.要求字符串是aeiou中的某个字符开头，后跟ad
        System.out.println("2." + str.matches("[a|e|i|o|u]ad"));
    }
}

3.正则表达式-预定义字符

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 TestDemo04 {
    public static void main(String[] args) {
        String str = "had.";
        //1.验证str是否3位数
        System.out.println("1." + str.matches("\\d\\d\\d"));
        //2.验证手机号：1开头，第二位：3/5/8，剩下9位都是0-9的数字
        System.out.println("2." + str.matches("1[3|5|8]\\d\\d\\d\\d\\d\\d\\d\\d\\d"));
        //3.验证字符串是否以h开头，以d结尾，中间是任何字符 str = "had";//要验证的字符串
        System.out.println("3." + str.matches("h.d"));
        //4.验证str是否是：had.
        System.out.println("4." + str.matches("had\\."));
    }
}

4.正则表达式-数量词

1. X? : 0次或1次 
2. X* : 0次到多次
3. X+ : 1次或多次
4. X{n} : 恰好n次 
5. X{n,} : 至少n次 
6. X{n,m}: n到m次(n和m都是包含的)
    
public class TestDemo05 {
    public static void main(String[] args) {
        String str = "221234567";
        //1.验证str是否是三位数字
        System.out.println("1." + str.matches("\\d{3}"));
        //2.验证str是否是2位数数字以及以上
        System.out.println("2." + str.matches("\\d{2,}"));
        //3.验证str是否是手机号： str = "13813183388";
        System.out.println("3." + str.matches("1[3|6|8]\\d{9}"));
        //4.验证小数:必须出现小数点，但是只能出现1次
        // 3.1  4.25 1314.1516
        System.out.println("4." + str.matches("\\d+\\.\\d+"));
        //5.验证小数：小数点可以不出现，也可以出现1次
        System.out.println("5." + str.matches("\\d+\\.?\\d+"));
        //6.验证小数：要求匹配：3、3.、3.14、+3.14、-3. s2 = "-3.";
        System.out.println("6." + str.matches("[+-]\\d+\\.?\\d*"));
        //7.验证qq号码：1).5--15位；2).全部是数字;3).第一位不是0
        System.out.println("7." + str.matches("[1-9]\\d{4,14}"));
    }
}

5.正则表达式-分组括号( )

/**
 * 正则表达式-分组()
 */
public class TestDemo06 {
    public static void main(String[] args) {
        String str = "DG8FV-B9TKY-FRT9J-99899-XPQ4G";
        //验证这个序列号：分为5组，每组之间使用-隔开，每组由5位A-Z或者0-9的字符组成
        System.out.println(str.matches("([A-Z0-9]{5}-){4}[A-Z0-9]{5}"));
    }
}

6. String的split方法

public String [] split ( String regex ) // 参数 regex 就是一个正则表达式。可以将当前字符串中匹配

regex 正则表达式的符号作为 " 分隔符 " 来切割字符串。

public String[] split(String regex); 可以使用正则表达式来切换字符串
    
/**
 * 正则表达式-split方法
 */
public class TestDemo07 {
    public static void main(String[] args) {
        String str = "18,,4,,,567,,,,99,56";
        //切割
        String[] nums = str.split(",+");
        //打印
        for (String num : nums) {
            System.out.println(num);
        }
    }
}

7.String类的replaceAll方法

public String replaceAll ( String regex , String newStr ) // 参数 regex 就是一个正则表达式。可以将当前字符串中匹配 regex 正则表达式的字符串替换为 newStr 。

public String replaceAll(String regex,String newStr);//将当前字符串中的旧串替换为新串,其他旧串可以使用正则去匹配
/**
 * 正则表达式-replaceAll
 */
public class TestDemo08 {
    public static void main(String[] args) {
        //将下面字符串中的"数字"替换为"*"
        String str = "jfdk432jfdk2jk24354j47jk5l31324";

        //将每个数字,都替换为一个*号
        String newStr1 = str.replaceAll("\\d", "*");
        System.out.println(newStr1);
        //将所有相邻的数字,只替换为一个*
        String newStr2 = str.replaceAll("\\d+", "*");
        System.out.println(newStr2);
    }
}

===================================

需求：请编写程序，完成叠词的替换，并测试。

字符串：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程

将字符串还原成:“我要学编程”。

    public static void main(String[] args) {
        String str ="我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";

        str = str.replaceAll("\\.", "");

        str = str.replaceAll("(.)\\1+", "$1");

        System.out.println(str);

    }

需求：1.验证给定的字符串全部由中文组成

2.提示：匹配中文字符的正则：[\u4e00-\u9fa5];方括号里面的两个数字表示中文在unicode编码表中对应的编号的起止位置；
 public static void main(String[] args) {
        String str = "吉吉老师";
        //注释：由于 ^ 为匹配输入字符串的开始位置
        //$为匹配输入字符串的结束位置
        //+ 代表一次或者多次
        boolean matches = str.matches("^[\\u4e00-\\u9fa5]+$");
        System.out.println(matches);
    }

参考：

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
Java=枚举，正则表达式，JDK8新特性Base64

枚举JDK8新特性-默认方法，Lambda，Stream流，方法引用，Base64用于字符串编码正则表达式一，枚举1.不使用枚举存在的问题public class TestPerson { public static void main(String[] args) { //1.创建对象 Person p1 = new Person...
复制链接

扫一扫