Java24注解，jdk1.8新特性

已于 2023-03-18 14:18:05 修改
阅读量235 收藏
点赞数
分类专栏： 初顾茅庐 文章标签： java mybatis spring
于 2022-11-04 19:40:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44207220/article/details/127583295
版权

注解

注解：解释代码的代码

常用的注解：

                @Override:重写

                @Deprecated:过时

                @SuppressWarnings("deprecation"):忽略警告

自定义注解

语法：

                访问权限修饰符 @ interface 注解名{

                                公共静态常量

                                注解属性

                }

1.注解的属性语法格式：

                        数据类型 属性名();

                        数据类型 属性名() default 默认值；

2.如果注解的属性没有默认值，使用注解时，必须给属性赋值

3.如果注解的属性有默认值，使用注解时，可以给该属性赋值，也可以使用默认值

4.注解属性的数据类型不能是集合

 

 

注解的使用

        注解下面要有代码的，没代码会报错 

@注解名(属性名1 = 属性值1,属性名2 =， 属性值2,属性名3 = {})

注意:

         1,可以不按照顺序赋值

         2,有默认值的属性可以不赋值

 不按顺序写可以，有默认值的也可以直接写

         3,如果注解中所有属性都有默认值或没有属性,此时可以省略()不写

        4,如果注解中有且只有一个value属性,在使用注解时,可以忽略属性名不写

                        如:

                        @注解名(值);

元注解

概念：解释注解的注解

常用的元注解：

                @Target：

                        作用：限定注解的使用范围

                        值：

                                 TYPE:可以在类上用

                                 FIELD:在属性上用

                                 METHOD:在方法上用

                                 PARAMETER:在形参上用

                                 CONSTRUCTOR:在构造函数上用

                                 ANNOTATION_TYPE:在定义注解时用

此时，此注解如果不在方法上使用就会报错

               注意：自定义一个注解不使用此注解时，可在任意位置使用

                @Retention

                        作用：限制器使用范围(在什么情况下使用)

                        值：

                                SOURCE:在java文件时可用

                                CLASS:编译为class文件可用

                                RUNTIME:程序运行时可用

                        注意：

                                自定义的注解默认是java文件时可用

                @Documented

                        作用:可以生成api文件

                @Inherited

                        作用:允许被继承

                         注意:不加是不被继承的

注解+反射

比如想改一个类的默认值     

import java.lang.reflect.Constructor;
import java.util.Arrays;
public class Cat {
	private String name;
	private int age;
	private String color;
	private String[] likeFood;
	public Cat(String name, int age, String color, String[] likeFood) {
		super();
		this.name = name;
		this.age = age;
		this.color = color;
		this.likeFood = likeFood;
	}
	@CatAnnotation(name = "小花",color = "花",age = 2)
	public Cat() throws NoSuchMethodException, SecurityException {
		super();	
		Class<Cat> c = Cat.class;//获取类对象	
		Constructor<Cat> con = c.getDeclaredConstructor();//获取无参构造函数		
		CatAnnotation annotation = con.getAnnotation(CatAnnotation.class);//获取注解传入		
		this.name = annotation.name();//获取注解中的属性值,并赋值给对应的属性
		this.age = annotation.age();
		this.color = annotation.color();
		this.likeFood = annotation.likeFood();
	}
	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;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public String[] getLikeFood() {
		return likeFood;
	}
	public void setLikeFood(String[] likeFood) {
		this.likeFood = likeFood;
	}
	@Override
	public String toString() {
		return "猫 名字" + name + ", 年龄：" + age + ", 颜色：" + color + ", 喜欢的食物=" + Arrays.toString(likeFood)
				+ "\n";
	}
}
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.CONSTRUCTOR)
public @interface CatAnnotation {
	String name() default "猫";
	int age() default 1;
	String color() default "黑";
	String[] likeFood() default {"老鼠","鱼"};
}

public class Test {
	public static void main(String[] args) throws NoSuchMethodException, SecurityException {
		Cat cat = new Cat();
		System.out.println(cat);
	}
}

 Jdk1.8新特性

函数式接口

简介：一个接口只有一个抽象方法，但是可以有多个非抽象方法。这种接口称为函数式接口 

注解：@FunctionalInterface,作用验证接口是否为函数式接口

系统提供的常见函数式接口

