1.Lambda表达式
Lambda是一个匿名函数,我们可以将Lambda表达式理解为一段可以传递的代码(将代码像数据一样传递)。
"->"(Lambda操作符)左边:Lambda表达式的所有参数。右边:Lambda体,Lambda需要执行的功能。
java
public class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("这是一个实现Runnable接口的子线程!");
}
}
public class Test {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
//等价于
Runnable runnable = new Runnable(){
@Override
public void run() {
System.out.println("这是一个实现Runnable接口的子线程!");
}
};
//等价于
Runnable runnable1 = ()-> System.out.println
("这是一个实现Runnable接口的子线程!");
Thread thread = new Thread(myRunnable);
thread.start();
//等价于
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("这是一个实现Runnable接口的子线程!");
}
}).start();
//等价于
new Thread(() -> System.out.println
("这是一个实现Runnable接口的子线程!")).start();
}
1.无参、无返回值
java
public interface Www {
public abstract void print1();//无参、无返回值
}
public class WwwTest {
public static void main(String[] args) {
Www www1 = new Www() {
@Override
public void print1() {
System.out.println("无参、无返回值");
}
};
Www www2 = ()-> {System.out.println("无参、无返回值")};
//等价于 当Lambda体只有一条语句的时候,return和{}可以省略掉
Www www3 = ()-> System.out.println("无参、无返回值");
//以上三种方法相当于创建一个类实现了Www接口。
//当运行方法时,要使用对象名.print();
}
}
2.无参、有返回值
java
public interface Www {
public abstract String print2();//无参、有返回值
//public abstract String print3(String name);//有参、有返回值
//public abstract String print4(String name,int i);//有多个参、有返回值
}
package lambda;
public class WwwTest {
public static void main(String[] args) {
Www www1 = new Www() {
@Override
public String print2() {
return "无参、有返回值";
}
Www www2 = ()-> "无参、有返回值";
//等价于
Www www3 = ()->{ return "无参、有返回值";};
//以上三种方法相当于创建一个类实现了Www接口。
//当运行方法时,要使用对象名.print();
}
}
3.有参、有返回值
java
public interface Www {
public abstract String print3(String name);//有参、有返回值
}
public class WwwTest {
public static void main(String[] args) {
Www www1 = new Www() {
@Override
public String print3(String name) {
System.out.println(name);
return "有参、有返回值";
}
Www www2 = (name)->{
System.out.println(name);
return "有参、有返回值";
};
//等价于 只有一个参数时,可以省略()
Www www3 = name->{
System.out.println(name);
return "有参、有返回值";
};
}
}
4.有多个参、有返回值
java
public interface Www {
public abstract String print4(String name,int i);//有多个参、有返回值
}
public class WwwTest {
public static void main(String[] args) {
Www www1 = new Www() {
@Override
public String print4(String name, int i) {
System.out.println(name+i);
return "有多个参、有返回值";
}
};
Www www2 = (name, i) -> {
System.out.println(name+i);
return "有多个参、有返回值";
};
}
}
**5.类型推断:**数据类型可以省略,因为编译器可以推断得出,称为"类型推断"。
java
public interface Www {
public abstract String print4(String name,int i);//有多个参、有返回值
}
public class WwwTest {
public static void main(String[] args) {
Www www1 = new Www() {
@Override
public String print4(String name, int i) {
System.out.println(name+i);
return "有多个参、有返回值";
}
};
Www www2 = (String name,int i) -> {
System.out.println(name+i);
return "有多个参、有返回值";
};
//等价于
Www www3 = (name, i) -> {
System.out.println(name+i);
return "有多个参、有返回值";
};
}
}
2.forEach+Lambda
1.使用forEach和Lambda循环list集合
java
public class ArrayList {
public static void main(String[] args) {
List<String> list = new java.util.ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
System.out.println("--------------------");
list.forEach(s -> System.out.println(s));
}
}
2.使用forEach和Lambda循环map集合
java
public class Student {
private String name;
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class HashMap1 {
public static void main(String[] args) {
Map<String,Student> map = new HashMap<>();
map.put("a",new Student("张三"));
map.put("b",new Student("李四"));
map.put("c",new Student("王五"));
map.forEach((key,value)-> System.out.println(key+"======"+ value.getName()));
//使用for增强循环遍历map集合
System.out.println("=====================");
Set keys = map.keySet();//返回键的集合
for (Object key : keys) {
System.out.println(key+"====="+map.get(key).getName());//get(key)根据键返回值
}
}
}
3.函数接口
只包含一个抽象方法的接口,称为函数式接口。并且可以使用lambda表达式来创建该接口的对象,可以在任意函数式接口上使用 @FunctionalInterface 注解,来检测它是否是符合函数式接口。同时javac也会包含一条声明,说明这个接口是否符合函数式接口。
Java中的函数式编程体现就是Lambda表达式,所以函数式接口即可以适用于Lambda使用的接口。
java
@FunctionalInterface
public interface Www {
public abstract void print();
}
public class WwwTest {
public static void main(String[] args) {
Www www1 = new Www() {
@Override
public void print() {
System.out.println("aaaa");
}
};
www1.print();
Www www2 = ()-> System.out.println("aaaa");
www2.print();
}
}
当接口中写入两个抽象方法时,会报错。
·