Java N-Tuple de la mise en œuvre

Félicitations sur l'apprentissage par la pratique. Voici quelques suggestions de "chances" d'amélioration:

1. Un seul type de n-uplet peut jamais exister (une fois Typelock est réglé). Cela fait mal de réutilisabilité et l'évolutivité dans les programmes de vouloir utiliser plusieurs types de Tuples, sauf si vous recourir à des cut-n-coller de la réutilisation (BirthdayTuple, DimensionsTuple, StreetAddressTuple, ...). Considérons un TupleFactory classe qui accepte les types de cibles et crée un tuple objet builder pour générer des n-uplets.

2. La validité de la valeur "null" comme une valeur dans un Tuple n'est pas documenté. Je pense qu'avant de Typelock est définie, la valeur null est permis; mais après Typelock est défini, le code va générer une exception NullPointerException - ce qui est incompatible. Si ils ne sont pas autorisés, le constructeur doit l'attraper et de la rejeter (indépendamment de Typelock). Si elles sont autorisées, le code de l'ensemble (constructeur, d'égal à égal, hashcode, etc) doit être modifié pour permettre à pour cela.

3. Décider si les Tuples sont destinés à être immuable des objets de valeur. Basé sur son manque de méthodes de définition, je suppose donc. Si oui, alors soyez prudent de "l'adoption" de la future baie lastTuple=this.arr. Même si c'est un var arg constructeur, le constructeur pourrait être appelée avec un tableau directement. La classe adopte le tableau (conserve une référence à elle), et les valeurs dans le tableau pourrait être modifié en dehors de la classe par la suite. Je ferais une copie de la matrice, mais également de documenter le problème potentiel avec les Tuples avec les non-valeurs inaltérables (qui peut être changée à l'extérieur de la n-uplet).

4. Votre equals méthode n'est pas la valeur null check (if (obj == null) return false) et la vérification de classe (soit obj instanceof Tuple ou this.getClass().equals(object.getClass())). L'égale de l'idiome est bien documenté.

5. Il n'y a pas moyen d'afficher les valeurs d'un Tuple, sauf par l'intermédiaire toString. Cela protège les valeurs et l'ensemble de l'immutabilité de la , mais je pense qu'il limite l'utilité de la classe.

6. Alors que je me rends compte à sa juste un exemple, je ne m'attends pas à utiliser cette classe pour quelque chose comme les anniversaires, les dates. Dans les domaines de solution fixe les types d'objets, de classes (comme la Date) sont tellement mieux. J'imagine que cette classe pour être utile dans des domaines spécifiques où les tuples sont des objets de première classe.

Modifier
Été de penser à ce sujet. Voici mon point de vue sur certains de code (sur github + tests):

