Using functional interface as parameters to filter() function in Java 8

Question

This is a code snippet that tries to use a functional interface inside the filter function.

Function<Path, Boolean> isNotPartitionFile = (path) -> {
    return !path.toString().contains("partition");
};

List<Path> pathsList =  Files.walk(Paths.get(extractFilesLocation))
                                 .filter(Files::isRegularFile)
                                 .filter(isNotPartitionFile)
                                 .collect(Collectors.toList());

When I try to use the isNotPartitionFile as a parameter to the filter() function, eclipse pops up an error that says The method filter(Predicate<? super Path>) in the type Stream<Path> is not applicable for the arguments (Function<Path,Boolean>). It also suggests to cast to (Predicate<? super Path>) , but this throws a runtime error that says it cannot be casted. How do I overcome this ?

Why are you storing it as a `Function` instead of a `Predicate`? — Louis Wasserman, Jun 04 '18 at 15:48
Why is `isNotPartitionFile` declared as `Function`? Wouldn't it be simpler to change it to `Predicate`? — Pshemo, Jun 04 '18 at 15:48
For better or for worse, `Predicate` does not extend `Function`. Use `Predicate`. — chrylis -cautiouslyoptimistic-, Jun 04 '18 at 15:49
@RavindraRanwala Are you sure? `filter` expects `Predicate`, there is no `filter` allowing `Function` so how can it work in eclipse if `Function` isn't subtype of any `Predicate`? — Pshemo, Jun 04 '18 at 15:51
Now it gives the error. Previously he has casted it to a predicate. — Ravindra Ranwala, Jun 04 '18 at 15:53
Casting it to a Predicate wouldn't work either. Casting it _and_ using a method reference would work, though. — Louis Wasserman, Jun 04 '18 at 15:55
BTW `if (condition) return true; else return false` can be simplified as `return condition;`. Since lambda `(arguments)->{return value;}` can be simplified as `(arguments)->value` you can rewrite it as `path -> !path.toString().contains("partition");` — Pshemo, Jun 04 '18 at 15:58

Ousmane D. · Answer 1 · 2018-06-04T16:17:16.283

2

isNotPartitionFile should be defined as:

Predicate<Path> isNotPartitionFile = path -> !path.toString().contains("partition");

because filter consumes a Predicate<T> not Function<T, R>.

edited Jun 04 '18 at 16:17

answered Jun 04 '18 at 15:55

Ousmane D.

54,915
8
91
126

StaticBeagle · Answer 2 · 2018-06-04T16:01:57.527

Predicate is a function that takes in a value and always return boolean. .filter is expecting a Predicate<T> and not a Function<T, Boolean>. The reason Predicate<T> doesn't extend Function<T, Boolean> is because Predicate<T> returns boolean which can never be null. To fix your issue, you could change your isNotPartitionFile to

Predicate<Path> isNotPartitionFile = (path) -> path.toString().contains("partition");

score 1 · Answer 3 · answered Jun 04 '18 at 15:57

1

I figured out the solution myself.

The filter function expects a function as a parameter, but a functional interface was passed. So it needs to be replaced with the apply function of the Function interface.

List<Path> pathsList =  Files.walk(Paths.get(extractFilesLocation))
                                 .filter(Files::isRegularFile)
                                 .filter(isNotPartitionFile::apply)
                                 .collect(Collectors.toList());

answered Jun 04 '18 at 15:57

kaushalpranav

1,725
24
39

2

"*The filter function expects a function as a parameter, but a functional interface was passed*" doesn't make much sense and suggests you are misunderstanding *functional interface*. *Functional* doesn't mean that interface must be of type `Function`, but that interface must have only *one abstract method*. So `Function` is functional interface because but only because it has precisely one abstract method: `B apply(A a)`. Also `Predicate ` is functional interface because it holds precisely one abstract method representing `A -> boolean` mapping. Similarly `Supplier` and `Consumer`. – Pshemo Jun 04 '18 at 16:10
1

Now `isNotPartitionFile::apply` will work in your case because it will represent something like `Predicate predicate = (path) -> isNotPartitionFile.apply(path)`. – Pshemo Jun 04 '18 at 16:13

score 1 · Answer 4 · answered Jun 04 '18 at 16:00

1

Stream<T> filter(Predicate<? super T> predicate) apply Predicate as parameter.

Predicate is a boolean-valued function.

Try this:

Predicate<Path> isNotPartitionFile = path -> !path.toString().contains("partition");

answered Jun 04 '18 at 16:00

Maxim Kasyanov

938
5
14

Using functional interface as parameters to filter() function in Java 8

4 Answers4