[Ben]

Also ... meine erste Frage in diesem Forum .. *g*

Ich stehe gerade so dermaßen auf dem Schlauch. Das ist fast nicht mehr schön. Zu wenig geschlafen, zu viel Stress .. keine Ahnung ..

Folgendes Problem:

Ich habe folgendes Interface

public interface TableData
{
  public static final Object[][] DATA = {
    {"1",  "2",  "3",  "4"},
	{"5",  "6",  "7",  "8"}
  };

  public static final String[] COLHEADS = {
    "Spalte1", "Spalte2", "Spalte3", "Spalte4"
  };

}

Dort werden, wie man sieht, Spaltennamen und Inhalte definiert.

Ich möchte dies nun in einer Tabelle darstellen. Alles gar kein Problem, sofern ich einfach nur setValueAt()
der Klasse JTable verwende.

Okay. Ich möchte nun aber folgende Darstellung haben:

Anstatt

Spalte1 Spalte2 Spalte3 Spalte4
  1       2       3       4      
  5       6       7       8

möchte ich es so darstellen

Spalte1  1  5 
Spalte2  2  6
spalte3  3  7
Spalte4  4  8

Aber ich komme gar nicht bis zur Tabelle. Da ist irgendwie eine logische Denkblockade.
Gehen wir mal davon aus, dass ich oben dargestelltes zweidimensionales Array habe.

Ich "murkse" hier derzeit mit diesem Code rum .. der ist grottenschlecht, das weiß ich .. aber so etwas wie
heute ist mir auch noch nicht passiert.
Ich raff es einfach nicht *g*

public class TableDemo implements TableData
{
    public static void main( String[] args )
    {
        // Neues 2-dim. Array anlegen.
        // Zeilen und Spalten werden durch das DATA-Array aus dem Interface "TableData"
        // bestimmt
        Object[][] neu = new Object[DATA[0].length][DATA.length+1];

        int spalten  = neu.length;
        int zeilen   = neu[0].length;

        // Testausgabe
        System.out.println("Spalten" + spalten );
        System.out.println("Zeilen" + zeilen);


        for( int i = 0; i < spalten; i++ )
        {
            // Start: Testausgabe
            System.out.print( i + " | ");

            // Zuweisung
            neu[i][0] = COLHEADS[i];

            for( int j = 1; j < zeilen-1; j++ )
            {
                // Fortführung: Testausgabe
                System.out.print( "i,j" + i + "," + j + " " );

                // Zuweisung
                neu[i][j] = DATA[i][j];
            }

            // Ende: Testausgabe
            System.out.println("");
        }



        // Array soll ausgegeben werden ... erst mal nicht so wichtig, da komme ich nämlich gar
        // nicht hin
        for( int i = 0; i < neu.length; i++ )
        {
            for( int j = 0; j < neu[0].length; j++ )
            {
                System.out.print( neu[i][j] + " ");
            }
            System.out.println("");
        }

    }

}

Ich erhalte folgende Fehlermeldung, wenn ich Kompilieren will:

Spalten4
Zeilen3
0 | i,j0,1 
1 | i,j1,1 
java.lang.ArrayIndexOutOfBoundsException: 2
	at [..].TableDemo.main(TableDemo.java:51)
	[..]
Exception in thread "main" 2 | i,j2,1

Kann mir da mal irgendwer weiterhelfen?
Ich verzweifel hier noch ...

Ich danke Euch.

Grüße Ben.

Also, DATA ist ein 3er Array mit Unterarrays der Länge 5.

DATA.length ist also 3, DATA[0].length ist also 5.

Jetzt weiß ich nicht was Du machen willst. Soll jetzt neu ein 4er Array mit der Länge 5 sein oder ein 3er Array der Länge 6? Du hast höchstwahrscheinlich beim Anlegen die Dimensionen vertauscht weil Splaten stehen bei Dir in der ersten Klammer und Zeilen in der zweiten, während beim Anlegen legst Du erst die Zeilen und dann die Spalten an?!?

Anschließend läßt Du j von 1 bis n-1 laufen, also wird die Zeile 0 von DATA niemals ausgelesen.Zudem läuft der Zähler nur bis n-1 statt bis n.

Das sind die Fehler die ich auf Anhieb entdecke.

Viel Erfolg beim weitersuchen!

[Ben]

hm. ja. ich geh auch gleich nach hause .. das wird hier ja heute nix mehr ..

