Java 8方法引用，双冒号（：:)运算符

最新推荐文章于 2024-10-08 22:32:31 发布
最新推荐文章于 2024-10-08 22:32:31 发布
阅读量543 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/allway2/article/details/113796843
版权

在Java 8中，双冒号（：:)运算符称为方法引用。请参考以下示例：

匿名类打印列表。

 

List<String> list = Arrays.asList("node", "java", "python", "ruby");

list.forEach(new Consumer<String>() {       // anonymous class

    @Override

    public void accept(String str) {

        System.out.println(str);

    }

});

匿名类-> Lambda表达式。

 

List<String> list = Arrays.asList("node", "java", "python", "ruby");

list.forEach(str -> System.out.println(str)); // lambda

Lambda表达式->方法引用。

 

List<String> list = Arrays.asList("node", "java", "python", "ruby");

list.forEach(System.out::println);          // method references

匿名类-> Lambda表达式->方法参考

注意
lambda表达式或方法引用都不执行任何操作，只是对现有方法的另一种调用。使用方法参考，可以获得更好的可读性。

有四种方法参考：

  • 引用静态方法 ClassName::staticMethodName
  • 引用特定对象的实例方法 Object::instanceMethodName
  • 引用特定类型的任意对象的实例方法ContainingType::methodName–
  • 引用构造函数 ClassName::new

1.静态方法

Lambda表达式。

 

(args) -> ClassName.staticMethodName(args)

方法参考。

 

ClassName::staticMethodName

1.1此示例打印一个字符串列表，该列表引用了静态方法SimplePrinter::print。

Java8MethodReference1a.java

 

package com.mkyong;

 

import java.util.Arrays;

import java.util.List;

import java.util.function.Consumer;

 

public class Java8MethodReference1a {

 

    public static void main(String[] args) {

 

        List<String> list = Arrays.asList("A", "B", "C");

 

        // anonymous class

        list.forEach(new Consumer<String>() {

            @Override

            public void accept(String x) {

                SimplePrinter.print(x);

            }

        });

 

        // lambda expression

        list.forEach(x -> SimplePrinter.print(x));

 

        // method reference

        list.forEach(SimplePrinter::print);

 

    }

 

}

 

class SimplePrinter {

    public static void print(String str) {

        System.out.println(str);

    }

}

1.2此示例将String列表转换为Integers列表，该方法引用静态方法Integer::parseInt。

整数.java

 

  public static int parseInt(String s) throws NumberFormatException {

        return parseInt(s,10);

  }

Java8MethodReference1b.java

 

package com.mkyong;

 

import java.util.Arrays;

import java.util.List;

import java.util.function.Function;

import java.util.stream.Collectors;

 

public class Java8MethodReference1b {

 

    public static void main(String[] args) {

 

        List<String> list = Arrays.asList("1", "2", "3");

 

        // anonymous class

        List<Integer> collect1 = list.stream()

                .map(new Function<String, Integer>() {

                    @Override

                    public Integer apply(String s) {

                        return Integer.parseInt(s);

                    }

                })

                .collect(Collectors.toList());

 

        // lambda expression

        List<Integer> collect2 = list.stream()

                .map(s -> Integer.parseInt(s))

                .collect(Collectors.toList());

 

        // method reference

        List<Integer> collect3 = list.stream()

                .map(Integer::parseInt)

                .collect(Collectors.toList());

 

    }

 

}

1.3此示例将两个连接Integer并返回String。它将方法引用静态方法IntegerUtils::join作为参数传递给另一个接受的方法BiFunction。

Java8MethodReference1c.java

 

package com.mkyong;

 

import java.util.function.BiFunction;

 

public class Java8MethodReference1c {

 

    public static void main(String[] args) {

 

        // anonymous class

        String result1 = playTwoArgument(1, 2, new BiFunction<Integer, Integer, String>() {

                  @Override

                  public String apply(Integer a, Integer b) {

                      return IntegerUtils.join(a, b);

                  }

              });                                                                   // 3

 

        // lambda

        String result1 = playTwoArgument(1, 2, (a, b) -> IntegerUtils.join(a, b));  // 3

 

        // method reference

        String result2 = playTwoArgument(1, 2, IntegerUtils::join);                 // 3

 

    }

 

