How do I use the DoubleSupplier functional interface in Java?

By I Wayan Saryada in Core API, Util Package 0 Comment

The DoubleSupplier interface in Java is part of the java.util.function package and is used to represent a supplier of double-valued results. It is a functional interface and is often used when we need to generate or supply double values (for example, random numbers or calculated values) without taking any input.

Functional Interface

Like other functional interfaces, DoubleSupplier is annotated with @FunctionalInterface and has a single abstract method:

double getAsDouble();

This method is used to obtain a double value whenever it is called.

How to Use DoubleSupplier

1. Using with Lambda Expressions

A common way to use DoubleSupplier is by defining the getAsDouble functionality using a lambda expression.

package org.kodejava.util.function;

import java.util.function.DoubleSupplier;

public class DoubleSupplierExample {
    public static void main(String[] args) {
        // Define a DoubleSupplier using a lambda expression
        DoubleSupplier randomSupplier = () -> Math.random();

        // Get values using the supplier
        System.out.println("Random value 1: " + randomSupplier.getAsDouble());
        System.out.println("Random value 2: " + randomSupplier.getAsDouble());
    }
}

2. Using Method References

We can also implement DoubleSupplier using method references when there is a method compatible with the getAsDouble signature.

package org.kodejava.util.function;

import java.util.function.DoubleSupplier;

public class DoubleSupplierMethodReference {
    public static void main(String[] args) {
        // Use Math.random as a method reference for DoubleSupplier
        DoubleSupplier randomSupplier = Math::random;

        // Get and print values
        System.out.println("Random value 1: " + randomSupplier.getAsDouble());
        System.out.println("Random value 2: " + randomSupplier.getAsDouble());
    }
}

3. Supplying Predefined Values

We can use DoubleSupplier to supply predefined double values. For instance, when iterating or producing specific values:

package org.kodejava.util.function;

import java.util.function.DoubleSupplier;

public class PredefinedDoubleSupplier {
    public static void main(String[] args) {
        // Supplier that always returns a specific value
        DoubleSupplier constantSupplier = () -> 42.0;

        // Get and print the value
        System.out.println("Constant value: " + constantSupplier.getAsDouble());
    }
}

4. Generating Calculated Values

DoubleSupplier can also be used in functional programming scenarios where a calculated double result is required:

package org.kodejava.util.function;

import java.util.function.DoubleSupplier;

public class CalculatedDoubleSupplier {
    public static void main(String[] args) {
        double initialValue = 10.0;
        // e.g., applying a tax rate
        DoubleSupplier calculatedSupplier = () -> initialValue * 1.21;

        System.out.println("Calculated value: " + calculatedSupplier.getAsDouble());
    }
}

5. Using in Streams

DoubleSupplier works seamlessly with primitive streams like DoubleStream:

package org.kodejava.util.function;

import java.util.function.DoubleSupplier;
import java.util.stream.DoubleStream;

public class DoubleStreamWithSupplier {
    public static void main(String[] args) {
        // Create a DoubleSupplier for an infinite stream of random numbers
        DoubleSupplier randomSupplier = Math::random;

        // Generate and print 5 random values
        DoubleStream.generate(randomSupplier)
                .limit(5)
                .forEach(value -> System.out.println("Random value: " + value));
    }
}

When to Use DoubleSupplier

  • To generate values on demand (e.g., random numbers, calculated results).
  • In functional programming contexts, often in combination with other functional constructs.
  • As an alternative to avoid hardcoding or passing values directly when we want them generated lazily.

Summary

The DoubleSupplier interface is a convenient way to represent a source of double values. It is simple to use with lambda expressions, method references, or inline implementations. It shines in scenarios where values need to be generated dynamically, especially when combined with Streams or functional programming operations.

How do I use the DoublePredicate functional interface in Java?

By I Wayan Saryada in Core API, Util Package 0 Comment

The DoublePredicate interface in Java, part of the java.util.function package, is a functional interface used to represent a predicate (boolean-valued function) that tests a single double-valued argument.

Functional Interface Details

The DoublePredicate interface has only one abstract method:

boolean test(double value);

This method evaluates the predicate on the given double value and returns a boolean result.

How to Use DoublePredicate

1. Using a Lambda Expression

