Lambdas (Java 8+) ਸੰਖੇਪ anonymous functions ਹਨ, ਅਤੇ ਇੱਕ functional interface ਇੱਕ interface ਹੈ ਜਿਸ ਵਿੱਚ ਬਿਲਕੁਲ ਇੱਕ abstract method ਹੈ — target type ਜੋ lambda implement ਕਰਦਾ ਹੈ। ਇਹ ਦੋਵਾਂ ਨੇ Java ਨੂੰ functional programming ਲਿਆਏ ਅਤੇ Stream API ਨੂੰ ਸ਼ਕਤੀ ਦਿੱਤੀ।
{
;
}
ਇੱਕ interface ਜਿਸ ਵਿੱਚ ਇੱਕ abstract method ਹੈ "functional" ਹੈ — ਇੱਕ lambda ਇਸਨੂੰ implement ਕਰ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ ਇਸ ਬਾਰੇ ਕੋਈ ambiguity ਨਹੀਂ ਕਿ lambda ਕਿਸ method ਨੂੰ ਪ੍ਰਸਤੁਤ ਕਰਦਾ ਹੈ।
// ❌ verbose anonymous class (pre-Java 8)
Calculator add = new Calculator() {
public int calculate(int a, int b) { return a + b; }
};
// ✅ lambda — same thing, far less boilerplate
Calculator add = (a, b) -> a + b;
Calculator multiply = (a, b) -> a * b;
add.calculate(2, 3); // 5
Lambda (a, b) -> a + b ਸਿੰਗਲ method ਦੀ implementation ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ — ਕੋਈ class ਨਹੀਂ, ਕੋਈ method signature boilerplate ਨਹੀਂ।
Function<String, Integer> length = s -> s.length(); // takes T, returns R
Predicate<Integer> isPositive = n -> n > 0; // takes T, returns boolean
Consumer<String> printer = s -> System.out.println(s); // takes T, returns void
Supplier<String> greeting = () -> "Hello"; // takes nothing, returns T
BiFunction<Integer, Integer, Integer> sum = (a, b) -> a + b; // two args
Java ਆਮ ਆਕਾਰਾਂ ਲਈ ਤਿਆਰ functional interfaces ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜੋ ਸਾਰੀ standard library ਵਿੱਚ (ਖਾਸ ਤੌਰ 'ਤੇ streams) ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।
// when a lambda just calls an existing method, use a method reference
list.forEach(System.out::println); // instead of x -> System.out.println(x)
list.stream().map(String::toUpperCase); // instead of s -> s.toUpperCase()
list.stream().map(Integer::parseInt); // static method ref
// passing behavior as arguments — the core enabler of the Stream API
people.stream()
.filter(p -> p.getAge() > 18) // Predicate lambda
.map(Person::getName) // method reference
.forEach(System.out::println); // Consumer
list.sort((a, b) -> a.compareTo(b)); // Comparator lambda
button.addActionListener(e -> handleClick()); // event handler
Lambdas ਅਤੇ functional interfaces ਨੇ Java ਨੂੰ functional programming ਲਿਆਏ, ਆਧੁਨਿਕ Java ਕਿਵੇਂ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ ਇਸ ਨੂੰ ਬੁਨਿਆਦੀ ਤੌਰ 'ਤੇ ਬਦਲਿਆ।
ਇਹ verbose anonymous-class boilerplate ਨੂੰ ਖਤਮ ਕਰਦੇ ਹਨ behavior ਨੂੰ data ਦੇ ਤੌਰ 'ਤੇ ਪਾਸ ਕਰਨ ਲਈ, event handlers, comparators, callbacks ਨੂੰ ਸੰਖੇਪ ਬਣਾਉਂਦੇ ਹਨ, ਅਤੇ — ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ — ਸਾਰੀ Stream API (ਜੋ ਆਪਣੀਆਂ filter/map/reduce operations ਲਈ lambdas 'ਤੇ ਨਿਰਭਰ ਹੈ)।
ਇਹ ਸਮਝਣਾ ਕਿ ਇੱਕ lambda ਇੱਕ functional interface (ਇੱਕ abstract method) ਨੂੰ target ਕਰਦਾ ਹੈ, built-in interfaces (Function, Predicate, Consumer, Supplier), ਅਤੇ method references idiomaticموdern Java ਲਿਖਣ ਅਤੇ streams, collections, ਅਤੇ concurrent APIs ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤੌਰ 'ਤੇ ਵਰਤਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।
ਇਹ ਭਾਸ਼ਾ ਦੇ ਵੱਡੇ ਵਿਕਾਸ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ ਅਤੇ ਮੌਜੂਦਾ Java fluency ਦਾ ਮੂਲ ਹਨ।
ਵਿਸਤ੍ਰਿਤ ਜਵਾਬਾਂ ਨਾਲ IT ਇੰਟਰਵਿਊ ਸਵਾਲਾਂ ਦੀ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ — ਜੂਨੀਅਰ ਤੋਂ ਸੀਨੀਅਰ ਤੱਕ।
ਦਾਨ ਕਰੋ