标签: predicate

我有一个功能:

private IEnumerable<Promotion> MatchesKeyword(IEnumerable<Promotion> list, String keyword)
{
   ...snip...
}

现在执行LINQ查询:

private IEnumerable<Promotion> MatchesKeyword(IEnumerable<Promotion> list, String keyword)
{
   return list.Where(item => item.Name.ContainsText(keyword)
      || item.Description.ContainsText(keyword)
      ...snip...
   );
}

这段代码运行得很好.

但我需要将其转换为使用PredicateBuilder:

private IEnumerable<Promotion> MatchesKeyword(IEnumerable<Promotion> list, String keyword)
{
   var predicate = PredicateBuilder.False<Promotion>();     

   predicate = predicate.Or(item => item.Name.ContainsText(keyword)
         || item.Description.ContainsText(keyword)
         ...snip...
   );

   return list.Where(predicate);
}

奇怪的是,这不会编译.失败的路线是:

return list.Where(predicate);

您可以选择错误:

• 实例参数:无法从'System.Collections.Generic.IEnumerable'转换为'System.Linq.IQueryable'
• 'System.Collections.Generic.IEnumerable'不包含'Where'的定义和最佳扩展方法重载'System.Linq.Enumerable.Where(System.Collections.Generic.IEnumerable,System.Func)'有一些无效的参数
• 参数2:无法从'System.Linq.Expressions.Expression>'转换为'System.Func'

有什么问题？IEnumerable进去,IEnumerable出来.

我会说实话,我读了这个页面PredicateBuilder,我不明白其中任何一个.

一个淡淡的,为什么我需要改变PredicateBuilder …

我正在重构一些代码,发现有两个地方可以使用相同的代码编写,除了一组的比较器less<double>在一个地方而greater<double>在另一个地方.就像是:

double MyClass::Function1(double val)
{
    std::set<double, less<double> > s;
    // Do something with s
}

double MyClass::Function2(double val)
{
    std::set<double, greater<double> > s;
    // Do the same thing with s as in Function1
}

所以我想到了:

double MyClass::GeneralFunction(double val, bool condition)
{  
    if(condition)  
    {  
        // Select greater as comparator  
    }  
    else
    {  
        // Select less as comparator  
    }  

    set<double, comparator> s;  
    // common code
}

我通过使用我的自定义比较器函数使它工作,如下所示:

bool my_greater(double lhs, double rhs)
{
    return lhs > rhs;
} …

"普通"函数通常仅在给定类型的对象域上定义,但某些函数(如Scheme类型谓词list?或procedure?)是为任何类型的参数定义的,甚至可以应用于它们自身.因此,例如(list? procedure?)评估#f和(procedure? procedure?)评估#t.我试图找出如何编写这种完全定义的函数,但未能找到讨论这个的源.

例如,假设我们使用以下构造函数和选择器实现了计算机程序的结构和解释的练习2.4中描述的对数据类型:

    (define (cons x y)
      (lambda (m) (m x y)))

    (define (car z)
      (z (lambda (p q) p)))

    (define (cdr z)
      (z (lambda (p q) q)))

那么我如何定义一个谓词pair?,该谓词返回#t任何使用构造的东西cons,以及#f任何不构造的东西？更一般地,怎么都类型谓词喜欢list?和procedure?实施？

我正在改变我的一些旧代码以利用Java 8的功能方面.特别是,我正在使用Guava谓词java.util.function.Predicate.其中一个谓词是检查a是否Stream是同质的,即由所有相同的元素组成.

在我的旧代码中(使用Guava Predicate),我有这个:

static <T> Predicate<Iterable<T>> isHomogeneous() {
    return new Predicate<Iterable<T>>() {
        public boolean apply(Iterable<T> iterable) {
            return Sets.newHashSet(iterable).size() == 1;
        }
    };
}

这是新版本,使用java.util.function.Predicate:

public static Predicate<Stream<?>> isHomogeneous =
    stream -> stream.collect(Collectors.toSet()).size() == 1;

IDE(IntellijIDEA v.12)没有显示任何红色波浪线表示错误,但是当我尝试编译时,我得到了这个:

