Java中的谓词

我正在浏览Java中使用

谓词的代码。我从未使用过
谓词
。有人能给我介绍一下
谓词及其Java实现的任何教程或概念解释吗？
您可以查看谓词使用的示例或示例

基本上，它用于根据您可能具有的任何特定条件筛选结果集中的行，并为满足条件的行返回true：

 // the age column to be between 7 and 10
    AgeFilter filter = new AgeFilter(7, 10, 3);

    // set the filter.
    resultset.beforeFirst();
    resultset.setFilter(filter);

我猜你说的是番石榴

从API：

确定给定输入的
true
或
false
值。例如，
RegexPredicate
可能实现
谓词
，并对与其给定正则表达式匹配的任何字符串返回true

这本质上是一个面向对象的抽象，用于
boolean
测试

例如，您可能有如下帮助器方法：

static boolean isEven(int num) {
   return (num % 2) == 0; // simple
}

    List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    for (int number : numbers) {
        if (isEven(number)) {
            process(number);
        }
    }

    Predicate<Integer> isEven = new Predicate<Integer>() {
        @Override public boolean apply(Integer number) {
            return (number % 2) == 0;
        }               
    };
    Iterable<Integer> evenNumbers = Iterables.filter(numbers, isEven);

    for (int number : evenNumbers) {
        process(number);
    }

static boolean isAllPositive(Iterable<Integer> numbers) {
    for (Integer number : numbers) {
        if (number < 0) {
            return false;
        }
    }
    return true;
}

//...
if (isAllPositive(numbers)) {
    System.out.println("Yep!");
}

现在，给定一个
列表
，您只能处理以下偶数：

static boolean isEven(int num) {
   return (num % 2) == 0; // simple
}

    List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    for (int number : numbers) {
        if (isEven(number)) {
            process(number);
        }
    }

    Predicate<Integer> isEven = new Predicate<Integer>() {
        @Override public boolean apply(Integer number) {
            return (number % 2) == 0;
        }               
    };
    Iterable<Integer> evenNumbers = Iterables.filter(numbers, isEven);

    for (int number : evenNumbers) {
        process(number);
    }

static boolean isAllPositive(Iterable<Integer> numbers) {
    for (Integer number : numbers) {
        if (number < 0) {
            return false;
        }
    }
    return true;
}

//...
if (isAllPositive(numbers)) {
    System.out.println("Yep!");
}

注意，现在for-each循环在没有
if
测试的情况下更简单。通过定义
Iterable evernumbers
，通过
filter
-ing使用
谓词
，我们已经达到了更高的abtraction级别

API链接



返回满足谓词的元素



关于高阶函数
谓词
允许
Iterables.filter
充当所谓的高阶函数。就其本身而言，这提供了许多优势。以上面的
列表编号为例。假设我们想测试所有的数字是否都是正数。我们可以这样写：

static boolean isEven(int num) {
   return (num % 2) == 0; // simple
}

    List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    for (int number : numbers) {
        if (isEven(number)) {
            process(number);
        }
    }

    Predicate<Integer> isEven = new Predicate<Integer>() {
        @Override public boolean apply(Integer number) {
            return (number % 2) == 0;
        }               
    };
    Iterable<Integer> evenNumbers = Iterables.filter(numbers, isEven);

    for (int number : evenNumbers) {
        process(number);
    }

static boolean isAllPositive(Iterable<Integer> numbers) {
    for (Integer number : numbers) {
        if (number < 0) {
            return false;
        }
    }
    return true;
}

//...
if (isAllPositive(numbers)) {
    System.out.println("Yep!");
}

希望您现在可以在更高的抽象中看到诸如“按给定谓词过滤所有元素”、“检查所有元素是否满足给定谓词”之类的例程的值，从而获得更好的代码

不幸的是，Java没有一流的方法：不能将方法传递给
Iterables.filter
和
Iterables.all
。当然，您可以在Java中传递对象。因此，定义了
谓词
类型，并传递实现此接口的对象

另见



谓词是返回真/假（即布尔）值的函数，而不是真/假（即布尔）值的命题。在Java中，不能有独立的函数，因此可以通过为表示谓词的对象创建接口来创建谓词，然后提供实现该接口的类。谓词接口的一个示例可能是：

public interface Predicate<ARGTYPE>
{
    public boolean evaluate(ARGTYPE arg);
}

自Java 8起，在Java API中定义的公共接口谓词接口（）。在Java8之前，您可能会发现从中重用接口很方便

另外，请注意，在Java8中，使用lambdas编写谓词要简单得多。例如，在Java 8及更高版本中，可以将
p->true
传递给函数，而不是像上面那样定义命名重言式子类。
加起来：

在java中筛选集合时，可以使用如下谓词：

public static <T> Collection<T> filter(final Collection<T> target,
   final Predicate<T> predicate) {
  final Collection<T> result = new ArrayList<T>();
  for (final T element : target) {
   if (predicate.apply(element)) {
    result.add(element);
   }
  }
  return result;
}

公共静态收集筛选器（最终收集目标，
最终谓词（谓词）{
最终收集结果=新建ArrayList（）；
for（最终T元素：目标）{
if（谓词.apply（元素））{
结果：添加（元素）；
}
}
返回结果；
}

一个可能的谓词可以是：

final Predicate<DisplayFieldDto> filterCriteria = 
                    new Predicate<DisplayFieldDto>() {
   public boolean apply(final DisplayFieldDto displayFieldDto) {
    return displayFieldDto.isDisplay();
   }
  };

最终谓词过滤器标准=
新谓词（）{
公共布尔应用（最终显示字段到显示字段）{
将displayFieldDto.isDisplay（）返回；
}
};

用法：

 final List<DisplayFieldDto> filteredList=
 (List<DisplayFieldDto>)filter(displayFieldsList, filterCriteria);

最终列表过滤器列表=
（列表）过滤器（displayFieldsList，filterCriteria）；
你说的是番石榴的
谓词吗？类似的东西？完全是另外一回事吗？还有Apache Commons
谓词
我不是指Guava的谓词，我的问题应该很清楚。但是你的解释帮助我理解了我在寻找什么，谓词逻辑在java中的使用方式。谢谢你的精心安排explanation@polygenelubricants既然我们已经有了做同样事情的
F
，为什么还要发明
Predicate
；谓词isEven=integer->（整数%2）==0；Iterable evenNumbers=numbers.stream（）.filter（isEven.collect）（Collectors.toList（））我引用的是commons谓词，而不是与结果集相关的谓词。谢谢，但这不是基本上违背了目的吗？选择函数式方法的主要原因是不要手动迭代，并去掉for。抽象级别变得越来越高，越来越强大——但是手动执行for会破坏这一目的，并返回到低级抽象。