When and why would you use Java's Supplier and Consumer interfaces?

Question

As a non-Java programmer learning Java, I am reading about Supplier and Consumer interfaces at the moment. And I can't wrap my head around their usage and meaning.

When and why you would use these interfaces? Can someone give me a simple layperson example of this?

I'm finding the Doc examples not succinct enough for my understanding.

Answer 1

Stuart Marks answer is the most complete. However, examples are always fun:

Supplier of a string:

Supplier<String> testSupplier = () -> {
    return "Normal supplier";
};
System.out.println(testSupplier.get());

Consumer of a string:

Consumer<String> testConsumer = consume -> {
    System.out.println(consume);
};
testConsumer.accept("Normal consumer");

And for some fun, a consumer with a consumer, becomes a supplier!

Consumer<Consumer<String>> testDoubleConsumer = callback -> {
    callback.accept("Wow, I supplied from a consumer");
};
testDoubleConsumer.accept(value -> {
    System.out.println(value);
});

With all these examples, I can pass these suppliers and consumers to a method:

public static void myMethod(
        Supplier<String> testSupplier,
        Consumer<String> testConsumer,
        Consumer<Consumer<String>> testDoubleConsumer) {
    
    // Consume the supplier
    System.out.println(testSupplier.get());
    
    // Supply the consumer
    testConsumer.accept("Normal consumer");
    
    // Consume the double consumer
    testDoubleConsumer.accept(value -> {
        System.out.println(value);
    });
}

public static void main(String[] args) {
    Supplier<String> testSupplier = () -> {
        return "Normal supplier";
    };
    Consumer<String> testConsumer = consume -> {
        System.out.println(consume);
    };
    Consumer<Consumer<String>> testDoubleConsumer = callback -> {
        callback.accept("Wow, I supplied from a consumer");
    };

    // Call it
    myMethod(testSupplier, testConsumer, testDoubleConsumer);
}

Answer 2

One of the use case of the supplier is to trigger the deferred execution of the lambda method

Answer 3

Stuart Marks is correct that Suppliers and Consumers (and other Functional Interfaces) represent structure rather than semantics. Here a real-world example of how this works in practice.

In a nutshell, functional interfaces like Suppliers and Consumers are usually used as parameters to methods that are written at a pretty abstract level. And the basic difference between a Supplier and a Consumer is about output versus input. In the consumer, the T is the input parameter, while in the supplier, The T is the output, or the return value.

Here's my real world example of a Supplier. These two methods call my serve() method, using a supplier as their second parameter, once as a lambda expression, and once as a method reference:

public ResponseEntity<MenuItemDto> getMenuItem(final Integer id) {
  return serve(HttpStats.OK, () -> menuService.getMenuItemDto(id));
}

public ResponseEntity<List<MenuItemDto>> getAll() {
  return serve(HttpStatus.OK, menuService::getAllMenuItems);
}

Here's the method they call:

public static <T> ResponseEntity<T> serve(HttpStatus successStatus, Supplier<T> method)
    throws ResponseException {
  try {
    return new ResponseEntity<>(method.get(), successStatus);
  } catch (ResponseException e) {
    ... // I log my exceptions and message here
    throw e; // uses HttpStatus in the ResponseException
  } catch (RuntimeException re) {
    ... // I log my exceptions and messages here
    throw new InternalError500Exception(re);
  }
}

So the Supplier parameter in the serve method may be any method that hits the database and returns some type of data. The serve() method makes no assumptions about what it takes to get that data, it just calls the method a Supplier<T>, and lets the developer define what that Supplier does.

A Consumer may be used the same way, except the it uses the value as an input. I haven't found a good real-world example in my current codebase, but when I do, I'll add it here.

Answer 4

This is Supplier:

public Integer getInteger() {
    return new Random().nextInt();
}

This is Consumer:

public void sum(Integer a, Integer b) {
    System.out.println(a + b);
}

So in layman terms, a supplier is a method that returns some value (as in its return value). Whereas, a consumer is a method that consumes some value (as in method argument), and does some operations on them.

Those will transform to something like these:

