j'ai un objet A. cet objet A peut avoir 4 voisins (haut bas gauche droite)
 
J'aimerai a partir de A, pouvoir avoir B, son voisin du haut de facon aisée (genre "position en x" + 1)
 
je pense a un tableau a deux dimensions en fait, et pouvoir me balader de case en case. Ceci dit, je cree dynamiquement les voisins en fct de si j'ai besoin d'aller les voir... par defaut, ya pas de voisin, mais si je dis "j'vais en haut", faut que ca cree le voisin du haut et que ca se deplace (tain j'explique trop mal)
du coup si je demarre ds mon tableau en 0,0 et que je monte, je passe en -1,0.. et mm enfin voila (je sais pas trop si c permis en java en fait)
 
le tout pour savoir si (a) et voisin de (d) si je fais le chemin suivant: abcd: (a la creation de a, il n'y a rien, je sais pas que d sera son voisin plus tard)
 

 
jpeux passer en negatif mes indices de tableau? Y a t'il un autre moyen moins "degueu" (totalement different peu importe pour gerer les voisin)
merci

non tu peut pas, l'acces a un element se fait directement par calcul de sont adresse en memoire donc si tu fait ca le programme va planter
 
moi je voit 2 solutions :
 
 
- garder le systeme du tableau et faire tes propres accesseurs a ce tableau qui s'arrangent pour toujours te retourner le bon element genre elem.getLeft()  
 
- soit tu lies les differents elements entre eux un peu comme dans une liste chainee :
 

mais ca risque peut etre detre lourd a gerer si pratiquement tout les objets ont un voisin, le tableau a deux dimension vaut le coup detre utilise
 
peut etre quil existe des objets plus appropries pour faire ca directement en java mais la je c pas ten dire +

oui mais le pb en fait c'est que a un moment il va me manquer des liens.... (exemple ci dessus, si je construis (a), (b), (c) puis (d), je sais que (b) et lié à (a) et (c), que (c) est lié a (b) et (d), mais j'ai aucune idée que (d) et lié à (a) et vice versa...
 
(edit: en admettant que le constructeur d'un elem prenne sa provenance en argument, et qu'il sauve la destination avant de se deplacer)

tu met le pointeur a nul au depart puis basta  
 
apres tu lie t elements  
 
a.setLeft(d);

je vois pas comment tu sais que (d) est a coté de (a)...
 
 
(a moins de faire un gros traitement une fois que tout est construit mais je voudrais éviter )

Y a aussi la solution de la Map : clef = 2 Integer, value = ton élément ...
 
faut voir les perfs du machin ...
 
 
A la rigueur si le parcours d'éléments en éléments doit être rapide, tu peux en plus gérer les voisins à la façon dont le proposait redFaction (avec les '*' en moins, on est pas en C )

si j'avais une matrice ca serait au tres grand max une matrice 16*9... jvais jeter un oeil a la map alors thx

si tu te sers d'une hashmap, teste les perfs avec différentes valeurs pour le initialCapacity. Plus ce sera grand, plus ca perndra de place mais plus la recherche devrais être rapide ...
 
fait aussi gaffe au codage du hashcode de l'objet qui te servira comme clef ...