java 泛型与函数接口的练习demo

项目中有很多重复性的代码,都被我改成了公共泛型方法,但是关于泛型与函数编程的结合还是感觉有些吃力,所以写了些练习demo

package com.example.testdemo.entity;


import lombok.Data;
import lombok.experimental.Accessors;

import java.util.*;
import java.util.function.*;

/**
 * TODO:
 *
 * @author WKQ
 * @date 2024/4/20
 */

@Data
@Accessors(chain = true)
class Dog {
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 姓名
     */
    private String name;
    /**
     * 描述:年龄大于等于8即为成年
     */
    private String desc;
}

@Data
@Accessors(chain = true)
class Cat {
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 姓名
     */
    private String name;
    /**
     * 描述:年龄大于等于6即为成年
     */
    private String desc;
}


public class TestContent {

    public static void main(String[] args) {
        test1();
        test2();
        test3();
    }

    /**
     * 案例1
     */
    private static void test1() {
        // 创建两只狗
        Dog dog1 = new Dog().setAge(6).setName("小黑狗");
        Dog dog2 = new Dog().setAge(8).setName("小白狗");

        // 创建一个 Map,键为 Dog 对象,值为处理 Dog 对象的 Consumer
        Map<Dog, Consumer<Dog>> map = new LinkedHashMap<>();

        // 创建 Consumer,用于打印 Dog 的名字
        Consumer<Dog> nameField = (Dog dog) -> System.out.println(dog.getName());
        // 创建 Consumer,用于打印 Dog 的年龄
        Consumer<Dog> ageField = (Dog dog) -> System.out.println(dog.getAge());

        // 将 Consumer 添加到 Map 中
        map.put(dog1, nameField);
        map.put(dog2, ageField);

        // 执行 Map 中的 Consumer,处理每只狗
        execField(map);

        // 创建两只猫
        Cat cat1 = new Cat().setAge(8).setName("小白猫");
        Cat cat2 = new Cat().setAge(8).setName("小黑猫");

        // 创建一个 Map,键为 Cat 对象,值为处理 Cat 对象的 Consumer
        Map<Cat, Consumer<Cat>> map1 = new LinkedHashMap<>();

        // 创建 Consumer,用于打印 Cat 的名字
        Consumer<Cat> nameField1 = (Cat cat) -> System.out.println(cat.getName());
        // 创建 Consumer,用于打印 Cat 的年龄
        Consumer<Cat> ageField1 = (Cat cat) -> System.out.println(cat.getAge());

        // 将 Consumer 添加到 Map 中
        map1.put(cat1, nameField1);
        map1.put(cat2, ageField1);

        // 执行 Map 中的 Consumer,处理每只猫
        execField(map1);
    }

    /**
     * 案例1
     */
    private static void test2() {
        // 创建三只狗
        Dog dog1 = new Dog().setAge(6).setName("小黑");
        Dog dog2 = new Dog().setAge(8).setName("小白");
        Dog dog3 = new Dog().setAge(10).setName("小红");

        // 创建一个 Map,键为 Dog 对象,值为处理 Dog 对象的 Consumer
        Map<Dog, Consumer<Dog>> map = new LinkedHashMap<>();

        // 创建 Consumer,用于处理 Dog 的描述(成年/未成年)
        Consumer<Dog> func = (Dog dog) -> {
            // 假设狗八岁成年
            Predicate<Integer> judge = (Integer num) -> num >= 8;
            if (judge.test(dog.getAge())) {
                dog.setDesc("成年");
            } else {
                dog.setDesc("未成年");
            }
        };

        // 将 Consumer 添加到 Map 中
        map.put(dog1, func);
        map.put(dog2, func);
        map.put(dog3, func);

        // 执行 Map 中的 Consumer,处理每只狗
        execField(map);
    }

    private static void test3() {
        // 创建三只狗
        Dog dog1 = new Dog().setAge(6).setName("小黑狗");
        Dog dog2 = new Dog().setAge(8).setName("小白狗");
        Dog dog3 = new Dog().setAge(9).setName("小红狗");

        // 创建一个 Map,键为 Dog 对象,值为处理 Dog 对象的 BiConsumer
        Map<Dog, BiConsumer<Dog, Predicate<Integer>>> map = new LinkedHashMap<>();

        // 创建 BiConsumer,用于处理 Dog 的描述(成年/未成年)
        BiConsumer<Dog, Predicate<Integer>> func = (Dog dog, Predicate<Integer> judge) -> {
            // 假设狗八岁成年
            if (judge.test(dog.getAge())) {
                dog.setDesc("成年");
            } else {
                dog.setDesc("未成年");
            }
        };

        // 将 BiConsumer 添加到 Map 中
        map.put(dog1, func);
        map.put(dog2, func);
        map.put(dog3, func);

        // 执行 Map 中的 BiConsumer,处理每只狗
        execField2(map, (Integer num) -> num >= 8);

        // 创建三只猫
        Cat cat1 = new Cat().setAge(6).setName("小黑猫");
        Cat cat2 = new Cat().setAge(8).setName("小白猫");
        Cat cat3 = new Cat().setAge(7).setName("小红猫");

        // 创建一个 Map,键为 Cat 对象,值为处理 Cat 对象的 BiConsumer
        Map<Cat, BiConsumer<Cat, Predicate<Integer>>> map2 = new LinkedHashMap<>();

        // 创建 BiConsumer,用于处理 Cat 的描述(成年/未成年)
        BiConsumer<Cat, Predicate<Integer>> func2 = (Cat cat, Predicate<Integer> judge) -> {
            // 假设猫六岁成年
            if (judge.test(cat.getAge())) {
                cat.setDesc("成年");
            } else {
                cat.setDesc("未成年");
            }
        };

        // 将 BiConsumer 添加到 Map 中
        map2.put(cat1, func2);
        map2.put(cat2, func2);
        map2.put(cat3, func2);

        // 执行 Map 中的 BiConsumer,处理每只猫
        execField2(map2, (Integer num) -> num >= 6);
    }

    /**
     * 执行 Map 中每个键对应的 Consumer 函数的处理逻辑。
     * <p>
     * 此方法遍历给定的 Map,对于每一个键值对,它获取对应的 Consumer,
     * 并使用该 Consumer 对键进行处理。
     *
     * @param <T> 键的类型
     * @param map 要处理的 Map,键为任何类型 T,值为处理该键的 Consumer<T>
     */
    public static <T> void execField(Map<T, Consumer<T>> map) {
        for (T t : map.keySet()) {
            Consumer<T> r = map.get(t);
            r.accept(t);
            System.out.println(t);
        }
    }

    /**
     * 执行 Map 中每个键对应的 BiConsumer 函数的处理逻辑。
     * <p>
     * 此方法遍历给定的 Map,对于每一个键值对,它获取对应的 BiConsumer,
     * 并使用该 BiConsumer 对键进行处理。处理时会使用提供的 Predicate 判断条件。
     *
     * @param <T> 键的类型
     * @param map 要处理的 Map,键为任何类型 T,值为处理该键的 BiConsumer<T, Predicate<Integer>>
     * @param test 用于判断的 Predicate<Integer>,用于 BiConsumer 中的判断逻辑
     */
    public static <T> void execField2(Map<T, BiConsumer<T, Predicate<Integer>>> map, Predicate<Integer> test) {
        for (T t : map.keySet()) {
            BiConsumer<T, Predicate<Integer>> con = map.get(t);
            con.accept(t, test);
            System.out.println(t);
        }
    }
}

  • 3
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值