标签: predicate

我有一个ArrayList要过滤,并用各种番石榴Predicate来过滤它.此列表只有50-100个元素.

我打算Iterables.removeIf依次使用每个谓词.它可能不是最大效率但从不介意(至少removeIf对RandomAccess列表有一些优化)

对于调试,我想简明地记录每个谓词的作用.例如

Pred0 removed [a, c, g]
Pred1 removed []
Pred2 removed [b, f]

有一些明显的黑客解决方案,但你认为最干净的是什么？

对于奖励积分,它也应该是合理有效的.;)

我正在通过我的AI教科书工作,我已经完成了我的部分的最后一个作业问题:

"以您选择的任何语言实施第69页概述的统一算法."

在页69,您有统一算法的以下伪代码:

function unify(E1, E2);
    begin
        case
            both E1 and E2 are constants or the empty list:
                if E1 = E2 then return {}
                else return FAIL;
            E1 is a variable:
                if E1 occurs in E2 then return FAIL
                 else return {E2/E1}
            E2 is a variable
                if E2 occurs in E1 then FAIL
                    else return {E1/E2}
            either E1 or E2 are empty then return FAIL
            otherwise:
                begin
                    HE1 := first element of E1;
                    HE2 := first element of E2; …

是否有一个javascript库,允许我在类似于MongoDB的查询语言的DSL中表达对象谓词？为了清楚大型程序,我希望能够说:

var obj = { 
    a: 1, 
    b: 'abcdefg' 
}, qry = { 
    a: { $gt: 0 }, 
    b: /^abc/ 
}; 

if(query(qry).matches(obj)) { 
    // do something appropriate since 
} 

代替:

var obj = { 
    a: 1, 
    b: 'abcdefg' 
}; 
if(obj.a>0 && qry.b.test(obj.b)) { 
    // do something appropriate 
} 

我正在使用Node.js,因此NPM上的任何内容都会很棒.如果库可以从数组中选择对象以及仅匹配单个对象,那将是一个额外的好处.

我回顾了这两个相关的问题,但对我的情况并没有特别的帮助:

• 实现类似goMongoDB的Query表达式对象评估
• 在PHP中评估类似MongoDB的JSON查询

我正在尝试过滤矢量,因此它只包含一个特定的值.

例如,确保向量仅包含值"abc"的元素.

现在,我正在努力实现这一目标remove_copy_if.

有没有办法在使用std算法之一时将附加参数传递给谓词？

std::vector<std::string> first, second;
first.push_back("abc");
first.push_back("abc");
first.push_back("def");
first.push_back("abd");
first.push_back("cde");
first.push_back("def");

std::remove_copy_if(first.begin(), first.end(), second.begin(), is_invalid);

我希望将以下函数作为谓词传递,但似乎更有可能最终将比较正在检查的当前值remove_copy_if和下一个.

bool is_invalid(const std::string &str, const std::string &wanted)
{
   return str.compare(wanted) != 0;
}

我有一种感觉,我可能正在接近这个错误所以任何建议将不胜感激!

谢谢

我经常发现自己需要过滤Stream或使用谓词来检查给定字段是否具有给定值.

比方说我有这个POJO:

public class A {
    private Integer field;

    public A(final Integer field) {
        this.field = field;
    }

    public Integer getField() {
        return field;
    }
}

我想Stream根据以下值来过滤一个对象field:

    final Integer someValue = 42;
    Stream.of(new A(42), new A(1729), new A(42), new A(87539319), new A(null))
            .filter(a -> Objects.equals(a.getField(), someValue))
            ...

是否有方便的方法来生成方法的谓词filter？我注意到Predicate.isEqual它有但不适合需要.

我可以很容易地写一个这样的:

public static <T,R> Predicate<T> isEqual(Function<? super T, ? extends R> f, R value) {
    return v -> Objects.equals(value, f.apply(v));
}

并将其用作: …

在研究Java8 Streams时,我遇到了以下代码片段:

Predicate<? super String> predicate = s -> s.startsWith("g");

