Sélection incorrect JXTable

Bonjour à tous ;),

J'aurai voulu savoir si quelqu'un pouvait m'éclairer dans le fonctionnement du composant JXtable. Effectivement, je crée une simple JXtable et lorsque l'utilisateur sélectionne une ligne l’étudiant en question est alors ajouté comme objet étudiant courant dans mon manager.

Le problème est lorsque l'on effectue un tri, la JXTable affiche bien la liste d’étudiant trié mais si on sélectionne une ligne, l’étudiant sélectionné est celui qui se trouvait sur cette ligne avant le tri.

Voici mon code :

La classe Etudiant qui représente un étudiant basique:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package testjxtable;
 
public class Student {
 
    private String firstName, lastName;
    private int id;
 
    public Student() {
        firstName = "First Name";
        lastName = "Last Name";
        id = -1;
    }
 
    public Student(String firstName, String LastName, int id) {
        this.firstName = firstName;
        this.lastName = LastName;
        this.id = id;
    }
 
    public String getFirstName() {
        return firstName;
    }
 
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
 
    public String getLastName() {
        return lastName;
    }
 
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
 
    public int getID() {
        return id;
    }
 
    public void setID(int id) {
        this.id = id;
    }
 
    @Override
    public String toString(){
        return "First Name: "+firstName+" Last Name: "+lastName+" id: "+ id;
    }
}

La classe StudentListModel qui représentele model de ma JXTable:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
package testjxtable;
 
import java.util.ArrayList;
import javax.swing.table.AbstractTableModel;
 
public class StudentListModel extends AbstractTableModel {
 
    private ArrayList<Student> studentList;
    public final String COLUMN_NAME_ID = "ID";
    public final String COLUMN_NAME_FIRSTNAME = ("First Name:");
    public final String COLUMN_NAME_LASTNAME = ("Last Name:");
 
    public static final int COLUMN_NUMBER_ID = 0;
    public static final int COLUMN_NUMBER_FIRSTNAME = 1;
    public static final int COLUMN_NUMBER_LASTNAME = 2;
    public static final int COLUMN_COUNT = 3;
 
    public StudentListModel(ArrayList<Student> studentList) {
        super();
        this.studentList = studentList;
    }
 
    public Student getSelectedStudent(int rowIndex) {
        return studentList.get(rowIndex);
    }
 
    @Override
    public int getRowCount() {
        return studentList.size();
    }
 
    @Override
    public int getColumnCount() {
        return COLUMN_COUNT;
    }
 
    @Override
    public boolean isCellEditable(int rowIndex, int colIndex) {
        return false;
 
    }
 
    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        if (!studentList.isEmpty()) {
            Student student = studentList.get(rowIndex);
            switch (columnIndex) {
                case COLUMN_NUMBER_ID:
                    return student.getID();
                case COLUMN_NUMBER_FIRSTNAME:
                    return student.getFirstName();
                case COLUMN_NUMBER_LASTNAME:
                    return student.getLastName();
                default:
                    return "";
            }
        } else {
            return "";
        }
    }
 
    @Override
    public Class getColumnClass(int column) {
        return getValueAt(0, column).getClass();
    }
 
    @Override
    public String getColumnName(int columnIndex) {
        switch (columnIndex) {
            case COLUMN_NUMBER_ID:
                return COLUMN_NAME_ID;
            case COLUMN_NUMBER_FIRSTNAME:
                return COLUMN_NAME_FIRSTNAME;
            case COLUMN_NUMBER_LASTNAME:
                return COLUMN_NAME_LASTNAME;
            default:
                return "";
        }
    }
    public ArrayList<Student> getStudentList() {
        return studentList;
    }
 
}

Le panel qui contient la JXtable:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
package testjxtable;
 
import javax.swing.JFrame;
 
public class StudentListPanel extends javax.swing.JPanel {
 
    private StudentManager studentManager = StudentManager.getInstance();
    private StudentListModel studentListModel;
 
    public StudentListPanel() {
 
        studentListModel = studentManager.getStudentListModel();
        generateTestStudentList();
        initComponents();
        studentTable.setColumnControlVisible(true);
        studentTable.getSelectionModel().addListSelectionListener(studentManager.createStudentSelectionListener(studentTable));
        studentTable.packAll();
    }
 
