Java 有没有办法将ArrayList放入JTable，其中每一行都是ArrayList的下一个索引？

我有许多不同的数组列表。我希望每个索引都是JTable中的一个新行，但我不确定如何做到这一点。我做了一个for循环，但它不工作。 有没有办法用数组列表而不是数组填充JTable

 public TableCreator() {
    super(new GridLayout(1,0));

    String[] columnNames = {"Item Type",
      "Description",
      "Size",
      "Price"};
    // for(int i=0; i<ShoppingFunctions.cartType.size(); i++){

    for(int i=0; i<GUI.size.size(); i++){//FIX!!!!
      item = ShoppingFunctions.cartType.get(i)+"\n";
      described = GUI.describe[GUI.imageNum];
      sizes = GUI.size.get(i);
      price = ShoppingFunctions.cartPrice.get(i)+"\n";
    }//end of for


   Object[][] data = {{item, described, sizes, price}};


    final JTable table = new JTable(data, columnNames);
    table.setPreferredScrollableViewportSize(new Dimension(500, 70));
    table.setFillsViewportHeight(true);

    if (DEBUG){
      table.addMouseListener(new MouseAdapter(){
        public void mouseClicked(MouseEvent e){
          printDebugData(table);
        }//end of method
      });//end of listener
    }//end of if

    JScrollPane scrollPane = new JScrollPane(table);
    add(scrollPane);
  }//end of method

publicTableCreator（）{
超级（新网格布局（1,0））；
String[]columnNames={“项目类型”，
“说明”，
“大小”，
“价格”}；
//对于（inti=0；i来说，简单的答案是基于
AbstractTableModel

例如

public abstract class AbstractGenericTableModel<R> extends AbstractTableModel {

    protected ArrayList<R> rows;
    protected List columnIdentifiers;

    public AbstractGenericTableModel() {
        this(0, 0);
    }

    public AbstractGenericTableModel(int rowCount, int columnCount) {
        this(new ArrayList(columnCount), rowCount);
    }

    public AbstractGenericTableModel(List columnNames, int rowCount) {
        setData(new ArrayList<>(rowCount), columnNames);
    }

    public AbstractGenericTableModel(List<R> data, List columnNames) {
        setData(data, columnNames);
    }

    public List<R> getRowData() {
        return rows;
    }

    private List nonNullVector(List v) {
        return (v != null) ? v : new ArrayList();
    }

    public void setData(List<R> data, List columnIdentifiers) {
        this.rows = new ArrayList<>(nonNullVector(data));
        this.columnIdentifiers = nonNullVector(columnIdentifiers);
        fireTableStructureChanged();
    }

    public void addRow(R rowData) {
        insertRow(getRowCount(), rowData);
    }

    public void insertRow(int row, R rowData) {
        rows.add(row, rowData);
        fireTableRowsInserted(row, row);
    }

    /**
     * Removes the row at <code>row</code> from the model. Notification of the row being removed will be sent to all the listeners.
     *
     * @param row the row index of the row to be removed
     * @exception ArrayIndexOutOfBoundsException if the row was invalid
     */
    public void removeRow(int row) {
        rows.remove(row);
        fireTableRowsDeleted(row, row);
    }

    public void setColumnIdentifiers(List columnIdentifiers) {
        setData(rows, columnIdentifiers);
    }

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

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

    @Override
    public String getColumnName(int column) {
        Object id = null;
        // This test is to cover the case when
        // getColumnCount has been subclassed by mistake ...
        if (column < columnIdentifiers.size() && (column >= 0)) {
            id = columnIdentifiers.get(column);
        }
        return (id == null) ? super.getColumnName(column)
                        : id.toString();
    }

}

public class ArrayListTableModel extends AbstractGenericTableModel<ArrayList> {

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        List<ArrayList> rows = getRowData();
        return rows.get(rowIndex).get(columnIndex);
    }

}

这将创建两个类，一个是基于“抽象泛型”的模型，它允许您指定支持行的物理数据，另一个是
ArrayListTableModel
，它允许您对单个数据使用
ArrayList

不过，这假设的是，每一行都有相同数量的元素，但不进行检查

我建议您仔细查看更多细节
简单的答案是基于类似于
AbstractTableModel的内容创建自己的

例如

public abstract class AbstractGenericTableModel<R> extends AbstractTableModel {

    protected ArrayList<R> rows;
    protected List columnIdentifiers;

    public AbstractGenericTableModel() {
        this(0, 0);
    }

    public AbstractGenericTableModel(int rowCount, int columnCount) {
        this(new ArrayList(columnCount), rowCount);
    }

    public AbstractGenericTableModel(List columnNames, int rowCount) {
        setData(new ArrayList<>(rowCount), columnNames);
    }

