# Class JList<E>

java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
javax.swing.JList<E>

Type Parameters:
  `E` - the type of the elements of this list

All Implemented Interfaces:
  `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
A component that displays a list of objects and allows the user to select one or more items. A separate model, `ListModel`, maintains the contents of the list.

It's easy to display an array or Vector of objects, using the `JList` constructor that automatically builds a read-only `ListModel` instance for you:

    // 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));
    }

A `ListModel` can be supplied directly to a `JList` by way of a constructor or the `setModel` method. The contents need not be static - the number of items, and the values of items can change over time. A correct `ListModel` implementation notifies the set of `javax.swing.event.ListDataListener`s that have been added to it, each time a change occurs. These changes are characterized by a `javax.swing.event.ListDataEvent`, which identifies the range of list indices that have been modified, added, or removed. `JList`'s `ListUI` is responsible for keeping the visual representation up to date with changes, by listening to the model.

Simple, dynamic-content, `JList` applications can use the `DefaultListModel` class to maintain list elements. This class implements the `ListModel` interface and also provides a `java.util.Vector`-like API. Applications that need a more custom `ListModel` implementation may instead wish to subclass `AbstractListModel`, which provides basic support for managing and notifying listeners. For example, a read-only implementation of `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; }
    };

The selection state of a `JList` is managed by another separate model, an instance of `ListSelectionModel`. `JList` is initialized with a selection model on construction, and also contains methods to query or set this selection model. Additionally, `JList` provides convenient methods for easily managing the selection. These methods, such as `setSelectedIndex` and `getSelectedValue`, are cover methods that take care of the details of interacting with the selection model. By default, `JList`'s selection model is configured to allow any combination of items to be selected at a time; selection mode `MULTIPLE_INTERVAL_SELECTION`. The selection mode can be changed on the selection model directly, or via `JList`'s cover method. Responsibility for updating the selection model in response to user gestures lies with the list's `ListUI`.

A correct `ListSelectionModel` implementation notifies the set of `javax.swing.event.ListSelectionListener`s that have been added to it each time a change to the selection occurs. These changes are characterized by a `javax.swing.event.ListSelectionEvent`, which identifies the range of the selection change.

The preferred way to listen for changes in list selection is to add `ListSelectionListener`s directly to the `JList`. `JList` then takes care of listening to the selection model and notifying your listeners of change.

Responsibility for listening to selection changes in order to keep the list's visual representation up to date lies with the list's `ListUI`.

Painting of cells in a `JList` is handled by a delegate called a cell renderer, installed on the list as the `cellRenderer` property. The renderer provides a `java.awt.Component` that is used like a "rubber stamp" to paint the cells. Each time a cell needs to be painted, the list's `ListUI` asks the cell renderer for the component, moves it into place, and has it paint the contents of the cell by way of its `paint` method. A default cell renderer, which uses a `JLabel` component to render, is installed by the lists's `ListUI`. You can substitute your own renderer using code like this:

     // 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());