    private void generateTestStudentList() {
 
        Student student1 = new Student();
        student1.setFirstName("firstName1");
        student1.setLastName("lastName1");
        student1.setID(1);
        studentManager.addStudent(student1);
 
        Student student2 = new Student();
        student2.setFirstName("firstName2");
        student2.setLastName("lastName2");
        student2.setID(2);
        studentManager.addStudent(student2);
 
        Student student3 = new Student();
        student3.setFirstName("firstName3");
        student3.setLastName("lastName3");
        student3.setID(3);
        studentManager.addStudent(student3);
 
        Student student4 = new Student();
        student4.setFirstName("firstName4");
        student4.setLastName("lastName4");
        student4.setID(4);
        studentManager.addStudent(student4);
 
        Student student5 = new Student();
        student5.setFirstName("firstName5");
        student5.setLastName("lastName5");
        student5.setID(5);
        studentManager.addStudent(student5);
 
        Student student6 = new Student();
        student6.setFirstName("firstName6");
        student6.setLastName("lastName6");
        student6.setID(6);
        studentManager.addStudent(student6);
    }
 
    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                         
    private void initComponents() {
        java.awt.GridBagConstraints gridBagConstraints;
 
        jScrollPane1 = new javax.swing.JScrollPane();
        studentTable = new org.jdesktop.swingx.JXTable();
        unselectStudentButton = new javax.swing.JButton();
        addButton = new javax.swing.JButton();
        delButton = new javax.swing.JButton();
        clearButton = new javax.swing.JButton();
        pushLabel = new javax.swing.JLabel();
 
        setLayout(new java.awt.GridBagLayout());
 
        studentTable.setModel(studentListModel);
        studentTable.setColumnControlVisible(true);
        studentTable.setShowHorizontalLines(false);
        studentTable.setShowVerticalLines(false);
        jScrollPane1.setViewportView(studentTable);
 
        gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.gridx = 0;
        gridBagConstraints.gridy = 0;
        gridBagConstraints.gridwidth = 5;
        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
        gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
        add(jScrollPane1, gridBagConstraints);
 
        unselectStudentButton.setText("Unselect");
        unselectStudentButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                unselectStudentButtonActionPerformed(evt);
            }
        });
        gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.gridx = 1;
        gridBagConstraints.gridy = 1;
        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
        gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
        add(unselectStudentButton, gridBagConstraints);
 
        addButton.setText("Add");
        addButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                addButtonActionPerformed(evt);
            }
        });
        gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.gridx = 2;
        gridBagConstraints.gridy = 1;
        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
        gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
        add(addButton, gridBagConstraints);
 
        delButton.setText("Del");
        delButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                delButtonActionPerformed(evt);
            }
        });
        gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.gridx = 3;
        gridBagConstraints.gridy = 1;
        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
        gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
        add(delButton, gridBagConstraints);
 
        clearButton.setText("Clear");
        clearButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                clearButtonActionPerformed(evt);
            }
        });
        gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.gridx = 4;
        gridBagConstraints.gridy = 1;
        gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
        gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
        add(clearButton, gridBagConstraints);
        gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.gridx = 0;
        gridBagConstraints.gridy = 1;
        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
        gridBagConstraints.anchor = java.awt.GridBagConstraints.LINE_END;
        gridBagConstraints.weightx = 0.1;
        add(pushLabel, gridBagConstraints);
    }// </editor-fold>                       
 
    private void clearButtonActionPerformed(java.awt.event.ActionEvent evt) {                                           
        studentManager.clearStudentList();
        studentListModel.fireTableDataChanged();
    }                                          
 
    private void delButtonActionPerformed(java.awt.event.ActionEvent evt) {                                         
        studentManager.delSelectedStudent();
        studentListModel.fireTableDataChanged();
    }                                        
 
    private void addButtonActionPerformed(java.awt.event.ActionEvent evt) {                                         
        studentManager.createStudent(666, "New", "student");
        studentListModel.fireTableDataChanged();
    }                                        
 
    private void unselectStudentButtonActionPerformed(java.awt.event.ActionEvent evt) {                                                     
        studentTable.clearSelection();
        studentManager.setIsOneStudentSelected(false);
    }                                                    
 
    // Variables declaration - do not modify                    
    private javax.swing.JButton addButton;
    private javax.swing.JButton clearButton;
    private javax.swing.JButton delButton;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JLabel pushLabel;
    private org.jdesktop.swingx.JXTable studentTable;
    private javax.swing.JButton unselectStudentButton;
    // End of variables declaration                  
 
    public static void main(String args[]) {
 
        java.awt.EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                JFrame test = new JFrame();
                test.add(new StudentListPanel());
                test.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                test.pack();
                test.setLocationRelativeTo(null);
                test.setVisible(true);
            }
        });
    }
}

