Estoy aprendiendo Java y tendré que hacer un proyecto para un proyecto universitario.

    public double getCreditAmount() {
    return movementList.stream()
            .filter(s -> s.getDate().before(tomorrow()))
            .filter(s -> s.type() == MovementType.CREDIT)
            .mapToDouble(s -> s.amount())
            .reduce(Double::sum)
            .orElse(0.0);
}

public double getDebitAmount(){
    return movementList.stream()
            .filter(s -> s.getDate().before(tomorrow()))
            .filter(s -> s.type() == MovementType.DEBIT)
            .mapToDouble(s -> s.amount())
            .reduce(Double::sum)
            .orElse(0.0);
}

public double updateBalance(){
    return sumOfTotal = getCreditAmount()-getDebitAmount();
}

Este es mi código que toma una enumeración (DEBIT O CRÉDITO), agrega los valores actuales y el método updateBalance los resta unos de otros. Pero entiendo que de esta manera produce código repetido que de alguna manera podría evitar. ¿Cómo podría evitar el código repetido? Sé que debería crear un método más general que evite la repetición de código de getCreditAmount () y getDebitAmount (). Pero, ¿cómo se supone que debo hacerlo?

0
acata8 28 may. 2020 a las 12:33

3 respuestas

La mejor respuesta

Al igual que otros han dicho, puede pasar el tipo de movimiento como parámetro, esto sigue un principio clave en la codificación DRY (No se repita).

Otras cosas que debes hacer:

  1. Déle a su método un nombre genérico porque ahora admite dos operaciones: CRÉDITO y Débito, por ejemplo. obtener, buscar, calcular. Elijo calcular porque estamos haciendo algunos cálculos en ese método.
  2. Me preocupa lo que está haciendo en mapToDouble porque es una operación intermedia que devuelve un DoubleStream que consiste en los resultados de aplicar la función de mapeador dada a los elementos de esta secuencia. Por lo tanto, supongo que s.amount () no devuelve un doble, así que paso la cantidad (s.amount ()) a Double :: parseDouble para analizar la entrada al valor Double

Así es como abordaría este problema

public double computeAmount(MovementType type) {
    return movementList.stream()
            .filter(s -> s.getDate().before(tomorrow()))
            .filter(s -> s.type() == type)
            .mapToDouble(s -> Double::parseDouble(s.amount()))
            .reduce(Double::sum)
            .orElse(0.0);
}

public double updateBalance(){
    return computeAmount(MovementType.CREDIT) - computeAmount(MovementType.DEBIT); 
}
0
Paul Tofunmi 28 may. 2020 a las 10:00

Como la única diferencia es el valor MovementType, apss como parámetro:

public double getAmount(MovementType type) {
    return movementList.stream().filter(s -> s.getDate().before(tomorrow()))
                       .filter(s -> s.type() == type).mapToDouble(s -> s.amount())
                       .reduce(Double::sum).orElse(0.0);
}

Y utilícelo así (no necesita una variable intermedia sumOfTotal)

public double updateBalance(){
    return getAmount(MovementType.CREDIT) - getAmount(MovementType.DEBIT); 
}
1
azro 28 may. 2020 a las 09:36

Simplemente implemente un método y pase el MovementType como parámetro:

public double getAmount(MovementType movementType) {
    return movementList.stream()
            .filter(s -> s.getDate().before(tomorrow()))
            .filter(s -> s.type() == movementType)
            .mapToDouble(s -> s.amount())
            .reduce(Double::sum)
            .orElse(0.0);
}

public double updateBalance() {
    return getAmount(MovementType.CREDIT) - getAmount(MovementType.DEBIT);
}

Una alternativa válida sería definir un método getBalanceAmount() adicional que lo haga todo de una vez. Esto evita tener que transmitir la lista dos veces:

public double getBalanceAmount(){
    return movementList.stream()
            .filter(s -> s.getDate().before(tomorrow()))
            .mapToDouble(s -> s.amount() * (s.type() == MovementType.DEBIT ? -1 : 1)
            .reduce(Double::sum)
            .orElse(0.0);
}
0
Robby Cornelissen 28 may. 2020 a las 09:43