Another job for the cell renderer is in helping to determine sizing information for the list. By default, the list's `ListUI` determines the size of cells by asking the cell renderer for its preferred size for each list item. This can be expensive for large lists of items. To avoid these calculations, you can set a `fixedCellWidth` and `fixedCellHeight` on the list, or have these values calculated automatically based on a single prototype value:

    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` doesn't implement scrolling directly. To create a list that scrolls, make it the viewport view of a `JScrollPane`. For example:

    JScrollPane scrollPane = new JScrollPane(myList);

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

`JList` doesn't provide any special handling of double or triple (or N) mouse clicks, but it's easy to add a `MouseListener` if you wish to take action on these events. Use the `locationToIndex` method to determine what cell was clicked. For example:

    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 is not thread safe. For more information see Swing's Threading Policy.

Warning: Serialized objects of this class will not be compatible with future Swing releases. The current serialization support is appropriate for short term storage or RMI between applications running the same version of Swing. As of 1.4, support for long term storage of all JavaBeans has been added to the `java.beans` package. Please see `XMLEncoder`.

See How to Use Lists in The Java Tutorial for further documentation.

Since:
  1.2
See Also:
  - `ListModel`
  - `AbstractListModel`
  - `DefaultListModel`
  - `ListSelectionModel`
  - `DefaultListSelectionModel`
  - `ListCellRenderer`
  - `DefaultListCellRenderer`

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`protected class`
`JList.AccessibleJList`
This class implements accessibility support for the `JList` class.
`static final class`
`JList.DropLocation`
A subclass of `TransferHandler.DropLocation` representing a drop location for a `JList`.

### Nested classes/interfaces declared in class JComponent

`JComponent.AccessibleJComponent`
Modifier and Type
Class
Description
`class`
`JComponent.AccessibleJComponent`
Inner class of JComponent used to provide default support for accessibility.

### Nested classes/interfaces declared in class Container

`Container.AccessibleAWTContainer`
Modifier and Type
Class
Description
`protected class`
`Container.AccessibleAWTContainer`
Inner class of Container used to provide default support for accessibility.

### Nested classes/interfaces declared in class Component

`Component.AccessibleAWTComponent, Component.BaselineResizeBehavior, Component.BltBufferStrategy, Component.FlipBufferStrategy`
Modifier and Type
Class
Description
`protected class`
`Component.AccessibleAWTComponent`
Inner class of Component used to provide default support for accessibility.
`static enum`
`Component.BaselineResizeBehavior`
Enumeration of the common ways the baseline of a component can change as the size changes.
`protected class`
`Component.BltBufferStrategy`
Inner class for blitting offscreen surfaces to a component.
`protected class`
`Component.FlipBufferStrategy`
Inner class for flipping buffers on a component.

## Field Summary

Fields
Modifier and Type
Field
Description
`static final int`
`HORIZONTAL_WRAP`
Indicates a "newspaper style" layout with cells flowing horizontally then vertically.
`static final int`
`VERTICAL`
Indicates a vertical layout of cells, in a single column; the default layout.
`static final int`
`VERTICAL_WRAP`
Indicates a "newspaper style" layout with cells flowing vertically then horizontally.

### Fields declared in class JComponent

`listenerList, TOOL_TIP_TEXT_KEY, ui, UNDEFINED_CONDITION, WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, WHEN_FOCUSED, WHEN_IN_FOCUSED_WINDOW`
Modifier and Type
Field
Description
`protected EventListenerList`
`listenerList`
A list of event listeners for this component.
`static final String`
`TOOL_TIP_TEXT_KEY`
The comment to display when the cursor is over the component, also known as a "value tip", "flyover help", or "flyover label".
`protected ComponentUI`
`ui`
The look and feel delegate for this component.
`static final int`
`UNDEFINED_CONDITION`
Constant used by some of the APIs to mean that no condition is defined.
`static final int`
`WHEN_ANCESTOR_OF_FOCUSED_COMPONENT`
Constant used for `registerKeyboardAction` that means that the command should be invoked when the receiving component is an ancestor of the focused component or is itself the focused component.
`static final int`
`WHEN_FOCUSED`
Constant used for `registerKeyboardAction` that means that the command should be invoked when the component has the focus.
`static final int`
`WHEN_IN_FOCUSED_WINDOW`
Constant used for `registerKeyboardAction` that means that the command should be invoked when the receiving component is in the window that has the focus or is itself the focused component.

### Fields declared in class Component

`accessibleContext, BOTTOM_ALIGNMENT, CENTER_ALIGNMENT, LEFT_ALIGNMENT, RIGHT_ALIGNMENT, TOP_ALIGNMENT`
Modifier and Type
Field
Description
`protected AccessibleContext`
`accessibleContext`
The `AccessibleContext` associated with this `Component`.
`static final float`
`BOTTOM_ALIGNMENT`
Ease-of-use constant for `getAlignmentY`.
`static final float`
`CENTER_ALIGNMENT`
Ease-of-use constant for `getAlignmentY` and `getAlignmentX`.
`static final float`
`LEFT_ALIGNMENT`
Ease-of-use constant for `getAlignmentX`.
`static final float`
`RIGHT_ALIGNMENT`
Ease-of-use constant for `getAlignmentX`.
`static final float`
`TOP_ALIGNMENT`
Ease-of-use constant for `getAlignmentY()`.

### Fields declared in interface ImageObserver

`ABORT, ALLBITS, ERROR, FRAMEBITS, HEIGHT, PROPERTIES, SOMEBITS, WIDTH`
Modifier and Type
Field
Description
`static final int`
`ABORT`
This flag in the infoflags argument to imageUpdate indicates that an image which was being tracked asynchronously was aborted before production was complete.
`static final int`
`ALLBITS`
This flag in the infoflags argument to imageUpdate indicates that a static image which was previously drawn is now complete and can be drawn again in its final form.
`static final int`
`ERROR`
This flag in the infoflags argument to imageUpdate indicates that an image which was being tracked asynchronously has encountered an error.
`static final int`
`FRAMEBITS`
This flag in the infoflags argument to imageUpdate indicates that another complete frame of a multi-frame image which was previously drawn is now available to be drawn again.
`static final int`
`HEIGHT`
This flag in the infoflags argument to imageUpdate indicates that the height of the base image is now available and can be taken from the height argument to the imageUpdate callback method.
`static final int`
`PROPERTIES`
This flag in the infoflags argument to imageUpdate indicates that the properties of the image are now available.
`static final int`
`SOMEBITS`
This flag in the infoflags argument to imageUpdate indicates that more pixels needed for drawing a scaled variation of the image are available.
`static final int`
`WIDTH`
This flag in the infoflags argument to imageUpdate indicates that the width of the base image is now available and can be taken from the width argument to the imageUpdate callback method.

## Constructor Summary

Constructors
Constructor
Description
`JList()`
Constructs a `JList` with an empty, read-only, model.
`JList(E[] listData)`
Constructs a `JList` that displays the elements in the specified array.
`JList(Vector<? extends E> listData)`
Constructs a `JList` that displays the elements in the specified `Vector`.
`JList(ListModel<E> dataModel)`
Constructs a `JList` that displays elements from the specified, `non-null`, model.

## Method Summary

Modifier and Type
Method
Description
`void`
`addListSelectionListener(ListSelectionListener listener)`
Adds a listener to the list, to be notified each time a change to the selection occurs; the preferred way of listening for selection state changes.
`void`
`addSelectionInterval(int anchor, int lead)`
Sets the selection to be the union of the specified interval with current selection.
`void`
`clearSelection()`
Clears the selection; after calling this method, `isSelectionEmpty` will return `true`.
`protected ListSelectionModel`
`createSelectionModel()`
Returns an instance of `DefaultListSelectionModel`; called during construction to initialize the list's selection model property.
`void`
`ensureIndexIsVisible(int index)`
Scrolls the list within an enclosing viewport to make the specified cell completely visible.
`protected void`
`fireSelectionValueChanged(int firstIndex, int lastIndex, boolean isAdjusting)`
Notifies `ListSelectionListener`s added directly to the list of selection changes made to the selection model.
`AccessibleContext`
`getAccessibleContext()`
Gets the `AccessibleContext` associated with this `JList`.
`int`
`getAnchorSelectionIndex()`
Returns the anchor selection index.
`Rectangle`
`getCellBounds(int index0, int index1)`
Returns the bounding rectangle, in the list's coordinate system, for the range of cells specified by the two indices.
`ListCellRenderer<? super E>`
`getCellRenderer()`
Returns the object responsible for painting list items.
`boolean`
`getDragEnabled()`
Returns whether or not automatic drag handling is enabled.
`final JList.DropLocation`
`getDropLocation()`
Returns the location that this component should visually indicate as the drop location during a DnD operation over the component, or `null` if no location is to currently be shown.
`final DropMode`
`getDropMode()`
Returns the drop mode for this component.
`int`
`getFirstVisibleIndex()`
Returns the smallest list index that is currently visible.
`int`
`getFixedCellHeight()`
Returns the value of the `fixedCellHeight` property.
`int`
`getFixedCellWidth()`
Returns the value of the `fixedCellWidth` property.
`int`
`getLastVisibleIndex()`
Returns the largest list index that is currently visible.
`int`
`getLayoutOrientation()`
Returns the layout orientation property for the list: `VERTICAL` if the layout is a single column of cells, `VERTICAL_WRAP` if the layout is "newspaper style" with the content flowing vertically then horizontally, or `HORIZONTAL_WRAP` if the layout is "newspaper style" with the content flowing horizontally then vertically.
`int`
`getLeadSelectionIndex()`
Returns the lead selection index.
`ListSelectionListener[]`
`getListSelectionListeners()`
Returns an array of all the `ListSelectionListener`s added to this `JList` by way of `addListSelectionListener`.
`int`
`getMaxSelectionIndex()`
Returns the largest selected cell index, or `-1` if the selection is empty.
`int`
`getMinSelectionIndex()`
Returns the smallest selected cell index, or `-1` if the selection is empty.
`ListModel<E>`
`getModel()`
Returns the data model that holds the list of items displayed by the `JList` component.
`int`
`getNextMatch(String prefix, int startIndex, Position.Bias bias)`
Returns the next list element whose `toString` value starts with the given prefix.
`Dimension`
`getPreferredScrollableViewportSize()`
Computes the size of viewport needed to display `visibleRowCount` rows.
`E`
`getPrototypeCellValue()`
Returns the "prototypical" cell value -- a value used to calculate a fixed width and height for cells.
`int`
`getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction)`
Returns the distance to scroll to expose the next or previous block.
`boolean`
`getScrollableTracksViewportHeight()`
Returns `true` if this `JList` is displayed in a `JViewport` and the viewport is taller than the list's preferred height, or if the layout orientation is `VERTICAL_WRAP` and `visibleRowCount <= 0`; otherwise returns `false`.
`boolean`
`getScrollableTracksViewportWidth()`
Returns `true` if this `JList` is displayed in a `JViewport` and the viewport is wider than the list's preferred width, or if the layout orientation is `HORIZONTAL_WRAP` and `visibleRowCount <= 0`; otherwise returns `false`.
`int`
`getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction)`
Returns the distance to scroll to expose the next or previous row (for vertical scrolling) or column (for horizontal scrolling).
`int`
`getSelectedIndex()`
Returns the smallest selected cell index; the selection when only a single item is selected in the list.
`int[]`
`getSelectedIndices()`
Returns an array of all of the selected indices, in increasing order.
`E`
`getSelectedValue()`
Returns the value for the smallest selected cell index; the selected value when only a single item is selected in the list.
`Object[]`
`getSelectedValues()`
Deprecated.
As of JDK 1.7, replaced by `getSelectedValuesList()`
`List<E>`
`getSelectedValuesList()`
Returns a list of all the selected items, in increasing order based on their indices in the list.
`Color`
`getSelectionBackground()`
Returns the color used to draw the background of selected items.
`Color`
`getSelectionForeground()`
Returns the color used to draw the foreground of selected items.
`int`
`getSelectionMode()`
Returns the current selection mode for the list.
`ListSelectionModel`
`getSelectionModel()`
Returns the current selection model.
`String`
`getToolTipText(MouseEvent event)`
Returns the tooltip text to be used for the given event.
`ListUI`
`getUI()`
Returns the `ListUI`, the look and feel object that renders this component.
`String`
`getUIClassID()`
Returns `"ListUI"`, the `UIDefaults` key used to look up the name of the `javax.swing.plaf.ListUI` class that defines the look and feel for this component.
`boolean`
`getValueIsAdjusting()`
Returns the value of the selection model's `isAdjusting` property.
`int`
`getVisibleRowCount()`
Returns the value of the `visibleRowCount` property.
`Point`
`indexToLocation(int index)`
Returns the origin of the specified item in the list's coordinate system.
`boolean`
`isSelectedIndex(int index)`
Returns `true` if the specified index is selected, else `false`.
`boolean`
`isSelectionEmpty()`
Returns `true` if nothing is selected, else `false`.
`int`
`locationToIndex(Point location)`
Returns the cell index closest to the given location in the list's coordinate system.
`protected String`
`paramString()`
Returns a `String` representation of this `JList`.
`void`
`removeListSelectionListener(ListSelectionListener listener)`
Removes a selection listener from the list.
`void`
`removeSelectionInterval(int index0, int index1)`
Sets the selection to be the set difference of the specified interval and the current selection.
`void`
`setCellRenderer(ListCellRenderer<? super E> cellRenderer)`
Sets the delegate that is used to paint each cell in the list.
`void`
`setDragEnabled(boolean b)`
Turns on or off automatic drag handling.
`final void`
`setDropMode(DropMode dropMode)`
Sets the drop mode for this component.
`void`
`setFixedCellHeight(int height)`
Sets a fixed value to be used for the height of every cell in the list.
`void`
`setFixedCellWidth(int width)`
Sets a fixed value to be used for the width of every cell in the list.
`void`
`setLayoutOrientation(int layoutOrientation)`
Defines the way list cells are laid out.
`void`
`setListData(E[] listData)`
Constructs a read-only `ListModel` from an array of items, and calls `setModel` with this model.
`void`
`setListData(Vector<? extends E> listData)`
Constructs a read-only `ListModel` from a `Vector` and calls `setModel` with this model.
`void`
`setModel(ListModel<E> model)`
Sets the model that represents the contents or "value" of the list, notifies property change listeners, and then clears the list's selection.
`void`
`setPrototypeCellValue(E prototypeCellValue)`
Sets the `prototypeCellValue` property, and then (if the new value is `non-null`), computes the `fixedCellWidth` and `fixedCellHeight` properties by requesting the cell renderer component for the given value (and index 0) from the cell renderer, and using that component's preferred size.
`void`
`setSelectedIndex(int index)`
Selects a single cell.
`void`
`setSelectedIndices(int[] indices)`
Changes the selection to be the set of indices specified by the given array.
`void`
`setSelectedValue(Object anObject, boolean shouldScroll)`
Selects the specified object from the list.
`void`
`setSelectionBackground(Color selectionBackground)`
Sets the color used to draw the background of selected items, which cell renderers can use fill selected cells.
`void`
`setSelectionForeground(Color selectionForeground)`
Sets the color used to draw the foreground of selected items, which cell renderers can use to render text and graphics.
`void`
`setSelectionInterval(int anchor, int lead)`
Selects the specified interval.
`void`
`setSelectionMode(int selectionMode)`
Sets the selection mode for the list.
`void`
`setSelectionModel(ListSelectionModel selectionModel)`
Sets the `selectionModel` for the list to a non-`null` `ListSelectionModel` implementation.
`void`
`setUI(ListUI ui)`
Sets the `ListUI`, the look and feel object that renders this component.
`void`
`setValueIsAdjusting(boolean b)`
Sets the selection model's `valueIsAdjusting` property.
`void`
`setVisibleRowCount(int visibleRowCount)`
Sets the `visibleRowCount` property, which has different meanings depending on the layout orientation: For a `VERTICAL` layout orientation, this sets the preferred number of rows to display without requiring scrolling; for other orientations, it affects the wrapping of cells.
`void`
`updateUI()`
Resets the `ListUI` property by setting it to the value provided by the current look and feel.

### Methods declared in class JComponent

`addAncestorListener, addNotify, addVetoableChangeListener, computeVisibleRect, contains, createToolTip, disable, enable, firePropertyChange, firePropertyChange, fireVetoableChange, getActionForKeyStroke, getActionMap, getAlignmentX, getAlignmentY, getAncestorListeners, getAutoscrolls, getBaseline, getBaselineResizeBehavior, getBorder, getBounds, getClientProperty, getComponentGraphics, getComponentPopupMenu, getConditionForKeyStroke, getDebugGraphicsOptions, getDefaultLocale, getFontMetrics, getGraphics, getHeight, getInheritsPopupMenu, getInputMap, getInputMap, getInputVerifier, getInsets, getInsets, getListeners, getLocation, getMaximumSize, getMinimumSize, getNextFocusableComponent, getPopupLocation, getPreferredSize, getRegisteredKeyStrokes, getRootPane, getSize, getToolTipLocation, getToolTipText, getTopLevelAncestor, getTransferHandler, getVerifyInputWhenFocusTarget, getVetoableChangeListeners, getVisibleRect, getWidth, getX, getY, grabFocus, hide, isDoubleBuffered, isLightweightComponent, isManagingFocus, isOpaque, isOptimizedDrawingEnabled, isPaintingForPrint, isPaintingOrigin, isPaintingTile, isRequestFocusEnabled, isValidateRoot, paint, paintBorder, paintChildren, paintComponent, paintImmediately, paintImmediately, print, printAll, printBorder, printChildren, printComponent, processComponentKeyEvent, processKeyBinding, processKeyEvent, processMouseEvent, processMouseMotionEvent, putClientProperty, registerKeyboardAction, registerKeyboardAction, removeAncestorListener, removeNotify, removeVetoableChangeListener, repaint, repaint, requestDefaultFocus, requestFocus, requestFocus, requestFocusInWindow, requestFocusInWindow, resetKeyboardActions, reshape, revalidate, scrollRectToVisible, setActionMap, setAlignmentX, setAlignmentY, setAutoscrolls, setBackground, setBorder, setComponentPopupMenu, setDebugGraphicsOptions, setDefaultLocale, setDoubleBuffered, setEnabled, setFocusTraversalKeys, setFont, setForeground, setInheritsPopupMenu, setInputMap, setInputVerifier, setMaximumSize, setMinimumSize, setNextFocusableComponent, setOpaque, setPreferredSize, setRequestFocusEnabled, setToolTipText, setTransferHandler, setUI, setVerifyInputWhenFocusTarget, setVisible, unregisterKeyboardAction, update`
Modifier and Type
Method
Description
`void`
`addAncestorListener(AncestorListener listener)`
Registers `listener` so that it will receive `AncestorEvents` when it or any of its ancestors move or are made visible or invisible.
`void`
`addNotify()`
Notifies this component that it now has a parent component.
`void`
`addVetoableChangeListener(VetoableChangeListener listener)`
Adds a `VetoableChangeListener` to the listener list.
`void`
`computeVisibleRect(Rectangle visibleRect)`
Returns the `Component`'s "visible rect rectangle" - the intersection of the visible rectangles for this component and all of its ancestors.
`boolean`
`contains(int x, int y)`
Gives the UI delegate an opportunity to define the precise shape of this component for the sake of mouse processing.
`JToolTip`
`createToolTip()`
Returns the instance of `JToolTip` that should be used to display the tooltip.
`void`
`disable()`
Deprecated.
As of JDK version 1.1, replaced by `java.awt.Component.setEnabled(boolean)`.
`void`
`enable()`
Deprecated.
As of JDK version 1.1, replaced by `java.awt.Component.setEnabled(boolean)`.
`void`
`firePropertyChange(String propertyName, boolean oldValue, boolean newValue)`
Support for reporting bound property changes for boolean properties.
`void`
`firePropertyChange(String propertyName, int oldValue, int newValue)`
Support for reporting bound property changes for integer properties.
`protected void`
`fireVetoableChange(String propertyName, Object oldValue, Object newValue)`
Supports reporting constrained property changes.
`ActionListener`
`getActionForKeyStroke(KeyStroke aKeyStroke)`
Returns the object that will perform the action registered for a given keystroke.
`final ActionMap`
`getActionMap()`
Returns the `ActionMap` used to determine what `Action` to fire for particular `KeyStroke` binding.
`float`
`getAlignmentX()`
Overrides `Container.getAlignmentX` to return the horizontal alignment.
`float`
`getAlignmentY()`
Overrides `Container.getAlignmentY` to return the vertical alignment.
`AncestorListener[]`
`getAncestorListeners()`
Returns an array of all the ancestor listeners registered on this component.
`boolean`
`getAutoscrolls()`
Gets the `autoscrolls` property.
`int`
`getBaseline(int width, int height)`
Returns the baseline.
`Component.BaselineResizeBehavior`
`getBaselineResizeBehavior()`
Returns an enum indicating how the baseline of the component changes as the size changes.
`Border`
`getBorder()`
Returns the border of this component or `null` if no border is currently set.
`Rectangle`
`getBounds(Rectangle rv)`
Stores the bounds of this component into "return value" `rv` and returns `rv`.
`final Object`
`getClientProperty(Object key)`
Returns the value of the property with the specified key.
`protected Graphics`
`getComponentGraphics(Graphics g)`
Returns the graphics object used to paint this component.
`JPopupMenu`
`getComponentPopupMenu()`
Returns `JPopupMenu` that assigned for this component.
`int`
`getConditionForKeyStroke(KeyStroke aKeyStroke)`
Returns the condition that determines whether a registered action occurs in response to the specified keystroke.
`int`
`getDebugGraphicsOptions()`
Returns the state of graphics debugging.
`static Locale`
`getDefaultLocale()`
Returns the default locale used to initialize each JComponent's locale property upon creation.
`FontMetrics`
`getFontMetrics(Font font)`
Gets the `FontMetrics` for the specified `Font`.
`Graphics`
`getGraphics()`
Returns this component's graphics context, which lets you draw on a component.
`int`
`getHeight()`
Returns the current height of this component.
`boolean`
`getInheritsPopupMenu()`
Returns true if the JPopupMenu should be inherited from the parent.
`final InputMap`
`getInputMap()`
Returns the `InputMap` that is used when the component has focus.
`final InputMap`
`getInputMap(int condition)`
Returns the `InputMap` that is used during `condition`.
`InputVerifier`
`getInputVerifier()`
Returns the input verifier for this component.
`Insets`
`getInsets()`
If a border has been set on this component, returns the border's insets; otherwise calls `super.getInsets`.
`Insets`
`getInsets(Insets insets)`
Returns an `Insets` object containing this component's inset values.
`<T extends EventListener>
T[]`
`getListeners(Class<T> listenerType)`
Returns an array of all the objects currently registered as `FooListener`s upon this `JComponent`.
`Point`
`getLocation(Point rv)`
Stores the x,y origin of this component into "return value" `rv` and returns `rv`.
`Dimension`
`getMaximumSize()`
If the maximum size has been set to a non-`null` value just returns it.
`Dimension`
`getMinimumSize()`
If the minimum size has been set to a non-`null` value just returns it.
`Component`
`getNextFocusableComponent()`
Deprecated.
As of 1.4, replaced by `FocusTraversalPolicy`.
`Point`
`getPopupLocation(MouseEvent event)`
Returns the preferred location to display the popup menu in this component's coordinate system.
`Dimension`
`getPreferredSize()`
If the `preferredSize` has been set to a non-`null` value just returns it.
`KeyStroke[]`
`getRegisteredKeyStrokes()`
Returns the `KeyStrokes` that will initiate registered actions.
`JRootPane`
`getRootPane()`
Returns the `JRootPane` ancestor for this component.
`Dimension`
`getSize(Dimension rv)`
Stores the width/height of this component into "return value" `rv` and returns `rv`.
`Point`
`getToolTipLocation(MouseEvent event)`
Returns the tooltip location in this component's coordinate system.
`String`
`getToolTipText()`
Returns the tooltip string that has been set with `setToolTipText`.
`Container`
`getTopLevelAncestor()`
Returns the top-level ancestor of this component (the containing `Window`) or `null` if this component has not been added to any container.
`TransferHandler`
`getTransferHandler()`
Gets the `transferHandler` property.
`boolean`
`getVerifyInputWhenFocusTarget()`
Returns the value that indicates whether the input verifier for the current focus owner will be called before this component requests focus.
`VetoableChangeListener[]`
`getVetoableChangeListeners()`
Returns an array of all the vetoable change listeners registered on this component.
`Rectangle`
`getVisibleRect()`
Returns the `Component`'s "visible rectangle" - the intersection of this component's visible rectangle, `new Rectangle(0, 0, getWidth(), getHeight())`, and all of its ancestors' visible rectangles.
`int`
`getWidth()`
Returns the current width of this component.
`int`
`getX()`
Returns the current x coordinate of the component's origin.
`int`
`getY()`
Returns the current y coordinate of the component's origin.
`void`
`grabFocus()`
Requests that this Component get the input focus, and that this Component's top-level ancestor become the focused Window.
`void`
`hide()`
Deprecated.
`boolean`
`isDoubleBuffered()`
Returns whether this component should use a buffer to paint.
`static boolean`
`isLightweightComponent(Component c)`
Returns true if this component is lightweight, that is, if it doesn't have a native window system peer.
`boolean`
`isManagingFocus()`
Deprecated.
As of 1.4, replaced by `Component.setFocusTraversalKeys(int, Set)` and `Container.setFocusCycleRoot(boolean)`.
`boolean`
`isOpaque()`
Returns true if this component is completely opaque.
`boolean`
`isOptimizedDrawingEnabled()`
Returns true if this component tiles its children -- that is, if it can guarantee that the children will not overlap.
`final boolean`
`isPaintingForPrint()`
Returns `true` if the current painting operation on this component is part of a `print` operation.
`protected boolean`
`isPaintingOrigin()`
Returns `true` if a paint triggered on a child component should cause painting to originate from this Component, or one of its ancestors.
`boolean`
`isPaintingTile()`
Returns true if the component is currently painting a tile.
`boolean`
`isRequestFocusEnabled()`
Returns `true` if this `JComponent` should get focus; otherwise returns `false`.
`boolean`
`isValidateRoot()`
If this method returns true, `revalidate` calls by descendants of this component will cause the entire tree beginning with this root to be validated.
`void`
`paint(Graphics g)`
Invoked by Swing to draw components.
`protected void`
`paintBorder(Graphics g)`
Paints the component's border.
`protected void`
`paintChildren(Graphics g)`
Paints this component's children.
`protected void`
`paintComponent(Graphics g)`
Calls the UI delegate's paint method, if the UI delegate is non-`null`.
`void`
`paintImmediately(int x, int y, int w, int h)`
Paints the specified region in this component and all of its descendants that overlap the region, immediately.
`void`
`paintImmediately(Rectangle r)`
Paints the specified region now.
`void`
`print(Graphics g)`
Invoke this method to print the component to the specified `Graphics`.
`void`
`printAll(Graphics g)`
Invoke this method to print the component.
`protected void`
`printBorder(Graphics g)`
Prints the component's border.
`protected void`
`printChildren(Graphics g)`
Prints this component's children.
`protected void`
`printComponent(Graphics g)`
This is invoked during a printing operation.
`protected void`
`processComponentKeyEvent(KeyEvent e)`
Processes any key events that the component itself recognizes.
`protected boolean`
`processKeyBinding(KeyStroke ks, KeyEvent e, int condition, boolean pressed)`
Invoked to process the key bindings for `ks` as the result of the `KeyEvent` `e`.
`protected void`
`processKeyEvent(KeyEvent e)`
Overrides `processKeyEvent` to process events.
`protected void`
`processMouseEvent(MouseEvent e)`
Processes mouse events occurring on this component by dispatching them to any registered `MouseListener` objects, refer to `Component.processMouseEvent(MouseEvent)` for a complete description of this method.
`protected void`
`processMouseMotionEvent(MouseEvent e)`
Processes mouse motion events, such as MouseEvent.MOUSE_DRAGGED.
`final void`
`putClientProperty(Object key, Object value)`
Adds an arbitrary key/value "client property" to this component.
`void`
`registerKeyboardAction(ActionListener anAction, String aCommand, KeyStroke aKeyStroke, int aCondition)`
This method is now obsolete, please use a combination of `getActionMap()` and `getInputMap()` for similar behavior.
`void`
`registerKeyboardAction(ActionListener anAction, KeyStroke aKeyStroke, int aCondition)`
This method is now obsolete, please use a combination of `getActionMap()` and `getInputMap()` for similar behavior.
`void`
`removeAncestorListener(AncestorListener listener)`
Unregisters `listener` so that it will no longer receive `AncestorEvents`.
`void`
`removeNotify()`
Notifies this component that it no longer has a parent component.
`void`
`removeVetoableChangeListener(VetoableChangeListener listener)`
Removes a `VetoableChangeListener` from the listener list.
`void`
`repaint(long tm, int x, int y, int width, int height)`
Adds the specified region to the dirty region list if the component is showing.
`void`
`repaint(Rectangle r)`
Adds the specified region to the dirty region list if the component is showing.
`boolean`
`requestDefaultFocus()`
Deprecated.
As of 1.4, replaced by `FocusTraversalPolicy.getDefaultComponent(Container).requestFocus()`
`void`
`requestFocus()`
Requests that this `Component` gets the input focus.
`boolean`
`requestFocus(boolean temporary)`
Requests that this `Component` gets the input focus.
`boolean`
`requestFocusInWindow()`
Requests that this `Component` gets the input focus.
`protected boolean`
`requestFocusInWindow(boolean temporary)`
Requests that this `Component` gets the input focus.
`void`
`resetKeyboardActions()`
Unregisters all the bindings in the first tier `InputMaps` and `ActionMap`.
`void`
`reshape(int x, int y, int w, int h)`
Deprecated.
As of JDK 5, replaced by `Component.setBounds(int, int, int, int)`.
`void`
`revalidate()`
Supports deferred automatic layout.
`void`
`scrollRectToVisible(Rectangle aRect)`
Forwards the `scrollRectToVisible()` message to the `JComponent`'s parent.
`final void`
`setActionMap(ActionMap am)`
Sets the `ActionMap` to `am`.
`void`
`setAlignmentX(float alignmentX)`
Sets the horizontal alignment.
`void`
`setAlignmentY(float alignmentY)`
Sets the vertical alignment.
`void`
`setAutoscrolls(boolean autoscrolls)`
Sets the `autoscrolls` property.
`void`
`setBackground(Color bg)`
Sets the background color of this component.
`void`
`setBorder(Border border)`
Sets the border of this component.
`void`
`setComponentPopupMenu(JPopupMenu popup)`
Sets the `JPopupMenu` for this `JComponent`.
`void`
`setDebugGraphicsOptions(int debugOptions)`
Enables or disables diagnostic information about every graphics operation performed within the component or one of its children.
`static void`
`setDefaultLocale(Locale l)`
Sets the default locale used to initialize each JComponent's locale property upon creation.
`void`
`setDoubleBuffered(boolean aFlag)`
Sets whether this component should use a buffer to paint.
`void`
`setEnabled(boolean enabled)`
Sets whether or not this component is enabled.
`void`
`setFocusTraversalKeys(int id, Set<? extends AWTKeyStroke> keystrokes)`
Sets the focus traversal keys for a given traversal operation for this Component.
`void`
`setFont(Font font)`
Sets the font for this component.
`void`
`setForeground(Color fg)`
Sets the foreground color of this component.
`void`
`setInheritsPopupMenu(boolean value)`
Sets whether or not `getComponentPopupMenu` should delegate to the parent if this component does not have a `JPopupMenu` assigned to it.
`final void`
`setInputMap(int condition, InputMap map)`
Sets the `InputMap` to use under the condition `condition` to `map`.
`void`
`setInputVerifier(InputVerifier inputVerifier)`
Sets the input verifier for this component.
`void`
`setMaximumSize(Dimension maximumSize)`
Sets the maximum size of this component to a constant value.
`void`
`setMinimumSize(Dimension minimumSize)`
Sets the minimum size of this component to a constant value.
`void`
`setNextFocusableComponent(Component aComponent)`
Deprecated.
As of 1.4, replaced by `FocusTraversalPolicy`
`void`
`setOpaque(boolean isOpaque)`
If true the component paints every pixel within its bounds.
`void`
`setPreferredSize(Dimension preferredSize)`
Sets the preferred size of this component.
`void`
`setRequestFocusEnabled(boolean requestFocusEnabled)`
Provides a hint as to whether or not this `JComponent` should get focus.
`void`
`setToolTipText(String text)`
Registers the text to display in a tool tip.
`void`
`setTransferHandler(TransferHandler newHandler)`
Sets the `TransferHandler`, which provides support for transfer of data into and out of this component via cut/copy/paste and drag and drop.
`protected void`
`setUI(ComponentUI newUI)`
Sets the look and feel delegate for this component.
`void`
`setVerifyInputWhenFocusTarget(boolean verifyInputWhenFocusTarget)`
Sets the value to indicate whether input verifier for the current focus owner will be called before this component requests focus.
`void`
`setVisible(boolean aFlag)`
Makes the component visible or invisible.
`void`
`unregisterKeyboardAction(KeyStroke aKeyStroke)`
This method is now obsolete.
`void`
`update(Graphics g)`
Calls `paint`.

### Methods declared in class Container

`add, add, add, add, add, addContainerListener, addImpl, addPropertyChangeListener, addPropertyChangeListener, applyComponentOrientation, areFocusTraversalKeysSet, countComponents, deliverEvent, doLayout, findComponentAt, findComponentAt, getComponent, getComponentAt, getComponentAt, getComponentCount, getComponents, getComponentZOrder, getContainerListeners, getFocusTraversalKeys, getFocusTraversalPolicy, getLayout, getMousePosition, insets, invalidate, isAncestorOf, isFocusCycleRoot, isFocusCycleRoot, isFocusTraversalPolicyProvider, isFocusTraversalPolicySet, layout, list, list, locate, minimumSize, paintComponents, preferredSize, printComponents, processContainerEvent, processEvent, remove, remove, removeAll, removeContainerListener, setComponentZOrder, setFocusCycleRoot, setFocusTraversalPolicy, setFocusTraversalPolicyProvider, setLayout, transferFocusDownCycle, validate, validateTree`
Modifier and Type
Method
Description
`Component`
`add(Component comp)`
Appends the specified component to the end of this container.
`Component`
`add(Component comp, int index)`
Adds the specified component to this container at the given position.
`void`
`add(Component comp, Object constraints)`
Adds the specified component to the end of this container.
`void`
`add(Component comp, Object constraints, int index)`
Adds the specified component to this container with the specified constraints at the specified index.
`Component`
`add(String name, Component comp)`
Adds the specified component to this container.
`void`
`addContainerListener(ContainerListener l)`
Adds the specified container listener to receive container events from this container.
`protected void`
`addImpl(Component comp, Object constraints, int index)`
Adds the specified component to this container at the specified index.
`void`
`addPropertyChangeListener(PropertyChangeListener listener)`
Adds a PropertyChangeListener to the listener list.
`void`
`addPropertyChangeListener(String propertyName, PropertyChangeListener listener)`
Adds a PropertyChangeListener to the listener list for a specific property.
`void`
`applyComponentOrientation(ComponentOrientation o)`
Sets the `ComponentOrientation` property of this container and all components contained within it.
`boolean`
`areFocusTraversalKeysSet(int id)`
Returns whether the Set of focus traversal keys for the given focus traversal operation has been explicitly defined for this Container.
`int`
`countComponents()`
Deprecated.
As of JDK version 1.1, replaced by getComponentCount().
`void`
`deliverEvent(Event e)`
Deprecated.
As of JDK version 1.1, replaced by `dispatchEvent(AWTEvent e)`
`void`
`doLayout()`
Causes this container to lay out its components.
`Component`
`findComponentAt(int x, int y)`
Locates the visible child component that contains the specified position.
`Component`
`findComponentAt(Point p)`
Locates the visible child component that contains the specified point.
`Component`
`getComponent(int n)`
Gets the nth component in this container.
`Component`
`getComponentAt(int x, int y)`
Locates the component that contains the x,y position.
`Component`
`getComponentAt(Point p)`
Gets the component that contains the specified point.
`int`
`getComponentCount()`
Gets the number of components in this panel.
`Component[]`
`getComponents()`
Gets all the components in this container.
`int`
`getComponentZOrder(Component comp)`
Returns the z-order index of the component inside the container.
`ContainerListener[]`
`getContainerListeners()`
Returns an array of all the container listeners registered on this container.
`Set<AWTKeyStroke>`
`getFocusTraversalKeys(int id)`
Returns the Set of focus traversal keys for a given traversal operation for this Container.
`FocusTraversalPolicy`
`getFocusTraversalPolicy()`
Returns the focus traversal policy that will manage keyboard traversal of this Container's children, or null if this Container is not a focus cycle root.
`LayoutManager`
`getLayout()`
Gets the layout manager for this container.
`Point`
`getMousePosition(boolean allowChildren)`
Returns the position of the mouse pointer in this `Container`'s coordinate space if the `Container` is under the mouse pointer, otherwise returns `null`.
`Insets`
`insets()`
Deprecated.
As of JDK version 1.1, replaced by `getInsets()`.
`void`
`invalidate()`
Invalidates the container.
`boolean`
`isAncestorOf(Component c)`
Checks if the component is contained in the component hierarchy of this container.
`boolean`
`isFocusCycleRoot()`
Returns whether this Container is the root of a focus traversal cycle.
`boolean`
`isFocusCycleRoot(Container container)`
Returns whether the specified Container is the focus cycle root of this Container's focus traversal cycle.
`final boolean`
`isFocusTraversalPolicyProvider()`
Returns whether this container provides focus traversal policy.
`boolean`
`isFocusTraversalPolicySet()`
Returns whether the focus traversal policy has been explicitly set for this Container.
`void`
`layout()`
Deprecated.
As of JDK version 1.1, replaced by `doLayout()`.
`void`
`list(PrintStream out, int indent)`
Prints a listing of this container to the specified output stream.
`void`
`list(PrintWriter out, int indent)`
Prints out a list, starting at the specified indentation, to the specified print writer.
`Component`
`locate(int x, int y)`
Deprecated.
As of JDK version 1.1, replaced by `getComponentAt(int, int)`.
`Dimension`
`minimumSize()`
Deprecated.
As of JDK version 1.1, replaced by `getMinimumSize()`.
`void`
`paintComponents(Graphics g)`
Paints each of the components in this container.
`Dimension`
`preferredSize()`
Deprecated.
As of JDK version 1.1, replaced by `getPreferredSize()`.
`void`
`printComponents(Graphics g)`
Prints each of the components in this container.
`protected void`
`processContainerEvent(ContainerEvent e)`
Processes container events occurring on this container by dispatching them to any registered ContainerListener objects.
`protected void`
`processEvent(AWTEvent e)`
Processes events on this container.
`void`
`remove(int index)`
Removes the component, specified by `index`, from this container.
`void`
`remove(Component comp)`
Removes the specified component from this container.
`void`
`removeAll()`
Removes all the components from this container.
`void`
`removeContainerListener(ContainerListener l)`
Removes the specified container listener so it no longer receives container events from this container.
`void`
`setComponentZOrder(Component comp, int index)`
Moves the specified component to the specified z-order index in the container.
`void`
`setFocusCycleRoot(boolean focusCycleRoot)`
Sets whether this Container is the root of a focus traversal cycle.
`void`
`setFocusTraversalPolicy(FocusTraversalPolicy policy)`
Sets the focus traversal policy that will manage keyboard traversal of this Container's children, if this Container is a focus cycle root.
`final void`
`setFocusTraversalPolicyProvider(boolean provider)`
Sets whether this container will be used to provide focus traversal policy.
`void`
`setLayout(LayoutManager mgr)`
Sets the layout manager for this container.
`void`
`transferFocusDownCycle()`
Transfers the focus down one focus traversal cycle.
`void`
`validate()`
Validates this container and all of its subcomponents.
`protected void`
`validateTree()`
Recursively descends the container tree and recomputes the layout for any subtrees marked as needing it (those marked as invalid).

### Methods declared in class Component

`action, add, addComponentListener, addFocusListener, addHierarchyBoundsListener, addHierarchyListener, addInputMethodListener, addKeyListener, addMouseListener, addMouseMotionListener, addMouseWheelListener, bounds, checkImage, checkImage, coalesceEvents, contains, createImage, createImage, createVolatileImage, createVolatileImage, disableEvents, dispatchEvent, enable, enableEvents, enableInputMethods, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, getBackground, getBounds, getColorModel, getComponentListeners, getComponentOrientation, getCursor, getDropTarget, getFocusCycleRootAncestor, getFocusListeners, getFocusTraversalKeysEnabled, getFont, getForeground, getGraphicsConfiguration, getHierarchyBoundsListeners, getHierarchyListeners, getIgnoreRepaint, getInputContext, getInputMethodListeners, getInputMethodRequests, getKeyListeners, getLocale, getLocation, getLocationOnScreen, getMouseListeners, getMouseMotionListeners, getMousePosition, getMouseWheelListeners, getName, getParent, getPropertyChangeListeners, getPropertyChangeListeners, getSize, getToolkit, getTreeLock, gotFocus, handleEvent, hasFocus, imageUpdate, inside, isBackgroundSet, isCursorSet, isDisplayable, isEnabled, isFocusable, isFocusOwner, isFocusTraversable, isFontSet, isForegroundSet, isLightweight, isMaximumSizeSet, isMinimumSizeSet, isPreferredSizeSet, isShowing, isValid, isVisible, keyDown, keyUp, list, list, list, location, lostFocus, mouseDown, mouseDrag, mouseEnter, mouseExit, mouseMove, mouseUp, move, nextFocus, paintAll, postEvent, prepareImage, prepareImage, processComponentEvent, processFocusEvent, processHierarchyBoundsEvent, processHierarchyEvent, processInputMethodEvent, processMouseWheelEvent, remove, removeComponentListener, removeFocusListener, removeHierarchyBoundsListener, removeHierarchyListener, removeInputMethodListener, removeKeyListener, removeMouseListener, removeMouseMotionListener, removeMouseWheelListener, removePropertyChangeListener, removePropertyChangeListener, repaint, repaint, repaint, requestFocus, requestFocus, requestFocusInWindow, resize, resize, setBounds, setBounds, setComponentOrientation, setCursor, setDropTarget, setFocusable, setFocusTraversalKeysEnabled, setIgnoreRepaint, setLocale, setLocation, setLocation, setMixingCutoutShape, setName, setSize, setSize, show, show, size, toString, transferFocus, transferFocusBackward, transferFocusUpCycle`
Modifier and Type
Method
Description
`boolean`
`action(Event evt, Object what)`
Deprecated.
As of JDK version 1.1, should register this component as ActionListener on component which fires action events.
`void`
`add(PopupMenu popup)`
Adds the specified popup menu to the component.
`void`
`addComponentListener(ComponentListener l)`
Adds the specified component listener to receive component events from this component.
`void`
`addFocusListener(FocusListener l)`
Adds the specified focus listener to receive focus events from this component when this component gains input focus.
`void`
`addHierarchyBoundsListener(HierarchyBoundsListener l)`
Adds the specified hierarchy bounds listener to receive hierarchy bounds events from this component when the hierarchy to which this container belongs changes.
`void`
`addHierarchyListener(HierarchyListener l)`
Adds the specified hierarchy listener to receive hierarchy changed events from this component when the hierarchy to which this container belongs changes.
`void`
`addInputMethodListener(InputMethodListener l)`
Adds the specified input method listener to receive input method events from this component.
`void`
`addKeyListener(KeyListener l)`
Adds the specified key listener to receive key events from this component.
`void`
`addMouseListener(MouseListener l)`
Adds the specified mouse listener to receive mouse events from this component.
`void`
`addMouseMotionListener(MouseMotionListener l)`
Adds the specified mouse motion listener to receive mouse motion events from this component.
`void`
`addMouseWheelListener(MouseWheelListener l)`
Adds the specified mouse wheel listener to receive mouse wheel events from this component.
`Rectangle`
`bounds()`
Deprecated.
As of JDK version 1.1, replaced by `getBounds()`.
`int`
`checkImage(Image image, int width, int height, ImageObserver observer)`
Returns the status of the construction of a screen representation of the specified image.
`int`
`checkImage(Image image, ImageObserver observer)`
Returns the status of the construction of a screen representation of the specified image.
`protected AWTEvent`
`coalesceEvents(AWTEvent existingEvent, AWTEvent newEvent)`
Potentially coalesce an event being posted with an existing event.
`boolean`
`contains(Point p)`
Checks whether this component "contains" the specified point, where the point's x and y coordinates are defined to be relative to the coordinate system of this component.
`Image`
`createImage(int width, int height)`
Creates an off-screen drawable image to be used for double buffering.
`Image`
`createImage(ImageProducer producer)`
Creates an image from the specified image producer.
`VolatileImage`
`createVolatileImage(int width, int height)`
Creates a volatile off-screen drawable image to be used for double buffering.
`VolatileImage`
`createVolatileImage(int width, int height, ImageCapabilities caps)`
Creates a volatile off-screen drawable image, with the given capabilities.
`protected final void`
`disableEvents(long eventsToDisable)`
Disables the events defined by the specified event mask parameter from being delivered to this component.
`final void`
`dispatchEvent(AWTEvent e)`
Dispatches an event to this component or one of its sub components.
`void`
`enable(boolean b)`
Deprecated.
As of JDK version 1.1, replaced by `setEnabled(boolean)`.
`protected final void`
`enableEvents(long eventsToEnable)`
Enables the events defined by the specified event mask parameter to be delivered to this component.
`void`
`enableInputMethods(boolean enable)`
Enables or disables input method support for this component.
`void`
`firePropertyChange(String propertyName, byte oldValue, byte newValue)`
Reports a bound property change.
`void`
`firePropertyChange(String propertyName, char oldValue, char newValue)`
Reports a bound property change.
`void`
`firePropertyChange(String propertyName, double oldValue, double newValue)`
Reports a bound property change.
`void`
`firePropertyChange(String propertyName, float oldValue, float newValue)`
Reports a bound property change.
`void`
`firePropertyChange(String propertyName, long oldValue, long newValue)`
Reports a bound property change.
`void`
`firePropertyChange(String propertyName, short oldValue, short newValue)`
Reports a bound property change.
`protected void`
`firePropertyChange(String propertyName, Object oldValue, Object newValue)`
Support for reporting bound property changes for Object properties.
`Color`
`getBackground()`
Gets the background color of this component.
`Rectangle`
`getBounds()`
Gets the bounds of this component in the form of a `Rectangle` object.
`ColorModel`
`getColorModel()`
Gets the instance of `ColorModel` used to display the component on the output device.
`ComponentListener[]`
`getComponentListeners()`
Returns an array of all the component listeners registered on this component.
`ComponentOrientation`
`getComponentOrientation()`
Retrieves the language-sensitive orientation that is to be used to order the elements or text within this component.
`Cursor`
`getCursor()`
Gets the cursor set in the component.
`DropTarget`
`getDropTarget()`
Gets the `DropTarget` associated with this `Component`.
`Container`
`getFocusCycleRootAncestor()`
Returns the Container which is the focus cycle root of this Component's focus traversal cycle.
`FocusListener[]`
`getFocusListeners()`
Returns an array of all the focus listeners registered on this component.
`boolean`
`getFocusTraversalKeysEnabled()`
Returns whether focus traversal keys are enabled for this Component.
`Font`
`getFont()`
Gets the font of this component.
`Color`
`getForeground()`
Gets the foreground color of this component.
`GraphicsConfiguration`
`getGraphicsConfiguration()`
Gets the `GraphicsConfiguration` associated with this `Component`.
`HierarchyBoundsListener[]`
`getHierarchyBoundsListeners()`
Returns an array of all the hierarchy bounds listeners registered on this component.
`HierarchyListener[]`
`getHierarchyListeners()`
Returns an array of all the hierarchy listeners registered on this component.
`boolean`
`getIgnoreRepaint()`
Returns whether or not paint messages received from the operating system should be ignored.
`InputContext`
`getInputContext()`
Gets the input context used by this component for handling the communication with input methods when text is entered in this component.
`InputMethodListener[]`
`getInputMethodListeners()`
Returns an array of all the input method listeners registered on this component.
`InputMethodRequests`
`getInputMethodRequests()`
Gets the input method request handler which supports requests from input methods for this component.
`KeyListener[]`
`getKeyListeners()`
Returns an array of all the key listeners registered on this component.
`Locale`
`getLocale()`
Gets the locale of this component.
`Point`
`getLocation()`
Gets the location of this component in the form of a point specifying the component's top-left corner.
`Point`
`getLocationOnScreen()`
Gets the location of this component in the form of a point specifying the component's top-left corner in the screen's coordinate space.
`MouseListener[]`
`getMouseListeners()`
Returns an array of all the mouse listeners registered on this component.
`MouseMotionListener[]`
`getMouseMotionListeners()`
Returns an array of all the mouse motion listeners registered on this component.
`Point`
`getMousePosition()`
Returns the position of the mouse pointer in this `Component`'s coordinate space if the `Component` is directly under the mouse pointer, otherwise returns `null`.
`MouseWheelListener[]`
`getMouseWheelListeners()`
Returns an array of all the mouse wheel listeners registered on this component.
`String`
`getName()`
Gets the name of the component.
`Container`
`getParent()`
Gets the parent of this component.
`PropertyChangeListener[]`
`getPropertyChangeListeners()`
Returns an array of all the property change listeners registered on this component.
`PropertyChangeListener[]`
`getPropertyChangeListeners(String propertyName)`
Returns an array of all the listeners which have been associated with the named property.
`Dimension`
`getSize()`
Returns the size of this component in the form of a `Dimension` object.
`Toolkit`
`getToolkit()`
Gets the toolkit of this component.
`final Object`
`getTreeLock()`
Gets this component's locking object (the object that owns the thread synchronization monitor) for AWT component-tree and layout operations.
`boolean`
`gotFocus(Event evt, Object what)`
Deprecated.
As of JDK version 1.1, replaced by processFocusEvent(FocusEvent).
`boolean`
`handleEvent(Event evt)`
Deprecated.
As of JDK version 1.1 replaced by processEvent(AWTEvent).
`boolean`
`hasFocus()`
Returns `true` if this `Component` is the focus owner.
`boolean`
`imageUpdate(Image img, int infoflags, int x, int y, int w, int h)`
Repaints the component when the image has changed.
`boolean`
`inside(int x, int y)`
Deprecated.
As of JDK version 1.1, replaced by contains(int, int).
`boolean`
`isBackgroundSet()`
Returns whether the background color has been explicitly set for this Component.
`boolean`
`isCursorSet()`
Returns whether the cursor has been explicitly set for this Component.
`boolean`
`isDisplayable()`
Determines whether this component is displayable.
`boolean`
`isEnabled()`
Determines whether this component is enabled.
`boolean`
`isFocusable()`
Returns whether this Component can be focused.
`boolean`
`isFocusOwner()`
Returns `true` if this `Component` is the focus owner.
`boolean`
`isFocusTraversable()`
Deprecated.
As of 1.4, replaced by `isFocusable()`.
`boolean`
`isFontSet()`
Returns whether the font has been explicitly set for this Component.
`boolean`
`isForegroundSet()`
Returns whether the foreground color has been explicitly set for this Component.
`boolean`
`isLightweight()`
A lightweight component doesn't have a native toolkit peer.
`boolean`
`isMaximumSizeSet()`
Returns true if the maximum size has been set to a non-`null` value otherwise returns false.
`boolean`
`isMinimumSizeSet()`
Returns whether or not `setMinimumSize` has been invoked with a non-null value.
`boolean`
`isPreferredSizeSet()`
Returns true if the preferred size has been set to a non-`null` value otherwise returns false.
`boolean`
`isShowing()`
Determines whether this component is showing on screen.
`boolean`
`isValid()`
Determines whether this component is valid.
`boolean`
`isVisible()`
Determines whether this component should be visible when its parent is visible.
`boolean`
`keyDown(Event evt, int key)`
Deprecated.
As of JDK version 1.1, replaced by processKeyEvent(KeyEvent).
`boolean`
`keyUp(Event evt, int key)`
Deprecated.
As of JDK version 1.1, replaced by processKeyEvent(KeyEvent).
`void`
`list()`
Prints a listing of this component to the standard system output stream `System.out`.
`void`
`list(PrintStream out)`
Prints a listing of this component to the specified output stream.
`void`
`list(PrintWriter out)`
Prints a listing to the specified print writer.
`Point`
`location()`
Deprecated.
As of JDK version 1.1, replaced by `getLocation()`.
`boolean`
`lostFocus(Event evt, Object what)`
Deprecated.
As of JDK version 1.1, replaced by processFocusEvent(FocusEvent).
`boolean`
`mouseDown(Event evt, int x, int y)`
Deprecated.
As of JDK version 1.1, replaced by processMouseEvent(MouseEvent).
`boolean`
`mouseDrag(Event evt, int x, int y)`
Deprecated.
As of JDK version 1.1, replaced by processMouseMotionEvent(MouseEvent).
`boolean`
`mouseEnter(Event evt, int x, int y)`
Deprecated.
As of JDK version 1.1, replaced by processMouseEvent(MouseEvent).
`boolean`
`mouseExit(Event evt, int x, int y)`
Deprecated.
As of JDK version 1.1, replaced by processMouseEvent(MouseEvent).
`boolean`
`mouseMove(Event evt, int x, int y)`
Deprecated.
As of JDK version 1.1, replaced by processMouseMotionEvent(MouseEvent).
`boolean`
`mouseUp(Event evt, int x, int y)`
Deprecated.
As of JDK version 1.1, replaced by processMouseEvent(MouseEvent).
`void`
`move(int x, int y)`
Deprecated.
As of JDK version 1.1, replaced by `setLocation(int, int)`.
`void`
`nextFocus()`
Deprecated.
As of JDK version 1.1, replaced by transferFocus().
`void`
`paintAll(Graphics g)`
Paints this component and all of its subcomponents.
`boolean`
`postEvent(Event e)`
Deprecated.
As of JDK version 1.1, replaced by dispatchEvent(AWTEvent).
`boolean`
`prepareImage(Image image, int width, int height, ImageObserver observer)`
Prepares an image for rendering on this component at the specified width and height.
`boolean`
`prepareImage(Image image, ImageObserver observer)`
Prepares an image for rendering on this component.
`protected void`
`processComponentEvent(ComponentEvent e)`
Processes component events occurring on this component by dispatching them to any registered `ComponentListener` objects.
`protected void`
`processFocusEvent(FocusEvent e)`
Processes focus events occurring on this component by dispatching them to any registered `FocusListener` objects.
`protected void`
`processHierarchyBoundsEvent(HierarchyEvent e)`
Processes hierarchy bounds events occurring on this component by dispatching them to any registered `HierarchyBoundsListener` objects.
`protected void`
`processHierarchyEvent(HierarchyEvent e)`
Processes hierarchy events occurring on this component by dispatching them to any registered `HierarchyListener` objects.
`protected void`
`processInputMethodEvent(InputMethodEvent e)`
Processes input method events occurring on this component by dispatching them to any registered `InputMethodListener` objects.
`protected void`
`processMouseWheelEvent(MouseWheelEvent e)`
Processes mouse wheel events occurring on this component by dispatching them to any registered `MouseWheelListener` objects.
`void`
`remove(MenuComponent popup)`
Removes the specified popup menu from the component.
`void`
`removeComponentListener(ComponentListener l)`
Removes the specified component listener so that it no longer receives component events from this component.
`void`
`removeFocusListener(FocusListener l)`
Removes the specified focus listener so that it no longer receives focus events from this component.
`void`
`removeHierarchyBoundsListener(HierarchyBoundsListener l)`
Removes the specified hierarchy bounds listener so that it no longer receives hierarchy bounds events from this component.
`void`
`removeHierarchyListener(HierarchyListener l)`
Removes the specified hierarchy listener so that it no longer receives hierarchy changed events from this component.
`void`
`removeInputMethodListener(InputMethodListener l)`
Removes the specified input method listener so that it no longer receives input method events from this component.
`void`
`removeKeyListener(KeyListener l)`
Removes the specified key listener so that it no longer receives key events from this component.
`void`
`removeMouseListener(MouseListener l)`
Removes the specified mouse listener so that it no longer receives mouse events from this component.
`void`
`removeMouseMotionListener(MouseMotionListener l)`
Removes the specified mouse motion listener so that it no longer receives mouse motion events from this component.
`void`
`removeMouseWheelListener(MouseWheelListener l)`
Removes the specified mouse wheel listener so that it no longer receives mouse wheel events from this component.
`void`
`removePropertyChangeListener(PropertyChangeListener listener)`
Removes a PropertyChangeListener from the listener list.
`void`
`removePropertyChangeListener(String propertyName, PropertyChangeListener listener)`
Removes a `PropertyChangeListener` from the listener list for a specific property.
`void`
`repaint()`
Repaints this component.
`void`
`repaint(int x, int y, int width, int height)`
Repaints the specified rectangle of this component.
`void`
`repaint(long tm)`
Repaints the component.
`protected boolean`
`requestFocus(boolean temporary, FocusEvent.Cause cause)`
Requests by the reason of `cause` that this `Component` get the input focus, and that this `Component`'s top-level ancestor become the focused `Window`.
`void`
`requestFocus(FocusEvent.Cause cause)`
Requests by the reason of `cause` that this Component get the input focus, and that this Component's top-level ancestor become the focused Window.
`boolean`
`requestFocusInWindow(FocusEvent.Cause cause)`
Requests by the reason of `cause` that this Component get the input focus, if this Component's top-level ancestor is already the focused Window.
`void`
`resize(int width, int height)`
Deprecated.
As of JDK version 1.1, replaced by `setSize(int, int)`.
`void`
`resize(Dimension d)`
Deprecated.
As of JDK version 1.1, replaced by `setSize(Dimension)`.
`void`
`setBounds(int x, int y, int width, int height)`
Moves and resizes this component.
`void`
`setBounds(Rectangle r)`
Moves and resizes this component to conform to the new bounding rectangle `r`.
`void`
`setComponentOrientation(ComponentOrientation o)`
Sets the language-sensitive orientation that is to be used to order the elements or text within this component.
`void`
`setCursor(Cursor cursor)`
Sets the cursor image to the specified cursor.
`void`
`setDropTarget(DropTarget dt)`
Associate a `DropTarget` with this component.
`void`
`setFocusable(boolean focusable)`
Sets the focusable state of this Component to the specified value.
`void`
`setFocusTraversalKeysEnabled(boolean focusTraversalKeysEnabled)`
Sets whether focus traversal keys are enabled for this Component.
`void`
`setIgnoreRepaint(boolean ignoreRepaint)`
Sets whether or not paint messages received from the operating system should be ignored.
`void`
`setLocale(Locale l)`
Sets the locale of this component.
`void`
`setLocation(int x, int y)`
Moves this component to a new location.
`void`
`setLocation(Point p)`
Moves this component to a new location.
`void`
`setMixingCutoutShape(Shape shape)`
Sets a 'mixing-cutout' shape for this lightweight component.
`void`
`setName(String name)`
Sets the name of the component to the specified string.
`void`
`setSize(int width, int height)`
Resizes this component so that it has width `width` and height `height`.
`void`
`setSize(Dimension d)`
Resizes this component so that it has width `d.width` and height `d.height`.
`void`
`show()`
Deprecated.
As of JDK version 1.1, replaced by `setVisible(boolean)`.
`void`
`show(boolean b)`
Deprecated.
As of JDK version 1.1, replaced by `setVisible(boolean)`.
`Dimension`
`size()`
Deprecated.
As of JDK version 1.1, replaced by `getSize()`.
`String`
`toString()`
Returns a string representation of this component and its values.
`void`
`transferFocus()`
Transfers the focus to the next component, as though this Component were the focus owner.
`void`
`transferFocusBackward()`
Transfers the focus to the previous component, as though this Component were the focus owner.
`void`
`transferFocusUpCycle()`
Transfers the focus up one focus traversal cycle.

### Methods declared in class Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`
Modifier and Type
Method
Description
`protected Object`
`clone()`
Creates and returns a copy of this object.
`boolean`
`equals(Object obj)`
Indicates whether some other object is "equal to" this one.
`protected void`
`finalize()`
Deprecated, for removal: This API element is subject to removal in a future version.
Finalization is deprecated and subject to removal in a future release.
`final Class<?>`
`getClass()`
Returns the runtime class of this `Object`.
`int`
`hashCode()`
Returns a hash code value for this object.
`final void`
`notify()`
Wakes up a single thread that is waiting on this object's monitor.
`final void`
`notifyAll()`
Wakes up all threads that are waiting on this object's monitor.
`final void`
`wait()`
Causes the current thread to wait until it is awakened, typically by being notified or interrupted.
`final void`
`wait(long timeoutMillis)`
Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
`final void`
`wait(long timeoutMillis, int nanos)`
Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.

