java.lang.Object javax.swing.SizeSequenceA
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 multicolumn 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 multicolumn 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 size_{0} pixels,
where size_{0} is the value returned by
getSize(0)
.
Thus, the first column ends at size_{0}  1.
The second column then begins at
the position size_{0}
and occupies size_{1} (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 sizebased and positionalbased 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.
Philip
 Milne1.3
 Method from javax.swing.SizeSequence Summary: 

getIndex, getPosition, getSize, getSizes, insertEntries, removeEntries, setSize, setSizes, setSizes 
Methods from java.lang.Object: 

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait 
Method from javax.swing.SizeSequence Detail: 

public int getIndex(int position){ return getIndex(0, a.length, position); }
getIndex(0) is 0,
since the first entry always starts at position 0. 
public int getPosition(int index){ return getPosition(0, a.length, 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 
public int getSize(int index){ return getPosition(index + 1)  getPosition(index); }
index is out of the range
(0 <= index < getSizes().length)
the behavior is unspecified. 
public int[] getSizes(){ int n = a.length; int[] sizes = new int[n]; getSizes(0, n, sizes); return sizes; }

public void insertEntries(int start, int length, int value){ int sizes[] = getSizes(); int end = start + length; int n = a.length + length; a = new int[n]; for (int i = 0; i < start; i++) { a[i] = sizes[i] ; } for (int i = start; i < end; i++) { a[i] = value ; } for (int i = end; i < n; i++) { a[i] = sizes[ilength] ; } setSizes(a); }
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. 
public void removeEntries(int start, int length){ int sizes[] = getSizes(); int end = start + length; int n = a.length  length; a = new int[n]; for (int i = 0; i < start; i++) { a[i] = sizes[i] ; } for (int i = start; i < n; i++) { a[i] = sizes[i+length] ; } setSizes(a); }
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. 
public void setSize(int index, int size){ changeSize(0, a.length, index, size  getSize(index)); }
index
does not fall in the range:
(0 <= index < getSizes().length)
the behavior is unspecified. 
public void setSizes(int[] sizes){ if (a.length != sizes.length) { a = new int[sizes.length]; } setSizes(0, a.length, 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 . 
void setSizes(int length, int size){ if (a.length != length) { a = new int[length]; } setSizes(0, length, size); }
length items
all with a size of size . 