We can use a lambda expression to define the behavior of the DoublePredicate. For example, to check if a double value is greater than a certain threshold:

package org.kodejava.util.function;

import java.util.function.DoublePredicate;

public class DoublePredicateExample {
    public static void main(String[] args) {
        // Define a DoublePredicate to check if a value is greater than 10.0
        DoublePredicate isGreaterThanTen = value -> value > 10.0;

        // Test the predicate
        // Output: true
        System.out.println(isGreaterThanTen.test(15.5));
        // Output: false
        System.out.println(isGreaterThanTen.test(8.2));
    }
}

2. Using the and, or, and negate Methods

DoublePredicate provides built-in methods for combining predicates:
– and(DoublePredicate other): Combines the current predicate with another predicate using a logical AND.
– or(DoublePredicate other): Combines the current predicate with another predicate using a logical OR.
– negate(): Returns a predicate that represents the logical negation of the current predicate.

Example:

package org.kodejava.util.function;

import java.util.function.DoublePredicate;

public class DoublePredicateCombination {
    public static void main(String[] args) {
        // Define basic predicates
        DoublePredicate isPositive = value -> value > 0;
        DoublePredicate isLessThanTen = value -> value < 10;

        // Combine predicates
        DoublePredicate isPositiveAndLessThanTen = isPositive.and(isLessThanTen);
        DoublePredicate isNegativeOrZero = isPositive.negate();

        // Test the combined predicates
        // Output: true
        System.out.println(isPositiveAndLessThanTen.test(5));
        // Output: false
        System.out.println(isPositiveAndLessThanTen.test(15));
        // Output: true
        System.out.println(isNegativeOrZero.test(-3));
    }
}

3. Using DoublePredicate with Streams

DoublePredicate works seamlessly with Java’s DoubleStream API for filtering primitive stream elements:

package org.kodejava.util.function;

import java.util.function.DoublePredicate;
import java.util.stream.DoubleStream;

public class DoublePredicateWithStream {
    public static void main(String[] args) {
        // Create a DoubleStream
        DoubleStream doubleStream = DoubleStream.of(1.5, -2.0, 3.8, 5.0, -1.1);

        // Define a predicate to filter positive values
        DoublePredicate isPositive = value -> value > 0;

        // Filter and print positive values
        doubleStream.filter(isPositive)
                .forEach(value -> System.out.println("Positive value: " + value));
    }
}

Output:

Positive value: 1.5
Positive value: 3.8
Positive value: 5.0

Key Points

  1. Implementation: DoublePredicate is a functional interface, so it can be implemented using lambda expressions, method references, or anonymous inner classes.
  2. Predicate Composition: Use and, or, and negate methods to create complex predicates.
  3. Integration in Streams: Useful for filtering double values in DoubleStream.

How do I use the DoubleFunction functional interface in Java?

By I Wayan Saryada in Core API, Util Package 0 Comment

The DoubleFunction interface in Java is a functional interface in the java.util.function package. It represents a function that takes in a double as an argument and produces a result of some type. Since it is a functional interface, you can use it as a lambda expression or method reference.

Method in DoubleFunction

The DoubleFunction interface has one abstract method:

R apply(double value);
  • value: The double value passed as input to the function.
  • The method returns an object of type R (the return type).

How to Use the DoubleFunction Interface

We typically use DoubleFunction in situations where we need to transform or process a double and produce a result of a specific type.

Example 1: Using DoubleFunction to Convert double to a String

package org.kodejava.util.function;

import java.util.function.DoubleFunction;

public class DoubleFunctionExample {
    public static void main(String[] args) {
        // Create a DoubleFunction that converts a double to a String representation
        DoubleFunction<String> doubleToString = (value) -> "Value is: " + value;

        // Use the DoubleFunction
        String result = doubleToString.apply(42.5);

        // Print the result
        // Output: Value is: 42.5
        System.out.println(result);
    }
}

Example 2: Using DoubleFunction to Compute Complex Results

You can use DoubleFunction to compute and return various types of results, such as objects of a custom type.

package org.kodejava.util.function;

import java.util.function.DoubleFunction;