## Field Details

### VERTICAL

public static final int VERTICAL
Indicates a vertical layout of cells, in a single column; the default layout.

Since:
  1.4
See Also:
  - `setLayoutOrientation(int)`
  - Constant Field Values

### VERTICAL_WRAP

public static final int VERTICAL_WRAP
Indicates a "newspaper style" layout with cells flowing vertically then horizontally.

Since:
  1.4
See Also:
  - `setLayoutOrientation(int)`
  - Constant Field Values

### HORIZONTAL_WRAP

public static final int HORIZONTAL_WRAP
Indicates a "newspaper style" layout with cells flowing horizontally then vertically.

Since:
  1.4
See Also:
  - `setLayoutOrientation(int)`
  - Constant Field Values

## Constructor Details

### JList

public JList(ListModel<E> dataModel)
Constructs a `JList` that displays elements from the specified, `non-null`, model. All `JList` constructors delegate to this one.

This constructor registers the list with the `ToolTipManager`, allowing for tooltips to be provided by the cell renderers.

Parameters:
  `dataModel` - the model for the list
Throws:
  `IllegalArgumentException` - if the model is `null`

### JList

public JList(E[] listData)
Constructs a `JList` that displays the elements in the specified array. This constructor creates a read-only model for the given array, and then delegates to the constructor that takes a `ListModel`.

Attempts to pass a `null` value to this method results in undefined behavior and, most likely, exceptions. The created model references the given array directly. Attempts to modify the array after constructing the list results in undefined behavior.

Parameters:
  `listData` - the array of Objects to be loaded into the data model, `non-null`

### JList

public JList(Vector<? extends E> listData)
Constructs a `JList` that displays the elements in the specified `Vector`. This constructor creates a read-only model for the given `Vector`, and then delegates to the constructor that takes a `ListModel`.

Attempts to pass a `null` value to this method results in undefined behavior and, most likely, exceptions. The created model references the given `Vector` directly. Attempts to modify the `Vector` after constructing the list results in undefined behavior.

Parameters:
  `listData` - the `Vector` to be loaded into the data model, `non-null`

### JList

public JList()
Constructs a `JList` with an empty, read-only, model.

## Method Details

### getUI

public ListUI getUI()
Returns the `ListUI`, the look and feel object that renders this component.

Overrides:
  `getUI` in class `JComponent`
Returns:
  the `ListUI` object that renders this component

### setUI

@BeanProperty(hidden=true, visualUpdate=true, description="The UI object that implements the Component's LookAndFeel.") public void setUI(ListUI ui)
Sets the `ListUI`, the look and feel object that renders this component.

Parameters:
  `ui` - the `ListUI` object
