Methoden JTable + 2 For-Schleifen

[Fesker]

Grüße, ich habe gerade ein kleines Verständnisproblem,
ich möchte einfach nur eine Tabelle füllen, mit den, wie sagt man - Inkrementwerten?
Also die Anzahl der Schleifendurchläufe, sodass dann etwas wie ... entsteht...

[0][1][2][3]
[4][5][6][7]

usw...


bei meiner Formel unten passiert aber was anderes.. :autsch:

[5][10][15][20]
[5][10][15][20]

Dachte einfach, ich kann den x mit dem y wert der schleifendurchläufe addieren... hab schon tausend andere varianten versucht, aber ich komm einfach nicht drauf, kann mir da mal jemand auf die Sprünge helfen? Fange grad an, an mir zu zweifeln..

Danke im Voraus.

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.util.Vector;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.table.DefaultTableModel;
import javax.swing.JTable;


public class MainWindow extends JFrame {

	private JPanel contentPane;
	private JTable table;

	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					MainWindow frame = new MainWindow();
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	
	public MainWindow() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(100, 100, 450, 300);
		contentPane = new JPanel();
		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
		contentPane.setLayout(new BorderLayout(0, 0));
		setContentPane(contentPane);
		
		DefaultTableModel model = new DefaultTableModel();
		table = new JTable(model);
		contentPane.add(table, BorderLayout.CENTER);
		
		Vector empty = new Vector();
		empty.add("");
		
		int zaehler=0;
				
		for (int y=0;y<10;y++){
			model.addColumn(empty);
			
			for (int x=0;x<5;x++){
				
				model.addRow(empty);
				model.setValueAt(zaehler, x, y);
                      zaehler+=1;
			}
		}
		
	}

}

 

[Fesker]

Huhu, ich bins noch mal...

 int zaehler=0;
                   
            for (int y=0;y<5;y++){ //Spalte
                model.addColumn(empty);
               
                for (int x=0;x<5;x++){
                	zaehler+=1;
                    System.out.println(x+","+y+","+zaehler); // Kontrolle.....
                    model.addRow(empty);
                    model.setValueAt(zaehler, x, y);
                }}

ich bin mir ziemlich sicher, dass dieser Code mich normalerweise bei einem 2DArray zum Erfolg führen würde.
Aber mit der JTabelle scheints nicht zu klappen, soll das so sein? opcorn:
Gibts da irgendeinen Trick?

 

[turtle]

Du hast falsche Vorstellungen vom TableModel einer JTable.

Praktisch alle Swing-Komponenten laden/speichern die Daten, die angezeigt werden, in einem entsprechenden Model.

Bei JTable ist das nicht anders. Hier heisst das Model TableModel und du benutzt ein fertige Implemtierung davon nämlich DefaultTableModel. Leider verwendet DefaultTableModel Vector als Speicher und macht es aus meiner Sicht schwieriger zu erkennen, was notwendig ist, damit die JTabel "gut" aussieht.

Ich fange immer bei JTable an und schreibe mir mein eigenes Model. Ich habe dein Problem mal umgeschrieben. Ich hoffe du erkennst es wieder

import java.awt.BorderLayout;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;

public class Sample extends JPanel {
	private final JTable table;

	public Sample() {
		MeinModel model = new MeinModel(4);
		table = new JTable(model);
		add(new JScrollPane(table), BorderLayout.CENTER);
	}

	public static void main(String[] args) {
		JFrame frame = new JFrame("Table");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.add(new Sample());
		frame.pack();
		frame.setVisible(true);

	}
}

class MeinModel extends AbstractTableModel {
	private final List<String> columns;
	private final List<List<String>> rows;

	public MeinModel(int anzahl) {
		columns = new ArrayList<>();
		for (int i = 0; i < anzahl; i++) {
			columns.add("Spalte " + i);
		}
		rows = new ArrayList<>();
		for (int zeile = 0; zeile < 10; zeile++) {
			List<String> oneRow = new ArrayList<>();
			for (int i = 0; i < anzahl; i++) {
				int zelle = i + 4 * zeile;
				oneRow.add("" + zelle);
			}
			rows.add(oneRow);
		}
	}

	@Override
	public int getRowCount() {
		return rows.size();
	}

	@Override
	public int getColumnCount() {
		return columns.size();
	}

	@Override
	public Object getValueAt(int rowIndex, int columnIndex) {
		return rows.get(rowIndex).get(columnIndex);
	}
}

 

[Fesker]

Puh... ich versuch das jetzt schon den halben Tag zu kapieren..

Das Problem ist, in dem Modell sind die Zeilen und Spalten doch schon schon vordefiniert.
Habs nochmal etwas abgewandelt, damit ich Zeilen und Spalten extern gleich mit angeben kann.
Ich möchte die nun aber von außen ändern können. also bspw. per ButtonClick.