    public AbstractGenericTableModel(List<R> data, List columnNames) {
        setData(data, columnNames);
    }

    public List<R> getRowData() {
        return rows;
    }

    private List nonNullVector(List v) {
        return (v != null) ? v : new ArrayList();
    }

    public void setData(List<R> data, List columnIdentifiers) {
        this.rows = new ArrayList<>(nonNullVector(data));
        this.columnIdentifiers = nonNullVector(columnIdentifiers);
        fireTableStructureChanged();
    }

    public void addRow(R rowData) {
        insertRow(getRowCount(), rowData);
    }

    public void insertRow(int row, R rowData) {
        rows.add(row, rowData);
        fireTableRowsInserted(row, row);
    }

    /**
     * Removes the row at <code>row</code> from the model. Notification of the row being removed will be sent to all the listeners.
     *
     * @param row the row index of the row to be removed
     * @exception ArrayIndexOutOfBoundsException if the row was invalid
     */
    public void removeRow(int row) {
        rows.remove(row);
        fireTableRowsDeleted(row, row);
    }

    public void setColumnIdentifiers(List columnIdentifiers) {
        setData(rows, columnIdentifiers);
    }

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

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

    @Override
    public String getColumnName(int column) {
        Object id = null;
        // This test is to cover the case when
        // getColumnCount has been subclassed by mistake ...
        if (column < columnIdentifiers.size() && (column >= 0)) {
            id = columnIdentifiers.get(column);
        }
        return (id == null) ? super.getColumnName(column)
                        : id.toString();
    }

}

public class ArrayListTableModel extends AbstractGenericTableModel<ArrayList> {

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        List<ArrayList> rows = getRowData();
        return rows.get(rowIndex).get(columnIndex);
    }

}

这将创建两个类，一个是基于“抽象泛型”的模型，它允许您指定支持行的物理数据，另一个是
ArrayListTableModel
，它允许您对单个数据使用
ArrayList

不过，这假设的是，每一行都有相同数量的元素，但不进行检查

我建议您仔细查看更多细节
简单的答案是基于类似于
AbstractTableModel的内容创建自己的

例如

public abstract class AbstractGenericTableModel<R> extends AbstractTableModel {

    protected ArrayList<R> rows;
    protected List columnIdentifiers;

    public AbstractGenericTableModel() {
        this(0, 0);
    }

    public AbstractGenericTableModel(int rowCount, int columnCount) {
        this(new ArrayList(columnCount), rowCount);
    }

    public AbstractGenericTableModel(List columnNames, int rowCount) {
        setData(new ArrayList<>(rowCount), columnNames);
    }

    public AbstractGenericTableModel(List<R> data, List columnNames) {
        setData(data, columnNames);
    }

    public List<R> getRowData() {
        return rows;
    }

    private List nonNullVector(List v) {
        return (v != null) ? v : new ArrayList();
    }

    public void setData(List<R> data, List columnIdentifiers) {
        this.rows = new ArrayList<>(nonNullVector(data));
        this.columnIdentifiers = nonNullVector(columnIdentifiers);
        fireTableStructureChanged();
    }

    public void addRow(R rowData) {
        insertRow(getRowCount(), rowData);
    }

    public void insertRow(int row, R rowData) {
        rows.add(row, rowData);
        fireTableRowsInserted(row, row);
    }

    /**
     * Removes the row at <code>row</code> from the model. Notification of the row being removed will be sent to all the listeners.
     *
     * @param row the row index of the row to be removed
     * @exception ArrayIndexOutOfBoundsException if the row was invalid
     */
    public void removeRow(int row) {
        rows.remove(row);
        fireTableRowsDeleted(row, row);
    }

    public void setColumnIdentifiers(List columnIdentifiers) {
        setData(rows, columnIdentifiers);
    }

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

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

    @Override
    public String getColumnName(int column) {
        Object id = null;
        // This test is to cover the case when
        // getColumnCount has been subclassed by mistake ...
        if (column < columnIdentifiers.size() && (column >= 0)) {
            id = columnIdentifiers.get(column);
        }
        return (id == null) ? super.getColumnName(column)
                        : id.toString();
    }

}

public class ArrayListTableModel extends AbstractGenericTableModel<ArrayList> {

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        List<ArrayList> rows = getRowData();
        return rows.get(rowIndex).get(columnIndex);
    }

}

这将创建两个类，一个是基于“抽象泛型”的模型，它允许您指定支持行的物理数据，另一个是
ArrayListTableModel
，它允许您对单个数据使用
ArrayList

不过，这假设的是，每一行都有相同数量的元素，但不进行检查

我建议您仔细查看更多细节
简单的答案是基于类似于
AbstractTableModel的内容创建自己的

例如

