JavaSE（Lombok、枚举、JDK8新特性、正则表达式）

已于 2022-01-20 21:49:12 修改
阅读量885 收藏 1
点赞数 1
分类专栏： java
于 2021-12-01 16:19:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50648720/article/details/121645683
版权

Lombok 枚举 方法引用 Base64 正则表达式
关键词由CSDN通过智能技术生成

JavaSE

Lombok

Lombok的使用

lombok介绍：

  • lombok可以使用注解的方式让一些代码变的简洁 方便
  • 实体类中有一些固定的代码：构造方法，getter/setter、equals、hashcode、toString方法都是固定的，写出来看着比较麻烦。而Lombok能通过注解的方式，在编译时自动为属性生成这些代码。

lombok使用：

​ 1. 添加lombok的jar包：

将lombok.jar(本例使用版本：1.18.10)，添加到模块目录下，并添加到ClassPath

​ 2. 为IDEA添加lombok插件（**连接网络使用）

安装完毕后，重启IDEA。

lombok常用注解

  • @Getter和@Setter

    • 作用：生成成员变量的get和set方法。
    • 写在成员变量上，指对当前成员变量有效。
    • 写在类上，对所有成员变量有效。
    • 注意：静态成员变量无效。

  • @ToString：

    • 作用：生成toString()方法。
    • 该注解只能写在类上。

  • @NoArgsConstructor和@AllArgsConstructor

    • @NoArgsConstructor：无参数构造方法。
    • @AllArgsConstructor：满参数构造方法。
    • 注解只能写在类上。

  • @EqualsAndHashCode

    • 作用：生成hashCode()和equals()方法。
    • 注解只能写在类上。

  • @Data

    • 作用： 生成setter/getter、equals、canEqual、hashCode、toString方法，如为final属性，则不会为该属性生成setter方法。

    • 注解只能写在类上。

枚举

枚举的概述和定义

不使用枚举存在的问题

假设要定义一个人类，人类中包含姓名和性别。通常会将性别定义成字符串类型，效果如下：

public class Person {
    private String name;
    private String sex;

    public Person() {
    }

    public Person(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }
	
    // 省略get/set/toString方法
}

public class Demo01 {
    public static void main(String[] args) {
        Person p1 = new Person("小明", "男");
        Person p2 = new Person("小明", "abc"); // 因为性别是字符串,所以我们可以传入任意字符串
    }
}

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

枚举的概念

枚举是一种引用数据类型，java中的枚举是有固定个数对象的"特殊类"。如果有些类的对象是固定个数的，就可以定义成枚举。比如性别、季节、方向。

定义枚举的格式

public enum 枚举名 {
    // 第一行都是罗列枚举实例,这些枚举实例直接写大写名字即可。
    实例,实例,实例,...；
}

public enum Sex {
   BOY, GIRL; 
}

public enum Season {
    SPRING, SUMMER, AUTUMN, WINTER;
}

public enum Direction{ 
    UP, RIGHT, DOWN, LEFT;
}

枚举的使用

  1. 定义枚举：BOY表示男，GIRL表示女
enum Sex {
    BOY, GIRL; // 男，女
}
  1. Perosn中的性别有String类型改为Sex枚举类型
public class Person {
    private String name;
    private Sex sex;

    public Person() {
    }

    public Person(String name, Sex sex) {
        this.name = name;
        this.sex = sex;
    }
    // 省略get/set/toString方法
}
  1. 使用是只能传入枚举中的固定值
public class Demo02 {
    public static void main(String[] args) {
        // 使用枚举格式: 枚举类型.枚举值
        Person p1 = new Person("小明", Sex.BOY);
        Person p2 = new Person("小明", Sex.GIRL);
        Person p3 = new Person("小明", "abc");// 编译报错
    }
}

枚举的其他内容

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

枚举的本质是一个类，我们刚才定义的Sex枚举最终效果如下：

public enum Sex {
    BOY, GIRL; // 男，女
}

public enum Sex {
    BOY(18), GIRL(16);

    public int age;

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

    public void showAge() {
        System.out.println("年龄是: " + age);
    }
}

public class Demo03 {
    public static void main(String[] args) {
        Person p1 = new Person("小明", Sex.BOY);
        Person p2 = new Person("小明", Sex.GIRL);

        Sex.BOY.showAge();
        Sex.GIRL.showAge();
    }
}

运行效果：
在这里插入图片描述

JDK8新特性

方法引用

方法引用概述

  • 方法引用使用一对冒号 :: , 方法引用就是用来在一定的情况下,替换Lambda表达式

方法引用基本使用

  • 使用场景：
    • 如果一个Lambda表达式大括号中的代码和另一个方法中的代码一模一样，那么就可以使用方法引用把该方法引过来，从而替换Lambda表达式
    • 如果一个Lambda表达式大括号中的代码就是调用另一方法，那么就可以使用方法引用把该方法引过来，从而替换Lambda表达式
public class Demo {

    public static void printStr(){
        System.out.println("任务执行了...");
    }

    public static void main(String[] args) {
        // 创建线程并启动线程
        // 1.匿名内部类的方式
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("任务执行了...");
            }
        }).start();

        // 2.Lambda表达式的方式
        new Thread(()->{System.out.println("任务执行了...");}).start();// 这个Lambda表达式大括号中的代码和Demo类的printStr()方法一模一样,符合方法引用替换Lambda表达式的场景

        new Thread(()->{Demo.printStr();}).start();// 这个Lambda表达的大括号中其实就是调用Demo类的printStr()方法,符合方法引用替换Lambda表达式的场景
        
	    // 3.方法引用的方式:
        new Thread(Demo::printStr).start();
    }
}

方法引用的分类

构造方法引用

public class Test2 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        list.add("小明");
        list.add("小红");
        list.add("小白");

        // 需求: 把集合中的元素转换为Person对象,打印输出
        list.stream().map(s-> new Person(s)).forEach(s-> System.out.println(s));

        System.out.println("======================");
       
        list.stream().map(Person::new).forEach(s-> System.out.println(s));
	
    }
}

静态方法引用

public class Test2 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        list.add("110");
        list.add("111");
        list.add("112");

        // 需求:把集合中的元素转换为int类型,打印输出
        list.stream().map(s-> Integer.parseInt(s)).forEach(s-> System.out.println(s));

        System.out.println("======================");

        list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));

    }
}

对象成员方法引用

  • 成员方法有参数

    public class Test2 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        list.add("小明");
        list.add("小红");
        list.add("小白");

        // 需求:把集合中所有元素打印输出
        list.stream().forEach(s-> System.out.println(s));

        System.out.println("=================================");
        
        list.stream().forEach(System.out::println);

    }
}

类的成员方法引用

  • 成员方法没有参数
    public class Test2 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        list.add("小明");
        list.add("小红");
        list.add("小白");

        // 需求: 把集合中的元素转换为该元素对应的字符长度,打印输出
        list.stream().map(s->s.length()).forEach(System.out::println);

        System.out.println("=================================");
		//会默认的用参数s去调用String类中的length()方法
        list.stream().map(String::length).forEach(System.out::println);

    }
}

Base64

Base64概述

  • Base64是jdk8提出的一个新特性,可以用来进行按照一定规则编码和解码

Base64编码和解码的相关方法

  • 编码的步骤:

    • 获取编码器
    • 调用方法进行编码

  • 解码步骤:

    • 获取解码器
    • 调用方法进行解码

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

    • **基本：**输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。
    • **URL：**输出映射到一组字符A-Za-z0-9+_，输出是URL和文件。
    • **MIME：**输出隐射到MIME友好格式。输出每行不超过76字符，并且使用’\r’并跟随’\n’作为分割。编码输出最后没有行分割。

  • 获取编码器和解码器的方法

    static Base64.Decoder getDecoder() 基本型 base64 解码器。