Nun habe ich versucht mir eine AddRow Funktion zu basteln.
Dazu einen kurzen Listeneintrag zur Kontrolle, ob der RowCount sich auch erhöht... ist wohl auch so..
Ich habe mich dann weiterbelesen, und es stand, dass das Model eine "fireSonstwas" Rückmeldung geben muss, damit die JTable sich aktualisiert.

So tat ich, und siehe da: Ein Error, der besagt, dass die getValue-Funktion unten einen IndexOutOfBound-Error liefert,

Index: 1, Size: 1
	at java.util.ArrayList.rangeCheck(Unknown Source)
	at java.util.ArrayList.get(Unknown Source)

Nur rufe ich diese doch gar nicht auf?! Wo liegt das Problem?

Gibt es denn noch andere Table-Alternativen?
Die Dinger, die man in Delphi immer so praktisch einfügen konnte, hatten alle schon 65500 Zeilen und Spalten vorgefertigt, da brauchte man sich nicht den Kopf zerbrechen. Die C++ Dinger sind da ähnlich gestrickt... kann doch nicht so schwer sein...

Spoiler

class SystemMapModel extends AbstractTableModel {
    private final List<String> columns;
    private final List<List<String>> rows;
    private DefaultListModel planetList = MainWindow.planetListModel;
 
    public SystemMapModel(int colCount, int rowCount) {
        columns = new ArrayList<>();
        for (int i = 0; i < colCount; i++) {
            columns.add("Spalte " + i);
        }
        rows = new ArrayList<>();
        for (int zeile = 0; zeile < rowCount; zeile++) {
            List<String> oneRow = new ArrayList<>();
            
            for (int i = 0; i < colCount; i++) {
                int zelle = i + colCount * zeile;
                oneRow.add("" + zelle);
            }
            rows.add(oneRow);
        }
    }
    
    // Meine Kreation
    public void addRow(){
    	List<String> emptyRow = new ArrayList<>();
    	emptyRow.add("");
    	rows.add(emptyRow);
    	planetList.add(0, "klappt" +rows.size());
    	fireTableDataChanged();

    }

@Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        return rows.get(rowIndex).get(columnIndex);
    }

Der Hintergrund ist doch auch nur ganz banal; es werden "Sonnensysteme" generiert, jedes mit eigener X- und Y- Koordinate, sodass ich diese hinterher in der JTable anklicken kann und sich dann ein Detailfenster mit weiteren Infos öffnet..

zur Zeit ist das einfach über ein ListModel gelöst, aber bei etwa 500 Systemen, kackt das ListModel ab, also brauch ich etwas anderes und sowieso übersichtlicheres ..

Grüße.

 

[turtle]

getValue-Funktion unten einen IndexOutOfBound-Error liefert

Nein, du rufst die Funktion nicht auf, aber es wird automatisch aufgerufen, wenn die JTable sich zeichnen möchte. Daher ruft es getRowCount und die anderen Methoden, die im TableModel definiert sind.

Daher ist es ein gutes Model auch so wichtig für das Zusammenspiel mit einer JTable. Und dein Model scheint da Probleme zu machen.

Das Problem ist, in dem Modell sind die Zeilen und Spalten doch schon schon vordefiniert.

Ja, genau. Und wenn das zu deiner Applikation nicht passt, ändere es doch einfach. Zeilen sind allerdings NICHT vordefiniert, sondern das Model bietet Methoden an, das die JTable anfragen kann, den Wert für eine bestimmte Zeile/Spalte zu erhalten. Dieses "malt" dann die JTable. Daher sind in meinem Beispiel Spalten und Zeilen auch List<XXX>, damit es einfach ist, deren Inhalt anzupassen.

Von dem was du schreibst, würde ich ein PlanetenModel schreiben, in der jede Zeile in der Tabelle einen Planeten darstellen kann. Im Model würden Spalten für Name, x, y, Gewicht und anderes definiert sein. Dieses wären auch Attribute eines Planeten. In meinem Beispiel hatte ich nur einen String im Model drin. Dieses macht bei dir wohl keinen Sinn.

Wenn du per Programm Änderungen am Model vornimmst, beispielsweise Zeile hinzufügst, musst du die natürlich dem Model hinzufügen; war in meinem Beispiel einfach, weil nur ein String vorkommen kann im Model (rows.add(oneRow)). Bei dir also wohl rows.add(neuerPlanet). Danach musst du alle Listener, beispielsweise deine JTable, informieren, das sich das Model geändert hat, damit neu gezeichnet werden kann.

Dieses würde ich aber erst machen, NACHDEM ein PlanetenModel geschrieben und mit Testdaten verifiziert worden ist.