Is there a method reference for a no-op (NOP) that can be used for anything lambda?
Solution 1
This is no deficiency.
Lambdas in Java are instances of functional interfaces; which, in turn, are abstracted to instances of Java constructs which can be simplified to one single abstract method, or SAM.
But this SAM still needs to have a valid prototype. In your case, you want to have a no-op Consumer<T>
which does nothing whatever the T
.
It still needs to be a Consumer<T>
however; which means the minimal declaration you can come up with is:
private static final Consumer<Object> NOOP = whatever -> {};
and use NOOP
where you need to.
Solution 2
In your particular case you could simply do:
foo(i -> {});
This means that the lambda expression receives a parameter but has no return value.
The equivalent code for a BiConsumer<T, U>
would be:
void bifoo(BiConsumer<Object, Object> consumer) { ... }
bifoo((a, b) -> {});
Solution 3
Could Function.identity()
fit your needs?
Returns a function that always returns its input argument.
Solution 4
If you want a method reference for a method that does nothing, the easiest way is to write a method that does nothing. Notice that in this example I have used Main::doNothing
when a Consumer<String>
is required.
class Main {
static void doNothing(Object o) { }
static void foo(Consumer<String> c) { }
public static void main(String[] args) {
foo(Main::doNothing);
}
}
You could also overload doNothing
by providing a version using varargs.
static void doNothing(Object... o) { }
This signature will accept literally any sequence of parameters (even primitives, as these will get autoboxed). That way you could pass Main::doNothing
whenever the functional interface's method has void
return type. For example you could pass Main::doNothing
when an ObjLongConsumer<Integer>
is needed.
Solution 5
You can have your own NOOP implementation, similar to Function.Identity.
static <T> Consumer<T> NOOP() {
return t -> {};
}
Related videos on Youtube
Comments
-
Davids037 almost 2 years
This may sounds like a strange question, but is there a way to refer to a standard no-op (aka null operation, null-pattern method, no-operation, do-nothing method) method for a Lambda in Java 8.
Currently, I have a method that takes a, say,
void foo(Consumer<Object>)
, and I want to give it a no-op, I have to declare:foo(new Consumer<Object>() { public void accept(Object o) { // do nothing } }
where I would like to be able to do something like:
foo(Object::null)
instead. Does something like exist?
Not sure how that would work with multi-parameter methods -- perhaps this is a deficiency in the lambdas in Java.
-
Stuart Marks about 9 yearsRelated: stackoverflow.com/a/26553481/1441122
-
paul_h over 5 years"Null Object" pattern is the name of this (per Martin Fowler's Refactoring book - 1997 and updated in 2018). And yes, it'd be great if most interfaces in the JDK shipped with a public static inner class NULL or NullObject.
-
paul_h over 5 yearsI mean .. Most interfaces in the JDK should ship with a inner class that is a Null Object implementation, and a public static var NULL or NullObject which is an instance of that for all to use, like so: foo = Consumer.NULL;
-
-
Davids037 about 9 yearsCan be extends for any number of arguments too: foo((a,b) -> {}); etc
-
Holger about 9 yearsWell, you can say
Consumer<ArbitraryType> c=Function.identity()::apply;
but the question is whether this is really better thanc=ignore->{};
… -
Radiodef about 9 yearsCan be generic for even more applicability.
static <T, U> U noop(T... a) {return null;}
-
Paul Boddington about 9 years@Radiodef I thought about mentioning that in my answer but decided I didn't like it because you can pass
noop
even in the case where the functional interface's method returns a primitive type, which is asking for a null pointer exception. -
Paul Boddington about 9 years@Radiodef The other unfortunate thing is that the signatures of the versions returning
U
andvoid
have the same erasure, so either the methods would have to have different names, or they'd have to be in different classes. Personally I think this is a deficiency, and something likenoop
ordoNothing
would fit natually in theObjects
class. -
Radiodef about 9 yearsAll true. I didn't think of the unboxing problem.
-
jk. over 7 yearsactually i think i like Function.identity()::apply as it doen't intriduce an unused parameter
-
xorcus over 4 yearsWould be really nice to have this in the Consumer interface itself.
-
Zoltán Umlauf over 4 yearsmight not have been what op was looking for, but this is what i was looking for, thanks!
-
Antoniossss about 2 yearsI know this is stupid, but I just used
Function.identity()::apply; over (v)->{}
as formatter leaves it in the same line instead of hardbreaking { } XD