Java 8Lambda之方法引用(Method References)

方法引用分为4类,方法引用也受到访问控制权限的限制,可以通过在引用位置是否能够调用被引用方法来判断。具体分类信息如下:

类型 使用方式
静态方法 ContainingClass::staticMethodName
指定实例的方法 containingObject::instanceMethodName
特定类实例的任意方法 ContainingType::methodName
构造方法 ClassName::new
    • 引用静态方法 
      ContainingClass::staticMethodName 
      例子: String::valueOf,对应的Lambda:(s) -> String.valueOf(s) 
      比较容易理解,和静态方法调用相比,只是把.换为::
    • 引用特定对象的实例方法 
      containingObject::instanceMethodName 
      例子: x::toString,对应的Lambda:() -> this.toString() 
      与引用静态方法相比,都换为实例的而已
    • 引用特定类型的任意对象的实例方法 
      ContainingType::methodName 
      例子: String::toString,对应的Lambda:(s) -> s.toString() 
      太难以理解了。难以理解的东西,也难以维护。建议还是不要用该种方法引用。 
      实例方法要通过对象来调用,方法引用对应Lambda,Lambda的第一个参数会成为调用实例方法的对象。
    • 引用构造函数 
      ClassName::new 
      例子: String::new,对应的Lambda:() -> new String() 
      构造函数本质上是静态方法,只是方法名字比较特殊。
一个实例:
package methodReference;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Supplier;

/**
 * @author jiangxiulian
 * @create 2017-12-28 下午12:03
 **/
public class MethodReference {

    public static void main(String args[]){

        //引用构造函数
        PersonFactory factory = new PersonFactory(Person::new);
       // PersonFactory personFactory = new PersonFactory(() ->new Person());
        List<Person> personList = new ArrayList<Person>();
        Person p1 = factory.getPerson();
        p1.setName("Kobe");
        personList.add(p1);

        Person p2 = factory.getPerson();
        p2.setName("James");
        personList.add(p2);

        Person p3 = factory.getPerson();
        p3.setName("Paul");
        personList.add(p3);

        Person[] persons1 = personList.toArray(new Person[personList.size()]);
        System.out.print("排序前");
        printArray(persons1);
        System.out.println();

        //引用静态方法
        Arrays.sort(persons1,MethodReference::myCompare);
        System.out.print("排序后");
        printArray(persons1);
        System.out.println();

        Person[] persons2 = personList.toArray(new Person[personList.size()]);
        System.out.print("排序前");
        printArray(persons2);
        System.out.println();

        //引用特定对象的实例方法
        Arrays.sort(persons2,p1::compare);
        System.out.print("排序后");
        printArray(persons2);
        System.out.println();

        Person[] persons3 = personList.toArray(new Person[personList.size()]);
        System.out.print("排序前");
        printArray(persons3);

        //  引用特定类型的任意对象的实例方法
        Arrays.sort(persons3,Person::compareTo);
        System.out.print("排序后");
        printArray(persons3);

    }

    public static void printArray(Person[] persons) {
        for (Person p : persons) {
            System.out.print(p.name + "  ");
        }
        System.out.println();
    }
    public static int myCompare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }

    static class Person{
        private String name;

        public Person(){

        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int compare(Person p1,Person p2){
            return p1.getName().compareTo(p2.getName());
        }

        public int compareTo(Person p){
            return this.getName().compareTo(p.getName());
        }
    }
    static class PersonFactory{
        private Supplier<Person> supplier;

        public PersonFactory(Supplier<Person> supplier){
            this.supplier = supplier;
        }

        public Person getPerson(){
            return supplier.get();
        }
    }
}


原文地址:https://www.cnblogs.com/jiangxiulian/p/8135793.html

时间: 2024-10-29 21:29:20

Java 8Lambda之方法引用(Method References)的相关文章

浅谈Java 8中的方法引用(Method References)

本人接触Java 8的时间不长,对Java 8的一些新特性略有所知.Java 8引入了一些新的编程概念,比如经常用到的 lambda表达式.Stream.Optional以及Function等,让人耳目一新.这些功能其实上手并不是很难,根据别人的代码抄过来改一下,并不要知道内部的实现原理,也可以很熟练地用好这些功能.但是当我深究其中一些细节时,会发现有一些知识的盲区.下面我就来谈一下Java 8中的Method References这个概念. 首先我给出官方对于这一概念的详细解释,https:/