See Also:
  - `UIDefaults.getUI(JComponent)`

### updateUI

public void updateUI()
Resets the `ListUI` property by setting it to the value provided by the current look and feel. If the current cell renderer was installed by the developer (rather than the look and feel itself), this also causes the cell renderer and its children to be updated, by calling `SwingUtilities.updateComponentTreeUI` on it.

Overrides:
  `updateUI` in class `JComponent`
See Also:
  - `UIManager.getUI(JComponent)`
  - `SwingUtilities.updateComponentTreeUI(Component)`

### getUIClassID

@BeanProperty(bound=false) public String getUIClassID()
Returns `"ListUI"`, the `UIDefaults` key used to look up the name of the `javax.swing.plaf.ListUI` class that defines the look and feel for this component.

Overrides:
  `getUIClassID` in class `JComponent`
Returns:
  the string "ListUI"
See Also:
  - `JComponent.getUIClassID()`
  - `UIDefaults.getUI(JComponent)`

### getPrototypeCellValue

public E getPrototypeCellValue()
Returns the "prototypical" cell value -- a value used to calculate a fixed width and height for cells. This can be `null` if there is no such value.

Returns:
  the value of the `prototypeCellValue` property
See Also:
  - `setPrototypeCellValue(E)`

### setPrototypeCellValue

