目录
1.lamdba表达式
1.1概念
Lambda表达式:特殊的匿名内部类，语法更简洁。
Lambda表达式允许把函数作为一个方法的参数(函数作为方法参数传递)，将代码像数据- -样传递。
1.2基本语法
<函数式接口> <变量名>=(参数1，参数2..)-> {
//方法体
};
注意: 函数式接口:接口中只有一个抽象方法。
(参数1，参数2): 抽象方法的参数
->: 分隔符
{}：表示抽象方法的实现
public class Test01 {
public static void main(String[] args) {
Runnable test01=()->{
System.out.println("这是Lambda表达式");
};
Thread t1= new Thread(test01);
t1.start();
//匿名内部类
Runnable test02 = new Runnable() {
@Override
public void run() {
System.out.println("这是匿名内部类");
}
};
Thread t2 = new Thread(test02);
t2.start();
//该构造方法需要传递一个线程任务对象。Runnable类型
my test03 = new my();
Thread t3 = new Thread(test03);
t3.start();
}
}
class my implements Runnable{
@Override
public void run() {
System.out.println("表达式");
}
}
分析代码:
Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心
为了指定 run 的方法体，不得不需要 Runnable 接口的实现类
为了省去定义一个 Runnable 实现类的麻烦，不得不使用匿名内部类
必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错
而实际上，似乎只有方法体才是关键所在。
这时可以使用lambda表示完成上面的要求。
Runnable test01=()->{
System.out.println("这是Lambda表达式");
};
Thread t1= new Thread(test01);
t1.start();
前提:必须是函数式接口。
简化匿名内部类的使用，语法更加简单。
1.3无参无返回值
public class Test03 {
public static void main(String[] args) {
Swimmable s1 = new Swimmable() {
@Override
public void swimming() {
System.out.println("游泳");
}
};
fun(s1);
//
// Swimmable s =()->{
// System.out.println("小潘去游泳");
// };
// fun(s);
fun(()->System.out.println("小潘"));
}
public static void fun(Swimmable w){
w.swimming();
}
}
interface Swimmable{
public void swimming();
}1.4有参数有返回值
下面举例演示 java.util.Comparator 接口的使用场景代码，其中的抽象方法定义为：
-
public abstract int compare(T o1, T o2);
当需要对一个对象集合进行排序时， Collections.sort 方法需要一个 Comparator 接口实例来指定排序的规则。
public class Test01 {
public static void main(String[] args) {
List<People> people = new ArrayList<>();
people.add(new People("张三",24,1.85));
people.add(new People("李四",12,1.85));
people.add(new People("王五",20,1.85));
Comparator<People> comparator =new Comparator<People>() {
@Override
public int compare(People o1, People o2) {
return o1.getAge()- o2.getAge();
}
};
Collections.sort(people,comparator);
for(People p :people){
System.out.println(p);
}
System.out.println("++++++++++");
// Comparator<People> comparator1 = (o1,o2)-> o2.getAge()-o1.getAge();
Collections.sort(people,(o1,o2)-> o2.getAge()-o1.getAge());
for (People p:people){
System.out.println(p);
}
}
}
class People {
private String name;
private Integer age;
private Double height;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Double getHeight() {
return height;
}
public void setHeight(Double height) {
this.height = height;
}
public People(String name, Integer age, Double height) {
this.name = name;
this.age = age;
this.height = height;
}
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
}1.5详细介绍lambda表达式
Lambda引入了新的操作符:-> (箭头操作符), ->将表达式分成两部分
左侧: (参数1,参数2--)表示参数列表
右侧: {}内部是方法体
●注意事项
形参列表的数据类型会自动推断
如果形参列表为空，只需保留()
如果形参只有1个，()可以省略， 只需要参数的名称即可
如果执行语句只有一句，且无返回值，{}可以省略，若有返回值，则若想省去{},
则必须同时省略return,且执行语句也保证只有一句
Lambda不 会生成-一个单独的内部类文件
2.函数式接口
如果一个接口只有一个抽象方法，则该接口称之为函数式接口，函数式接口
可以使用Lambda表达式，Lambda表达式会被匹配到这个抽象方法上。
@FunctionalInterface注解检测接口是否符合函数式接口。
内置函数式接口的由来
public class Test03 {
public static void main(String[] args) {
Operater o=arr -> {
int sum=0;
for(int n:arr){
sum+=n;
}
System.out.println("数组的和为:"+sum);
};
fun(o);
}
public static void fun(Operater operater){
int[] arr={2,3,4,5,6};
operater.getSum(arr);
}
}
@FunctionalInterface
interface Operater{
//求数组的和
public abstract void getSum(int[] arr);
}
分析
我们知道使用Lambda表达式的前提是需要有函数式接口。而Lambda使用时不关心接口名，抽象方法名，只关心抽 象方法的参数列表和返回值类型。因此为了让我们使用Lambda方便，JDK提供了大量常用的函数式接口。
常见得函数式接口
java.util.function保存
2.1Consumer<T>消费型接口
有参数，无返回值。
public class Test04 {
public static void main(String[] args) {
Integer[] num={2,3,4,5,6};
Consumer<Integer[]> consumer = (arr)->{
int sum = 0;
for(int i :arr){
sum+=i;
}
System.out.println(sum);
};
getSum(consumer,num);
}
public static void getSum(Consumer<Integer[]> consumer,Integer[] arr){
consumer.accept(arr);
}
}
2.2 Supplier<T>供给型函数式接口
T:表示返回结果的泛型
无参，想有返回结果的函数式接口时
T get();
public class Test06 {
public static void main(String[] args) {
fun(()->{
return new Random().nextInt(10);
});
}
public static void fun (Supplier<Integer> supplier){
Integer s = supplier.get();
System.out.println("结果："+s);
}
}2.3 Function<T,R> 函数型函数式接口
T: 参数类型的泛型
R: 函数返回结果的泛型
有参，有返回值
public class Test05 {
public static void main(String[] args) {
fun((t)->{
return t.length();
},"hello world");
}
public static void fun(Function<String ,Integer> function,String msg){
Integer integer = function.apply(msg);
System.out.println(integer);
}
}
2.4 Predicated<T>断言型接口
T: 参数的泛型
boolean test(T t);
当传入一个参数时，需要对该参数进行判断时，则需要这种函数。
public class Test07 {
public static void main(String[] args) {
fun((n)->{
return n.length()>3?true:false;
},"王二麻子");
}
public static void fun(Predicate<String> predicate ,String name){
boolean b = predicate.test(name);
System.out.println("名字是否长："+b);
}
}
3 方法引用
3.1 lambda表达式的冗余
public class Test01 {
public static void main(String[] args) {
// Consumer<Integer[]> consumer = (arr)->{
// int sum = 0;
// for (int a:arr) {
// sum+=a;
//
// }
// System.out.println("数组的和为："+sum);
// };
// fun(consumer);
fun(Test01::sum);
}
public static void fun(Consumer<Integer[]> consumer){
Integer[] arr = {2,3,4,5,6};
consumer.accept(arr);
}
public static void sum (Integer[] arr){
int sum=0;
for(int a :arr){
sum+=a;
}
System.out.println("数组的和为："+sum);
}
}
分析:
如果我们在Lambda中所指定的功能，已经有其他方法存在相同方案，那是否还有必要再写重复逻辑？可以直接“引 用”过去就好了：---方法引用。
请注意其中的双冒号 :: 写法，这被称为“方法引用”，是一种新的语法。
3.2什么是方法引用
方法引用是Lambda表达式的一种简写形式。如果Lambda表达式方法体中只是调用一个特定的已经存在的方法，则可以使用方法引用。.
常见形式
对象::实例方法
类::静态方法
类::实例方法
类::new
方法引用的分类
3.3静态方法引用
public class Test01 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(5);
list.add(6);
list.add(0);
list.add(2);
//Comparator<Integer> c= (o1,o2)->o1-o2;
//Comparator<Integer> c=(o1,o2)->Integer.compare(o1,o2);
Comparator<Integer> c=Integer::compare;
list.sort(c);
System.out.println(list);
}
}3.4实例方法引用
public class Test02 {
public static void main(String[] args) {
//People[] ps = {new People("张三",18),new People("李四",23),new People("王五",15)};
// Comparator<People> p = (o1,o2)->o1.getAge()-o2.getAge();
//Comparator<People> p=(o1,o2)->People.compareTo(o1,o2);
//Comparator<People> p=People::compareTo;
//Arrays.sort(ps,p);
// System.out.println(Arrays.toString(ps));
People p = new People("张安",22);
// Supplier<String> s=()->{
// return p.getName();
// };
Supplier<String> s=p::getName;
fun(s);
}
public static void fun(Supplier<String> supplier){
String s = supplier.get();
System.out.println("结果为："+s);
}
}
class People{
private String name;
private int age;
public static int compareTo(People p1,People p2){
return p1.getAge()-p2.getAge();
}
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public People(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
3.5 对象方法引用
类名::实例方法. (参数1,参数2)->参数1.实例方法(参数2)
public class Test03 {
public static void main(String[] args) {
// Function<String,Integer> function =(str)->{
// return str.length();
// };
Function<String,Integer> function =String::length;
Integer hello = function.apply("hello");;
System.out.println(hello);
BiFunction<String,String ,Boolean> bi=String::equals;
Boolean aBoolean = bi.apply("Hello", "hello");
System.out.println(aBoolean);
}
}3.6构造方法引用
类名::new (参数)->new 类名(参数)
public class Test03 {
public static void main(String[] args) {
Function<String,Pe> p=Pe::new;
Pe pe = p.apply("张三");
System.out.println(pe);
}
}
class Pe{
private String name;
public Pe(String name) {
this.name = name;
}
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