java: no suitable method found for
collect(java.util.stream.Collector<java.lang.Object,capture#1 of ?,java.util.Set<java.lang.Object>>)
  method java.util.stream.Stream.<R>collect(java.util.function.Supplier<R>,java.util.function.BiConsumer<R,? super capture#2 of ?>,java.util.function.BiConsumer<R,R>) is not applicable
    (cannot infer type-variable(s) R
      (actual and formal argument lists differ in length))
  method java.util.stream.Stream.<R,A>collect(java.util.stream.Collector<? super capture#2 of …

当我尝试使用 Querydsl（如 Spring 参考Spring 1.10.4.RELEASE 参考中所示）时，我从 IDE 中收到一些错误：无法解析方法 findAll(predicate)。我将导入更改为 com.mysema.query.types.Predicate。现在方法看起来不错。但我无法解决问题：

Predicate predicate = user.getUsername().equalsIgnoreCase(username).and((user.getId().equals(userid)).not);

我收到错误：无法解析方法：并且无法解析方法。

一些参考：示例 32. 存储库上的 Querydsl 集成

interface UserRepository extends CrudRepository<User, Long>, QueryDslPredicateExecutor<User> {

}

以上允许使用 Querydsl Predicate 编写类型安全查询。

Predicate predicate = user.firstname.equalsIgnoreCase("dave")
.and(user.lastname.startsWithIgnoreCase("mathews"));

userRepository.findAll(predicate);

但例子是不正确的。有人知道如何使用这个吗？

这是我的代码.

import java.util.stream.Stream;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.function.Predicate;

public class StreamMethod{
    public static void main(String... args){
        List<Integer> data = new ArrayList<Integer>(Arrays.asList(1,2,3,4,5,6,7,8));

        allMatch(data, x -> x < 10);
    }

    public static <T> void allMatch(List<?> list, Predicate<? super T> predicate){
        boolean allSatisfy = list.stream().allMatch(predicate);
        System.out.println(allSatisfy);
    }
}

我收到了错误incompatible types: Predicate<CAP#1> cannot be converted to Predicate<? super CAP#2>.你能帮我解决一下吗？为什么会显示此错误？

然后我也将上面的传递参数更改为

Predicate<Integer> pred= x -> x < 10;
allMatch(data, pred);

但仍面临错误.

我必须在 Prolog 中创建家庭关系来完成一项作业，我偶然发现了这个问题。

man(john).
woman(lisa).
married(john,lisa).

?- married(john,X).
X = lisa.

?- married(X,john).
false.

如何使这个谓词以两种方式起作用？如果约翰嫁给了丽莎，那么丽莎也嫁给了约翰。

对于事实，我只能使用性别、父母和已婚：

man(john).
woman(lisa).
parent(john,steve).
parent(lisa,steve).
married(john,lisa).

这个要求使得这个解决方案对我来说无法使用。我不能只添加关系，wife(lisa,john).因为我必须自己定义妻子、丈夫等。

wife(X,Y) :- woman(X),married(X,Y).

我使用带有 Spring REST 端点的 QueryDSL 谓词对象来检索和查询参数值。

@GetMapping("/{subjectId}/students")
@RolesAllowed( {Roles.PLATFORM_ADMIN, Roles.USER})
public List<StudentResponse> getAllStudents(@PathVariable final String subjectId,                                
                                      @QuerydslPredicate(root = Student.class) final Predicate predicate) {     

        final Predicate searchPredicate = studentPredicate()
                .predicate(predicate)
                .subjectId(subjectId)
                .build();
        return studentService.findBySubjectId(subjectId, searchPredicate);

}

Student类包含studentId和studentName属性；

现在，如果有人调用https://hostname/ {subjectId}/students?studentId=1234&studentName=test

然后上面的代码生成带有参数值的谓词对象。但是我需要从谓词对象中获取以上 2 个参数值，以便除了数据库查询之外进行进一步处理。我没有看到谓词对象有任何支持方法来检索值。那么我该怎么做呢？

我有一系列谓词子句，像这样

student?.firstName?.equals("John") ?: false &&
student?.lastName?.equals("Smith") ?: false &&
student?.age?.equals(20) ?: false &&
student?.homeAddress?.equals("45 Boot Terrace") ?: false &&
student?.cellPhone?.startsWith("123456") ?: false

我发现可以切换到布尔谓词and()而不是&&，但总的来说，它并没有使代码更简洁。