public class DoubleFunctionExample2 {
    public static void main(String[] args) {
        // Create a DoubleFunction that creates an Area object from a radius
        DoubleFunction<Area> calculateArea =
                (radius) -> new Area(Math.PI * radius * radius);

        // Compute the area using the DoubleFunction
        Area area = calculateArea.apply(5.0);

        // Print the result
        // Output: Area is: 78.53981633974483
        System.out.println("Area is: " + area.getValue());
    }
}

// A simple class to store area
class Area {
    private double value;

    public Area(double value) {
        this.value = value;
    }

    public double getValue() {
        return value;
    }
}

Example 3: Method References with DoubleFunction

You can simplify usage by using method references when possible.

package org.kodejava.util.function;

import java.util.function.DoubleFunction;

public class DoubleFunctionExample3 {
    public static void main(String[] args) {
        // Using a method reference for Math.sqrt
        DoubleFunction<Double> sqrtFunction = Math::sqrt;

        // Apply the DoubleFunction
        double result = sqrtFunction.apply(25.0);

        // Print the result
        // Output: Square root is: 5.0
        System.out.println("Square root is: " + result);
    }
}

Use Cases

  • Converting a double to a custom object (e.g., Area, Volume).
  • Performing mathematical computations with a double input and returning relevant results.
  • Simplifying transformations in streams or other functional programming contexts.

Key Points to Note

  1. DoubleFunction<R> is particularly useful to avoid unnecessary boxing of primitive double values when dealing with functions that process them since it directly deals with primitive types.
  2. It produces a result of any type R, which makes it very flexible.

By using DoubleFunction, we can write concise, reusable, and readable code for operations that require processing a double to produce a result.

How do I use the DoubleConsumer functional interface in Java?

By I Wayan Saryada in Core API, Util Package 0 Comment

The DoubleConsumer interface in Java is part of the java.util.function package and is used to represent an operation that takes a single double-valued argument and does not return a result. It is commonly used in lambda expressions or method references for consuming a double value (often for side effect operations such as logging or accumulating values).

Functional Interface

The DoubleConsumer interface is a functional interface and is annotated with @FunctionalInterface, meaning it has exactly one abstract method:

void accept(double value);

This method is applied to perform an operation using the given double value.

How to Use DoubleConsumer

Here are some scenarios where we can use DoubleConsumer:

1. Using a Lambda Expression

A common use of DoubleConsumer is to define its functionality using a lambda expression.

Example:

package org.kodejava.util.function;

import java.util.function.DoubleConsumer;

public class DoubleConsumerExample {
    public static void main(String[] args) {
        // Define a DoubleConsumer to print a double value
        DoubleConsumer printConsumer = value -> System.out.println("Value: " + value);

        // Consume a value
        printConsumer.accept(42.5);
    }
}

Output:

Value: 42.5

2. Using a Method Reference

If we have a method compatible with the accept(double) signature, you can use it as a method reference to implement DoubleConsumer.

Example:

package org.kodejava.util.function;

import java.util.function.DoubleConsumer;

public class DoubleConsumerMethodReference {
    public static void printValue(double value) {
        System.out.println("Received: " + value);
    }

    public static void main(String[] args) {
        // Use a method reference to implement DoubleConsumer
        DoubleConsumer printConsumer = DoubleConsumerMethodReference::printValue;

        // Consume a value
        printConsumer.accept(19.99);
    }
}

Output:

Received: 19.99

3. Using andThen() Method for Chaining Operations

The DoubleConsumer interface has a built-in andThen method that allows chaining multiple operations. The andThen method returns a composed DoubleConsumer that performs this operation, followed by another DoubleConsumer.

Example:

package org.kodejava.util.function;

import java.util.function.DoubleConsumer;

public class DoubleConsumerChaining {
    public static void main(String[] args) {
        // Consumer to log a value
        DoubleConsumer logConsumer = value -> System.out.println("Logging value: " + value);

        // Consumer to process a value (e.g., multiply it by 2)
        DoubleConsumer processConsumer = value -> System.out.println("Processed value: " + (value * 2));

        // Chain both consumers using andThen()
        DoubleConsumer chainedConsumer = logConsumer.andThen(processConsumer);

        // Consume a value
        chainedConsumer.accept(8.5);
    }
}

Output:

Logging value: 8.5
Processed value: 17.0

4. Using DoubleConsumer in Streams

