Java8新特性-004-方法、构造器、数组引用

方法引用

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）
• 方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来。
• 如下三种主要使用情况：

1.对象::实例方法 
2.类::静态方法
3.类::实例

应用条件

• 对象::实例方法名、类::静态方法名——应用条件：
  要实现的Lambda表达式中的抽象方法具体实现的时候调用了另外一个对象的方法（类的静态方法），如果这两个方法（自己的抽象方法、另一个对象的方法）的参数和返回值一致，那么可以直接使用。

  总结：参数和返回值类型一致。

• 类::实例方法名——应用条件;
  Lambda表达式有两个参数，第一个参数作为实例方法的调用者，第二个参数作为这个实例方法的参数，且返回值类型和Lambda表达式返回值的类型一致时，可用（类名::实例方法名指的是第一个参数的类和实例方法）。

  如：boolean test(String str1,String str2) ==> (str1,str2) -> str1.equals(str2)，其中str1.equals(str2)满足上述条件，就可以写为：String::eauals;

  总结：
  - 参数一作为实例方法的调用者；
  - 参数二作为实例方法的参数；
  - 返回值类型和Lambda表达式一致；

测试代码

TestMethodRef.java

package java8.method.constructor;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

import org.junit.Test;

public class TestMethodConstructor {
    /**
     * 方法的引用：
     *  1.若Lambda中的内容有方法已经实现了，那么我们可以使用“方法引用”，
     *      可以理解为方法引用是Lambda表达式的另外一种形式
     *  2.方法引用的三种形式：
     *      2.1.对象::实例方法名
     *      2.2.类::静态方法名
     *      2.3.类::实例方法名
     *  3.应用条件
     *      3.1.对象::实例方法名、类::静态方法名——应用条件：
     *          要实现的Lambda表达式中的抽象方法具体实现的时候调用了另外一个对象的方法（类的静态方法），
     *          如果这两个方法（自己的抽象方法、另一个对象的方法）的参数和返回值一致，
     *          那么可以直接使用。
     *          总结：参数和返回值类型一致。
     *      3.2.类::实例方法名——应用条件;
     *          Lambda表达式有两个参数，第一个参数作为实例方法的调用者，第二个参数作为这
     *          个实例方法的参数，且返回值类型和Lambda表达式返回值的类型一致时，可用
     *          （类名::实例方法名指的是第一个参数的类和实例方法）。
     *          如：boolean test(String str1,String str2) ==> (str1,str2) -> str1.equals(str2);
     *          其中str1.equals(str2)满足上述条件，就可以写为：String::eauals;
     *          总结：
     *              - 参数一作为实例方法的调用者；
     *              - 参数二作为实例方法的参数；
     *              - 返回值类型和Lambda表达式一致；
     */

    /**
     * 2.1.对象::实例方法名
     */
    @Test
    public void testMethodRef1() {
        PrintStream out = System.out;
        /**
         *  Lambda对象 = 另一个对象::另一个对象符合要求的方法名。
         */

        /**
         * 参数和返回值一致：
         * accept: void accept(String str);
         * println: void println(String str);
         */
        Consumer<String> consumer = out::println;

        consumer.accept("对象::实例方法名!");
    }

//////////////////////////////////////////////////////////////////////////////  
    /**
     * 2.2.类::静态方法名
     */
    /**
     * 规则和2.1类似，都是参数和返回值对应
     */
    @Test
    public void testMethodRef2() {
        /**
         * 同样的，参数和返回值要一致：
         * int Comparator.compare(Integer i1, Integer i2)
         * int Integer.compare(Integer i1, Integer i2)
         */
        Comparator<Integer> comparator = Integer::compare;


        TreeSet<Integer> treeSetInteger = new TreeSet<>(comparator);
        treeSetInteger.add(10);
        treeSetInteger.add(-1);
        treeSetInteger.add(20);
        Iterator<Integer> iterator = treeSetInteger.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next() + "\t");
        }
    }
//////////////////////////////////////////////////////////////////////////////
    /**
     * 2.3.类::实例方法名
     */
    /**
     * 应用条件：
     *  Lambda表达式有两个参数，第一个参数作为实例方法的调用者，第二个参数作为这个实例
     *  方法的参数，且返回值类型和Lambda表达式返回值的类型一致时，可用（类名::实例方法名
     *      指的是第一个参数的类和实例方法）。
     *  如：boolean test(String str1,String str2) ==> (str1,str2) -> str1.equals(str2);
     *      其中str1.equals(str2)满足上述条件，就可以写为：String::eauals;
     */
    @Test
    public void testMethodRef3() {
        /**
         * 参数和返回值一致：
         *  - 参数一作为实例方法的调用者；
         *  - 参数二作为实例方法的参数；
         *  - 返回值类型和Lambda表达式一致；
         */
        BiPredicate<String, String> biPredicate = String::equals;
        System.out.println(biPredicate.test("中国", "日本"));
    }
}

构造器引用

• 格式： ClassName::new
• 与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致！

测试代码

TestConstuctorRef.java

package java8.method.constructor;

import java.util.function.Function;
import java.util.function.Supplier;

import org.junit.Test;

public class TestConstuctorRef {

    /**
     * 构造器引用：
     *   1.格式：
     *      类名::new
     *   2.应用条件
     *      Lambda表达式的内容刚好只有这一个新建对象的语句，新建的对象也刚好是这个Lambda
     *      表达式的返回值，并且Lambda表达式的参数刚好是新建对象的构造器的参
     *      数（对应去调用这个构造器）。  
     */

    @Test
    public void testConstructor1() {
        /**
         * 应用条件：
         *  1.新建的对象刚好是Lambda表达式的返回值类型；
         *  2.Lambda表达式的参数刚好是这个构造器的参数值（对应去调用这个构造器）；
         */
        // 对应：空参构造器
        Supplier<Person> supplierPerson = Person::new;

        System.out.println(supplierPerson.get());

        // 对应：一个参数的构造器，String
        Function<String, Person> functionPerson = Person::new;  // <String, Person> -->参数,返回值
        System.out.println(functionPerson.apply("周杰伦"));
    }
}

class Person {
    private String name = "冯强";

    // 构造器一
    public Person() {

    }

    // 构造器二
    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + "]";
    }
}

数组引用

• 格式： 数组类型[] :: new
  

测试代码

TestArrayRef.java

package java8.method.constructor;

import java.util.function.Function;

import org.junit.Test;

public class TestArrayRef {
    /**
     * 数组引用：
     *  1.格式
     *      数组类型[]::new;
     *  2.引用条件：
     *      和构造器引用的条件是一样的（返回值类型，参数对应构造器），只是写法是专有的。
     */
    @Test
    public void testArrayRef() {
        /**
         * String[] apply(Integer i); --> String[]::new; --> new String(i);
         */
        Function<Integer, String[]> functionStringArray = String[]::new;

        String[] apply = functionStringArray.apply(10);
        System.out.println("数组长： " + apply.length);
    }
}

---

其它

• 源码下载

关注下方公众号，回复：Java8.code

• 欢迎加入交流群：451826376

• 更多信息：www.itcourse.top