模块 java.desktop
包 javax.swing

类 JList<E>

java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
javax.swing.JList<E>
类型参数：
E - 此list元素的类型
所有已实现的接口：
ImageObserver , MenuContainer , Serializable , Accessible , Scrollable
@JavaBean (defaultProperty ="UI", description ="A component which allows for the selection of one or more objects from a list.") public class JList<E> extends JComponent implements Scrollable , Accessible
显示对象列表并允许用户选择一个或多个项目的组件。一个单独的模型 ListModel 维护列表的内容。

使用自动为您构建只读 ListModel 实例的 JList 构造函数，可以轻松显示对象数组或 Vector：

 
 // Create a JList that displays strings from an array

 String[] data = {"one", "two", "three", "four"};
 JList<String> myList = new JList<String>(data);

 // Create a JList that displays the superclasses of JList.class, by
 // creating it with a Vector populated with this data

 Vector<Class<?>> superClasses = new Vector<Class<?>>();
 Class<JList> rootClass = javax.swing.JList.class;
 for(Class<?> cls = rootClass; cls != null; cls = cls.getSuperclass()) {
   superClasses.addElement(cls);
 }
 JList<Class<?>> myList = new JList<Class<?>>(superClasses);

 // The automatically created model is stored in JList's "model"
 // property, which you can retrieve

 ListModel<Class<?>> model = myList.getModel();
 for(int i = 0; i < model.getSize(); i++) {
   System.out.println(model.getElementAt(i));
 }

ListModel 可以通过构造函数或 setModel 方法直接提供给 JList。内容不必是静态的——项目的数量和项目的值可以随时间变化。每次发生更改时，正确的 ListModel 实现都会通知已添加到其中的 javax.swing.event.ListDataListener 集合。这些更改以 javax.swing.event.ListDataEvent 为特征，它标识已修改、添加或删除的列表索引的范围。 JList 的 ListUI 负责通过聆听模型使视觉表示与变化保持同步。

简单的动态内容 JList 应用程序可以使用 DefaultListModel 类来维护列表元素。此类实现了 ListModel 接口，还提供了类似 java.util.Vector 的 API。需要更多自定义 ListModel 实现的应用程序可能希望继承 AbstractListModel ，它为管理和通知监听器提供基本支持。例如，AbstractListModel 的只读实现：

 
 // This list model has about 2^16 elements. Enjoy scrolling.

 ListModel<String> bigData = new AbstractListModel<String>() {
   public int getSize() { return Short.MAX_VALUE; }
   public String getElementAt(int index) { return "Index " + index; }
 };

JList 的选择状态由另一个单独的模型（ListSelectionModel 的实例）管理。 JList 在构造时用选择模型初始化，还包含查询或设置此选择模型的方法。此外，JList 提供了方便的方法来轻松管理选择。这些方法（例如 setSelectedIndex 和 getSelectedValue ）是处理与选择模型交互的细节的覆盖方法。默认情况下，JList 的选择模型被配置为允许一次选择任意项目组合；选择模式MULTIPLE_INTERVAL_SELECTION。可以直接在选择模型上更改选择模式，或通过JList 的覆盖方法。响应用户手势更新选择模型的责任在于列表的 ListUI 。

每次选择发生更改时，正确的 ListSelectionModel 实现都会通知已添加到其中的 javax.swing.event.ListSelectionListener 集合。这些更改以 javax.swing.event.ListSelectionEvent 为特征，它标识选择更改的范围。

监听列表选择变化的首选方法是将 ListSelectionListener 直接添加到 JList 。 JList 然后负责收听选择模型并通知您的听众更改。

监听选择更改以保持列表的视觉表示为最新的责任在于列表的 ListUI 。

JList 中的单元格绘制由称为单元格渲染器的委托处理，作为 cellRenderer 属性安装在列表中。渲染器提供了一个 java.awt.Component，它像“橡皮图章”一样用于绘制单元格。每次需要绘制一个单元格时，列表的 ListUI 向单元格渲染器请求组件，将其移动到位，并让它通过其 paint 方法绘制单元格的内容。列表的 ListUI 安装了默认的单元格渲染器，它使用 JLabel 组件进行渲染。您可以使用如下代码替换您自己的渲染器：

 
 // Display an icon and a string for each object in the list.

 class MyCellRenderer extends JLabel implements ListCellRenderer<Object> {
   static final ImageIcon longIcon = new ImageIcon("long.gif");
   static final ImageIcon shortIcon = new ImageIcon("short.gif");

   // This is the only method defined by ListCellRenderer.
   // We just reconfigure the JLabel each time we're called.

   public Component getListCellRendererComponent(
    JList<?> list,      // the list
    Object value,      // value to display
    int index,        // cell index
    boolean isSelected,   // is the cell selected
    boolean cellHasFocus)  // does the cell have focus
   {
     String s = value.toString();
     setText(s);
     setIcon((s.length() > 10) ? longIcon : shortIcon);
     if (isSelected) {
       setBackground(list.getSelectionBackground());
       setForeground(list.getSelectionForeground());
     } else {
       setBackground(list.getBackground());
       setForeground(list.getForeground());
     }
     setEnabled(list.isEnabled());
     setFont(list.getFont());
     setOpaque(true);
     return this;
   }
 }

 myList.setCellRenderer(new MyCellRenderer());

单元格渲染器的另一项工作是帮助确定列表的大小信息。默认情况下，列表的 ListUI 通过向单元格渲染器询问每个列表项的首选大小来确定单元格的大小。对于大型项目列表，这可能会很昂贵。为避免这些计算，您可以在列表中设置 fixedCellWidth 和 fixedCellHeight，或者根据单个原型值自动计算这些值：

 
 JList<String> bigDataList = new JList<String>(bigData);

 // We don't want the JList implementation to compute the width
 // or height of all of the list cells, so we give it a string
 // that's as big as we'll need for any cell. It uses this to
 // compute values for the fixedCellWidth and fixedCellHeight
 // properties.

 bigDataList.setPrototypeCellValue("Index 1234567890");