    private static <R> R playTwoArgument(Integer i1, Integer i2,

        BiFunction<Integer, Integer, R> func) {

        return func.apply(i1, i2);

    }

 

}

 

class IntegerUtils{

 

    public static String join(Integer a, Integer b) {

        return String.valueOf(a + b);

    }

 

}

 

2.引用特定对象的实例方法

Lambda表达式。

 

(args) -> object.instanceMethodName(args)

方法参考。

 

object::instanceMethodName

2.1此示例Employee按薪水排序列表。我们可以参考compareBySalary特定对象的实例方法ComparatorProvider。

Java8MethodReference2

 

package com.mkyong;

 

import java.math.BigDecimal;

import java.util.Arrays;

import java.util.List;

 

public class Java8MethodReference2 {

 

    public static void main(String[] args) {

 

        List<Employee> list = Arrays.asList(

                new Employee("mkyong", 38, BigDecimal.valueOf(3800)),

                new Employee("zilap", 5, BigDecimal.valueOf(100)),

                new Employee("ali", 25, BigDecimal.valueOf(2500)),

                new Employee("unknown", 99, BigDecimal.valueOf(9999)));

 

        // anonymous class

        /*list.sort(new Comparator<Employee>() {

            @Override

            public int compare(Employee o1, Employee o2) {

                return provider.compareBySalary(o1, o2);

            }

        });*/

 

        ComparatorProvider provider = new ComparatorProvider();

 

        // lambda

        // list.sort((o1, o2) -> provider.compareBySalary(o1, o2));

 

        // method reference

        list.sort(provider::compareBySalary);

 

        list.forEach(x -> System.out.println(x));

 

    }

 

}

 

class ComparatorProvider {

 

    public int compareByAge(Employee o1, Employee o2) {

        return o1.getAge().compareTo(o2.getAge());

    }

 

    public int compareByName(Employee o1, Employee o2) {

        return o1.getName().compareTo(o2.getName());

    }

 

    public int compareBySalary(Employee o1, Employee o2) {

        return o1.getAge().compareTo(o2.getAge());

    }

 

}

Employee.java

 

package com.mkyong;

 

import java.math.BigDecimal;

 

public class Employee {

 

    String name;

    Integer age;

    BigDecimal salary;

 

    // generated by IDE, getters, setters, constructor, toString

}

输出

 

Employee{name='zilap', age=5, salary=100}

Employee{name='ali', age=25, salary=2500}

Employee{name='mkyong', age=38, salary=3800}

Employee{name='unknown', age=99, salary=9999}

3.引用特定类型的任意对象的实例方法。

该语句有点混乱，需要很少的解释，请参见以下示例：

Lambda表达式。

 

// arg0 is the first argument

(arg0, rest_of_args) -> arg0.methodName(rest_of_args)

 

// example, assume a and b are String

(a, b) -> a.compareToIgnoreCase(b)

方法参考。

 

// first argument type

arg0_Type::methodName

 

// arg0 is type of ClassName

ClassName::methodName

 

// example, a is type of String

String::compareToIgnoreCase

对于(String a, String b)，其中a和b是任意名称，并且String是其任意类型。此示例使用方法引用来引用特定类型compareToIgnoreCase的任意对象a（第一个参数）的实例方法String。

3.1查看此方法参考中的官方示例

 

  String[] stringArray = { "Barbara", "James", "Mary", "John",

                "Patricia", "Robert", "Michael", "Linda" };

  Arrays.sort(stringArray, String::compareToIgnoreCase);

我们通过了方法参考String::compareToIgnoreCase作为的比较器Arrays.sort。

说明
查看Arrays.sort方法签名：

 

public static <T> void sort(T[] a, Comparator<? super T> c) {

}

在以上示例中，Arrays.sort期望为Comparator<String>。的Comparator是一个功能接口，其抽象方法compare匹配BiFunction<String, String, Integer>，它需要的两个参数，String并返回一个int。

