numeros - ¿Cómo almacenar una matriz de pares en Java?

numeros impares y pares java

Question

Soy nuevo en Java, quiero almacenar un conjunto de pares de dobles. Mi código se ve así:

import java.util.ArrayList;
import java.util.Map.Entry;

List<Entry<Double, Double>> values = new ArrayList<>();
Entry<Double, Double> pair;
// set pair values:
// pair.setKey(0.5); // this method does not exists
// pair.setValue(3.6);
values.add(pair);

¿Cómo puedo inicializar la variable par? ¿Hay una mejor estructura para almacenar mi serie de pares de dobles?

Answer 1

¿Es Entry una clase que definiste? Lo creas con new .

Entry<Double, Double> pair = new Entry<Double, Double>(d1, d2);

Nota: Supongo que ha definido un constructor que toma 2 dobles y tiene referencias para d1 y d2 .

Te sugiero que NO uses la clase Map.Entry . La semántica para esa clase es tal que los valores son una clave y un valor, que se ajustan a la forma en que funcionan los mapas.

Answer 2

Cree su propia clase para representar un par y agregue un constructor que tome dos argumentos:

public class MyPair
{
    private final Double key;
    private final Double value;

    public MyPair(Double aKey, Double aValue)
    {
        key   = aKey;
        value = aValue;
    }

    public Double key()   { return key; }
    public Double value() { return value; }
}

Vea esta respuesta por razones por las que no existe un Pair en Java: ¿Cuál es el equivalente del par C ++ <L, R> en Java?

Answer 3

El tipo Map.Entry que está intentando usar es solo una interfaz y, por lo tanto, no se puede crear una instancia. Si quisiera (mal) usar tipos internos de Map , entonces la implementación concreta Map.Entry HashEntry sería una opción.

Sin embargo, es una idea mucho mejor implementar su propio tipo de par. O, para usar un Mapa en lugar de una matriz, si se adapta a sus necesidades.

Answer 4

No podrías simplemente usar

public class MyClass<A,B> extends ArrayList{
private A first;
private B second;
public MyClass(A first, B second){
super();
this.first = first;
this.second = second;}
}

y luego agrega alguna forma de método de adición, junto con un primer y segundo método de acceso y mutador? Soy algo nuevo en la programación, pero de esta manera parece que podría funcionar, y sería accesible a otras cosas que no sea solo el DOBLE (en caso de que quieras usar otros tipos, como Integer o incluso String) .

Answer 5

No quieres usar Entry, es una INTERFAZ, no una CLASE. Esa interfaz es utilizada por una implementación de Set cuando llama a entrySet () en una clase que implementa Map. Básicamente, te permite manipular el mapa implementado como si fuera un conjunto.

Lo que harías (pero no puedes) es esto. Si intenta hacer esto, verá un error de compilador en la línea de "No se puede crear una instancia del tipo Map.Entry". Eso es porque Map.Entry es una interfaz, no una clase. Una interfaz no contiene ningún código real, por lo que no hay un constructor real para ejecutar aquí.

Entry<Double, Double> pair = new Entry<Double, Double>();

Si observa los documentos a continuación, puede ver claramente en la parte superior que se trata de un "Mapa de interfaz. Ingreso", lo que significa que es una interfaz. http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Map.Entry.html

Lo que debe hacer en lugar de intentar crear una instancia de una interfaz, que es imposible, es crear su propia clase llamada Pair. Algo como esto. Recuerda cambiar el paquete si usas el siguiente código.

package org.mike.test;

public class Pair {
    private double x = 0.0;
    private double y = 0.0;

    public Pair(double x, double y)
    {
        this.x = x;
        this.y = y;
    }

    public Pair()
    {

    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }


}

Después de escribir tu clase de par, tu código ahora se verá así.

package org.mike.test;

import java.util.ArrayList;
import org.mike.test.Pair; //You don''t need this if the Pair class is in the same package as the class using it

public class tester {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<Pair> values = new ArrayList<Pair>();
        Pair pair = new Pair();
        // set pair values:
        pair.setY(3.6);
        pair.setX(3.6);
        values.add(pair);
    }

}

Answer 6

Otro enfoque, y probablemente la forma más eficiente de almacenar y disponer de pares dobles, es usar un solo conjunto de dobles, y usar (2 * i) y (2 * i + 1) como su esquema de indexación. Además, obtiene la ventaja de que la matriz se inicializará en todos los 0s cuando la cree, no se requieren pasos adicionales. Desafortunadamente, hay una pequeña sobrecarga de codificación adicional para implementar add () y remove (), pero sorprendentemente, es probablemente menos que crear su propia clase de contenedor para el par.

class MyClass {
    double[] values;
    int count;

    MyClass(int initialCapacity) {
        values = new double[initialCapacity*2];
    }

    // adding a pair
    void addPair(double x, double y) {
        if (count*2 >= values.length) {
            values = Arrays.copyOf(values, values.length*2);
        }
        values[count*2] = x;
        values[count*2 + 1] = y;
        count++;
    }

    void remove(int index) {
        if (index >= count) throw new IndexOutOfBoundsException();

        if (index < --count) {
            System.arraycopy(values, (index+1)*2, values, index*2, (count - index) * 2);
        }
    }

    int size() { return count; }

    // both these should check that index < count.
    double getX(int index) { return values[index*2]; }
    double getY(int index) { return values[index*2 + 1]; }

    void exampleIteration() {
        // getX/Y accessors are examples of how to get
        // the values, but it will be more efficient
        // in most cases to just access the array
        // array directly as so...
        for (int i=0 ; i<count ; ++i) {
            System.out.printf("%d: (%f,%f)%n", i, values[i*2], values[i*2+1]);
        }
    }
}

Answer 7

Podrías usar un mapa para resolver esto.

Answer 8

Si tiene acceso a la clase Entry, puede crear un constructor que tome la clave y el valor como parámetros.

Entry<Double, Double> pair = new Entry<Double, Double>(0.5, 3.6);
values.add(pair);