Dire que j'ai la déclaration de tableau suivant:
new double[][] {new double[] {1, 2, 3}, new double[] {4,5,6}, new double[] {7,8,9}}
et je veux « traduire » (changement) le contenu du tableau par un montant fixe dans une direction donnée, en laissant le contenu existant dans les cellules non écrasées - par exemple:
1 2 3 1 1 2
4 5 6 Shifted by +1 in x becomes: 4 4 5
7 8 9 7 7 8
1 2 3 1 2 3
4 5 6 Shifted by +1 in y becomes: 1 2 3
7 8 9 4 5 6
Je peux faire ces opérations en utilisant assez facilement System.arraycopy:
déplacer par dy:
boolean b2t = dy<0; // bottom to top movement
dy = Math.abs(dy);
if (b2t)
{
System.arraycopy(a, dy, a, 0, (a.length-dy));
}
else
{
System.arraycopy(a, 0, a, dy, (a.length-dy));
}
déplacer par dx:
boolean l2r = dx>0; // left to right movement
dx = Math.abs(dx);
for (double[] i : a)
{
if (l2r)
{
System.arraycopy(i, 0, i, dx, (i.length-dx));
}
else
{
System.arraycopy(i, dx, i, 0, (i.length-dx));
}
}
Le comportement intéressant vient quand je tente de faire les deux ensemble (par exemple dx = 1 and dy = 1).
Si j'utilise le code ci-dessus dans l'ordre indiqué (dy alors dx), il semble que le tableau copié est mis à jour dans l'itération de boucle pour le tableau, il a été copié.
par exemple, pour les changements que j'observe sont comme suit par exemple 1..9, pour dx = 1 et dy = 1,:
Orig. dy for:dx(1) dx(2) dx(3)
1 2 3 1 2 3 1 1 2 1 1 1 1 1 1
4 5 6 -> 1 2 3 -> 1 1 2 -> 1 1 1 -> 1 1 1
7 8 9 4 5 6 4 5 6 4 5 6 4 4 5
Comme vous pouvez le voir, au cours de la forboucle dans le dxtransform, il est le traitement des première et deuxième rangées comme ils sont le même objet; et ainsi appliquer la transformation à deux reprises - l' appliquer aux deux tableaux les deux fois.
La documentation pour les Etats System.arraycopy:
Si le src et dest arguments se réfèrent au même objet tableau, la copie est réalisée comme si les composants à des positions srcPos par srcPos + longueur 1 ont d'abord été copiés sur un tableau temporaire avec des composants de longueur et le contenu du tableau temporaire étaient copiées dans les positions destPos à travers longueur-1 + destPos du réseau de destination.
En d' autres termes, lorsque la dytransformation est fait, les deux premiers rangs sont copiés au large à un tableau temporaire séparé, puis de nouveau pour le tableau principal , amais en position décalée.
Il me semble qu'il copie l' referenceau tableau, plutôt que le tableau lui - même - est que ce qui se passe?
Quoi qu'il en soit, je peux résoudre le problème en échangeant le code de sorte qu'il ne les déplace dx avant la dy; mais il serait intéressant de confirmer ce qui se passe ici; parce que si je voulais développer cela en 3 dimensions, je ne serais pas juste capable de réorganiser pour le faire fonctionner.
Oui, il est la copie des références.
Un tableau 2D est en fait une matrice dont les éléments sont des objets de type tableau.
Par conséquent, lorsque System.arraycopycopie les éléments du tableau source au tableau cible (indépendamment du fait qu'ils sont le même tableau ou non) il fait référence copie à ces éléments, qui dans vos moyens de cas références aux réseaux internes.