ソースコード上の値ではなくて自分で編集した値を使って空白セルを用いたJTableのグループ化を実現したいんですが

Question

前提

https://ateraimemo.com/Swing/RowGroupInTable.html
このサイトの参考リンクのstackoverflowにある回答欄のソースコードについて

やりたいこと

コピペして何回か実行してみました。すると問題点が出てきました
すでに登録？保存？した値（例addMyData(model, new MyData("Tom", 17, "Book1"));
についてはレンダラーの機能で表現できていると思うのですが
新しいデータを追加してソートしたい場合には
新しい行を追加して空のセルの中に編集した値を入れるという風に考えると思います
しかしうまい方法が思い浮かびません

自分の頭の中

まず新しい行を追加するにはaddRowメソッドで追加するしかないので
model.addRow();
でも空の行を追加したいので
model.addRow(new Object[]);
と書くけどその行に新規のデータを手打ちしてソートしようにもモデルと紐づけられてないのでこれは無理
じゃあ、MyDataクラスのようにコンストラクタとゲッターを作ってそれを利用するか？いや待てよ
自分が編集したらこのコンストラクタは生成されないから意味ないだろ？

諦めきれない

一か月ほど前、似たような質問でベストアンサーの方に
「> 空っぽの行を追加して値を入力して保存する

コード的には逆のほうが分かり易いと思います。
つまり、追加ボタンを押したら ( 例えば ) 入力用のダイアログを出して日付や氏名等を入力し、 OK が押されたらそのデータで TableModel に addRow するということです。」
という回答をしてもらったんですが
その回答は確かにコードを作る側として簡単そうなんですけど
いざプログラムが完成したときに使う側としては一々ダイアログを出して入力する作業がめんどくさそうなんですよ
今ここで躓いています何か打開する方法を教えてください

追記
つまり何が言いたいのかというと
手打ちした値を何かに保存してそれをモデルと関連付けてソートしてさらにグループ化を表現したい（ダイアログの方法以外で
ということです

該当のソースコード

import java.awt.*;
import java.util.*;
import java.util.List;
import javax.swing.*;
import javax.swing.table.*;

public class RowGroupInTableTest {
  private JComponent makeUI() {
    String[] titles = new String[] {"Name", "Last job duration", "Book #"};
    DefaultTableModel model = new DefaultTableModel(null, titles) {
      @Override public Class<?> getColumnClass(int column) {
        return MyData.class;
      }
    };
    addMyData(model, new MyData("Tom",     17, "Book1"));
    addMyData(model, new MyData("Tom",     23, "Book2"));
    addMyData(model, new MyData("Tom",     25, "Book3"));
    addMyData(model, new MyData("Polazzo", 41, "Book1"));
    addMyData(model, new MyData("Polazzo", 45, "Book2"));
    addMyData(model, new MyData("Polazzo", 12, "Book3"));
    addMyData(model, new MyData("Anna",     1, "Book3"));
    addMyData(model, new MyData("Anna",    33, "Book5"));

    JTable table = new JTable(model);
    table.setFillsViewportHeight(true);
    table.setDefaultRenderer(MyData.class, new MyRenderer());

    TableRowSorter<TableModel> sorter = new TableRowSorter<TableModel>(table.getModel());
    Comparator<MyData> c = Comparator.comparing(MyData::getName);
    sorter.setComparator(0, c);
    sorter.setComparator(1, c.thenComparing(Comparator.comparingInt(MyData::getDuration)));
    sorter.setComparator(2, c.thenComparing(Comparator.comparing(MyData::getBook)));
    table.setRowSorter(sorter);

    return new JScrollPane(table);
  }
  private static void addMyData(DefaultTableModel model, MyData data) {
    //Omission work...
    model.addRow(Collections.nCopies(3, data).toArray());
  }
  public static void main(String[] args) {
    EventQueue.invokeLater(() -> {
      JFrame f = new JFrame();
      f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
      f.getContentPane().add(new RowGroupInTableTest().makeUI());
      f.setSize(320, 240);
      f.setLocationRelativeTo(null);
      f.setVisible(true);
    });
  }
}

