如何在java中的每个jList项中添加Jpanel

我想在java中的每个

jlist

项中动态添加

jPanel

。其中

jPanel

包含按钮、进度条和标签。而

jlist

在

jlist

中的每个元组中都包含

jpanel

，jlist不能保存组件，而只能保存组件的渲染。因此，简而言之，您的请求不可能直接实现但是，您可以使用类似于JTable的东西来保存JButton、JProgressBar和JLabel的可编辑渲染。JTable的最大区别在于它的单元格是可编辑的，因此按钮可以在这种环境中“工作”

通过查看指向Swing教程和其他Swing资源的链接，您可以在此处找到更多内容：

---

示例代码：

• 请注意，这使用了Rob Camicker令人惊讶的奇妙按钮栏。可以找到文章，也可以找到代码
• 这也借用了mKorbel的StackOverflow应答代码
• 还有垃圾神的密码

---

导入java.awt.BorderLayout；
导入java.awt.Color；
导入java.awt.Component；
导入java.awt.event.*；
导入java.beans.PropertyChangeEvent；
导入java.beans.PropertyChangeListener；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.Random；
导入javax.swing.*；
导入javax.swing.border.border；
导入javax.swing.border.LineBorder；
导入javax.swing.event.SwingPropertyChangeSupport；
导入javax.swing.table.AbstractTableModel；
导入javax.swing.table.DefaultTableCellRenderer；
导入javax.swing.table.TableCellEditor；
导入javax.swing.table.TableCellRenderer；
导入javax.swing.table.TableColumnModel；
@抑制警告（“串行”）
公共类ComplexTableEg扩展了JPanel{
私有CTTableModel tableModel=新CTTableModel（）；
私有JTable table=新JTable（tableModel）；
公共complextableg（）{
StartProgressAction StartProgressAction=新建StartProgressAction(
“启动进度”，KeyEvent.VK_；
新按钮列（表，开始压缩，0）；
table.getColumnModel（）.getColumn（2.setCellRenderer）（新的ProgressRenderer（））；
JPanel buttonPanel=新的JPanel（）；
add（newjbutton（newaddrowaction（“addrow”，KeyEvent.VK_A））；
setLayout（新的BorderLayout（））；
添加（新的JScrollPane（表），BorderLayout.CENTER）；
添加（按钮面板，边框布局。页面\结尾）；
}
私有类AddRowAction扩展了AbstractAction{
公共AddRowAction（字符串名，int助记符）{
超级（姓名）；
putValue（助记符键，助记符）；
}
@凌驾
已执行的公共无效操作（操作事件e）{
int rowCount=tableModel.getRowCount（）+1；
CTRowData ctRow=新CTRowData（“行”+行计数）；
tableModel.addRow（ctRow）；
}
}
私有静态void createAndShowGui（）{
ComplexTableEg主面板=新的ComplexTableEg（）；
JFrame=新JFrame（“复杂表格Eg”）；
frame.setDefaultCloseOperation（JFrame.DISPOSE_ON_CLOSE）；
frame.getContentPane（）.add（主面板）；
frame.pack（）；
frame.setLocationByPlatform（真）；
frame.setVisible（true）；
}
公共静态void main（字符串[]args）{
SwingUtilities.invokeLater（新的Runnable（）{
公开募捐{
createAndShowGui（）；
}
});
}
}
/**
*来自mKorbel的StackOverflow答案
*@link:https://stackoverflow.com/a/7036206/522444
*
*/
类ProgressRenderer扩展了DefaultTableCellRenderer{
私有最终JProgressBar b=新JProgressBar（0，100）；
公营机构（{
超级（）；
set不透明（true）；
b、 setBorder（BorderFactory.createEmptyByOrder（1,1,1,1））；
}
@凌驾
公共组件GetTableCellRenderComponent（JTable表、对象值、布尔isSelected、布尔hasFocus、int行、int列）{
整数i=（整数）值；
String text=“已完成”；
if（i<0）{
text=“错误”；
}否则如果（i<100）{
b、 设定值（i）；
返回b；
}
getTableCellRenderComponent（表、文本、isSelected、hasFocus、行、列）；
归还这个；
}
}
@抑制警告（“串行”）
类StartProgressAction扩展了AbstractAction{
public StartProgressAction（字符串名，int助记符）{
超级（姓名）；
putValue（助记符键，助记符）；
}
@凌驾
已执行的公共无效操作（操作事件e）{
JTable table=（JTable）e.getSource（）；
int rowIndex=Integer.parseInt（例如getActionCommand（））；
CTTableModel=（CTTableModel）table.getModel（）；
CTRowData行=model.getRow（行索引）；
row.startProcessing（）；
}
}
@抑制警告（“串行”）
类CTTableModel扩展了AbstractTableModel{
公共静态最终字符串[]列标题={“按钮”，“标签”，
“进展”}；
private List dataList=new ArrayList（）；
@凌驾
public int getRowCount（）{
返回dataList.size（）；
}
公共CTRowData getRow（int ROWDINDEX）{
返回dataList.get（rowIndex）；
}
@凌驾
public int getColumnCount（）{
返回列_HEADERS.length；
}
@凌驾
公共对象getValueAt（int行索引、int列索引）{
CTRowData行=dataList.get（rowIndex）；
开关（列索引）{
案例0：
返回CTRowData.START\u处理；
案例1：
返回row.getText（）；
案例2：
返回row.getValue（）；
}
返回null；
}
@凌驾
公共类getColumnClass（int columnIndex）{
开关（列索引）{
案例0：
返回字符串.class；
案例1：
返回字符串.class；
案例2：
返回Integer.class；
}
//永远不应该需要这个默认值
返回super.getColumnClass（columnIndex）；
}
@凌驾
公共字符串getColumnName（int列）{
返回列标题[列]；
}
公共vo
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.event.*;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.border.LineBorder;
import javax.swing.event.SwingPropertyChangeSupport;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumnModel;

@SuppressWarnings("serial")
public class ComplexTableEg extends JPanel {
   private CTTableModel tableModel = new CTTableModel();
   private JTable table = new JTable(tableModel);

   public ComplexTableEg() {
      StartProgressAction startProgressAction = new StartProgressAction(
            "Start Progress", KeyEvent.VK_S);
      new ButtonColumn(table, startProgressAction, 0);
      table.getColumnModel().getColumn(2).setCellRenderer(new ProgressRenderer());

      JPanel buttonPanel = new JPanel();
      buttonPanel.add(new JButton(new AddRowAction("Add Row", KeyEvent.VK_A)));

      setLayout(new BorderLayout());
      add(new JScrollPane(table), BorderLayout.CENTER);
      add(buttonPanel, BorderLayout.PAGE_END);
   }

   private class AddRowAction extends AbstractAction {
      public AddRowAction(String name, int mnemonic) {
         super(name);
         putValue(MNEMONIC_KEY, mnemonic);
      }

      @Override
      public void actionPerformed(ActionEvent e) {
         int rowCount = tableModel.getRowCount() + 1;
         CTRowData ctRow = new CTRowData("Row " + rowCount);
         tableModel.addRow(ctRow);
      }
   }

   private static void createAndShowGui() {
      ComplexTableEg mainPanel = new ComplexTableEg();

      JFrame frame = new JFrame("Complex Table Eg");
      frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
      frame.getContentPane().add(mainPanel);
      frame.pack();
      frame.setLocationByPlatform(true);
      frame.setVisible(true);
   }

   public static void main(String[] args) {
      SwingUtilities.invokeLater(new Runnable() {
         public void run() {
            createAndShowGui();
         }
      });
   }
}

/**
 * From mKorbel's StackOverflow answer
 * @link: https://stackoverflow.com/a/7036206/522444
 *
 */
class ProgressRenderer extends DefaultTableCellRenderer {
   private final JProgressBar b = new JProgressBar(0, 100);

   public ProgressRenderer() {
       super();
       setOpaque(true);
       b.setBorder(BorderFactory.createEmptyBorder(1, 1, 1, 1));
   }

   @Override
   public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
       Integer i = (Integer) value;
       String text = "Completed";
       if (i < 0) {
           text = "Error";
       } else if (i < 100) {
           b.setValue(i);
           return b;
       }
       super.getTableCellRendererComponent(table, text, isSelected, hasFocus, row, column);
       return this;
   }
}

