Java Pass Function as Parameter — Complete Guide with Code Examples

To pass a function as a parameter in Java, you use a functional interface together with a lambda expression or a method reference. Java does not let you pass raw methods directly, so the function must be wrapped in a type such as Function, Predicate, Consumer, or your own custom functional interface.

This is one of the most important ideas in modern Java because it lets the same method accept different behavior at runtime. That is exactly how streams, callbacks, validators, mappers, and strategy-like business rules work.

Introduction to passing functions as parameters in Java

Passing a function as a parameter means your method receives behavior, not just data. Instead of hardcoding what the method should do internally, you give it logic from the outside.

Here is the minimal pattern before anything else:

import java.util.function.Function;

// Method accepts a function: String -> String
public String transform(String input, Function<String, String> fn) {
    return fn.apply(input);
}

// Call with a lambda
String result = transform("hello", s -> s.toUpperCase()); // HELLO

// Or with a method reference
String result2 = transform("hello", String::toUpperCase); // HELLO

That is the full pattern: define a method that accepts a functional interface, then pass behavior using either a lambda or a method reference. The rest of this guide shows when to use each interface, how lambdas work, when method references are cleaner, and what mistakes to avoid in production code.

How Java handled this before and after Java 8

Before Java 8, Java developers passed behavior using interfaces and anonymous inner classes. Since Java 8, lambdas and method references made the same pattern much shorter and easier to read.

interface Calculator {
    int calculate(int a, int b);
}

public void processNumbers(int x, int y, Calculator calc) {
    System.out.println(calc.calculate(x, y));
}

// Before Java 8
processNumbers(5, 3, new Calculator() {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
});

// Java 8+
processNumbers(5, 3, (a, b) -> a + b);

Functional interfaces: the foundation of function parameters

A functional interface is an interface with exactly one abstract method. This is the type that a lambda expression or method reference is assigned to. In practice, this means you do not pass a raw function in Java — you pass an object whose type is a functional interface.

In most cases, start with the built-in interfaces from java.util.function before creating your own.

import java.util.function.*;

public class BuiltInInterfacesDemo {

    public static Integer applyFunction(String s, Function<String, Integer> fn) {
        return fn.apply(s);
    }

    public static boolean check(String s, Predicate<String> predicate) {
        return predicate.test(s);
    }

    public static void process(String s, Consumer<String> action) {
        action.accept(s);
    }

    public static String getDefault(Supplier<String> supplier) {
        return supplier.get();
    }

    public static void main(String[] args) {
        System.out.println(applyFunction("hello", String::length)); // 5
        System.out.println(check("", String::isEmpty));             // true
        process("world", System.out::println);                      // world
        System.out.println(getDefault(() -> "fallback value"));     // fallback value
    }
}

Creating your own functional interfaces

Create a custom functional interface only when the built-in ones do not describe your method signature or your domain clearly enough. In many cases, Function, Predicate, or Consumer is already enough.

@FunctionalInterface
public interface StringProcessor {
    String process(String input, int maxLength);

    default String processWithPrefix(String input, int maxLength) {
        return "Processed: " + process(input, maxLength);
    }
}

public void handleString(String text, StringProcessor processor) {
    String result = processor.process(text, 10);
    System.out.println(result);
}

handleString("Hello World", (s, len) -> s.substring(0, Math.min(s.length(), len)));
// Output: Hello Worl

How parameter passing works in Java

Java is always pass-by-value. When you pass a lambda or method reference, Java passes a copy of the reference to the function object. The function itself is not copied, and captured local variables must be effectively final.

Lambda expressions: the modern approach

A lambda is an anonymous function defined inline. The general syntax is (parameters) -> expression or (parameters) -> { statements; }. The compiler usually infers the type from the surrounding functional interface.

// Single expression
processNumbers(5, 3, (a, b) -> a + b);

// Block body
processNumbers(5, 3, (a, b) -> {
    int sum = a + b;
    System.out.println("Computing: " + a + " + " + b);
    return sum;
});

// No parameters
Runnable r = () -> System.out.println("Running!");

// One parameter
Consumer<String> printer = s -> System.out.println(s);

// Type inferred
Function<String, Integer> fn1 = s -> s.length();

// Explicit type
Function<String, Integer> fn2 = (String s) -> s.length();

Lambdas can capture variables from the enclosing scope, but only if those variables are effectively final. In other words, you can read them, but you cannot reassign them later.