public abstract class AbstractGenericTableModel<R> extends AbstractTableModel {

    protected ArrayList<R> rows;
    protected List columnIdentifiers;

    public AbstractGenericTableModel() {
        this(0, 0);
    }

    public AbstractGenericTableModel(int rowCount, int columnCount) {
        this(new ArrayList(columnCount), rowCount);
    }

    public AbstractGenericTableModel(List columnNames, int rowCount) {
        setData(new ArrayList<>(rowCount), columnNames);
    }

    public AbstractGenericTableModel(List<R> data, List columnNames) {
        setData(data, columnNames);
    }

    public List<R> getRowData() {
        return rows;
    }

    private List nonNullVector(List v) {
        return (v != null) ? v : new ArrayList();
    }

    public void setData(List<R> data, List columnIdentifiers) {
        this.rows = new ArrayList<>(nonNullVector(data));
        this.columnIdentifiers = nonNullVector(columnIdentifiers);
        fireTableStructureChanged();
    }

    public void addRow(R rowData) {
        insertRow(getRowCount(), rowData);
    }

    public void insertRow(int row, R rowData) {
        rows.add(row, rowData);
        fireTableRowsInserted(row, row);
    }

    /**
     * Removes the row at <code>row</code> from the model. Notification of the row being removed will be sent to all the listeners.
     *
     * @param row the row index of the row to be removed
     * @exception ArrayIndexOutOfBoundsException if the row was invalid
     */
    public void removeRow(int row) {
        rows.remove(row);
        fireTableRowsDeleted(row, row);
    }

    public void setColumnIdentifiers(List columnIdentifiers) {
        setData(rows, columnIdentifiers);
    }

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

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

    @Override
    public String getColumnName(int column) {
        Object id = null;
        // This test is to cover the case when
        // getColumnCount has been subclassed by mistake ...
        if (column < columnIdentifiers.size() && (column >= 0)) {
            id = columnIdentifiers.get(column);
        }
        return (id == null) ? super.getColumnName(column)
                        : id.toString();
    }

}

public class ArrayListTableModel extends AbstractGenericTableModel<ArrayList> {

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        List<ArrayList> rows = getRowData();
        return rows.get(rowIndex).get(columnIndex);
    }

}

这将创建两个类，一个是基于“抽象泛型”的模型，它允许您指定支持行的物理数据，另一个是
ArrayListTableModel
，它允许您对单个数据使用
ArrayList

不过，这假设的是，每一行都有相同数量的元素，但不进行检查

我建议您仔细查看以了解更多详细信息。您可以使用。它将支持存储在
数组列表
、
向量
或实现
列表
接口的任何其他类中的数据行

ListTableModel
还基于一个通用的TableModel，允许您将对象添加到模型中的行中。有许多基于行的方法可以方便地使用模型

ListTableModel
提供了一些方法，可用于轻松自定义模型：

setColumnClass–指定各个列的类别，以便表可以使用适当的呈现器/编辑器
setModelEditable–为整个模型指定可编辑属性
setColumnEditable–指定列级别的可编辑属性。此属性将优先于模型可编辑属性
另一个选项是遍历
ArrayList
并将每一行数据复制到
Vector
，然后使用
addRow（…）将
Vector
添加到
DefaultTableModel
方法。
您可以使用。它将支持存储在
数组列表
、
向量
或实现
列表
接口的任何其他类中的数据行

ListTableModel
还基于一个通用的TableModel，允许您将对象添加到模型中的行中。有许多基于行的方法可以方便地使用模型

ListTableModel
提供了一些方法，可用于轻松自定义模型：

setColumnClass–指定各个列的类别，以便表可以使用适当的呈现器/编辑器
setModelEditable–为整个模型指定可编辑属性
setColumnEditable–指定列级别的可编辑属性。此属性将优先于模型可编辑属性
另一个选项是遍历
ArrayList
并将每一行数据复制到
Vector
，然后使用
addRow（…）将
Vector
添加到
DefaultTableModel
方法。
您可以使用。它将支持存储在
数组列表
、
向量
或实现
列表
接口的任何其他类中的数据行

ListTableModel
还基于一个通用的TableModel，允许您将对象添加到模型中的行中。有许多基于行的方法可以方便地使用模型

ListTableModel
提供了一些方法，可用于轻松自定义模型：

setColumnClass–指定各个列的类别，以便表可以使用适当的呈现器/编辑器
setModelEditable–为整个模型指定可编辑属性
setColumnEditable–指定列级别的可编辑属性。此属性将优先于模型可编辑属性
另一个选项是遍历
ArrayList
并将每一行数据复制到
Vector
，然后使用
addRow（…）将
Vector
添加到
DefaultTableModel
方法。
您可以使用。它将支持存储在
数组列表
、
向量
或实现