第14章总结：lambda表达式与处理-CSDN博客

本文链接：https://blog.csdn.net/2301_76534925/article/details/133801175

14.1： lambada表达式
14.1.1：lambada表达式简介

无参数

package fourteen;
interface SayhHi{
String say();//抽象方法接口
}

public class NoParamDemo {
public static void main(String[] args) {
//无参数
//利用匿名内部类补全方法体
SayhHi sh1 = new SayhHi() {
public String say() {
return "这是匿名内部类";
}
};
System.out.print(sh1.say());
}

}

使用表达式表达

System.out.print(sh1.say());
//利用lambda表达式补全方法体
SayhHi sh2 =() -> {
return "这是lambda表达式";
};
System.out.println(sh2.say());

}

}

有参数

使用表达式

package fourteen;
interface AddInt{
int add(int a,int b);//抽象方法接口
}

public class Prama {

public static void main(String[] args) {

//有参数
//利用匿名内部类补全方法体
AddInt ai1 = new AddInt() {
public int add(int a,int b){
return a+b;
}
};
System.out.println("匿名内部类:" + ai1.add(3, 5));
//利用lambda表达式补全方法体
AddInt ai2=( a, b) -> {
return a+b ;
};
System.out.println("lambda表达式:"+ai2.add(3, 5));

}

}

例题

package fourteen;
interface CheckGrade {
String check(int grade); // 查询成绩结果
}

public class GradeDemo {
public static void main(String[] args) {
CheckGrade g = (n) -> { // lambda实现代码块
if (n >= 90 && n <= 100) { // 如果成绩在90-100
return "成绩为优"; // 输出成绩为优
} else if (n >= 80 && n < 90) { // 如果成绩在80-89
return "成绩为良"; // 输出成绩为良
} else if (n >= 60 && n < 80) { // 如果成绩在60-79
return "成绩为中"; // 输出成绩为中
} else if (n >= 0 && n < 60) { // 如果成绩小于60
return "成绩为差"; // 输出成绩为差
} else { // 其他数字不是有效成绩
return "成绩无效"; // 输出成绩无效
}
}; // 不要丢掉lambda语句后的分号
System.out.println(g.check(89)); // 输出查询结果
}
}
//14.3

//使用方法的引用补全方法体

双冒号：：

static int add(int x, int y) {//方法的引用，这是方法体的方法

return x+y;

}

static int add(int x, int y) {//方法的引用，这是方法体的方法

return x+y;

}

完整代码

package fourteen;
interface AddInt{
int add(int a,int b);//抽象方法接口
}

public class Prama {
static int add(int x, int y) {//方法的引用，这是方法体的方法
//对象也可以找到这个方法体，非静态
return x+y;
}

public static void main(String[] args) {
//有参数
//利用匿名内部类补全方法体
AddInt ai1 = new AddInt() {
public int add(int a,int b){
return a+b;
}
};
System.out.println("匿名内部类:" + ai1.add(3, 5));
//利用lambda表达式补全方法体
AddInt ai2=( a, b) -> {
return a+b ;
};
System.out.println("lambda表达式:"+ai2.add(3, 5));
//使用方法的引用补全方法体
AddInt ai3 = Prama::add;//找到类，找到方法体
System.out.println("方法体："+ai3.add(3, 5));

}

}

例14.8

package fourteen;

import java.text.SimpleDateFormat;
import java.util.Date;
interface InstanceMethodInterface { // 创建测试接口
String method(Date date); // 带参数的抽象方法
}
public class InstanceMethodDemo {
public String format(Date date) { // 格式化方法
// 创建日期格式化对象，并指定日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
return sdf.format(date); // 返回格式化结果
}

public static void main(String[] args) {
// 创建类对象
InstanceMethodDemo demo = new InstanceMethodDemo();
// 引用类对象的方法
InstanceMethodInterface im = demo::format;
Date date = new Date(); // 创建日期对象
System.out.println("默认格式：" + date); // 输出日期对象默认格式
// 输出经过接口方法处理过的格式
System.out.println("接口输出的格式：" + im.method(date));
}
}//14.8

//调用构造器

package fourteen;
interface ConIn{
ConDemo action();//创建接口，正好是这个类的构造器类型，抽象方法

}
public class ConDemo {
//使用无参的构造方法补全方法体
public ConDemo() {//构造方法要写小括号
System.out.println("无参构造方法");//构造方法
}
public ConDemo(int a) {//构造方法要写小括号
System.out.println("有参构造方法");//构造方法
}
public static void main(String args[]) {
ConIn ci1 = ConDemo:: new;//new一个对象
ci1.action();//调用action方法
//使用有参数的方法来补全方法体
//ConDemo action(int a);
//ConIn ci1 = ConDemo:: new;//new一个对象
//ci1.action(5);//调用action方法
}

}

流：

static List<Employee> getEmpList() { // 提供数据初始化方法
List<Employee> list = new ArrayList<Employee>();
// 添加员工数据
list.add(new Employee("老张", 40, 9000, "男", "运营部"));
list.add(new Employee("小刘", 24, 5000, "女", "开发部"));
list.add(new Employee("大刚", 32, 7500, "男", "销售部"));
list.add(new Employee("翠花", 28, 5500, "女", "销售部"));
list.add(new Employee("小马", 21, 3000, "男", "开发部"));
list.add(new Employee("老王", 35, 6000, "女", "人事部"));
list.add(new Employee("小王", 21, 3000, "女", "人事部"));
return list;

stream接口

package fourteen;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo {

public static void main(String[] args) {
List<Employee> list=Employee.getEmpList();//从employee表拿到list表中的员工表
Stream<Employee> stream = list.stream();//调用list方法将表转换成流
//筛选年龄>30岁的员工
stream=stream.filter(sx-> sx.getAge()>30);//写条件，sx属于临时变量
//限制条数
stream = stream.limit(2);
List<Employee> result = stream.collect(Collectors.toList());//转成List链表
for (Employee sx : result) {//for循环输出结果
System.out.println(sx);

}
}

}

数据分组

package fourteen;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class GroupDemo {

public static void main(String[] args) {
// 分组
List<Employee> list=Employee.getEmpList();//从employee表拿到list表中的员工表
Stream<Employee> stream = list.stream();//调用list方法将表转换成员工流
Map<String,List<Employee>> map = //创建map集合存入，String代指dept，list链表指代map集合的value
stream.collect(Collectors.groupingBy(Employee::getDept));//利用流调用collect方法，分组方法，传入方法
Set<String> depts = map.keySet();//获取map集合中的部门表
for(String dept:depts){//for循环一个部门，depts代指部门
System.out.println(dept+"员工信息如下：");//输出信息
List<Employee> temp = map.get(dept);//分组列表输出
for(Employee g : temp){//temp是临时变量
System.out.println(g);//
}
System.out.println();
}

}

}