class MyData {
  private final String name;
  private final int duration;
  private final String book;
  protected MyData(String name, int duration, String book) {
    this.name = name;
    this.duration = duration;
    this.book = book;
  }
  public String getName() {
    return name;
  }
  public int getDuration() {
    return duration;
  }
  public String getBook() {
    return book;
  }
}

class MyRenderer implements TableCellRenderer {
  TableCellRenderer def = new DefaultTableCellRenderer();
  @Override public Component getTableCellRendererComponent(
      JTable table, Object value, boolean isSelected, boolean hasFocus,
      int row, int column) {
    JLabel orig = (JLabel) def.getTableCellRendererComponent(
        table, value, isSelected, hasFocus, row, column);
    orig.setHorizontalAlignment(SwingConstants.LEFT);
    MyData data = (MyData) value;
    switch (table.convertColumnIndexToModel(column)) {
    case 0:
      String str = data.getName();
      if (row > 0) {
        //if (table.getModel().getValueAt(row-1, column).equals(value)) {
        //Since it compares with the value of the previous line on the display,
        //table.getModel() is not needed
        MyData prev = (MyData) table.getValueAt(row - 1, column);
        if (Objects.equals(prev.getName(), str)) {
          str = " ";
        }
      }
      orig.setText(str);
      break;
    case 1:
      orig.setHorizontalAlignment(SwingConstants.RIGHT);
      orig.setText("" + data.getDuration());
      break;
    case 2:
      orig.setText(data.getBook());
      break;
    default:
      break;
    }
    return orig;
  }
}

補足情報（FW/ツールのバージョンなど）

All in One パッケージ　Eclipse 2021

Comments

[TN8001]

回答で解決したなら「解決済」にしてください。
[ヘルプ | 質問を解決済みにしたい](https://teratail.com/help#resolve-question)

解決していないのであれば、問題点・わからない点等をコメントするか質問を編集してください。

Answer 1

諦めきれない

っておっしゃってるので、いろいろ試しては頭にきてやめてを繰り返していました^^;
これめちゃくちゃ悩ましいですね...（実際やってみないと難しさがわからないですね）

JTableで同一内容のセルを空表示にしてグループ化を表現する - Java Swing Tips
まず参考リンクでなぜ変則的なモデルになっているかを、把握しておく必要があります。

// 普通はこう持つ
Object[][] data = { { "Tom", 17, "Book1", }, { "Tom", 23, "Book2", }, };

// しかしこうなっている
var d1 = new MyData("Tom", 17, "Book1");
var d2 = new MyData("Tom", 23, "Book2");
Object[][] data = { { d1, d1, d1, }, { d2, d2, d2, }, };

なぜこんなことになっているかというと、普通の持ち方だとTableRowSorterに文字列等しか渡ってこず、ほかのカラムの情報が取れないからです。
そのためすべてのセルにMyDataを入れることによって、TableRowSorterで複数カラムによるソートを実現しています。

この状態で編集するにはCellRendererと、対になるCellEditorを作る必要があります。
やってやれないことはないですが、実現したいことに比べあまりに面倒です。

発想を変えてまともなモデルを作ったうえで、ソートのほうをどうにかすることにしました^^
空表示にするには常に先頭のカラムが、（プライマリで）ソートされていなければなりません。
これはSortKeysの0番目は、常にColumnが0ということになります。
DefaultRowSorter#setSortKeys (Java Platform SE 8 )
そのためどのカラムをクリックしても左端にしか▲がでませんが、意味からすると全く正しいです。

新しい行を追加して空のセルの中に編集した値を入れるという風に考えると思います

これC#メインの私からすると当たり前なんですけど（DataGridViewとか標準でそういう作り）、Javaは（Swing・JavaFXどちらも）そういう思想ではないようですね...

手打ちした値を何かに保存してそれをモデルと関連付けてソートしてさらにグループ化を表現したい（ダイアログの方法以外で

13 表ビュー(リリース8)
これみたいに同じ画面内に、テキストフィールドがあるのでもダメですか？

空行を追加するボタンを置くなら、テキストフィールドがあっても大差ない気がします。
かといって「入力を感知して常に空行を出し続ける」のは、面倒そうなのは明らかなのでやる気はないです^^;

import javax.swing.*;
import javax.swing.table.*;
import java.awt.*;
import java.util.*;
import java.util.List;


public class RowGroupInTableTest extends JFrame {
    public static void main(String[] args) {
        new RowGroupInTableTest().setVisible(true);
    }

    private final MyDataModel model = new MyDataModel(new String[]{ "Name", "Last job duration", "Book #" });

    RowGroupInTableTest() {
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setSize(320, 240);
        setLocationRelativeTo(null);
        add(makeTable());
        add(makeInput(), BorderLayout.SOUTH);
    }

    private JComponent makeTable() {
        var d = new MyData[]{
            new MyData("Tom", 17, "Book1"),
            new MyData("Tom", 3, "Book2"),
            new MyData("Tom", 25, "Book3"),
            new MyData("Polazzo", 41, "Book1"),
            new MyData("Polazzo", 45, "Book2"),
            new MyData("Polazzo", 12, "Book3"),
            new MyData("Anna", 1, "Book3"),
            new MyData("Anna", 33, "Book5"),
        };
        model.addMyData(d);

        var table = new JTable(model);

        var renderer = new DefaultTableCellRenderer() {
            @Override public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                if (0 < row && Objects.equals(value, table.getValueAt(row - 1, column))) {
                    value = "";
                }
                return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
            }
        };
        table.getColumnModel().getColumn(0).setCellRenderer(renderer);

        var sorter = new TableRowSorter<>(table.getModel()) {
            // いまいちだがうまく制御が利かなかったため自前管理
            private final SortKey[] keys = new SortKey[]{
                new SortKey(0, SortOrder.ASCENDING),
                new SortKey(1, SortOrder.ASCENDING),
                new SortKey(2, SortOrder.ASCENDING),
            };

            {
                // なくてもいいのだがデフォはSortOrder.UNSORTEDなのでわかりにくいかなと
                super.setSortKeys(Arrays.asList(keys));
                setSortsOnUpdates(true);
            }

            @Override public void setSortKeys(List<? extends SortKey> sortKeys) {
                // オリジナルとソートが同じではないがこっちのほうが好み
                var c = sortKeys.get(0).getColumn();
                var o = keys[c].getSortOrder() == SortOrder.ASCENDING ? SortOrder.DESCENDING : SortOrder.ASCENDING;
                keys[c] = new SortKey(keys[c].getColumn(), o);

                var newKeys = new ArrayList<SortKey>();
                newKeys.add(keys[0]);
                newKeys.add(keys[c]);
                super.setSortKeys(newKeys);
            }
        };
        table.setRowSorter(sorter);

        return new JScrollPane(table);
    }

    private JComponent makeInput() {
        var inner = new JPanel(new GridLayout(1, 3));
        var nameTextField = new JTextField();
        inner.add(nameTextField);
        var durationTextField = new JTextField();
        durationTextField.setHorizontalAlignment(JTextField.RIGHT);
        durationTextField.setInputVerifier(new InputVerifier() {
            @Override public boolean verify(JComponent input) {
                try {
                    Integer.parseInt(((JTextField) input).getText());
                    input.setBorder(BorderFactory.createEmptyBorder(1, 1, 1, 1));
                    return true;
                } catch (NumberFormatException e) {
                    input.setBorder(BorderFactory.createLineBorder(Color.RED));
                    return false;
                }
            }
        });
        inner.add(durationTextField);
        var bookTextField = new JTextField();
        inner.add(bookTextField);

        var outer = new JPanel(new BorderLayout());
        outer.add(inner, BorderLayout.CENTER);
        var button = new JButton("add");
        button.addActionListener(x -> {
            var name = nameTextField.getText();
            var duration = Integer.parseInt(durationTextField.getText());
            var book = bookTextField.getText();
            model.addMyData(new MyData(name, duration, book));
        });
        getRootPane().setDefaultButton(button);
        outer.add(button, BorderLayout.EAST);

        return outer;
    }

    // 別にclassでいいんですけどなんとなくｗ
    record MyData(String name, int duration, String book) { }

    static class MyDataModel extends AbstractTableModel {
        private final List<MyData> data = new ArrayList<>();
        private final String[] columns;

        public MyDataModel(String[] titles) { columns = titles; }

        public void addMyData(MyData myData) {
            var rowIndex = data.size();
            data.add(myData);
            fireTableRowsInserted(rowIndex, rowIndex);
            fireTableRowsUpdated(0, data.size() - 1); // live sorting
        }

        public void addMyData(MyData[] myDataArray) {
            var firstRow = data.size();
            Collections.addAll(data, myDataArray);
            var lastRow = data.size() - 1;
            fireTableRowsInserted(firstRow, lastRow);
        }

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

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

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

        @Override public Class<?> getColumnClass(int columnIndex) {
            // Switch式いいですね^^
            return switch (columnIndex) {
                case 0, 2 -> String.class;
                case 1 -> Integer.class;
                default -> throw new IndexOutOfBoundsException(columnIndex);
            };
        }

        @Override public boolean isCellEditable(int rowIndex, int columnIndex) { return true; }

        @Override public Object getValueAt(int rowIndex, int columnIndex) {
            var d = data.get(rowIndex);
            return switch (columnIndex) {
                case 0 -> d.name();
                case 1 -> d.duration();
                case 2 -> d.book();
                default -> throw new IndexOutOfBoundsException(columnIndex);
            };
        }

        @Override public void setValueAt(Object val, int rowIndex, int columnIndex) {
            var d = data.get(rowIndex);
            switch (columnIndex) {
                case 0 -> data.set(rowIndex, new MyData((String) val, d.duration(), d.book()));
                case 1 -> data.set(rowIndex, new MyData(d.name(), (Integer) val, d.book()));
                case 2 -> data.set(rowIndex, new MyData(d.name(), d.duration(), (String) val));
                default -> throw new IndexOutOfBoundsException(columnIndex);
            }
            fireTableCellUpdated(rowIndex, columnIndex);
        }

        public MyData getMyData(int rowIndex) { return data.get(rowIndex); }

        public List<MyData> getMyDataList() { return Collections.unmodifiableList(data); }
    }
}

