Comment stocker un tableau de paires en Java?

Je suis nouveau sur le java, je veux stocker un tableau de la paire de double. Mon code ressemble à ceci:

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);

Comment puis-je initialiser la paire de variable ?
Est-il une meilleure structure pour stocker mon tableau de paire de doubles ?

source d'informationauteur Benjamin Crouzier

Créer votre propre classe pour représenter une paire et d'ajouter un constructeur qui prend deux arguments:

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; }
}

Voir cette réponse pour les raisons pourquoi un Pair n'existe pas en Java: Quel est l'équivalent du C++ Paire<L,R> en Java?

Vous ne souhaitez pas utiliser l'Entrée c'est une INTERFACE, pas une CLASSE. Cette interface est utilisée par un implémentations de Jeu lorsque vous appelez entrySet() sur une classe qui implémente la Carte. Essentiellement, il vous permet de manipuler la mise en œuvre de la Carte comme s'il s'agissait d'un Jeu.

Ce que vous voulez faire (mais ne le peut pas) est-ce. Si vous essayez de faire cela, vous verrez une erreur de compilation, le long des lignes de "Ne peut pas instancier le type de Carte.Entrée". C'est parce que la Carte.L'entrée est une interface, pas une classe. Une interface ne contient pas de code réel, donc il n'y a pas de véritable constructeur de courir ici.

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

Si vous regardez les docs ci-dessous, vous pouvez voir clairement en haut que c'est une "Carte d'Interface.Entrée", ce qui signifie qu'il est une interface.
http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Map.Entry.html

Ce que vous devez faire au lieu d'essayer de les instancier une interface, ce qui est impossible, c'est de créer votre propre classe appelée Paire. Quelque chose comme cela. N'oubliez pas de modifier le paquet si vous utilisez le code ci-dessous.

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;
    }


}

Après avoir écrit votre Paire de la classe de votre code devrait ressembler à ceci.

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);
    }

}

2

Ne pourriez-vous utiliser
```
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;}
}
```
puis ajouter une certaine forme d'ajouter une méthode, avec une première et une deuxième accesseur & mutateur méthode? Je suis une sorte de nouveau à la programmation, mais de cette façon semble comme il pourrait fonctionner, et être accessible à d'autres choses que juste le DOUBLE, (en cas en bas de la route que vous souhaitez utiliser d'autres types, comme un Entier ou d'une même Chaîne).
1

Vous pouvez utiliser une carte de résoudre ce problème.
1

Est Entry une classe que vous avez défini? Vous l'instancier avec new.
```
Entry<Double, Double> pair = new Entry<Double, Double>(d1, d2);
```
Remarque, je suis en supposant que vous avez défini un constructeur qui prend 2 doubles, et vous avez des références pour d1 et d2.

Je vous suggère de ne PAS utiliser le Map.Entry classe. La sémantique de cette classe sont telles que les valeurs sont une clé et une valeur, raccord avec la carte de travail.
0

Si vous avez accès à l'Entrée de la classe, vous pouvez créer un constructeur qui prend une clé et une valeur en tant que paramètres.
```
Entry<Double, Double> pair = new Entry<Double, Double>(0.5, 3.6);
values.add(pair);
```
0

La Map.Entry type que vous essayez d'utiliser est juste une interface, et ne peut donc pas être instanciée. Si vous voulais (sig)en usage interne types de Mappuis le béton Map.Entry mise en œuvre HashEntry serait une option.

Toutefois, c'est une bien meilleure idée de réaliser ses propres Paire de type. Ou à l'utilisation d'une Carte au lieu d'un tableau si cela convient à vos besoins.

Une autre approche, et probablement le moyen le plus efficace pour stocker et tableau de double paires est d'utiliser un seul tableau de double, et l'utilisation (2*i) et (2*i + 1) que votre système d'indexation. En outre, vous gagnez l'avantage que le tableau sera initialisée à 0 lors de sa création, aucune étape supplémentaire n'est requis. Malheureusement, il y a un peu de codage supplémentaire de frais généraux pour mettre en œuvre la méthode add() et remove(), mais étonnamment, c'est probablement moins que de créer votre propre classe de conteneur pour la paire.

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]);
}
}
}

Vous devez vous connecter pour publier un commentaire.