JList 不直接实现滚动。要创建滚动列表，请将其设为 JScrollPane 的视口视图。例如：

 JScrollPane scrollPane = new JScrollPane(myList);

 // Or in two steps:
 JScrollPane scrollPane = new JScrollPane();
 scrollPane.getViewport().setView(myList);

JList 不提供对两次或三次（或 N）鼠标单击的任何特殊处理，但如果您希望对这些事件采取操作，则可以轻松添加 MouseListener。使用 locationToIndex 方法确定单击了哪个单元格。例如：

 MouseListener mouseListener = new MouseAdapter() {
   public void mouseClicked(MouseEvent e) {
     if (e.getClickCount() == 2) {
       int index = list.locationToIndex(e.getPoint());
       System.out.println("Double clicked on Item " + index);
     }
   }
 };
 list.addMouseListener(mouseListener);

Warning: Swing 不是线程安全的。有关详细信息，请参阅 Swing 的线程策略。

Warning: 此类的序列化对象将与未来的 Swing 版本不兼容。当前的序列化支持适用于运行相同版本 Swing 的应用程序之间的短期存储或 RMI。从 1.4 开始，对所有 JavaBeans 的长期存储的支持已添加到 java.beans 包中。请参阅 XMLEncoder 。

有关更多文档，请参阅 The Java Tutorial 中的 如何使用列表。