@BeanProperty(visualUpdate=true, description="The cell prototype value, used to compute cell width and height.") public void setPrototypeCellValue(E prototypeCellValue)
Sets the `prototypeCellValue` property, and then (if the new value is `non-null`), computes the `fixedCellWidth` and `fixedCellHeight` properties by requesting the cell renderer component for the given value (and index 0) from the cell renderer, and using that component's preferred size.

This method is useful when the list is too long to allow the `ListUI` to compute the width/height of each cell, and there is a single cell value that is known to occupy as much space as any of the others, a so-called prototype.

While all three of the `prototypeCellValue`, `fixedCellHeight`, and `fixedCellWidth` properties may be modified by this method, `PropertyChangeEvent` notifications are only sent when the `prototypeCellValue` property changes.

To see an example which sets this property, see the class description above.

The default value of this property is `null`.

This is a JavaBeans bound property.

Parameters:
  `prototypeCellValue` - the value on which to base `fixedCellWidth` and `fixedCellHeight`
See Also:
  - `getPrototypeCellValue()`
  - `setFixedCellWidth(int)`
  - `setFixedCellHeight(int)`
  - `Container.addPropertyChangeListener(PropertyChangeListener)`

### getFixedCellWidth

public int getFixedCellWidth()
Returns the value of the `fixedCellWidth` property.

Returns:
  the fixed cell width
See Also:
  - `setFixedCellWidth(int)`

### setFixedCellWidth

@BeanProperty(visualUpdate=true, description="Defines a fixed cell width when greater than zero.") public void setFixedCellWidth(int width)
Sets a fixed value to be used for the width of every cell in the list. If `width` is -1, cell widths are computed in the `ListUI` by applying `getPreferredSize` to the cell renderer component for each list element.

The default value of this property is `-1`.

This is a JavaBeans bound property.

Parameters:
  `width` - the width to be used for all cells in the list
See Also:
  - `setPrototypeCellValue(E)`
  - `getFixedCellWidth()`
  - `Container.addPropertyChangeListener(PropertyChangeListener)`

### getFixedCellHeight

public int getFixedCellHeight()
Returns the value of the `fixedCellHeight` property.

Returns:
  the fixed cell height
See Also:
  - `setFixedCellHeight(int)`

### setFixedCellHeight

@BeanProperty(visualUpdate=true, description="Defines a fixed cell height when greater than zero.") public void setFixedCellHeight(int height)
Sets a fixed value to be used for the height of every cell in the list. If `height` is -1, cell heights are computed in the `ListUI` by applying `getPreferredSize` to the cell renderer component for each list element.

The default value of this property is `-1`.

This is a JavaBeans bound property.

Parameters:
  `height` - the height to be used for all cells in the list
See Also:
  - `setPrototypeCellValue(E)`
  - `setFixedCellWidth(int)`
  - `Container.addPropertyChangeListener(PropertyChangeListener)`

### getCellRenderer

public ListCellRenderer<? super E> getCellRenderer()
Returns the object responsible for painting list items.

Returns:
  the value of the `cellRenderer` property
See Also:
  - `setCellRenderer(ListCellRenderer)`

### setCellRenderer

@BeanProperty(visualUpdate=true, description="The component used to draw the cells.") public void setCellRenderer(ListCellRenderer<? super E> cellRenderer)
Sets the delegate that is used to paint each cell in the list. The job of a cell renderer is discussed in detail in the class level documentation.

If the `prototypeCellValue` property is `non-null`, setting the cell renderer also causes the `fixedCellWidth` and `fixedCellHeight` properties to be re-calculated. Only one `PropertyChangeEvent` is generated however - for the `cellRenderer` property.

The default value of this property is provided by the `ListUI` delegate, i.e. by the look and feel implementation.

This is a JavaBeans bound property.

Parameters:
  `cellRenderer` - the `ListCellRenderer` that paints list cells
See Also:
  - `getCellRenderer()`

### getSelectionForeground

public Color getSelectionForeground()
Returns the color used to draw the foreground of selected items. `DefaultListCellRenderer` uses this color to draw the foreground of items in the selected state, as do the renderers installed by most `ListUI` implementations.

Returns:
  the color to draw the foreground of selected items
See Also:
  - `setSelectionForeground(Color)`
  - `DefaultListCellRenderer`

### setSelectionForeground

@BeanProperty(visualUpdate=true, description="The foreground color of selected cells.") public void setSelectionForeground(Color selectionForeground)
Sets the color used to draw the foreground of selected items, which cell renderers can use to render text and graphics. `DefaultListCellRenderer` uses this color to draw the foreground of items in the selected state, as do the renderers installed by most `ListUI` implementations.

The default value of this property is defined by the look and feel implementation.

This is a JavaBeans bound property.

Parameters:
  `selectionForeground` - the `Color` to use in the foreground for selected list items
See Also:
  - `getSelectionForeground()`
  - `setSelectionBackground(Color)`
  - `JComponent.setForeground(Color)`
  - `JComponent.setBackground(Color)`
  - `JComponent.setFont(Font)`
  - `DefaultListCellRenderer`

### getSelectionBackground

public Color getSelectionBackground()
Returns the color used to draw the background of selected items. `DefaultListCellRenderer` uses this color to draw the background of items in the selected state, as do the renderers installed by most `ListUI` implementations.

Returns:
  the color to draw the background of selected items
See Also:
  - `setSelectionBackground(Color)`
  - `DefaultListCellRenderer`

### setSelectionBackground

@BeanProperty(visualUpdate=true, description="The background color of selected cells.") public void setSelectionBackground(Color selectionBackground)
Sets the color used to draw the background of selected items, which cell renderers can use fill selected cells. `DefaultListCellRenderer` uses this color to fill the background of items in the selected state, as do the renderers installed by most `ListUI` implementations.

The default value of this property is defined by the look and feel implementation.

This is a JavaBeans bound property.

Parameters:
  `selectionBackground` - the `Color` to use for the background of selected cells
See Also:
  - `getSelectionBackground()`
  - `setSelectionForeground(Color)`
  - `JComponent.setForeground(Color)`
  - `JComponent.setBackground(Color)`
  - `JComponent.setFont(Font)`
  - `DefaultListCellRenderer`

### getVisibleRowCount

public int getVisibleRowCount()
Returns the value of the `visibleRowCount` property. See the documentation for `setVisibleRowCount(int)` for details on how to interpret this value.

Returns:
  the value of the `visibleRowCount` property.
See Also:
  - `setVisibleRowCount(int)`

### setVisibleRowCount

@BeanProperty(visualUpdate=true, description="The preferred number of rows to display without requiring scrolling") public void setVisibleRowCount(int visibleRowCount)
Sets the `visibleRowCount` property, which has different meanings depending on the layout orientation: For a `VERTICAL` layout orientation, this sets the preferred number of rows to display without requiring scrolling; for other orientations, it affects the wrapping of cells.

In `VERTICAL` orientation:
Setting this property affects the return value of the `getPreferredScrollableViewportSize()` method, which is used to calculate the preferred size of an enclosing viewport. See that method's documentation for more details.

In `HORIZONTAL_WRAP` and `VERTICAL_WRAP` orientations:
This affects how cells are wrapped. See the documentation of `setLayoutOrientation(int)` for more details.

The default value of this property is `8`.

Calling this method with a negative value results in the property being set to `0`.

This is a JavaBeans bound property.

Parameters:
  `visibleRowCount` - an integer specifying the preferred number of rows to display without requiring scrolling
See Also:
  - `getVisibleRowCount()`
  - `getPreferredScrollableViewportSize()`
  - `setLayoutOrientation(int)`
  - `JComponent.getVisibleRect()`
  - `JViewport`

### getLayoutOrientation

public int getLayoutOrientation()
Returns the layout orientation property for the list: `VERTICAL` if the layout is a single column of cells, `VERTICAL_WRAP` if the layout is "newspaper style" with the content flowing vertically then horizontally, or `HORIZONTAL_WRAP` if the layout is "newspaper style" with the content flowing horizontally then vertically.

Returns:
  the value of the `layoutOrientation` property
Since:
  1.4
See Also:
  - `setLayoutOrientation(int)`

### 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)
Defines the way list cells are laid out. Consider a `JList` with five cells. Cells can be laid out in one of the following ways:

    VERTICAL:          0
                       1
                       2
                       3
                       4

    HORIZONTAL_WRAP:   0  1  2
                       3  4

    VERTICAL_WRAP:     0  3
                       1  4
                       2

A description of these layouts follows:

Describes layouts VERTICAL,HORIZONTAL_WRAP, and VERTICAL_WRAP
Value | Description
--- | ---
`VERTICAL` | Cells are laid out vertically in a single column.
`HORIZONTAL_WRAP` | Cells are laid out horizontally, wrapping to a new row as necessary. If the `visibleRowCount` property is less than or equal to zero, wrapping is determined by the width of the list; otherwise wrapping is done in such a way as to ensure `visibleRowCount` rows in the list.
`VERTICAL_WRAP` | Cells are laid out vertically, wrapping to a new column as necessary. If the `visibleRowCount` property is less than or equal to zero, wrapping is determined by the height of the list; otherwise wrapping is done at `visibleRowCount` rows.

The default value of this property is `VERTICAL`.

Parameters:
  `layoutOrientation` - the new layout orientation, one of: `VERTICAL`, `HORIZONTAL_WRAP` or `VERTICAL_WRAP`
Throws:
  `IllegalArgumentException` - if `layoutOrientation` isn't one of the allowable values
Since:
  1.4
See Also:
  - `getLayoutOrientation()`
  - `setVisibleRowCount(int)`
  - `getScrollableTracksViewportHeight()`
  - `getScrollableTracksViewportWidth()`

### getFirstVisibleIndex

@BeanProperty(bound=false) public int getFirstVisibleIndex()
Returns the smallest list index that is currently visible. In a left-to-right `componentOrientation`, the first visible cell is found closest to the list's upper-left corner. In right-to-left orientation, it is found closest to the upper-right corner. If nothing is visible or the list is empty, `-1` is returned. Note that the returned cell may only be partially visible.

Returns:
  the index of the first visible cell
See Also:
  - `getLastVisibleIndex()`
  - `JComponent.getVisibleRect()`

### getLastVisibleIndex

@BeanProperty(bound=false) public int getLastVisibleIndex()
Returns the largest list index that is currently visible. If nothing is visible or the list is empty, `-1` is returned. Note that the returned cell may only be partially visible.

Returns:
  the index of the last visible cell
See Also:
  - `getFirstVisibleIndex()`
  - `JComponent.getVisibleRect()`

### ensureIndexIsVisible

public void ensureIndexIsVisible(int index)
Scrolls the list within an enclosing viewport to make the specified cell completely visible. This calls `scrollRectToVisible` with the bounds of the specified cell. For this method to work, the `JList` must be within a `JViewport`.

If the given index is outside the list's range of cells, this method results in nothing.

Parameters:
  `index` - the index of the cell to make visible
See Also:
  - `JComponent.scrollRectToVisible(Rectangle)`
  - `JComponent.getVisibleRect()`

### setDragEnabled

@BeanProperty(bound=false, description="determines whether automatic drag handling is enabled") public void setDragEnabled(boolean b)
Turns on or off automatic drag handling. In order to enable automatic drag handling, this property should be set to `true`, and the list's `TransferHandler` needs to be `non-null`. The default value of the `dragEnabled` property is `false`.

The job of honoring this property, and recognizing a user drag gesture, lies with the look and feel implementation, and in particular, the list's `ListUI`. When automatic drag handling is enabled, most look and feels (including those that subclass `BasicLookAndFeel`) begin a drag and drop operation whenever the user presses the mouse button over an item and then moves the mouse a few pixels. Setting this property to `true` can therefore have a subtle effect on how selections behave.

If a look and feel is used that ignores this property, you can still begin a drag and drop operation by calling `exportAsDrag` on the list's `TransferHandler`.

Parameters:
  `b` - whether or not to enable automatic drag handling
Throws:
  `HeadlessException` - if `b` is `true` and `GraphicsEnvironment.isHeadless()` returns `true`
Since:
  1.4
See Also:
  - `GraphicsEnvironment.isHeadless()`
  - `getDragEnabled()`
  - `JComponent.setTransferHandler(TransferHandler)`
  - `TransferHandler`

