Coleccions i streams

name: portada
class: portada-slide, center, middle

# Coleccions i streams
## Programació funcional

.footnote[Joan Puigcerver Ibáñez]

---
layout: true
class: regular-slide
.right[.logo[![logoMislata](/itb/images/logo_mislata.png)]]

---
# Programció funcional
- Volem poder passar funcions com a arguments.

```
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

// eliminar valors negatius d'una llista
list.removeIf(value -> value <= 0);

// Ordenar de major amenor
list.sort((v1, v2) -> v2-v1);

// Imprimir cada element de la llista
list.forEach((n) -> { System.out.println(n); });
```

---
# Java Lambda
- Permet definir una funció i passar-la com a paràmentre

---
# Java Lambda

- Un parametre amb una expressió
	- return elidit

```
parameter -> expression
```
---
# Java Lambda

- Més d'un paràmetre amb una expressió
	- return elidit

```
(parameter1, parameter2) -> expression
```

---
# Java Lambda

- Si el codi és llarg podem crear un bloc
	-return s'ha de posar

```
(parameter1, parameter2) -> { code block }
```

---
# Exercici
LamdaSample

---
# Method reference
- Permet passar com a paràmentre una funció existent

---
# Method reference
### Mètode estàtic

```
private static boolean isNegativeOrZero(Integer integer) {
    return integer<=0;
}

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    list.removeIf(StreamSamples::isNegativeOrZero);
    list.forEach(System.out::println);
}
```

---
# Method reference
### Mètode d'un objecte

```
public class School {
    List<String> studentNames;
    String domain;
    // ...
    public void printEmails(){
        studentNames.forEach(this::printEmailFromName);
    }
    public void printEmailFromName(String name){
        System.out.println(name+"@"+domain);
    }
}
```

---
# Exercici
MethodReferenceSample

---
# Collections

Llistat de mètodes estàtics sobre coleccions

```
Collections.max(list)
Collections.min(list)
Collections.frequency(list, value)
```

---
# Comparator

```
// reserve sort
list.sort(Comparator.reverseOrder());

List<Rectangle> rectangles = new ArrayList<>();
// Ordenar rectangles per area
rectangles.sort(Comparator.comparing(Rectangle::getArea));
rectangles.sort(Comparator.comparing(Rectangle::getArea).reversed());

// Obté el producte més car. En cas d'empat l'últim alfabeticament.
List<Product> products = new ArrayList<>();
Collections.max(products, Comparator.comparing(Product::getPrice).thenComparing(Product::getName));
```

---
# Streams
- Un stream (flux) és una seqüència d'objectes que admet diversos mètodes que es poden canalitzar (pipe) per produir el resultat desitjat.

```
long countDistinct = list.stream().distinct().count();
boolean existValueBetween10And20 = list.stream().anyMatch(element -> element>10 && element<20);
```

---
# Streams
- Podem crear un stream d'una llista amb el mètode .stream();

```
Stream<String> stream = list.stream();
```

---
# Stream operations
## filter

```
// imprimir valors superiors a 4
list.stream()
	.filter(value -> value >4)
	.forEach(System.out::println);
```

---
# Stream operations
## Map

```
// imprimir el doble dels valors
list.stream()
    .map(value -> value*2)
    .forEach(System.out::println);
```

---
# Stream operations
## Collect

```
// Llista amb +1 a cada valor
List<Integer> plusOne = list.stream()
	.map(v->v+1)
	.collect(Collectors.toList());
```

---
# Stream operations
## allMatch, anyMatch, noneMatch

```
// Llista amb +1 a cada valor
boolean allZeros = list.stream().allMatch(v -> v==0);
```
---
# Stream operations
## reduce

```
// suma els valors
int sum = list.stream().reduce(0, (a, b) -> a+b);

// calcula el valor màxim
int max = list.stream().reduce(0, (a, b) -> Math.max(a,b));
```

---
# Stream
## Integer/double streams

```
List<Rectangle> rectangles = new ArrayList<>();
double average = rectangles.stream()
	.mapToDouble(Rectangle::getArea)
	.average().getAsDouble();
```

---
# Creació de streams

```
Stream<String> streamOfArray = Stream.of("a", "b", "c");

Stream<Integer> tenOnes = Stream.generate(() -> 1).limit(10);

Stream<Integer> oneToTen = Stream.iterate(1, n -> n + 1).limit(10);

Stream<Integer> oneToFive =IntStream.range(1, 5);
```

---
# Més a Streams
- https://www.baeldung.com/java-8-streams-introduction