El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Expressions Lambda

Següent ►
►

Les expressions lambda són una característica poderosa introduïda a Java 8 que permeten escriure codi més concís i llegible. Les lambdes són essencialment funcions anònimes que poden ser tractades com a objectes de primera classe. Això significa que es poden passar com a arguments a mètodes, retornar des de mètodes i assignar a variables.

Continguts

  1. Què és una Expressió Lambda?
  2. Sintaxi de les Expressions Lambda
  3. Exemples Pràctics
  4. Interfícies Funcionals
  5. Exercicis Pràctics
  6. Solucions

Què és una Expressió Lambda?

Una expressió lambda és una manera concisa de representar una funció anònima. Les lambdes permeten escriure codi més compacte i llegible, especialment quan es treballa amb col·leccions i API de fluxos.

Beneficis de les Expressions Lambda

  • Concises: Redueixen la quantitat de codi necessari.
  • Llegibles: Fan que el codi sigui més fàcil de llegir i entendre.
  • Flexibles: Es poden utilitzar en qualsevol lloc on es necessiti una instància d'una interfície funcional.

Sintaxi de les Expressions Lambda

La sintaxi bàsica d'una expressió lambda és la següent:

(parameters) -> expression

O, si el cos de la lambda és més complex:

(parameters) -> { statements; }

Components de la Sintaxi

  • Paràmetres: Els paràmetres de la funció. Si no hi ha paràmetres, es poden ometre els parèntesis.
  • Operador Lambda: L'operador -> separa els paràmetres del cos de la lambda.
  • Cos: El cos de la lambda, que pot ser una expressió única o un bloc de codi.

Exemples de Sintaxi

// Lambda sense paràmetres
() -> System.out.println("Hello, World!");

// Lambda amb un sol paràmetre
x -> x * x;

// Lambda amb múltiples paràmetres
(x, y) -> x + y;

// Lambda amb un bloc de codi
(x, y) -> {
    int sum = x + y;
    return sum;
};

Exemples Pràctics

Exemple 1: Filtrar una Llista

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Anna", "John", "Mike", "Sara");

        // Filtrar noms que comencen amb 'A'
        List<String> filteredNames = names.stream()
                                          .filter(name -> name.startsWith("A"))
                                          .collect(Collectors.toList());

        System.out.println(filteredNames); // Output: [Anna]
    }
}

Exemple 2: Ordenar una Llista

import java.util.Arrays;
import java.util.List;

public class LambdaExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Anna", "John", "Mike", "Sara");

        // Ordenar noms en ordre alfabètic invers
        names.sort((a, b) -> b.compareTo(a));

        System.out.println(names); // Output: [Sara, Mike, John, Anna]
    }
}

Interfícies Funcionals

Una interfície funcional és una interfície que conté exactament un mètode abstracte. Les expressions lambda es poden utilitzar per implementar interfícies funcionals. Java proporciona diverses interfícies funcionals predefinides en el paquet java.util.function.

Exemple d'Interfície Funcional

@FunctionalInterface
interface MyFunctionalInterface {
    void myMethod();
}

public class LambdaExample {
    public static void main(String[] args) {
        MyFunctionalInterface myFunc = () -> System.out.println("Lambda Executed");
        myFunc.myMethod(); // Output: Lambda Executed
    }
}

Exercicis Pràctics

Exercici 1: Filtrar i Transformar una Llista

Escriu una expressió lambda per filtrar una llista de números per obtenir només els parells i després multiplica cada número per 2.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaExercise {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Filtrar i transformar
        List<Integer> result = numbers.stream()
                                      .filter(n -> n % 2 == 0)
                                      .map(n -> n * 2)
                                      .collect(Collectors.toList());

        System.out.println(result); // Output: [4, 8, 12, 16, 20]
    }
}

Exercici 2: Ordenar una Llista d'Objectes

Escriu una expressió lambda per ordenar una llista d'objectes Person per edat.

import java.util.Arrays;
import java.util.List;

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

public class LambdaExercise {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Anna", 25),
            new Person("John", 30),
            new Person("Mike", 20),
            new Person("Sara", 22)
        );

        // Ordenar per edat
        people.sort((p1, p2) -> Integer.compare(p1.age, p2.age));

        System.out.println(people); // Output: [Mike (20), Sara (22), Anna (25), John (30)]
    }
}

Solucions

Solució a l'Exercici 1

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaExerciseSolution {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Filtrar i transformar
        List<Integer> result = numbers.stream()
                                      .filter(n -> n % 2 == 0)
                                      .map(n -> n * 2)
                                      .collect(Collectors.toList());

        System.out.println(result); // Output: [4, 8, 12, 16, 20]
    }
}

Solució a l'Exercici 2

import java.util.Arrays;
import java.util.List;

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

public class LambdaExerciseSolution {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Anna", 25),
            new Person("John", 30),
            new Person("Mike", 20),
            new Person("Sara", 22)
        );

        // Ordenar per edat
        people.sort((p1, p2) -> Integer.compare(p1.age, p2.age));

        System.out.println(people); // Output: [Mike (20), Sara (22), Anna (25), John (30)]
    }
}

Conclusió

Les expressions lambda són una eina poderosa en Java que permeten escriure codi més concís i llegible. Són especialment útils quan es treballa amb col·leccions i API de fluxos. En aquest tema, hem après la sintaxi bàsica de les lambdes, hem vist exemples pràctics i hem treballat amb interfícies funcionals. Els exercicis pràctics proporcionats ajuden a reforçar els conceptes apresos.

◄ Anterior
◄
Següent ►
►

Curs de Programació en Java

Mòdul 1: Introducció a Java

Mòdul 2: Flux de Control

Mòdul 3: Programació Orientada a Objectes

Mòdul 4: Programació Orientada a Objectes Avançada

Mòdul 5: Estructures de Dades i Col·leccions

Mòdul 6: Gestió d'Excepcions

Mòdul 7: Entrada/Sortida de Fitxers

Mòdul 8: Multithreading i Concurrència

Mòdul 9: Xarxes

Mòdul 10: Temes Avançats

Mòdul 11: Frameworks i Llibreries de Java

Mòdul 12: Construcció d'Aplicacions del Món Real

El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats