静态方法引用
静态方法Util
public class Util {
public static int StringLength(String s){
return s.length();
}
}
函数式接口TestFunctional
@FunctionalInterface //用来约束这个接口只有一个抽象方法
public interface TestFunctional {
int toLength(String s);
}
测试类进行调用接口的实现类对象的toLength方法
public class Test {
public static void main(String[] args) {
//调用接口的实现类对象的toLength静态方法
//创建实现类实现TestFunctional接口,并重写toLength,然后使用实现类调用toLength静态方法==>匿名内部类
//匿名内部类
TestFunctional a=new TestFunctional() {
@Override
public int toLength(String s) {
return Util.StringLength(s);
}
};
//原始lambda表达式
TestFunctional a=(String s)->{
return Util.StringLength(s);
};
//简化后
TestFunctional a=(s)-> Util.StringLength(s);
//方法引用
TestFunctional a=Util::StringLength;
}
}
实例方法引用
实例方法Util
public class Util {
public int StringLength(String s){
return s.length();
}
}
函数式接口TestFunctional
@FunctionalInterface
public interface InstanceFunctional {
int toLength(String s);
}
测试类进行调用接口的实现类对象的toLength方法
public class Test {
public static void main(String[] args) {
Util util = new Util();
//调用接口的实现类对象的toLength方法
//创建实现类实现TestFunctional接口,并重写toLength,然后再new创建实现类对象==>匿名内部类
//匿名内部类
InstanceFunctional functional=new InstanceFunctional() {
@Override
public int toLength(String s) {
return util.StringLength(s);
}
};
//原始lambda表达式
InstanceFunctional functional=(String s)->{
return util.StringLength(s);
};
//简化后
InstanceFunctional functional=s-> util.StringLength(s);
//方法引用
InstanceFunctional functional=util::StringLength;
}
}
构造函数引用
public class Person {
private String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
}
函数式接口TestFunctional
@FunctionalInterface
public interface ConstructorFunctional {
Person create(String name);
}
测试类进行调用接口的实现类对象的create方法
public class Test {
public static void main(String[] args) {
//调用接口的实现类对象的create方法
//创建实现类实现TestFunctional接口,并重写create,然后再new创建实现类对象==>匿名内部类
//匿名内部类
ConstructorFunctional functional=new ConstructorFunctional() {
@Override
public Person create(String name) {
return new Person(name);
}
};
//原始lambda表达式
ConstructorFunctional functional=(String name)->{
return new Person(name);
};
//简化后
ConstructorFunctional functional=name->new Person(name);
//方法引用
ConstructorFunctional functional=Person::new;
}
}
特定类型的任意对象的实例方法引用
函数式接口TestFunctional
@FunctionalInterface
public interface SpecialFunctional {
int toLength(String s);
}
测试类进行调用接口的实现类对象的toLength方法
public class Test {
public static void main(String[] args) {
//调用接口的实现类对象的toLength方法
//创建实现类实现TestFunctional接口,并重写toLength,然后再new创建实现类对象==>匿名内部类
//匿名内部类
SpecialFunctional special=new SpecialFunctional() {
@Override
public int toLength(String s) {
return s.length();
}
};
//原始lambda表达式
SpecialFunctional special=(String s)->{
return s.length();
};
//简化后
SpecialFunctional special=s->s.length();
//方法引用
SpecialFunctional special=String::length;
}
}
特定类型的任意对象的实例方法引用举例
方法引用类型 | 函数式接口定义 | 实例方法 | 方法引用表达式 | 使用场景描述 |
---|---|---|---|---|
特定类型的任意对象的实例方法引用 | interface StringCheck { boolean check(String s); } | boolean isEmpty() | String::isEmpty | 检查字符串是否为空 |
特定类型的任意对象的实例方法引用 | interface ListSize { int size(List<?> list); } | int size() | List::size | 获取列表的大小 |
特定类型的任意对象的实例方法引用 | interface ThreadStatus { boolean isAlive(Thread t); } | boolean isAlive() | Thread::isAlive | 检查线程是否仍然活跃 |
特定类型的任意对象的实例方法引用 | interface NumberSign { int getSign(BigDecimal number); } | int signum() | BigDecimal::signum | 获取BigDecimal数值的符号(正数、负数或零) |
特定类型的任意对象的实例方法引用 | interface StringOperation { String operate(String s); } | String toLowerCase() | String::toLowerCase | 转换字符串为小写 |
特定类型的任意对象的实例方法引用 | interface IntValue { int getInt(Integer integer); } | int intValue() | Integer::intValue | 获取Integer的原始int值 |
特定类型的任意对象的实例方法引用 | interface BoolValue { boolean getBool(Boolean bool); } | boolean booleanValue() | Boolean::booleanValue | 获取Boolean的原始boolean值 |
特定类型的任意对象的实例方法引用 | interface EmptyCheck { boolean isEmpty(Collection<?> collection); } | boolean isEmpty() | Collection::isEmpty | 检查集合是否为空 |
特定类型的任意对象的实例方法引用 | interface DoubleValue { double getDouble(Double d); } | double doubleValue() | Double::doubleValue | 获取Double的原始double值 |
示例 1: 使用 String 类的 isEmpty 方法
首先,定义一个函数式接口:
@FunctionalInterface
interface StringCheck {
boolean check(String s);
}
匿名内部类
StringCheck check1 = new StringCheck() {
@Override
public boolean check(String s) {
return s.isEmpty();
}
};
Lambda表达式
StringCheck check2 = s -> s.isEmpty();
方法引用
StringCheck check3 = String::isEmpty;
示例 2: 使用 List 类的 size 方法
定义一个接口来处理列表:
@FunctionalInterface
interface ListSize {
int size(List<?> list);
}
匿名内部类
ListSize size1 = new ListSize() {
@Override
public int size(List<?> list) {
return list.size();
}
};
Lambda表达式
ListSize size2 = list -> list.size();
方法引用
ListSize size3 = List::size;
示例 3: 使用 Thread 类的 isAlive 方法
定义一个接口来检查线程状态:
@FunctionalInterface
interface ThreadStatus {
boolean isAlive(Thread t);
}
匿名内部类
ThreadStatus status1 = new ThreadStatus() {
@Override
public boolean isAlive(Thread t) {
return t.isAlive();
}
};
Lambda表达式
ThreadStatus status2 = t -> t.isAlive();
方法引用
ThreadStatus status3 = Thread::isAlive;
示例 4: 使用 BigDecimal 类的 signum 方法
定义一个接口来获取数字的符号:
@FunctionalInterface
interface NumberSign {
int getSign(BigDecimal number);
}
匿名内部类
NumberSign sign1 = new NumberSign() {
@Override
public int getSign(BigDecimal number) {
return number.signum();
}
};
Lambda表达式
NumberSign sign2 = number -> number.signum();
方法引用
NumberSign sign3 = BigDecimal::signum;
示例 5: 使用 String 类的 toLowerCase 方法
定义一个接口来转换字符串为小写:
@FunctionalInterface
interface StringOperation {
String operate(String s);
}
方法引用
StringOperation lower = String::toLowerCase;
示例 6: 使用 Integer 类的 intValue 方法
定义一个接口来获取 Integer 对象的原始 int 值:
@FunctionalInterface
interface IntValue {
int getInt(Integer integer);
}
方法引用
IntValue intValue = Integer::intValue;
示例 7: 使用 Boolean 类的 booleanValue 方法
定义一个接口来获取 Boolean 对象的原始 boolean 值:
@FunctionalInterface
interface BoolValue {
boolean getBool(Boolean bool);
}
方法引用
BoolValue boolValue = Boolean::booleanValue;
示例 8: 使用 Collection 类的 isEmpty 方法
定义一个接口来检查任何类型的集合是否为空:
@FunctionalInterface
interface EmptyCheck {
boolean isEmpty(Collection<?> collection);
}
方法引用
EmptyCheck empty = Collection::isEmpty;
示例 9: 使用 Double 类的 doubleValue 方法
定义一个接口来获取 Double 对象的原始 double 值:
@FunctionalInterface
interface DoubleValue {
double getDouble(Double d);
}
方法引用
DoubleValue doubleValue = Double::doubleValue;