【Java8 新特性 6】断定型接口Predicate

灰太狼 2021-08-31 07:06 283阅读 0赞

## 一、一段代码引起的思考 ##

// ?主要用于变量上，T主要用于类或方法上
    private static <T> Predicate<T> getDistinct(Function<? super T, ?> param) {
        Map<Object, Boolean> map = new HashMap<>();
        //hash中不存在这个key，则返回null，如果存在返回true
        Predicate<T> ret = t -> map.putIfAbsent(param.apply(t), Boolean.TRUE) == null;
        return ret;
    }
     
    private static void test01() {
        List<User> list = new ArrayList<User>();
        list.add(new User("zs", 18));
        list.add(new User("ls", 28));
        list.add(new User("ww", 38));
        list.add(new User("ww", 40));
        System.out.println(list);
        System.out.println("----------------stream().filter-------------------------");
        List<User> list1  = list.stream().filter(getDistinct(a -> a.getName())).collect(Collectors.toList());
        System.out.println(list1);
    }

![20210218210708167.png][]

## 二、Predicate源码分析 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70][]

函数式接口！

一种相见恨晚的感觉！

## 三、代码实例 ##

### 1、利用函数式接口进行比较 ###

// 利用函数式接口
    private static void test01() {
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String t) {
                return t.equals("zs");
            }
        };
        boolean test = predicate.test("ls");
        System.out.println(test);
        boolean test2 = predicate.test("zs");
        System.out.println(test2);
    }

### 2、一些常见的比较 ###

// 判断传入的字符串的长度是否大于5  
// 判断传入的数字是否大于0  
// 判断传入的值在hash中是否存在

（1）普通写法

static Map<String, Object> hashMap = new HashMap<String, Object>();
    private static void test02() {
        boolean judgeLength = judgeLength("zhangsan");
        System.out.println(judgeLength);
        boolean judgeInt = judgeInt(10);
        System.out.println(judgeInt);
        hashMap.put("zs", 18);
        hashMap.put("ls", 28);
        hashMap.put("ww", 38);
        boolean judgeKey = judgeKey("zs");
        System.out.println(judgeKey);
    }
     
    // 判断传入的字符串的长度是否大于5
    private static boolean judgeLength(String str) {
        return str.length() > 5 ? true : false;
    }
     
    // 判断传入的数字是否大于0
    private static boolean judgeInt(int i) {
        return i > 0 ? true : false;
    }
     
    // 判断传入的值在hash中是否存在
    private static boolean judgeKey(String key) {
        return hashMap.containsKey(key) ? true : false;
    }

（2）Predicate写法

private static <T> boolean judgeByPredicate(T t, Predicate<T> predicate) {
        return predicate.test(t);
    }

private static void test03() {
        boolean judgeByPredicate = judgeByPredicate("zhangsan", t -> t.length() > 5);
        System.out.println(judgeByPredicate);
     
        boolean judgeByPredicate2 = judgeByPredicate(10,t -> t > 0);
        System.out.println(judgeByPredicate2);
     
        hashMap.put("zs", 18);
        hashMap.put("ls", 28);
        hashMap.put("ww", 38);
     
        boolean judgeByPredicate3 = judgeByPredicate("zs1", t -> hashMap.containsKey(t));
        System.out.println(judgeByPredicate3);
    }

### 3、And 、Or、取反 ###

//negate --> 取反 (逻辑非)
    private static <T> boolean judgeByPredicateNegate(T t, Predicate<T> predicate) {
        return predicate.negate().test(t);
    }

/**
     * 理论上and可以无限加下去
     * @param <T>
     * @param t 待判断的参数
     * @param predicate1 断定表达式1
     * @param predicate2 断定表达式2
     * @return 是否满足两个条件
     */
    private static <T> boolean judgeByPredicateAnd(T t, Predicate<T> predicate1, Predicate<T> predicate2) {
        return predicate1.and(predicate2).test(t);
    }
     
    //逻辑与
    private static <T> boolean judgeByPredicateAnd2(T t, Predicate<T> predicate1, Predicate<T> predicate2, Predicate<T> predicate3) {
        return predicate1.and(predicate2).and(predicate3).test(t);
    }
     
    //逻辑或
    private static <T> boolean judgeByPredicateOr(T t, Predicate<T> predicate1, Predicate<T> predicate2) {
        return predicate1.or(predicate2).test(t);
    }
     
    private static boolean judgeByPredicateEquals(String str1, String str2) {
        return Predicate.isEqual(str1).test(str2);
    }

