Java8 Lambda表达式

最新推荐文章于 2022-11-23 10:48:14 发布
最新推荐文章于 2022-11-23 10:48:14 发布
阅读量328 收藏
点赞数
分类专栏： java基础 文章标签： Java8 Lambda Lambda表达式 default FunctionalInterface
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xktxoo/article/details/83998270
版权

lambda表达式是java8提供一个重要的特性，它提供了一个正常的参数列表和一个使用这些参数的主体，它必须依附于一个特别的对象类型–函数式接口，lambda表达式语法为：

(parameters) -> expression
(parameters) -> {statements}
一、函数式接口

如果在一个接口中有且只有一个抽象方法，那么这个接口就可以当做函数式接口。Java8引入了@FunctionalInterface注解，主要用于编译错误检查，加上该注解，当接口不符合函数式接口定义的时候，编译器会报错。如果一个接口满足函数式接口的定义，不加@FunctionalInterface注解，编译器也会把该接口当做函数式接口处理。一个函数式接口如下：

@FunctionalInterface
public interface TestFunc {
    void sayHi(String name);
}

测试函数式接口的简单使用：

public class TestFuncMain {
    public static void main(String ... args) {
        TestFunc testFunc = name -> System.out.print(name);
        testFunc.sayHi("Jerry");
    }
}

二、函数式接口返回实例

函数式接口返回实例的方式有两种：

  • 2.1 通过lambda表达式返回接口实例

最常用的一种使用方式。返回一个Runable接口的实例示例：

public class TestLambda {
    public static void main(String ... args) {
        new Thread(() -> System.out.println("sub thread")).start();
        System.out.println("main thread");
    }
}
  • 返回方法引用

返回构造器，语法：Class::new ，Class中必须要有一个显示的无参构造方法，否则会报错；
返回方法，语法：Class::method

