Vorneweg: Das mit den Matrizen ist ziemlich gewagt. Jeder „Normale Mensch ®“ würde das mit einem switch(rotationSteps) machen und händisch aufdröseln. Und damit wäre das ziemlich trivial. Aber so es ist zumindest interessant 
(Irgendwann ist mir mal aufgefallen, dass die Veränderungen der Einträge (!) von (3D) Rotationsmatrizen für die Anwendung auf verschiedene Achsen wieder durch Lineare Transformationen abbildbar sind: Rotation matrix - Wikipedia : Von x nach z ist es eine Translation um (-1,-1). Von x nach y ist es eine Skalierung um Faktor 1.5 und eine Spiegelung an der Hauptdiagonalen. Aber das nur nebenbei 
)
Vielleicht würde es schon helfen, in die Arrays die Koordinaten für die Addressierung reinzuschreiben…
[2,0][2,1]
[1,0][1,1]
[0,0][0,1]
Wenn der nun um 90° CW gedreht wird, dann vermutlich um (0,0). Was da rauskäme wäre
[0,0][1,0][2,0]
[0,1][1,1][2,1]
Aber wenn der nach dem gleichen Muster (von unten nach oben, und in jeder Zeile von links nach rechts) durchnumeriert werden sollte, wäre das ja
[1,0][1,1][1,2]
[0,0][0,1][0,2]
Der Ursprung ist ja woanders. Oder auf dein Beispiel bezogen: Einmal ist der Ursprung bei [0], und einmal ist er bei [4].
Ich glaube, dass nicht der array gedreht wird, sondern die Addressierung (in OpenGL: Man dreht nicht das Objekt, sondern die Kamera ). Deswegen gehe ich davon aus, dass man den Adressierungspunkt nicht mit der Matrix transformieren darf, die man auf den Array anwenden würde, sondern mit der inversen davon. Außerdem gehe ich davon aus, dass man das nicht nur mit Rotationsmatrizen (und ohne händische Verschiebungen) abbilden kann - da kommen ja ein paar Minusse vor, und Arrays mögen Minusse gar nicht Ich denke also, dass man den Zugriff immer noch „zurechtbiegen“ muss, damit man nur auf positive indizes zugreift - und auf die richtigen. Man muss also dafür sorgen, dass die Adressierung (zusätzlich zur Drehung) noch in der richtigen Ecke anfängt.
In jedem Fall erscheint das ziemlich kompliziert. Oder ich stehe auch auf dem Schlauch, und zwar mächtig (das ist gut möglich (übermüdet)). Ich hab’ zwar mit viel Rumprobiererei etwas hingefrickelt…
// For https://forum.byte-welt.net/t/array-inhalt-drehen/19341
package bytewelt;
import java.awt.Point;
import java.awt.geom.AffineTransform;
public class RotatedArrayAccess
{
public static void main(String[] args)
{
int array[][] = {
{ 0, 1 },
{ 2, 3 },
{ 4, 5 }
};
for (int i = 0; i < 4; i++)
{
System.out.println("Rotated " + i + " steps");
int rows = getRows(array, i);
int cols = getCols(array, i);
System.out.println(" rows " + rows);
System.out.println(" cols " + cols);
for (int r = rows-1; r >= 0; r--)
{
for (int c = 0; c < cols; c++)
{
System.out.printf("%3d", get(array, r, c, i));
}
System.out.println();
}
}
}
private static int get(int[][] array, int r, int c, int rotationSteps)
{
Point p = new Point(c, r);
int rows = array.length;
int cols = array[0].length;
int rMax = rows - 1;
int cMax = cols - 1;
Point rotatedMax = rotate(cMax, rMax, rotationSteps);
int cMinMax = Math.min(0, rotatedMax.x);
int rMinMax = Math.min(0, rotatedMax.y);
Point rotatedMin = rotate(cMinMax, rMinMax, -rotationSteps);
int rMin = rotatedMin.y;
int cMin = rotatedMin.x;
AffineTransform at = new AffineTransform();
at.concatenate(rotation(-rotationSteps));
at.transform(p, p);
int ar = (rMin+p.y);
int ac = (cMin+p.x);
return array[ar][ac];
}
private static AffineTransform rotation(int rotationSteps)
{
int steps = rotationSteps % 4;
if (steps < 0)
{
steps += 4;
}
return AffineTransform.getQuadrantRotateInstance(-steps);
}
private static Point rotate(int x, int y, int rotationSteps)
{
Point p = new Point(x, y);
rotation(rotationSteps).transform(p, p);
return p;
}
private static int getRows(int array[][], int rotationSteps)
{
return Math.abs(rotate(array.length, array[0].length, rotationSteps).x);
}
private static int getCols(int array[][], int rotationSteps)
{
return Math.abs(rotate(array.length, array[0].length, rotationSteps).y);
}
}
aber wie man sieht: „Schön“ ist das nicht. Mach’ einfach ein switch 
Schön, eine Frage zu sehen, bei der man sich beim Titel denkt: „Joa, worum geht’s? Quadratischer 2D-Array mit umkopieren, oder diese [0,1,2,3]->[3,0,1,2]-Operation (die auch „Rotation“ heißt)?“, und dann beim Autor schon stutzt, beim Durchlesen merkt, dass es nicht um eine Trivialität geht, und beim genaueren Überlegen+Implementieren dann denkt: "Sh!t, bin ich jetzt blöd?! 
"
