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

本文链接：https://blog.csdn.net/2301_76534800/article/details/133796749

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();
       }



   }

}