ソート法がオリジナル（どのカラムをクリックしても左端も変わる）と違いますが、私はこっち（2個目・3個目のクリックでは左端は動かない）が好みです^^

Comments

[jimbe]

私も RowSorter を弄っていたのですが、落とし所がなかなか決まらず。
後は JTable 自体を弄るくらいでしょうか。

[rokkunroru]

自分の理想はこれに近いかもです。お二人ともありがとうございます

Answer 2

仰る通り、追加修正等の度にダイアログが出てくるのは結構面倒です。ですので EXCEL シートのように直接書き込めた方が「使う側にとっては簡単」です。
そしてダイアログを出すほうが「コードを作る側として簡単そう」というのもその通りです。
そこから逆に言いますと、使う側にとっては簡単になる「直接書き込み」はコードを作る側にとっては(コード的にも、データの整合性的にも)「簡単では無く」なります。

例えば JTable のセルの値を更新するテーブルモデルの実装方法 のような記事をお読みになってみては如何でしょうか。

---

テーブルモデルを AbstractTableModel から作り、編集可能としてみました。(編集可能状態になるだけで、実際には編集・追加の処理が入っていませんので、編集・追加は出来ません。)
"Name" の列は OmittableString.class とすることでレンダラを使うようにし、編集可能とする為にエディタを設定しています。(name の実体は String なので特別なことはしていません。)
グループ化・ソートをオリジナル(?)に合わせる為に、 Duration・Book クラスを作って name を参照できるようにしました。
その為、全列にレンダラ・エディタが必要になりました・・・。

大きくなってきたので Row クラスを別ファイルとしました。
Insert キー / Delete キーで 行の追加・削除をしてみました。

RowGroupInTableTest2.java

public class RowGroupInTableTest2 extends JFrame {
  public static void main(String[] args) {
    EventQueue.invokeLater(() -> new RowGroupInTableTest2().setVisible(true));
  }

  RowGroupInTableTest2() {
    super("RowGroupInTableTest2");
    setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    setSize(320, 240);
    setLocationRelativeTo(null);

    MyTableModel model = new MyTableModel();
    model.add(new MyData("Tom",     17, "Book1"));
    model.add(new MyData("Tom",     23, "Book2"));
    model.add(new MyData("Tom",     25, "Book3"));
    model.add(new MyData("Polazzo", 41, "Book1"));
    model.add(new MyData("Polazzo", 45, "Book2"));
    model.add(new MyData("Polazzo", 12, "Book3"));
    model.add(new MyData("Anna",     1, "Book3"));
    model.add(new MyData("Anna",    33, "Book5"));

    JTable table = new JTable(model);
    table.setFillsViewportHeight(true);
    table.setDefaultRenderer(Row.Name.class, new Row.NameRenderer());
    table.setDefaultEditor(Row.Name.class, new DefaultCellEditor(new JTextField()));
    table.setDefaultRenderer(Row.Duration.class, new Row.DurationRenderer());
    table.setDefaultEditor(Row.Duration.class, new Row.DurationEditor());
    table.setDefaultRenderer(Row.Book.class, new Row.BookRenderer());
    table.setDefaultEditor(Row.Book.class, new Row.BookEditor());

    table.setRowSorter(new TableRowSorter<TableModel>(model));

    setAction(table, KeyStroke.getKeyStroke(KeyEvent.VK_INSERT, 0), new AddAction());
    setAction(table, KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0), new DeleteAction());

    getContentPane().add(new JScrollPane(table));
  }

  private static void setAction(JTable table, KeyStroke key, Action a) {
    table.getActionMap().put(a, a);

    InputMap im;
    im = table.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
    im.put(key, a);
    im = table.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
    im.put(key, a);
  }

  static class AddAction extends AbstractAction {
    public AddAction() {
      super("table-row-add");
    }

    @Override
    public void actionPerformed(ActionEvent e) {
      JTable table = (JTable)e.getSource();
      MyTableModel model = (MyTableModel)table.getModel();
      model.insert(table.getRowCount(), new MyData("", 0, ""));
    }
  }

  public class DeleteAction extends AbstractAction {
    public DeleteAction() {
      super("table-row-del");
    }

    @Override
    public void actionPerformed(ActionEvent e) {
      JTable table = (JTable)e.getSource();
      int[] rows = table.getSelectedRows();
      for(int i=0; i<rows.length; i++) {
        rows[i] = table.convertRowIndexToModel(rows[i]);
      }

      MyTableModel model = (MyTableModel)table.getModel();
      for(int i=rows.length-1; i>=0; i--) {
        model.remove(rows[i]);
      }
    }
  }
}

class MyData {
  final String name;
  final int duration;
  final String book;

  MyData(String name, int duration, String book) {
    this.name = name;
    this.duration = duration;
    this.book = book;
  }
}

