Java 8的方法引用

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java 8的方法引用，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5677字，纯文字阅读大概需要9分钟。

内容图文

Java 8的方法引用是调用已有方法的Lambda表达式的简写形式，与Lambda表达式一样可作为函数式接口参数。

1.实例方法和静态方法

方法引用能作为哪种类型的函数式接口，要转化为Lambda表达式后看参数和返回值类型是否和函数式接口的抽象方法一致。
(1)t::instanceMethod等价于(x, y,...) -> t.instanceMethod(x, y,...)
(2)T::staticMethod等价于(x, y,...) -> T.staticMethod(x, y,...)
(3)T::instanceMethod等价于(x, y,...) -> x.instanceMethod(y,...)

2.构造器引用

构造器引用可作为Supplier<T>, Function<R, T>, BiFunction<R, S, T>函数式接口，具体类型取决于上下文以及是否定义了对应类型的构造器。
(1)若定义了T()，则T::new等价于() -> new T()，可作为Supplier<T>
(2)若定义了T(R)，则T::new等价于r -> new T(r)，可作为Function<R, T>
(3)若定义了T(R, S)，则T::new等价于(r, s) -> new T(r, s)，可作为BiFunction<R, S, T>

3.数组构造器引用

数组构造器引用可作为IntFunction<T[]>或Function<Integer, T[]>
T[]::new等价于n -> new T[n]

4.示例代码

import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.BooleanSupplier;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.IntSupplier;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class MethodReferenceDemo {

	public static void main(String[] args) {
		A a = new A(8);
		B b = new B(-2, 2.5);
		System.out.println("a = " + a);
		System.out.println("b = " + b);

		/*
			a::getX等价于() -> a.getX()
			是无参数、返回int的Lambda表达式
			可作为IntSupplier或Supplier<Integer>，不可作为Function<A, Integer>
		*/
		System.out.println("a::getX");
		supplier1(a::getX);
		/*
			A::getX等价于t -> t.getX()
			是有一个A类型的参数、返回int的Lambda表达式
			可作为ToIntFunction<A>或Function<A, Integer>
		*/
		System.out.println("A::getX");
		function1(A::getX, a);

		/*
			a::isPositive等价于() -> a.isPositive()
			是无参数、返回boolean的Lambda表达式
			可作为BooleanSupplier或Supplier<Boolean>，不可作为Function<A, Boolean>或Predicate<A>
		*/
		System.out.println("a::isPositive");
		supplier2(a::isPositive);
		/*
			A::isPositive等价于t -> t.isPositive()
			是有一个A类型的参数、返回boolean的Lambda表达式
			可作为Function<A, Boolean>或Predicate<A>
		*/
		System.out.println("A::isPositive");
		function2(A::isPositive, a);
		predicate(A::isPositive, b.getA());

		/*
			a::add等价于x -> a.add(x)
			是有一个int类型的参数、返回A的Lambda表达式
			可作为IntFunction<A>或Function<Integer, A>
		*/
		System.out.println("a::add");
		function3(a::add, 10);
		/*
			A::add等价于(t, x) -> t.add(x)
			是有一个A类型的参数和一个int类型的参数、返回A的Lambda表达式
			可作为BiFunction<A, Integer, A>
		*/
		System.out.println("A::add");
		function4(A::add, b.getA(), 10);

		/*
			由于参数是Supplier<A>且A定义了无参构造器
			因此A::new等价于() -> new A()，对应A的无参构造器
		*/
		System.out.println("A::new");
		supplier3(A::new);
		/*
			由于参数是IntFunction<A>且A定义了构造器A(int)
			因此A::new等价于x -> new A(x)，对应A的构造器A(int)
		*/
		function3(A::new, 1);
		/*
			由于参数是BiFunction<Integer, Double, B>且B定义了构造器B(int, double)
			因此B::new等价于(x, y) -> new B(x, y)，对应B的构造器B(int, double)
		*/
		System.out.println("B::new");
		function5(B::new, 25, 0.25);

		// double[]::new等价于n -> new double[n]
		System.out.println("double[]::new");
		function6(double[]::new, 3);

		stream();
	}

	public static void supplier1(IntSupplier supplier) {
		System.out.printf("supplier.getAsInt()=%d\n", supplier.getAsInt());
	}

	public static void supplier2(BooleanSupplier supplier) {
		System.out.printf("supplier.getAsBoolean()=%s\n", supplier.getAsBoolean());
	}

	public static void supplier3(Supplier<A> supplier) {
		System.out.printf("supplier.get()=%s\n", supplier.get());
	}

	public static void predicate(Predicate<A> predicate, A a) {
		System.out.printf("predicate.test(%s)=%s\n", a, predicate.test(a));
	}

	public static void function1(Function<A, Integer> function, A a) {
		System.out.printf("function.apply(%s)=%d\n", a, function.apply(a));
	}

	public static void function2(Function<A, Boolean> function, A a) {
		System.out.printf("function.apply(%s)=%s\n", a, function.apply(a));
	}

	public static void function3(IntFunction<A> function, int x) {
		System.out.printf("function.apply(%d)=%s\n", x, function.apply(x));
	}

	public static void function4(BiFunction<A, Integer, A> function, A a, int x) {
		System.out.printf("function.apply(%s, %d)=%s\n", a, x, function.apply(a, x));
	}

	public static void function5(BiFunction<Integer, Double, B> function, int x, double y) {
		System.out.printf("function.apply(%d, %f)=%s\n", x, y, function.apply(x, y));
	}

	public static void function6(IntFunction<double[]> function, int x) {
		System.out.printf("function.apply(%d)=%s\n", x, Arrays.toString(function.apply(x)));
	}

	public static void stream() {
		A[] aArray = Stream.iterate(-5, x -> x + 1)
				.limit(10)
				.map(A::new)
				.filter(A::isPositive)
				.toArray(A[]::new);
		System.out.printf("stream result: %s\n", Arrays.toString(aArray));
	}

}

class A {
	private int x;

	public A() {
		x = 0;
	}

	public A(int x) {
		this.x = x;
	}

	public int getX() {
		return x;
	}

	public boolean isPositive() {
		return x > 0;
	}

	public A add(int x) {
		return new A(this.x + x);
	}

	@Override
	public String toString() {
		return "A{" +
				"x=" + x +
				'}';
	}

}

class B {
	private A a;
	private double y;

	public B() {
		a = new A();
	}

	public B(int x, double y) {
		a = new A(x);
		this.y = y;
	}

	public A getA() {
		return a;
	}

	public double getY() {
		return y;
	}

	@Override
	public String toString() {
		return "B{" +
				"a=" + a +
				", y=" + y +
				'}';
	}

}

运行结果

a = A{x=8}
b = B{a=A{x=-2}, y=2.5}
a::getX
supplier.getAsInt()=8
A::getX
function.apply(A{x=8})=8
a::isPositive
supplier.getAsBoolean()=true
A::isPositive
function.apply(A{x=8})=true
predicate.test(A{x=-2})=false
a::add
function.apply(10)=A{x=18}
A::add
function.apply(A{x=-2}, 10)=A{x=8}
A::new
supplier.get()=A{x=0}
function.apply(1)=A{x=1}
B::new
function.apply(25, 0.250000)=B{a=A{x=25}, y=0.25}
double[]::new
function.apply(3)=[0.0, 0.0, 0.0]
stream result: [A{x=1}, A{x=2}, A{x=3}, A{x=4}]

内容总结

以上是互联网集市为您收集整理的Java 8的方法引用全部内容，希望文章能够帮你解决Java 8的方法引用所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端