Java 8 Handbook

FunctionInterface
https://dzone.com/articles/introduction-functional-1
There’s an annotation introduced- @FunctionalInterface which can be used for compiler level errors when the interface you have annotated is not a valid Functional Interface.

The interface can also declare the abstract methods from the java.lang.Object class, but still the interface can be called as a Functional Interface:

@FunctionalInterface
public interface SimpleFuncInterface {
  public void doWork();
  public String toString();
  public boolean equals(Object o);
}

Once you add another abstract method to the interface then the compiler/IDE will flag it as an error.

Interface can extend another interface and in case the Interface it is extending in functional and it doesn’t declare any new abstract methods then the new interface is also functional. But an interface can have one abstract method and any number of default methods and the interface would still be called an functional interface. To get an idea of default methods please read here.

@FunctionalInterface
public interface ComplexFunctionalInterface extends SimpleFuncInterface {
  default public void doSomeWork(){
    System.out.println("Doing some work in interface impl...");
  }
  default public void doSomeOtherWork(){
    System.out.println("Doing some other work in interface impl...");
  }
}

https://alextheedom.wordpress.com/2015/11/17/java-8-streams-filter-and-predicate-negation/

Stream.of(1, 2, 3, 4, 5, 6, 7)       .filter(((Predicate) c -> c % 2 == 0).negate())

Answer 1: Write a predicate utility method
You can simplify this by writing a utility method that performs the negation.

1 2 3

public static <R> Predicate<R> not(Predicate<R> predicate) {       return predicate.negate(); }

Which results in much neater code.

1 2	Stream.of(1, 2, 3, 4, 5, 6, 7)       .filter(not(c -> c % 2 == 0))

Answer 2: Use an identity function to convert the method reference to a Predicate

We use a utility method to convert a method reference to a predicate.

1 2 3

public static <T> Predicate<T> predicate(Predicate<T> predicate) {       return predicate; }

although the code is not as neat.

1 2	Stream.of("Cat", "", "Dog")       .filter(predicate(String::isEmpty).negate())

Answer 3: Use the not (!) operator

1 2 3 4 5

Stream.of(1, 2, 3, 4, 5, 6, 7)       .filter((c -> c % 2 != 0)) Stream.of("Cat", "", "Dog")       .filter(str -> !str.isEmpty())