### getDragEnabled

public boolean getDragEnabled()
Returns whether or not automatic drag handling is enabled.

Returns:
  the value of the `dragEnabled` property
Since:
  1.4
See Also:
  - `setDragEnabled(boolean)`

### setDropMode

public final void setDropMode(DropMode dropMode)
Sets the drop mode for this component. For backward compatibility, the default for this property is `DropMode.USE_SELECTION`. Usage of one of the other modes is recommended, however, for an improved user experience. `DropMode.ON`, for instance, offers similar behavior of showing items as selected, but does so without affecting the actual selection in the list.

`JList` supports the following drop modes:

- `DropMode.USE_SELECTION`
- `DropMode.ON`
- `DropMode.INSERT`
- `DropMode.ON_OR_INSERT`

The drop mode is only meaningful if this component has a `TransferHandler` that accepts drops.

Parameters:
  `dropMode` - the drop mode to use
Throws:
  `IllegalArgumentException` - if the drop mode is unsupported or `null`
Since:
  1.6
See Also:
  - `getDropMode()`
  - `getDropLocation()`
  - `JComponent.setTransferHandler(TransferHandler)`
  - `TransferHandler`

### getDropMode

public final DropMode getDropMode()
Returns the drop mode for this component.

Returns:
  the drop mode for this component
Since:
  1.6
See Also:
  - `setDropMode(DropMode)`

### getDropLocation

@BeanProperty(bound=false) public final JList.DropLocation getDropLocation()
Returns the location that this component should visually indicate as the drop location during a DnD operation over the component, or `null` if no location is to currently be shown.

This method is not meant for querying the drop location from a `TransferHandler`, as the drop location is only set after the `TransferHandler`'s `canImport` has returned and has allowed for the location to be shown.

When this property changes, a property change event with name "dropLocation" is fired by the component.

By default, responsibility for listening for changes to this property and indicating the drop location visually lies with the list's `ListUI`, which may paint it directly and/or install a cell renderer to do so. Developers wishing to implement custom drop location painting and/or replace the default cell renderer, may need to honor this property.

Returns:
  the drop location
Since:
  1.6
See Also:
  - `setDropMode(DropMode)`
  - `TransferHandler.canImport(TransferHandler.TransferSupport)`

### getNextMatch

public int getNextMatch(String prefix, int startIndex, Position.Bias bias)
Returns the next list element whose `toString` value starts with the given prefix.

Parameters:
  `prefix` - the string to test for a match
  `startIndex` - the index for starting the search
  `bias` - the search direction, either Position.Bias.Forward or Position.Bias.Backward.
Returns:
  the index of the next list element that starts with the prefix; otherwise `-1`
Throws:
  `IllegalArgumentException` - if prefix is `null` or startIndex is out of bounds
Since:
  1.4

### getToolTipText

public String getToolTipText(MouseEvent event)
Returns the tooltip text to be used for the given event. This overrides `JComponent`'s `getToolTipText` to first check the cell renderer component for the cell over which the event occurred, returning its tooltip text, if any. This implementation allows you to specify tooltip text on the cell level, by using `setToolTipText` on your cell renderer component.

Note: For `JList` to properly display the tooltips of its renderers in this manner, `JList` must be a registered component with the `ToolTipManager`. This registration is done automatically in the constructor. However, if at a later point `JList` is unregistered, by way of a call to `setToolTipText(null)`, tips from the renderers will no longer display.

Overrides:
  `getToolTipText` in class `JComponent`
Parameters:
  `event` - the `MouseEvent` to fetch the tooltip text for
Returns:
  a string containing the tooltip
See Also:
  - `JComponent.setToolTipText(String)`
  - `JComponent.getToolTipText()`

### locationToIndex

public int locationToIndex(Point location)
Returns the cell index closest to the given location in the list's coordinate system. To determine if the cell actually contains the specified location, compare the point against the cell's bounds, as provided by `getCellBounds`. This method returns `-1` if the model is empty

This is a cover method that delegates to the method of the same name in the list's `ListUI`. It returns `-1` if the list has no `ListUI`.

Parameters:
  `location` - the coordinates of the point
Returns:
  the cell index closest to the given location, or `-1`

### indexToLocation

public Point indexToLocation(int index)
Returns the origin of the specified item in the list's coordinate system. This method returns `null` if the index isn't valid.

This is a cover method that delegates to the method of the same name in the list's `ListUI`. It returns `null` if the list has no `ListUI`.

Parameters:
  `index` - the cell index
Returns:
  the origin of the cell, or `null`

### getCellBounds

public Rectangle getCellBounds(int index0, int index1)
Returns the bounding rectangle, in the list's coordinate system, for the range of cells specified by the two indices. These indices can be supplied in any order.

If the smaller index is outside the list's range of cells, this method returns `null`. If the smaller index is valid, but the larger index is outside the list's range, the bounds of just the first index is returned. Otherwise, the bounds of the valid range is returned.

This is a cover method that delegates to the method of the same name in the list's `ListUI`. It returns `null` if the list has no `ListUI`.

Parameters:
  `index0` - the first index in the range
  `index1` - the second index in the range
Returns:
  the bounding rectangle for the range of cells, or `null`

### getModel

public ListModel<E> getModel()
Returns the data model that holds the list of items displayed by the `JList` component.

Returns:
  the `ListModel` that provides the displayed list of items
See Also:
  - `setModel(ListModel)`

### setModel

@BeanProperty(visualUpdate=true, description="The object that contains the data to be drawn by this JList.") public void setModel(ListModel<E> model)
Sets the model that represents the contents or "value" of the list, notifies property change listeners, and then clears the list's selection.

This is a JavaBeans bound property.

Parameters:
  `model` - the `ListModel` that provides the list of items for display
Throws:
  `IllegalArgumentException` - if `model` is `null`
See Also:
  - `getModel()`
  - `clearSelection()`

### setListData

public void setListData(E[] listData)
Constructs a read-only `ListModel` from an array of items, and calls `setModel` with this model.

Attempts to pass a `null` value to this method results in undefined behavior and, most likely, exceptions. The created model references the given array directly. Attempts to modify the array after invoking this method results in undefined behavior.

Parameters:
  `listData` - an array of `E` containing the items to display in the list
See Also:
  - `setModel(ListModel)`

### setListData

public void setListData(Vector<? extends E> listData)
Constructs a read-only `ListModel` from a `Vector` and calls `setModel` with this model.

Attempts to pass a `null` value to this method results in undefined behavior and, most likely, exceptions. The created model references the given `Vector` directly. Attempts to modify the `Vector` after invoking this method results in undefined behavior.

Parameters:
  `listData` - a `Vector` containing the items to display in the list
See Also:
  - `setModel(ListModel)`

### createSelectionModel

protected ListSelectionModel createSelectionModel()
Returns an instance of `DefaultListSelectionModel`; called during construction to initialize the list's selection model property.

Returns:
  a `DefaultListSelectionModel`, used to initialize the list's selection model property during construction
See Also:
  - `setSelectionModel(ListSelectionModel)`
  - `DefaultListSelectionModel`

### getSelectionModel

public ListSelectionModel getSelectionModel()
Returns the current selection model. The selection model maintains the selection state of the list. See the class level documentation for more details.

Returns:
  the `ListSelectionModel` that maintains the list's selections
See Also:
  - `setSelectionModel(ListSelectionModel)`
  - `ListSelectionModel`

### fireSelectionValueChanged

protected void fireSelectionValueChanged(int firstIndex, int lastIndex, boolean isAdjusting)
Notifies `ListSelectionListener`s added directly to the list of selection changes made to the selection model. `JList` listens for changes made to the selection in the selection model, and forwards notification to listeners added to the list directly, by calling this method.

This method constructs a `ListSelectionEvent` with this list as the source, and the specified arguments, and sends it to the registered `ListSelectionListeners`.

Parameters:
  `firstIndex` - the first index in the range, `<= lastIndex`
  `lastIndex` - the last index in the range, `>= firstIndex`
  `isAdjusting` - whether or not this is one in a series of multiple events, where changes are still being made
See Also:
  - `addListSelectionListener(ListSelectionListener)`
  - `removeListSelectionListener(ListSelectionListener)`
  - `ListSelectionEvent`
  - `EventListenerList`

### addListSelectionListener

public void addListSelectionListener(ListSelectionListener listener)
Adds a listener to the list, to be notified each time a change to the selection occurs; the preferred way of listening for selection state changes. `JList` takes care of listening for selection state changes in the selection model, and notifies the given listener of each change. `ListSelectionEvent`s sent to the listener have a `source` property set to this list.

Parameters:
  `listener` - the `ListSelectionListener` to add
See Also:
  - `getSelectionModel()`
  - `getListSelectionListeners()`

### removeListSelectionListener

public void removeListSelectionListener(ListSelectionListener listener)
Removes a selection listener from the list.

Parameters:
  `listener` - the `ListSelectionListener` to remove
See Also:
  - `addListSelectionListener(ListSelectionListener)`
  - `getSelectionModel()`

### getListSelectionListeners

@BeanProperty(bound=false) public ListSelectionListener[] getListSelectionListeners()
Returns an array of all the `ListSelectionListener`s added to this `JList` by way of `addListSelectionListener`.

Returns:
  all of the `ListSelectionListener`s on this list, or an empty array if no listeners have been added
Since:
  1.4
See Also:
  - `addListSelectionListener(ListSelectionListener)`

### setSelectionModel

@BeanProperty(description="The selection model, recording which cells are selected.") public void setSelectionModel(ListSelectionModel selectionModel)
Sets the `selectionModel` for the list to a non-`null` `ListSelectionModel` implementation. The selection model handles the task of making single selections, selections of contiguous ranges, and non-contiguous selections.

This is a JavaBeans bound property.

Parameters:
  `selectionModel` - the `ListSelectionModel` that implements the selections
Throws:
  `IllegalArgumentException` - if `selectionModel` is `null`
See Also:
  - `getSelectionModel()`

### 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)
Sets the selection mode for the list. This is a cover method that sets the selection mode directly on the selection model.

The following list describes the accepted selection modes:

- `ListSelectionModel.SINGLE_SELECTION` - Only one list index can be selected at a time. In this mode, `setSelectionInterval` and `addSelectionInterval` are equivalent, both replacing the current selection with the index represented by the second argument (the "lead").
- `ListSelectionModel.SINGLE_INTERVAL_SELECTION` - Only one contiguous interval can be selected at a time. In this mode, `addSelectionInterval` behaves like `setSelectionInterval` (replacing the current selection}, unless the given interval is immediately adjacent to or overlaps the existing selection, and can be used to grow the selection.
- `ListSelectionModel.MULTIPLE_INTERVAL_SELECTION` - In this mode, there's no restriction on what can be selected. This mode is the default.

Parameters:
  `selectionMode` - the selection mode
Throws:
  `IllegalArgumentException` - if the selection mode isn't one of those allowed
See Also:
  - `getSelectionMode()`

### getSelectionMode

public int getSelectionMode()
Returns the current selection mode for the list. This is a cover method that delegates to the method of the same name on the list's selection model.

Returns:
  the current selection mode
See Also:
  - `setSelectionMode(int)`

### getAnchorSelectionIndex

@BeanProperty(bound=false) public int getAnchorSelectionIndex()
Returns the anchor selection index. This is a cover method that delegates to the method of the same name on the list's selection model.

Returns:
  the anchor selection index
See Also:
  - `ListSelectionModel.getAnchorSelectionIndex()`

### getLeadSelectionIndex

@BeanProperty(bound=false, description="The lead selection index.") public int getLeadSelectionIndex()
Returns the lead selection index. This is a cover method that delegates to the method of the same name on the list's selection model.

Returns:
  the lead selection index
See Also:
  - `ListSelectionModel.getLeadSelectionIndex()`

### getMinSelectionIndex

@BeanProperty(bound=false) public int getMinSelectionIndex()
Returns the smallest selected cell index, or `-1` if the selection is empty. This is a cover method that delegates to the method of the same name on the list's selection model.

Returns:
  the smallest selected cell index, or `-1`
See Also:
  - `ListSelectionModel.getMinSelectionIndex()`

### getMaxSelectionIndex

@BeanProperty(bound=false) public int getMaxSelectionIndex()
Returns the largest selected cell index, or `-1` if the selection is empty. This is a cover method that delegates to the method of the same name on the list's selection model.

Returns:
  the largest selected cell index
See Also:
  - `ListSelectionModel.getMaxSelectionIndex()`

### isSelectedIndex

public boolean isSelectedIndex(int index)
Returns `true` if the specified index is selected, else `false`. This is a cover method that delegates to the method of the same name on the list's selection model.

Parameters:
  `index` - index to be queried for selection state
Returns:
  `true` if the specified index is selected, else `false`
See Also:
  - `ListSelectionModel.isSelectedIndex(int)`
  - `setSelectedIndex(int)`

### isSelectionEmpty

@BeanProperty(bound=false) public boolean isSelectionEmpty()
Returns `true` if nothing is selected, else `false`. This is a cover method that delegates to the method of the same name on the list's selection model.

Returns:
  `true` if nothing is selected, else `false`
See Also:
  - `ListSelectionModel.isSelectionEmpty()`
  - `clearSelection()`

### clearSelection

public void clearSelection()
Clears the selection; after calling this method, `isSelectionEmpty` will return `true`. This is a cover method that delegates to the method of the same name on the list's selection model.

See Also:
  - `ListSelectionModel.clearSelection()`
  - `isSelectionEmpty()`