private static void test04() {
        boolean judgeByPredicate = judgeByPredicateAnd("zhangsan", t -> t.length() > 5, t -> t.length() < 7);
        System.out.println("*and**"+judgeByPredicate);
     
        boolean judgeByPredicateOr = judgeByPredicateOr("zhangsan", t -> t.length() > 5, t -> t.length() < 7);
        System.out.println("*or**"+judgeByPredicateOr);
     
        boolean judgeByPredicate4 = judgeByPredicateAnd2("zhangsan", t -> t.length() > 5, t -> t.length() < 10, t -> t.contains("li"));
        System.out.println("***"+judgeByPredicate4);
     
        boolean judgeByPredicate2 = judgeByPredicate(10,t -> t > 0);
        System.out.println(judgeByPredicate2);
     
        hashMap.put("zs", 18);
        hashMap.put("ls", 28);
        hashMap.put("ww", 38);
        boolean judgeByPredicate3 = judgeByPredicate("zs1", t -> hashMap.containsKey(t));
        System.out.println(judgeByPredicate3);
    }
     
    private static void test05() {
        String str1 = "zhangsan";
        String str2 = "zs";
        String str3 = "zhangsan";
        boolean judgeByPredicateEquals = judgeByPredicateEquals(str1, str2);
        System.out.println("judgeByPredicateEquals1:"+judgeByPredicateEquals);
        judgeByPredicateEquals = judgeByPredicateEquals(str1, str3);
        System.out.println("judgeByPredicateEquals2:"+judgeByPredicateEquals);
    }

test04的控制台输出：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 1][]

## 四、消费型接口consumer ##

//consumer接口
    private static void test01() {
        String[] arr = {"张三:18", "李四:25", "王五:28"};
        consumerTest(arr, con -> {
            System.out.print("姓名："+con.split(":")[0] + "，");
        }, con -> {
            System.out.println("年龄："+con.split(":")[1]);
        });
        }
     
        private static void consumerTest(String[] arr, Consumer<String> consumer1, Consumer<String> consumer2) {
        for(int i = 0; i<arr.length; i++) {
            consumer1.andThen(consumer2).accept(arr[i]);
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 2][]

private static void test01() {
    	List<Book> list = new ArrayList<Book>();
    	list.add(new Book("effective java", 110));
    	list.add(new Book("effective c++", 88));
    	list.add(new Book("effective c#", 59));
    	list.forEach(x -> {
    		if(x.getBookName().contains("java")) {
    			x.setBookPrice(x.getBookPrice()/2);
    		}
    	});
    	//[Book [bookName=effective java, bookPrice=55], 
    	//Book [bookName=effective c++, bookPrice=88], 
    	//Book [bookName=effective c#, bookPrice=59]]
    	System.out.println(list);
    }

往期精彩内容：

[Java知识体系总结（2021版）][Java_2021]

[Java多线程基础知识总结（绝对经典）][Java]

[【全栈最全Java框架总结】SSH、SSM、Springboot][Java_SSH_SSM_Springboot]

[超详细的springBoot学习笔记][springBoot]

[常见数据结构与算法整理总结][Link 1]

[Java设计模式：23种设计模式全面解析（超级详细）][Java_23]

[Java面试题总结（附答案）][Java 1]

[20210218210708167.png]: /images/20210813/f6d218542d25433288cc7fa3b238555f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70]: /images/20210813/0cdf068148de4b2aba5208352181cbdb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 1]: /images/20210813/13d44e650e994ba1a1d2f3aeae51a72a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 2]: /images/20210813/fa9d0c793bc44cf7ad25a1fe8d25f807.png
[Java_2021]: https://blog.csdn.net/guorui_java/article/details/112391105
[Java]: https://blog.csdn.net/guorui_java/article/details/107599455
[Java_SSH_SSM_Springboot]: https://blog.csdn.net/guorui_java/article/details/104018528
[springBoot]: https://blog.csdn.net/guorui_java/article/details/104137262
[Link 1]: https://blog.csdn.net/guorui_java/article/details/106217472
[Java_23]: https://blog.csdn.net/guorui_java/article/details/104026988
[Java 1]: https://blog.csdn.net/guorui_java/article/details/107803283