接口名返回值类型抽象方法分类
Consumer<t>voidaccept(T  t)消费型接口
Supplier<T>Tget()供给型接口
Function<T,R>Rapply(T  t)函数型接口
Predicate<T>booleantest(T t)断言型接口

 Lambda

简介：一种特殊的匿名内部类

优点：语法简洁，节省内存，不会生成class文件

缺点：太过简洁，对于新手来说可读性差

语法

TreeSet<String> set = new TreeSet<String>(new Comparator<String>() {
				@Override			
				public int compare(String o1, String o2) {
					
					return 0;
				}
		});

1，创建匿名内部类中只有一个方法，此时才能使用Lambda表达式

	TreeSet<String> set = new TreeSet<String>((String o1, String o2) -> {			
					return 0;		
		});

2，在Lambda表达式中，可以省略形参的数据类型

TreeSet<String> set = new TreeSet<String>((o1, o2) -> {			
					return o1.compareTo(o2);		
		});

3，在Lambda表达式中，当只有一个形参时可以忽略小括号不写

4，当代码块中只有一行代码时，可以省略大括号不写

public class Test03 {
	public static void main(String[] args) {
		MyInter inter = new MyInter() {		
			@Override
			public void tese(int num) {
				System.out.println("你好世界");
			}
		};//匿名内部类
		
		MyInter inter2 = (int num) ->{ 
				System.out.println("你好世界");
		};// Lambda表答式
			
		MyInter inter3 = ( num) ->{ 
				System.out.println("你好世界");
		};//可以省略参数类型
		
		MyInter inter4 = num -> { 
				System.out.println("你好世界");
		};//只有一个参数时省略小括号
		MyInter inter5 = num -> System.out.println("你好世界");//只有一行代码时省略大括号

	}
	
}

interface MyInter{
	void tese(int num);
}

5，当代码块中只有一行代码，此代码块为返回值，此时如果需要省略大括号，也要将return去掉

MyInter02 inter02 = ()->0;

interface MyInter02{
	int tese();
}

例子：

		/**
		 * 定义一个方法传入字符串，返回字符串长度
		 * 使用函数式接口
		 * Function
		 */
//		Function<String, Integer> function = new Function<String, Integer>() {
//			@Override
//			public Integer apply(String t) {
//				
//				return t.length();
//			}
//		};
	
		Function<String, Integer> function = t->t.length();

		Integer len = function.apply("红岸基地");
		System.out.println(len);

方法引用

简介：在Lambda表达式前提下的一些特殊情况可继续做简化

常见形式：

                对象::实例方法

package test4;
public class Per {
	private String name;
	public Per() {
		super();
	}
	public Per(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Per [name=" + name + "]";
	}	
	public  void name() {
		System.out.println(name);	
	}
}

         

//Consumer<Per> con1 = t->t.name();//形参传入的内容就是方法体中所使用的对象
		Consumer<Per> con1 = Per::name;
		con1.accept(per);

                类::静态方法

//		Consumer<Integer> con2 = new Consumer<Integer>() {
//
//			@Override
//			public void accept(Integer t) {
//				Utils.output(t);		
//			}
//		};
//		
//		
		//Consumer<Integer> con2 = t->Utils.output(t);
		Consumer<Integer> con2 = Utils::output;
		//当传入的形参与方法中代码的实参一致，就可以使用方法引用
		con2.accept(9527);
		


class Utils{
	public  void out(Integer t) {
		System.out.println(t);
	}
	
	public static  void output(Integer t) {
		System.out.println(t);
	}
}

                类::实例方法

	Utils tils = new Utils();
		
		Consumer<Integer> con1 = new Consumer<Integer>() {

			@Override
			public void accept(Integer t) {
				tils.out(t);
			}
		};
		
		//Consumer<Integer>con1 = t->tils.out(t);
		//当传入的参数就是方法中代码的实参，可以使用方法引用
		
		Consumer<Integer>con1 = tils::out;
		con1.accept(45);

              

class Utils{
	public  void out(Integer t) {
		System.out.println(t);
	}
}

  类::new

顺序要一致

		
//		Supplier<Per> sup = new Supplier<Per>() {
//			@Override
//			public Per get() {
//			
//				return new Per();
//			}
//		};
		
//		Supplier<Per> sup = ()->new Per();
//		//当方法体中没有形参列表，而且方法体中只有一行代码，而且该代码用于创建对象
//	    // 可以使用方法引用简写
		
		Supplier<Per> sup = Per::new;
		
		Per per = sup.get(); //调用就会提供Per对象
//		Function<String, Per> fun = new Function<String, Per>() {
//
//			@Override
//			public Per apply(String t) {
//				
//				return new Per(t);
//			}
//		};
		
	//	Function<String, Per> fun = t->new Per(t);
		Function<String, Per> fun =Per::new ;
		
		
		fun.apply("庄颜");

流

    简介

                Stream:工作流

                         类似集合，区别是集合中存的是数据，流中存的是过程

         特点：自己不会存储数据，不会改变源对象，也可以延迟执行

使用步骤

           1.创建

           2.中间操作

                        中间键可以有多个

           3.终止操作

                        一旦进行终止操作，流就不能·在使用了 

                          (链条式开发：上一个方法的返回值是下一个方法的调用的对象)

创建

方式1:

                通过Collection对象的stream方法获取  串行流  按数据的顺序一个一个来

                     

	 ArrayList<Integer> list = new ArrayList<Integer>();
		Collections.addAll(list, 0,1,2,3,4,5,6,7,8,9);
		 
		 Stream<Integer> stream = list.stream();//按数据的顺序一个一个来
//		 stream.forEach(new Consumer<Integer>() {
//			@Override
//			public void accept(Integer t) {
//				System.out.print(t);	
//			}
//		});
		 
		// stream.forEach(t->System.out.print(t));
		 stream.forEach(System.out::print);

                通过Collection对象的parallelStream方法获取  并行流  不管顺序

                     

System.out.println();
		 System.out.println("-------------------");
		 Stream<Integer> stream2 = list.parallelStream();//不管顺序
//		 stream2.forEach(new Consumer<Integer>() {
//				@Override
//				public void accept(Integer t) {
//					System.out.print(t);	
//				}
//			});
		 
		// stream2.forEach(t->System.out.print(t));
		 stream2.forEach(System.out::print);

方式2:

                通过Arrays提供的stream方法                    

 int[] nums = {0,1,2,3,4,5,6,7,8,9};
		 IntStream stream3 = Arrays.stream(nums);

		 
		//	stream3.forEach(t->System.out.print(t));

			stream3.forEach(System.out::print);

方式3:

                通过Stream接口提供的of,iterate,generate

代码：of普通流

                

		//Stream<Integer> stream = Stream.of(0,1,2,3,4,5,6,7,8,9);
	//	Stream.of(0,1,2,3,4,5,6,7,8,9).forEach(t->System.out.println(t));
		Stream.of(0,1,2,3,4,5,6,7,8,9).forEach(System.out::print);

代码：iterate迭代流

                

代码：generate生成流

方式4:

                通过Stream接口子类或子接口对象调用of,iterate,generate

中间操作

filter:过滤
limit:限制
skip:跳过
distinct去掉重复
sorted排序
map映射操作
parallel并行流

注意:一个流可以有多个中间操作,也可以没有

1,filter过滤
    代码:
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));
        //获取薪资大于15000,forEach终止操作,遍历结果
        list.stream()
            .filter(e->e.getMoney()>15000)
            .forEach(System.out::println);
2,limit限制
    代码:
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));
        //获取集合中前两个输出
        list.stream()
            .limit(2)
            .forEach(System.out::println);
3,skip跳过
    代码:
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));
        //跳过集合中前两个输出
        list.stream()
        .skip(2)
        .forEach(System.out::println);

4,distinct去掉重复
    注意:存储对象必须实现hashCode()和equals()方法,用这两个方法判断是否重复,先调用哪个hashCode方法,如果该方法的返回值与存储其他数据一致,在调用equals比较
    代码:
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));

        list.stream()
        .distinct()
        .forEach(System.out::println);

5,sorted排序
    代码:
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));

        list.stream()
        .sorted((e1,e2)->Double.compare(e1.getMoney(), e2.getMoney()))
        .forEach(System.out::println);

6,map映射操作
    简介:将当前Stream中的每个元素都映射转换为另一个元素，从而得到一个新的Stream
    代码:
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));

        list.stream()
        .map(e->e.getName())
        .forEach(System.out::println);

