Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Functional Interfaces in Java 8 — @FunctionalInterface annotation, built-in interfaces (Predicate, Function, Consumer, Supplier), composition, and custom interfaces.
What is a Functional Interface?
A Functional Interface is an interface that contains exactly one abstract method. It can have any number of default or static methods. Functional interfaces are the foundation of lambda expressions — every lambda targets a functional interface.
java example
@FunctionalInterface
public interface Calculator {
int compute(int a, int b); // Single abstract method (SAM)
// ✅ Default methods are allowed
default void printResult(int a, int b) {
System.out.println("Result: " + compute(a, b));
}
// ✅ Static methods are allowed
static Calculator add() {
return (a, b) -> a + b;
}
// ✅ Methods from Object class don't count
boolean equals(Object obj);
String toString();
}The @FunctionalInterface Annotation
This annotation is optional but highly recommended:
java example
@FunctionalInterface // Compiler enforces single abstract method
interface Greeting {
void greet(String name);
// void farewell(String name); // ❌ Compile error if uncommented
}Without the annotation, the interface is still functional if it has one abstract method — the annotation just enables compile-time checking.
Primitive Specializations
To avoid autoboxing overhead, Java provides primitive versions:
java example
// Instead of Predicate<Integer> - avoids boxing
IntPredicate isEven = n -> n % 2 == 0;
LongPredicate isPositiveLong = n -> n > 0L;
DoublePredicate isFinite = Double::isFinite;
// Instead of Function<Integer, Integer>
IntUnaryOperator doubler = n -> n * 2;
IntFunction<String> intToString = Integer::toString;
ToIntFunction<String> stringLength = String::length;
// Instead of Consumer<Integer>
IntConsumer printInt = System.out::println;
// Instead of Supplier<Integer>
IntSupplier randomInt = () -> (int)(Math.random() * 100);
// Performance comparison
long start = System.nanoTime();
IntStream.range(0, 1_000_000).filter(n -> n % 2 == 0).sum(); // Fast (no boxing)
long primitiveTime = System.nanoTime() - start;
start = System.nanoTime();
Stream.iterate(0, n -> n + 1).limit(1_000_000)
.filter(n -> n % 2 == 0)
.mapToInt(Integer::intValue).sum(); // Slower (boxing/unboxing)
long boxedTime = System.nanoTime() - start;Composing Functional Interfaces
Building Complex Logic from Simple Pieces
Example
public class CompositionDemo {
// Reusable predicates
static Predicate<String> hasMinLength(int min) {
return s -> s.length() >= min;
}
static Predicate<String> containsDigit() {
return s -> s.chars().anyMatch(Character::isDigit);
}
static Predicate<String> containsUppercase() {
return s -> s.chars().anyMatch(Character::isUpperCase);
}
static Predicate<String> doesNotContain(String forbidden) {
return s -> !s.contains(forbidden);
}
public static void main(String[] args) {
// Compose a password validator from simple predicates
Predicate<String> strongPassword = hasMinLength(8)
.and(containsDigit())
.and(containsUppercase())
.and(doesNotContain("password"))
.and(doesNotContain("123456"));
System.out.println(strongPassword.test("MyP@ss1")); // false (too short)
System.out.println(strongPassword.test("MyStr0ngPass")); // true
// Function pipeline
Function<String, String> pipeline =
((Function<String, String>) String::trim)
.andThen(String::toLowerCase)
.andThen(s -> s.replaceAll("[^a-z0-9]", "-"))
.andThen(s -> s.replaceAll("-+", "-"));
System.out.println(pipeline.apply(" Hello World! ")); // "hello-world-"
}
}
Output
false (too short) true "hello-world-"
Custom Functional Interfaces
Tri-Function (Java doesn't provide this)
java example
@FunctionalInterface
interface TriFunction<A, B, C, R> {
R apply(A a, B b, C c);
default <V> TriFunction<A, B, C, V> andThen(Function<R, V> after) {
return (a, b, c) -> after.apply(this.apply(a, b, c));
}
}
// Usage
TriFunction<Integer, Integer, Integer, Integer> volume = (l, w, h) -> l * w * h;
TriFunction<Integer, Integer, Integer, String> volumeDesc =
volume.andThen(v -> "Volume: " + v + " cubic units");
System.out.println(volumeDesc.apply(3, 4, 5)); // "Volume: 60 cubic units"Output
"Volume: 60 cubic units"
Checked Function (handles exceptions)
java example
@FunctionalInterface
interface CheckedFunction<T, R> {
R apply(T t) throws Exception;
static <T, R> Function<T, R> unchecked(CheckedFunction<T, R> f) {
return t -> {
try {
return f.apply(t);
} catch (Exception e) {
throw new RuntimeException(e);
}
};
}
}
// Usage - parsing URLs without try-catch clutter
List<URL> urls = paths.stream()
.map(CheckedFunction.unchecked(URL::new))
.collect(Collectors.toList());Real-World Usage Patterns
Specification Pattern
Example
public interface Specification<T> extends Predicate<T> {
default Specification<T> and(Specification<T> other) {
return t -> this.test(t) && other.test(t);
}
default Specification<T> or(Specification<T> other) {
return t -> this.test(t) || other.test(t);
}
default Specification<T> not() {
return t -> !this.test(t);
}
}
// Product specifications
Specification<Product> isPremium = p -> p.getPrice() > 100;
Specification<Product> isInStock = p -> p.getQuantity() > 0;
Specification<Product> isElectronics = p -> "Electronics".equals(p.getCategory());
Specification<Product> premiumElectronicsInStock =
isPremium.and(isInStock).and(isElectronics);
List<Product> result = products.stream()
.filter(premiumElectronicsInStock)
.collect(Collectors.toList());
Interview Questions
Q1: What makes an interface "functional"?
Answer: Exactly one abstract method (SAM — Single Abstract Method). Default methods, static methods, and methods inherited from Object don't count.
Q2: Name the four core functional interfaces and their method signatures.
Answer: Predicate<T> → boolean test(T t), Function<T,R> → R apply(T t), Consumer<T> → void accept(T t), Supplier<T> → T get().
Q3: What's the difference between Function.compose() and Function.andThen()?
Answer: f.andThen(g) applies f first, then g: g(f(x)). f.compose(g) applies g first, then f: f(g(x)).
Q4: Why do IntPredicate, LongConsumer, etc. exist?
Answer: To avoid autoboxing/unboxing overhead. Using IntPredicate instead of Predicate<Integer> avoids creating Integer wrapper objects, improving performance significantly in high-throughput scenarios.
Q5: Can a functional interface extend another interface?
Answer: Yes, but the resulting interface must still have only one abstract method (either inherited or its own, minus any that match Object methods).
Q6: What happens if @FunctionalInterface is on an interface with 2 abstract methods?
Answer: Compilation error. The annotation is a compile-time check. Without the annotation, the interface simply isn't functional and can't be used as a lambda target.
Q7: Write a generic retry mechanism using Supplier.
Example
public static <T> T retry(Supplier<T> operation, int maxAttempts) {
for (int i = 1; i <= maxAttempts; i++) {
try {
return operation.get();
} catch (Exception e) {
if (i == maxAttempts) throw e;
System.out.println("Attempt " + i + " failed, retrying...");
}
}
throw new IllegalStateException("Unreachable");
}
Output
Attempt " + i + " failed, retrying...
Summary
In this chapter, we learned about Functional Interface in Java 8 in detail. Here are the key points:
- Basic introduction to the concept and why it is needed
- Syntax and structure with complete examples
- Internal working and best practices
- Real-world applications and use cases
- Common mistakes and how to avoid them
- How this topic is asked in interviews
To practice these concepts, write and run the code in your IDE and verify the output. Modify each example and experiment so that you deeply understand the concept.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Functional Interface in Java 8.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, features, functional, interface
Related Java Master Course Topics
Continue learning this concept
Java 8 FeaturesDate and Time API in Java 8Complete guide to java.time package — LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Duration, Period, formatting, parsing, and migration from legacy Date/Calendar.Java 8 FeaturesDefault and Static Methods in InterfacesComplete guide to Default and Static methods in Java 8 interfaces — interface evolution, multiple inheritance resolution, and practical design patterns.Java 8 FeaturesLambda Expression in Java 8Master Lambda Expressions in Java 8 — syntax, functional programming paradigm, type inference, variable capture, and real-world usage patterns with comprehensive examples.Java 8 FeaturesMethod Reference in Java 8Deep guide to Method References in Java 8 — all four types, when to use vs lambdas, constructor references, and practical patterns.Java 8 FeaturesOptional Class in Java 8Master the Optional class in Java 8 — eliminating null pointer exceptions, proper usage patterns, chaining operations, and anti-patterns to avoid.Java 8 FeaturesStream API in Java 8Complete guide to Java 8 Stream API — creation, intermediate operations, terminal operations, parallel streams, collectors, and real-world data processing pipelines.