由于泛型参数是下限,我认为这不会编译.我看到它的方式,如果一个Object是String的超类型,那么传入一个Object类型应该会破坏它,因为Object没有startsWith()函数.但是,我很惊讶地看到它没有任何问题.

更进一步,当我调整谓词采取上限:

<? extends String>,

它不会编译.

我以为我理解了上限和下限的含义,但显然,我错过了一些东西.任何人都可以帮助解释为什么下限与这个lambda一起工作？

我在一些项目中看到人们使用Predicates而不是纯if语句,如下面的一个简单示例所示:

    int i = 5;
    // Option 1
    if (i == 5) {
        // Do something
        System.out.println("if statement");
    }

    // Option 2
    Predicate<Integer> predicate = integer -> integer == 5;
    if (predicate.test(i)) {
        // Do something
        System.out.println("predicate");
    }

更喜欢Predicate陈述的重点是什么？

我正在尝试为I18N实现构建JPA规范,以便能够过滤名称.
在数据库中,我有多种语言的翻译.
问题是大多数时候只指定默认语言.
因此,当有人请求翻译非默认语言时,我希望它能够使用默认语言.

到目前为止,我能够在规格中构建它

Specification<S> specification = (root, query, cb) -> {
  Join i18n = root.join("translations", JoinType.LEFT);
  i18n.alias("i18n");
  Join i18nDefault = root.join("translations", JoinType.LEFT);
  i18nDefault.alias("i18nDefault");

  i18n.on(cb.and(cb.equal(i18n.get("itemId"), root.get("itemId")), cb.equal(i18n.get("languageId"), 1)));
  i18nDefault.on(cb.and(cb.equal(i18nDefault.get("itemId"), root.get("itemId")), cb.equal(i18nDefault.get("languageId"), 22)));

  // Clauses and return stuff
};

但这会导致错误,这听起来像是这个解决方案的坏消息

org.hibernate.hql.internal.ast.QuerySyntaxException: with-clause referenced two different from-clause elements
[
 select generatedAlias0 from com.something.Item as generatedAlias0 
 left join generatedAlias0.i18n as i18n with (i18n.itemId=generatedAlias0.itemId) and ( i18n.languageId=1L )
 left join generatedAlias0.i18n as i18nDefault with (i18nDefault.itemId=generatedAlias0.itemId) and ( i18nDefault.languageId=1L )
];

所以Hibernate不允许我用不同的元素构建一个with子句(在本例中是itemId和languageId).
有什么方法可以正确地或以不同的方式实现这个？

最后,我希望Hibernate生成一个如下所示的查询(Oracle) …

我试图从矢量中删除一些元素,基于谓词,并收集结果.这是一个具有预期结果的(不工作)示例:

let mut v: Vec<i32> = vec![1, 2, 3, 4, 5, 6];

let drained: Vec<i32> = v.iter().filter(|e| (*e) % 2 == 0).drain(..).collect();

assert_eq!(v, vec![1, 3, 5]);
assert_eq!(drained, vec![2, 4, 6]);

这导致错误

error[E0599]: no method named `drain` found for type `std::iter::Filter<std::slice::Iter<'_, i32>, [closure@src/main.rs:4:45: 4:62]>` in the current scope
 --> src/main.rs:4:64
  |
4 |     let drained: Vec<i32> = v.iter().filter(|e| (*e) % 2 == 0).drain(..).collect();
  |                                                                ^^^^^

我看过几种不同的选择,它们似乎都没有做我想做的事情:

• Vec::retain 从向量中删除元素,但不会返回已删除元素的所有权.

• v.drain(..).filter(condition).collect()返回正确的值,drained但清空整个向量.

我在SO上找到了这个代码示例(不记得从哪里:/),它允许我在启动我的应用程序时检查行代码参数:

if (e.Args.Length == 0 || e.Args.Any("-show".Contains))
{
  //show interface...
}

我似乎无法理解它是如何"-show".Contains工作的.如果与(经典)有任何区别x => x.Contains('"-show")(除了明显的打字增益).

工作就像一个魅力,但我想明白为什么,我觉得一些大的东西是hapening.