自从：
1.2
参见：

  • 字段详细信息

  • 构造方法详细信息

    • JList

      public JList(ListModel <E > dataModel)
      构造一个 JList 显示来自指定 non-null 模型的元素。所有 JList 构造函数委托给这个。

      此构造函数使用 ToolTipManager 注册列表，允许单元格渲染器提供工具提示。

      参数：
      dataModel - 列表的模型
      抛出：
      IllegalArgumentException - 如果模型是 null

    • JList

      public JList(E [] listData)
      构造一个 JList 显示指定数组中的元素。此构造函数为给定数组创建一个只读模型，然后委托给采用 ListModel 的构造函数。

      尝试将 null 值传递给此方法会导致未定义的行为，并且很可能会导致异常。创建的模型直接引用给定的数组。在构造列表后尝试修改数组会导致未定义的行为。

      参数：
      listData - 要加载到数据模型中的对象数组，non-null

    • JList

      public JList(Vector <? extends E > listData)
      构造一个 JList 以显示指定 Vector 中的元素。此构造函数为给定的 Vector 创建一个只读模型，然后委托给采用 ListModel 的构造函数。

      尝试将 null 值传递给此方法会导致未定义的行为，并且很可能会导致异常。创建的模型直接引用给定的 Vector。在构造列表后尝试修改 Vector 会导致未定义的行为。

      参数：
      listData - 要加载到数据模型中的 Vector，non-null

    • JList

      public JList()
      用一个空的只读模型构造一个JList。

  • 方法详情

    • getUI

      public ListUI  getUI()
      返回 ListUI ，呈现此组件的外观对象。
      重写：
      getUI 在类 JComponent 中
      返回：
      呈现该组件的 ListUI 对象

    • setUI

      @BeanProperty (hidden =true, visualUpdate =true, description ="The UI object that implements the Component\'s LookAndFeel.") public void setUI(ListUI  ui)
      设置 ListUI ，呈现此组件的外观对象。
      参数：
      ui - ListUI 对象
      参见：

    • updateUI

      public void updateUI()
      通过将 ListUI 属性设置为当前外观提供的值来重置它。如果当前单元格渲染器是由开发人员安装的（而不是外观本身），这也会导致单元格渲染器及其子级通过调用 SwingUtilities.updateComponentTreeUI 进行更新。
      重写：
      updateUI 在类 JComponent 中
      参见：

    • getUIClassID

      @BeanProperty (bound =false) public String  getUIClassID()
      返回 "ListUI" ，UIDefaults 键用于查找定义此组件外观的 javax.swing.plaf.ListUI 类的名称。
      重写：
      getUIClassID 在类 JComponent 中
      返回：
      字符串“ListUI”
      参见：

    • getPrototypeCellValue

      public E  getPrototypeCellValue()
      返回“原型”单元格值——用于计算单元格固定宽度和高度的值。如果没有这样的值，这可以是 null。
      返回：
      prototypeCellValue 属性的值
      参见：

    • setPrototypeCellValue

      @BeanProperty (visualUpdate =true, description ="The cell prototype value, used to compute cell width and height.") public void setPrototypeCellValue(E  prototypeCellValue)
      设置 prototypeCellValue 属性，然后（如果新值为 non-null ），通过从单元格渲染器请求单元格渲染器组件的给定值（和索引 0）并使用该组件的首选大小来计算 fixedCellWidth 和 fixedCellHeight 属性。

      当列表太长而无法让 ListUI 计算每个单元格的宽度/高度时，此方法很有用，并且已知有一个单元格值占用与其他任何单元格一样多的空间，即所谓的原型.

      虽然 prototypeCellValue、fixedCellHeight 和 fixedCellWidth 属性中的所有三个都可以通过此方法修改，但 PropertyChangeEvent 通知仅在 prototypeCellValue 属性更改时发送。

      要查看设置此属性的示例，请参阅上面的 类描述。

      此属性的默认值为 null 。

      这是一个 JavaBeans 绑定属性。

      参数：
      prototypeCellValue - fixedCellWidth 和 fixedCellHeight 所基于的值
      参见：

    • getFixedCellWidth

      public int getFixedCellWidth()
      返回 fixedCellWidth 属性的值。
      返回：
      固定单元格宽度
      参见：

    • setFixedCellWidth

      @BeanProperty (visualUpdate =true, description ="Defines a fixed cell width when greater than zero.") public void setFixedCellWidth(int width)
      设置用于列表中每个单元格宽度的固定值。如果 width 为 -1，则通过将 getPreferredSize 应用于每个列表元素的单元格渲染器组件，在 ListUI 中计算单元格宽度。

      此属性的默认值为 -1 。

      这是一个 JavaBeans 绑定属性。

      参数：
      width - 用于列表中所有单元格的宽度
      参见：

    • getFixedCellHeight

      public int getFixedCellHeight()
      返回 fixedCellHeight 属性的值。
      返回：
      固定单元格高度
      参见：

    • setFixedCellHeight

      @BeanProperty (visualUpdate =true, description ="Defines a fixed cell height when greater than zero.") public void setFixedCellHeight(int height)
      设置用于列表中每个单元格高度的固定值。如果 height 为 -1，则通过将 getPreferredSize 应用于每个列表元素的单元格渲染器组件，在 ListUI 中计算单元格高度。

      此属性的默认值为 -1 。

      这是一个 JavaBeans 绑定属性。

      参数：
      height - 用于列表中所有单元格的高度
      参见：

    • getCellRenderer

      public ListCellRenderer <? super E > getCellRenderer()
      返回负责绘制列表项的对象。
      返回：
      cellRenderer 属性的值
      参见：

    • setCellRenderer

      @BeanProperty (visualUpdate =true, description ="The component used to draw the cells.") public void setCellRenderer(ListCellRenderer <? super E > cellRenderer)
      设置用于绘制列表中每个单元格的委托。 类级别文档 中详细讨论了单元渲染器的工作。

      如果 prototypeCellValue 属性为 non-null ，则设置单元格渲染器还会导致重新计算 fixedCellWidth 和 fixedCellHeight 属性。然而，只生成一个 PropertyChangeEvent - 用于 cellRenderer 属性。

      此属性的默认值由ListUI 委托提供，即由外观实现提供。

      这是一个 JavaBeans 绑定属性。

      参数：
      cellRenderer - 绘制列表单元格的 ListCellRenderer
      参见：

    • getSelectionForeground

      public Color  getSelectionForeground()
      返回用于绘制所选项目前景的颜色。 DefaultListCellRenderer 使用此颜色绘制处于选中状态的项目的前景，大多数 ListUI 实现安装的渲染器也是如此。
      返回：
      绘制所选项目前景的颜色
      参见：

    • setSelectionForeground

      @BeanProperty (visualUpdate =true, description ="The foreground color of selected cells.") public void setSelectionForeground(Color  selectionForeground)
      设置用于绘制所选项目前景的颜色，单元格渲染器可用于渲染文本和图形。 DefaultListCellRenderer 使用此颜色绘制处于选中状态的项目的前景，大多数 ListUI 实现安装的渲染器也是如此。

      此属性的默认值由外观实现定义。

      这是一个 JavaBeans 绑定属性。

      参数：
      selectionForeground - 在所选列表项的前台使用的 Color
      参见：

    • getSelectionBackground

      public Color  getSelectionBackground()
      返回用于绘制所选项目背景的颜色。 DefaultListCellRenderer 使用此颜色绘制处于选中状态的项目的背景，大多数 ListUI 实现安装的渲染器也是如此。
      返回：
      绘制所选项目背景的颜色
      参见：

    • setSelectionBackground

      @BeanProperty (visualUpdate =true, description ="The background color of selected cells.") public void setSelectionBackground(Color  selectionBackground)
      设置用于绘制所选项目背景的颜色，单元格渲染器可以使用该颜色填充所选单元格。 DefaultListCellRenderer 使用此颜色填充处于选中状态的项目的背景，大多数 ListUI 实现安装的渲染器也是如此。

      此属性的默认值由外观实现定义。

      这是一个 JavaBeans 绑定属性。

      参数：
      selectionBackground - 用于所选单元格背景的 Color
      参见：

    • getVisibleRowCount

      public int getVisibleRowCount()
      返回 visibleRowCount 属性的值。有关如何解释此值的详细信息，请参阅 setVisibleRowCount(int) 的文档。
      返回：
      visibleRowCount 属性的值。
      参见：

    • setVisibleRowCount

      @BeanProperty (visualUpdate =true, description ="The preferred number of rows to display without requiring scrolling") public void setVisibleRowCount(int visibleRowCount)
      设置 visibleRowCount 属性，该属性根据布局方向具有不同的含义：对于 VERTICAL 布局方向，这设置了无需滚动即可显示的首选行数；对于其他方向，它会影响单元格的包裹。

      在 VERTICAL 方向：
      设置此属性会影响 getPreferredScrollableViewportSize() 方法的返回值，该方法用于计算封闭视口的首选大小。有关详细信息，请参阅该方法的文档。

      在 HORIZONTAL_WRAP 和 VERTICAL_WRAP 方向：
      这会影响单元格的包裹方式。有关详细信息，请参阅 setLayoutOrientation(int) 的文档。

      此属性的默认值为 8 。

      使用负值调用此方法会导致将属性设置为 0 。

      这是一个 JavaBeans 绑定属性。

      参数：
      visibleRowCount - 一个整数，指定无需滚动即可显示的首选行数
      参见：

    • getLayoutOrientation

      public int getLayoutOrientation()
      返回列表的布局方向属性：VERTICAL如果布局是单列单元格，VERTICAL_WRAP如果布局是“报纸样式”且内容垂直然后水平流动，或者HORIZONTAL_WRAP如果布局是“报纸样式”且内容水平流动然后垂直流动。
      返回：
      layoutOrientation 属性的值
      自从：
      1.4
      参见：

    • setLayoutOrientation

      @BeanProperty (visualUpdate =true, enumerationValues ={"JList.VERTICAL","JList.HORIZONTAL_WRAP","JList.VERTICAL_WRAP"}, description ="Defines the way list cells are laid out.") public void setLayoutOrientation(int layoutOrientation)
      定义列表单元格的布局方式。考虑一个有五个单元格的 JList。可以通过以下方式之一布置单元格： 
       VERTICAL:     0
          1
          2
          3
          4

 HORIZONTAL_WRAP:  0 1 2
          3 4

 VERTICAL_WRAP:   0 3
          1 4
          2

      这些布局的描述如下：

      描述布局 VERTICAL、HORIZONTAL_WRAP 和 VERTICAL_WRAP
      Value Description
      VERTICAL 单元格垂直排列在一列中。
      HORIZONTAL_WRAP 单元格水平放置，必要时换行。如果 visibleRowCount 属性小于或等于零，则换行由列表的宽度决定；否则换行以确保列表中有 visibleRowCount 行的方式完成。
      VERTICAL_WRAP 单元格垂直放置，必要时换行到新列。如果 visibleRowCount 属性小于或等于零，则换行由列表的高度决定；否则换行在 visibleRowCount 行完成。
      此属性的默认值为 VERTICAL 。
      参数：
      layoutOrientation - 新布局方向，其中之一：VERTICAL、HORIZONTAL_WRAP 或 VERTICAL_WRAP
      抛出：
      IllegalArgumentException - 如果 layoutOrientation 不是允许值之一
      自从：
      1.4
      参见：

    • getFirstVisibleIndex

      @BeanProperty (bound =false) public int getFirstVisibleIndex()
      返回当前可见的最小列表索引。在从左到右的 componentOrientation 中，第一个可见单元格最靠近列表的左上角。在从右到左的方向上，它最靠近右上角。如果什么都不可见或列表为空，则返回 -1。请注意，返回的单元格可能仅部分可见。
      返回：
      第一个可见单元格的索引
      参见：

    • getLastVisibleIndex

      @BeanProperty (bound =false) public int getLastVisibleIndex()
      返回当前可见的最大列表索引。如果什么都不可见或列表为空，则返回 -1。请注意，返回的单元格可能仅部分可见。
      返回：
      最后一个可见单元格的索引
      参见：

    • ensureIndexIsVisible

      public void ensureIndexIsVisible(int index)
      在封闭的视口中滚动列表以使指定的单元格完全可见。这将使用指定单元格的边界调用 scrollRectToVisible。要使此方法起作用，JList 必须在 JViewport 内。

      如果给定的索引在列表的单元格范围之外，则此方法不会产生任何结果。

      参数：
      index - 要显示的单元格的索引
      参见：

    • setDragEnabled

      @BeanProperty (bound =false, description ="determines whether automatic drag handling is enabled") public void setDragEnabled(boolean b)
      打开或关闭自动拖动处理。为了启用自动拖动处理，此属性应设置为 true ，列表的 TransferHandler 需要为 non-null 。 dragEnabled 属性的默认值为 false 。

      尊重此属性并识别用户拖动手势的工作在于外观实现，特别是列表的 ListUI 。启用自动拖动处理后，只要用户在项目上按下鼠标按钮，然后将鼠标移动几个像素，大多数外观（包括子类 BasicLookAndFeel 的外观和感觉）都会开始拖放操作。因此，将此属性设置为 true 会对选择的行为方式产生微妙的影响。

      如果使用忽略此属性的外观，您仍然可以通过在列表的 TransferHandler 上调用 exportAsDrag 来开始拖放操作。

      参数：
      b - 是否启用自动拖动处理
      抛出：
      HeadlessException - 如果 b 是 true 并且 GraphicsEnvironment.isHeadless() 返回 true
      自从：
      1.4
      参见：

    • getDragEnabled

      public boolean getDragEnabled()
      返回是否启用自动拖动处理。
      返回：
      dragEnabled 属性的值
      自从：
      1.4
      参见：

    • setDropMode

      public final void setDropMode(DropMode  dropMode)
      设置此组件的放置模式。为了向后兼容，此属性的默认值为 DropMode.USE_SELECTION 。但是，建议使用其中一种其他模式，以改善用户体验。例如，DropMode.ON 提供了类似的将项目显示为选中的行为，但不会影响列表中的实际选择。

      JList 支持以下丢弃模式：

      • DropMode.USE_SELECTION
      • DropMode.ON
      • DropMode.INSERT
      • DropMode.ON_OR_INSERT
      仅当此组件具有接受丢弃的 TransferHandler 时，丢弃模式才有意义。
      参数：
      dropMode - 使用的丢弃模式
      抛出：
      IllegalArgumentException - 如果丢弃模式不受支持或 null
      自从：
      1.6
      参见：

    • getDropMode

      public final DropMode  getDropMode()
      返回此组件的放置模式。
      返回：
      该组件的放置模式
      自从：
      1.6
      参见：

    • getDropLocation

      @BeanProperty (bound =false) public final JList.DropLocation  getDropLocation()
      返回此组件在组件上的 DnD 操作期间应直观指示为放置位置的位置，如果当前没有要显示的位置，则返回 null。

      此方法不适用于从 TransferHandler 查询放置位置，因为放置位置仅在 TransferHandler 的 canImport 返回并允许显示位置后设置。

      当此属性更改时，组件将触发名为“dropLocation”的属性更改事件。

      默认情况下，负责监听此属性的更改并在视觉上指示放置位置的责任在于列表的 ListUI ，它可以直接绘制它和/或安装单元格渲染器来这样做。希望实现自定义放置位置绘制和/或替换默认单元格渲染器的开发人员可能需要遵守此属性。

      返回：
      下降位置
      自从：
      1.6
      参见：

    • getNextMatch

      public int getNextMatch(String  prefix, int startIndex, Position.Bias  bias)
      返回其 toString 值以给定前缀开头的下一个列表元素。
      参数：
      prefix - 用于测试匹配的字符串
      startIndex - 开始搜索的索引
      bias - 搜索方向，Position.Bias.Forward 或 Position.Bias.Backward。
      返回：
      以前缀开头的下一个列表元素的索引；否则-1
      抛出：
      IllegalArgumentException - 如果前缀是 null 或 startIndex 超出范围
      自从：
      1.4

    • getToolTipText

      public String  getToolTipText(MouseEvent  event)
      返回要用于给定事件的工具提示文本。这会覆盖 JComponent 的 getToolTipText 以首先检查单元格渲染器组件以查找发生事件的单元格，并返回其工具提示文本（如果有）。此实现允许您通过在单元格渲染器组件上使用 setToolTipText 来指定单元格级别的工具提示文本。

      Note: 为了让 JList 以这种方式正确显示其渲染器的工具提示，JList 必须是使用 ToolTipManager 注册的组件。此注册在构造函数中自动完成。但是，如果稍后通过调用 setToolTipText(null) 取消注册 JList，渲染器的提示将不再显示。

      重写：
      getToolTipText 在类 JComponent 中
      参数：
      event - MouseEvent 获取工具提示文本
      返回：
      包含工具提示的字符串
      参见：

    • locationToIndex

      public int locationToIndex(Point  location)
      返回列表坐标系中最接近给定位置的单元格索引。要确定单元格是否实际包含指定位置，请将点与单元格的边界进行比较，如 getCellBounds 所提供的。如果模型为空，此方法返回 -1

      这是一个覆盖方法，它委托给列表的 ListUI 中同名的方法。如果列表中没有 ListUI，则返回 -1。

      参数：
      location - 点的坐标
      返回：
      最接近给定位置的单元格索引，或 -1

    • indexToLocation

      public Point  indexToLocation(int index)
      返回列表坐标系中指定项目的原点。如果索引无效，此方法返回 null。

      这是一个覆盖方法，它委托给列表的 ListUI 中同名的方法。如果列表中没有 ListUI，则返回 null。

      参数：
      index - 单元索引
      返回：
      单元格的起源，或null

    • getCellBounds

      public Rectangle  getCellBounds(int index0, int index1)
      返回列表坐标系中由两个索引指定的单元格范围的边界矩形。这些索引可以按任何顺序提供。

      如果较小的索引在列表的单元格范围之外，则此方法返回 null 。如果较小的索引有效，但较大的索引在列表范围之外，则仅返回第一个索引的边界。否则，返回有效范围的边界。

      这是一个覆盖方法，它委托给列表的 ListUI 中同名的方法。如果列表中没有 ListUI，则返回 null。

      参数：
      index0 - 范围内的第一个索引
      index1 - 范围内的第二个索引
      返回：
      单元格范围的边界矩形，或 null

    • getModel

      public ListModel <E > getModel()
      返回包含 JList 组件显示的项目列表的数据模型。
      返回：
      ListModel 提供显示的项目列表
      参见：

    • setModel

      @BeanProperty (visualUpdate =true, description ="The object that contains the data to be drawn by this JList.") public void setModel(ListModel <E > model)
      设置表示列表内容或“值”的模型，通知属性更改监听，然后清除列表的选择。

      这是一个 JavaBeans 绑定属性。

      参数：
      model - 提供要显示的项目列表的 ListModel
      抛出：
      IllegalArgumentException - 如果 model 是 null
      参见：

    • setListData

      public void setListData(E [] listData)
      从项目数组构造一个只读的 ListModel，并使用此模型调用 setModel。

      尝试将 null 值传递给此方法会导致未定义的行为，并且很可能会导致异常。创建的模型直接引用给定的数组。调用此方法后尝试修改数组会导致未定义的行为。

      参数：
      listData - 包含要在列表中显示的项目的 E 数组
      参见：

    • setListData

      public void setListData(Vector <? extends E > listData)
      从 Vector 构造一个只读的 ListModel 并使用此模型调用 setModel。

      尝试将 null 值传递给此方法会导致未定义的行为，并且很可能会导致异常。创建的模型直接引用给定的 Vector。在调用此方法后尝试修改 Vector 会导致未定义的行为。

      参数：
      listData - 一个 Vector 包含要在列表中显示的项目
      参见：

    • createSelectionModel

      protected ListSelectionModel  createSelectionModel()
      返回 DefaultListSelectionModel 的实例；在构造期间调用以初始化列表的选择模型属性。
      返回：
      DefaultListSelecitonModel ，用于在构造期间初始化列表的选择模型属性
      参见：

    • getSelectionModel

      public ListSelectionModel  getSelectionModel()
      返回当前选择模型。选择模型维护列表的选择状态。有关详细信息，请参阅类级别文档。
      返回：
      维护列表选择的 ListSelectionModel
      参见：

    • fireSelectionValueChanged

      protected void fireSelectionValueChanged(int firstIndex, int lastIndex, boolean isAdjusting)
      通知 ListSelectionListener s 直接添加到对选择模型所做的选择更改列表中。 JList 监听对选择模型中的选择所做的更改，并通过调用此方法将通知转发给直接添加到列表中的监听器。

      此方法构造一个 ListSelectionEvent 并将此list作为源和指定的参数，并将其发送到已注册的 ListSelectionListeners 。

      参数：
      firstIndex - 范围内的第一个索引，<= lastIndex
      lastIndex - 范围内的最后一个索引，>= firstIndex
      isAdjusting - 这是否是一系列多个事件中的一个，其中仍在进行更改
      参见：

    • addListSelectionListener

      public void addListSelectionListener(ListSelectionListener  listener)
      向列表添加一个监听器，每次选择发生更改时都会收到通知；监听选择状态变化的首选方式。 JList 负责监听选择模型中的选择状态变化，并将每个变化通知给定的监听器。 ListSelectionEvent 发送给监听器的 source 属性设置为此list。
      参数：
      listener - 要添加的 ListSelectionListener
      参见：

    • removeListSelectionListener

      public void removeListSelectionListener(ListSelectionListener  listener)
      从列表中删除选择监听。
      参数：
      listener - 要删除的 ListSelectionListener
      参见：

    • getListSelectionListeners

      @BeanProperty (bound =false) public ListSelectionListener [] getListSelectionListeners()
      返回通过 addListSelectionListener 添加到此 JList 的所有 ListSelectionListener 的数组。
      返回：
      此list中的所有 ListSelectionListener s，如果未添加任何监听器，则为空数组
      自从：
      1.4
      参见：

    • setSelectionModel

      @BeanProperty (description ="The selection model, recording which cells are selected.") public void setSelectionModel(ListSelectionModel  selectionModel)
      将列表的 selectionModel 设置为非 null ListSelectionModel 实现。选择模型处理进行单一选择、连续范围选择和非连续选择的任务。

      这是一个 JavaBeans 绑定属性。

      参数：
      selectionModel - 实现选择的 ListSelectionModel
      抛出：
      IllegalArgumentException - 如果 selectionModel 是 null
      参见：

    • setSelectionMode

      @BeanProperty (bound =false, enumerationValues ={"ListSelectionModel.SINGLE_SELECTION","ListSelectionModel.SINGLE_INTERVAL_SELECTION","ListSelectionModel.MULTIPLE_INTERVAL_SELECTION"}, description ="The selection mode.") public void setSelectionMode(int selectionMode)
      设置列表的选择模式。这是一个重写方法，直接在选择模型上设置选择模式。

      以下列表描述了可接受的选择模式：

      • ListSelectionModel.SINGLE_SELECTION - 一次只能选择一个列表索引。在这种模式下，setSelectionInterval 和 addSelectionInterval 是等效的，都用第二个参数（“lead”）表示的索引替换当前选择。
      • ListSelectionModel.SINGLE_INTERVAL_SELECTION - 一次只能选择一个连续的间隔。在此模式下，addSelectionInterval 的行为类似于 setSelectionInterval（替换当前选择}，除非给定间隔与现有选择紧邻或重叠，并且可用于扩大选择。
      • ListSelectionModel.MULTIPLE_INTERVAL_SELECTION - 在此模式下，可以选择的内容没有限制。此模式是默认模式。
      参数：
      selectionMode - 选择模式
      抛出：
      IllegalArgumentException - 如果选择模式不是允许的模式之一
      参见：

    • getSelectionMode

      public int getSelectionMode()
      返回列表的当前选择模式。这是一个重写方法，它委托给列表选择模型上的同名方法。
      返回：
      当前选择模式
      参见：

    • getAnchorSelectionIndex

      @BeanProperty (bound =false) public int getAnchorSelectionIndex()
      返回锚点选择索引。这是一个重写方法，它委托给列表选择模型上的同名方法。
      返回：
      锚选择指数
      参见：

    • getLeadSelectionIndex

      @BeanProperty (bound =false, description ="The lead selection index.") public int getLeadSelectionIndex()
      返回潜在客户选择索引。这是一个重写方法，它委托给列表选择模型上的同名方法。
      返回：
      铅选择指数
      参见：

    • getMinSelectionIndex

      @BeanProperty (bound =false) public int getMinSelectionIndex()
      返回最小的选定单元格索引，如果选择为空，则返回 -1。这是一个覆盖方法，它委托给列表选择模型上的同名方法。
      返回：
      最小的选定单元格索引，或 -1
      参见：

    • getMaxSelectionIndex

      @BeanProperty (bound =false) public int getMaxSelectionIndex()
      返回最大的选定单元格索引，如果选择为空，则返回 -1。这是一个覆盖方法，它委托给列表选择模型上的同名方法。
      返回：
      最大的选定单元格索引
      参见：

    • isSelectedIndex

      public boolean isSelectedIndex(int index)
      如果选择了指定的索引，则返回 true，否则返回 false。这是一个覆盖方法，它委托给列表选择模型上的同名方法。
      参数：
      index - 要查询选择状态的索引
      返回：
      true 如果选择了指定的索引，否则 false
      参见：

    • isSelectionEmpty

      @BeanProperty (bound =false) public boolean isSelectionEmpty()
      如果未选择任何内容，则返回 true，否则返回 false。这是一个覆盖方法，它委托给列表选择模型上的同名方法。
      返回：
      true 如果没有选择，否则 false
      参见：

    • clearSelection

      public void clearSelection()
      清除选择；调用此方法后，isSelectionEmpty 将返回 true。这是一个覆盖方法，它委托给列表选择模型上的同名方法。
      参见：

    • setSelectionInterval

      public void setSelectionInterval(int anchor, int lead)
      选择指定的间隔。 anchor 和 lead 索引都包括在内。 anchor 不必小于或等于 lead 。这是一个覆盖方法，它委托给列表选择模型上的同名方法。

      有关如何处理小于 0 的值的详细信息，请参阅正在使用的选择模型类的文档。

      参数：
      anchor - 选择的第一个索引
      lead - 要选择的最后一个索引
      参见：

    • addSelectionInterval

      public void addSelectionInterval(int anchor, int lead)
      将选择设置为指定间隔与当前选择的并集。 anchor 和 lead 索引都包括在内。 anchor 不必小于或等于 lead 。这是一个覆盖方法，它委托给列表选择模型上的同名方法。

      有关如何处理小于 0 的值的详细信息，请参阅正在使用的选择模型类的文档。

      参数：
      anchor - 添加到选择的第一个索引
      lead - 添加到选择中的最后一个索引
      参见：

    • removeSelectionInterval

      public void removeSelectionInterval(int index0, int index1)
      将选区设置为指定区间与当前选区的差值。 index0 和 index1 索引都被删除。 index0 不必小于或等于 index1。这是一个覆盖方法，它委托给列表选择模型上的同名方法。

      有关如何处理小于 0 的值的详细信息，请参阅正在使用的选择模型类的文档。

      参数：
      index0 - 要从选择中删除的第一个索引
      index1 - 要从选择中删除的最后一个索引
      参见：

    • setValueIsAdjusting

      public void setValueIsAdjusting(boolean b)
      设置选择模型的 valueIsAdjusting 属性。当 true 时，即将进行的选择更改应被视为单个更改的一部分。此属性在内部使用，开发人员通常不需要调用此方法。例如，当模型响应用户拖动而更新时，该属性的值在拖动开始时设置为 true，在拖动完成时设置为 false。这允许监听器仅在更改已完成时更新，而不是处理所有中间值。

      如果进行一系列应被视为单个更改的一部分的更改，您可能希望直接使用它。

      这是一个覆盖方法，它委托给列表选择模型上的同名方法。有关详细信息，请参阅 ListSelectionModel.setValueIsAdjusting(boolean) 的文档。

      参数：
      b - 属性的新值
      参见：

    • getValueIsAdjusting

      public boolean getValueIsAdjusting()
      返回选择模型的 isAdjusting 属性的值。

      这是一个重写方法，它委托给列表选择模型上的同名方法。

      返回：
      选择模型的 isAdjusting 属性的值。
      参见：

    • getSelectedIndices

      public int[] getSelectedIndices()
      按递增顺序返回所有选定索引的数组。
      返回：
      所有选定的索引，按升序排列，如果未选择任何内容，则为空数组
      参见：

    • setSelectedIndex

      @BeanProperty (bound =false, description ="The index of the selected cell.") public void setSelectedIndex(int index)
      选择单个单元格。如果给定索引大于或等于模型大小，则不执行任何操作。这是在选择模型上使用 setSelectionInterval 的便捷方法。有关如何处理小于 0 的值的详细信息，请参阅正在使用的选择模型类的文档。
      参数：
      index - 要选择的单元格的索引
      参见：

    • setSelectedIndices

      public void setSelectedIndices(int[] indices)
      将选择更改为给定数组指定的索引集。大于或等于模型大小的索引将被忽略。这是一种清除选择然后在选择模型上使用 addSelectionInterval 添加索引的便捷方法。有关如何处理小于 0 的值的详细信息，请参阅正在使用的选择模型类的文档。
      参数：
      indices - 要选择的单元格索引数组，non-null
      抛出：
      NullPointerException - 如果给定的数组是 null
      参见：

    • getSelectedValues

      @Deprecated @BeanProperty (bound =false) public Object [] getSelectedValues()
      已弃用。
      从 JDK 1.7 开始，由 getSelectedValuesList() 取代
      返回所有选定值的数组，根据它们在列表中的索引按升序排列。
      返回：
      所选值，如果未选择任何内容，则为空数组
      参见：

    • getSelectedValuesList

      @BeanProperty (bound =false) public List <E > getSelectedValuesList()
      返回所有选定项目的列表，根据列表中的索引按升序排列。
      返回：
      所选项目，如果未选择任何内容，则为空列表
      自从：
      1.7
      参见：

    • getSelectedIndex

      public int getSelectedIndex()
      返回最小的选定单元格索引；选择当列表中只有一个项目被选中时。当选择多个项目时，它只是选择最小的索引。如果没有选择，则返回 -1。

      此方法是委托给 getMinSelectionIndex 的覆盖。

      返回：
      最小的选定单元格索引
      参见：

    • getSelectedValue

      @BeanProperty (bound =false) public E  getSelectedValue()
      返回最小选定单元格索引的值；选定的值当列表中只有一个项目被选中时。选择多个项目时，它只是选择的最小索引的值。如果没有选择，则返回 null。

      这是一种简单的方法，它只返回 getMinSelectionIndex 的模型值。

      返回：
      第一个选择的值
      参见：

    • setSelectedValue

      public void setSelectedValue(Object  anObject, boolean shouldScroll)
      从列表中选择指定的对象。如果传递的对象是 null ，则选择被清除。
      参数：
      anObject - 要选择的对象
      shouldScroll - true 如果列表应滚动以显示所选对象（如果存在）；否则false

    • getPreferredScrollableViewportSize

      @BeanProperty (bound =false) public Dimension  getPreferredScrollableViewportSize()
      计算显示 visibleRowCount 行所需的视口大小。此方法返回的值取决于布局方向：

      VERTICAL :
      如果 fixedCellWidth 和 fixedCellHeight 都已设置（明确地或通过指定原型单元值），这是微不足道的。宽度只是 fixedCellWidth 加上列表的水平insets。高度是 fixedCellHeight 乘以 visibleRowCount 加上列表的垂直插入。

      如果未指定 fixedCellWidth 或 fixedCellHeight，则使用试探法。如果模型为空，则宽度为 fixedCellWidth，如果大于 0，或硬编码值 256。高度是 fixedCellHeight 乘以 visibleRowCount，如果 fixedCellHeight 大于 0，否则它是 16 的硬编码值乘以 visibleRowCount。

      如果模型不为空，则宽度是首选尺寸的宽度，通常是最宽列表元素的宽度。高度是索引为 0 的单元格的高度乘以 visibleRowCount 加上列表的垂直插入。

      VERTICAL_WRAP 或 HORIZONTAL_WRAP ：
      此方法仅返回 getPreferredSize 的值。列表的 ListUI 应覆盖 getPreferredSize 以返回适当的值。

      指定者：
      getPreferredScrollableViewportSize 在接口 Scrollable 中
      返回：
      包含显示 visibleRowCount 行所需的视口大小的维度
      参见：

    • getScrollableUnitIncrement

      public int getScrollableUnitIncrement(Rectangle  visibleRect, int orientation, int direction)
      返回滚动以显示下一行或上一行（对于垂直滚动）或列（对于水平滚动）的距离。

      对于水平滚动，如果布局方向为 VERTICAL ，则返回列表的字体大小（如果字体为 null 则为 1 ）。

      指定者：
      getScrollableUnitIncrement 在接口 Scrollable 中
      参数：
      visibleRect - 视口内可见的视图区域
      orientation - SwingConstants.HORIZONTAL 或 SwingConstants.VERTICAL
      direction - 小于或等于零向上/向后滚动，大于零向下/向前
      返回：
      在指定方向滚动的“单位”增量；总是积极的
      抛出：
      IllegalArgumentException - 如果 visibleRect 是 null，或者 orientation 不是 SwingConstants.VERTICAL 或 SwingConstants.HORIZONTAL 之一
      参见：

    • getScrollableBlockIncrement

      public int getScrollableBlockIncrement(Rectangle  visibleRect, int orientation, int direction)
      返回滚动以显示下一个或上一个块的距离。

      对于垂直滚动，使用以下规则：

      • 如果向下滚动，则返回滚动的距离，以便最后一个可见元素成为第一个完全可见的元素
      • 如果向上滚动，则返回滚动的距离，以便第一个可见元素成为最后一个完全可见的元素
      • 如果列表为空，则返回 visibleRect.height

      对于水平滚动，当布局方向为 VERTICAL_WRAP 或 HORIZONTAL_WRAP 时：

      • 如果向右滚动，则返回滚动的距离，以便最后一个可见元素成为第一个完全可见的元素
      • 如果向左滚动，则返回滚动的距离，以便第一个可见元素成为最后一个完全可见的元素
      • 如果列表为空，则返回 visibleRect.width

      对于水平滚动和 VERTICAL 方向，返回 visibleRect.width 。

      请注意，visibleRect 的值必须等于 this.getVisibleRect()。

      指定者：
      getScrollableBlockIncrement 在接口 Scrollable 中
      参数：
      visibleRect - 视口内可见的视图区域
      orientation - SwingConstants.HORIZONTAL 或 SwingConstants.VERTICAL
      direction - 小于或等于零向上/向后滚动，大于零向下/向前
      返回：
      在指定方向滚动的“块”增量；总是积极的
      抛出：
      IllegalArgumentException - 如果 visibleRect 是 null，或者 orientation 不是 SwingConstants.VERTICAL 或 SwingConstants.HORIZONTAL 之一
      参见：

    • getScrollableTracksViewportWidth

      @BeanProperty (bound =false) public boolean getScrollableTracksViewportWidth()
      如果此 JList 显示在 JViewport 中并且视口比列表的首选宽度宽，或者布局方向为 HORIZONTAL_WRAP 和 visibleRowCount <= 0 ，则返回 true；否则返回 false 。

      如果是 false ，则不跟踪视口的宽度。如果 JViewport 本身嵌入在 JScrollPane 中，这允许水平滚动。

      指定者：
      getScrollableTracksViewportWidth 在接口 Scrollable 中
      返回：
      封闭的视口是否应该强制列表的宽度匹配它自己的
      参见：

    • getScrollableTracksViewportHeight

      @BeanProperty (bound =false) public boolean getScrollableTracksViewportHeight()
      如果此 JList 显示在 JViewport 中并且视口高于列表的首选高度，或者布局方向为 VERTICAL_WRAP 和 visibleRowCount <= 0 ，则返回 true；否则返回 false 。

      如果是 false ，则不跟踪视口的高度。如果 JViewport 本身嵌入在 JScrollPane 中，这将允许垂直滚动。

      指定者：
      getScrollableTracksViewportHeight 在接口 Scrollable 中
      返回：
      封闭的视口是否应该强制列表的高度与其自身的高度相匹配
      参见：

    • paramString

      protected String  paramString()
      返回此 JList 的 String 表示。此方法仅用于调试目的，返回的 String 的内容和格式可能因实现而异。返回的 String 可能为空，但可能不是 null 。
      重写：
      paramString 在类 JComponent 中
      返回：
      这个 JList 的 String 表示。

    • getAccessibleContext

      @BeanProperty (bound =false) public AccessibleContext  getAccessibleContext()
      获取与此 JList 关联的 AccessibleContext。对于 JList，AccessibleContext 采用 AccessibleJList 的形式。

      如有必要，将创建一个新的 AccessibleJList 实例。

      指定者：
      getAccessibleContext 在接口 Accessible 中
      重写：
      getAccessibleContext 在类 Component 中
      返回：
      一个 AccessibleJList 作为这个 JList 的 AccessibleContext