7,parallel并行流
    简介:采用多线程 效率高
    代码:
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));

        list.stream().parallel()
        .forEach(System.out::println);

结束操作

forEach遍历
min最小值
max最大值
count数量
reduce规约
collect收集

注意:一个流有且只有一个结束操作

1,forEach遍历
    代码:
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));
        list.stream().forEach(System.out::println);
2,min最小值
    代码:
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));

        Optional<Employee> min = list.stream().min((o1,o2)->Integer.compare(o1.getMoney(), o2.getMoney()));
        System.out.println(min.get());

3,max最大值
    代码:
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));

        Optional<Employee> max = list.stream().max((e1,e2)->Integer.compare(e1.getMoney(), e2.getMoney()));
        System.out.println(max.get());
4,count数量
    代码:
        //薪资大于20000的人数
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));

        long count = list.stream().filter(o -> o.getMoney()>20000).count();
        System.out.println(count);

5,reduce规约
    代码:
        //所有员工薪资和
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));

        Optional<Double> sum = list.stream()
            .map(e->e.getMoney())
            .reduce((x,y)->x+y);
        System.out.println(sum.get());

6,collect收集
    代码:
        //获取所有的员工姓名，封装成一个list集合
        ArrayList<Employee> list=new ArrayList<>();
        list.add(new Employee("小王", 15000));
        list.add(new Employee("小张", 12000));
        list.add(new Employee("小李", 18000));
        list.add(new Employee("小孙", 20000));
        list.add(new Employee("小刘", 25000));
        list.add(new Employee("小刘", 25000));

        List<String> names = list.stream()
            .map(e->e.getName())
            .collect(Collectors.toList());
        for (String string : names) {
            System.out.println(string);
        }