比较器

 

@FunctionalInterface

public interface Comparator<T> {

    int compare(T o1, T o2);  // this matches BiFunction<String, String, Integer>

}

查看BiFunction方法签名：

BiFunction.java

 

@FunctionalInterface

public interface BiFunction<T, U, R> {

      R apply(T t, U u);

}

进一步阅读– Java 8 BiFunction示例

下面的lambda提供了的实现BiFunction<String,String,Integer>，因此Arrays.sortaccept接受下面的lambda表达式作为有效语法。

 

(String a, String b) -> a.compareToIgnoreCase(b) // return int

 

// a is type of String

// method reference

String::compareToIgnoreCase

3.2让我们看另一个例子。

Java8MethodReference3a.java

 

package com.mkyong;

 

import java.util.function.BiPredicate;

import java.util.function.Function;

 

public class Java8MethodReference3a {

 

    public static void main(String[] args) {

 

        // lambda

        int result = playOneArgument("mkyong", x -> x.length());   // 6

 

        // method reference

        int result2 = playOneArgument("mkyong", String::length);   // 6

 

        // lambda

        Boolean result3 = playTwoArgument("mkyong", "y", (a, b) -> a.contains(b)); // true

 

        // method reference

        Boolean result4 = playTwoArgument("mkyong", "y", String::contains);        // true

 

        // lambda

        Boolean result5 = playTwoArgument("mkyong", "1", (a, b) -> a.startsWith(b)); // false

 

        // method reference

        Boolean result6 = playTwoArgument("mkyong", "y", String::startsWith);        // false

 

        System.out.println(result6);

    }

 

    static <R> R playOneArgument(String s1, Function<String, R> func) {

        return func.apply(s1);

    }

 

    static Boolean playTwoArgument(String s1, String s2, BiPredicate<String, String> func) {

        return func.test(s1, s2);

    }

 

}

3.3让我们看看另一个示例，自定义对象。

Java8MethodReference3b.java

 

package com.mkyong;

 

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.util.function.BiFunction;

 

public class Java8MethodReference3b {

 

    public static void main(String[] args) {

 

        Invoice obj = new Invoice("A001", BigDecimal.valueOf(1.99), 3);

 

        InvoiceCalculator formula = new InvoiceCalculator();

 

        // lambda

        BigDecimal result = calculate(formula, obj, (f, o) -> f.normal(o));         // 5.97

 

        // method reference

        BigDecimal result2 = calculate(formula, obj, InvoiceCalculator::normal);    // 5.97

 

        // lambda

        BigDecimal result3 = calculate(formula, obj, (f, o) -> f.promotion(o));     // 5.37

 

        // method reference

        BigDecimal result4 = calculate(formula, obj, InvoiceCalculator::promotion); // 5.37

 

    }

 

    static BigDecimal calculate(InvoiceCalculator formula, Invoice s1,

                                BiFunction<InvoiceCalculator, Invoice, BigDecimal> func) {

        return func.apply(formula, s1);

    }

 

}

 

class InvoiceCalculator {

 

    public BigDecimal normal(Invoice obj) {

        return obj.getUnitPrice().multiply(BigDecimal.valueOf(obj.qty));

    }

 

    public BigDecimal promotion(Invoice obj) {

        return obj.getUnitPrice()

                .multiply(BigDecimal.valueOf(obj.qty))

                .multiply(BigDecimal.valueOf(0.9))

                .setScale(2, RoundingMode.HALF_UP);

    }

}

 

class Invoice {

 

    String no;

    BigDecimal unitPrice;

    Integer qty;

 

    // generated by IDE, setters, gettes, constructor, toString

}

第一个参数是的类型InvoiceCalculator。因此，我们可以引用特定类型normal or promotion的任意对象（f）的实例方法（）InvoiceCalculator。

 

(f, o) -> f.normal(o))

(f, o) -> f.promotion(o))

 

InvoiceCalculator::normal

InvoiceCalculator::promotion

