LazyRow

Functions summary

Unit

@Composable
LazyRow(
    modifier: Modifier,
    state: LazyListState,
    contentPadding: PaddingValues,
    reverseLayout: Boolean,
    horizontalArrangement: Arrangement.Horizontal,
    verticalAlignment: Alignment.Vertical,
    flingBehavior: FlingBehavior,
    userScrollEnabled: Boolean,
    overscrollEffect: OverscrollEffect?,
    cacheWindow: LazyLayoutCacheWindow,
    content: LazyListScope.() -> Unit
)

The horizontally scrolling list that only composes and lays out the currently visible items.

Cmn

Functions

LazyRow

Cmn

Artifact: androidx.compose.foundation:foundation

View Source

@Composable
fun LazyRow(
    modifier: Modifier = Modifier,
    state: LazyListState = rememberLazyListState(),
    contentPadding: PaddingValues = PaddingValues(0.dp),
    reverseLayout: Boolean = false,
    horizontalArrangement: Arrangement.Horizontal = if (!reverseLayout) Arrangement.Start else Arrangement.End,
    verticalAlignment: Alignment.Vertical = Alignment.Top,
    flingBehavior: FlingBehavior = ScrollableDefaults.flingBehavior(),
    userScrollEnabled: Boolean = true,
    overscrollEffect: OverscrollEffect? = rememberOverscrollEffect(),
    cacheWindow: LazyLayoutCacheWindow = LazyListDefaults.cacheWindow(state),
    content: LazyListScope.() -> Unit
): Unit

The horizontally scrolling list that only composes and lays out the currently visible items. The content block defines a DSL which allows you to emit items of different types. For example you can use LazyListScope.item to add a single item and LazyListScope.items to add a list of items.

import androidx.compose.foundation.lazy.LazyRow
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.material3.Text

val itemsList = (0..5).toList()
val itemsIndexedList = listOf("A", "B", "C")

LazyRow {
    items(itemsList) { Text("Item is $it") }

    item { Text("Single item") }

    itemsIndexed(itemsIndexedList) { index, item -> Text("Item at index $index is $item") }
}

Sample with custom cache window:

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.layout.LazyLayoutCacheWindow
import androidx.compose.material3.Text

val itemsList = (0..100).toList()

LazyColumn(cacheWindow = LazyLayoutCacheWindow(aheadFraction = 0.5f, behindFraction = 0.2f)) {
    items(itemsList) { item -> Text("Item $item") }
}

Parameters
`modifier: Modifier = Modifier`	the modifier to apply to this layout
`state: LazyListState = rememberLazyListState()`	the state object to be used to control or observe the list's state
`contentPadding: PaddingValues = PaddingValues(0.dp)`	a padding around the whole content. This will add padding for the content after it has been clipped, which is not possible via `modifier` param. You can use it to add a padding before the first item or after the last one. If you want to add a spacing between each item use `horizontalArrangement`.
`reverseLayout: Boolean = false`	reverse the direction of scrolling and layout. When `true`, items are laid out in the reverse order and `LazyListState.firstVisibleItemIndex` == 0 means that row is scrolled to the end. Note that `reverseLayout` does not change the behavior of `horizontalArrangement`, e.g. with 123### becomes 321###.
`horizontalArrangement: Arrangement.Horizontal = if (!reverseLayout) Arrangement.Start else Arrangement.End`	The horizontal arrangement of the layout's children. This allows to add a spacing between items and specify the arrangement of the items when we have not enough of them to fill the whole minimum size.
`verticalAlignment: Alignment.Vertical = Alignment.Top`	the vertical alignment applied to the items
`flingBehavior: FlingBehavior = ScrollableDefaults.flingBehavior()`	logic describing fling behavior.
`userScrollEnabled: Boolean = true`	whether the scrolling via the user gestures or accessibility actions is allowed. You can still scroll programmatically using the state even when it is disabled.
`overscrollEffect: OverscrollEffect? = rememberOverscrollEffect()`	the `OverscrollEffect` that will be used to render overscroll for this layout. Note that the `OverscrollEffect.node` will be applied internally as well - you do not need to use Modifier.overscroll separately.
`cacheWindow: LazyLayoutCacheWindow = LazyListDefaults.cacheWindow(state)`	`LazyLayoutCacheWindow` configuring the area ahead and behind the viewport to prefetch and retain items. The default cache window does not cache items while the user is not scrolling. Override this to tune scrolling performance, such as increasing the ahead window to reduce frame drops during scrolling or adding a behind window to retain recently visible items when scrolling back and forth.
`content: LazyListScope.() -> Unit`	a block which describes the content. Inside this block you can use methods like `LazyListScope.item` to add a single item or `LazyListScope.items` to add a list of items.