Valori univoci da una List di oggetti

[fermat]

ciao!

io ho una lista di questi oggetti:

import org.dizitart.no2.IndexType;
import org.dizitart.no2.objects.Id;
import org.dizitart.no2.objects.Index;
import org.dizitart.no2.objects.Indices;

import java.io.Serializable;
import java.util.Date;

@Indices(value = {
        @Index(value = "gruppo", type = IndexType.NonUnique),
        @Index(value = "titolo", type = IndexType.Unique)
})
public class Nota implements Serializable {

    @Id
private long notaId;
    private String gruppo;
    private String titolo;
    private String testo;
    private Date data;

    public long getNotaId() {
        return notaId;
    }

    public void setNotaId(long notaId) {
        this.notaId = notaId;
    }

    public String getTitolo() {
        return titolo;
    }

    public void setTitolo(String titolo) {
        this.titolo = titolo;
    }

    public String getTesto() {
        return testo;
    }

    public void setTesto(String testo) {
        this.testo = testo;
    }

    public Date getData() {
        return data;
    }

    public void setData(Date data) {
        this.data = data;
    }

    public String getGruppo() {
        return gruppo;
    }

    public void setGruppo(String gruppo) {
        this.gruppo = gruppo;
    }
}

la lista può avere lo stesso gruppo ripetuto più volte.
io avrei la necessità di iterare su questa lista prendendo i valori univoci di gruppo.
ho fatto un pò di tentativi, di cui questo è l'ultimo:

@FXML
public void initialize() {
    List<Nota> list = new ArrayList<>(db.getGruppi().toList());
    list.stream().filter(distinctByKey(n -> n.getGruppo())).collect(Collectors.toList());

    for (Nota n : list) {
        System.out.println(n.getGruppo());
    }
}

public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
    Map<Object, Boolean> map = new ConcurrentHashMap<>();
    return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}

ma compaiono i valori doppi.
come dovrei fare??

[andbin]

la lista può avere lo stesso gruppo ripetuto più volte.
io avrei la necessità di iterare su questa lista prendendo i valori univoci di gruppo.

Quindi da un List<Nota> vuoi (ti va bene) ottenere un Set<String> con i gruppi "distinti" (essendo un Set) ?

List<Nota> list = ........
Set<String> gruppiDistinti = list.stream().map(Nota::getGruppo).collect(Collectors.toSet());

P.S. puoi anche arrivarci con il distinct() dopo il map se poi vuoi ottenere un List.

[fermat]

ciao andbin!

in effetti avevo provato con Set, ma usando Nota e non String.
così come hai fatto tu funziona.
ho solo provato ad aggiungere il sorted, ma sembra non ordini come vorrei:

Set<String> gruppiDistinti = list.stream()
        .sorted(Comparator.comparing(Nota::getGruppo))
        .map(Nota::getGruppo)
        .collect(Collectors.toSet());

invece, per quanto riguarda List, ho fatto così:

List<Nota> list = new ArrayList<>(db.getGruppi().toList());
list.stream()
        .map(Nota::getGruppo)
        .distinct()
        .collect(Collectors.toList())
        .forEach(n -> {
            System.out.println(n);
        });

sembrerebbe funzionare!

[andbin]

in effetti avevo provato con Set, ma usando Nota e non String.

Se volevi ottenere dei Nota "distinti" per gruppo, c'è una questione di concetto: come scarti le note? Nella lista hai es. 3 Nota completamente diversi come altri dati ma con STESSO gruppo. Quale dei 3 tieni? La prima nota? L'ultima nota?
Non ha tantissimo senso .... e poi a cosa servirebbe?

così come hai fatto tu funziona.
ho solo provato ad aggiungere il sorted, ma sembra non ordini come vorrei:

Set<String> gruppiDistinti = list.stream()
        .sorted(Comparator.comparing(Nota::getGruppo))
        .map(Nota::getGruppo)
        .collect(Collectors.toSet());

Il punto è che poi va tutto in un Set che non è ordinato. Se vuoi un Set "ordinato", puoi usare il toCollection e gli passi un Supplier per creare un TreeSet, che è ordinato.

[fermat]

diciamo che io devo tirar fuori tutti i gruppi univoci, perchè poi in un'altra finestra devo tirar fuori tutte le voci del gruppo selezionato.
solo che il db che sto usando, Nitrite, non supporta una clausola GROUP BY o DISTINCT (o almeno io non trovato questa cosa).
quindi ho pensato di raggruppare la lista per gruppo.
non mi serve sapere quale tengo quando raggruppo.
(lo so, probabilmente non sono riuscito a spiegarmi).

ma cmq così dovrei aver risolto.
grazie mille!

[fermat]

come non detto.
probabilmente mi sfugge qualcosa:

List<Nota> list = new ArrayList<>(db.getGruppi().toList());
list.stream()
        .map(Nota::getGruppo)
        .distinct()
        .collect(Collectors.toList())
        .forEach(n -> {
            System.out.println(n);
        });

ObservableList<Nota> obl = FXCollections.observableArrayList(list);
tblGruppi.getColumns().setAll(TableColumns.setcols(new String[]{"GRUPPO"}));
tblGruppi.setItems(obl);

il forEach visualizza solo i risultati raggruppati.
però nella tabella ci sono tutti.
possibile??

[andbin]

il forEach visualizza solo i risultati raggruppati.
però nella tabella ci sono tutti.
possibile??

Il collect è una terminal operation. Non restituisce un nuovo Stream ma un valore "finale" (in quel caso un List, dato dal toList() ).
Poi il forEach è sul List (che è Iterable).

Insomma, hai usato la lista solo "al volo" per il forEach, non l'hai assegnata ad altro. E' questo il dubbio che hai?

[fermat]

si più o meno è quello il dubbio.
perhè io avevo provato banalmente così:

List<Nota> list = new ArrayList<>(db.getGruppi().toList());
List<Nota> nl = list.stream()
        .map(Nota::getGruppo)
        .distinct()
        .collect(Collectors.toList());

ma mi da errore:

Error:(49, 25) java: incompatible types: inference variable T has incompatible bounds
    equality constraints: com.mp.jnotes.Nota
    lower bounds: java.lang.String

che non ho ben capito!

[andbin]

List<Nota> list = new ArrayList<>(db.getGruppi().toList());
List<Nota> nl = list.stream()
        .map(Nota::getGruppo)
        .distinct()
        .collect(Collectors.toList());

Certo, così dà errore. Il map(Nota::getGruppo) trasforma un Stream<Nota> in un Stream<String> (String del gruppo). Quindi alla fine ovviamente non puoi avere un List<Nota> !

[fermat]

ok, l'unica soluzione che mi è venuta in mente è questa:

List<Nota> nl = new ArrayList<>();
List<Nota> list = new ArrayList<>(db.getGruppi().toList());
list.stream()
        .map(Nota::getGruppo)
        .distinct()
        .collect(Collectors.toList())
        .forEach(n -> {
            Nota nt = new Nota();
            nt.setGruppo(n);
            nl.add(nt);
        });

apperentemente funziona.
non so se ci sono modi migliori!