class MyTableModel extends AbstractTableModel {
  abstract private class Column {
    final String title;
    Column(String title) {
      this.title = title;
    }
    abstract Object getValueAt(Row row);
    abstract Class<?> getColumnClass();
    abstract Row setRowAt(Row row, Object aValue);
  }
  private Column[] columns = {
      new Column("Name") {
        Object getValueAt(Row row) { return row.name; }
        Class<?> getColumnClass() { return Row.Name.class; }
        Row setRowAt(Row row, Object aValue) { return row.setName((String)aValue); }              
      },
      new Column("Last job duration") {
        Object getValueAt(Row row) { return row.duration; }
        Class<?> getColumnClass() { return Row.Duration.class; }
        Row setRowAt(Row row, Object aValue) { return row.setDuration((Integer)aValue); }              
      },
      new Column("Book #") {
        Object getValueAt(Row row) { return row.book; }
        Class<?> getColumnClass() { return Row.Book.class; }
        Row setRowAt(Row row, Object aValue) { return row.setBook((String)aValue); }              
      }
  };

  private List<Row> rowList = new ArrayList<>();

  void add(MyData data) {
    insert(rowList.size(), data);
  }

  void insert(int rowIndex, MyData data) {
    rowList.add(rowIndex, new Row(data.name, data.duration, data.book));
    fireTableRowsInserted(rowIndex, rowIndex);
  }

  void remove(int rowIndex) {
    rowList.remove(rowIndex);
    fireTableRowsDeleted(rowIndex, rowIndex);
  }

  List<MyData> getList() {
    List<MyData> list = new ArrayList<>();
    for(Row row : rowList) list.add(row.getMyData());
    return list;
  }

  @Override
  public String getColumnName(int column) {
    return columns[column].title;
  }

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

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

  @Override
  public Object getValueAt(int rowIndex, int columnIndex) {
    return columns[columnIndex].getValueAt(rowList.get(rowIndex));
  }

  @Override
  public Class<?> getColumnClass(int columnIndex) {
    return columns[columnIndex].getColumnClass();
  }

  @Override
  public boolean isCellEditable(int rowIndex, int columnIndex) {
    return true;
  }

  @Override
  public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
    rowList.set(rowIndex, columns[columnIndex].setRowAt(rowList.get(rowIndex), aValue));
  }
}

Row.java

class Row {
  final String name;
  final Duration duration;
  final Book book;

  Row(String name, int duration, String book) {
    this.name = name;
    this.duration = new Duration(duration);
    this.book = new Book(book);
  }

  Row setName(String name) {
    return new Row(name, duration.value, book.value);
  }
  Row setDuration(int duration) {
    return new Row(name, duration, book.value);
  }
  Row setBook(String book) {
    return new Row(name, duration.value, book);
  }
  MyData getMyData() {
    return new MyData(name, duration.value, book.value);
  }

  class Name {
  }
  static class NameRenderer extends DefaultTableCellRenderer {
    @Override
    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
      //直前の行と同じ内容なら省略する
      value = row>0 && Objects.equals(table.getValueAt(row-1, column), value) ? "" : value;

      return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
    }
  }

  class Duration implements Comparable<Duration> {
    final Integer value;
    private Duration(int value) {
      this.value = value;
    }
    private String getName() { return Row.this.name; }
    @Override
    public int compareTo(Duration o) {
      int result = getName().compareTo(o.getName());
      return result == 0 ? value.compareTo(o.value) : result; 
    }
  }

  static class DurationRenderer extends DefaultTableCellRenderer {
    DurationRenderer() {
      super();
      setHorizontalAlignment(SwingConstants.RIGHT);
    }
    @Override
    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
      return super.getTableCellRendererComponent(table, ((Duration)value).value, isSelected, hasFocus, row, column);
    }
  }
  static class DurationEditor extends AbstractCellEditor implements TableCellEditor {
    private JTextField component = new JTextField();
    DurationEditor() {
      component.setHorizontalAlignment(JTextField.RIGHT);
    }
    @Override
    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
      Duration duration = (Duration)value;
      component.setText(""+duration.value);
      return component;
    }
    @Override
    public Object getCellEditorValue() {
      try {
        return Integer.parseInt(component.getText());
      } catch(NumberFormatException e) {
        return 0;
      }
    }
  }

  class Book implements Comparable<Book> {
    final String value;
    private Book(String value) {
      this.value = value;
    }
    private String getName() { return Row.this.name; }
    @Override
    public int compareTo(Book o) {
      int result = getName().compareTo(o.getName());
      return result == 0 ? value.compareTo(o.value) : result; 
    }
  }

  static class BookRenderer extends DefaultTableCellRenderer {
    @Override
    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
      return super.getTableCellRendererComponent(table, ((Book)value).value, isSelected, hasFocus, row, column);
    }
  }

  static class BookEditor extends AbstractCellEditor implements TableCellEditor {
    private JTextField component = new JTextField();
    @Override
    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
      Book book = (Book)value;
      component.setText(book.value);
      return component;
    }
    @Override
    public Object getCellEditorValue() {
      return component.getText();
    }
  }
}

