1. 函数式接口

  • 函数式接口主要指只包含一个抽象方法的接口，如：java.lang.Runnable(java1.0)、java.util.Comparator接口(java1.4)等。
  • Java8提供@FunctionalInterface注解来定义函数式接口，若定义的接口不符合函数式的规范便会报错
  • java.util.function包包含了常用的函数式接口
接口名称 方法声明 功能介绍
Consumer void accept(T t) 根据指定的参数执行操作
Supplier T get() 得到一个返回值
Function<T,R> R apply(T t) 根据指定的参数执行操作并返回
Predicate boolean test(T t) 判断指定的参数是否满足条件

2. lambda表达式

  • 语法格式：(参数列表) -> { 方法体; } - 其中()、参数类型、{} 以及return关键字 可以省略

3.方法引用

  • 通过方法的名字来指向一个方法而不需要为方法引用提供方法体，该方法的调用交给函数式接口执行
  • 方法引用使用一对冒号 :: 将类或对象与方法名进行连接，通常使用方式如下：
    • 对象的非静态方法引用 ObjectName :: MethodName
    • 类的静态方法引用 ClassName :: StaticMethodName
    • 类的非静态方法引用 ClassName :: MethodName
    • 构造器的引用 ClassName :: new
    • 数组的引用 TypeName[] :: new
  • 方法引用是在特定场景下lambda表达式的一种简化表示，可以进一步简化代码的编写使代码更加紧凑简洁，从而减少冗余代码
package task02;

import java.util.Comparator;

import java.util.function.Consumer;

import java.util.function.Function;

import java.util.function.Predicate;

import java.util.function.Supplier;

public class Java8New {

    public static void main(String[] args) {

        //函数式接口

        Comparator comparator = new Comparator() {

            @Override

            public int compare(Object o1, Object o2) {

                return -1;

            }

        };

        System.out.println(comparator.compare(1, 2));

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

        Runnable runnable = new Runnable() {

            @Override

            public void run() {

                System.out.println("running");

            }

        };

        runnable.run();

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

        Consumer consumer = new Consumer() {

            @Override

            public void accept(Object o) {

                System.out.println(o);

            }

        };

        consumer.accept("函数式接口");

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

        Supplier supplier = new Supplier() {

            @Override

            public Object get() {

                return "返回单个值";

            }

        };

        System.out.println(supplier.get());

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

        Function function = new Function() {

            @Override

            public Object apply(Object o) {

                return o;

            }

        };

        System.out.println(function.apply("指定参数返回"));

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

        Predicate predicate = new Predicate() {

            @Override

            public boolean test(Object o) {

                return false;

            }

        };

        System.out.println(predicate.test("不满足条件"));

        //lambda表达式

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

        Comparator comparator1 = (Object o1, Object o2) -> -1;

        System.out.println(comparator.compare(2, 3));

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

        Runnable runnable1 = () -> System.out.println("running");

        runnable1.run();

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

        Consumer consumer1 = o -> System.out.println(o);

        consumer1.accept("函数式接口");

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

        Supplier supplier1 = () -> "返回单个值";

        System.out.println(supplier.get());

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

        Function function1 = o1 -> o1;

        System.out.println(function1.apply("hello"));

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

        Predicate predicate1 = o -> false;

        System.out.println(predicate1.test("false"));

        //方法引用

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

        Person person = new Person("hello");

        Consumer<String> consumer2= person::setName;

        consumer2.accept("zhangfei");

        System.out.println(person.getName());

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

        Supplier<String> supplier2=person::getName;

        System.out.println(supplier2.get());

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

        Function<String,Integer> function2=Integer::parseInt;

        System.out.println(function2.apply("12345"));

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

        Function<String,Person> function3=Person::new;

        System.out.println(function3.apply("guanyu").getName());

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

        Function<Integer,Integer[]>function4=Integer[]::new;

        Integer[] apply = function4.apply(4);

        for (Integer i:apply) {

            System.out.println(i);

        }

    }

}

4. Stream接口

  • java.util.stream.Stream接口是对集合功能的增强，可以对集合元素进行复杂的查找、过滤、筛选操作
  • 借助于Lambda 表达式极大的提高编程效率和程序可读性，同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势
  • 创建
    • 方式一：通过调用集合的默认方法来获取流，如：default Stream stream()
    • 方式二：通过数组工具类中的静态方法来获取流，如：static IntStream stream(int[] array)
    • 方式三：通过Stream接口的静态方法来获取流，如：static Stream of(T... values)
    • 方式四：通过Stream接口的静态方法来获取流，static Stream generate(Supplier<? extends T> s)
  • 筛选切片
方法声明 功能介绍
Stream filter(Predicate<? super T> predicate) 返回一个包含匹配元素的流
Stream distinct() 返回不包含重复元素的流
Stream limit(long maxSize) 返回不超过给定元素数量的流
Stream skip(long n) 返回丢弃前n个元素后的流
  • 映射
方法声明 功能介绍
Stream map(Function<? super T,? extends R>
mapper)		 返回每个处理过元素组成的流
Stream flatMap(Function<? super T,? extends
Stream<? extends R>> mapper)		 返回每个被替换过元素组成的流，并
将所有流合成一个流
  • 排序
方法声明 功能介绍
Stream sorted() 返回经过自然排序后元素组成的流
Stream sorted(Comparator<? super T> comparator) 返回经过比较器排序后元素组成的流
  • 匹配与查找