public class Cat {
    private String name;
    public String getName() {
        return name;
    }
    public Cat() {
    }
    public Cat(String name) {
        this.name = name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public static Cat create(Supplier<Cat> sup) {
        return sup.get();
    }
    public void run() {
        System.out.println(name + " is running");
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Cat cat = (Cat) o;
        return Objects.equals(name, cat.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

测试函数示接口返回构造器和方法的示例：

public class TestReferrenceLambda {
    public static void main(String ... args) {
        Cat cat = Cat.create(Cat::new);
        cat.setName("cat0");
        List<Cat> cats = Arrays.asList(cat, new Cat("cat1"), new Cat("cat2"), new Cat("cat3"));
        cats.forEach(Cat::run);
    }
}
三、default关键字

default关键字是Java8中引入的关键字，在此之前，Java接口不能有方法体函数的，default关键字让接口可以有默认的方法体。

一个有方法体的Java接口如下：

public interface TestDefault {
    default void defaultMethod() {
        System.out.println("this is default method in interface");
    }
    void apply ();
}

测试示例：

public class TestDefaultImpl implements TestDefault {
    @Override
    public void apply() {
        System.out.println("implement method of interface");
    }
    public static void main(String ... args) {
        TestDefault testDefault = new TestDefaultImpl();
        testDefault.defaultMethod();
        testDefault.apply();
    }
}
四、Function接口

Function接口是一个函数式接口，它包含三个默认方法和一个抽象方法。

@FunctionalInterface
public interface Function<T, R> {
	 // 将参数赋予相应的方法
    R apply(T t);
	// 默认方法，先调用入参的apply方法，再调用自身的apply方法
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
	// 默认方法，先调用自身的apply方法，再调用入参的apply方法
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
	// 静态方法，返回当前正在执行的方法
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

测试示例：

public class TestFunction {

    public static void main(String ... args) {
        Function<Long, Long> plus2Func = (n) -> n + 2;
        Function<Long, Long> doubleFunc = (n) -> n * 2;

        System.out.println(plus2Func.apply(3L)); // 3 + 2
        System.out.println(doubleFunc.apply(3L)); // 3 * 2
        System.out.println(plus2Func.andThen(doubleFunc).apply(3L)); // (3 + 2) * 2
        System.out.println(plus2Func.compose(doubleFunc).apply(3L)); // 3 * 2 + 2
     	System.out.println(Function.identity().compose(doubleFunc).apply(3L)); // 3 * 2
    }
}
五、Consumer接口

Consumer接口也是一个函数示接口，它包含一个默认方法和一个抽象方法。

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
	// 默认方法，先执行自身的accept方法，再执行入参的accept方法
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

使用示例：

public class TestComsumer {
    public static void main(String ... args) {
        Consumer<Integer> consumer = (n) -> {
            n = n * 2;
            System.out.println(n);
        };
        Consumer<Integer> consumer1 = (n) -> {
            n = n + 5;
            System.out.println(n);
        };
        consumer.andThen(consumer1).accept(10);
    }
}
六、Predicate接口

Predicate接口包含三个默认方法，一个静态方法和一个抽象方法。

@FunctionalInterface
public interface Predicate<T> {
	// 返回布尔值，用于校验
    boolean test(T t);
	// 默认方法，接收一个Predicate参数，用于判断两个条件是否都成立
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
	// 默认方法，对判断取反
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
	// 默认方法，接收一个Predicate参数，用于判断两个条件是否至少有一个成立
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

测试示例：

public class TestPredicate {
    public static void main(String... args) {
        System.out.println(judge("abcde", (p) -> p.startsWith("a")) );
        System.out.println(judgeNo("abcde", (p) -> p.startsWith("a")) );
        System.out.println(judgeAnd("abcde", (p) -> p.startsWith("a"), (p) -> p.length() > 10) );
        System.out.println(judgeOr("abcde", (p) -> p.startsWith("a"), (p) -> p.length() > 10) );

        System.out.println(Predicate.isEqual("test").test("test"));
        System.out.println(Predicate.isEqual("test").test("test1"));
    }
    private static boolean judge(String str, Predicate<String> condition) {
        if (null == str) {
            return false;
        }
        return condition.test(str);
    }
    private static boolean judgeNo(String str, Predicate<String> condition) {
        if (null == str) {
            return false;
        }
        return condition.negate().test(str);
    }
    private static boolean judgeAnd(String str, Predicate<String> condition1, Predicate<String> condition2) {
        if (null == str) {
            return false;
        }
        return condition1.and(condition2).test(str);
    }
    private static boolean judgeOr(String str, Predicate<String> condition1, Predicate<String> condition2) {
        if (null == str) {
            return false;
        }
        return condition1.or(condition2).test(str);
    }
}
七、Stream工具类

Java8中引入了对集合数据进行处理的Stream流，主要用于集合数据的筛选、过滤、计算等操作。它不会存储和修改元素，遍历结束即消费结束。

public class TestStream {

    public static void main(String ... args) {
        createStream();
        streamFilter();
        streamMap();
        streamSort();
        streamStop();
        streamReduce();
        streamCollect();
    }

	// 创建Stream流
    private static void createStream() {
        List<String> list = Arrays.asList("abc", "cde", "hij");
        Stream<String> stream1 = list.stream();  // 通过集合创建
        Stream<String> stream2 = list.parallelStream();  // 通过集合创建
        stream1.forEach(System.out::println);
        stream2.forEach(System.out::println);
        Stream<Integer> strea3 = Stream.iterate(2, (x) -> x * 2).limit(5);  // 通过函数创建
        strea3.forEach(System.out::println);
        Stream<Double> stream4 = Stream.generate(Math::random).limit(5);  // 通过函数创建
        stream4.forEach(System.out::println);
        Stream<String> stream5 = Stream.of("abc", "def"); // 通过值创建
        Stream<String> stream6 = Arrays.stream(strings);  // 通过数组创建
     }
     
	// 中间方法：filter、distinct、limit、skip
	// filter:在流中筛选一些符合要求的元素
	// distinct:在流中利用equals方法去除某些相同的元素
	// limit: 在流中数据达到最大值时截断流
	// skip: 丢弃流中的前n个元素
     private static void streamFilter() {
        List<Cat> cats = Arrays.asList(new Cat("abc"), new Cat("abc"), new Cat("def"), new Cat("ghi"), new Cat("lmn1"));
        cats.stream().filter((cat) -> cat.getName().length() < 4).distinct().limit(3).skip(1).forEach(System.out::println);
     }
     
	// 映射：map、flatmap
	// map: 对于Stream中包含的元素使用给定的转换函数进行转换操作，新生成的Stream只包含转换生成的元素。
	// flatMap：和map类似，不同的是其每个元素转换得到的是Stream对象，会把子Stream中的元素压缩到父集合中
     private static void streamMap() {
         List<Cat> cats = Arrays.asList(new Cat("abc"), new Cat("abc"), new Cat("def"), new Cat("ghi"), new Cat("lmn1"));
         List<Cat> cats2 = Arrays.asList(new Cat("lmnabcde"));
         cats.stream().map((cat) -> cat.getName() + " -> feeded").forEach(System.out::println);
         Stream.of(cats, cats2).flatMap((list) -> list.stream()).map((cat) -> cat.getName() + " -> not feeded").forEach(System.out::println);
     }

	// 排序：sort、sorted
	// sort: 按照自然规则排序
	// sorted: 按照给定规则排序
     private static void streamSort() {
         List<Cat> cats = Arrays.asList(new Cat("abc"), new Cat("abc"), new Cat("def"), new Cat("ghi"), new Cat("lmn1"));
         cats.stream().map(cat -> cat.getName().length()).sorted().forEach(System.out::println);
         cats.stream().sorted(Comparator.comparing(cat -> -1 * cat.getName().length())).forEach(System.out::println);
     }
	
	// 终止操作
	// count: 返回流中的元素个数
	// allMatch: 流中的元素是否都满足Predicate条件
	// anyMatch: 流中是否有元素满足Predicate条件
	// max: 返回Comparator比较后的最大值
     private static void streamStop() {
         List<Cat> cats = Arrays.asList(new Cat("abc"), new Cat("abc"), new Cat("def"), new Cat("ghi"), new Cat("lmn1"));
         System.out.println(cats.stream().count());
         System.out.println(cats.stream().allMatch((cat) -> cat.getName().equals("abc")));
         System.out.println(cats.stream().anyMatch((cat) -> cat.getName().equals("abc")));
         System.out.println(cats.stream().max((cat1, cat2) -> cat1.getName().length() - cat2.getName().length()));
     }
	
	// 归约
	// reduce(b): 将流中的元素经过指定运算，折叠成一个元素输出
	// reduce(a, b): 将流中的元素经过指定运算，折叠成一个元素输出，指定起始值a
     private static void streamReduce() {
         List<Cat> cats = Arrays.asList(new Cat("abc"), new Cat("abc"), new Cat("def"), new Cat("ghi"), new Cat("lmn1"));
         System.out.println(cats.stream().map(cat -> cat.getName().length()).reduce(Integer::sum));
         System.out.println(cats.stream().map(cat -> cat.getName().length()).reduce(3, Integer::sum));
     }

	// collect，将流转换成集合的形式
     private static void streamCollect() {
         List<Cat> cats = Arrays.asList(new Cat("abc"), new Cat("abc"), new Cat("adef"), new Cat("aghi"), new Cat("lmn1"));
         Set<Cat> set = cats.stream().filter(cat -> cat.getName().startsWith("a")).collect(Collectors.toSet());
         set.stream().forEach(System.out::println);
     }
}
Jerry的技术博客
关注
专栏目录
java8 Lambda表达式
菜鸟进阶之路
05-02 3209
一、概述 java为了引入函数式编程的特性在java8中引入了一个全新的概念“lambda表达式”，同时为了使“lambda表达式”与现有的类库无缝结合，引入了default关键字，允许在接口中定义default的默认实现方法，同时允许在接口中定义static静态实现方法，这两者在java7中是不允许的。lambda表达式从语法层面看极大的简化了匿名内部类的使用，将匿名内部类声明过程中...
Java练习（八）---return用法
不学习，永远发现不了自己的潜力
02-21 175
public static void main(String[] args) { for (int i = 1; i < 4; i++) { if (i==3){ System.out.println("小王是猪"); return; } System.out.println("小王是狗"); } System.out.
java8 return_在Java8的foreach()中使用return/break/continue，不会跳出循环
weixin_29133151的博客
02-25 358
今天使用lambda表达式处理集合时，发现对return、break以及continue的使用有点迷惑，于是自己动手测试了一下，才发现在使用foreach()处理集合时不能使用break和continue这两个方法，也就是说不能按照普通的for循环遍历集合时那样根据条件来中止遍历，而如果要实现在普通for循环中的效果时，可以使用return来达到，也就是说如果你在一个方法的lambda表达式中使用...
常用的函数式接口_Function接口_默认方法andThen
Leon_Jinhai_Sun的博客
03-08 757
默认方法：andThen Function 接口中有一个默认的andThen 方法，用来进行组合操作。JDK源代码如： default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) { Objects.requireNonNull(after); ret...
java基础复习--常用的4个函数式接口
m0_46275020的博客
04-13 382
常用的4个函数式接口 前言 大家好，我是一名正在努力学java的学生，注册CSDN有段时间了，今天终于心血来潮想冒个泡！水平有限，望各位笑纳。 JDK8.0最大的热点，就是迎来函数式编程，在java.util.function包下，更新了众多函数式接口。 使用lambda表达式，极大地提升了敲代码的效率，但是对初学者来说可能比较难以理解，今天复习基础知识中顺便复习了函数式接口。 一：Supplie...
Java-8-Function
Coder_py的博客
02-02 285
Java-8-Function interface Function<T, R> 源码: @FunctionalInterface public interface Function<T, R> { R apply(T t); default <V> Function<V, R> compose(Functi...
Java 8 lambda表达式
06-27
Java 8 的引入，尤其是Lambda表达式，对Java语言产生了深远的影响，它为Java开发者带来了更简洁、更灵活的编程方式。Lambda表达式是函数式编程的核心元素，它允许我们将函数作为方法参数传递，或者将代码块当作数据...
Java8新特性Lambda表达式的一些复杂用法总结
08-29
Java 8引入了Lambda表达式，这是一种强大的新特性，它为Java编程语言带来了函数式编程的概念。Lambda表达式允许程序员创建匿名函数，即没有名称的函数，这些函数可以直接作为值传递给方法或存储在变量中。这使得代码...
java8 lambda表达式学习总结
04-23
1. **类型推断**：Java 8 可以自动推断Lambda表达式的参数类型，因此在许多情况下，我们无需显式声明类型。 2. **捕获外部变量**：Lambda 表达式可以访问和修改其定义范围内的 final 或基本类型的局部变量。 3. **...
Java8 Lambda表达式模板方法实现解析
09-07
Java8 Lambda表达式是Java语言的一个重要特性，它引入了函数式编程的概念，极大地简化了对匿名函数的处理。Lambda表达式使得代码更加简洁、易读，并且在处理集合操作时特别有用，如流(Stream) API的使用。下面将详细...
Java 8 Lambda 表达式比较器使用示例代码
08-25
Java 8 Lambda 表达式比较器使用示例代码 Java 8 Lambda 表达式比较器使用示例代码主要介绍了如何使用 Java 8 Lambda 表达式编写一个 Comparator 来对 List 进行排序。下面将详细说明 Lambda 表达式比较器的使用...
JAVA中List集合去重的方案，通过Function函数接口自定义一个UniqueSet
weixin_42454225的博客
04-17 897
Function<T, R>函数接口自定义一个UniqueSet 在开发中，有很多地方需要实现： 一个List中Person对象，根据Person对象中的age年龄去重，留下年龄不重复的集合。 实现方案一： 也是最传统最简单的：{{{width=“50” height=“50”}}} List<Person> list = new ArrayList(); //将list转成TreeSet 自定义一个比较器compartor Set b
遍历function的写法
MaWenDong
07-07 418
function Test1() print("func:1") end function Test2() print("func:2") end function Test3() print("func:3") end local tab = {} tab.test1 = {} tab.test1.time = 0 tab.test1.func = Test1 tab.test2 = {} tab.test2.time = 0 tab.test2.func = Test2 t...
JDK8之Function接口
热门推荐
Jim Huang的程序Blog
09-09 1万+
新特性中有个Function接口用在支持lamdba表达式。 个人理解这个接口就是把一些输入参数封装在1个 or n个方法内，并且输出的结果类型可以和参数一致 or 不一致。 同时可以利用这个接口不断把方法迭代，用来完成方法的组合。 如果大家对于这个类的用法还有其他的想法，欢迎留言。 1.  R apply(T t) ->  将function对象应用到输入的参数上
Function函数接口解析
代码的诱惑
01-31 1319
此函数接口相对java8是基础 仅有一个抽象方法的接口可以称之为函数式接口，同时在Function接口中你可能看到的不是一个方法，java8的新特性中有一个是接口可以有默认的接口实现。所有compose，andThen，identity三个方法都符合函数式接口的允许范围。那么他唯一的一个抽象接口是apply。 方法解析 Function接口定义 注意：上面有@Functio
【Java8】Function 讲解
sowhat
02-20 6113
Java8 添加了一个新的特性Function，顾名思义这一定是一个函数式的操作。我们知道Java8的最大特性就是函数式接口。所有标注了@FunctionalInterface注解的接口都是函数式接口，具体来说，所有标注了该注解的接口都将能用在lambda表达式上。 标注了@FunctionalInterface的接口有很多，但此篇我们主要讲Function，了解了Function其他的操作也就...
Java8之Function函数、BiFunction函数详解
最新发布
qq_43842093的博客
11-23 8415
它也是一个函数式接口，它是Function 的 另一种形式，它接收两个参数（T，U），返回一个参数（R）。那么接下来我们看看这个接口里面有哪些方法吧。
Java8日期/时间使用
xktxoo的博客
06-10 8028
一、名词 时间戳（时刻）：时间戳是指格林尼治时间1970年01月01日00时00分00秒到现在的总秒数（毫秒数），可以理解成绝对时间，它与时区无关，不同时区对同一时间戳的解读不一样 时区：同一时刻（时间戳），世界上各地区的时间可能是不一样的，具体时间与时区相关，按经度一共分为24个时区，英国格林尼治是0时区，中国北京是东8区 二、Java8时间 2.1 Java8时间 Java1.0版本时...
深入理解Java 8 Lambda表达式
"精通Java 8 Lambda表达式" 在Java 8中，Lambda表达式是一项重要的新特性，它极大地简化了函数式编程，使得代码更加简洁、易读。Lambda表达式是Java对函数式编程风格的一种引入，允许将匿名函数作为参数传递给方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值