Primordial “est synonyme de” méthode: comment faire pour déterminer le type du paramètre?

En raison de l'effacement, vous ne pouvez pas. À propos de les meilleures que vous pourriez faire est de stocker dans le tuple de la classe, le type de plan pour le n-uplet de maintenir un "java.lang.Class" membre de champ. Ensuite, vous pouvez comparer ces champs assurez-vous que le n-uplet de la classe est la même types.

Aussi, voir ce fil:
Quel est l'équivalent du C++ Paire<L,R> en Java?

Il serait utile si vous afficher plus au sujet de votre classe. Je pense à la décoché exprimés et le nombre de champs que vous assimiler signifie qu'il doit être Tuple<E,F> non?

EDIT: voici un utile Paire de classe je l'utilise régulièrement (vous pouvez adapter votre Tuple de la classe si nécessaire). Remarque, semblables à des suggestions faites par d'autres, cette classe permet à l'contenues membres de décider de la question de l'égalité. Votre cas d'utilisation est ce qui doit déterminer si l'égalité est vraiment basé sur le type de contenus membres.

/**
* Adapted from http://forums.sun.com/thread.jspa?threadID=5132045
* 
* 
* @author Tim Harsch
*
* @param <L>
* @param <R>
*/
public class Pair<L, R> {
private final L left;
private final R right;
public R getRight() {
return right;
} //end getter
public L getLeft() {
return left;
} //end getter
public Pair(final L left, final R right) {
this.left = left;
this.right = right;
} //end constructor
public static <A, B> Pair<A, B> create(A left, B right) {
return new Pair<A, B>(left, right);
} //end factory method
@Override
public final boolean equals(Object o) {
if (!(o instanceof Pair<?,?>))
return false;
final Pair<?, ?> other = (Pair<?, ?>) o;
return equal(getLeft(), other.getLeft()) && equal(getRight(), other.getRight());
} //end method
public static final boolean equal(Object o1, Object o2) {
if (o1 == null) {
return o2 == null;
}
return o1.equals(o2);
} //end method
@Override
public int hashCode() {
int hLeft = getLeft() == null ? 0 : getLeft().hashCode();
int hRight = getRight() == null ? 0 : getRight().hashCode();
return hLeft + (37 * hRight);
} //end method
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append('<');
if( left == null ) {
sb.append("null");
} else {
sb.append(left.toString());
} //end if
sb.append(',');
if( right == null ) {
sb.append("null");
} else {
sb.append(right.toString());
} //end if
sb.append('>');
return sb.toString();
} //end method
} //end class

Malheureusement, vous ne pouvez pas le faire au moment de la compilation; l'information est allé. Telles sont les conséquences de type erasure. Une alternative consiste à stocker le paramètre comme une Class instance, puis le chercher plus tard.

Les suggestions de conserver une référence à E's type avec un Class objet semblent inefficace (que beaucoup de inutile de références à une Class de prendre de la mémoire) et inutile pour votre problème.

Il n'est pas généralement vrai que Foo<Bar> etFoo<Baz> devrait être inégale. Si vous n'avez pas besoin E. Et, dans le code que vous avez écrit, vous n'avez même pas besoin de compiler. Tout simplement jeté à Tuple<?>, car c'est vraiment tout ce que vous savez à propos de Tuple à ce point. - Il encore compile tous et à toutes.

Si vous êtes passé Tuples avec les données de deux sauvagement différents types, ces éléments ne seront pas equals, et votre méthode sera de retour false, comme souhaité. (On l'espère-dépend de ces types de mise en œuvre de equals sainement.)

Je suis d'accord avec les commentaires ci-dessus, pourquoi ne le classe E doivent être égaux? et comment voulez-vous traiter les sous-classes de E?

De toute façon, étant donné que c'est ici un exemple de code qui peut vous aider:

public class Example<T> {
T t;
public Example(T t) {
this.t = t;
}
public static void main(String[] args) {
final String s = "string";
final Integer i = 1;
final Number n = 1;
final Example<String> exampleString = new Example<String>(s);
final Example<Integer> exampleInteger = new Example<Integer>(i);
final Example<Number> exampleNumber = new Example<Number>(n);
System.out.println("exampleString subclass "  + exampleString.t.getClass());
System.out.println("exmapleIntger subclass " + exampleInteger.t.getClass());
System.out.println("exmapleNumber subclass " + exampleNumber.t.getClass());
System.out.println("Integer equals Number = " + 
exampleInteger.t.equals(exampleNumber.t));
}
}

Vous pouvez appeler t.getClass() pour obtenir des informations de classe sur le type de T (en supposant qu'il n'est pas nul, bien sûr.)

J'espère que cette aide.