JAVA 8 方法引用 - Method References

什么是方法引用 简单地说,就是一个Lambda表达式.在Java 8中,我们会使用Lambda表达式创建匿名方法,但是有时候,我们的Lambda表达式可能仅仅调用一个已存在的方法,而不做任何其它事,对于这种情况,通过一个方法名字来引用这个已存在的方法会更加清晰,Java 8的方法引用允许我们这样做.方法引用是一个更加紧凑,易读的Lambda表达式,注意方法引用是一个Lambda表达式,其中方法引用的操作符是双冒号"::". 方法引用例子 先看一个例子 首先定义一个Person类,如下:

Java学习笔记-方法引用

方法引用(Method Reference) 上一篇中记录了Lambda表达式,其可以创建匿名方法.当Lambda表达式只是调用一个存在的方法时,可以采用方法引用(JDK8具有的特性).如下: 1 public class Person { 2 3 public enum Sex { 4 MALE, FEMALE 5 } 6 7 String name; 8 LocalDate birthday; 9 Sex gender; 10 String emailAddress; 11 int age;

java中的方法引用

引用静态方法:类名称::static 方法名称: 引用某个对象的方法:对象::普通方法: 引用特定类方法:特定类::方法 引用构造方法:类名称::new 范例:引用静态方法 package com.java.demo; interface IMessage<P,R>{ // P表示方法的参数类型,R表示方法的返回值类型 public R change(P p); } public class TestDemo{ public static void main(String args[]){ /

Java自学-Lambda 方法引用

Lambda 方法引用 步骤 1 : 引用静态方法 首先为TestLambda添加一个静态方法: public static boolean testHero(Hero h) { return h.hp>100 && h.damage<50; } Lambda表达式: filter(heros, h->h.hp>100 && h.damage<50); 在Lambda表达式中调用这个静态方法: filter(heros, h -> Tes

java什么是方法(Method)?

方法是一组为了实现特定功能的代码块的集合.方法在语法上的功能主要有以下两个: ①:结构化代码 将代码按照功能进行组织,使代码的结构比较清晰,容易阅读和修改,也就是程序的可维护性强. ②:减少代码重复 一个固定的功能,可能会在程序中多次使用,在使用时只需要调用写好的方法,而不用重复书写对应的功能代码. 方法在书写时需要注意以下两点: ①:逻辑严谨 方法实现的一个完整的功能,所以在书写时要考虑到各种可能的情况,并对每种情况做出恰当的处理. ②:通用性强(可重复利用) 方法实现的是一种功能,在实际实现

Java 8新特性-4 方法引用

对于引用来说我们一般都是用在对象,而对象引用的特点是:不同的引用对象可以操作同一块内容! Java 8的方法引用定义了四种格式: 引用静态方法     ClassName :: staticMethodName 引用对象方法:  Object:: methodName 引用特定类型方法: ClassName :: methodName 引用构造方法: ClassName  :: new 静态方法引用示例 /** * 静态方法引用 * @param <P> 引用方法的参数类型 * @param

Java8之方法引用

一.概述 在学习lambda表达式之后,我们通常使用lambda表达式来创建匿名方法.然而,有时候我们仅仅是调用了一个已存在的方法.如下: Arrays.sort(stringsArray,(s1,s2)->s1.compareToIgnoreCase(s2)); 在Java8中,我们可以直接通过方法引用来简写lambda表达式中已经存在的方法. Arrays.sort(stringsArray, String::compareToIgnoreCase); 这种特性就叫做方法引用(Method

009-jdk1.8版本新特性一-展方法,Lambda表达式,函数式接口、方法引用构造引用

一.JDK1.8 名称:Spider(蜘蛛) 发布日期:2014-03-18 新特性: 1.1.扩展方法[接口的默认方法] Java 8允许我们给接口添加一个非抽象的方法实现,只需要使用 default关键字即可,这个特征又叫做扩展方法. 在Java中只有单继承,如果要让一个类赋予新的特性,通常是使用接口来实现,在C++中支持多继承,允许一个子类同时具有多个父类的接口与功能,在其他语言中,让一个类同时具有其他的可复用代码的方法叫做mixin.新的Java 8 的这个特新在编译器实现的角度上来说更