JAVA8新特性（Lambda表达式，函数型接口，Stream API，新时间）

最新推荐文章于 2024-08-12 15:45:48 发布

小鑫鑫大猩猩

最新推荐文章于 2024-08-12 15:45:48 发布

阅读量204

点赞数 1

分类专栏： Java 文章标签： java stream lambda 大数据

本文链接：https://blog.csdn.net/qq_42217774/article/details/107782370

版权

Java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Lambda表达式

Lambda基础语法

Java8中引用入了一个新的操作符：“->”，该操作符称为箭头操作符或者Lambda操作符。

箭头操作符将Lambda表达式拆分成两部分：

左侧：Lambda表达式的参数列表
右侧：Lambda表达式的要执行的功能，即Lambda体
语法格式：
无参数，无返回值
Runnable r = () -> System.out.println("Hello World");
一个参数（小括号可以省略不写），无返回值
Consumer<String> con = x -> System.out.println(x);
con.accept("Hello World");
有两个及以上的参数（小括号不可省略），有返回值，并且有多条语句（大括号不可以省略）。若只有一条语句，return和大括号都可以省略不写。
Comparator<Integer> com = (x, y) -> {
    System.out.println("Hello World");
    return Integer.compara(x, y);
}
//只有一条语句
Comparator<Integer> com1 = (x, y) -> Integer.compara(x, y);
Lambda表达式的参数列表的参数类型可以不写，因为JVM编译器可以根据上下文推断出数据类型，即“类型推断”。如果写的话所有参数都应该写上。
Comparator<Integer> com1 = (Integer x, Integer y) -> Integer.compara(x, y);

Lambda表达式需要“函数式接口”的支持

函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。可以使用**@FuncationalInterface**修饰，可以检查此接口是不是函数式接口。
eg：
//package com.ysj.lambda1;
@FunctionalInterface
public interface MyFunction<T, R> {
    R operation(T l1,T l2);
}

//package com.ysj.lambda;
public class LambdaTest1 {
    @Test
    void test1() {
        Long result = operation(100L, 200L, (l1, l2) -> l1 * l2);
        System.out.println(result);
    }
    public Long operation(Long l1, Long l2, MyFunction<Long,Long> mf) {
        return mf.operation(l1, l2);
    }
}
内置四大核心函数式接口

消费型接口：Consumer<T> 对类型为T的对象应用操作
void accept(T t);

供给型接口：Supplier<T> 返回类型为T的对象
T get();

函数型接口：Function<T, R> 对类型为T的对象应用操作，并返回R类型的对象
R apply(T t);

断言型接口：Predicate<T> 确定类型T的对象是否满足某约束
boolean test(T t);

方法引用

方法引用：若Lambda体中的内容已经有方法实现了，我们可以使用“方法引用”（可以理解方法引用为Lambda表达式的另一种表现形式）。
主要有三种语法格式：1、实例方法名的返回值类型和参数列表应该和函数式接口中方法的返回值类型和参数列表一致；2、如果Lambda参数列表中的第一个参数是实例方法的调用者，第二个参数是实例方法的参数时，可以使用ClassName::method。
对象::实例方法名
//Consumer<String> con = x -> System.out.println(x);
PrintStream ps = System.out;
Consumer<String> con = ps::println;
//Consumer<String> con = System.out::println;
类::静态方法名
//Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
Comparator<Integer> com = Integer::compare;
类::实例方法名
//BiPredicate<String, String> bp = (x, y) -> x.equals(y);
BiPredicate<String, String> bp = String::equals;

构造器引用

ClassName::new （需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表一致）
//Supplier<String> sup = () -> new String();
Supplier<String> sup = String::new;

数组引用

Type[]::new

//Function<Integer, String> fun = x -> new String[x];
Function<Integer, String[]> fun = String[]::new;

Stream API

概念

流是什么：
是数据渠道，用于操作数据源（集合，数组等）所生成的元素序列。
集合讲的是数据，流讲的是计算。
Stream自己不会存储元素。
Stream不会产生新对象，他们会返回一个持有结果的新Stream。
Stream操作是延迟执行的，这意味着他们会等到结果的时候才执行。

操作步骤

Stream的三个操作步骤：