方法声明 功能介绍
Optional findFirst() 返回该流的第一个元素
boolean allMatch(Predicate<? super T> predicate) 返回所有元素是否匹配
boolean noneMatch(Predicate<? super T> predicate) 返回没有元素是否匹配
Optional max(Comparator<? super T> comparator) 根据比较器返回最大元素
Optional min(Comparator<? super T> comparator) 根据比较器返回最小元素
long count() 返回元素的个数
void forEach(Consumer<? super T> action) 对流中每个元素执行操作
  • 规约：

    Optional reduce(BinaryOperator accumulator) 返回结合后的元素值
  • 收集：
    <R,A> R collect(Collector<? super T,A,R> collector) 使用收集器对元素进行处理 
package task02;

import java.util.ArrayList;

import java.util.List;

import java.util.function.BinaryOperator;

import java.util.stream.Collectors;

import java.util.stream.Stream;

public class StreamTest {

    public static void main(String[] args) {

        List<Person> list = new ArrayList<>();

        list.add(new Person("zhangfei", 30));

        list.add(new Person("wangfei", 18));

        list.add(new Person("lifei", 29));

        list.add(new Person("sunfei", 25));

        list.add(new Person("qianfei", 15));

        list.add(new Person("zhaofei", 42));

        list.add(new Person("zhangfei", 30));

        //创建Stream

        Stream<Person> stream = list.stream();

        //操作

        //Stream filter(Predicate<? super T> predicate) 返回一个包含匹配元素的流

        stream.filter((Person person) -> {

            return person.getAge() > 20;

        }).forEach((Person person) -> System.out.println(person));

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

        //Stream distinct() 返回不包含重复元素的流

        list.stream().distinct().forEach((Person person) -> System.out.println(person));

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

        //Stream skip(long n) 返回丢弃前n个元素后的流

        //Stream limit(long maxSize) 返回不超过给定元素数量的流

        //丢弃前2个返回后四个

        list.stream().skip(2).limit(4).forEach((Person person) -> System.out.println(person));

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

        //方法声明 功能介绍

        //Stream map(Function<? super T,? extends R> mapper) 返回每个处理过元素组成的流

        list.stream().map(person -> person.getName()).forEach((String s) -> System.out.println(s));

        //Optional findFirst() 返回该流的第一个元素

        System.out.println(list.stream().findFirst());

        //boolean noneMatch(Predicate<? super T> predicate) 返回没有元素是否匹配

        System.out.println(list.stream().noneMatch(person -> person.getAge() > 25));

        //方法声明 功能介绍

        //Optional reduce(BinaryOperator accumulator) 返回结合后的元素值

        System.out.print("sum");

        System.out.println(list.stream().map((Person::getAge)).reduce((o1, o2) -> o1 + o2));

        //方法声明 功能介绍

        //<R,A> R collect(Collector<? super T,A,R> collector) 使用收集器对元素进行处理

        list.stream().collect(Collectors.toList()).forEach((Person person) -> System.out.println(person));

    }

}

5. Optional类的使用

  • java.util.Optional类可以理解为一个简单的容器，其值可能是null或者不是null，代表一个值存在或不存在。该类的引入很好的解决空指针异常，不用显式进行空值检测。
方法声明 功能介绍
static Optional ofNullable(T value) 根据参数指定数值来得到Optional类型的对
象
Optional map(Function<? super T,? extends U>
mapper)		 根据参数指定规则的结果来得到Optional类
型的对象
T orElse(T other) 若该值存在就返回，否则返回other的数
值		 
package task02;

import java.util.Optional;

public class OptionalTest {

    public static void main(String[] args) {

        //判断字符串是否为空，若不为空则打印字符串的长度，否则打印0

        String s = "hello";

        Optional<String> s1 = Optional.ofNullable(s);

        System.out.println(s1.orElse("0"));//hello

        String s2 = null;

        Optional<String> s3 = Optional.ofNullable(s2);

        System.out.println(s3.orElse("0")); //0

    }

}

最新文章

  1. 《Entity Framework 6 Recipes》中文翻译系列 (15) -----第三章 查询之与列表值比较和过滤关联实体
  2. 行程编码（atoi函数）
  3. druid 配置
  4. So you want to be a 2n-aire?[HDU1145]
  5. shell zsh
  6. 問題排查：F5啟動偵錯後所提示的錯誤 (1)
  7. ASP.NET服务器控件在IE10浏览器（非兼容模式）下报脚本错误的可能解决办法
  8. POJ 2502 Subway
  9. zoj 3823 Excavator Contest 构造
  10. 30个你不可不知的CSS选择器
  11. TensorFlow文档翻译-01-TensorFlow入门
  12. [源码分析]ReentrantLock &amp; AbstractQueuedSynchronizer &amp; Condition
  13. sql的基础用法
  14. 记一次JAVA WEB项目解决XSS攻击的办法(亲测有效)
  15. [STM32F103]DMA原理
  16. caffe-windows环境配置（github上官方BVLC/caffe的推荐配置方法详解）
  17. Zookeeper的一致性协议：Zab
  18. Anaconda3（python3.5.2）中安装opencv3
  19. PostgreSQL角色和权限理解
  20. MySQL主从复制报错及解决方法

热门文章

  1. 在vue中如何使用WebSocket 以及nginx代理如何配置WebSocket
  2. 十二、.net core(.NET 6)添加通用的访问webapi的方法(包括HttpClient和HttpWebRequest)
  3. Paddle Inference推理部署
  4. RISC-V与DSA计算机架构
  5. 编写HSA内核
  6. Httprunner的使用
  7. 用java实现一个ATM机系统（2.0版）
  8. 尚硅谷Java——宋红康笔记【day19-day24】
  9. P1045 [NOIP2003 普及组] 麦森数
  10. 新增秒杀功能、优惠券、支付宝、Docker，newbee-mall升级版开源啦！