Cad iad lambdas agus comhéadáin fheidhmiúla?

Question

Accepted Answer

**Is iad lambdas** (Java 8+) feidhmeanna gan ainm gonta, agus is **comhéadan feidhmiúil** ná comhéadan le go díreach **aon bhunphaidreoir dhírithe** — an spórt sprice a chuireann lambda i bhfeidhm. Le chéile, thug siad clár feidhmiúil do Java agus cuireann siad an Stream API ar fáil. ## Comhéadan feidhmiúil ```java @FunctionalInterface // optional annotation — enforces ONE abstract method interface Calculator { int calculate(int a, int b); // the single abstract method } ``` Is "feidhmiúil" a bhíonn ar chomhéadan le ceann amháin de bhunphaidreoir dírithe — is féidir le lambda é a chur i bhfeidhm mar níl aon dhúshlán ann faoin bpaidreoir a bhí an lambda ann. ## Comhréir lambda — cuir i bhfeidhm go gonta ```java // ❌ 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 ``` Soláthraíonn an lambda `(a, b) -> a + b` an cur i bhfeidhm ar an bpaidreoir amháin — gan aicme, gan boilerplate sínithe an phaidreora. ## Comhéadáin fheidhmiúla ionsuite (java.util.function) ```java Function length = s -> s.length(); // takes T, returns R Predicate isPositive = n -> n > 0; // takes T, returns boolean Consumer printer = s -> System.out.println(s); // takes T, returns void Supplier greeting = () -> "Hello"; // takes nothing, returns T BiFunction sum = (a, b) -> a + b; // two args ``` Soláthraíonn Java comhéadáin fheidhmiúla réamhdhéanta do chruth coitianta, a úsáidtear ar fud an leabharlainne caighdeánach (go háirithe streams). ## Tagairt mhodh — níos gonta fós ```java // 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 ``` ## Áit ina ngreannann lambdas ```java // 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 ``` ## Cén fáth a bhíonn sé tábhachtach Thug lambdas agus comhéadáin fheidhmiúla an phrógram feidhmiúil do Java, agus bhraistí siad ar an mbealach a scríobhtar Java nua-aimseartha. Dhéanann siad an boilerplate verbóis ar chúl: bealach a bhaint ar na ranganna gan ainm agus **iompar a sheoladh mar sonraí**, rud a ligean an-geal oibreoir imeachta, comparáidí, glaoighchallbhaír, agus — is tábhachtaí — an **Stream API** iomlán (a bhraitheann ar lambdas dá scagadh/map/laghdú oibríochtaí). Tá sé riachtanach a thuiscint go spriocann lambda comhéadan feidhmiúil (aon paidreoir dírithe), na comhéadáin ionsuite (Function, Predicate, Consumer, Supplier), agus tagairt mhodh chun Java nua-aimseartha idiomatach a scríobh agus aibhéamh streams, cnuasaithe, agus API comhuaineach a úsáid go héifeachtach. Dhéan siad a bharrachas ar an teanga agus is bunúsach dóibh gealadh reatha Java.