java - JTable中的数据没有改变

Question

到目前为止我尝试了太多并且阅读了很多东西。对于我的案例仍然找不到任何可行的解决方案。所以这里是交易。在游戏过程中，玩家的金钱不断变化。我想要实现的目标是立即从 JTable 显示金钱，这样玩家只需查看 table 就可以随时跟踪他的金钱。但是，正如你可以想象的那样，我在兑换货币时未能兑换。它只是停留在它开始时的数量。

到目前为止，我得到的是一个精心构建的 JTable，它显示了玩家一开始的初始资金以及我的 JTable 的自定义模型。

由于我相信解决方案依赖于模型和 setValuesAt(Object value, int row, int column)，所以我试图找到一种解决方法。我得到的是一个名为刷新的方法。更具体地说，让我向您展示我的代码的一部分。

这是构造函数中的 rowData 数组，我用它来在游戏开始时显示初始资金:

rowData = new Object[][]{
                {GameFlow.getPlayer1().getName(), "Pink", GameFlow.getPlayer1().getMoney()},
                {GameFlow.getPlayer2().getName(), "Blue", GameFlow.getPlayer2().getMoney()},
                {GameFlow.getPlayer3().getName(), "Green", GameFlow.getPlayer3().getMoney()},
                {GameFlow.getPlayer4().getName(), "Red", GameFlow.getPlayer4().getMoney()},
        };

说到这里，我还需要向您展示以下两个函数，setValueAt 和refresh(refresh 是我刚刚为简单更新更改而编写的一个方法):

public void setValueAt(Object value, int row, int col) {
    rowData[row][col] = value;
    fireTableCellUpdated(row, col);
}
public void refresh(){
    for (int i = 0; i < 4; i++) {
        setValueAt(GameFlow.getPlayer1().getMoney(), i, 2);
    }
}

在这里，在刷新中，我只想更改第二(2nd)行，因为前两行是静态的并且永远不会改变。另外，for 循环中的数字 4 是玩家的数量，因此 4 保存的是行数。

您可以在下面找到我的整个表格模型代码:

import javax.swing.table.AbstractTableModel;

public class MonopolyTableModel extends AbstractTableModel {
    private String[] columnNames = {
            "Name",
            "Color",
            "Money",
    };
    private Object[][] rowData;

    public MonopolyTableModel() {
        rowData = new Object[][]{
                {GameFlow.getPlayer1().getName(), "Pink", GameFlow.getPlayer1().getMoney()},
                {GameFlow.getPlayer2().getName(), "Blue", GameFlow.getPlayer2().getMoney()},
                {GameFlow.getPlayer3().getName(), "Green", GameFlow.getPlayer3().getMoney()},
                {GameFlow.getPlayer4().getName(), "Red", GameFlow.getPlayer4().getMoney()},
        };
    }
    @Override
    public int getRowCount() {
        return rowData.length; 
    }
    @Override
    public int getColumnCount() {
        return columnNames.length;
    }
    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        return rowData[rowIndex][columnIndex];
    }

    public void setValueAt(Object value, int row, int col) {
        rowData[row][col] = value;
        fireTableCellUpdated(row, col);
    }

    public String getColumnName(int columnIndex) {
        return columnNames[columnIndex];
    }

    public void refresh(){
        for (int i = 0; i < 4; i++) {
            setValueAt(GameFlow.getPlayer1().getMoney(), i, 2);
        }
    }

}

这就是我在 Gui 类中使用的方式:

MonopolyTableModel monoModel = (MonopolyTableModel) dataTable.getModel();
monoModel.refresh();

希望这些足以展示，如果需要，我可以展示更多，但由于这是一个学校项目，我避免展示太多。

Answer 1

根据您提供的断章取义的代码，很难找出问题所在。

每当我处理 JTable 时，我都会使用它来对物理数据进行建模，在您的例子中，这就是 Player 对象。这样，如果 Player 在表外部被修改，您只需触发模型更新即可让表刷新值。同样，您也可以将一些功能集中到表中，并使用它直接修改 Player 对象。

