How to use

IntPredicate

in

java.util.function

@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 );
  }
};

 IntPredicate predicate=i -> i==5;

if(ints.length>0 && predicate.test(ints[0]))
  predicate=predicate.negate();
boolean result = IntStream.of(ints).anyMatch(predicate);

 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;
  }
}