Domanda Stream con le lambda

Ordina per data Ordina commenti per reazioni
E

elcondor

Utente Bronze
28 Settembre 2020
48
13
3
24
Salve, chiedevo un chiarimento sulle stream con le lambda. Per esempio dato il frammento di codice come lo posso trasformare con le stream e lambda? HELP ME

Java: 
public void getClienti() {
        for (Clienti x : this.clienti)
            if (x != null)
                System.out.println(x);
    }

    public void setClienti(Clienti[] clienti) {
        this.clienti = clienti;
    }

    private int freePosition(Object[] unNome) {
        int pos = -1;
        for (int a = 0; a < unNome.length; a++) {
            if (unNome[a] == null) {
                pos = a;
                break;
            }
        }
        return pos;
    }
 
Una roba di questo tipo, non ho potuto testare quindi eventualmente dovrai fixare qualcosina
Java: 
public void getClienti() {
    cars.stream()
        .filter(Objects::nonNull)
        .forEach(System.out::println);
}

public int freePosition(Object[] unNome) {
    return IntStream.range(0, unNome.length)
                    .filter(i -> unNome[i] == null)
                    .findFirst()
                    .orElse(-1);
}
Anche se personalmente trovo più chiara e compatta la versione normale
Java: 
public void getClienti() {
    for (Clienti x: this.clienti)
        if (x != null) System.out.println(x);
}

private int freePosition(Object[] unNome) {
    for (int a = 0; a < unNome.length; a++) {
        if (unNome[a] == null) return a;
    }
    return -1;
}
 
St3ve ha detto:
Una roba di questo tipo, non ho potuto testare quindi eventualmente dovrai fixare qualcosina
Java: 
public void getClienti() {
    cars.stream()
        .filter(Objects::nonNull)
        .forEach(System.out::println);
}

public int freePosition(Object[] unNome) {
    return IntStream.range(0, unNome.length)
                    .filter(i -> unNome[i] == null)
                    .findFirst()
                    .orElse(-1);
}
Anche se personalmente trovo più chiara e compatta la versione normale
Java: 
public void getClienti() {
    for (Clienti x: this.clienti)
        if (x != null) System.out.println(x);
}

private int freePosition(Object[] unNome) {
    for (int a = 0; a < unNome.length; a++) {
        if (unNome[a] == null) return a;
    }
    return -1;
}
Clicca per espandere...
Mi da l'errore sulla riga cars.stream()
 
Ultima modifica:
St3ve ha detto:
Beh, ovviamente è clienti e non cars. Devo aver fatto pasticci con il copia&incolla.
Se ti da altri errori magari posta più codice almeno posso compilare io stesso.

EDIT: magari Arrays.stream(clienti).blablabla, non conosco i tipi delle tue variabili.
Clicca per espandere...
In effetti è un programma con 3 classi più il main. Se metto Clienti non mi da errore, però poi mi da errore nel main quando chiamo a.getClienti();
Messaggio unito automaticamente:

elcondor ha detto:
In effetti è un programma con 3 classi più il main. Se metto Clienti non mi da errore, però poi mi da errore nel main quando chiamo a.getClienti();
Clicca per espandere...
Funziona così:
Java: 
public void getClienti() {
        Arrays.stream(clienti)
            .filter(Objects::nonNull)
            .forEach(System.out::println);
    }

    public int freePosition(Object[] unNome) {
        return IntStream.range(0, unNome.length)
                        .filter(i -> unNome[i] == null)
                        .findFirst()
                        .orElse(-1);
    }

funziona bene grazie tantissimo
Messaggio unito automaticamente:

ok St3ve trasformato anche gli altri. In effetti molto più snello con le stream e le lambda. Poi son punti di vista ovviamente.
Funzionano quesi tutti ma questo non so: te lo posto
Java: 
public void removeAutomobile(int targa) {
        int pos = -1;
        for (int i = 0; i < this.automobili.length; i++) {
            if (this.automobili[i].getTarga() == targa) {
                pos = i;
                break;
            } else
                System.err.println("Targa Inesistente");
        }
        if (pos != -1)
            this.automobili[pos] = null;
    }
Messaggio unito automaticamente:

St3ve help me :)
 
Sei sicuro che il codice che hai scritto sia corretto? Il messaggio di errore che stai stampando mi lascia pensare che quello che vuoi fare sia più simile a questo
Java: 
public void removeAutomobile(int targa) {
    int pos = -1;
    for (int i = 0; i < this.automobili.length; i++) {
        if (this.automobili[i].getTarga() == targa) {
            pos = i;
            break;
        }
    }
    if (pos != -1) this.automobili[pos] = null;
    else System.err.println("Targa Inesistente");
}
ovvero "Targa Inesistente" viene stampato se la targa non è presente in nessun elemento dell'array. Questa roba si può scrivere in questo modo
Java: 
public void removeAutomobile(int targa) {
    Optional<Automobile> car = Arrays.stream(automobili) // assumo che la classe si chiami Automobile
      .filter(c.getTarga() == targa)
      .findFirst();

    if (car.isPresent()) automobili[car.get()] = null;
    else System.err.println("Targa Inesistente");
}
O molto meglio (anche se non proprio equivalente), definisci automobili come una lista e poi con una sola linea di codice risolvi scrivendo automobili.removeIf(car -> car.getTarga() == targa).

