一.lambda表达式
1.为什么使用lambda表达式
lambda是一个匿名函数,我们可以把lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。可以写出更简洁,更灵活的代码。作为一种更紧凑的代码风格,是java语言的表达能力得到了提升。
2.lambda 基础语法
java8中引入了一个新的操作符 “->” 该操作符成为箭头操作符或lambda操作符
- 左侧:lambda 表达式的参数列表
- 右侧:lambda 表达式所需执行的功能,即lambda体
- lambda表达式需要函数式接口的支持(见下图)
语法格式一:无参数,无返回值
@Test
public void test1(){
// 匿名内部类方式
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("hello world");
}
};
r1.run();
System.out.println("-------------------");
// lambda方式
Runnable r2 = () -> System.out.println("hello world");
r2.run();
}
语法格式二:有一个参数,并且无返回值
@Test
public void test2(){
Consumer<String> con = (x) -> System.out.println(x);
con.accept("miracle");
}
语法格式三:有二个以上的参数,有回值,并且lambda 体中有多条语句,语句要使用{}
@Test
public void test3(){
Comparator<Integer> comparator = (x, y) -> {
System.out.println("函数式接口");
return Integer.compare(x, y);
};
}
语法格式四:有二个以上的参数,有回值,并且lambda 体中有一条语句,语句可以省略{}和return
@Test
public void test4(){
Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);
}
3.方法引用
若lambda体中的内容有方法已经实现了,我们可以使用"方法引用"(可以理解为方法引用是lambda表达式的另一种表现形式)
主要有三种语法格式:
- 对象::实例方法名
- 类::静态方法名
- 类::实例方法名
注意 lambda 体中调用方法的参数列表与返回值类型,要与函数式接口中抽象方法的函数列表和返回值类型保持一致!
- 对象::实例方法名 示例
@Test
public void test1(){
// System.out 返回打印流 PrintStream 对象
Consumer<String> consumer = System.out::println;
consumer.accept("miracle");
}
- 类::静态方法名
@Test
public void test3(){
// Integer类的静态方法compare
Comparator<Integer> com = Integer::compare;
int compare1 = com.compare(1, 2);
int compare2 = com.compare(2, 2);
int compare3 = com.compare(3, 2);
System.out.println(compare1);
System.out.println(compare2);
System.out.println(compare3);
}
二.Stream
1.了解Stream
java8中有两个最为重要的改变,一个是lambda表达式;另一个则是 Stream API (java.util.stream.*)
Stream 是 java8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找,过滤和映射数据等操作。使用Stream API 对集合数据进行操作,就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之,Stream API 提供了一种高效且易于使用的处理数据的方式。
2.Stream是什么
- 是数据渠道,用于操作数据源(集合,数组等)所生成的元素序列。
- 集合讲的是数据,流讲的是计算
注意:
- Stream 自己不会储存元素。
- Stream 不会改变源对象。相反,他们会返回一个持有结果的新Stream
- Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
3.Stream的操作三个步骤
1.创建 Stream
一个数据源(如:集合,数组),获取一个流
示例
@Test
public void test1(){
// 创建 Stream 流,可以通过 Collection 系列集合接口提供的 stream() 或 parallelStream()
// 创建 Stream 流,可以通过 Arrays 的 stream 将数组转换成流
// 创建 Stream 流,可以通过 Stream.of() 方法获取流
// 创建流的第一种方式
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
// 创建流的第二种方式
Employee[] emps = new Employee[10];
Stream<Employee> stream2 = Arrays.stream(emps);
// 创建流的第三种方式
Stream<String> stream3 = Stream.of("aa", "bb", "cc");
// 创建流的第四种方式(创建无限流)
// 1.迭代方式
Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
stream4.limit(10).forEach(System.out::println);
// 2.生成方式
Stream<Double> stream5 = Stream.generate(() -> Math.random());
stream5.limit(10).forEach(System.out::println);
}
2.中间操作
一个中间操作链,对数据源的数据进行处理
(1)筛选与切片
filter 接收lambda,从流中排除某些元素。
limit 截断流,使其元素不超过给定数量。
skip 跳过元素,返回一个扔掉了前n个元素的流。若流中元素不足n个,则返回一个空流。与limit(n)互补
distinct 筛选,通过流所生成的元素的hashCode() 和 equals() 去除重复元素
- filter
List<Employee> employees = Arrays.asList(
new Employee("张三",18, 9999.99),
new Employee("李四",38, 5555.99),
new Employee("王五",50, 6666.99),
new Employee("赵六",16, 3333.99),
new Employee("田七",8, 7777.99)
);
@Test
public void test1(){
Stream<Employee> employeeStream = employees.stream().filter((e) -> {
System.out.println("Stream API 的中间操作");
return e.getAge() > 35;
});
employeeStream.forEach(System.out::println);
}
- limit
// 返回流中前两个
Stream<Employee> employeeStream = employees.stream().limit(2);
employeeStream.forEach(System.out::println);
- skip
@Test
public void test3(){
// 返回丢掉前两个元素的流
Stream<Employee> employeeStream = employees.stream().skip(2);
employeeStream.forEach(System.out::println);
}
- distinct
@Test
public void test4(){
// 这里去重是根据元素的 hashCode 和 equals 方法去除重复元素
Stream<Employee> employeeStream = employees.stream().distinct();
employeeStream.forEach(System.out::println);
}
(2)映射
map-接收 lambda,将元素转换成其他形式或提取信息。接收一个函数作为参数,该函数会被应用到每个
flatMap-接收一个函数作为参数,将流中的每个值都替换成另一个流,然后把所有流连接成一个流。
示例1:元素转换成其他形式
@Test
public void test5(){
List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
// 这里会返回一个新流
Stream<String> stream = list.stream().map((str) -> str.toUpperCase());
stream.forEach(System.out::println);
}
示例2:提取流中的元素
@Test
public void test6(){
// 这里会返回一个新流
Stream<String> stream = employees.stream().map(Employee::getName);
stream.forEach(System.out::println);
}
(3)排序
sorted() 自然排序
sorted(Comparator com) 定制排序
示例1:自然排序
@Test
public void test7(){
List<String> list = Arrays.asList("ccc", "aaa", "bbb", "ddd", "eee");
list.stream().sorted().forEach(System.out::println);
}
示例2:定制排序
@Test
public void test8(){
Stream<Employee> stream = employees.stream().sorted((x, y) -> (int) (x.getSalary() - y.getSalary()));
stream.forEach(System.out::println);
}
3.终止操作(终端操作)
一个终止操作,执行中间操作链,并产生结果
Employee.java
package com.miracle.java8.test1;
import java.util.Objects;
public class Employee {
private String name;
private int age;
private double salary;
private Status status;
public Employee() {
}
public Employee(String name, int age, double salary, Status status) {
this.name = name;
this.age = age;
this.salary = salary;
this.status = status;
}
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 double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Status getStatus() {
return status;
}
public void setStatus(Status status) {
this.status = status;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return age == employee.age &&
Double.compare(employee.salary, salary) == 0 &&
Objects.equals(name, employee.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age, salary);
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
", status=" + status +
'}';
}
public enum Status{
FREE,
BUSY,
VOCATION
}
}
(1)查找与匹配
- allMatch 检查是否匹配所有元素
@Test
public void test9(){
boolean b = employees.stream().allMatch(employee -> employee.getStatus().equals(Employee.Status.BUSY));
System.out.println(b);
}
- anyMatch 检查是否至少匹配一个元素
@Test
public void test10(){
boolean b = employees.stream().anyMatch(employee -> employee.getStatus().equals(Employee.Status.BUSY));
System.out.println(b);
}
- noneMatch 检查是否没有匹配所有元素
@Test
public void test11(){
boolean b = employees.stream().noneMatch(employee -> employee.getStatus().equals(Employee.Status.BUSY));
System.out.println(b);
}
- findFirst 返回第一个元素
- findAny 返回当前流中的任意元素
- count 返回流中元素的总个数
- max 返回流中最大值
- min 返回流中最小值
(2)规约
reduce(T identity, BinaryOperator) / reduce(BinaryOperator) 可以将流中元素反复结合起来,得到一个值
实例一:将集合中元素求和
@Test
public void test12(){
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 这里reduce把集合里面数据相加,起始值为0
Integer sum = list.stream().reduce(0, (x, y) -> x + y);
System.out.println(sum);
}
4.Stream的并发流
Stream流操作默认产生的是串行流(单线程,速度慢),Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与串行流直接进行转换
串行流示例
@Test
public void test13(){
// 产生一个long型数字组成的流,是串行流(单线程,速度慢)
LongStream longStream = LongStream.rangeClosed(0, 100000000000L);
// 进行加和操作
long result = longStream.reduce(0, Long::sum);
System.out.println(result);
}
并发流示例
@Test
public void test14(){
// 产生一个long型数字组成的流,是并发流(多线程,速度快)
LongStream longStream = LongStream.rangeClosed(0, 100000000000L).parallel();
// 进行加和操作
long result = longStream.reduce(0, Long::sum);
System.out.println(result);
}
三.Optional类
1.介绍
Optional 类(java.util.Optional) 是一个容器类,代表一个值存在或不存在,原来用null表示一个值不存在,现在Optional可以更好的表达这个概念。并且可以避免空指针异常。
四.接口中的默认方法与静态方法
五.新时间日期API
1.LocalDate,LocalTime,LocalDateTime(获取的是当前操作系统时间)
LocalDate,LocalTime,LocalDateTime类的实例是不可变的对象(线程安全),分别表示使用ISO-8601日历系统的日期,时间,日期和时间,三者API相同用法一致,下面以 LocalDateTime 为例
@Test
public void test1(){
// 获取当前系统时间
LocalDateTime now = LocalDateTime.now();
System.out.println(now);
// 获取年
int year = now.getYear();
System.out.println(year);
// 获取月
int month = now.getMonthValue();
System.out.println(month);
// 获取天
int day = now.getDayOfMonth();
System.out.println(day);
// 时
int hour = now.getHour();
System.out.println(hour);
// 构造时间
LocalDateTime localDateTime = LocalDateTime.of(2015, 10, 19, 13, 22, 33);
System.out.println(localDateTime);
// 日期运算
LocalDateTime nowTime = LocalDateTime.now();
// 时间相加(plus系列方法,年月日时分秒),加两年
LocalDateTime plusYears = nowTime.plusYears(2);
System.out.println(plusYears);
// 时间相减(minus系列方法,年月日时分秒) 减两..年
LocalDateTime minusYears = plusYears.minusYears(2);
System.out.println(minusYears);
}
2.Instant :时间戳(以 unix 元年:1970年1月1日 00:00:00 到某个时间之间的毫秒值)
// 获取的是UTC时间,和北京时间有时差(8小时)
Instant now = Instant.now();
// 这里打印的是正常的时间格式
System.out.println(now);
// 获取时间戳(毫秒)
long timeStamp = now.toEpochMilli();
System.out.println(timeStamp);
3.时间间隔计算
Duration :计算两个“时间”之间的间隔
@Test
public void test3(){
Instant instant1 = Instant.now();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Instant instant2 = Instant.now();
Duration between1 = Duration.between(instant1, instant2);
// 求两个时间戳之间的间隔
System.out.println(between1.toMillis());
LocalTime localTime1 = LocalTime.now();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
LocalTime localTime2 = LocalTime.now();
// 两个时间间隔
Duration between2 = Duration.between(localTime1, localTime2);
System.out.println(between2.toMillis());
}
Period:计算两个“日期”之间的间隔
@Test
public void test4(){
LocalDate date1 = LocalDate.of(2015, 1, 1);
LocalDate date2 = LocalDate.now();
Period period = Period.between(date1, date2);
// 获取两个日期间,间隔多少年
System.out.println(period.getYears());
// 获取两个日期间,的间隔多少月
System.out.println(period.getMonths());
// 获取两个日期间,间隔多少日
System.out.println(period.getDays());
}
4.日期的操纵
- TemporalAdjuster:时间校正器。有时我们可能需要获取例如,将日期调整到“下个周日”等操作。
- TemporalAdjusters:该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现
@Test
public void test5(){
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);
// 通过with方法,将日期指定为当月的某一天
LocalDateTime ldt2 = ldt.withDayOfMonth(1);
System.out.println(ldt2);
/**
* 可以传入一个 TemporalAdjuster 接口的实现类
* 也可以使用 JDK 自带的 TemporalAdjusters中提供的实现
*/
// 计算下周一的时间
LocalDateTime nextMonday = ldt.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
System.out.println(nextMonday);
}
- DateTimeFormatter:格式化时间/日期
// 指定格式化标准
DateTimeFormatter dtf = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
LocalDateTime ldt = LocalDateTime.now();
// 格式化
String formatDateTime = ldt.format(dtf);
System.out.println(formatDateTime);
// 也可以指定自己格式化标准
DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒");
String formatDateTime2 = ldt.format(dtf2);
System.out.println(formatDateTime2);