Refine search
@Override public boolean anyMatch(IntPredicate predicate) { requireNonNull(predicate); return predicate.test(element); }
@Override public int indexOf(IntPredicate predicate, int fromIndex) { Assert.notNull(predicate, "IntPredicate must not be null"); if (fromIndex < 0) { fromIndex = 0; } else if (fromIndex >= this.byteBuf.writerIndex()) { return -1; } int length = this.byteBuf.writerIndex() - fromIndex; return this.byteBuf.forEachByte(fromIndex, length, predicate.negate()::test); }
@Override public boolean test( int item ) { return filter.test( item ); } };
package com.company; import rx.Observable; import java.util.function.IntPredicate; import java.util.stream.IntStream; public class Main { public static void main(String[] args) { final IntPredicate[] p={(x)->true}; IntStream primesStream=IntStream.iterate(2,n->n+1).filter(i -> p[0].test(i)).peek(i->p[0]=p[0].and(v->v%i!=0) ); Observable primes = Observable.from(()->primesStream.iterator()); primes.take(10).forEach((x) -> System.out.println(x.toString())); } }
@Override public IntPredicate getMatcher(NodeVectorTree tree) { switch (operator) { case Token.UNION: return nodetest1.getMatcher(tree).or(nodetest2.getMatcher(tree)); case Token.INTERSECT: return nodetest1.getMatcher(tree).and(nodetest2.getMatcher(tree)); case Token.EXCEPT: return new IntExceptPredicate(nodetest1.getMatcher(tree), nodetest2.getMatcher(tree)); default: throw new IllegalArgumentException("Unknown operator in Combined Node Test"); } }
/** * Evaluates whether the provided table bucket number passes the bucket predicate. * A bucket predicate can be present in two cases: * <ul> * <li>Filter on "$bucket" column. e.g. {@code "$bucket" between 0 and 100} * <li>Single-value equality filter on all bucket columns. e.g. for a table with two bucketing columns, * {@code bucketCol1 = 'a' AND bucketCol2 = 123} * </ul> */ public boolean isTableBucketEnabled(int tableBucketNumber) { return bucketFilter.test(tableBucketNumber); } }
IntPredicate dividesBy3 = i -> i % 3 == 0; IntPredicate dividesBy5 = i -> i % 5 == 0; IntPredicate doesntDivide = dividesBy3.negate().and(dividesBy5.negate()); IntStream.rangeClosed(0, 100).forEach(i -> { StringBuffer bfr = new StringBuffer(); if (dividesBy3.test(i)) bfr.append("Fizz"); if (dividesBy5.test(i)) bfr.append("Buzz"); if (doesntDivide.test(i)) bfr.append(i); System.out.println(bfr); });
public static StreamEx<Integer> sieve(StreamEx<Integer> input, IntPredicate isPrime) { return input.headTail((head, tail) -> isPrime.test(head) ? sieve(tail, isPrime.and(n -> n % head != 0)).prepend(head) : sieve(tail, isPrime)); } sieve(StreamEx.iterate(2, x -> x+1), i -> true).limit(1000).forEach(System.out::println);
@Override public IntPredicate getMatcher(NodeVectorTree tree) { switch (operator) { case Token.UNION: return nodetest1.getMatcher(tree).or(nodetest2.getMatcher(tree)); case Token.INTERSECT: return nodetest1.getMatcher(tree).and(nodetest2.getMatcher(tree)); case Token.EXCEPT: return new IntExceptPredicate(nodetest1.getMatcher(tree), nodetest2.getMatcher(tree)); default: throw new IllegalArgumentException("Unknown operator in Combined Node Test"); } }
@Override public boolean noneMatch(IntPredicate predicate) { requireNonNull(predicate); return !predicate.test(element); }
@Override public int lastIndexOf(IntPredicate predicate, int fromIndex) { Assert.notNull(predicate, "IntPredicate must not be null"); int i = Math.min(fromIndex, this.writePosition - 1); for (; i >= 0; i--) { byte b = this.byteBuffer.get(i); if (predicate.test(b)) { return i; } } return -1; }
@Override public int lastIndexOf(IntPredicate predicate, int fromIndex) { Assert.notNull(predicate, "IntPredicate must not be null"); if (fromIndex < 0) { return -1; } fromIndex = Math.min(fromIndex, this.byteBuf.writerIndex() - 1); return this.byteBuf.forEachByteDesc(0, fromIndex + 1, predicate.negate()::test); }
@Override public boolean allMatch(IntPredicate predicate) { requireNonNull(predicate); return predicate.test(element); }
private boolean skip(int c) { return predicate.test(c); } }
@Override public int lastIndexOf(IntPredicate predicate, int fromIndex) { Assert.notNull(predicate, "IntPredicate must not be null"); if (fromIndex < 0) { return -1; } fromIndex = Math.min(fromIndex, this.byteBuf.writerIndex() - 1); return this.byteBuf.forEachByteDesc(0, fromIndex + 1, predicate.negate()::test); }
/** * Returns, if this stream is ordered, a stream consisting of the longest * prefix of elements taken from this stream that match the given predicate. * * @param predicate - a non-interfering, stateless predicate to apply to * elements to determine the longest prefix of elements. * @return the new stream */ public IntStream takeWhile(IntPredicate predicate) { requireNonNull(predicate); if (predicate.test(element)) { return this; } else { return empty(); } }
private boolean skip(int c) { return predicate.test(c); } };
@Override public int indexOf(IntPredicate predicate, int fromIndex) { Assert.notNull(predicate, "IntPredicate must not be null"); if (fromIndex < 0) { fromIndex = 0; } else if (fromIndex >= this.byteBuf.writerIndex()) { return -1; } int length = this.byteBuf.writerIndex() - fromIndex; return this.byteBuf.forEachByte(fromIndex, length, predicate.negate()::test); }
/** * Returns, if this stream is ordered, a stream consisting of the remaining * elements of this stream after dropping the longest prefix of elements * that match the given predicate. Otherwise returns, if this stream is * unordered, a stream consisting of the remaining elements of this stream * after dropping a subset of elements that match the given predicate. * * @param predicate - a non-interfering, stateless predicate to apply to * elements to determine the longest prefix of elements. * * @return new new stream */ public IntStream dropWhile(IntPredicate predicate) { requireNonNull(predicate); if (predicate.test(element)) { return empty(); } else { return this; } }