===
Tuple.java
===
package com.stackoverflow.tuple;
/**
* Tuple are immutable objects.  Tuples should contain only immutable objects or
* objects that won't be modified while part of a tuple.
*/
public interface Tuple {
public TupleType getType();
public int size();
public <T> T getNthValue(int i);
}
===
TupleType.java
===
package com.stackoverflow.tuple;
/**
* Represents a type of tuple.  Used to define a type of tuple and then
* create tuples of that type.
*/
public interface TupleType {
public int size();
public Class<?> getNthType(int i);
/**
* Tuple are immutable objects.  Tuples should contain only immutable objects or
* objects that won't be modified while part of a tuple.
*
* @param values
* @return Tuple with the given values
* @throws IllegalArgumentException if the wrong # of arguments or incompatible tuple values are provided
*/
public Tuple createTuple(Object... values);
public class DefaultFactory {
public static TupleType create(final Class<?>... types) {
return new TupleTypeImpl(types);
}
}
}
===
TupleImpl.java (not visible outside package)
===
package com.stackoverflow.tuple;
import java.util.Arrays;
class TupleImpl implements Tuple {
private final TupleType type;
private final Object[] values;
TupleImpl(TupleType type, Object[] values) {
this.type = type;
if (values == null || values.length == 0) {
this.values = new Object[0];
} else {
this.values = new Object[values.length];
System.arraycopy(values, 0, this.values, 0, values.length);
}
}
@Override
public TupleType getType() {
return type;
}
@Override
public int size() {
return values.length;
}
@SuppressWarnings("unchecked")
@Override
public <T> T getNthValue(int i) {
return (T) values[i];
}
@Override
public boolean equals(Object object) {
if (object == null)   return false;
if (this == object)   return true;
if (! (object instanceof Tuple))   return false;
final Tuple other = (Tuple) object;
if (other.size() != size())   return false;
final int size = size();
for (int i = 0; i < size; i++) {
final Object thisNthValue = getNthValue(i);
final Object otherNthValue = other.getNthValue(i);
if ((thisNthValue == null && otherNthValue != null) ||
(thisNthValue != null && ! thisNthValue.equals(otherNthValue))) {
return false;
}
}
return true;
}
@Override
public int hashCode() {
int hash = 17;
for (Object value : values) {
if (value != null) {
hash = hash * 37 + value.hashCode();
}
}
return hash;
}
@Override
public String toString() {
return Arrays.toString(values);
}
}
===
TupleTypeImpl.java (not visible outside package)
===
package com.stackoverflow.tuple;
class TupleTypeImpl implements TupleType {
final Class<?>[] types;
TupleTypeImpl(Class<?>[] types) {
this.types = (types != null ? types : new Class<?>[0]);
}
public int size() {
return types.length;
}
//WRONG
//public <T> Class<T> getNthType(int i)
//RIGHT - thanks Emil
public Class<?> getNthType(int i) {
return types[i];
}
public Tuple createTuple(Object... values) {
if ((values == null && types.length == 0) ||
(values != null && values.length != types.length)) {
throw new IllegalArgumentException(
"Expected "+types.length+" values, not "+
(values == null ? "(null)" : values.length) + " values");
}
if (values != null) {
for (int i = 0; i < types.length; i++) {
final Class<?> nthType = types[i];
final Object nthValue = values[i];
if (nthValue != null && ! nthType.isAssignableFrom(nthValue.getClass())) {
throw new IllegalArgumentException(
"Expected value #"+i+" ('"+
nthValue+"') of new Tuple to be "+
nthType+", not " +
(nthValue != null ? nthValue.getClass() : "(null type)"));
}
}
}
return new TupleImpl(this, values);
}
}
===
TupleExample.java
===
package com.stackoverflow.tupleexample;
import com.stackoverflow.tuple.Tuple;
import com.stackoverflow.tuple.TupleType;
public class TupleExample {
public static void main(String[] args) {
//This code probably should be part of a suite of unit tests
//instead of part of this a sample program
final TupleType tripletTupleType =
TupleType.DefaultFactory.create(
Number.class,
String.class,
Character.class);
final Tuple t1 = tripletTupleType.createTuple(1, "one", 'a');
final Tuple t2 = tripletTupleType.createTuple(2l, "two", 'b');
final Tuple t3 = tripletTupleType.createTuple(3f, "three", 'c');
final Tuple tnull = tripletTupleType.createTuple(null, "(null)", null);
System.out.println("t1 = " + t1);
System.out.println("t2 = " + t2);
System.out.println("t3 = " + t3);
System.out.println("tnull = " + tnull);
final TupleType emptyTupleType =
TupleType.DefaultFactory.create();
final Tuple tempty = emptyTupleType.createTuple();
System.out.println("\ntempty = " + tempty);
//Should cause an error
System.out.println("\nCreating tuple with wrong types: ");
try {
final Tuple terror = tripletTupleType.createTuple(1, 2, 3);
System.out.println("Creating this tuple should have failed: "+terror);
} catch (IllegalArgumentException ex) {
ex.printStackTrace(System.out);
}
//Should cause an error
System.out.println("\nCreating tuple with wrong # of arguments: ");
try {
final Tuple terror = emptyTupleType.createTuple(1);
System.out.println("Creating this tuple should have failed: "+terror);
} catch (IllegalArgumentException ex) {
ex.printStackTrace(System.out);
}
//Should cause an error
System.out.println("\nGetting value as wrong type: ");
try {
final Tuple t9 = tripletTupleType.createTuple(9, "nine", 'i');
final String verror = t9.getNthValue(0);
System.out.println("Getting this value should have failed: "+verror);
} catch (ClassCastException ex) {
ex.printStackTrace(System.out);
}
}
}
===
Sample Run
===
t1 = [1, one, a]
t2 = [2, two, b]
t3 = [3.0, three, c]
tnull = [null, (null), null]
tempty = []
Creating tuple with wrong types: 
java.lang.IllegalArgumentException: Expected value #1 ('2') of new Tuple to be class java.lang.String, not class java.lang.Integer
at com.stackoverflow.tuple.TupleTypeImpl.createTuple(TupleTypeImpl.java:32)
at com.stackoverflow.tupleexample.TupleExample.main(TupleExample.java:37)
Creating tuple with wrong # of arguments: 
java.lang.IllegalArgumentException: Expected 0 values, not 1 values
at com.stackoverflow.tuple.TupleTypeImpl.createTuple(TupleTypeImpl.java:22)
at com.stackoverflow.tupleexample.TupleExample.main(TupleExample.java:46)
Getting value as wrong type: 
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at com.stackoverflow.tupleexample.TupleExample.main(TupleExample.java:58)