### setSelectionInterval

public void setSelectionInterval(int anchor, int lead)
Selects the specified interval. Both `anchor` and `lead` indices are included. `anchor` doesn't have to be less than or equal to `lead`. This is a cover method that delegates to the method of the same name on the list's selection model.

Refer to the documentation of the selection model class being used for details on how values less than `0` are handled.

Parameters:
  `anchor` - the first index to select
  `lead` - the last index to select
See Also:
  - `ListSelectionModel.setSelectionInterval(int, int)`
  - `DefaultListSelectionModel.setSelectionInterval(int, int)`
  - `createSelectionModel()`
  - `addSelectionInterval(int, int)`
  - `removeSelectionInterval(int, int)`

### addSelectionInterval

public void addSelectionInterval(int anchor, int lead)
Sets the selection to be the union of the specified interval with current selection. Both the `anchor` and `lead` indices are included. `anchor` doesn't have to be less than or equal to `lead`. This is a cover method that delegates to the method of the same name on the list's selection model.

Refer to the documentation of the selection model class being used for details on how values less than `0` are handled.

Parameters:
  `anchor` - the first index to add to the selection
  `lead` - the last index to add to the selection
See Also:
  - `ListSelectionModel.addSelectionInterval(int, int)`
  - `DefaultListSelectionModel.addSelectionInterval(int, int)`
  - `createSelectionModel()`
  - `setSelectionInterval(int, int)`
  - `removeSelectionInterval(int, int)`

### removeSelectionInterval

public void removeSelectionInterval(int index0, int index1)
Sets the selection to be the set difference of the specified interval and the current selection. Both the `index0` and `index1` indices are removed. `index0` doesn't have to be less than or equal to `index1`. This is a cover method that delegates to the method of the same name on the list's selection model.

Refer to the documentation of the selection model class being used for details on how values less than `0` are handled.

Parameters:
  `index0` - the first index to remove from the selection
  `index1` - the last index to remove from the selection
See Also:
  - `ListSelectionModel.removeSelectionInterval(int, int)`
  - `DefaultListSelectionModel.removeSelectionInterval(int, int)`
  - `createSelectionModel()`
  - `setSelectionInterval(int, int)`
  - `addSelectionInterval(int, int)`

### setValueIsAdjusting

public void setValueIsAdjusting(boolean b)
Sets the selection model's `valueIsAdjusting` property. When `true`, upcoming changes to selection should be considered part of a single change. This property is used internally and developers typically need not call this method. For example, when the model is being updated in response to a user drag, the value of the property is set to `true` when the drag is initiated and set to `false` when the drag is finished. This allows listeners to update only when a change has been finalized, rather than handling all of the intermediate values.

You may want to use this directly if making a series of changes that should be considered part of a single change.

This is a cover method that delegates to the method of the same name on the list's selection model. See the documentation for `ListSelectionModel.setValueIsAdjusting(boolean)` for more details.

Parameters:
  `b` - the new value for the property
See Also:
  - `ListSelectionModel.setValueIsAdjusting(boolean)`
  - `ListSelectionEvent.getValueIsAdjusting()`
  - `getValueIsAdjusting()`

### getValueIsAdjusting

public boolean getValueIsAdjusting()
Returns the value of the selection model's `isAdjusting` property.

This is a cover method that delegates to the method of the same name on the list's selection model.

Returns:
  the value of the selection model's `isAdjusting` property.
See Also:
  - `setValueIsAdjusting(boolean)`
  - `ListSelectionModel.getValueIsAdjusting()`

### getSelectedIndices

public int[] getSelectedIndices()
Returns an array of all of the selected indices, in increasing order.

Returns:
  all of the selected indices, in increasing order, or an empty array if nothing is selected
See Also:
  - `removeSelectionInterval(int, int)`
  - `addListSelectionListener(ListSelectionListener)`

### setSelectedIndex

@BeanProperty(bound=false, description="The index of the selected cell.") public void setSelectedIndex(int index)
Selects a single cell. Does nothing if the given index is greater than or equal to the model size. This is a convenience method that uses `setSelectionInterval` on the selection model. Refer to the documentation for the selection model class being used for details on how values less than `0` are handled.

Parameters:
  `index` - the index of the cell to select
See Also:
  - `ListSelectionModel.setSelectionInterval(int, int)`
  - `isSelectedIndex(int)`
  - `addListSelectionListener(ListSelectionListener)`

### setSelectedIndices

public void setSelectedIndices(int[] indices)
Changes the selection to be the set of indices specified by the given array. Indices greater than or equal to the model size are ignored. This is a convenience method that clears the selection and then uses `addSelectionInterval` on the selection model to add the indices. Refer to the documentation of the selection model class being used for details on how values less than `0` are handled.

Parameters:
  `indices` - an array of the indices of the cells to select, `non-null`
Throws:
  `NullPointerException` - if the given array is `null`
See Also:
  - `ListSelectionModel.addSelectionInterval(int, int)`
  - `isSelectedIndex(int)`
  - `addListSelectionListener(ListSelectionListener)`

### getSelectedValues

@Deprecated @BeanProperty(bound=false) public Object[] getSelectedValues()
Deprecated.
As of JDK 1.7, replaced by `getSelectedValuesList()`
Returns an array of all the selected values, in increasing order based on their indices in the list.

Returns:
  the selected values, or an empty array if nothing is selected
See Also:
  - `isSelectedIndex(int)`
  - `getModel()`
  - `addListSelectionListener(ListSelectionListener)`

### getSelectedValuesList

@BeanProperty(bound=false) public List<E> getSelectedValuesList()
Returns a list of all the selected items, in increasing order based on their indices in the list.

Returns:
  the selected items, or an empty list if nothing is selected
Since:
  1.7
See Also:
  - `isSelectedIndex(int)`
  - `getModel()`
  - `addListSelectionListener(ListSelectionListener)`

### getSelectedIndex

public int getSelectedIndex()
Returns the smallest selected cell index; the selection when only a single item is selected in the list. When multiple items are selected, it is simply the smallest selected index. Returns `-1` if there is no selection.

This method is a cover that delegates to `getMinSelectionIndex`.

Returns:
  the smallest selected cell index
See Also:
  - `getMinSelectionIndex()`
  - `addListSelectionListener(ListSelectionListener)`

### getSelectedValue

@BeanProperty(bound=false) public E getSelectedValue()
Returns the value for the smallest selected cell index; the selected value when only a single item is selected in the list. When multiple items are selected, it is simply the value for the smallest selected index. Returns `null` if there is no selection.

This is a convenience method that simply returns the model value for `getMinSelectionIndex`.

Returns:
  the first selected value
See Also:
  - `getMinSelectionIndex()`
  - `getModel()`
  - `addListSelectionListener(ListSelectionListener)`

### setSelectedValue

public void setSelectedValue(Object anObject, boolean shouldScroll)
Selects the specified object from the list. If the object passed is `null`, the selection is cleared.

Parameters:
  `anObject` - the object to select
  `shouldScroll` - `true` if the list should scroll to display the selected object, if one exists; otherwise `false`

### getPreferredScrollableViewportSize

@BeanProperty(bound=false) public Dimension getPreferredScrollableViewportSize()
Computes the size of viewport needed to display `visibleRowCount` rows. The value returned by this method depends on the layout orientation:

`VERTICAL`:
This is trivial if both `fixedCellWidth` and `fixedCellHeight` have been set (either explicitly or by specifying a prototype cell value). The width is simply the `fixedCellWidth` plus the list's horizontal insets. The height is the `fixedCellHeight` multiplied by the `visibleRowCount`, plus the list's vertical insets.

If either `fixedCellWidth` or `fixedCellHeight` haven't been specified, heuristics are used. If the model is empty, the width is the `fixedCellWidth`, if greater than `0`, or a hard-coded value of `256`. The height is the `fixedCellHeight` multiplied by `visibleRowCount`, if `fixedCellHeight` is greater than `0`, otherwise it is a hard-coded value of `16` multiplied by `visibleRowCount`.

If the model isn't empty, the width is the preferred size's width, typically the width of the widest list element. The height is the height of the cell with index 0 multiplied by the `visibleRowCount`, plus the list's vertical insets.

`VERTICAL_WRAP` or `HORIZONTAL_WRAP`:
This method simply returns the value from `getPreferredSize`. The list's `ListUI` is expected to override `getPreferredSize` to return an appropriate value.

Specified by:
  `getPreferredScrollableViewportSize` in interface `Scrollable`
Returns:
  a dimension containing the size of the viewport needed to display `visibleRowCount` rows
See Also:
  - `getPreferredScrollableViewportSize()`
  - `setPrototypeCellValue(E)`

### getScrollableUnitIncrement

public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction)
Returns the distance to scroll to expose the next or previous row (for vertical scrolling) or column (for horizontal scrolling).

For horizontal scrolling, if the layout orientation is `VERTICAL`, then the list's font size is returned (or `1` if the font is `null`).

Specified by:
  `getScrollableUnitIncrement` in interface `Scrollable`
Parameters:
  `visibleRect` - the view area visible within the viewport
  `orientation` - `SwingConstants.HORIZONTAL` or `SwingConstants.VERTICAL`
  `direction` - less or equal to zero to scroll up/back, greater than zero for down/forward
Returns:
  the "unit" increment for scrolling in the specified direction; always positive
Throws:
  `IllegalArgumentException` - if `visibleRect` is `null`, or `orientation` isn't one of `SwingConstants.VERTICAL` or `SwingConstants.HORIZONTAL`
See Also:
  - `getScrollableBlockIncrement(Rectangle, int, int)`
  - `Scrollable.getScrollableUnitIncrement(Rectangle, int, int)`

### getScrollableBlockIncrement

public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction)
Returns the distance to scroll to expose the next or previous block.

For vertical scrolling, the following rules are used:

- if scrolling down, returns the distance to scroll so that the last visible element becomes the first completely visible element
- if scrolling up, returns the distance to scroll so that the first visible element becomes the last completely visible element
- returns `visibleRect.height` if the list is empty

For horizontal scrolling, when the layout orientation is either `VERTICAL_WRAP` or `HORIZONTAL_WRAP`:

- if scrolling right, returns the distance to scroll so that the last visible element becomes the first completely visible element
- if scrolling left, returns the distance to scroll so that the first visible element becomes the last completely visible element
- returns `visibleRect.width` if the list is empty

For horizontal scrolling and `VERTICAL` orientation, returns `visibleRect.width`.

Note that the value of `visibleRect` must be the equal to `this.getVisibleRect()`.

Specified by:
  `getScrollableBlockIncrement` in interface `Scrollable`
Parameters:
  `visibleRect` - the view area visible within the viewport
  `orientation` - `SwingConstants.HORIZONTAL` or `SwingConstants.VERTICAL`
  `direction` - less or equal to zero to scroll up/back, greater than zero for down/forward
Returns:
  the "block" increment for scrolling in the specified direction; always positive
Throws:
  `IllegalArgumentException` - if `visibleRect` is `null`, or `orientation` isn't one of `SwingConstants.VERTICAL` or `SwingConstants.HORIZONTAL`
See Also:
  - `getScrollableUnitIncrement(Rectangle, int, int)`
  - `Scrollable.getScrollableBlockIncrement(Rectangle, int, int)`

### getScrollableTracksViewportWidth

@BeanProperty(bound=false) public boolean getScrollableTracksViewportWidth()
Returns `true` if this `JList` is displayed in a `JViewport` and the viewport is wider than the list's preferred width, or if the layout orientation is `HORIZONTAL_WRAP` and `visibleRowCount <= 0`; otherwise returns `false`.

If `false`, then don't track the viewport's width. This allows horizontal scrolling if the `JViewport` is itself embedded in a `JScrollPane`.

Specified by:
  `getScrollableTracksViewportWidth` in interface `Scrollable`
Returns:
  whether or not an enclosing viewport should force the list's width to match its own
See Also:
  - `Scrollable.getScrollableTracksViewportWidth()`

### getScrollableTracksViewportHeight

@BeanProperty(bound=false) public boolean getScrollableTracksViewportHeight()
Returns `true` if this `JList` is displayed in a `JViewport` and the viewport is taller than the list's preferred height, or if the layout orientation is `VERTICAL_WRAP` and `visibleRowCount <= 0`; otherwise returns `false`.

If `false`, then don't track the viewport's height. This allows vertical scrolling if the `JViewport` is itself embedded in a `JScrollPane`.

Specified by:
  `getScrollableTracksViewportHeight` in interface `Scrollable`
Returns:
  whether or not an enclosing viewport should force the list's height to match its own
See Also:
  - `Scrollable.getScrollableTracksViewportHeight()`

### paramString

protected String paramString()
Returns a `String` representation of this `JList`. This method is intended to be used only for debugging purposes, and the content and format of the returned `String` may vary between implementations. The returned `String` may be empty, but may not be `null`.

Overrides:
  `paramString` in class `JComponent`
Returns:
  a `String` representation of this `JList`.

### getAccessibleContext

@BeanProperty(bound=false) public AccessibleContext getAccessibleContext()
Gets the `AccessibleContext` associated with this `JList`. For `JList`, the `AccessibleContext` takes the form of an `AccessibleJList`.

A new `AccessibleJList` instance is created if necessary.

Specified by:
  `getAccessibleContext` in interface `Accessible`
Overrides:
  `getAccessibleContext` in class `Component`
Returns:
  an `AccessibleJList` that serves as the `AccessibleContext` of this `JList`