@SuppressWarnings("serial")
class StartProgressAction extends AbstractAction {
   public StartProgressAction(String name, int mnemonic) {
      super(name);
      putValue(MNEMONIC_KEY, mnemonic);
   }

   @Override
   public void actionPerformed(ActionEvent e) {
      JTable table = (JTable) e.getSource();
      int rowIndex = Integer.parseInt(e.getActionCommand());
      CTTableModel model = (CTTableModel) table.getModel();
      CTRowData row = model.getRow(rowIndex);
      row.startProcessing();
   }
}

@SuppressWarnings("serial")
class CTTableModel extends AbstractTableModel {
   public static final String[] COLUMN_HEADERS = { "Button", "Label",
         "Progress" };
   private List<CTRowData> dataList = new ArrayList<>();

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

   public CTRowData getRow(int rowIndex) {
      return dataList.get(rowIndex);
   }

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

   @Override
   public Object getValueAt(int rowIndex, int columnIndex) {
      CTRowData row = dataList.get(rowIndex);
      switch (columnIndex) {
      case 0:
         return CTRowData.START_PROCESSING;
      case 1:
         return row.getText();
      case 2:
         return row.getValue();
      }
      return null;
   }

   @Override
   public Class<?> getColumnClass(int columnIndex) {
      switch (columnIndex) {
      case 0:
         return String.class;
      case 1:
         return String.class;
      case 2:
         return Integer.class;
      }
      // should never need this default
      return super.getColumnClass(columnIndex);
   }

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