static Base64.Encoder getEncoder() 基本型 base64 编码器。

static Base64.Decoder getMimeDecoder() Mime型 base64 解码器。
static Base64.Encoder getMimeEncoder() Mime型 base64 编码器。

static Base64.Decoder getUrlDecoder() Url型 base64 解码器。
static Base64.Encoder getUrlEncoder() Url型 base64 编码器。

  • 编码和解码的方法:

    Encoder编码器:  encodeToString(byte[] bys)编码
Decoder解码器:  decode(String str) 解码

案例演示

  • 基本
public class Test1 {
    public static void main(String[] args) {
        // 使用基本型的编码器和解码器对数据进行编码和解码:
        // 1.获取编码器
        Base64.Encoder encoder = Base64.getEncoder();

        // 2.对字符串进行编码
        String str = "name=xx?password=123456";
        String str1 = encoder.encodeToString(str.getBytes());

        // 3.打印输出编码后的字符串
        System.out.println("编码后的字符串:"+str1);

        // 4.获取解码器
        Base64.Decoder decoder = Base64.getDecoder();

        // 5.对编码后的字符串进行解码
        byte[] bys = decoder.decode(str1);
        String str2 = new String(bys);

        // 6.打印输出解码后的字符串
        System.out.println("解码后的字符串:"+str2);
    }
}
  • URL
public class Test2 {
    public static void main(String[] args) {

        // 使用URL型的编码器和解码器对数据进行编码和解码:
        // 1.获取编码器
        Base64.Encoder encoder = Base64.getUrlEncoder();

        // 2.对字符串进行编码
        String str = "name=xx?password=123456";
        String str1 = encoder.encodeToString(str.getBytes());

        // 3.打印输出编码后的字符串
        System.out.println("编码后的字符串:"+str1);

        // 4.获取解码器
        Base64.Decoder decoder = Base64.getUrlDecoder();

        // 5.对编码后的字符串进行解码
        byte[] bys = decoder.decode(str1);
        String str2 = new String(bys);

        // 6.打印输出解码后的字符串
        System.out.println("解码后的字符串:"+str2);
    }
}
  • MIME
public class Test3 {
    public static void main(String[] args) {
        // 使用MIME型的编码器和解码器对数据进行编码和解码:
        // 1.获取编码器
        Base64.Encoder encoder = Base64.getMimeEncoder();

        // 2.对字符串进行编码
        String str = "";
        for (int i = 0; i < 100; i++) {
            str += i;
        }
        System.out.println("编码前的字符串:"+str);

        String str1 = encoder.encodeToString(str.getBytes());

        // 3.打印输出编码后的字符串
        System.out.println("编码后的字符串:"+str1);

        // 4.获取解码器
        Base64.Decoder decoder = Base64.getMimeDecoder();

        // 5.对编码后的字符串进行解码
        byte[] bys = decoder.decode(str1);
        String str2 = new String(bys);

        // 6.打印输出解码后的字符串
        System.out.println("解码后的字符串:"+str2);
    }
}

正则表达式

正则表达式的概念及演示

  • 概述：正则表达式其实就是一个匹配规则，用来替换之前复杂的if结构判断

  • 在Java中，经常需要验证一些字符串，是否符合规则，例如：校验qq号码是否正确，手机号码是否正确，邮箱是否正确等等。那么如果使用if就会很麻烦，而正则表达式就是用来验证各种字符串的规则。它内部描述了一些规则，可以验证用户输入的字符串是否匹配这个规则。

  • 先看一个不使用正则表达式验证的例子：下面的程序让用户输入一个QQ号码，我们要验证：

    • QQ号码必须是5–15位长度
    • 而且必须全部是数字
    • 而且首位不能为0