Le manager etudiant qui est en charge de l'ajout, suppression , etc ...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
package testjxtable;
 
import java.util.ArrayList;
import org.jdesktop.swingx.JXTable;
 
public class StudentManager {
 
    private static StudentManager s_instance = null;
    private ArrayList<Student> studentlist;
    private Student selectedStudent;
    private boolean isOneStudentSelected;
    private StudentSelectionListener studentSelectionListener;
    private StudentListModel studentListModel;
 
    private StudentManager() {
        studentlist = new ArrayList<Student>();
        studentListModel = new StudentListModel(studentlist);
        selectedStudent = new Student();
        isOneStudentSelected = false;
    }
 
    /**
     * Retrieves single instance of StudentManager
     *
     * @return The unique instance of StudentManager
     */
    public synchronized static StudentManager getInstance() {
        if (s_instance == null) {
            s_instance = new StudentManager();
        }
        return s_instance;
    }
 
    public void createStudent(int id, String firstName, String LastName) {
        studentlist.add(new Student(firstName, LastName, id));
    }
 
    public void addStudent(Student student) {
        studentlist.add(student);
    }
 
    public void delSelectedStudent() {
        studentlist.remove(selectedStudent);
    }
 
    public void delStudent(Student student) {
        studentlist.remove(student);
    }
 
    public void delStudentWhitID(int id) {
        for (int i = 0; i < studentlist.size(); i++) {
            if (studentlist.get(i).getID()== id) {
                studentlist.remove(i);
            }
        }
    }
 
    public void clearStudentList() {
        studentlist.clear();
    }
 
    public void setSelectedStudent(Student selectedStudent) {
        this.selectedStudent = selectedStudent;
        System.out.println("SELECTED STUDENT:"+selectedStudent.getFirstName());
    }
 
    public Student getStudentWhitMatricule(int id) {
        for (int i = 0; i < studentlist.size(); i++) {
            if (studentlist.get(i).getID()== id) {
                return studentlist.get(i);
            }
        }
        return null;
    }
 
    public ArrayList<Student> getStudentlist() {
        return studentlist;
    }
 
    public StudentSelectionListener createStudentSelectionListener(JXTable studentTable) {
        studentSelectionListener = new StudentSelectionListener(studentTable);
        return studentSelectionListener;
    }
 
    public StudentListModel getStudentListModel() {
        return studentListModel;
    }
 
    public Student getSelectedStudent() {
        return selectedStudent;
    }
 
    public void setIsOneStudentSelected(boolean isOneStudentSelected) {
        this.isOneStudentSelected = isOneStudentSelected;
    }
 
    public boolean isIsOneStudentSelected() {
        return isOneStudentSelected;
    }
 
 
}

La classe qui contient le listener de sélection

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package testjxtable;
 
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import org.jdesktop.swingx.JXTable;
 
public class StudentSelectionListener implements ListSelectionListener {
 
    private JXTable studentTable;
    private StudentManager studentManager = StudentManager.getInstance();
 
    public StudentSelectionListener(JXTable studentTable) {
        this.studentTable = studentTable;
    }
 
    @Override
    public void valueChanged(ListSelectionEvent e) {
        if (!e.getValueIsAdjusting() && !studentManager.getStudentlist().isEmpty() && studentTable.getSelectedRow() != -1) {
            System.out.println("Ligne selectionné:"+studentTable.getSelectedRow());
            System.out.println(((StudentListModel) (studentTable.getModel())).getStudentList());
            studentManager.setSelectedStudent(((StudentListModel) (studentTable.getModel())).getSelectedStudent(studentTable.getSelectedRow()));
        }
    }
}

Si quelqu'un à déjà rencontré ce problème ou voit d'ou ça peut venir :calim2: