Java学习笔记day25

最新推荐文章于 2024-06-29 11:59:11 发布

新手小白6

最新推荐文章于 2024-06-29 11:59:11 发布

阅读量86

点赞数

分类专栏： Java学习记录文章标签： java 学习 jvm

本文链接：https://blog.csdn.net/kouzai8880/article/details/127588756

版权

Java学习记录专栏收录该内容

41 篇文章 0 订阅

订阅专栏

注解

概念

解释代码的代码，称为注解，也被称为元代码

常用的注解

@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: 在构造函数上用
		注意: 自定义一个注解不使用上述注解时，自定义的注解可以在任何一处使用
	@Retention
		作用: 限定其使用范围(在什么情况下使用)
		值: 
			SOURCE: 在java文件时可用
			CLASS: 编译为class文件时可用
			RUNTIME: 程序运行时可用
		注意: 
			自定义的注解默认是java文件时可用
	@Documented
		作用: 可以生成api文件
	@Inherited
		作用: 允许被继承
		注意: 不加是不被继承的

注解 + 反射

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.CONSTRUCTOR)
public @interface DogAnnotation {
	String name() default "狗";
	int age() default 1;
	String color() default "黑";
	String[] likeFoods() default {"骨头", "肉"};
}

import java.lang.reflect.Constructor;
import java.util.Arrays;

public class Dog {
	private String name;
	private int age;
	private String color;
	private String[] likeFoods;
	
	@DogAnnotation(name = "小狗", color = "白")
	public Dog() throws Exception {
		Class c = Dog.class;
		Constructor<Dog> constructor = c.getDeclaredConstructor();
		DogAnnotation annotation = constructor.getAnnotation(DogAnnotation.class);
		this.name = annotation.name();
		this.age = annotation.age();
		this.color = annotation.color();
		this.likeFoods = annotation.likeFoods();
	}

	public Dog(String name, int age, String color, String[] likeFoods) {
		this.name = name;
		this.age = age;
		this.color = color;
		this.likeFoods = likeFoods;
	}

	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[] getLikeFoods() {
		return likeFoods;
	}

	public void setLikeFoods(String[] likeFoods) {
		this.likeFoods = likeFoods;
	}

	@Override
	public String toString() {
		return "Dog [name=" + name + ", age=" + age + ", color=" + color + ", likeFoods=" + Arrays.toString(likeFoods)
				+ "]";
	}	
}


public class Test {
	public static void main(String[] args) throws Exception {
		Dog dog = new Dog();
		System.out.println(dog);
	}
}

运行结果

JDK1.8新特性

简介

在Java 8版本添加的新内容
如: Java5的时候添加反射，Java2集合...

函数式接口

简介

一个接口中只有一个抽象方法，这种接口称为函数式接口

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

接口名         返回值类型    抽象方法        分类
Consumer<T>    void      accept(T t)   消费型接口
Supplier<T>     T        get()         供给型接口
Function<T,R>   R        apply(T t)    函数型接口
Predicate<T>   boolean   test(T t)     断言型接口

Lambda

简介

一种特殊的匿名内部类

优点

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

语法

() -> {}
注意: 
	1.创建的匿名内部类中只有一个方法，此时才能使用Lambda表达式
	2.在Lambda表达式中，可以省略形参的数据类型
	3.在Lambda表达式中，当只有一个形参时可以忽略小括号不写
	4.当代码块只有一行代码时，可以省略大括号不写
	5.当代码块中只有一行代码，该代码是返回值，此时如果要省略大括号，也需将return去掉

package demo01;

import java.util.function.Function;

public class Test {
	public static void main(String[] args) {
		/**
		 * 定义一个方法传入字符串,返回字符串长度
		 */
//		Function<String, Integer> function = new Function<String, Integer>() {
//			@Override
//			public Integer apply(String t) {
//				return t.length();
//			}
//		};
		
//		Function<String, Integer> function = (String t) -> {
//				return t.length();
//		};
		
		Function<String, Integer> function = t -> t.length();
				
		Integer len = function.apply("Hello Java!");
		System.out.println(len);
	}
}

运行结果

方法引用

简介

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

常见形式

对象::实例方法
类::静态方法
类::实例方法
类::new

package demo02;

public class Person {
	private String name;

	public Person() {

	}

	public Person(String name) {
		this.name = name;
	}

	public void getName() {
		System.out.println(name);
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + "]";
	}		
}

package demo02;

import java.util.function.Consumer;

//方法引用
//对象::实例方法
public class Test {
	public static void main(String[] args) {
		A a = new A();
//		Consumer<Integer> consumer = new Consumer<Integer>() {
//
//			@Override
//			public void accept(Integer t) {
//				a.out(t);
//			}
//		};
		
		//Lambda表达式简写
//		Consumer<Integer> consumer = (Integer t) -> {
//				a.out(t);
//		};
		
		//继续简写
//		Consumer<Integer> consumer = t -> a.out(t);
		
		//当传入的形参与方法中代码的实参一致,可以使用方法引用
		
		Consumer<Integer> consumer = a::out;
		consumer.accept(10);
	}
}

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

运行结果

package demo02;

import java.util.function.Consumer;

//方法引用
//类::静态方法
public class Test02 {
	public static void main(String[] args) {
//		Consumer<Integer> consumer = new Consumer<Integer>() {
//
//			@Override
//			public void accept(Integer t) {
//				B.out(t);
//			}
//		};
		
		//Lambda表达式简写
//		Consumer<Integer> consumer = (Integer t) -> {
//				B.out(t);
//		};
		
		//继续简写
//		Consumer<Integer> consumer = t -> B.out(t);
		
		//当传入的形参与方法中代码的实参一致,可以使用方法引用
		Consumer<Integer> consumer = B::out;
		consumer.accept(10);
	}
}

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

运行结果

package demo02;

import java.util.function.Consumer;

//方法引用
//类::实例方法
public class Test03 {
	public static void main(String[] args) {
//		Consumer<Person> consumer = new Consumer<Person>() {
//
//			@Override
//			public void accept(Person t) {
//				t.getName();
//			}
//		};
		
		//Lambda表达式简写
//		Consumer<Person> consumer = (Person t) -> {
//				t.getName();
//		};
		
		//继续简写
//		Consumer<Person> consumer = t -> t.getName();
		
		//形参传入的内容就是方法体中调用方法的对象
		//此时可以使用方法引用再次简化
		Consumer<Person> consumer = Person::getName;
		
		Person person = new Person("张三");
		consumer.accept(person);
	}
}

运行结果

package demo02;

import java.util.function.Function;
import java.util.function.Supplier;

//方法引用
//类::new
public class Test04 {
	public static void main(String[] args) {
//		Supplier<Person> supplier = new Supplier<Person>() {
//
//			@Override
//			public Person get() {
//				return new Person();
//			}
//		};
		
		//Lambda表达式简写
//		Supplier<Person> supplier = () -> new Person();
		
		//此方法体中只有一行代码,而且该代码用于创建对象
		//此时可以使用方法引用简写
		Supplier<Person> supplier = Person::new;
		Person person = supplier.get();
		System.out.println(person);
		
		System.out.println("-------------------------");
		
//		Function<String, Person> function = new Function<String, Person>() {
//
//			@Override
//			public Person apply(String t) {
//				return new Person(t);
//			}
//		};
		
		//Lambda表达式简写
//		Function<String, Person> function = (String t) -> {
//				return new Person(t);
//		};
		
		//继续简写
//		Function<String, Person> function = t -> new Person(t);
		
		//使用方法引用简写
		Function<String, Person> function = Person::new;
		Person p = function.apply("张三");
		System.out.println(p);
	}
}

运行结果

流

简介

Stream: 工作流

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

特点

自己不会存储数据
不会改变源对象

使用步骤

1.创建
2.中间操作
	注意: 中间操作可以有多个
3.终止操作
	注意: 一旦进行终止操作，该流就不能再使用了

创建

方式1: 
	通过Collection对象的stream方法获取
	通过Collection对象的parallelStream方法获取
