Java JTable paramètre Largeur de colonne

J'ai un JTable dans lequel je définis la taille de la colonne comme suit:

table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.getColumnModel().getColumn(0).setPreferredWidth(27);
table.getColumnModel().getColumn(1).setPreferredWidth(120);
table.getColumnModel().getColumn(2).setPreferredWidth(100);
table.getColumnModel().getColumn(3).setPreferredWidth(90);
table.getColumnModel().getColumn(4).setPreferredWidth(90);
table.getColumnModel().getColumn(6).setPreferredWidth(120);
table.getColumnModel().getColumn(7).setPreferredWidth(100);
table.getColumnModel().getColumn(8).setPreferredWidth(95);
table.getColumnModel().getColumn(9).setPreferredWidth(40);
table.getColumnModel().getColumn(10).setPreferredWidth(400);

Cela fonctionne bien, mais lorsque la table est agrandie, j'obtiens un espace vide à droite de la dernière colonne. Est-il possible de redimensionner la dernière colonne à la fin de la fenêtre une fois redimensionnée?

J'ai trouvé une AUTO_RESIZE_LAST_COLUMNpropriété dans les documents mais cela ne fonctionne pas.

Edit: JTableest dans une JScrollPanesa taille préférée est définie.

Que se passe-t-il si vous appelez setMinWidth(400)sur la dernière colonne au lieu de setPreferredWidth(400)?

Dans le JavaDoc pour JTable, lisez doLayout()très attentivement la documentation. Voici quelques bits de choix:

Lorsque la méthode est appelée à la suite du redimensionnement d'une fenêtre englobante, resizingColumn est null. Cela signifie que le redimensionnement a eu lieu "en dehors" du JTable et le changement - ou "delta" - doit être distribué à toutes les colonnes quel que soit le mode de redimensionnement automatique de ce JTable.

Cela pourrait expliquer pourquoi AUTO_RESIZE_LAST_COLUMNne vous a pas aidé.

Remarque: Lorsqu'un JTable ajuste la largeur des colonnes, il respecte absolument leurs valeurs minimales et maximales.

Cela indique que vous souhaiterez peut-être définir Min == Max pour toutes les colonnes sauf les dernières, puis définir Min = Preferred sur la dernière colonne et ne pas définir Max ou définir une très grande valeur pour Max.

Avec JTable.AUTO_RESIZE_OFF, le tableau ne changera pas la taille de l'une des colonnes pour vous, il prendra donc votre paramètre préféré. Si votre objectif est d'avoir les colonnes par défaut à votre taille préférée, sauf pour que la dernière colonne remplisse le reste du volet, vous avez la possibilité d'utiliser l' JTable.AUTO_RESIZE_LAST_COLUMNautoResizeMode, mais il peut être plus efficace lorsqu'il est utilisé avec TableColumn.setMaxWidth()au lieu de TableColumn. setPreferredWidth () pour tout sauf la dernière colonne.

Une fois que vous êtes convaincu que AUTO_RESIZE_LAST_COLUMNcela fonctionne, vous pouvez expérimenter une combinaison de TableColumn.setMaxWidth()etTableColumn.setMinWidth()

JTable.AUTO_RESIZE_LAST_COLUMNest défini comme "Pendant toutes les opérations de redimensionnement, n'appliquez les ajustements qu'à la dernière colonne" ce qui signifie que vous devez définir le mode de redimensionnement automatique à la fin de votre code , sinon setPreferredWidth () n'affectera rien!

Donc, dans votre cas, ce serait la bonne façon:

table.getColumnModel().getColumn(0).setPreferredWidth(27);
table.getColumnModel().getColumn(1).setPreferredWidth(120);
table.getColumnModel().getColumn(2).setPreferredWidth(100);
table.getColumnModel().getColumn(3).setPreferredWidth(90);
table.getColumnModel().getColumn(4).setPreferredWidth(90);
table.getColumnModel().getColumn(6).setPreferredWidth(120);
table.getColumnModel().getColumn(7).setPreferredWidth(100);
table.getColumnModel().getColumn(8).setPreferredWidth(95);
table.getColumnModel().getColumn(9).setPreferredWidth(40);
table.getColumnModel().getColumn(10).setPreferredWidth(400);
table.setAutoResizeMode(JTable.AUTO_RESIZE_LAST_COLUMN);

Utilisez cette méthode

public static void setColumnWidths(JTable table, int... widths) {
    TableColumnModel columnModel = table.getColumnModel();
    for (int i = 0; i < widths.length; i++) {
        if (i < columnModel.getColumnCount()) {
            columnModel.getColumn(i).setMaxWidth(widths[i]);
        }
        else break;
    }
}

Ou prolongez la JTableclasse:

public class Table extends JTable {
    public void setColumnWidths(int... widths) {
        for (int i = 0; i < widths.length; i++) {
            if (i < columnModel.getColumnCount()) {
                columnModel.getColumn(i).setMaxWidth(widths[i]);
            }
            else break;
        }
    }
}