// new operator itself is a supplier, of the reference to the newly created object
Supplier<List<String>> listSupplier = ArrayList::new;
Consumer<String> printConsumer = a1 -> System.out.println(a1);
BiConsumer<Integer, Integer> sumConsumer = (a1, a2) -> System.out.println(a1 + a2);

As for usage, the very basic example would be: Stream#forEach(Consumer) method. It takes a Consumer, which consumes the element from the stream you're iterating upon, and performs some action on each of them. Probably print them.

Consumer<String> stringConsumer = (s) -> System.out.println(s.length());
Arrays.asList("ab", "abc", "a", "abcd").stream().forEach(stringConsumer);

Answer 5

A Supplier is any method which takes no arguments and returns a value. Its job is literally to supply an instance of an expected class. For instance, every reference to a 'getter' method is a Supplier

public Integer getCount(){
    return this.count;
}

Its instance method reference myClass::getCount is an instance of Supplier<Integer>.

A Consumer is any method which takes arguments and returns nothing. It is invoked for its side-effects. In Java terms, a Consumer is an idiom for a void method. 'setter' methods are a good example:

public void setCount(int count){
    this.count = count;
}

Its instance method reference myClass::setCount is an instance of Consumer<Integer> and IntConsumer.

A Function<A,B> is any method which takes an argument of one type, and returns another. This can be referred to as a 'transformation'. The Function<A,B> takes an A and returns a B. Notable is that for a given value of A, the function should always return a specific value of B. A and B can in fact be the same type, such as the following:

public Integer addTwo(int i){
    return i+2;
}

Its instance method reference myClass:addTwo is a Function<Integer, Integer> and a ToIntFunction<Integer>.

A Class method reference to a getter is another example of a function.

public Integer getCount(){
    return this.count;
}

Its class method reference MyClass::getCount is an instance of Function<MyClass,Integer> and ToIntFunction<MyClass>.

Answer 6

Why are Consumer/Supplier/other functional interfaces defined in java.util.function package: Consumer and Supplier are two, among many, of the in-built functional interfaces provided in Java 8. The purpose of all these in-built functional interfaces is to provide a ready "template" for functional interfaces having common function descriptors(functional method signatures/definitions).

Lets say we have a required to convert a type T to another type R. If we were to pass any function defined like this as a parameter to a method, then that method would need to define a Functional Interface whose functional/abstract method takes parameter of type T as input and gives a parameter of type R as output. Now, there could be many scenarios like this and the programmer(s) would end up defining multiple functional interfaces for their needs. To avoid this kind of a scenario, ease programming & bring a common standard in usage of functional interfaces, a set of in-built functional interfaces such as Predicate, Function, Consumer & Supplier have been defined.

What does Consumer do: Consumer functional interface accepts an input, does something with that input and does not give any output. Its definition is like this (from Java Source) -

@FunctionalInterface
public interface Consumer<T> {
 void accept(T t);
}

Here accept() is the functional\abstract method which does takes an input and returns no output. So, if you want to input an Integer, do something with it with no output then instead of defining your own interface use an instance of Consumer.

What does Supplier do: Supplier functional interface does not take any input but returns an output. Its defined like this(from Java Source) -

@FunctionalInterface
public interface Supplier<T> {
  T get();
}

Wherever you need a function which returns something, say an Integer, but takes no output use an instance of Supplier.

In case more clarity, along with example usage, of Consumer & Supplier interfaces is needed then you can refer my blog posts on the same - http://www.javabrahman.com/java-8/java-8-java-util-function-consumer-tutorial-with-examples/ and http://www.javabrahman.com/java-8/java-8-java-util-function-supplier-tutorial-with-examples/

Answer 7

Consumer and supplier are the interfaces provided by java. Consumer is use for iterate over the list elements and supplier is use for supply object's

you can easily understand with code demonstration.

Consumer

package com.java.java8;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

/**
 * The Class ConsumerDemo.
 *
 * @author Ankit Sood Apr 20, 2017
 */
public class ConsumerDemo {

    /**
     * The main method.
     *
     * @param args
     *            the arguments
     */
    public static void main(String[] args) {

    List<String> str = new ArrayList<>();
    str.add("DEMO");
    str.add("DEMO2");
    str.add("DEMO3");

    /* Consumer is use for iterate over the List */
    Consumer<String> consumer = new Consumer<String>() {
        @Override
        public void accept(String t) {

        /* Print list element on consile */
        System.out.println(t);
        }
    };

    str.forEach(consumer);

    }

}