String prefix = "Hello, ";

Function<String, String> greeter = name -> prefix + name;
System.out.println(greeter.apply("Alice")); // Hello, Alice

// This would not compile if prefix were reassigned later

Method references: cleaner syntax for existing methods

A method reference is a shorter way to write a lambda that only calls an existing method. For example, instead of s -> s.toUpperCase(), you can write String::toUpperCase. Use method references when they make the code clearer, not just shorter.

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class MethodReferencesDemo {

    static int doubleIt(int n) { return n * 2; }

    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Bob", "Charlie");

        // Static method reference
        List<Integer> doubled = List.of(1, 2, 3).stream()
            .map(MethodReferencesDemo::doubleIt)
            .collect(Collectors.toList());

        // Specific object method reference
        String expected = "Hello";
        Predicate<String> isHello = expected::equals;

        // Arbitrary object method reference
        List<String> upper = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());

        // Constructor reference
        Supplier<ArrayList<String>> listFactory = ArrayList::new;
        ArrayList<String> newList = listFactory.get();
    }
}

Real-world examples: streams, callbacks, and strategy pattern

The idea becomes much clearer once you see it in real code. In modern Java projects, functions are most often passed into streams, callback handlers, validators, mappers, and strategy-like business rules.

Passing functions to streams

import java.util.*;
import java.util.stream.*;

public class StreamFunctionsDemo {

    public static void main(String[] args) {
        List<String> words = List.of("java", "stream", "lambda", "filter", "map");

        // filter takes Predicate<T>
        List<String> longWords = words.stream()
            .filter(w -> w.length() > 4)
            .collect(Collectors.toList());

        // map takes Function<T, R>
        List<Integer> lengths = words.stream()
            .map(String::length)
            .collect(Collectors.toList());

        // forEach takes Consumer<T>
        words.stream()
            .filter(w -> w.startsWith("l"))
            .forEach(System.out::println);

        // sorted takes Comparator
        List<String> sorted = words.stream()
            .sorted(Comparator.comparingInt(String::length))
            .collect(Collectors.toList());
    }
}

Callback pattern

import java.util.function.Consumer;

public class FileProcessor {

    public void processFile(String filename, Consumer<String> onSuccess, Consumer<Exception> onError) {
        try {
            String content = readFile(filename);
            onSuccess.accept(content);
        } catch (Exception e) {
            onError.accept(e);
        }
    }

    private String readFile(String filename) {
        return "file content of " + filename;
    }
}

FileProcessor processor = new FileProcessor();
processor.processFile(
    "data.csv",
    content -> System.out.println("Read: " + content),
    err -> System.err.println("Failed: " + err.getMessage())
);

Strategy pattern with functional interfaces

import java.util.function.Function;

public class PriceCalculator {

    public double calculate(double basePrice, Function<Double, Double> discountStrategy) {
        return discountStrategy.apply(basePrice);
    }

    public static void main(String[] args) {
        PriceCalculator calc = new PriceCalculator();

        Function<Double, Double> noDiscount = price -> price;
        Function<Double, Double> tenPercent = price -> price * 0.90;
        Function<Double, Double> flatFifteen = price -> price - 15.0;

        System.out.println(calc.calculate(100.0, noDiscount));  // 100.0
        System.out.println(calc.calculate(100.0, tenPercent));  // 90.0
        System.out.println(calc.calculate(100.0, flatFifteen)); // 85.0
    }
}

Common mistakes and how to avoid them

Most bugs here do not come from syntax. They come from readability problems, captured mutable state, checked exceptions, and using custom interfaces where built-in ones already exist. These are the mistakes that show up most often in real Java codebases.

import java.util.concurrent.atomic.AtomicInteger;

// MISTAKE: trying to modify a captured variable
// int count = 0;
// list.forEach(item -> count++); // compile error

// FIX
AtomicInteger count = new AtomicInteger(0);
list.forEach(item -> count.incrementAndGet());

// MISTAKE: complex lambda
list.stream()
    .map(s -> {
        String trimmed = s.trim();
        String upper = trimmed.toUpperCase();
        return upper.replace(" ", "_");
    });

// FIX: extract to named method
list.stream().map(MyUtils::normalize);

public class MyUtils {
    public static String normalize(String s) {
        return s.trim().toUpperCase().replace(" ", "_");
    }
}