Puis

table.setColumnWidths(30, 150, 100, 100);

En lisant la remarque de Kleopatra (sa deuxième fois, elle a suggéré de jeter un œil à javax.swing.JXTable , et maintenant je suis désolé de ne pas avoir jeté un coup d'œil la première fois :)) Je vous suggère de suivre le lien

J'ai eu cette solution pour le même problème: (mais je vous suggère de suivre le lien ci-dessus) Lors du redimensionnement du tableau, mettez à l'échelle les largeurs de colonne du tableau à la largeur totale du tableau actuel. pour ce faire, j'utilise un tableau global d'entiers pour les largeurs de colonne (relatives)):

private int[] columnWidths=null;

J'utilise cette fonction pour définir les largeurs de colonne du tableau:

public void setColumnWidths(int[] widths){
    int nrCols=table.getModel().getColumnCount();
    if(nrCols==0||widths==null){
        return;
    }
    this.columnWidths=widths.clone();

    //current width of the table:
    int totalWidth=table.getWidth();

    int totalWidthRequested=0;
    int nrRequestedWidths=columnWidths.length;
    int defaultWidth=(int)Math.floor((double)totalWidth/(double)nrCols);

    for(int col=0;col<nrCols;col++){
        int width = 0;
        if(columnWidths.length>col){
            width=columnWidths[col];
        }
        totalWidthRequested+=width;
    }
    //Note: for the not defined columns: use the defaultWidth
    if(nrRequestedWidths<nrCols){
        log.fine("Setting column widths: nr of columns do not match column widths requested");
        totalWidthRequested+=((nrCols-nrRequestedWidths)*defaultWidth);
    }
    //calculate the scale for the column width
    double factor=(double)totalWidth/(double)totalWidthRequested;

    for(int col=0;col<nrCols;col++){
        int width = defaultWidth;
        if(columnWidths.length>col){
            //scale the requested width to the current table width
            width=(int)Math.floor(factor*(double)columnWidths[col]);
        }
        table.getColumnModel().getColumn(col).setPreferredWidth(width);
        table.getColumnModel().getColumn(col).setWidth(width);
    }

}

Lors de la configuration des données que j'appelle:

    setColumnWidths(this.columnWidths);

et en changeant, j'appelle le jeu ComponentListener au parent de la table (dans mon cas le JScrollPane qui est le conteneur de ma table):

public void componentResized(ComponentEvent componentEvent) {
    this.setColumnWidths(this.columnWidths);
}

notez que la table JTable est également globale:

private JTable table;

Et ici, je règle l'auditeur:

    scrollPane=new JScrollPane(table);
    scrollPane.addComponentListener(this);

fireTableStructureChanged();

sera le comportement de redimensionnement par défaut ! Si cette méthode est appelée quelque part dans votre code APRÈS avoir défini les propriétés de redimensionnement de la colonne, tous vos paramètres seront réinitialisés. Cet effet secondaire peut survenir indirectement. Fe à la suite de la modification du modèle de données lié d'une manière que cette méthode est appelée, une fois les propriétés définies.

Pas besoin de l'option, faites simplement la largeur préférée de la dernière colonne au maximum et cela prendra tout l'espace supplémentaire.

table.getColumnModel().getColumn(0).setPreferredWidth(27);
table.getColumnModel().getColumn(1).setPreferredWidth(120);
table.getColumnModel().getColumn(2).setPreferredWidth(100);
table.getColumnModel().getColumn(3).setPreferredWidth(90);
table.getColumnModel().getColumn(4).setPreferredWidth(90);
table.getColumnModel().getColumn(6).setPreferredWidth(120);
table.getColumnModel().getColumn(7).setPreferredWidth(100);
table.getColumnModel().getColumn(8).setPreferredWidth(95);
table.getColumnModel().getColumn(9).setPreferredWidth(40);
table.getColumnModel().getColumn(10).setPreferredWidth(Integer.MAX_INT);

Ce code fonctionne pour moi sans setAutoResizeModes.

        TableColumnModel columnModel = jTable1.getColumnModel();
        columnModel.getColumn(1).setPreferredWidth(170);
        columnModel.getColumn(1).setMaxWidth(170);
        columnModel.getColumn(2).setPreferredWidth(150);
        columnModel.getColumn(2).setMaxWidth(150);
        columnModel.getColumn(3).setPreferredWidth(40);
        columnModel.getColumn(3).setMaxWidth(40);

Utilisez ce code. Cela a fonctionné pour moi. J'ai envisagé 3 colonnes. Modifiez la valeur de boucle de votre code.

TableColumn column = null;
for (int i = 0; i < 3; i++) {
    column = table.getColumnModel().getColumn(i);
    if (i == 0) 
        column.setMaxWidth(10);
    if (i == 2)
        column.setMaxWidth(50);
}