Supplier

package com.java.java8;

import java.util.function.Supplier;

/**
 * The Class SupplierDemo.
 *
 * @author Ankit Sood Apr 20, 2017
 */
public class SupplierDemo {

    /**
     * The main method.
     *
     * @param args
     *            the arguments
     */
    public static void main(String[] args) {
    getValue(() -> "Output1");
    getValue(() -> "OutPut2");
    }

    /**
     * Gets the value.
     *
     * @param supplier
     *            the supplier
     * @return the value
     */
    public static void getValue(Supplier<?> supplier) {
    System.out.println(supplier.get());
    }

}

Answer 8

1. Meaning

See my answers to my question here and also another here, but in short these new Interfaces provide convention and descriptiveness for everyone to use (+ funky method chaining such as .forEach(someMethod().andThen(otherMethod()))

2. Differences

Consumer: Takes something, does something, returns nothing: void accept(T t)

Supplier: Takes nothing, returns something : T get() (reverse of Consumer, basically a universal 'getter' method)

3. Usage

// Consumer: It takes something (a String) and does something (prints it) 
    List<Person> personList = getPersons();

     personList.stream()
                    .map(Person::getName)    
                    .forEach(System.out::println); 

Supplier: wrap repetitive code, e.g. code execution timing

public class SupplierExample {

    public static void main(String[] args) {

        // Imagine a class Calculate with some methods
        Double result1 = timeMe(Calculate::doHeavyComputation);
        Double result2 = timeMe(Calculate::doMoreComputation);
    }
    private static Double timeMe(Supplier<Double> code) {

        Instant start = Instant.now();
        // Supplier method .get() just invokes whatever it is passed
        Double result = code.get();
        Instant end = Instant.now();

        Duration elapsed = Duration.between(start,end);
        System.out.println("Computation took:" + elapsed.toMillis());

        return result;
    }
}

Answer 9

In Laymen terms,

supplier will supply data but without consuming any data. In programming terms a method which doesn't take any argument but return a value. It is used to generate new values.

http://codedestine.com/java-8-supplier-interface/

consumer will consume data and but do not return any data. In programming terms a method which takes multiple argument and does not return any value.

http://codedestine.com/java-8-consumer-interface/

Answer 10

The reason you're having difficulty grasping the meaning of functional interfaces such as those in java.util.function is that the interfaces defined here do not have any meaning! They are present primarily to represent structure, not semantics.

This is atypical for most Java APIs. The typical Java API, such as a class or interface, has meaning, and you can develop a mental model for what it represents and use that to understand the operations on it. Consider java.util.List for example. A List is a container of other objects. They have a sequence and an index. The number of objects contained in the list is returned by size(). Each object has an index in the range 0..size-1 (inclusive). The object at index i can be retrieved by calling list.get(i). And so forth.

The functional interfaces in java.util.function don't have any such meaning. Instead, they're interfaces that merely represent the structure of a function, such as the number of arguments, the number of return values, and (sometimes) whether an argument or return value is a primitive. Thus we have something like Function<T,R> which represents a function that takes a single argument of type T and returns a value of type R. That's it. What does that function do? Well, it can do anything ... as long as it takes a single argument and returns a single value. That's why the specification for Function<T,R> is little more than "Represents a function that accepts one argument and produces a result."

Clearly, when we're writing code, it has meaning, and that meaning has to come from somewhere. In the case of the functional interfaces, the meaning comes from the context in which they're used. The interface Function<T,R> has no meaning in isolation. However, in the java.util.Map<K,V> API, there is the following:

V computeIfAbsent(K key, Function<K,V> mappingFunction)

(wildcards elided for brevity)

Ah, this use of Function is as a "mapping function". What does that do? In this context, if key is not already present in the map, the mapping function is called and is handed the key and is expected to produce a value, and the resulting key-value pair is inserted into the map.

So you can't look at the specification for Function (or any of the other functional interfaces, for that matter) and attempt to discern what they mean. You have to look at where they're used in other APIs to understand what they mean, and that meaning applies only to that context.