四水木天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jdk1.8+中文注释
07-31
jdk1.8+中文注释
jdk1.8 官方正式版64位下载
04-17
JDK 1.8提供了许多的新特性和改进，例如 lambda表达式、重复注解、类型注解、新的时间API、并发API增强、G1垃圾回收器等。这使得开发人员能够更快速、更方便地编写出性能更好、更安全、更易于维护的Java应用程序。...
Java之基础注解（基于jdk1.8）
qq_37113604的博客
08-23 1716
或许你经常使用框架，经常使用注解进行快捷开发，但是你了解注解是怎么实现的吗，本篇博客将探讨下java中的四个元注解 首先说下jdk1.8在注解方面的新特性：jdk1,8新增了重复注解与类型注解 重复注解： 在1.8以前，同一个程序元素前最多只能有一个相同类型的注解； 如果需要在同一个元素前使用多个相同类型的注解，必须要使用注解容器。 public@interfaceAuthority {...
Java JDK（2024年）下载安装教程
IT徐师兄
05-03 754
Java JDK 的下载安装教程，有需要的话，可以仔细看一下。希望对大家有所帮助。JDK（Java SE Development Kit，Java语言软件开发工具包）是原SUN公司（现已被Oracle公司收购）提供的软件包，其中含有编写和运行Java程序的所有工具，包括组成Java环境的基本条件：Java编译器javac.exe、Java解释器java.exe等。
JDK1.8新的元注解——@Repeatable
Cap220590的博客
07-07 456
JDK1.8之后添加了一个新的元注解——@Repeatable，对于它的用法，我在网上逛了一圈，很失望，没能解答我的疑惑。 这里先引入来自于博客Java注解——Repeatable对于@Repeatable 的用法： 首先创建一个APersons注解，再创建一个APerson注解，最后编写一个Man类来作为测试： 创建一个APersons注解，里面包含一个Aperson类型的数组 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME)
JDK1.8新特性（四）：接口、线程安全的时间与注解
GDUT_Trim的博客
09-28 582
接口中的默认方法与静态方法线程安全的时间格式化SimpleDateFormat的多线程安全问题解决方案时间类时间戳时间与日期间隔时间校正器：TemporalAdjuster时间格式化：DateTimeFormatter时区处理注解重复注解类型注解 接口中的默认方法与静态方法 JDK1.8支持在接口中有默认方法与静态方法了，之前接口用只能有抽象方法和静态常量 default：修饰接口的默认实现（为了提高兼容性，假如一个接口增加了方法，那么实现类都需要去实现新增的方法，所以添加了默认实现，让以前的实现类不需.
java24 手写服务器最终版本
weixin_34006468的博客
09-23 65
手写服务器最终版本; &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;web-app&gt; &lt;servlet&gt; &lt;servlet-name&gt;login&lt;/servlet-name&gt; &lt;servlet-class&gt
JDK1.8【函数式接口】【定义与使用】【源码】
04-19
JDK1.8【函数式接口】【定义与使用】【源码】 文章地址：https://blog.csdn.net/m0_37969197/article/details/124146253 * 函数式接口（类的定义与适应形式，只是一种类的定义形式，属于新增语法） * 包：java....
jdk1.8及安装教程
最新发布
05-08
具备以下新特性： 1. Lambda 表达式 2. Stream API 3. 接口的默认和静态方法 4. 新的日期时间 API 5. Nashorn JavaScript 引擎 6. 类型注解 7. Optional 类 8. CompletableFuture 9. 新的工具 10. 改进的安全性能 11...
支持jdk1.8的java反编译工具 luyten
08-15
Procyon-Decompiler支持JDK1.8类的反编译，在很多方面做得非常不错：字符串的Switch、枚举声明方面、注解方面、匿名类、内部类、Java8新接口规范、Java8 Lambda表达式、Java8 方法传递等。  luyten是Procyon的GUI，...
【原创】JDK1.8 教程，不用任何框架实现MVC架构和仿spring注入管理的例子
02-06
一个全面使用JDK1.8语法的J2EE示例，附带模拟数据库操作和基于注解的Bean注入管理。供J2EE开发新手学习。无需spring，掌握SpringMvc主要的开发思路。
(JDK大全) jdk1.6.0_24 解压免安装版
06-13
官方下载需要登录，此处用于保存方便下载，也可以方便给其他用户下载，此包为正版，版权为oracle所有。 JDK Windows jdk1.6.0_24版本 64位解压版 解压即用，不需要安装！
JDK8注解应用例子
12-07
jdk8下注解的应用例子，详细的举例了使用方法，大家可以间接参考
JDK1.8新特性知识详解
fanghuainihao的博客
03-23 3013
jdk 1.8 新特性知识详解
Java1.8新增元注解@Repeatable
NewBeeMu的博客
12-07 501
最近在复习元注解这一块的时候，发现Java1.8除了带来了很多新特性以外，还带来了一个新的元注解@Repeatable @Repeatable这个元注解的作用就是他注解的值可以取多个，是可以重复的 举个栗子，假设我很牛，我一个人可以干产品，可以干前端，可以干后端，还可以做测试。。。 @interface Mines{ Mine[] value(); } @Repeatable(Mines.class) @interface Mine{ String role default ""; } @
Java注解详解
demon7552003的小本本
01-14 777
Java注解详解
java1.8新特性入门级讲解
我认不到你的博客
10-20 4127
java1.8引入了许多的特性，在此我们主要讨论一下几点： - **接口静态方法** - **接口默认方法** ： 默认方法就是一个在接口里面有了一个或多个实现的方法。 - **函数式接口**： 一个在接口只有一个待实现的方法。 （重要） - **Lambda 表达式**： Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。 （重要） - **Stream API**： 新添加的Stream API（java.util.stream） 把真正的函数式
Java注解（三） 自定义注解与提取注解
热门推荐
Jayme
05-01 2万+
自定义注解跟提取注解 自定义注解主要讲解如何自定义跟在自定义中应该注意的问题。 提取注解主要讲的是如何通过反射机制结合AnnotatedElement获取注解相关的信息
JVM-openjdk-24
03-27 1万+
openjdk 直接 github openjdk 下载源代码。 —— corba：不流行的多语言、分布式通讯接口 —— hotspot：Java 虚拟机 —— jaxp：XML 处理 —— jaxws：一组 XML web services 的 Java API —— jdk：java 开发工具包 —— —— 针对操作系统的部分 —— —— share：与平台无关的实现 —— langtools...
java17和jdk1.8的区别
06-13
3. 功能特性：Java 17 包含了一些新的功能特性，比如支持嵌套的注解，增强的 switch 语句等；而 JDK 1.8 则引入了一些新的特性，比如 Lambda 表达式、Stream API 等。 4. 性能优化：Java 17 在性能优化方面有一定的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值