Java LongUnaryOperator

Introduction

In Java, the LongUnaryOperator interface is a functional interface that represents an operation on a single long-valued operand, producing a long result. It is part of the java.util.function package and is commonly used for operations that transform long values.

Table of Contents

1. What is LongUnaryOperator?
2. Methods and Syntax
3. Examples of LongUnaryOperator
4. Real-World Use Case
5. Conclusion

1. What is LongUnaryOperator?

LongUnaryOperator is a functional interface that takes a single long as input and returns a long as a result. It is useful for scenarios where mathematical operations or transformations are applied to long values.

2. Methods and Syntax

The main methods in the LongUnaryOperator interface are:

• long applyAsLong(long operand): Applies this operator to the given operand and returns a long result.
• default LongUnaryOperator andThen(LongUnaryOperator after): Returns a composed operator that first applies this operator to its input, and then applies the after operator to the result.
• default LongUnaryOperator compose(LongUnaryOperator before): Returns a composed operator that first applies the before operator to its input, and then applies this operator to the result.

Syntax

LongUnaryOperator operator = (long operand) -> {
    // operation on operand
    return result;
};

3. Examples of LongUnaryOperator

Example 1: Doubling a Value

import java.util.function.LongUnaryOperator;

public class DoublingExample {
    public static void main(String[] args) {
        // Define a LongUnaryOperator that doubles the value
        LongUnaryOperator doubleValue = (operand) -> operand * 2;

        long result = doubleValue.applyAsLong(5L);
        System.out.println("Doubled Value: " + result);
    }
}

Output:

Doubled Value: 10

Example 2: Incrementing a Value

import java.util.function.LongUnaryOperator;

public class IncrementExample {
    public static void main(String[] args) {
        // Define a LongUnaryOperator that increments the value by 1
        LongUnaryOperator increment = (operand) -> operand + 1;

        long result = increment.applyAsLong(7L);
        System.out.println("Incremented Value: " + result);
    }
}

Output:

Incremented Value: 8

Example 3: Using andThen

import java.util.function.LongUnaryOperator;

public class AndThenExample {
    public static void main(String[] args) {
        // Define two LongUnaryOperators
        LongUnaryOperator doubleValue = (operand) -> operand * 2;
        LongUnaryOperator increment = (operand) -> operand + 1;

        // Compose the operators
        LongUnaryOperator doubleThenIncrement = doubleValue.andThen(increment);

        long result = doubleThenIncrement.applyAsLong(3L);
        System.out.println("Result after doubling and incrementing: " + result);
    }
}

Output:

Result after doubling and incrementing: 7

Example 4: Using compose

import java.util.function.LongUnaryOperator;

public class ComposeExample {
    public static void main(String[] args) {
        // Define two LongUnaryOperators
        LongUnaryOperator increment = (operand) -> operand + 1;
        LongUnaryOperator doubleValue = (operand) -> operand * 2;

        // Compose the operators
        LongUnaryOperator incrementThenDouble = doubleValue.compose(increment);

        long result = incrementThenDouble.applyAsLong(3L);
        System.out.println("Result after incrementing and doubling: " + result);
    }
}

Output:

Result after incrementing and doubling: 8

4. Real-World Use Case: Applying Discounts

In e-commerce applications, LongUnaryOperator can be used to apply discounts to product prices.

import java.util.function.LongUnaryOperator;

public class DiscountCalculator {
    public static void main(String[] args) {
        // Define a LongUnaryOperator to apply a 10% discount
        LongUnaryOperator applyDiscount = (price) -> (long) (price * 0.9);

        long discountedPrice = applyDiscount.applyAsLong(100L);
        System.out.println("Discounted Price: " + discountedPrice);
    }
}

Output:

Discounted Price: 90

Conclusion

The LongUnaryOperator interface is a practical tool in Java for transforming long values. It is particularly useful for mathematical calculations and data processing. Using LongUnaryOperator can lead to cleaner and more efficient code, especially in functional programming contexts. The andThen and compose methods allow for easy composition of operations, enhancing code modularity.