精华内容
下载资源
问答
  • 抛出受检异常的时候,我们的接口应该带上throw关键字,但通过lambda表达式实现的Consumer的accept方法并不带有关键字,因此在lambda表达式中不能抛出受检异常必须把它吃掉 转载于:...

    抛出受检异常的时候,我们的接口应该带上throw关键字,但通过lambda表达式实现的Consumer的accept方法并不带有关键字,因此在lambda表达式中不能抛出受检异常必须把它吃掉

     

      

     

    转载于:https://www.cnblogs.com/lccsblog/p/11341200.html

    展开全文
  • //编译通过 Stream.of("a", "b", "c").forEach(str -> { throw new RuntimeException(new IOException()); }); 转换成RuntimeException即可

    //编译通过
    Stream.of("a", "b", "c").forEach(str -> {
        throw new RuntimeException(new IOException());
    });

    转换成RuntimeException即可

    展开全文
  • 今儿在使用lambda表达式时,lambda表达式内出现了异常,准备直接抛出,没想到却还是报错: 由于博主lambda表达式用的比较少,刚看到这问题时,可以说是一脸懵逼.毕竟两边的提示可以说是前后矛盾啊. 刷新几下编译器还是...

    问题描述

    今儿在使用lambda表达式时,lambda表达式内出现了异常,准备直接抛出,没想到却还是报错:
    在这里插入图片描述
    由于博主lambda表达式用的比较少,刚看到这问题时,可以说是一脸懵逼.毕竟两边的提示可以说是前后矛盾啊.
    刷新几下编译器还是报错,就只能老老实实的找原因.

    问题原因

    所幸Java是一门比较成熟的语言,前辈们已经踩了足够的坑.
    之所以有这种现象是因为lambda表达式本身没有处理异常的机制 ,以至于遇到受检异常时,无法通过主动抛出来解决.
    但具体的也不是很清楚了,若有其他道友遇到这种问题,欢迎评论区留言讨论.

    解决方案

    将受检异常包装成非受检异常,即RuntimeException

    效果如下:
    在这里插入图片描述

    虽然效果还是不甚理想,就当涨了一波lambda表达式的熟练度吧.
    老老实实的用普通循环写也是不错的

    参考内容

    1. jdk8 lambda表达式抛出异常
    2. lambda表达式处理异常

    如果大家遇到了类似的问题,欢迎在评论区一起交流探讨

    展开全文
  • java的lambda表达式

    2020-01-20 17:10:36
    lambda表达式的格式 以->分隔,前边是参数列表,后边是表达式体也就是具体要执行得到逻辑。 根据参数列表的个数有无返回值等可以分为6种形式,这个不必多说。...需要注意的是,若 Lambda 表达式抛出一个受检异常...

    lambda表达式的格式

    以->分隔,前边是参数列表,后边是表达式体也就是具体要执行得到逻辑。
    根据参数列表的个数有无返回值等可以分为6种形式,这个不必多说。
    在这里插入图片描述

    lambda表达式依赖函数式接口

    lambda表达式依赖于函数式接口,即只有一个抽象方法的接口。个人理解表达式体就是实现那个唯一抽象方法的。也就是创建了一个实现这个接口的一个对象。需要注意的是,若 Lambda 表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明,也就是lambda表达式里不能抛出异常,或者try/catch。
    我们可以在任意函数式接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口。
    在这里插入图片描述

    Java内置的四大函数式接口

    在这里插入图片描述

    @Test
        public void test6() {
            Supplier<String> supplier = ()->"532323".substring(0, 2);
            System.out.println(supplier.get());
        }
        @Test
        public void test7() {
            Function<String, String> function = (x)->x.substring(0, 2);
            System.out.println(function.apply("我是中国人"));
        }
        @Test
        public void test8() {
            Predicate<String> predicate = (x)->x.length()>5;
            System.out.println(predicate.test("12345678"));
            System.out.println(predicate.test("123"));
        }
    

    运行结果:
    在这里插入图片描述

    关于lambda表达式里不能抛出受查异常问题

    首先,运行时异常可以抛出,因为运行时异常编译器不管,只有在程序运行时发生后直接挂掉程序就行。但是受查异常编译器要求必须处理,否则编译不通过,要么try/catch掉要么向上抛让,但是lambda里不能向上抛,原因是lambda表达式本质是执行了函数式接口里的那个唯一抽象方法,如果这个方法抛异常那么这个接口也要抛异常,但是这个接口源码是不能改的,也就是不能抛出去异常。如果你自己定义的函数接口那个抽象方法抛出了异常,那么lambda表达式就可以抛异常。

    自己写的例子

    package com.company.java8.lambda;
    @FunctionalInterface
    public interface ConsumerInterface <T>{
        void accept(T t);
    }
    
    
    package com.company.java8.lambda;
    
    
    import java.util.List;
    
    public class TestStream<T> {
        private List<T> list;
        public void myForEach(ConsumerInterface<T> sonsumer){
            for(T t:list){
                sonsumer.accept(t);
            }
        }
        public void setList(List<T> list){
            this.list=list;
        }
    }
    
    
    package com.company.java8.lambda;
    
    import java.util.Arrays;
    import java.util.List;
    
    public class Test {
        public static void main(String[] args){
            TestStream<String> stream = new TestStream<String>();
            List list = Arrays.asList("11","22","33");
            stream.setList(list);
            stream.myForEach(str -> {System.out.println(str);
               // 只有函数式接口里的方法抛出异常,这里才能抛出异常
           //相当于在这里重写了accept方法
            });
        }
    }
    
    
    
    

    ``
    运行结果:
    在这里插入图片描述

    又一个例子

    public interface Cook {
        void makeFood();
        }
    
    public class Demo05InvokeCook {
        public static void main(String[] args) {
            // TODO 请在此使用Lambda【标准格式】调用invokeCook方法
             invokeCook(()> {
           System.out.println("吃饭啦!");  
        });
        }
        private static void invokeCook(Cook cook) {
            cook.makeFood();
        }
        }
    

    又又又一个例子

    public class Person {
        private String name;
        private int age;
       
        // 省略构造器、toString方法与Getter Setter
    }
    

    传统写法
    如果使用传统的代码对 Person[] 数组进行排序,写法如下:

    public class Demo06Comparator {
        public static void main(String[] args) {
           // 本来年龄乱序的对象数组  
            Person[] array = {
             new Person("古力娜扎", 19),    
             new Person("迪丽热巴", 18),    
            new Person("马尔扎哈", 20) };     
           // 匿名内部类  
            Comparator<Person> comp = new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    return o1.getAge() ‐ o2.getAge();
                }
            };
            Arrays.sort(array, comp); // 第二个参数为排序规则,即Comparator接口实例
            for (Person person : array) {
                System.out.println(person);
            }
        }
    }
    

    下面我们来搞清楚上述代码真正要做什么事情。
    为了排序, Arrays.sort 方法需要排序规则,即 Comparator 接口的实例,抽象方法 compare 是关键;
    为了指定 compare 的方法体,不得不需要 Comparator 接口的实现类;
    为了省去定义一个 ComparatorImpl 实现类的麻烦,不得不使用匿名内部类;
    必须覆盖重写抽象 compare 方法,所以方法名称、方法参数、方法返回值不得不再写一遍,且不能写错;
    实际上,只有参数和方法体才是关键。
    说白了就是我要执行一个函数式接口里的方法,甭new对象啥的啦,直接需要的地方重写方法得了。
    Lambda写法

    public class Demo07ComparatorLambda {
        public static void main(String[] args) {
            Person[] array = {
               new Person("古力娜扎", 19),  
               new Person("迪丽热巴", 18),  
               new Person("马尔扎哈", 20) };  
            Arrays.sort(array, (Person a, Person b)> {
               return a.getAge() ‐ b.getAge();  
            });
            for (Person person : array) {
                System.out.println(person);
            }
        }
    }
    

    再来一个例子吧

    @FunctionalInterface
    public interface ConInterface2 {
         void doSom(List d);
    }
    
    package com.company.java8.lambda;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class MainTest {
        public static void main(String[] args) {
            List<String> a = new ArrayList();
            a.add("aaa");
            a.add("bbb");
            //方式一
            ConInterface2 cif = (gg) -> System.out.println(gg.get(1));
            cif.doSom(a);
    
            //方式二
            bb(a,(List q) -> {
                System.out.println(q.get(1));
            });
        }
             private static void bb(List w,ConInterface2 c2){
                 c2.doSom(w);
             }
    
    }
    
    

    运行结果

    bbb
    bbb
    
    展开全文
  • 抛出一个受检异常(即:非运行时异常),那么该异常需要在目标接口的抽 象方法上进行声明)。 我们可以在一个接口上使用 @FunctionalInterface 注解,这样做可以检 查它是否是一个函数式接口。同时 javadoc 也会包...
  •   先暂时将Java8中的Lambda表达式看成匿名的函数,它跟一般的方法类似,一样具有参数类型、函数主体、返回值甚至可抛出异常列表。但是,它与一般方法最大的不同是:它可以作为参数传递给方法或者存储在变量中。可...
  • 函数式接口

    2019-08-24 21:47:45
    背景: Lambda表达式针对的都是接口,相当于是给接口提供具体的实现类的对象时使用Lambda表达式,且这个接口中...(若Lambda表达式抛出一个受检异常(即:非运行时异常),那么该异常需要在目标接口的抽象方法上进行声...
  • 可以在函数式接口上使用λ表达式,函数式接口就是只定义一个抽象方法的接口(函数式接口只可以定义一个抽象接口,但是可以定义多个默认方法...请注意,任何函数式接口都不允许抛出受检异常(checked exception)。如果...
  • 函数式接口 ...通过Lambda表达式来创建该接口的对象,若Lambda表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明。 ​ 为了确保你的接口一定达到这个要求,你只需要给你的接口添加...
  • 通过Lambda 表达式来创建该接口的对象(若Lambda 表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明); 我们可以在任意函数式接口上使用@FunctionalInterface注解,这样做可以检查它是否是一...
  • (若Lambda接口抛出一个受检异常,那么该异常需要在接口目标接口的抽象方法上进行声明)  3) 在任何函数式接口上使用@FunctionalInterface注解,可以检查该接口中是否是一个函数式接口。 2. 常用的JDK自定义的...
  • (若 Lambda 表达式抛出一个受检异常(即:非运行时异常),那么该异常需要在目标接口的抽象方法上进行声明) (3)我们可以在一个接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口。...
  • 1、什么是函数式接口 ...(若 Lambda表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明)。 我们可以在任意函数式接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数...
  • 第03篇 函数式接口

    2019-11-09 23:08:28
    (若 Lambda表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明)。 我们可以在任意函数式接口上使用 @FunctionalInterface 注解, 这样做可以检查它是否是一个函数式接口,同时 javadoc 也会包 含...
  • (若 Lambda表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明)。 我们可以在任意函数式接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口,同时 javadoc 也会...
  • (若 Lambda表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明)。 2 我们可以在任意函数式接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口,同时 javadoc 也会...
  • (若Lambda表达式抛出一个受检异常(即非运行时异常),那么该异常需要在目标接口的抽象方法上进行声明)。 我们可以在一个接口上使用@Functiongallnterface注解,这样做可以检查它是否是一个...
  • Java之函数式接口源码解析

    千次阅读 2020-09-28 20:23:17
    (若 Lambda 表达式抛出一个受检异常(即:非运行时异常),那么该异常需要在目标接口的抽象方法上进行声明)。 我们可以在一个接口上使用 @FunctionalInterface注解,这样做可以检查它是否是一个函数式接口。同时 ...
  • Java8-函数式接口

    2020-12-10 11:15:36
    (若 Lambda 表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明)。 我们可以在任意函数式接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口,同时 javadoc 也会包...
  • jdk1.8新特性 函数式接口

    千次阅读 2018-05-09 13:29:55
    (若Lambda 表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明)。 3、我们可以在任意函数式接口上使用@FunctionalInterface注解,这样做可以检查它是否是一个函数式接口,同时javadoc也会...
  • Java函数式接口

    2020-12-14 14:17:29
    Lambda 表达式抛出一个受检异常(即:非运行时异常),那么该异常需要在目标接口的抽象方法上进行声明。 我们可以在一个接口上使用 @FunctionalInterface 注解,这样做可以检查它是否是一个函数式接口。同时 javadoc...
  • 抛出一个受检异常(即:非运行时异常),那么该异常需要在目标接口的抽 象方法上进行声明)。 ●我们可以在- 一个接口上使用@FunctionalInterface注解,这样做可以检 查它是否是一个函数式接口。同时javadoc也会包含一条...
  • 抛出一个受检异常(即:非运行时异常),那么该异常需要在目标接口的抽 象方法上进行声明)。 ●我们可以在- 一个接口上使用@FunctionalInterface注解,这样做可以检 查它是否是一个函数式接口。同时javadoc也会包含一条...
  • (若Lambda表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明)。 (3)、我们可以在任意函数式接口上使用@FunctionalInterface注解,这样做可以检查它是否是一个函数式接口,同时javadoc也会...
  • 函数式Functional接口什么是函数式式(Functional)...(若 Lambda 表达抛出一个受检异常(即:非运行时异常),那么该异常需要在目标接口的象方法上进行声明)。 我们可以在一个接口上使用 @FunctionalInterface 注解,这

空空如也

空空如也

1 2
收藏数 26
精华内容 10
关键字:

lambda抛出受检异常