C'est la solution la plus simple et c'est aussi le meilleur. Il est similaire à la façon dont les Tuples sont représentés dans les .NET. Il élude soigneusement java effacement. Il est fortement typé. Il ne jette pas des exceptions. Il est très facile à utiliser.

public interface Tuple
{
int size();
}
public class Tuple2<T1,T2> implements Tuple
{
public final T1 item1;
public final T2 item2;
public Tuple2(
final T1 item_1,
final T2 item_2)
{
item1 = item_1;
item2 = item_2;
}
@Override
public int size()
{
return 2;
}
}
public class Tuple3<T1,T2,T3> implements Tuple
{
public final T1 item1;
public final T2 item2;
public final T3 item3;
public Tuple3(
final T1 item_1,
final T2 item_2,
final T3 item_3)
{
item1 = item_1;
item2 = item_2;
item3 = item_3;
}
@Override
public int size()
{
return 3;
}
}

Quel est le but de typeLock? Pour permettre à quelqu'un pour empêcher la construction de plus de ces objets? Cette partie n'a pas beaucoup de sens.

Pourquoi voudriez-vous jamais eu envie de laisser quelqu'un prévenir la poursuite de l'instanciation de vos objets? Si, pour quelque raison que c'est quelque chose que vous avez besoin, au lieu de "verrouillage" d'une classe et de lever des exceptions, assurez-vous que le chemin d'accès du code ... ne pas créer plusieurs objets de ce type.

Quel est le but de la statique lastTuple qui est une référence de la dernière instancié Tuple? C'est une mauvaise pratique de mélanger les références statiques comme ça.

Franchement le code est assez déroutant, même si la nécessité de cette classe est source de confusion. Si d'une certaine façon c'était le code que je passais en revue dans un environnement de travail, je ne le permettrait pas.

Ici est vraiment une terrible n-tuple de mise en œuvre qui utilise des génériques pour fournir le type de compilation des contrôles. La méthode main (fourni à des fins de démonstration) montre à quel horrible ce qui serait d'utiliser:

interface ITuple { }
/**
* Typed immutable arbitrary-length tuples implemented as a linked list.
*
* @param <A> Type of the first element of the tuple
* @param <D> Type of the rest of the tuple
*/
public class Tuple<A, D extends ITuple> implements ITuple {
/** Final element of a tuple, or the single no-element tuple. */
public static final TupleVoid END = new TupleVoid();
/** First element of tuple. */
public final A car;
/** Remainder of tuple. */
public final D cdr;
public Tuple(A car, D cdr) {
this.car = car;
this.cdr = cdr;
}
private static class TupleVoid implements ITuple { private TupleVoid() {} }
//Demo time!
public static void main(String[] args) {
Tuple<String, Tuple<Integer, Tuple<String, TupleVoid>>> triple =
new Tuple<String, Tuple<Integer, Tuple<String, TupleVoid>>>("one",
new Tuple<Integer, Tuple<String, TupleVoid>>(2,
new Tuple<String, TupleVoid>("three",
END)));
System.out.println(triple.car + "/" + triple.cdr.car + "/" + triple.cdr.cdr.car);
//: one/2/three
}
}

Il serait préférable d'utiliser des génériques pour la compilation de sécurité de type. Vous pouvez définir une interface par arité. Ensuite, vous pouvez définir séparé Appelable interfaces pour accéder aux valeurs du tuple.

interface Tuple1 <T0> { <R> R accept ( Callable1<R,T0> callable ) ; }
interface Tuple2 <T0,T1> { <R> R accept ( Callable2<R,T0,T1> callable ) ; }
...
interface Tuplek <T0,T1,T2,...,Tk> { <R> R accept ( Callablek<R,T0,T1,T2,...,Tk> callable ) ; }
interface Callable1<R,T0> { R call ( T0 t0 ) ; }
interface Callable2<R,T0> { R call ( T0 t0 , T1 t1 ) ; }
....
interface Callablek<R,T0,T1,T2,...,Tk> { R call ( T0 t0 , T1 t1 , T2 t2 , ... , Tk tk ) ; }