public class Demo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入你的QQ号码：");
		String qq = sc.next();
		
		System.out.println(checkQQ(qq));
	}
	//自己编写代码，验证QQ号码
	private static boolean checkQQ(String qq) {
		//1.验证5--15位
		if(qq.length() < 5 || qq.length() > 15){
			return false;
		}
		//2.必须都是数字；
		for(int i = 0;i < qq.length() ; i++){
			char c = qq.charAt(i);
			if(c < '0' || c > '9'){
				return false;
			}
		}
		//3.首位不能是0；
		char c = qq.charAt(0);
		if(c == '0'){
			return false;
		}
		return true;//验证通过
	}
	
}
  • 使用正则表达式验证：
public class Demo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入你的QQ号码：");
		String qq = sc.next();
		
		System.out.println(checkQQ2(qq));
	}
	//使用正则表达式验证
	private static boolean checkQQ2(String qq){
		String regex = "[1-9]\\d{4,14}";//正则表达式
		return qq.matches(regex);
	}
}

上面程序checkQQ2()方法中String类型的变量regex就存储了一个"正则表达式 "，而这个正则表达式就描述了需要的三个规则。matches()方法是String类的一个方法，用于接收一个正则表达式，并将"本对象"与参数"正则表达式"进行匹配，如果本对象符合正则表达式的规则，则返回true，否则返回false。

正则表达式的基本使用

正则表达式-字符类

  • 语法示例：[] 表示匹配单个字符 ^ 取反 - 范围

    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 Test1 {
    public static void main(String[] args) {
        String str = "ead";
        //1.验证str是否以h开头，以d结尾，中间是a,e,i,o,u中某个字符
        System.out.println(str.matches("h[aeiou]d"));// false
        System.out.println("hed".matches("h[aeiou]d"));// true
        System.out.println("heod".matches("h[aeiou]d"));// false
        System.out.println("==========================================");

        //2.验证str是否以h开头，以d结尾，中间不是a,e,i,o,u中的某个字符
        System.out.println(str.matches("h[^aeiou]d"));// false
        System.out.println("hed".matches("h[^aeiou]d"));// false
        System.out.println("hbd".matches("h[^aeiou]d"));// true
        System.out.println("==========================================");

        //3.验证str是否a-z的任何一个小写字符开头，后跟ad
        System.out.println(str.matches("[a-z]ad"));// true
        System.out.println("Aad".matches("[a-z]ad"));// false
        System.out.println("==========================================");

        //4.验证str是否以a-d或者m-p之间某个字符开头，后跟ad
        System.out.println(str.matches("[a-dm-p]ad"));//false
        System.out.println("bad".matches("[a-dm-p]ad"));// true
        System.out.println("nad".matches("[a-dm-p]ad"));// true

    }
}

正则表达式-逻辑运算符

  • 语法示例：

    1. &&：并且
    2. | ：或者

  • 代码示例：

public class Test2 {
    public static void main(String[] args) {
       
        String str = "had";
        //1.要求字符串是小写辅音字符开头，后跟ad  除了a,e,i,o,u之外,其他的都是辅音字母
        System.out.println(str.matches("[a-z&&[^aeiou]]ad"));// true
        System.out.println("aad".matches("[a-z&&[^aeiou]]ad"));// false
        System.out.println("Aad".matches("[a-z&&[^aeiou]]ad"));// false
        System.out.println("========================");

        //2.要求字符串是aeiou中的某个字符开头，后跟ad
        System.out.println(str.matches("[aeiou]ad"));// false
        System.out.println(str.matches("[a|e|i|o|u]ad"));// false

        System.out.println("aad".matches("[aeiou]ad"));// true
        System.out.println("aad".matches("[a|e|i|o|u]ad"));// true
    }
}