   public void addRow(CTRowData row) {
      dataList.add(row);
      int firstRow = dataList.size() - 1;
      fireTableRowsInserted(firstRow, firstRow);

      row.addPropertyChangeListener(new RowDataListener(firstRow));
   }

   private class RowDataListener implements PropertyChangeListener {
      private int row;

      public RowDataListener(int row) {
         this.row = row; 
      }

      @Override
      public void propertyChange(PropertyChangeEvent evt) {
         if (CTRowData.VALUE.equals(evt.getPropertyName())) {
            fireTableCellUpdated(row, 2);
         }
      }
   }

   @Override
   public boolean isCellEditable(int rowIndex, int columnIndex) {
      boolean cellEditable = false;
      if (columnIndex != 0) {
         cellEditable = false;
      } else {
         cellEditable = true;
      }
      return cellEditable;
   }
}

class CTRowData {
   public static final String VALUE = "value";
   public static final String PROCESSING = "processing";
   public static final String START_PROCESSING = "Start Processing";
   private static final int TIMER_DELAY = 500;
   public static final int MAX_VALUE = 100;
   private String text;
   private boolean processing = false;
   private int value = 0;
   private Random random = new Random();
   private SwingPropertyChangeSupport pcSupport = new SwingPropertyChangeSupport(
         this);

   public CTRowData(String text) {
      this.text = text;
   }

   public boolean isProcessing() {
      return processing;
   }

   public void setProcessing(boolean processing) {
      boolean oldValue = this.processing;
      boolean newValue = processing;
      this.processing = processing;
      pcSupport.firePropertyChange(PROCESSING, oldValue, newValue);
   }

   public void startProcessing() {
      if (processing) {
         return;
      }
      setProcessing(true);
      setValue(0);
      new Timer(TIMER_DELAY, new TimerListener()).start();
   }

   public String getText() {
      return text;
   }

   public int getValue() {
      return value;
   }

   public void setValue(int value) {
      int oldValue = this.value;
      int newValue = value;
      this.value = value;
      pcSupport.firePropertyChange(VALUE, oldValue, newValue);
   }

   public void addPropertyChangeListener(PropertyChangeListener listener) {
      pcSupport.addPropertyChangeListener(listener);
   }

   public void removePropertyChangeListener(PropertyChangeListener listener) {
      pcSupport.removePropertyChangeListener(listener);
   }

   private class TimerListener implements ActionListener {
      @Override
      public void actionPerformed(ActionEvent e) {
         int temp = value;
         temp += 5 + random.nextInt(10);
         temp = Math.min(temp, MAX_VALUE);
         setValue(temp);
         if (temp >= MAX_VALUE) {
            ((Timer) e.getSource()).stop();
            setProcessing(false);
         }
      }
   }
}