deine aussagen kann ich nachvollziehen.
was meinst du aber mit 4er-array (etc.)?

neu sollte soviele zeilen haben, wie DATA spalten und so viele spalten, wie DATA zeilen +1.

das "+1" kommt durch die spaltennamen, die ja noch hinzukommen müssen.

verstehst du, was ich machen will?

in dem Fall wirst Du zum transponieren i und j bei der Zuweisung vertauschen müssen (in etwa so

for( int j = 1; j < zeilen; j++ ) 
            { 
                // Fortführung: Testausgabe 
                System.out.print( "i,j" + i + "," + j + " " ); 
 
                // Zuweisung 
                neu[i][j] = DATA[j-1][i]; 
            }

Ausserdem hast Du einen Spaltentext zu wenig deklariert.

[Ben]

sorry. das mit dem spaltentext ist schon richtig. habe es oben editiert.
ic hwerde das gleich mal testen.

wei o wei .. ich sollte heute abend früh ins bett gehen ..

danke dir auf jeden fall. werde mich nochmals melden.

[Ben]

mensch mensch mensch.
gerade nochmal hingesetzt und .. sorry .. ich bin total am ende ^^

ich hatte das problem chon vor wochen gelöst, aber nur den code nicht wiedergefunden und war nicht in der lage es nochmals zu rekonstruieren.

aber nun gut ... jetzt hab ich ihn doch gefunden:

Aufrufende Klasse: "TableDemo"

public class TableDemo implements TableData
{
    public static void main( String[] args )
    {
        TransposedTable transposed = new TransposedTable( COLHEADS, DATA );
 
        Object[][] tableData = transposed.getJoinedData();
 
        // Testausgabe
        for( int row = 0; row < tableData.length; row++ )
        {
            for( int col = 0; col < tableData[0].length; col++ )
            {
                 System.out.print( " " + tableData[row][col] );
            }
            System.out.println( "" );
        }
 
        System.out.println( "
 
" );
        Object[][] transposedTableData = transposed.transposeCompleteTable();
 
 
        // Testausgabe
        for( int row = 0; row < transposedTableData.length; row++ )
        {
            for( int col = 0; col < transposedTableData[0].length; col++ )
            {
                 System.out.print( " " + transposedTableData[row][col] );
            }
            System.out.println( "" );
        }
 
    }
 
}

Klasse: "TransposedTable"

public class TransposedTable
{
    private Object[] colheads;
    private Object[][] data;
 
    private Object[][] tableData;
 
 
    public TransposedTable( Object[] colheads, Object[][] data )
    {
        this.colheads = colheads;
        this.data     = data;
    }
 
    /**
     *  zum Test wird hier einfach mal das "gejointe" Array zurückgegeben
     *
     * @return Object[][]
     */
    public Object[][] getJoinedData()
    {
        return joinColheadsAndData();
    }
 
 
    /**
     *  Der Inhalt der beiden Arrays wird zu einem zusammengebaut.
     *
     * @return Object[][]
     */
    private Object[][] joinColheadsAndData()
    {
        int rowcount  = data.length;
        int columncount = colheads.length;
        Object[][] joined = new Object[rowcount + 1][columncount];
 
        for( int col = 0; col < columncount; col++  )
        {
            joined[0][col] = colheads[col];
        }
 
 
        for( int row = 0; row < rowcount; row++ )
        {
            for( int col = 0; col < columncount; col++ )
            {
                joined[row+1][col] = data[row][col];
            }
        }
 
        return joined;
    }
 
 
    /**
     * Das "gejointe" Array wird transponiert.
     *
     * @return Object[][]
     */
    public Object[][] transposeCompleteTable()
    {
        Object[][] tableData = this.joinColheadsAndData();
 
        int rowcount  = tableData.length;
        int columncount = tableData[0].length;
 
        Object[][] transposedTableData = new Object[columncount][rowcount];
 
        for( int col = 0; col < columncount; col++ )
        {
            for( int row = 0; row < rowcount; row++ )
            {
                transposedTableData[col][row] = tableData[row][col];
            }
        }
 
        setTableData( transposedTableData );
 
        return transposedTableData;
    }
 
 
    public void setTableData( Object[][] tableData )
    {
        this.tableData = tableData;
    }
 
}

eventuell hilft es ja irgendwem weiter.


grüße ben.


edit:
btw: der java-highlighter ist aber auch verbuggt ..