这样，模型和数据始终保持同步(即使显示不同步)

在此示例中，有两种更新模型/表的方法。

首先，您可以更新 Player 对象并要求模型“刷新”给定的播放器，例如...

Player player = model.getPlayerAt(selectedRow);
player.setMoney(player.getMoney() + 10);
model.update(player);

或者您可以让模型通过 setValueAt 方法更新 Player...

Player player = model.getPlayerAt(selectedRow);
model.setValueAt(player.getMoney() - 10, selectedRow, 1);

作为一个可运行的示例...

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;

public class Test {

    public static void main(String[] args) {
        new Test();
    }

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        private PlayerTableModel model;

        public TestPane() {
            List<Player> players = new ArrayList<>(5);
            players.add(new Player("Han Solo", 100d));
            players.add(new Player("Dark Vadar", 100d));
            players.add(new Player("R2-D2", 100d));
            players.add(new Player("Darth Maul", 100d));
            players.add(new Player("Jawa", 100d));

            setLayout(new BorderLayout());
            model = new PlayerTableModel(players);
            JTable table = new JTable(model);
            add(new JScrollPane(table));

            JPanel actions = new JPanel();
            JButton add = new JButton("+");
            JButton subtract = new JButton("-");

            actions.add(add);
            actions.add(subtract);

            add.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    int selectedRow = table.getSelectedRow();
                    if (selectedRow >= 0) {
                        selectedRow = table.convertRowIndexToModel(selectedRow);
                        Player player = model.getPlayerAt(selectedRow);
                        player.setMoney(player.getMoney() + 10);
                        model.update(player);
                    }
                }
            });
            subtract.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    int selectedRow = table.getSelectedRow();
                    if (selectedRow >= 0) {
                        selectedRow = table.convertRowIndexToModel(selectedRow);
                        Player player = model.getPlayerAt(selectedRow);
                        model.setValueAt(player.getMoney() - 10, selectedRow, 1);
//                      player.setMoney(player.getMoney() - 10);
//                      model.update(player);
                    }
                }
            });

            add(actions, BorderLayout.SOUTH);

        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }

        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            g2d.dispose();
        }

    }

    public static class PlayerTableModel extends AbstractTableModel {

        protected static final String COLUMNN_NAMES[] = {"Name", "Money"};

        private List<Player> players;

        public PlayerTableModel(List<Player> players) {
            this.players = new ArrayList(players);
        }

        public Player getPlayerAt(int row) {
            return players.get(row);
        }

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

        @Override
        public int getColumnCount() {
            return COLUMNN_NAMES.length;
        }

        @Override
        public String getColumnName(int column) {
            return COLUMNN_NAMES[column];
        }

        @Override
        public Object getValueAt(int rowIndex, int columnIndex) {
            Player player = players.get(rowIndex);
            Object value = null;
            switch (columnIndex) {
                case 0:
                    value = player.getName();
                    break;
                case 1:
                    value = player.getMoney();
                    break;
            }
            return value;
        }

        @Override
        public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
            if (columnIndex == 1) {
                Player player = players.get(rowIndex);
                player.setMoney((double)aValue);
                super.setValueAt(aValue, rowIndex, columnIndex);
                fireTableCellUpdated(rowIndex, columnIndex);
            }
        }

        public void update(Player player) {
            int row = players.indexOf(player);
            fireTableRowsUpdated(row, row);
        }

    }

    public class Player {

        private String name;
        private double money;

        public Player(String name, double money) {
            this.name = name;
            this.money = money;
        }

        public double getMoney() {
            return money;
        }

        public String getName() {
            return name;
        }

        public void setMoney(double money) {
            this.money = money;
        }

    }

}

重点是，你的玩家和你的模型之间不应该有这样的脱节，即使你需要将玩家包装到另一个对象中，以便你可以扩展你想要显示的属性，至少这样，当您请求一个值时，它与该对象实际具有的值相同，并且当您设置它时，它已被设置在同一个对象上。