正则表达式-预定义字符

  • 语法示例：
    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 Test3 {
    public static void main(String[] args) {
        
        String str = "258";
        //1.验证str是否3位数字
        System.out.println(str.matches("\\d\\d\\d"));// true
        System.out.println("25".matches("\\d\\d\\d"));// false
        System.out.println("+===================================");

        //2.验证手机号：1开头，第二位：3/5/8，剩下9位都是0-9的数字
        System.out.println(str.matches("1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d"));// false
        System.out.println("13838381234".matches("1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d"));// true
        System.out.println("14838381234".matches("1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d"));// false
        System.out.println("+===================================");

        //3.验证字符串是否以h开头，以d结尾，中间是任何字符
        System.out.println(str.matches("h.d"));// false
        System.out.println("h%d".matches("h.d"));// true
        System.out.println("h#d".matches("h.d"));// true
        System.out.println("+===================================");

        //4.验证str是否是：h.d
        System.out.println("h.d".matches("h.d"));// true
        System.out.println("had".matches("h.d"));// true

        System.out.println("h.d".matches("h\\.d"));// true
        System.out.println("had".matches("h\\.d"));// false

    }
}

正则表达式-数量词

  • 语法示例：
    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 Test4 {
    public static void main(String[] args) {
        
        //1.验证str是否是三位数字
        System.out.println("123".matches("\\d{3}"));// true
        System.out.println("12".matches("\\d{3}"));// false
        System.out.println("1234".matches("\\d{3}"));// false
        System.out.println("===================================");

        //2.验证str是否是多位数字
        System.out.println("12".matches("\\d{2,3}"));// true
        System.out.println("123".matches("\\d{2,3}"));// true
        System.out.println("1223".matches("\\d{2,3}"));// false

        System.out.println("1".matches("\\d+"));// true
        System.out.println("12".matches("\\d+"));// true
        System.out.println("123".matches("\\d+"));// true
        System.out.println("1234".matches("\\d+"));// true
        System.out.println("===================================");

        //3.验证str是否是手机号：1).第一位为1 2).第二位是3,5,8 3).后面9位都是数字
        System.out.println("13838381234".matches("1[358]\\d{9}"));// true
        System.out.println("14838381234".matches("1[358]\\d{9}"));// false
        System.out.println("===================================");

        //4.验证qq号码：1).5--15位；2).全部是数字;3).第一位不是0
        System.out.println("123456".matches("[1-9]\\d{4,14}"));// true
        System.out.println("023456".matches("[1-9]\\d{4,14}"));// false
        System.out.println("123".matches("[1-9]\\d{4,14}"));// false
    }
}

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

public class Test5 {
    public static void main(String[] args) {
        /*
            正则表达式-分组括号( )
         */
        String str = "DG8FV-B9TKY-FRT9J-99899-XPQ4G";
        // 分成5组: 前面4组的规则是一样的 后面一组单独规则
        System.out.println(str.matches("([A-Z0-9]{5}-){4}[A-Z0-9]{5}"));
        // xxyy
        // \\1表示第一组 {1}表示第一组再出现一次   \\2表示第二组  {1}表示第二组再出现一次
        System.out.println("呵呵哈哈".matches("(.)\\1{1}(.)\\2{1}"));// true
        System.out.println("呵呵呵哈哈哈".matches("(.)\\1{1}(.)\\2{1}"));// false
        System.out.println("呵呵呵哈哈哈".matches("(.)\\1{2}(.)\\2{2}"));// true
    }
}

String中正则表达式的使用

String的split方法中使用正则表达式

  • String类的split()方法原型：
    public String[] split(String regex)//参数regex就是一个正则表达式。可以将当前字符串中匹配regex正则表达式的符号作为"分隔符"来切割字符串。
  • 代码示例：
public class Demo {
	public static void main(String[] args) {
		String str = "18  4 567       99     56";
		String[] strArray = str.split(" +");
		for (int i = 0; i < strArray.length; i++) {
			System.out.println(strArray[i]);
		}
	}
}

String类的replaceAll方法中使用正则表达式

  • String类的replaceAll()方法原型：
public String replaceAll(String regex,String newStr)//参数regex就是一个正则表达式。可以将当前字符串中匹配regex正则表达式的字符串替换为newStr。
  • 代码示例：
