浅谈Lambda表达式、引用以及函数式接口
Lambda表达式
表达式要求：SAM（Single Abstract Method），一个接口中只有一个抽象方法，除此之外没有任何其他方法定义，这样的抽象方法成为函数式接口，函数式接口才能为Lambda表达式所使用。
一般在函数式接口前面加上“@FunctionalInterface”表明函数式接口。
Lambda表达式格式：
- 方法没有参数：()->{语句};
//实例：
@FunctionalInterface
interface IMessage
{
public void printClassName();
}
public class Demo6 {
public static void main(String[] args) {
IMessage cn = ()->{
System.out.println("abc");
};
cn.printClassName();
}
}
输出结果：abc
interface IAdd{
public int plus(int x,int y);
}
class Add{
public static int add(int x,int y){
return x+y;
}
}
public class Demo{
public static void main(String[] args){
IAdd a = Add :: add;
System.out.println(a.plus(1,2));
}
}
输出结果：3
- 方法有参数：(参数1，参数2)->{语句};
//实例：
@FunctionalInterface
interface IMessage
{
public void printClassName(String str);
}
public class Demo6 {
public static void main(String[] args) {
IMessage cn = (str)->{
System.out.println("abc"+str);
};
cn.printClassName("Bullet");
}
}
输出结果：abcBullet
- 如果只有一行语句并且是返回语句：(参数1，参数2)->语句；
//实例：
@FunctionalInterface
interface IMessage
{
public String printClassName(String str);
}
public class Demo6 {
public static void main(String[] args) {
IMessage cn = (str)-> "abc"+str ;
//不需要加大括号也不需要加return
System.out.println(cn.printClassName("Bullet"));
}
}
输出结果：abcBullet
引用
引用即 让不同的方法名称可以描述同一个方法
接口引用要求引用类必须是函数式接口！
引用格式：
1. 引用静态方法：类名称::Static方法名称;
++必须是函数式接口（SAM标准）++
//实例： String.valueOf();
//方法定义：public static String valueOf(int i); -该方法有参数和返回值
@FunctionalInterface
interface IFunction<P,R>{ //泛型类型，参数P，返回值R
public R change(P p);
}
public class Demo6 {
public static void main(String[] args) {
IFunction<Integer,String> ch = String :: valueOf;
//将String.valueOf取别名ch.change
String str = ch.change(999);
System.out.println(str.length());
}
}
输出结果：3
2. 引用某个实例对象的方法：实例化对象:: 普通方法；
++必须是函数式接口（SAM标准）++
++有实例化对象++
//实例方法定义：public String toUpperCase();
@FunctionalInterface
interface IFunction<R>{
public R upper();
}
public class Demo6 {
public static void main(String[] args) {
IFunction<String> up = "www.sdibt.edu.cn" :: toUpperCase;
//有实例化对象"www.sdibt.edu.cn"
String str = up.upper();
System.out.println(str);
}
}
输出结果：WWW.SDIBT.EDU.CN
interface IAdd{
public int plus(int x,int y);
}
class Add{
public int add(int x,int y){
return x+y;
}
}
public class Demo{
public static void main(String[] args){
Add q = new Add();
IAdd a = q :: add;
System.out.println(a.plus(1,2));
}
}
输出结果：3
3. 引用特定类型的方法：特定类::普通方法；
++必须是函数式接口（SAM标准）++
++没有实例化对象，只想进行方法引用，可使用特定类处理++
//实例方法定义：public int compareTo(String anotherString);
@FunctionalInterface
interface IFunction<P>{
public int compare(P p1,P p2);
}
public class Demo6 {
public static void main(String[] args) {
IFunction<String> fun = String :: compareTo;
System.out.println(fun.compare("A", "a"));
}
}
输出结果：-32
4. 引用构造方法：类名称::new；
@FunctionalInterface
interface IFunction<R>{
public R create(String s,int a);
}
class Person {
private String name;
private int age;
public Person(String s,int a) {
this.name = s;
this.age = a;
}
public String toString() {
return "Name:"+name+"、age:"+age;
}
}
public class Demo6 {
public static void main(String[] args) {
IFunction<Person> fun = Person :: new;
System.out.println(fun.create("张三", 20));
}
}
输出结果：Name:张三、age:20
预置函数式接口
系统中有预置函数式接口，存在java.util.function包中，有如下核心接口供使用:
不要忘记导入包：
import java.util.function.*;
1.功能型函数式接口（有接收值有返回值）：
@FunctionalInterface
public interface Function<T,R>{
public R apply(T t);
}
//实例：
import java.util.function.*;
class Add{
public String add(String a){
return a.toUpperCase(); //作用将字符串变大写
}
}
public class Demo{
public static void main(String[] args){
Add q = new Add();
Function <String,String> fun = q :: add; //<接收值，返回值>
System.out.println(fun.apply("Hello!"));
}
}
2.消费型函数式接口（只有接收值，没有返回值）：
@FunctionalInterface
public interface Consumer<T>{
public void accept(T t);
}
//实例：
import java.util.function.*;
class Add{
public void add(String a){
System.out.println(a);
}
}
public class Demo{
public static void main(String[] args){
Add q = new Add();
Consumer <String> fun = q :: add;
fun.accept("hello！");
}
}
3.供给型函数式接口（没有接收值，只有返回值）：
@FunctionalInterface
public interface Supplier<T>{
public T get();
}
//实例：
import java.util.function.*;
class Add{
public String add(){
return "Hello World!";
}
}
public class Demo{
public static void main(String[] args){
Add q = new Add();
Supplier <String> fun = q :: add;
System.out.println(fun.get());
}
}
4.断言型函数式接口（有接收值，但是返回值一定是boolean）：
@FunctionalInterface
public interface Predicate<T>{
public boolean test(T t);
}
//实例：
import java.util.function.*;
class Add{
public String add(){
return "Hello World!";
}
}
public class Demo{
public static void main(String[] args){
Add q = new Add();
Predicate <String> fun = "sdibt" :: equalsIgnoreCase;
System.out.println(fun.test("SDIBT"));
}
}