public class SizeSequence extends Object
SizeSequence
object efficiently maintains an ordered list of sizes and corresponding positions. One situation for which SizeSequence
might be appropriate is in a component that displays multiple rows of unequal size. In this case, a single SizeSequence
object could be used to track the heights and Y positions of all rows. Another example would be a multi-column component, such as a JTable
, in which the column sizes are not all equal. The JTable
might use a single SizeSequence
object to store the widths and X positions of all the columns. The JTable
could then use the SizeSequence
object to find the column corresponding to a certain position. The JTable
could update the SizeSequence
object whenever one or more column sizes changed.
The following figure shows the relationship between size and position data for a multi-column component.
In the figure, the first index (0) corresponds to the first column, the second index (1) to the second column, and so on. The first column's position starts at 0, and the column occupies size0 pixels, where size0 is the value returned by getSize(0)
. Thus, the first column ends at size0 - 1. The second column then begins at the position size0 and occupies size1 (getSize(1)
) pixels.
Note that a SizeSequence
object simply represents intervals along an axis. In our examples, the intervals represent height or width in pixels. However, any other unit of measure (for example, time in days) could be just as valid.
getIndex(position)
and setSize(index, size)
. Whichever choice of internal format is made one of these operations is costly when the number of entries becomes large. If sizes are stored, finding the index of the entry that encloses a particular position is linear in the number of entries. If positions are stored instead, setting the size of an entry at a particular index requires updating the positions of the affected entries, which is also a linear calculation. Like the above techniques this class holds an array of N integers internally but uses a hybrid encoding, which is halfway between the size-based and positional-based approaches. The result is a data structure that takes the same space to store the information but can perform most operations in Log(N) time instead of O(N), where N is the number of entries in the list.
Two operations that remain O(N) in the number of entries are the insertEntries
and removeEntries
methods, both of which are implemented by converting the internal array to a set of integer sizes, copying it into the new array, and then reforming the hybrid representation in place.
Constructor | Description |
---|---|
SizeSequence() |
Creates a new SizeSequence object that contains no entries. |
SizeSequence |
Creates a new SizeSequence object that contains the specified number of entries, all initialized to have size 0. |
SizeSequence |
Creates a new SizeSequence object that contains the specified sizes. |
SizeSequence |
Creates a new SizeSequence object that contains the specified number of entries, all initialized to have size value . |
Modifier and Type | Method | Description |
---|---|---|
int |
getIndex |
Returns the index of the entry that corresponds to the specified position. |
int |
getPosition |
Returns the start position for the specified entry. |
int |
getSize |
Returns the size of the specified entry. |
int[] |
getSizes() |
Returns the size of all entries. |
void |
insertEntries |
Adds a contiguous group of entries to this SizeSequence . |
void |
removeEntries |
Removes a contiguous group of entries from this SizeSequence . |
void |
setSize |
Sets the size of the specified entry. |
void |
setSizes |
Resets this SizeSequence object, using the data in the sizes argument. |
public SizeSequence()
SizeSequence
object that contains no entries. To add entries, you can use insertEntries
or setSizes
.public SizeSequence(int numEntries)
SizeSequence
object that contains the specified number of entries, all initialized to have size 0.numEntries
- the number of sizes to trackNegativeArraySizeException
- if numEntries < 0
public SizeSequence(int numEntries, int value)
SizeSequence
object that contains the specified number of entries, all initialized to have size value
.numEntries
- the number of sizes to trackvalue
- the initial value of each sizepublic SizeSequence(int[] sizes)
SizeSequence
object that contains the specified sizes.sizes
- the array of sizes to be contained in the SizeSequence
public void setSizes(int[] sizes)
SizeSequence
object, using the data in the sizes
argument. This method reinitializes this object so that it contains as many entries as the sizes
array. Each entry's size is initialized to the value of the corresponding item in sizes
.sizes
- the array of sizes to be contained in this SizeSequence
public int[] getSizes()
public int getPosition(int index)
getPosition(0)
returns 0, getPosition(1)
is equal to getSize(0)
, getPosition(2)
is equal to getSize(0)
+ getSize(1)
, and so on. Note that if index
is greater than length
the value returned may be meaningless.
index
- the index of the entry whose position is desiredpublic int getIndex(int position)
getIndex(0)
is 0, since the first entry always starts at position 0.position
- the position of the entrypublic int getSize(int index)
index
is out of the range (0 <= index < getSizes().length)
the behavior is unspecified.index
- the index corresponding to the entrypublic void setSize(int index, int size)
index
does not fall in the range: (0 <= index < getSizes().length)
the behavior is unspecified.index
- the index corresponding to the entrysize
- the size of the entrypublic void insertEntries(int start, int length, int value)
SizeSequence
. Note that the values of start
and length
must satisfy the following conditions: (0 <= start < getSizes().length)
AND (length >= 0)
. If these conditions are not met, the behavior is unspecified and an exception may be thrown.start
- the index to be assigned to the first entry in the grouplength
- the number of entries in the groupvalue
- the size to be assigned to each new entryArrayIndexOutOfBoundsException
- if the parameters are outside of the range: (0 <= start < (getSizes().length)) AND (length >= 0)
public void removeEntries(int start, int length)
SizeSequence
. Note that the values of start
and length
must satisfy the following conditions: (0 <= start < getSizes().length)
AND (length >= 0)
. If these conditions are not met, the behavior is unspecified and an exception may be thrown.start
- the index of the first entry to be removedlength
- the number of entries to be removed
© 1993, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/docs/api/java.desktop/javax/swing/SizeSequence.html