Ejercicio 3 Par1_23_02

[tomaspietravallo]

Buenas!

Queria saber como se consideraria esta resolucion del ejercicio

// ReportCollection<T> sin modificar

// Report<T>
public abstract class Report<T> implements ReportCollection<T> {
    private static final int INITIAL_DIM = 10;
    @SuppressWarnings("unchecked")
    private T[] elems = (T[]) new Object[INITIAL_DIM];
    private int dim = 0;
    private final Comparator<? super T> cmp;

    public Report(Comparator<? super T> cmp) {
        this.cmp = cmp;
    }

    public void add(T report) {
        elems[dim++] = report;
    }

    public T get(int index) {
        return elems[index];
    }

    public T[] reports() {
        T[] arr = Arrays.copyOf(elems, dim);
        Arrays.sort(arr, cmp);
        return arr;
    }

}

// MinToMax

public class MinToMaxReport<T> extends Report<T> {
    public MinToMaxReport(Comparator<? super T> cmp) {
        super(cmp);
    }
}

// MaxToMin
public class MaxToMinReport<T> extends Report<T> {
    public MaxToMinReport(Comparator<? super T> cmp) {
        super(cmp.reversed());
    }
}

Ademas de cualquier corrección general (mas que bienvenida) me interesaba saber los siguientes puntos:

1. Esta bien/ se puede utilizar .reversed() para invertir el orden? Después de ver la solución me di cuenta que podría haber extendido a MinToMaxReport, pero en el contexto de la consigna no me pareció tan mal tener otra clase que extendiera Report con el comprador invertido respecto a lo que entregue un usuario

   public class MaxToMinReport<T> extends Report<T> {
   public MaxToMinReport(Comparator<? super T> cmp) {
       super(cmp.reversed());
   }
   }

2. Para reescribir el comparador, el IDE me sugirio utilizar comparingInt, thenComparing, estaria bien utilizar esto/ se puede en el parcial?

Comparator<Weather> weatherCmp = (a,b) -> {
    int ret = Integer.compare(b.temperature, a.temperature);
    if (ret == 0) ret = a.city.compareTo(b.city);
    return ret;
};

// Se transforma a ->
Comparator.comparingInt((Weather a) -> a.temperature).reversed().thenComparing(a -> a.city);

Muchas gracias! Tomas

[fmeola]

Hola Tomás. En Report#add no estás contemplando qué pasa cuando se llena tu array (por ejemplo cuando quiero agregar el elemento número 11). Deberías implementar un resize y agrandarlo cuando corresponda. En Report#get no estás haciendo programación defensiva. Vos sabés cuántos elementos agregaste así que validá que el índice que recibís no sea negativo y que sea menor a la cantidad de elementos que agregaste. Respecto a 1. el uso de .reversed() está bien y desde ya que está excelente hacer una clase abstracta que no sabe qué criterio usar y luego dos concretas hijas con el criterio de orden concreto. En cuanto a 2. este cuatrimestre no lo llegamos a ver pero sí obvio lo podés usar. Todas esas invocaciones a métodos de Comparator como comparing y thenComparing te permiten ir construyendo un comparator de a partes, donde vas agregando en orden los criterios.

[tomaspietravallo]

resize

Jajja si de tanto implementarlo se me pasó por alto

get

Gracias por la aclaración, no me di cuenta

.reversed()

Genial! Entonces entiendo que estuvo bien planteada la herencia. Bueno saber lo del método .reversed()

Comparator.thenComparing

Okey! Genial

Gracias!! ❤️