TreeMap no clasificar correctamente

user1986787:

Estoy tratando de ordenar una TreeMap acuerdo con el "peso". Pero por alguna razón se está eliminando entradas con el mismo valor de peso a pesar de que las claves son diferentes.

A continuación se muestra el código:

class Edge  {
    int source;
    int destination;
    int weight;

    public Edge(int source, int destination, int weight) {
        this.source = source;
        this.destination = destination;
        this.weight = weight;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + destination;
        result = prime * result + source;
        result = prime * result + weight;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Edge other = (Edge) obj;
        if (destination != other.destination)
            return false;
        if (source != other.source)
            return false;
        if (weight != other.weight)
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "Edge [source=" + source + ", destination=" + destination + ", weight=" + weight + "]";
    }
}

Datos de HashMap:

{Edge [fuente = 0, destino = 1, peso = 5] = 5, Edge [fuente = 1, destino = 2, peso = 4] = 4, Edge [fuente = 2, destino = 3, peso = 5] = 5, Edge [fuente = 0, destino = 3, peso = 6] = 6, Edge [fuente = 0, destino = 2, peso = 3] = 3, Edge [fuente = 1, destino = 3, peso = 7] = 7}

Map<Edge, Integer> treemap = new TreeMap<>(new MyWeightComp());
    treemap.putAll(map);

Comparador de la Treemap:

 class MyWeightComp implements Comparator<Edge>{

    @Override
    public int compare(Edge e1, Edge e2) {
        return e1.weight-e2.weight;
    }
}

Los datos después de la clasificación:

{Edge [fuente = 0, destino = 2, peso = 3] = 3, Edge [fuente = 1, destino = 2, peso = 4] = 4, Edge [fuente = 0, destino = 1, peso = 5] = 5, Edge [fuente = 0, destino = 3, peso = 6] = 6, Edge [fuente = 1, destino = 3, peso = 7] = 7}

Así se puede ver que, por alguna razón los datos con el mismo peso está consiguiendo eliminan a pesar de que la clave es una combinación de origen y destino.

Peter Lawrey:

Todos los Mapas de eliminación de duplicados y si compareTo devuelve 0, que se supone que es la misma clave.

class MyWeightComp implements Comparator<Edge> {

    @Override
    public int compare(Edge e1, Edge e2) {
        int cmp = Integer.compare(e1.weight, e2.weight); // handle overflows.
        if (cmp == 0)
            cmp = Integer.compare(e1.source, e2.source);
        if (cmp == 0)
            cmp = Integer.compare(e1.destination, e2.destination);
        return cmp;
    }
}

Si tiene campos que no son importantes para la clasificación, usted todavía tiene que elegir un orden arbitrario, pero consistente si no quiere que se ignoran para los propósitos de duplicados.

La consistencia clave que necesita para garantizar es compare(a, b) == -compare(b, a)o más exactamentesign(compare(a, b)) == -sign(compare(b, a))