创建Stream
可以通过Collection集合提供的stream()（串行流）或parallelStream()（并行流）
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
通过Arrays中的静态方法stream()获取数组流
User[] users = new User[10];
Stream<User> stream2 = Arrays.stream(users);
通过Stream中的静态方法of()
Stream<String> stream3 = Stream.of("aa", "bb", "cc");
创建无限流
迭代：iterate()
//从0开始，无限的+2
Stream<Integer> stream4 = Stream.iterate(0, x -> x + 2);
生成：generate()
//输出前十个生成的随机数
Stream.generate(()-> Math.random()).limit(10).forEach(System.out::println);
中间操作：多个中间操作连接起来形成一个流水线，除非流水线触发终止操作，否则中间操作不会触发任何处理，而在终止操作时一次性全部处理，称为“惰性求值”。
筛选与切片
filter（接收Lambda，从流中排除某些元素）

limit（截断流，使其元素不超过指定的次数）

skip(n)（跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个则返回一个空流，与limit形成互补。
distinct（筛选，通过流所生成的hashcode()和equals()去除重复元素。
List<Student> students = Arrays.asList(
    new Student("zs",23,110),
    new Student("ls",22,140),
    new Student("ww",21,150),
    new Student("zl",22,110),
    new Student("al",23,110)
);
students.stream()
    .filter(x -> {
        System.out.println(x.getName()+"的年龄："+x.getAge());
        return x.getAge() > 21;
    })//会对students里面的所有元素进行迭代
    .limit(4)//依次遍历集合中的元素，获得四个符合过滤结果的元素
    .skip(1)//在四个结果中除去前面一个
    .distinct() //要重写实体类中的hashcode()和equals()方法才能生效
    .forEach(System.out::println);//这是一个终止操作
映射：
map（接收Lambda，将元素转化为其他形式或提取信息。接收一个函数作为参数，然后将函数作用在每一个元素上并将其映射成一个新的元素）
flatmap（接收一个函数作为参数，将流中的每个值都转换为另一个流，然后把流连成一个流。有点类似List集合中的addAll()方法）
List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");
//map
list.stream()
    .map(String::toUpperCase)
    .forEach(System.out::println);
//flagmap
list.stream()
    .flatMap(str -> {
        Character[] chs = new Character[str.toCharArray().length];
        int i = 0;
        for (char c : str.toCharArray()) {
            chs[i] = c;
            i++;
        }
        return Arrays.stream(chs);
    })
    .forEach(System.out::println);
排序
sorted（自然排序，按照被排序对象类型中的compareTo()排）
sorted(Comparator com)（定制排序）
//sorted()
List<String> list = Arrays.asList("aaa","ddd","ccc","bbb");
list.stream().sorted().forEach(System.out::println);
//sorted(Comparator com)
students.stream()
    .sorted((e1, e2) -> {
        if (e1.getScore() == e2.getScore()) {
            return e1.getName().compareTo(e2.getName());
        } else {
            return e1.getScore() - e2.getScore();
        }
    }).forEach(System.out::println);
终止操作
查找与匹配

allMatch-检查是否匹配所有元素
anyMatch-检查是否至少匹配一个元素
noneMatch-检查是否没有匹配所有元素
findFirst-返回第一个元素
findAny-返回当前流中的任意元素
count-返回流中元素的总个数
max-返回流中最大值
min-返回流中最小值
归约
reduce(T identity, BinaryOperator) / reduce(BinaryOperator) 可以将流中元素反复结合起来，得到一个值。（一般与map结合使用）
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Integer result = list.stream().reduce(0, Integer::sum);
System.out.println(result);

Optional<Integer> result1 = list.stream().reduce(Integer::sum);//可能为空，所以封装到Optional中
System.out.println(result1);
收集

collect-将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

并行流与顺序流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
Java 8中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API可以声明性地通过parallel() 与
sequential()在并行流与顺序流之间进行切换。
Instant start = Instant.now();
long result = LongStream.rangeClosed(0, 10000L)
    .sequential()
    .reduce(0,Long::sum);
Instant end = Instant.now();
//System.out.println("并行流耗费时间："+ Duration.between(start,end).toMillis());//100亿：4653ms，1000亿：37648ms
System.out.println("顺序流耗费时间："+ Duration.between(start,end).toMillis());//100亿：7052ms，1000亿：-

Optional类

Optional<T> 类(java.util.Optional)是一个容器类，代表一个值存在或不存在，原来用null表示一个值不存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常或者快速定位空指针。
常用方法:
Optional.of(T t):创建-一个Optional 实例
Optional. empty():创建-一个空的Optional 实例
Optional. ofNullable(T t):若t不为null，创建Optional 实例，否则创建空实例
isPresent():判断是否包含值
orElse(T t):如果调用对象包含值，返回该值，否则返回t
orElseGet (Supplier s):如果调用对象包含值，返回该值，否则返回s获取的值
map (Function f):如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
flatMap (Function mapper):与map类似，要求返回值必须是Optional

接口中的默认方法和静态方法