方式2: 
	通过Arrays提供的stream方法
方式3: 
	通过Stream接口提供的of,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);

package demo03;

public class Employee {
	private String name;
	private int money;
	
	public Employee() {

	}
	
	public Employee(String name, int money) {
		this.name = name;
		this.money = money;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getMoney() {
		return money;
	}

	public void setMoney(int money) {
		this.money = money;
	}

	@Override
	public String toString() {
		return "Employee [name=" + name + ", money=" + money + "]";
	}		
}

package demo03;

import java.util.ArrayList;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class Test01 {
	public static void main(String[] args) {
		ArrayList<Employee> list=new ArrayList<Employee>();
		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(new Predicate<Employee>() {
//
//			@Override
//			public boolean test(Employee e) {
//				return e.getMoney() > 15000;
//			}
//		})
//		.forEach(new Consumer<Employee>() {
//
//			@Override
//			public void accept(Employee e) {
//				System.out.println(e);
//			}
//		});
		
		//简化写法
		list.stream()
		.filter(e->e.getMoney()>15000)
		.forEach(System.out::println);
	}
}

运行结果

package demo03;

import java.util.ArrayList;
import java.util.function.Consumer;

public class Test02 {
	public static void main(String[] args) {
		ArrayList<Employee> list=new ArrayList<Employee>();
		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(new Consumer<Employee>() {
//
//			@Override
//			public void accept(Employee e) {
//				System.out.println(e);
//			}
//		});
		
		//简化写法
		list.stream()
			.limit(2)
			.forEach(System.out::println);
	}
}

运行结果

package demo03;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;

public class Test05 {
	public static void main(String[] args) {
		ArrayList<Employee> list=new ArrayList<Employee>();
		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(new Comparator<Employee>() {
//
//			@Override
//			public int compare(Employee e1, Employee e2) {
//				return Double.compare(e1.getMoney(), e2.getMoney());
//			}
//		}).forEach(new Consumer<Employee>() {
//
//			@Override
//			public void accept(Employee e) {
//				System.out.println(e);
//			}
//		});
		
		//简化写法
		list.stream()
		.sorted((e1,e2)->Double.compare(e1.getMoney(), e2.getMoney()))
		.forEach(System.out::println);
	}
}

运行结果

package demo03;

import java.util.ArrayList;
import java.util.function.Consumer;
import java.util.function.Function;

public class Test06 {
	public static void main(String[] args) {
		ArrayList<Employee> list=new ArrayList<Employee>();
		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(new Function<Employee, String>() {
//
//			@Override
//			public String apply(Employee e) {
//				return e.getName();
//			}
//		}).forEach(new Consumer<String>() {
//
//			@Override
//			public void accept(String s) {
//				System.out.println(s);
//			}
//		});
		
		//简化写法
		list.stream()
		.map(e->e.getName())
		.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<Integer> 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);
		}

package demo04;

public class Employee {
	private String name;
	private int money;
	
	public Employee() {

	}
	
	public Employee(String name, int money) {
		this.name = name;
		this.money = money;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getMoney() {
		return money;
	}

	public void setMoney(int money) {
		this.money = money;
	}

	@Override
	public String toString() {
		return "Employee [name=" + name + ", money=" + money + "]";
	}		
}

package demo04;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Optional;

public class Test03 {
	public static void main(String[] args) {
		ArrayList<Employee> list=new ArrayList<Employee>();
		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(new Comparator<Employee>() {
//
//			@Override
//			public int compare(Employee e1, Employee e2) {				
//				return Integer.compare(e1.getMoney(), e2.getMoney());
//			}
//		});
//		System.out.println(max.get());
		
		//简化写法
		Optional<Employee> max = list.stream().max((e1,e2)->Integer.compare(e1.getMoney(), e2.getMoney()));
		System.out.println(max.get());
	}
}

运行结果

package demo04;

import java.util.ArrayList;
import java.util.function.Predicate;

public class Test04 {
	public static void main(String[] args) {
		ArrayList<Employee> list=new ArrayList<Employee>();
		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));
		
		//薪资大于20000的人数
//		long count = list.stream().filter(new Predicate<Employee>() {
//
//			@Override
//			public boolean test(Employee e) {
//				return e.getMoney() > 20000;
//			}
//		}).count();
		
		//简化写法
		long count = list.stream().filter(o -> o.getMoney()>20000).count();
		System.out.println(count);
	}
}

运行结果

package demo04;

import java.util.ArrayList;
import java.util.Optional;
import java.util.function.BinaryOperator;
import java.util.function.Function;

public class Test05 {
	public static void main(String[] args) {
		ArrayList<Employee> list=new ArrayList<Employee>();
		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<Integer> sum = list.stream().map(new Function<Employee, Integer>() {
//
//			@Override
//			public Integer apply(Employee e) {
//				return e.getMoney();
//			}
//		}).reduce(new BinaryOperator<Integer>() {
//			
//			@Override
//			public Integer apply(Integer x, Integer y) {
//				return x + y;
//			}
//		});
		
		//简化写法
		Optional<Integer> sum = list.stream()
			.map(e->e.getMoney())
			.reduce((x,y)->x+y);
		System.out.println(sum.get());
	}
}

运行结果

package demo04;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Test06 {
	public static void main(String[] args) {
		ArrayList<Employee> list=new ArrayList<Employee>();
		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集合
//		List<String> names = list.stream().map(new Function<Employee, String>() {
//
//			@Override
//			public String apply(Employee e) {
//				return e.getName();
//			}
//		}).collect(Collectors.toList());
		
		//简化写法
		List<String> names = list.stream()
			.map(e->e.getName())
			.collect(Collectors.toList());
		
		for (String string : names) {
			System.out.println(string);
		}
	}
}

运行结果

新时间API

简介

以前的时间相关API,是线程不安全的,而且在设计时就是混乱的
所以在JDK1.8时候提供新的时间API的类

提供的类有:
	LocalDate
	LocalTime
	LocalDateTime
		替换Date
	
	DateTimeFormatter
		替换:SimpleDateFormat
	
	Instant
		瞬时
	ZoneId
		时区

LocalDate

作用: 本地日期
提供的方法: 
	static LocalDate now(): 获取当前日期
	static LocalDate of(): 获取指定日期

LocalTime

作用: 本地时间
提供的方法: 
	static LocalTime now(): 获取当前时间
	static LocalTime of(): 获取指定时间

LocalDateTime

作用: 本地日期时间
提供的方法: 
	static LocalTime now(): 获取当前日期时间
	static LocalTime of(): 获取指定日期时间
	getXXX(): 获取时间
	withXXX(): 设置时间
	plusXXX(): 在原时间基础上增加
	minusXXX(): 在原时间基础上减小

DateTimeFormatter

package demo05;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Test01 {
	public static void main(String[] args) {
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
		LocalDateTime dateTime01 = LocalDateTime.now();
		//将时间转换为固定格式的字符串
		String str = formatter.format(dateTime01);
		System.out.println(str);
		//将固定格式的字符串转换为对象
		LocalDateTime dateTime02 = LocalDateTime.parse("2022年12月10日 13:14:52", formatter);
		System.out.println(dateTime02);
	}
}

运行结果

Instant

作用: 瞬时

package demo05;

import java.time.Instant;

public class Test02 {
	public static void main(String[] args) {
		Instant instant = Instant.now();
		System.out.println(instant);
	}
}

运行结果

转换

package demo05;

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;

public class Test03 {
	public static void main(String[] args) {
		//将Date对象的时间转换为LocalDatetime对象
		Date date = new Date();
		Instant instant = date.toInstant();
		LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
		System.out.println(dateTime);
		
		//将LocalDatetime对象转换为Date对象
		LocalDateTime dateTime2 = LocalDateTime.of(2000, 1, 1, 12, 0, 1);
		Instant instant2 = dateTime2.atZone(ZoneId.systemDefault()).toInstant();
		Date date2 = Date.from(instant2);
		System.out.println(date2);
	}
}