| Methods Summary |
|---|
| public void | append(int key, E value)Puts a key/value pair into the array, optimizing for the case where
the key is greater than all existing keys in the array.
if (mSize != 0 && key <= mKeys[mSize - 1]) {
put(key, value);
return;
}
if (mGarbage && mSize >= mKeys.length) {
gc();
}
int pos = mSize;
if (pos >= mKeys.length) {
int n = ContainerHelpers.idealIntArraySize(pos + 1);
int[] nkeys = new int[n];
Object[] nvalues = new Object[n];
// Log.e("SparseArray", "grow " + mKeys.length + " to " + n);
System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
System.arraycopy(mValues, 0, nvalues, 0, mValues.length);
mKeys = nkeys;
mValues = nvalues;
}
mKeys[pos] = key;
mValues[pos] = value;
mSize = pos + 1;
|
| public void | clear()Removes all key-value mappings from this SparseArray.
int n = mSize;
Object[] values = mValues;
for (int i = 0; i < n; i++) {
values[i] = null;
}
mSize = 0;
mGarbage = false;
|
| public android.support.v4.util.SparseArrayCompat | clone()
SparseArrayCompat<E> clone = null;
try {
clone = (SparseArrayCompat<E>) super.clone();
clone.mKeys = mKeys.clone();
clone.mValues = mValues.clone();
} catch (CloneNotSupportedException cnse) {
/* ignore */
}
return clone;
|
| public void | delete(int key)Removes the mapping from the specified key, if there was any.
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
if (i >= 0) {
if (mValues[i] != DELETED) {
mValues[i] = DELETED;
mGarbage = true;
}
}
|
| private void | gc()
// Log.e("SparseArray", "gc start with " + mSize);
int n = mSize;
int o = 0;
int[] keys = mKeys;
Object[] values = mValues;
for (int i = 0; i < n; i++) {
Object val = values[i];
if (val != DELETED) {
if (i != o) {
keys[o] = keys[i];
values[o] = val;
values[i] = null;
}
o++;
}
}
mGarbage = false;
mSize = o;
// Log.e("SparseArray", "gc end with " + mSize);
|
| public E | get(int key)Gets the Object mapped from the specified key, or null
if no such mapping has been made.
return get(key, null);
|
| public E | get(int key, E valueIfKeyNotFound)Gets the Object mapped from the specified key, or the specified Object
if no such mapping has been made.
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
if (i < 0 || mValues[i] == DELETED) {
return valueIfKeyNotFound;
} else {
return (E) mValues[i];
}
|
| public int | indexOfKey(int key)Returns the index for which {@link #keyAt} would return the
specified key, or a negative number if the specified
key is not mapped.
if (mGarbage) {
gc();
}
return ContainerHelpers.binarySearch(mKeys, mSize, key);
|
| public int | indexOfValue(E value)Returns an index for which {@link #valueAt} would return the
specified key, or a negative number if no keys map to the
specified value.
Beware that this is a linear search, unlike lookups by key,
and that multiple keys can map to the same value and this will
find only one of them.
Note also that unlike most collections' {@code indexOf} methods,
this method compares values using {@code ==} rather than {@code equals}.
if (mGarbage) {
gc();
}
for (int i = 0; i < mSize; i++)
if (mValues[i] == value)
return i;
return -1;
|
| public int | keyAt(int index)Given an index in the range 0...size()-1, returns
the key from the indexth key-value mapping that this
SparseArray stores.
if (mGarbage) {
gc();
}
return mKeys[index];
|
| public void | put(int key, E value)Adds a mapping from the specified key to the specified value,
replacing the previous mapping from the specified key if there
was one.
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
if (i >= 0) {
mValues[i] = value;
} else {
i = ~i;
if (i < mSize && mValues[i] == DELETED) {
mKeys[i] = key;
mValues[i] = value;
return;
}
if (mGarbage && mSize >= mKeys.length) {
gc();
// Search again because indices may have changed.
i = ~ ContainerHelpers.binarySearch(mKeys, mSize, key);
}
if (mSize >= mKeys.length) {
int n = ContainerHelpers.idealIntArraySize(mSize + 1);
int[] nkeys = new int[n];
Object[] nvalues = new Object[n];
// Log.e("SparseArray", "grow " + mKeys.length + " to " + n);
System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
System.arraycopy(mValues, 0, nvalues, 0, mValues.length);
mKeys = nkeys;
mValues = nvalues;
}
if (mSize - i != 0) {
// Log.e("SparseArray", "move " + (mSize - i));
System.arraycopy(mKeys, i, mKeys, i + 1, mSize - i);
System.arraycopy(mValues, i, mValues, i + 1, mSize - i);
}
mKeys[i] = key;
mValues[i] = value;
mSize++;
}
|
| public void | remove(int key)Alias for {@link #delete(int)}.
delete(key);
|
| public void | removeAt(int index)Removes the mapping at the specified index.
if (mValues[index] != DELETED) {
mValues[index] = DELETED;
mGarbage = true;
}
|
| public void | removeAtRange(int index, int size)Remove a range of mappings as a batch.
final int end = Math.min(mSize, index + size);
for (int i = index; i < end; i++) {
removeAt(i);
}
|
| public void | setValueAt(int index, E value)Given an index in the range 0...size()-1, sets a new
value for the indexth key-value mapping that this
SparseArray stores.
if (mGarbage) {
gc();
}
mValues[index] = value;
|
| public int | size()Returns the number of key-value mappings that this SparseArray
currently stores.
if (mGarbage) {
gc();
}
return mSize;
|
| public java.lang.String | toString(){@inheritDoc}
This implementation composes a string by iterating over its mappings. If
this map contains itself as a value, the string "(this Map)"
will appear in its place.
if (size() <= 0) {
return "{}";
}
StringBuilder buffer = new StringBuilder(mSize * 28);
buffer.append('{");
for (int i=0; i<mSize; i++) {
if (i > 0) {
buffer.append(", ");
}
int key = keyAt(i);
buffer.append(key);
buffer.append('=");
Object value = valueAt(i);
if (value != this) {
buffer.append(value);
} else {
buffer.append("(this Map)");
}
}
buffer.append('}");
return buffer.toString();
|
| public E | valueAt(int index)Given an index in the range 0...size()-1, returns
the value from the indexth key-value mapping that this
SparseArray stores.
if (mGarbage) {
gc();
}
return (E) mValues[index];
|