public class Demo {
    public static void main(String[] args) {
        //将下面字符串中的"数字"替换为"*"
        String str = "jfdk432jfdk2jk24354j47jk5l31324";
        System.out.println(str.replaceAll("\\d+", "*"));
    }
}
荞澳
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSe系列二十七: Java正则表达式
07-08
JavaSe系列二十七: Java正则表达式
JDK1.8(JavaSE1.8/JDK8)
12-10
首先，让我们关注JDK8中的核心特性之一——Lambda表达式。Lambda表达式是函数式编程的一种体现，它使得编写简洁、易读的代码成为可能，特别是在处理集合和多线程时。通过Lambda表达式，我们可以将匿名函数作为参数...
推荐两款java开发实用工具 hutool 和 lombok
evelynnJava的博客
04-21 1608
hutool工具 hutool官方网址 摘抄一段hutool工具的简介: Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，是项目中“util”包友好的替代，它节省了开发人员对项目中公用类和公用工具方法的封装时间，使开发专注于业务。 安装使用: 首先在maven项目的pom.xml的dependencies中加入以下内容: <dependency> <groupId>cn.hutool</groupId> <ar
Java枚举类使用Lombok
热门推荐
心之所往 码之所向
06-12 1万+
枚举类是一个特殊的常量类，由于其特殊的设计，具有简洁性、安全性以及便捷性，在开发中被普遍使用。本文简单介绍一下如何使用Lombok进行枚举类定义。
好家伙！JDK16 GA 终于发布，内置 Lombok 的功能，真的顶？
芋艿V
03-18 1223
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 8:55 更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2020 超神之路，很肝~中...
java Lombok使用
qq_42572322的博客
07-19 125
通过注解的方式添加getter/setter方法，添加构造器，添加equals等方法。Lombok是java的一个库，能自动插入编辑器并构建工具，简化java开发。//getter,setter，tostring等方法。
Java8新特性【函数式编程API、新时间日期处理API、Optional容器类】总结
欢迎来到编程小栈
12-03 1090
文章目录1、Lambda表达式1.1什么是Lambda表达式1.2从匿名类到 Lambda 的转换1.3Lambda表达式语法2、函数式接口2.1什么是函数式接口2.2自定义函数式接口2.3内置核心函数式接口2.4接口中常用的默认方法3、方法引用与构造器引用3.1 推荐用法3.2 基本格式3.3 语法详解(了解)3.3.1引用类的静态方法3.3.2 引用对象的实例方法3.3.4 引用类的实例方法3.3.5 构造器引用4、Stream API4.1什么是Stream4.2Stream操作的三个步骤4.2.1创
随记、三个小知识点（枚举、set、lombok）
ITw333的博客
09-25 2942
1.枚举类的一个用法： public enum OrderStatusEnum{ CANCELED(0,"已取消"), NO_PAY(10,"未支付"), PAID(20,"已付款"), SHIPPED(40,"已发货"), ORDER_SUCCESS(50,"订单完成"), ORDER_CLOSE(60,"订单关闭"); Or
java8新特性Lambda表达式
最新发布
05-23
想要快速了解并掌握Lambda表达式的可以学习
JavaSE6新特性:Instrumentation新功能
03-04
Instrumentation简介Instrumentation的基本功能和用法JavaSE6的新特性：虚拟机启动后的动态instrumentJavaSE6新特性：本地方法的InstrumentationJavaSE6新特性：BootClassPath/SystemClassPath的动态增补结语参考...
lombok的使用
chenjianhuideyueding的博客
12-26 374
lombok其实可以算是一个小型的插件，它的使用要有两个条件（我使用的是idea工具）： 1、安装lombok插件 2、引入lombok的jar包 安装： ctrl+alt+s先打开setting界面，然后搜索plugins: 点击Plugins,然后点击Browse Repositories...,在弹出框中输入：lombok 然后点击右边安装即可。 注意有的时候在线安装会...
使用Spring Boot和Lombok创建通用返回类和状态码枚举
melck的博客
09-20 490
通过引入Lombok依赖并使用注解，我们能够快速生成通用返回类的代码，包括数据、消息和状态码。同时，通过定义状态码枚举类，我们能够统一管理常见的状态码和对应的消息。通过以上示例代码，我们可以看到，创建通用返回类和状态码枚举能够帮助我们简化开发过程并提高代码的可读性。为了简化这个过程，我们可以使用Spring Boot框架和Lombok库来创建一个通用的返回类和状态码枚举。使用这两个通用类，我们可以在Spring Boot项目中快速创建统一的返回格式，并且使用统一的状态码来表示请求结果。
【Java】【正则表达式】正则表达式
天天向上 Up Up Up (*^▽^*)
11-24 475
package _09_regex; import java.util.Scanner; import java.util.regex.Pattern; import com.easing.commons.util.format.TextUtil; import lombok.Cleanup; public class _01_Regex { public static void ...
【Java】lombok 枚举 tostring()方法 Bug
u010900754的专栏
10-25 4109
今天发现一个诡异的问题，一个枚举类使用lombok加上tostring注解以后，枚举tostring方法返回是异常的。 @ToString public enum WORD { A,B,C } public static void main(String args[]) { System.out.println(WORD.A.toString()); ...
Lombok 常用注解
m0_53067943的博客
07-26 501
主演总结了Lombok的常用注解
Lombok 注解及使用大全
demo_yo的博客
07-11 1562
一、Lombok 注解大全 优点： 能通过注解的形式自动生成构造器、getter / setter、equals、hashcode、toString 等方法，提高了一定的开发效率，让代码变得简洁，不用过多的去关注相应的方法。 属性做修改时，也简化了维护为这些属性所生成的 getter / setter 方法等。缺点： 不支持多种参数构造器的重载。 虽然省去了手动创建一系列方法的麻烦，但大大降低了源代码的可读性和完整性，降低了阅读源代码的舒适度。.........
LomBok使用讲解
Happy_lifer的博客
06-13 3313
当我调试程序项目代码到调用Mybatis的插入SQL对应的方法的时候时，我看到NMetaVerify对象的nMetaType属性还是有数据的，但是执行插入之后，数据库的nMetaType就是一直是null，原先我以为是我的枚举类型写法不正确，看了下别的同样具有枚举类型的细分，也是正常能插入到数据库当中的，这更让我感觉到疑惑了。可以以链的形式调用；顶级类Object⾥⾯的⽅法，所有类都是继承Object的，返回值int类型根据⼀定的hash规则(存储地址，字段，或者⻓度等)，映射成⼀个数值，即散列值。
hive 索爱_大数据
weixin_39892447的博客
12-21 148
第一阶段(Java基础高级)Java语言的高级特性静态导入、自动封箱拆箱、可变参数、增强for、枚举、类加载器、反射、内省、泛型、注解、动态代理回掌握Java语言的高级特性Java多线程多线程加强、线程池、Thread Local掌握Java线程池技术，掌握线程的Join、notify、notifyAll等机制XMLDom解析、Sax解析、Pull解析Schema基于Xml的解析与维护WebHtm...
lombok 中各种注解的基本使用方法
HeatDeath的博客
04-07 2491
val : 和 scala 中 val 同名, 可以在运行时确定类型; @NonNull : 注解在参数上, 如果该类参数为 null , 就会报出异常, throw new NullPointException(参数名) @Cleanup : 注释在引用变量前, 自动回收资源 默认调用 close() 方法 @Getter/@Setter : 注解在类上, 为类提供读写属性 @Gett...
掌握Java正则表达式：实战案例与高效验证
本文档深入浅出地讲解了JavaSE中的正则表达式用法及其在实际开发中的应用。首先，我们明确了学习正则表达式的重要性，它能够简化复杂的文本匹配任务，提高代码的效率和可读性。 在文档中，作者以验证QQ号码为例，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值