recyclerview/androidx.recyclerview.widget/SortedList

SortedList

open class SortedList<T>(source)

A Sorted list implementation that can keep items in order and also notify for changes in the list such that it can be bound to a RecyclerView.Adapter.

It keeps items ordered using the compare method and uses binary search to retrieve items. If the sorting criteria of your items may change, make sure you call appropriate methods while editing them to avoid data inconsistencies.

You can control the order of items and change notifications via the Callback parameter.

Constructors

constructor(@NonNull klass: Class<T>, @NonNull callback: SortedList.Callback<T>)

Creates a new SortedList of type T.

constructor(@NonNull klass: Class<T>, @NonNull callback: SortedList.Callback<T>, initialCapacity: Int)

Creates a new SortedList of type T.

Types

BatchedCallback

open class BatchedCallback<T2> : SortedList.Callback<T2>

A callback implementation that can batch notify events dispatched by the SortedList.

abstract class Callback<T2> : Comparator<T> , ListUpdateCallback

The class that controls the behavior of the SortedList.

Properties

INVALID_POSITION

val INVALID_POSITION: Int = -1

Used by indexOf when the item cannot be found in the list.

Functions

open fun add(item: T): Int

Adds the given item to the list.

open fun addAll(@NonNull items: Array<T>)

open fun addAll(@NonNull items: Collection<T>)

open fun addAll(@NonNull items: Array<T>, mayModifyInput: Boolean)

Adds the given items to the list.

beginBatchedUpdates

open fun beginBatchedUpdates()

Batches adapter updates that happen after calling this method and before calling endBatchedUpdates.

open fun clear()

Removes all items from the SortedList.

endBatchedUpdates

open fun endBatchedUpdates()

Ends the update transaction and dispatches any remaining event to the callback.

open fun get(index: Int): T

Returns the item at the given index.

open fun indexOf(item: T): Int

Returns the position of the provided item.

recalculatePositionOfItemAt

open fun recalculatePositionOfItemAt(index: Int)

This method can be used to recalculate the position of the item at the given index, without triggering an onChanged callback.

open fun remove(item: T): Boolean

Removes the provided item from the list and calls onRemoved.

open fun removeItemAt(index: Int): T

Removes the item at the given index and calls onRemoved.

open fun replaceAll(@NonNull items: Array<T>)

open fun replaceAll(@NonNull items: Collection<T>)

open fun replaceAll(@NonNull items: Array<T>, mayModifyInput: Boolean)

Replaces the current items with the new items, dispatching ListUpdateCallback events for each change detected as appropriate.

open fun size(): Int

The number of items in the list.

open fun updateItemAt(index: Int, item: T)

Updates the item at the given index and calls onChanged and/or onMoved if necessary.