“类优先”原则

接口默认方法的”类优先”原则
若一个接口中定义了一个默认方法，而另外一个父类或接口中.又定义了一个同名的方法时
选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法(不管方法是否是默认方法)，那么必须覆盖该方法来解决冲突

接口中还可以写静态方法。

新时间日期API

特点：1、不可变；2、线程安全。

LocalDate、LocalTime、 LocalDateTime类的实例是不可变的对象，分别表示使用IS0-8601日历系统（国际标准化组织制定的现代公民的日期和时间的表示法）的日期、时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间信息。也不包含与时区相关的信息。

@Test
void test1() {
    LocalDateTime ldt1 = LocalDateTime.now();//创建当地时间
    System.out.println(ldt1);
    LocalDateTime ldt2 = LocalDateTime.of(2020, 8, 3, 18, 4);//自定义任何时间
    System.out.println(ldt2);
    System.out.println(ldt1.plusYears(3));//在当地时间上加3年
    System.out.println(ldt1.minusYears(3));//在当地时间上减3年
    System.out.println(ldt1.getYear());
    System.out.println(ldt1.getDayOfWeek());//获取当日星期
}

Instant: 时间戳（以Unix元年：1970-1-1 00:00:00到某个时间之间的毫秒值）

@Test
void test2() {
    Instant now = Instant.now();//默认获取UTC时区，即世界协调时间，和格林威治时间一样，国际日期变更线的时间。
    System.out.println(now);
    OffsetDateTime time = now.atOffset(ZoneOffset.ofHours(8));//设置时间偏移量
    System.out.println(time);
    System.out.println(now.toEpochMilli());//时间戳
    System.out.println(Instant.ofEpochSecond(1));//Unix元年+1s的时间
}

Duration: 计算两个时间之间的间隔；Period: 计算两个日期之间的间隔

@Test
void test3() throws InterruptedException {
    Instant start = Instant.now();
    Thread.sleep(1000);
    Instant end = Instant.now();
    System.out.println(Duration.between(start, end).toNanos());//以为纳秒单位
    System.out.println(Duration.between(start, end).getNano());//只获取纳秒
    System.out.println(Duration.between(start, end).toMillis());//以毫秒为单位
    System.out.println("----------------------------");
    LocalDate data1 = LocalDate.of(2019, 1, 1);
    LocalDate data2 = LocalDate.now();
    Period period = Period.between(data1, data2);
    System.out.println(period);
    System.out.println(period.toTotalMonths());
}

时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。

TemporalAdjusters:该类通过静态方法提供了大量的常用TemporalAdjuster的实现。例如获取下个周日：

LocalDate nextSunday = LocalDate . now() . with(
    TemporalAdjusters. next(DayOfWeek . SUNDAY)
);

@Test
void test4() {
    LocalDateTime now = LocalDateTime.now();
    LocalDateTime ldt1 = now.withDayOfMonth(1);
    System.out.println(ldt1);
    LocalDateTime ldt2 = now.with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY));//当月第一周的周一是多少号
    System.out.println(ldt2);
    LocalDateTime ldt3 = now.with(TemporalAdjusters.next(DayOfWeek.MONDAY));//下个周一是什么时候
    System.out.println(ldt3);
    //自定义：下一个工作日
    System.out.println(now.with(data -> {
        LocalDateTime ldt4 = (LocalDateTime) data;
        if (ldt4.getDayOfWeek().equals(DayOfWeek.FRIDAY)) {
            return ldt4.plusDays(3);
        } else if (ldt4.getDayOfWeek().equals(DayOfWeek.SATURDAY)) {
            return ldt4.plusDays(2);
        } else {
            return ldt4.plusDays(1);
        }
    }));
}

时间格式化

@Test
void test5() {
    DateTimeFormatter isoDate = DateTimeFormatter.ISO_DATE;
    LocalDateTime now = LocalDateTime.now();
    String date = now.format(isoDate);
    System.out.println(date);
    DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
    String date1 = pattern.format(now);
    System.out.println(date1);
}

小鑫鑫大猩猩

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA8新特性（Lambda表达式，函数型接口，Stream API，新时间）

Lambda表达式Lambda基础语法Java8中引用入了一个新的操作符：“->”，该操作符称为箭头操作符或者Lambda操作符。箭头操作符将Lambda表达式拆分成两部分：左侧：Lambda表达式的参数列表右侧：Lambda表达式的要执行的功能，即Lambda体语法格式：无参数，无返回值Runnable r = () -> System.out.println("Hello World");一个参数（小括号可以省略不写），无返回值Consumer
复制链接

扫一扫

专栏目录