P.S. Se intuisci che non ho letto, volendo puoi taggarmi usando la chiocciola (e.g., @elcondor ). Quando i messaggi si uniscono automaticamente molte volte non mi arrivano notifiche e non me ne accorgo.
 
Difficile darti la pappa pronta quando non mi dai abbastanza ingredienti. Posta un codice sufficientemente lungo da permettermi di compilare e testare. Anche se vabbé... in teoria quello che ti ho scritto dovrebbe essere più che sufficiente a farti capre come si faccia, poi logicamente dovrai adattarlo in base al tuo codice e al tipo di dati che stai utilizzando.
 
la classe completa è questa , alcune ho già sostituito con le stream e lambda...
Java: 
import java.util.Arrays;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.IntStream;

public class Archivio {
    private Clienti[] clienti;
    private Automobile[] automobili;

    public Archivio() {
        this.clienti = new Clienti[5];
        this.automobili = new Automobile[5];
    }

    public void addCliente(String nome) {
        int x = freePosition(this.clienti);
        if (x != -1)
            this.clienti[x] = new Clienti(nome);
        else
            System.out.println("Pieno per clienti");
    }
    public void getClienti() {
        Arrays.stream(clienti)
            .filter(Objects::nonNull)
            .forEach(System.out::println);
    }

    private int freePosition(Object[] unNome) {
        return IntStream.range(0, unNome.length)
                        .filter(i -> unNome[i] == null)
                        .findFirst()
                        .orElse(-1);
    }

    public void addAutomobile(int targa, String nome) {
        Automobile t = new Automobile();
        t.setNumeroTarga(targa);
        t.setProprietario(new Clienti(nome));
        int x = freePosition(automobili);
        if (x != -1)
            automobili[x] = t;
    }

    public void getAutomobili() {
        Arrays.stream(automobili)
        .filter(Objects::nonNull)
        .forEach(System.out::println);

    }

    public void setAutomobili(Automobile[] automobili) {
        this.automobili = automobili;
    }

    public void removeAutomobile(int targa) {
                
        int pos = -1;
        for (int i = 0; i < this.automobili.length; i++) {
            if (this.automobili[i].getTarga() == targa) {
                pos = i;
                break;
            } else
                System.err.println("Targa Inesistente");
        }
        if (pos != -1)
            this.automobili[pos] = null;
    }

    public void clienteTarga(int targa) {
        for (Automobile x : this.automobili) {
            if (x.getTarga() == targa)
                System.out.println("La targa inserita è di: " + x.getProprietario().getNominativo());
            break;
        }
    }

    public void returnTarga(String nome) {
        for (Automobile x : this.automobili) {
            if (x != null && x.getProprietario().getNominativo().equals(nome))
                System.out.println("Dal nome " + nome + " ha la seguente macchina: " + x.getTarga());
        }
    }

    public void contaAuto(String nome) {
        int count = 0;
        for (Automobile x : this.automobili) {
            if (x != null && x.getProprietario().getNominativo().equals(nome))
                count++;
        }
        System.out.println(nome + " ha totale macchine: " + count);
    }

    public void removeCliente(String nome) {
        for (int x = 0; x < this.automobili.length; x++) {
            if (this.automobili[x] != null && this.automobili[x].getProprietario().getNominativo().equals(nome)) {
                this.automobili[x] = null;
            }
        }
        for (int x = 0; x < this.clienti.length; x++) {
            if (this.clienti[x] != null && this.clienti[x].getNominativo().equals(nome)) {
                this.clienti[x] = null;
            }
        }
    }

    public void maxAuto() {
        int count = 0;
        String str = "";
        for (int x = 0; x < this.automobili.length; x++) {
            if (this.automobili[x] == null);
            for (int a = 0; x < this.clienti.length; x++) {
                String temp = this.clienti[a].getNominativo();
                count = 0;
                if (this.automobili[x].getProprietario().getNominativo().equals(temp)) {
                    count++;
                    str = temp;
                }
            }
            System.out.println("Cliente con maggior auto assiurate è: " + str);
        }
    }
}
 
Molto brutto
Java: 
public void removeAutomobile(int targa) {                       
    OptionalInt car_id = IntStream.range(0, automobili.length)  
        .filter(i -> automobili[i].getTarga() == targa)         
        .findFirst();                                           
                                                                
    if (car_id.isPresent()) automobili[car_id.getAsInt()] = null;
    else System.err.println("Targa Inesistente");               
}
seriamente, se al posto di scrivere
Java: 
private Clienti[] clienti;
private Automobile[] automobili;
scrivi
Java: 
private List<Clienti> clienti;     
private List<Automobile> automobili;
tutto quello che hai implementato diventa molto più semplice e non devi usare null da nessuna parte ;)
 
Si funziona. Hai ragione è brutto il codice, con le liste è più lineare e corretto. Ma la traccia chiedeva di usare gli array ..Grazie sei euper.
Se lo faccio dovrei cambiare tutto il codice ovviamente
 

DISCUSSIONI SIMILI

G
Discussione Creare una codifica
  • 0
  • 177
0
177
Sicurezza Informatica
Goclau
L
Domanda Programma di gestione autostrada in C
  • 1
  • 362
1
362
C / C++
DispatchCode
C
Domanda aiuto programma
  • 8
  • 499
8
499
C / C++
CyberBerry
A
Domanda aiutatemi a correggere il mio codice c++ per il codice fiscale
  • 5
  • 608
5
608
C / C++
DispatchCode
Top Bottom
Indietro