The DoubleConsumer is often used in conjunction with Java’s Stream API, particularly when working with primitive streams like DoubleStream.

Example:

package org.kodejava.util.function;

import java.util.stream.DoubleStream;

public class DoubleConsumerWithStream {
    public static void main(String[] args) {
        // Create a DoubleStream
        DoubleStream doubleStream = DoubleStream.of(1.0, 2.5, 3.8);

        // Use DoubleConsumer to print each value in the stream
        doubleStream.forEach(value -> System.out.println("Stream value: " + value));
    }
}

Output:

Stream value: 1.0
Stream value: 2.5
Stream value: 3.8

Key Points

  1. Functional Interface: Since it is a functional interface, we can easily implement it using lambda expressions or method references.
  2. Purpose: It is ideal for consuming double values where no result is needed, such as in logging, accumulation, or side effect operations.
  3. Stream Integration: Frequently used in primitive streams (DoubleStream) for operations on elements.
  4. Method Chaining: The andThen method allows combining multiple DoubleConsumer instances into a single operation.

By leveraging DoubleConsumer, we can perform concise and reusable operations on double values throughout our application.

How do I use the DoubleBinaryOperator functional interface in Java?

By I Wayan Saryada in Core API, Util Package 0 Comment

The DoubleBinaryOperator interface in Java is part of java.util.function and is used to represent an operation that takes two double-valued operands and produces a double-valued result. It is a functional interface, meaning it has a single abstract method that can be implemented using a lambda expression or method reference.

The single abstract method in DoubleBinaryOperator is:

double applyAsDouble(double left, double right);

How to Use DoubleBinaryOperator

1. Using a Lambda Expression

A common way to use DoubleBinaryOperator is to define the operation using a lambda expression.

Example:

package org.kodejava.util.function;

import java.util.function.DoubleBinaryOperator;

public class DoubleBinaryOperatorExample {
    public static void main(String[] args) {
        // Define a DoubleBinaryOperator to add two double values
        DoubleBinaryOperator addition = (a, b) -> a + b;

        // Apply the operator on some values
        double result = addition.applyAsDouble(5.5, 4.5);

        // Output: Addition Result: 10.0
        System.out.println("Addition Result: " + result);
    }
}

2. Using a Method Reference

If we have a method that matches the signature of the applyAsDouble method, we can use a method reference to implement the DoubleBinaryOperator.

Example:

package org.kodejava.util.function;

import java.util.function.DoubleBinaryOperator;

public class DoubleBinaryOperatorExample2 {

    // Define a static method for multiplication
    public static double multiply(double a, double b) {
        return a * b;
    }

    public static void main(String[] args) {
        // Use a method reference to implement DoubleBinaryOperator
        DoubleBinaryOperator multiplication = DoubleBinaryOperatorExample2::multiply;

        // Apply the operator on some values
        double result = multiplication.applyAsDouble(3.5, 2.0);

        // Output: Multiplication Result: 7.0
        System.out.println("Multiplication Result: " + result);
    }
}

3. Using with Other Functional Interfaces

We can combine DoubleBinaryOperator with other functional interfaces or use it in streams for processing numerical data.

Example with parallel reduction:

package org.kodejava.util.function;

import java.util.Arrays;
import java.util.function.DoubleBinaryOperator;

public class DoubleBinaryOperatorExample3 {
    public static void main(String[] args) {
        // Define a DoubleBinaryOperator for subtraction
        DoubleBinaryOperator subtraction = (a, b) -> a - b;

        // Use it in a reduction with doubles in a stream
        double[] numbers = {10.0, 3.0, 4.0};
        double result = Arrays.stream(numbers).reduce(0.0, subtraction);

        // Output: Reduction Result: -17.0
        System.out.println("Reduction Result: " + result);
    }
}

Key Points

  1. Functional Interface: It is annotated with @FunctionalInterface, so you can use lambda expressions or method references for implementation.
  2. Purpose: Useful when working with operations involving two double operands and a double result, such as addition, subtraction, multiplication, division, or any custom operation.
  3. Stream Operations: Can be effectively utilized in stream reductions or parallel processing involving numerical computations.

By leveraging DoubleBinaryOperator, we can write concise and reusable numerical operations in your Java programs.