精华内容
下载资源
问答
  • (1)super引用父类方法 public class Human extends Man { @Override public void sayHello() { System.out.println("我是Human"); } public void method(Greentable g){ g.green(); } public void show...

    (1)super引用父类方法

    public class Human extends Man {
        @Override
        public void sayHello() {
            System.out.println("我是Human");
        }
        public void method(Greentable g){
            g.green();
        }
        public void show(){
            //使用匿名内部类实现
            method(new Greentable() {
                @Override
                public void green() {
                    Man man = new Man();
                    man.sayHello();
                }
            });
            //使用Lambda表达式优化
            method(()->{
                super.sayHello();
            });
            //使用方法引用优化
            method(super::sayHello);
    
        }
    
        public static void main(String[] args) {
            Human human = new Human();
            human.show();
    
        }
    }
    

    (2)父类

    public class Man {
        public void sayHello(){
            System.out.println("我是Man");
        }
    }

    (3)函数式接口

    @FunctionalInterface
    public interface Greentable {
        void green();
    }

     

    展开全文
  • * 方法引用: * 当Lambda表达式中仅仅调用一个已经存在的方法时, * 我们就可以使用方法引用代替Lambda表达式。这样 * 可以让程序进一步简洁。 * * 方法引用分为以下四种: * 1 引用静态方法 * 2 通过对象...
    /*
     * 方法引用:
     * 当Lambda表达式中仅仅调用一个已经存在的方法时,
     * 我们就可以使用方法引用代替Lambda表达式。这样
     * 可以让程序进一步简洁。
     * 
     * 方法引用分为以下四种:
     * 1 引用静态方法
     * 2 通过对象(引用)引用实例方法
     * 3 通过类型引用实例方法
     * 4 引用构造器
     */
        public class MethodReference {
        public static void main(String[] args) {
            Person person1 = new Person("人1", 20, 150, 160);
            Person person2 = new Person("人2", 30, 150, 120);
            Friend f = (p1, p2) -> Person.makeFriend(p1, p2);
            // f.makeFriend(person1, person2);
            // 引用静态方法,抽象方法的每个参数会依次传递给
            // 所引用的静态方法。
            f = Person::makeFriend;
    
            Tools tool = new Tools();
            f = (p1, p2) -> tool.makeFriend(p1, p2);
            // 通过对象引用实例方法
            // 抽象方法的每个参数会依次传递给所引用的实例方法。
            f = tool::makeFriend;
    
            f = (p1, p2) -> p1.makeFriend2(p2);
            // 通过类型引用实例方法
            // 抽象方法第一个参数用来从当所引用实例方法的调用对象。
            // 抽象方法的第二个参数起,会依次传递给所引用的实例方法。
            f = Person::makeFriend2;
    
            Create c = (name, age, height, weight) -> new Person(name, age, height, weight);
            // 引用构造器
            //抽象方法的每个参数会依次传递给所引用构造器的参数
            c = Person::new;
        }
    }
    
    @FunctionalInterface
    interface Friend {
        // 两个人交朋友
        void makeFriend(Person p1, Person p2);
    }
    
    @FunctionalInterface
    interface Create {
        Person build(String name, int age, int height, int weight);
    }
    
        class Person {
        private String name;
        private int age;
        private int height;
        private int weight;
    
        public Person(String name, int age, int height, int weight) {
            super();
            this.name = name;
            this.age = age;
            this.height = height;
            this.weight = weight;
        }
    
        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 int getHeight() {
            return height;
        }
    
        public void setHeight(int height) {
            this.height = height;
        }
    
        public int getWeight() {
            return weight;
        }
    
        public void setWeight(int weight) {
            this.weight = weight;
        }
    
        public void makeFriend2(Person p) {
            //使用当前对象this与参数p交朋友
        }
    
        public static void makeFriend(Person p1, Person p2) {
            //两个人交朋友的细节
            System.out.println("两个人交朋友的细节");
        }
    }
        class Tools {
            public void makeFriend(Person p1, Person p2) {
                System.out.println("两个人交朋友的细节");
            }
        }
    展开全文
  • Java 提供了一种生成函数对象的方法,比 lambda 还要简洁,那就是:方法引用(method references)。下面是一段程序代码片段,它维护一个从任意键到整数值的映射。如果将该值解释为键的实例个数,则该程序是一个多重...

    43. 方法引用优于 lambda 表达式

    lambda 优于匿名类的主要优点是它更简洁。Java 提供了一种生成函数对象的方法,比 lambda 还要简洁,那就是:方法引用(method references)。下面是一段程序代码片段,它维护一个从任意键到整数值的映射。如果将该值解释为键的实例个数,则该程序是一个多重集合的实现。该代码的功能是,根据键找到整数值,然后在此基础上加 1:

    map.merge(key, 1, (count, incr) -> count + incr);
    

    请注意,此代码使用 merge 方法,该方法已添加到 Java 8 中的 Map 接口中。如果没有给定键的映射,则该方法只是插入给定值; 如果映射已经存在,则合并给定函数应用于当前值和给定值,并用结果覆盖当前值。 此代码表示 merge 方法的典型用例。

    代码很好读,但仍然有一些样板的味道。 参数 countincr 不会增加太多价值,并且占用相当大的空间。 真的,所有的 lambda 都告诉你函数返回两个参数的和。 从 Java 8 开始,Integer 类(和所有其他包装数字基本类型)提供了一个静态方法总和,和它完全相同。 我们可以简单地传递一个对这个方法的引用,并以较少的视觉混乱得到相同的结果:

    map.merge(key, 1, Integer::sum);
    

    方法的参数越多,你可以通过方法引用消除更多的样板。 然而,在一些 lambda 中,选择的参数名称提供了有用的文档,使得 lambda 比方法引用更具可读性和可维护性,即使 lambda 看起来更长。

    只要方法引用能做的事情,就没有 lambda 不能完成的(只有一种情况例外 - 如果你好奇的话,参见 JLS,9.9-2)。 也就是说,使用方法引用通常会得到更短,更清晰的代码。 如果 lambda 变得太长或太复杂,它们也会给你一个结果:你可以从 lambda 中提取代码到一个新的方法中,并用对该方法的引用代替 lambda。 你可以给这个方法一个好名字,并把它文档记录下来。

    如果你使用 IDE 编程,它将提供替换 lambda 的方法,并在任何地方使用方法引用。通常情况下,你应该接受这个提议。偶尔,lambda 会比方法引用更简洁。这种情况经常发生在方法与 lambda 相同的类中。例如,考虑这段代码,它被假定出现在一个名为 GoshThisClassNameIsHumongous 的类中:

    service.execute(GoshThisClassNameIsHumongous::action);
    

    这个 lambda 类似于等价于下面的代码:

    service.execute(() -> action());
    

    使用方法引用的代码段并不比使用 lambda 的代码片段更短也不清晰,所以优先选择后者。 在类似的代码行中,Function 接口提供了一个通用的静态工厂方法来返回标识函数 Function.identity()。 不使用这种方法,而是使用等效的 lambda 内联代码:x -> x,通常更短,更简洁。

    许多方法引用是指静态方法,但有 4 种方法没有引用静态方法。 其中两个 Lambda 等式是特定(bound)和任意(unbound)对象方法引用。 在特定对象引用中,接收对象在方法引用中指定。 特定对象引用在本质上与静态引用类似:函数对象与引用的方法具有相同的参数。 在任意对象引用中,接收对象在应用函数对象时通过方法的声明参数之前的附加参数指定。 任意对象引用通常用作流管道(pipelines)中的映射和过滤方法(条目 45)。 最后,对于类和数组,有两种构造方法引用。 构造方法引用用作工厂对象。 下表总结了所有五种方法引用:

    方法引用类型
    Method Ref Type
    举例
    Example
    Lambda 等式
    Lambda Equivalent
    Static Integer::parseInt str -> Integer.parseInt(str)
    Bound Instant.now()::isAfter Instant then = Instant.now();
    t -> then.isAfter(t)
    Unbound String::toLowerCase str -> str.toLowerCase()
    Class Constructor TreeMap<K, V>::new () -> new TreeMap<K, V>
    Array Constructor int[]::new len -> new int[len]

    总之,方法引用通常为 lambda 提供一个更简洁的选择。 如果方法引用看起来更简短更清晰,请使用它们;否则,还是坚持 lambda。

    展开全文
  • Java8方法引用

    千次阅读 2018-06-13 10:06:42
    Java8中方法引用Demo详解1.1 方法引用出现的背景在使用Lambda表达式的时候,我们实际上传递进去的代码就是一种解决方案:拿什么参数做什么操作。 那么考虑一种情况:如果我们在Lambda中所指定的操作方案,已经有...

    内容简介:

    1. 方法引用Demo详解

    2. 通过5种语法使用方法引用

    3. 方法引用使用总结

    1. 在Java8中方法引用Demo详解

    1.1 方法引用出现的背景

    在使用Lambda表达式的时候,我们实际上传递进去的代码就是一种解决方案:拿什么参数做什么操作。
    那么考虑一种情况:如果我们在Lambda中所指定的操作方案,已经有地方存在相同方案,那是否还有必要再写重复逻辑呢?

    1.2 问题的引出

    
        //函数式接口,用于打印字符串.
        @FunctionalInterface
        interface Print{
            public void print(String s);
        }
        
        //使用lambda表达式完成案例测试.
        public class PrintDemo {
        
            public static void main(String[] args) {
                //Lambda方式解决
                print(s -> {System.out.println(s);}, "hello");
            }
            
            public static void print(Print p,String s){
                p.print(s);
            }
        }
    
    
        输出结果:
                hello

    1.3 问题的发现与解决

    
    这段代码的问题在于,对String进行控制台打印输出的操作方案,明明已经有了现成的实现,那就是System.out对象中的println(String)方法。既然Lambda希望做的事情就是调用println(String)方法,那何必自己手动调用呢?
    能否省去Lambda的语法格式(尽管它已经相当简洁)呢?只要“路由”过去就好了:
    
        //函数式接口,用于打印字符串.
        @FunctionalInterface
        interface Print{
            public void print(String s);
        }
        
        //使用lambda表达式完成案例测试.
        public class PrintDemo {
        
            public static void main(String[] args) {
                //方法引用解决方式
                //请注意其中的双冒号“::”写法,这被称为“方法引用”,而双冒号是一种“引用运算符”。
                print(System.out :: print,"world");
            }
            
            public static void print(Print p,String s){
                p.print(s);
            }
        }
    
    
        输出结果:
                world

    1.4 方法引用案例的总结

    
    以上例中,System.out对象中有一个重载的println(String)方法恰好就是我们所需要的。那么对于printString方法的函数式接口参数,对比下面两种写法:
    Lambda表达式:s -> System.out.println(s);
    方法引用:System.out::println
    第一种语义是指:拿到参数之后经Lambda之手,继而传递给System.out.println方法去处理。第二种等效写法的语义是指:直接让System.out中的println方法来取代Lambda。两种写法的执行效果完全一样,而第二种方法引用的写法复用了已有方案,更加简洁。

    1.5 引用运算符

    
    双冒号“::”为引用运算符,而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中,那么则可以通过双冒号来引用该方法作为Lambda的替代者。

    2.通过5种语法使用方法引用

    2.1 通过对象名引用成员方法

    
    
        //函数式接口
        @FunctionalInterface
        interface Printable{
            public void print(String s);
        }
    
        //已存在的类,类中有打印字符串的方法.
        class AlreadyExistPrint{
        
            public void PrintString(String s){
            System.out.println(s);
        }
    
    
        //测试通过对象名进行方法引用.
        public class ObjectMethodReference {
        
            public static void main(String[] args) {
                //通过对象名引用方法
                AlreadyExistPrint ap = new AlreadyExistPrint();
                print(ap :: PrintString,"java");
            }
            
            public static void print(Printable p,String s){
                p.print(s);
            } 
    
        }
    
        输出结果:
                java

    2.2 通过类名引用静态方法

    
        //函数式接口
        @FunctionalInterface
        interface MyMath{
            int max(int a, int b);
        }
    
        //已存在的类
        这里使用JDK提供的Math类中的静态方法max(int a,int b);
    
    
        //测试通过类名引用静态方法.
        public class ClassStaticMethod {
        
            public static void main(String[] args) {
                //通过Math类的类名引用静态方法max();
                int max = getMax(Math :: max, 10, 20);
                System.out.println(max);
            }
            
            public static int getMax(MyMath lambda ,int a,int b){
                return lambda.max(a, b);
            }
    
        }
    
        输出结果:
                20

    2.3 通过类名引用成员方法

    
        /*
        成员方法需要依托对象才可以执行,所以当并不存在对象时,成员方法无法执行。
        如果希望成员方法的引用中仅出现类名称而不出现对象名称,情况则要复杂一些:
        必须为其指定一个用来执行成员方法的对象实例。
        */
    
        //在函数式接口中的参数里加入对象实例:
        @FunctionalInterface
        interface Printable{
            public void print(AlreadyExistPrint a ,String s);
        }
    
        //已存在的类
        class AlreadyExistPrint{
        
            public void PrintString(String s){
                System.out.println(s);
            }
    
        }
    
        //测试通过类名引用成员方法.
        public class ClassMethod {
            public static void main(String[] args) {
                //通过类名引用成员方法;
                //lambda方式实现: 
                //语义解析: 拿着对象a去调用a的print方法打印s 
                print((a,s) -> {a.PrintString(s);},new AlreadyExistPrint(),"hello");
                
                //简化写法: 方法引用 (通过类名引用成员方法)
                print(AlreadyExistPrint :: PrintString,new AlreadyExistPrint(),"hello");
                
            }
            
            public static void print(Printable p ,AlreadyExistPrint a,String s){
                p.print(a,s);
            } 
    
        }
    
        输出结果:
                hello
                hello

    2.4 通过super引用成员方法

    
        //函数式接口
        @FunctionalInterface
        interface Eat{
            void eat(String food);
        }
    
        //已存在的类
        class Animal{
            public void eat(String food){
                System.out.println("吃:"+food);
            }
        }
    
        //Animal的子类
        class Cat extends Animal{
            
            @Override
            public void eat(String food) {
                //通过super引用父类的方法.
                method(super :: eat,food);
            }
             
            public void method(Eat e, String s){
                e.eat(s);
            }
        }
    
    
        //测试通过类名引用成员方法.
        public class SuperMethod {
        
            public static void main(String[] args) {
                Cat c = new Cat();
                c.eat("鱼");
            }
    
        }
    
        输出结果:
                吃鱼

    2.5通过this引用成员方法

    
        //函数式接口
        interface shopping {
            void buy(int money);
        }
    
        //已存在的类
        class Man {
            //男人将来都要买个属于自己的房子.
            public void buyHouse(int money) {
                System.out.println("买套房子消费:"+money);
            }
        
            //结婚就得购物,买买买啊.
            public void marry(shopping lambda,int money) {
                lambda.buy(money);
            }
        
            //开心方法.男人要想开心.就得结婚
            public void beHappy() {
                //通过this引用成员方法.
                marry(this::buyHouse,1000000);
            }
        }
    
    
        //测试通过类名引用成员方法.
        public class ThisMethod {
    
            public static void main(String[] args) {
                Man man = new Man();
                man.beHappy();
            }
        }
    
    
        输出结果:
                买套房子消费:1000000

    3.方法引用使用总结

    ​ (1) Lambda表达式:s -> System.out.println(s); (2) 方法引用:System.out::println

    
    第一种语义是指:拿到参数之后经Lambda之手,继而传递给System.out.println方法去处理。
    
    第二种等效写法的语义是指:直接让System.out中的println方法来取代Lambda。
    两种写法的执行效果完全一样,而第二种方法引用的写法复用了已有方案,更加简洁。
    
    函数式接口是Lambda的基础,而方法引用是Lambda的孪生兄弟。

    展开全文
  • java8方法引用理解

    千次阅读 2018-11-21 13:41:30
    什么是方法引用? 方法引用可用于在不调用方法的情况下引用方法。它将方法视为Lambda表达式。它们只能作为语法糖来减少一些lambdas的冗长。在方法引用中,将包含方法的对象(或类)放在::运算符之前,将方法的名称...
  • Java 8 方法引用

    千次阅读 2019-01-08 23:10:04
    方法引用是用来直接访问类或者实例已经存在的方法或者构造方法。 二、哪里能用? 当Lambda表达式中只是执行一个方法调用时。 三、怎么理解? 这里以Arrays的sort方法进行讲解:public static &lt;T&gt; ...
  • java8 方法引用详解

    千次阅读 2020-01-19 20:27:08
    一、方法引用概述 (这些话理解起来非常费劲,后面会结合具体情形讲解) 1、方法引用(Method References) 当要传递给Lambda体的操作,已经有了实现方法,可以使用方法引用。 2、方法引用可以看做是Lambda...
  • Java8】 方法引用 讲解

    万次阅读 2019-11-21 19:24:06
    一、概述 在学习 lambda 表达式之后,我们通常使用 lambda 表达式来创建匿名方法。然而,有时候我们仅仅是调用了一个已...在Java8中,我们可以直接通过方法引用来简写lambda 表达式中已经存在的方法。 Arrays.so...
  •  如果函数式接口的实现恰好是通过调用一个静态方法来实现,那么就可以使用静态方法引用 二、实例 public class StaticExample { /** * 无参数有返回值 * @return */ public static String put() { ...
  • Java8方法引用和构造器引用示例

    千次阅读 2017-08-05 21:00:33
    package com.expgiga.Java8; import java.io.PrintStream;... * 一、方法引用:若Lambda体中的内容有方法已经实现了,可以使用"方法引用"(可以理解为方法引用是Lambda表达式的另外一种表现形式) * * 主要有
  • java中的方法引用

    千次阅读 2019-08-16 18:03:48
    目录 简介 一,类::静态方法 二,对象::实例方法 ...方法引用可以认为是Lambda表达式的一种特殊形式,Lambda表达式可以让开发者自定义抽象方法的实现代码,方法引用则可以让开发者直接引用已存在的实现方法,...
  • Java四种方法引用

    千次阅读 2018-05-10 21:03:11
    方法引用是lambda表达式的一种特殊形式,如果正好有某个方法满足一个lambda表达式的形式,那就可以将这个lambda表达式用方法引用的方式表示,但是如果这个lambda表达式的比较复杂就不能用方法引用进行替换。...
  • 详解Java8特性之方法引用

    万次阅读 2017-05-05 12:49:15
    前言在详解Java8特性之Lambda表达式 中我介绍了Java8中的Lambda表达式,通过Lambda表达式我们就可以快速地创建一个函数式接口的实例,可以说是大大简便了我们开发。你以为只能做到这么简便了嘛,big...方法引用方法引用
  • Java 8方法引用使用指南

    千次阅读 2016-05-11 12:10:50
    本文作者为拥有15年 Java 开发经验的资深程序员 Per-Åke Minborg,主要介绍如何灵活地解析 Java 中的方法引用。文章系国内 ITOM 管理平台 OneAPM 编译呈现。
  • java工程引用其他java工程解决方法

    千次阅读 2015-01-30 14:03:39
    (其实相当简单):不需要在Java Build Path中Add项目,只需要在eclipse的Web工程上右键->Properties->Java EE Modul Dependencies中选中java项目的JAR/Module就可以了,此时Project References会自动勾选择相应的...
  • 在使用特定类的任意对象的方法引用时,总是莫名其妙报错:non-static method can not referenced from a static context。 解决方案:其实是类型匹配不正确,修改类型后不再报错; public class StreamTest { ...
  • java8系列之方法引用

    千次阅读 2017-02-13 10:37:40
    在这种情况下,java8提供了一个简写语法,那就是方法引用,进一步简化Lambda表达式。方法引用的形式方法引用的语法结构:ClassName::methodName(注意:只需要写方法名,不需要写括号,因为这里并不调用该方法)方法...
  • Java新特性之方法引用

    千次阅读 2019-06-11 11:21:35
    方法引用的使用 最初,引用只是针对引用类型完成的,也就是只有数组、类、接口才具备引用操作。JDK1.8后追加了方法引用。实际上引用的本质就是别名。 因此方法的引用就是别名的使用。 方法的引用有四种形式: 引用...
  • Java8——方法引用与构造器引用

    千次阅读 2019-03-29 19:05:03
    一、方法引用  若Lambda体中的内容已经有方法实现过了,我们可以使用方法引用,使用方法引用的时候需要保证引用方法的参数列表和返回值类型与我们当前所要实现的函数式接口方法的参数列表和返回值类型保持一致。...
  • JAVA8之方法引用和构造引用

    千次阅读 2016-07-13 18:08:01
    其实关于方法引用和构造引用大家可以简单理解为lambda的简写形式 一.方法引用 方法引用分为三类: 1.指向静态方法的方法引用 例子: public static void main(String[] args) { String num="122"; int parse ...
  • Java8————方法引用

    千次阅读 2018-10-06 11:41:57
    译者注:本篇博客翻译自Oracle官方教程《Method References》。作为Java 8 新特性Lambda表达式的引申概念,博主依然采用官方文档的方式来学习这一重要的概念。希望对各位同道有所帮助。...方法引用允许你这...
  • Java8中的方法引用

    千次阅读 2018-09-10 14:53:51
    在上一篇的Java8新特性中我们聊过Lambda表达式,这一篇我们来看一下Java8中另一个特性:方法引用方法引用   在讲方法引用之前我们先看一个例子以及输出的结果:  public static void LambdaTest() {  ...
  • 方法引用:  方法引用返回的是接口的实现  private static &lt;T&gt; Iterable&lt;T&gt; itToIterable(Stream&lt;T&gt; stream) { return stream::iterator; //编译通过此处返回的是...
  • 03. Java8-方法引用

    万次阅读 2019-08-27 16:13:15
    方法引用是Lambda 表达式的另一种简写方式. 普通的Lambda 表达式的lambda体其实就是一段匿名类的核心代码实现, 每次创建Lambda 表达式时都需要重新写一次方法的实现, 对于代码重用而言并不乐观. 而方法引用则时, 用...
  • Java8 方法引用-Method References

    千次阅读 2017-06-22 00:13:11
    前言怎样更好的引入Java8中的方法引用呢? 我们首先看一下一个简单的例子: Consumer<String> con=(str)->System.out.println(str); con.accept("我是消费型接口!");这时候你就会知道这行代码输出的是:我是消费型...
  • Java8 MethodReference方法引用

    千次阅读 2017-11-02 11:04:13
    package com.lgx.jdk8.part02; import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.function.Function;...import java.util.function.Supplier;... * 方法引用的学习 */

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,400
精华内容 21,760
关键字:

java方法引用

java 订阅