java.util.function.Predicate

电玩女神 2023-01-07 10:12 110阅读 0赞

## 一、java.util.function.Predicate ##

## 求最大值，代码保存 ##

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
            Optional<Integer> max = numbers.stream().reduce(Integer::max);
            System.out.println(max.orElse(0));
            System.out.println(numbers.stream().max(Integer::compare).get());
            System.out.println(numbers.stream().mapToInt(i -> i).max().getAsInt());

这里类是java自带主要广泛用在支持lambda表达式的API中。

#### 1、接口源码 ####

@FunctionalInterface
    public interface Predicate<T> { 
        /** * 具体过滤操作 需要被子类实现. * 用来处理参数T是否满足要求,可以理解为 条件A */
        boolean test(T t);
        
        /** * 调用当前Predicate的test方法之后再去调用other的test方法,相当于进行两次判断 * 可理解为 条件A && 条件B */
        default Predicate<T> and(Predicate<? super T> other) { 
            Objects.requireNonNull(other);
            return (t) -> test(t) && other.test(t);
        }
        /** * 对当前判断进行"!"操作,即取非操作，可理解为 ! 条件A */
        default Predicate<T> negate() { 
            return (t) -> !test(t);
        }
        /** * 对当前判断进行"||"操作,即取或操作,可以理解为 条件A ||条件B */
        default Predicate<T> or(Predicate<? super T> other) { 
            Objects.requireNonNull(other);
            return (t) -> test(t) || other.test(t);
        }
    
        /** * 对当前操作进行"="操作,即取等操作,可以理解为 A == B */
        static <T> Predicate<T> isEqual(Object targetRef) { 
            return (null == targetRef)
                    ? Objects::isNull
                    : object -> targetRef.equals(object);
        }
    }

#### 2、常规示例 ####

public static void main(String[] args) { 
            /** * 1、判断数字是否大于7 */
            //设置一个大于7的过滤条件
            Predicate<Integer> predicate = x -> x > 7;
            System.out.println(predicate.test(10)); //输出 true
            System.out.println(predicate.test(6));  //输出 fasle
             /** * 2、大于7并且 */
            //在上面大于7的条件下，添加是偶数的条件
            predicate = predicate.and(x -> x % 2 == 0);
            System.out.println(predicate.test(6));  //输出 fasle
            System.out.println(predicate.test(12)); //输出 true
            System.out.println(predicate.test(13)); //输出 fasle
            /** * 3、add or 简化写法 */
            predicate = x -> x > 5 && x < 9;
            System.out.println(predicate.test(10)); //输出 false
            System.out.println(predicate.test(6));  //输出 true
        }

#### 3、集合Stream示例 ####

**User对象**

@Data
    @AllArgsConstructor
    @ToString
    public class User { 
        /** * 姓名 */
        private String name;
    
        /** * 性别 */
        private String sex;
    
        /** * 年龄 */
        private Integer age;
        
       /** * 重写equals和hashCode */
        @Override
        public boolean equals(Object obj) { 
            if (obj instanceof User) { 
                User user = (User) obj;
                if (name.equals(user.name)){ 
                    return true;
                }
            }
                return false;
            }
            @Override
            public int hashCode () { 
                return name.hashCode();
            }
    
        }

**测试代码**

public static void main(String[] args) { 
            User user1 = new User("张三", "女", 1);
            User user2 = new User("李四", "男", 2);
            User user3 = new User("张三", "女", 3);
            List<User> list = Lists.newArrayList(user1, user2, user3);
    
           /** * 1、获取年龄大于2的对象 */
            List<User> collect = list.stream().filter(x -> x.getAge() > 2).collect(Collectors.toList());
            System.out.println("获取年龄大于2的数量 = " + collect.size());
            //输出：获取年龄大于2的数量 = 1
    
            /** * 2、去重 设置name相同即为相同对象 */
            //方式1直接使用 distinct
            List<User> collect1 = list.stream().distinct().collect(Collectors.toList());
            System.out.println("输出剩余对象" + collect1);
            //输出：输出剩余对象[User(name=张三, sex=女, age=1), User(name=李四, sex=男, age=2)]
    
            /** * 3、从集合找出与该对象相同的元素 同样name相同即为相同对象 */
            User user4 = new User("张三", "男", 8);
            Predicate<User> predicate =  Predicate.isEqual(user4);
            List<User> collect2 = list.stream().filter(predicate).collect(Collectors.toList());
            System.out.println("与该对象相同的对象有" + collect2);
            //输出：与该对象相同的对象有[User(name=张三, sex=女, age=1), User(name=张三, sex=女, age=3)]
        }

java.util.function.Predicate

发表评论取消回复

还没有评论，来说两句吧...

相关阅读