Comments

[rokkunroru]

すみません、編集可能か不可能かの件で質問したいのですが
https://java.keicode.com/lib/swing-jtable-2.php
の下の
「見栄えは前回と同様です。しかし、前回と違うのは今度は全てのセルが編集不可になっていることです。

これはなぜかというと、あるセルを編集可とするか編集不可とすべきかもテーブルモデルクラスで決めることです。しかし、 今回は明示的に編集可としていないので、編集不可となります。

前回 JTable のコンストラクタにデータとカラム名を渡したときは、実は内部的に自動的にデフォルトのテーブルモデルオブジェクトが作成されます。 （その名もズバリ DefaultTableModel というクラスのオブジェクトです。）その DefaultTableModel では全てのセルを編集可としているので、JTable は全てのセルを編集可としているということです。」
という文があるのですが
ならなぜ該当のソースコードはDefaultTableModel を使っているにもかかわらず編集不可能なのでしょうか

[jimbe]

「該当のソースコード」と仰っているのは TableTest13 のことでしょうか。
TableTest13 のモデル MyTableModel1 は TableTest13 の上で紹介されているコードで、 DefaultTableModel では無く AbstractTableModel です。
AbstractTableModel の isCellEditable メソッドは常に false を返します。

AbstractTableModel.isCellEditable
https://docs.oracle.com/javase/jp/8/docs/api/javax/swing/table/AbstractTableModel.html#isCellEditable-int-int-

DefaultTableModel.isCellEditable
https://docs.oracle.com/javase/jp/8/docs/api/javax/swing/table/DefaultTableModel.html#isCellEditable-int-int-

[rokkunroru]

そちらではなくて
addMyData(model, new MyData("Tom", 17, "Book1"));
addMyData(model, new MyData("Tom", 23, "Book2"));
がある方のソースコードです分かりづらくて申し訳ないです

[jimbe]

失礼しました、ご質問のコードのほうですね。
それは恐らく getColumnClass で MyData.class を返しているからだと思います。
JTable セルの編集には CellEditor が使われ、それは基本的なクラス毎 (String や Integer 、Boolean 等) には予め用意されており、 getColumnClass の返すクラスによって選択・使用されます。
が、 MyData 用のエディタは当然ありませんので、編集出来ません。
CellRenderer のように CellEditor も作成・設定する必要があると思います。

[jimbe]

コード変更したら 10000万文字をぎりぎり超えたようで、import 省略しました。

[TN8001]

> Insert キー / Delete キーで 行の追加・削除をしてみました。

なるほどその手がありましたね。
マウス人間なんで全く考えもしませんでした^^;

> コード変更したら 10000万文字をぎりぎり超えたようで、import 省略しました。

１万字ですねｗ
調子に乗ってコードを書いていると、意外とあっさり行ってしまいますよね。

私は今回はJTableへのヘイトがたまって、そういう状態にはなっていませんが^^;

[jimbe]

Insert/Delete は本来(?)ならメニューのショートカットとしてですが、メニューの実装は提示出来なさそうです。

10000万…それだけあれば…ご指摘有難う御座います orz
コード400行位でいっぱいですから、冗長気味の java では少し大きくなるだけでも厳しいです。

Swing も、更新があった当時でもどこか中途半端で、結局そのままとなってしまいましたね。