知道了？没有更多的例子🙂

4.引用构造函数。

Lambda表达式。

 

(args) -> new ClassName(args)

方法参考。

 

ClassName::new

4.1引用默认构造函数。

Java8MethodReference4a.java

 

package com.mkyong;

 

import java.math.BigDecimal;

import java.util.HashMap;

import java.util.Map;

import java.util.function.Supplier;

 

public class Java8MethodReference4a {

 

    public static void main(String[] args) {

 

        // lambda

        Supplier<Map> obj1 = () -> new HashMap();   // default HashMap() constructor

        Map map1 = obj1.get();

 

        // method reference

        Supplier<Map> obj2 = HashMap::new;

        Map map2 = obj2.get();

 

        // lambda

        Supplier<Invoice> obj3 = () -> new Invoice(); // default Invoice() constructor

        Invoice invoice1 = obj3.get();

 

        // method reference

        Supplier<Invoice> obj4 = Invoice::new;

        Invoice invoice2 = obj4.get();

 

    }

 

}

 

class Invoice {

 

    String no;

    BigDecimal unitPrice;

    Integer qty;

 

    public Invoice() {

    }

 

    //... generated by IDE

}

4.2引用接受参数的构造函数– Invoice(BigDecimal unitPrice)

Java8MethodReference4b.java

 

package com.mkyong;

 

import java.math.BigDecimal;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.function.Function;

 

public class Java8MethodReference4b {

 

    public static void main(String[] args) {

 

        List<BigDecimal> list = Arrays.asList(

                BigDecimal.valueOf(9.99),

                BigDecimal.valueOf(2.99),

                BigDecimal.valueOf(8.99));

 

        // lambda

        // List<Invoice> invoices = fakeInvoice(list, (price) -> new Invoice(price));

 

        // method reference

        List<Invoice> invoices = fakeInvoice(list, Invoice::new);

 

        invoices.forEach(System.out::println);

    }

 

    static List<Invoice> fakeInvoice(List<BigDecimal> list, Function<BigDecimal, Invoice> func) {

        List<Invoice> result = new ArrayList<>();

 

        for (BigDecimal amount : list) {

            result.add(func.apply(amount));

        }

        return result;

    }

 

}

 

class Invoice {

 

    String no;

    BigDecimal unitPrice;

    Integer qty;

 

    public Invoice(BigDecimal unitPrice) {

        this.unitPrice = unitPrice;

    }

 

    //... generated by IDE

}

输出

 

Invoice{no='null', unitPrice=9.99, qty=null}

Invoice{no='null', unitPrice=2.99, qty=null}

Invoice{no='null', unitPrice=8.99, qty=null}

完毕。

 

