The LongToIntFunction is a functional interface in Java located in the java.util.function package. It represents a function that accepts a long-valued argument and produces an int-valued result. It is a specialized form of functional interface primarily used to avoid boxing when working with primitive types.

Here is a guide on how to use the LongToIntFunction interface:

1. Functional Interface Definition

The LongToIntFunction is defined as:

@FunctionalInterface
public interface LongToIntFunction {
    int applyAsInt(long value);
}

This means:
– It has a single abstract method named applyAsInt(long value), which takes a long as input and returns an int.
– It can be implemented using a lambda expression, method reference, or an anonymous class.

---

2. Usage Examples

a. Using Lambda Expression:

package org.kodejava.util.function;

import java.util.function.LongToIntFunction;

public class LongToIntFunctionExample {
    public static void main(String[] args) {
        // Example: Converting long to int (e.g., modulo operation)
        // Converts and limits to two-digit values
        LongToIntFunction longToInt = value -> (int) (value % 100);

        long exampleValue = 12345678L;
        int result = longToInt.applyAsInt(exampleValue);

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

In this example, the lambda expression converts a long value into an int by taking its modulo.

---

b. Using Method Reference:

If there’s an existing method compatible with the signature of applyAsInt(long value), we can use a method reference.

package org.kodejava.util.function;

import java.util.function.LongToIntFunction;

public class LongToIntFunctionExample2 {
    public static void main(String[] args) {
        // Example: Using a method reference for a custom conversion
        LongToIntFunction longToInt = LongToIntFunctionExample2::convertLongToInt;

        long exampleValue = 987654321L;
        int result = longToInt.applyAsInt(exampleValue);

        // Custom behavior
        System.out.println("Result: " + result);
    }

    // Custom method matching the LongToIntFunction signature
    public static int convertLongToInt(long value) {
        // Keep the last 3 digits as int
        return (int) (value % 1000);
    }
}

---

c. Using an Anonymous Class:

We can also use an anonymous class to implement the interface.

package org.kodejava.util.function;

import java.util.function.LongToIntFunction;

public class LongToIntFunctionExample3 {
    public static void main(String[] args) {
        // Anonymous class implementation
        LongToIntFunction longToInt = new LongToIntFunction() {
            @Override
            public int applyAsInt(long value) {
                return (int) (value / 1000);
            }
        };

        long exampleValue = 987654321L;
        int result = longToInt.applyAsInt(exampleValue);

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

---

3. When to Use

The LongToIntFunction is useful when:
– We work with primitive types (long and int) and want to avoid the unnecessary cost of boxing and unboxing.
– We need to process a long and get an int result in a concise, functional programming style.

---

4. Real-life Scenario

Imagine we are working with a large dataset containing timestamps represented as long values. We may want to extract part of the timestamp (like the hour or day) as an int:

package org.kodejava.util.function;

import java.time.Instant;
import java.util.function.LongToIntFunction;

public class LongToIntFunctionExample4 {
    public static void main(String[] args) {
        // Extract the hour part from a UNIX timestamp
        LongToIntFunction extractHour =
                timestamp -> Instant.ofEpochSecond(timestamp)
                        .atZone(java.time.ZoneId.systemDefault()).getHour();

        // Current timestamp in seconds
        long currentTimestamp = Instant.now().getEpochSecond();
        int hour = extractHour.applyAsInt(currentTimestamp);

        System.out.println("Current Hour: " + hour);
    }
}

This shows how we can use LongToIntFunction in a practical application.

---

Summary

• The LongToIntFunction interface makes it easy to handle the transformation from long to int type.
• It avoids overhead caused by boxing and unboxing of primitive types.
• It is often used with lambda expressions, method references, or anonymous classes.