allway2
关注
理解 Java8 中双冒号 “ :: “ 的用法，方法引用符
Java Punk
01-25 6313
Java8 中，双冒号 :: 称为“方法引用操作符”，:: 符号为引用运算符，而它所在的表达式被称为方法引用，我们可以使用它来引用类的方法。
java8双冒号（::）的使用（方法引用）
weixin_44236185的博客
06-24 4475
java8双冒号（::）的使用（方法引用）
java8中:: 用法示例（JDK8双冒号用法）
08-25
主要给大家介绍了关于java8 中的:: 用法（JDK8双冒号用法）的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用java8具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Java基础-方法引用体验
二丫的博客
11-02 119
方法引用体验 需求： 1.定义一个接口（Printable）:里面定义一个抽象方法：void printString(String s); 2.定义一个测试类（PrintableDemo），在测试类中提供两种方法 一个方法是：usePrintable(Printable p) 一个方法是主方法，在主方法中调用usePrintable方法 PrintableDemo.java文件 public static void main(String[] arg
java8 双冒号（::）使用方法
最新发布
code_agent的博客
10-08 428
双冒号（::）运算符是跟函数式接口相关的运算符，作为函数式接口的赋值操作。
JAVA 8 中“::” 用法
魏波
10-08 1669
类名::静态方法名， 如 Integer::parseInt。实例对象::实例方法，如 String::substring。在JAVA 8 中，可以通过 “::” 关键字来访问类的。类名::new， 如 User::new。构造方法，对象方法，静态方法。
java30-方法引用-方法引用符-引用类方法-引用对象的实例方法-引用类的实例方法-引用构造器
LXMXHJ的博客
03-13 793
方法引用 概念： 使用Lambda表达式，实际上传递进去的就是一种解决方案：拿参数做操作 方法引用 = 使用已经存在的方案 案例： 定义接口Printable，定义抽象方法 void printString（String s） 定义测试类PrinttableDemo，定义usePrintable（Printable p) 和 main方法调用usePrintable public class PrintableDemo { public static void main(String[] arg
[Java 8] ::
q503385724的博客
04-23 119
public class AcceptMethod { public static void printValur(String str){ System.out.println("print value : "+str); } public static void main(String[] args) { List<St...
使用Java8中的双冒号运算符（::）调用方法
Zh_xy33的博客
04-02 1549
一直搞不明白双冒号运算要怎么使用，今天在《Java8实战》中看到相关内容，讲解的比较详细，参考这篇文章，总结一下，希望能帮助大家，如果有兴趣，也可以直接看《Java8实战》这本书 双冒号运算就是Java中的方法引用，他是一种更简洁的lambda表达式，一些情况下，比lambda表达式更易读，更自然。 注意，方法引用不需要括号 构建方法： 静态方法 Lambda：(args) ->...
笃学私教：如何理解并使用Java中双冒号(::)运算操作符
weixin_46898270的博客
10-19 2409
Java中双冒号操作符是Java 8中的Lambda表达式写法之一，对于Lambda表达式潘老师之前也写过总结的博文，大家可执行在博客中搜索，下面我们来看一下我们应该如何理解并使用Java中双冒号操作符。 一、定义与理解 1、定义 双冒号运算操作符是类方法的句柄，lambda表达式的一种简写，这种简写的学名叫eta-conversion或者叫η-conversion。 2、理解 英文格式双冒号::，读：double colon，双冒号（::）运算符在Java 8中被用作方法引用（method referen
Java中的双冒号运算符与PHP中的双冒号运算符的不同
05-01
在Java中，双冒号运算符用于方法引用，它是一种lambda表达式的简化写法。例如，假设有一个接口`MyInterface`和一个实现该接口的类`MyClass`，则可以使用双冒号运算符来引用`MyClass`中的方法： ``` MyInterface ...
java8，JDK，JDK8,Android
03-18
java8，JDK，JDK8,Android
java中方法引用
weixin_51304175的博客
09-07 141
方法引用符 1：::该符号为引用运算符，而它所在的表达式被称为方法引用 2：方法引用是Lambda的孪生兄弟 eg: 定义接口Printable，有一个方法printInt： public interface Printable { void printInt(int i); } 测试类： public class Main { public static void main(String[] args) { //调用usePrintable方法 //use
Java 8
330553352的专栏
10-21 611
一、什么是Stream 1.1、Stream（流）是一个来自数据源的元素队列并支持聚合操作 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。 数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sor...
Java：java 8
netyeaxi的专栏
03-29 686
Java 8新特性探究
java8 :: 用法 （JDK8 双冒号用法）
韩猿外的博客
04-08 230
jdk8中使用了::的用法。就是把方法当做参数传到stream内部，使stream的每个元素都传入到该方法里面执行一下， 格式: 类名：：方法名 案例： 表达式： person -> person.getAge(); 使用双冒号： Person：：getAge 其实这里就是省略了参数的书写(毕竟流中的元素都要进行一遍操作) ArrayList<String> collect = a1.stream().map(String::toUpperCase).collect(Col
java8方法引用::操作符
徐海兴的专栏
11-02 1347
java8中方法引用::有四种类型 ClassName::New ClassName::static_method ClassName::instance_method instance::instance_method 第一种是对构造函数的引用，相当于创建对象 第二种与第四种，如果有参数会把参数当方法的实参 第三种会把第一个参数当做类对象，来调用instance_method,其他参数当做方法...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值