输入关键字搜索
开发者能力认证
鸿蒙高校创新赛
HarmonyOS 7
animation
HarmonyOS行业解决方案
layoutWeight
HarmonyOS模板&组件
bindPopup
bindsheet
CTRL+K
文档管理中心

HarmonyOS

输入关键字搜索
开发者能力认证
鸿蒙高校创新赛
HarmonyOS 7
animation
HarmonyOS行业解决方案
layoutWeight
HarmonyOS模板&组件
bindPopup
bindsheet
CTRL+K
指南
指南应用框架ArkUI（方舟UI框架）UI开发 (ArkTS声明式开发范式)列表与网格创建懒加载布局 (LazyColumnLayout/LazyVGridLayout/LazyVWaterFlowLayout)

创建懒加载布局 (LazyColumnLayout/LazyVGridLayout/LazyVWaterFlowLayout)

更新时间: 2026-08-29 09:41
本文导读
展开章节

ArkUI提供了Scroll、List、Grid、WaterFlow四种滚动类组件。其中，Scroll不支持懒加载，List、Grid、WaterFlow虽支持配合LazyForEach实现懒加载，但各自仅支持特定的布局模式。在实际业务场景中，一个滚动页面往往需要混合使用多种布局模式。例如，电商首页可能同时包含多列网格分类入口、瀑布流商品卡片、线性列表推荐；社交应用信息流可能同时包含文本列表、九宫格图片、视频卡片。此时单一滚动组件无法灵活适配，存在一定局限性。

懒加载布局容器是一类嵌套在可滚动父组件（Scroll、List、WaterFlow）内部，负责按需加载子组件的布局容器。这类容器本身不提供滚动能力，由父组件统一处理滚动。它仅创建和布局处于可滚动父组件可视区域内的子组件，并在帧间空闲时隙预加载可视区域上方和下方各半屏的内容，从而减少首帧渲染时间和内存开销。ArkUI提供了三种支持懒加载的布局容器组件：垂直线性布局LazyColumnLayout、垂直网格布局LazyVGridLayout、垂直瀑布流布局LazyVWaterFlowLayout。不同的懒加载布局容器提供不同的布局模式，开发者可以将多种类型的懒加载布局容器组合在同一个父组件中使用，灵活实现混合布局。

从API版本19开始，支持LazyVGridLayout。从API版本26.0.0开始，支持LazyColumnLayout和LazyVWaterFlowLayout。

使用场景

懒加载布局容器适用于以下典型场景。

  • 混合布局页面：一个滚动页面中需要同时展示多种布局模式的内容，如电商首页、社交应用信息流。List、Grid、WaterFlow分别支持线性、网格、瀑布流布局模式，通过懒加载布局容器可以将不同布局模式灵活组合在同一个可滚动父组件中，每个容器独立配置各自的布局参数（如分组、列数），所有区域共享父组件的统一滚动，无需额外处理滚动组件嵌套导致的手势冲突。

  • 独立数据源管理：页面中不同区域的数据来源不同，需要分别管理各自的数据。每个懒加载布局容器可以使用独立的数据源，不同业务模块的数据无需耦合在一起，降低数据管理的复杂度。

  • Scroll大量子组件场景优化：Scroll组件作为通用滚动容器，本身不提供懒加载能力。通过在其中使用懒加载布局容器，可以实现子组件的按需加载，避免一次性创建所有子组件，保障大量子组件场景下的流畅体验。

能力对比

三种懒加载布局容器的能力对比如下。

展开
能力 LazyVGridLayout LazyVWaterFlowLayout LazyColumnLayout
API起始版本 19 26.0.0 26.0.0
设置行间距 支持（rowsGap） 支持（rowsGap） 支持（space）
设置列间距（columnsGap） 支持 支持 不支持
设置列数（columnsTemplate） 支持 支持 不支持
设置子组件水平对齐方式（alignItems） 不支持 不支持 支持
设置头部组件（header） 从API版本26.0.0开始支持 支持 支持
设置尾部组件（footer） 从API版本26.0.0开始支持 支持 支持
设置吸附效果（sticky） 从API版本26.0.0开始支持 支持 支持
监听可视区域子组件索引变化（onVisibleIndexesChange） 从API版本26.0.0开始支持 支持 支持
嵌套懒加载布局容器 不支持 不支持 支持
布局模式 垂直网格布局 垂直瀑布流布局 垂直线性布局
示例图

约束与限制

  1. 三种懒加载布局容器的高度默认自适应内容，不建议设置会固定或约束组件垂直方向尺寸的属性，设置后会导致显示异常或无法正常滚动。涉及的属性包括height、size中的height、constraintSize中的minHeight/maxHeight、aspectRatio、layoutWeight，以及height取LayoutPolicy值的场景。

  2. 三种懒加载布局容器均需要配合可滚动父组件使用，不同容器支持的父组件范围有所差异。

  3. 三种懒加载布局容器在不同父组件下的懒加载支持条件如下。

    • 在List组件下，要求List组件布局方向必须是竖直方向（即listDirection属性设置为Axis.Vertical），在非竖直方向的List中使用懒加载布局容器会导致应用崩溃。当List设置了lanes、chainAnimation、scrollSnapAlign属性中的任意一个或多个时，懒加载布局容器的懒加载功能会失效。

    • 在Scroll组件下，要求Scroll组件布局方向必须是竖直方向（即scrollable属性设置为ScrollDirection.Vertical），在非竖直方向的Scroll中使用懒加载布局容器会导致应用崩溃。

    • 在WaterFlow组件下，要求WaterFlow组件布局方向必须是竖直方向（即layoutDirection属性设置为FlexDirection.Column），在非竖直方向的WaterFlow中使用LazyColumnLayout或LazyVWaterFlowLayout会导致应用崩溃，使用LazyVGridLayout不会导致应用崩溃，但懒加载功能会失效。当WaterFlow为多列模式或分段布局中的多列分段时，三种懒加载布局容器的懒加载功能均会失效。此外，在布局方向为FlexDirection.ColumnReverse的WaterFlow组件下使用懒加载布局容器会导致显示异常。

创建懒加载网格布局 (LazyVGridLayout)

从API version 19开始，支持懒加载垂直网格布局LazyVGridLayout，其适用于等宽等高的多列网格展示场景，如九宫格图片展示、功能入口图标，也适用于不等宽的多列网格展示场景，如按比例分配列宽的数据面板、设置页面。

创建LazyVGridLayout

以下以在Scroll组件中为例，展示了LazyVGridLayout的创建方式。创建时，需要确保Scroll的布局方向为ScrollDirection.Vertical。

收起
自动换行
深色代码主题
复制
  1. Scroll() {
  2.   LazyVGridLayout() {
  3.     // 子组件
  4.     // ...
  5.   }
  6.   // ...
  7. }
  8. .scrollable(ScrollDirection.Vertical)
LazyVGridLayoutSample.ets

设置列数

LazyVGridLayout组件提供了columnsTemplate属性用于设置当前网格布局的列数和每列尺寸占比。

columnsTemplate属性值是一个由多个空格和'数字+fr'间隔拼接的字符串，fr的个数即网格布局的列数，fr前面的数值大小用于计算该列在网格布局宽度上的占比，最终决定该列宽度。不设置时默认1列。设置为'0fr'时，该列的列宽为0，不显示子组件。设置为其他非法值时，子组件显示为固定1列。

图1 列数占比示例图

如上图所示，构建的是一个三行三列的网格布局，其在水平方向上分为四等份，第一列占一份，第二列占两份，第三列占一份。只要将columnsTemplate设置为'1fr 2fr 1fr'，即可实现上述网格布局。

收起
自动换行
深色代码主题
复制
  1. LazyVGridLayout() {
  2.   // 子组件
  3.   // ...
  4. }
  5. .columnsTemplate('1fr 1fr 1fr') // 设置为3列，每列等宽
  6. // ...
  7. LazyVGridLayout() {
  8.   // 子组件
  9.   // ...
  10. }
  11. .columnsTemplate('1fr 2fr') // 设置为2列，第一列占1份，第二列占2份
LazyVGridLayoutSample.ets

columnsTemplate还支持通过repeat关键字自动计算列数，格式为'repeat(auto-fit/auto-fill/auto-stretch, track-size)'，其中repeat、auto-fit、auto-fill、auto-stretch为关键字，track-size为列宽，支持px、vp、%等单位，默认单位为vp，也支持无单位的有效数字。track-size至少包含一个有效列宽。

展开
模式 示例 说明
auto-fit 'repeat(auto-fit, 80vp)' 设置最小列宽，自动计算列数和实际列宽。仅支持一个有效列宽值。
auto-fill 'repeat(auto-fill, 80vp)' 设置固定列宽，自动计算列数。支持一个或多个有效列宽，如'repeat(auto-fill, 20 80px)'。
auto-stretch 'repeat(auto-stretch, 80vp)' 设置固定列宽，以columnsGap为最小列间距，自动计算列数和实际列间距。仅支持一个有效列宽值，不支持单位%。

设置行列间距

在两个网格单元之间的垂直间距称为行间距，水平间距称为列间距，如下图所示。

图2 网格的行列间距示例图

LazyVGridLayout组件提供了rowsGap和columnsGap属性分别设置行间距和列间距。默认值均为LengthMetrics.vp(0)，设置为小于0的值时按默认值显示。

收起
自动换行
深色代码主题
复制
  1. LazyVGridLayout() {
  2.   // 子组件
  3.   // ...
  4. }
  5. // ...
  6. .rowsGap(LengthMetrics.vp(10))
  7. .columnsGap(LengthMetrics.vp(10))
LazyVGridLayoutSample.ets

创建懒加载瀑布流布局 (LazyVWaterFlowLayout)

从API版本26.0.0开始，支持懒加载垂直瀑布流布局LazyVWaterFlowLayout，其适用于多列等宽但不等高的卡片展示场景，如图片展示、商品推荐。在瀑布流布局中，每个子节点都会放置在当前总高度最小的列。若多列总高度相同，则按照从左到右的顺序进行填充。

创建LazyVWaterFlowLayout

使用LazyVWaterFlowLayout前，需要通过import { LazyVWaterFlowLayout } from '@kit.ArkUI'导入该组件。

以下以在Scroll组件中为例，展示了LazyVWaterFlowLayout的创建方式。创建时，需要确保Scroll的布局方向为ScrollDirection.Vertical。

收起
自动换行
深色代码主题
复制
  1. Scroll() {
  2.   LazyVWaterFlowLayout() {
  3.     // 子组件
  4.     // ...
  5.   }
  6.   // ...
  7. }
  8. .scrollable(ScrollDirection.Vertical)
LazyVWaterFlowLayoutSample.ets

设置列数

LazyVWaterFlowLayout组件提供了columnsTemplate属性用于设置当前瀑布流布局的列数和每列尺寸占比。

columnsTemplate属性值是一个由多个空格和'数字+fr'间隔拼接的字符串，fr的个数即瀑布流布局的列数，fr前面的数值大小用于计算该列在瀑布流布局宽度上的占比，最终决定该列宽度。不设置时默认1列。设置为'0fr'时，该列的列宽为0，不显示子组件。设置为其他非法值时，子组件显示为固定1列。

收起
自动换行
深色代码主题
复制
  1. LazyVWaterFlowLayout() {
  2.   // 子组件
  3.   // ...
  4. }
  5. .columnsTemplate('1fr 1fr 1fr') // 设置为3列，每列等宽
  6. // ...
  7. LazyVWaterFlowLayout() {
  8.   // 子组件
  9.   // ...
  10. }
  11. .columnsTemplate('1fr 2fr') // 设置为2列，第一列占1份，第二列占2份
LazyVWaterFlowLayoutSample.ets

columnsTemplate还支持通过repeat关键字自动计算列数，格式为'repeat(auto-fit/auto-fill/auto-stretch, track-size)'，其中repeat、auto-fit、auto-fill、auto-stretch为关键字，track-size为列宽，支持px、vp、%等单位，默认单位为vp，也支持无单位的有效数字。track-size至少包含一个有效列宽。

与LazyVGridLayout组件不同的是，LazyVWaterFlowLayout组件的columnsTemplate属性还支持设置为ItemFillPolicy类型的枚举值，此时会根据组件宽度对应的栅格容器断点类型自动确定列数。例如，设置为ItemFillPolicy.BREAKPOINT_DEFAULT，组件宽度属于sm及更小的断点区间时LazyVWaterFlowLayout显示2列，属于md断点区间时显示3列，属于lg及更大的断点区间时显示5列，且每列均为1fr。

展开
模式 示例 说明
auto-fit 'repeat(auto-fit, 80vp)' 设置最小列宽，自动计算列数和实际列宽。仅支持一个有效列宽值。
auto-fill 'repeat(auto-fill, 80vp)' 设置固定列宽，自动计算列数。支持一个或多个有效列宽，如'repeat(auto-fill, 20 80px)'。
auto-stretch 'repeat(auto-stretch, 80vp)' 设置固定列宽，以columnsGap为最小列间距，自动计算列数和实际列间距。仅支持一个有效列宽值，不支持单位%。
断点适配 ItemFillPolicy.BREAKPOINT_DEFAULT 根据组件宽度对应断点类型确定列数。

设置行列间距

在两个子组件之间的垂直间距称为行间距，水平间距称为列间距。

LazyVWaterFlowLayout组件提供了rowsGap和columnsGap属性分别设置行间距和列间距。默认值均为LengthMetrics.vp(0)，设置为小于0的值时按默认值显示。

收起
自动换行
深色代码主题
复制
  1. LazyVWaterFlowLayout() {
  2.   // 子组件
  3.   // ...
  4. }
  5. // ...
  6. .rowsGap(LengthMetrics.vp(10))
  7. .columnsGap(LengthMetrics.vp(10))
LazyVWaterFlowLayoutSample.ets

创建懒加载线性布局 (LazyColumnLayout)

从API版本26.0.0开始，支持懒加载线性布局LazyColumnLayout，其子元素在垂直方向依次排列，常用于单列列表场景，如消息列表、设置项列表。

创建LazyColumnLayout

使用LazyColumnLayout前，需要通过import { LazyColumnLayout } from '@kit.ArkUI'导入该组件。

以下以在Scroll组件中为例，展示了LazyColumnLayout的创建方式。创建时，需要确保Scroll的布局方向为ScrollDirection.Vertical。

收起
自动换行
深色代码主题
复制
  1. Scroll() {
  2.   LazyColumnLayout() {
  3.     // 子组件
  4.     // ...
  5.   }
  6.   // ...
  7. }
  8. .scrollable(ScrollDirection.Vertical)
LazyColumnLayoutSample.ets

设置子组件间距

LazyColumnLayout组件提供了space属性用于设置子组件在垂直方向上的间距。默认值为LengthMetrics.vp(0)，设置为小于0的值时按默认值显示。

收起
自动换行
深色代码主题
复制
  1. LazyColumnLayout() {
  2.   // 子组件
  3.   // ...
  4. }
  5. .space(LengthMetrics.vp(10))
LazyColumnLayoutSample.ets

设置子组件对齐方式

LazyColumnLayout组件提供了alignItems属性用于设置子组件在水平方向上的对齐方式。未设置时，对齐方式默认值为HorizontalAlign.Center。

收起
自动换行
深色代码主题
复制
  1. LazyColumnLayout() {
  2.   // 子组件
  3.   // ...
  4. }
  5. // ...
  6. .alignItems(HorizontalAlign.Start)
LazyColumnLayoutSample.ets

嵌套懒加载布局容器

LazyColumnLayout支持嵌套使用LazyVGridLayout、LazyVWaterFlowLayout及其自身，以实现更复杂的混合布局。被嵌套的懒加载布局容器会作为LazyColumnLayout的子组件，在进入可视区域时按需加载。

收起
自动换行
深色代码主题
复制
  1. Scroll() {
  2.   LazyColumnLayout() {
  3.     // ...
  4. 

  5.     // 区域一：线性列表
  6.     LazyColumnLayout() {
  7.       // ...
  8.     }
  9.     // ...
  10. 

  11.     // 区域二：网格布局
  12.     LazyVGridLayout() {
  13.       // ...
  14.     }
  15.     // ...
  16. 

  17.     // 区域三：瀑布流布局
  18.     LazyVWaterFlowLayout() {
  19.       // ...
  20.     }
  21.     // ...
  22.   }
  23.   // ...
  24. }
  25. .scrollable(ScrollDirection.Vertical)
LazyColumnLayoutNestedLazyLayout.ets

监听可视区域变化

三种懒加载布局容器均支持通过onVisibleIndexesChange事件监听可视区域内子组件索引值的变化。在组件初始化时或可视区域内子组件的索引值发生变化时触发回调，返回可视区域内子组件的起始索引值和终止索引值。当懒加载布局容器内没有子组件或可视区域内无可见子组件时，start和end均返回-1。

以下示例分别展示了三种懒加载布局容器注册onVisibleIndexesChange事件回调的方式。

收起
自动换行
深色代码主题
复制
  1. // 区域一：线性列表
  2. LazyColumnLayout() {
  3.   // ...
  4. }
  5. .onVisibleIndexesChange((start: number, end: number) => {
  6.   console.info('LazyColumnLayout visible indexes: start: ' + start + ', end: ' + end);
  7. })
  8. // ...
  9. 

  10. // 区域二：网格布局
  11. LazyVGridLayout() {
  12.   // ...
  13. }
  14. .onVisibleIndexesChange((start: number, end: number) => {
  15.   console.info('LazyVGridLayout visible indexes: start: ' + start + ', end: ' + end);
  16. })
  17. // ...
  18. 

  19. // 区域三：瀑布流布局
  20. LazyVWaterFlowLayout() {
  21.   // ...
  22. }
  23. .onVisibleIndexesChange((start: number, end: number) => {
  24.   console.info('LazyVWaterFlowLayout visible indexes: start: ' + start + ', end: ' + end);
  25.   // ...
  26. })
LazyColumnLayoutNestedLazyLayout.ets

利用onVisibleIndexesChange回调，可以在即将触底时提前加载更多数据，实现无限滚动。以下示例展示了LazyVWaterFlowLayout配合LazyForEach实现无限滚动：通过在onVisibleIndexesChange回调中判断当前可视区域的终止索引值（end）是否接近数据源的总数量（totalCount），当剩余数据不足时，向数据源中追加新数据，从而在用户滚动到底部前提前完成数据加载，实现无缝滚动体验。

收起
自动换行
深色代码主题
复制
  1. List({ space: 10 }) {
  2.   // ...
  3.   // 瀑布流布局
  4.   LazyVWaterFlowLayout() {
  5.     LazyForEach(this.flowData, (item: number) => {
  6.       // ...
  7.     }, (item: number) => item.toString())
  8.   }
  9.   .columnsTemplate('1fr 1fr')
  10.   .rowsGap(LengthMetrics.vp(10))
  11.   .columnsGap(LengthMetrics.vp(10))
  12.   .onVisibleIndexesChange((start: number, end: number) => {
  13.     console.info('LazyVWaterFlowLayout visible indexes: start: ' + start + ', end: ' + end);
  14.     // 滚动监听：即将触底时提前加载更多数据
  15.     if (end + 20 >= this.flowData.totalCount()) {
  16.       let currentCount = this.flowData.totalCount();
  17.       for (let i = currentCount; i < currentCount + 100; i++) {
  18.         this.flowData.pushData(i);
  19.       }
  20.     }
  21.   })
  22. }
  23. .listDirection(Axis.Vertical)
ListNestedLazyLayout.ets

混合布局

  • 直接组合多种懒加载布局容器

通过将多种懒加载布局容器组合在同一个可滚动父组件中使用，可以灵活实现混合布局。

以下示例以List组件作为可滚动父组件为例，在其中同时使用LazyVGridLayout和LazyVWaterFlowLayout，并为每个容器分别配置独立的列数和行列间距，实现了混合布局。

收起
自动换行
深色代码主题
复制
  1. import { LengthMetrics, LazyVWaterFlowLayout, LazyVWaterFlowLayoutAttribute } from '@kit.ArkUI';
  2. 

  3. class BasicDataSource<T> implements IDataSource {
  4.   private listeners: DataChangeListener[] = [];
  5.   protected dataArray: T[] = [];
  6. 

  7.   public totalCount(): number {
  8.     return this.dataArray.length;
  9.   }
  10. 

  11.   public getData(index: number): T {
  12.     return this.dataArray[index];
  13.   }
  14. 

  15.   registerDataChangeListener(listener: DataChangeListener): void {
  16.     if (this.listeners.indexOf(listener) < 0) {
  17.       this.listeners.push(listener);
  18.     }
  19.   }
  20. 

  21.   unregisterDataChangeListener(listener: DataChangeListener): void {
  22.     const pos = this.listeners.indexOf(listener);
  23.     if (pos >= 0) {
  24.       this.listeners.splice(pos, 1);
  25.     }
  26.   }
  27. 

  28.   notifyDataReload(): void {
  29.     this.listeners.forEach(listener => {
  30.       listener.onDataReloaded();
  31.     })
  32.   }
  33. 

  34.   notifyDataAdd(index: number): void {
  35.     this.listeners.forEach(listener => {
  36.       listener.onDataAdd(index);
  37.     })
  38.   }
  39. 

  40.   notifyDataDelete(index: number): void {
  41.     this.listeners.forEach(listener => {
  42.       listener.onDataDelete(index);
  43.     })
  44.   }
  45. }
  46. 

  47. class MyDataSource<T> extends BasicDataSource<T> {
  48.   public pushData(data: T): void {
  49.     this.dataArray.push(data);
  50.     this.notifyDataAdd(this.dataArray.length - 1);
  51.   }
  52. }
  53. 

  54. @Entry
  55. @Component
  56. export struct ListNestedLazyLayout {
  57.   // 网格区域数据源
  58.   private gridData: MyDataSource<number> = new MyDataSource<number>();
  59.   // 瀑布流区域数据源
  60.   private flowData: MyDataSource<number> = new MyDataSource<number>();
  61. 

  62.   private itemHeight(index: number): number {
  63.     return 80 + (index * 37 % 121)
  64.   }
  65. 

  66.   aboutToAppear(): void {
  67.     for (let i = 0; i < 6; i++) {
  68.       this.gridData.pushData(i);
  69.     }
  70.     for (let i = 0; i < 100; i++) {
  71.       this.flowData.pushData(i);
  72.     }
  73.   }
  74. 

  75.   build() {
  76.     NavDestination() {
  77.       Column() {
  78.         List({ space: 10 }) {
  79.           ListItem() {
  80.             // 请将$r('app.string.list_nested_lazyLayout_grid')替换为实际资源文件
  81.             // 在本示例中该资源文件的value值为"网格布局"
  82.             Text($r('app.string.list_nested_lazyLayout_grid'))
  83.               .fontSize(14)
  84.               .fontColor(Color.Gray)
  85.           }
  86. 

  87.           // 等宽的网格布局
  88.           LazyVGridLayout() {
  89.             LazyForEach(this.gridData, (item: number) => {
  90.               Text('item' + item.toString())
  91.                 .height(96)
  92.                 .width('100%')
  93.                 .borderRadius(5)
  94.                 .backgroundColor('#ffe0e2e4')
  95.                 .textAlign(TextAlign.Center)
  96.             }, (item: number) => item.toString())
  97.           }
  98.           .columnsTemplate('1fr 1fr 1fr')
  99.           .rowsGap(LengthMetrics.vp(10))
  100.           .columnsGap(LengthMetrics.vp(10))
  101.           .onVisibleIndexesChange((start: number, end: number) => {
  102.             console.info('LazyVGridLayout visible indexes: start: ' + start + ', end: ' + end);
  103.           })
  104. 

  105.           // 不等宽的网格布局
  106.           LazyVGridLayout() {
  107.             LazyForEach(this.gridData, (item: number) => {
  108.               Text('item' + (this.gridData.totalCount() + item).toString())
  109.                 .height(96)
  110.                 .width('100%')
  111.                 .borderRadius(5)
  112.                 .backgroundColor('#ffe0e2e4')
  113.                 .textAlign(TextAlign.Center)
  114.             }, (item: number) => item.toString())
  115.           }
  116.           .columnsTemplate('1fr 2fr')
  117.           .rowsGap(LengthMetrics.vp(10))
  118.           .columnsGap(LengthMetrics.vp(10))
  119.           .margin({ bottom: 16 })
  120.           .onVisibleIndexesChange((start: number, end: number) => {
  121.             console.info('LazyVGridLayout visible indexes: start: ' + (this.gridData.totalCount() + start) + ', end: ' +
  122.               (this.gridData.totalCount() + end));
  123.           })
  124. 

  125.           ListItem() {
  126.             // 请将$r('app.string.list_nested_lazyLayout_waterFlow')替换为实际资源文件
  127.             // 在本示例中该资源文件的value值为"瀑布流布局"
  128.             Text($r('app.string.list_nested_lazyLayout_waterFlow'))
  129.               .fontSize(14)
  130.               .fontColor(Color.Gray)
  131.           }
  132. 

  133.           // 瀑布流布局
  134.           LazyVWaterFlowLayout() {
  135.             LazyForEach(this.flowData, (item: number) => {
  136.               Text('item' + item.toString())
  137.                 .height(this.itemHeight(item))
  138.                 .width('100%')
  139.                 .borderRadius(5)
  140.                 .backgroundColor('#ffe0e2e4')
  141.                 .textAlign(TextAlign.Center)
  142.             }, (item: number) => item.toString())
  143.           }
  144.           .columnsTemplate('1fr 1fr')
  145.           .rowsGap(LengthMetrics.vp(10))
  146.           .columnsGap(LengthMetrics.vp(10))
  147.           .onVisibleIndexesChange((start: number, end: number) => {
  148.             console.info('LazyVWaterFlowLayout visible indexes: start: ' + start + ', end: ' + end);
  149.             // 滚动监听：即将触底时提前加载更多数据
  150.             if (end + 20 >= this.flowData.totalCount()) {
  151.               let currentCount = this.flowData.totalCount();
  152.               for (let i = currentCount; i < currentCount + 100; i++) {
  153.                 this.flowData.pushData(i);
  154.               }
  155.             }
  156.           })
  157.         }
  158.         .listDirection(Axis.Vertical)
  159.         .backgroundColor(Color.White)
  160.         .borderRadius(12)
  161.         .padding(12)
  162.         .width('100%')
  163.         .layoutWeight(1)
  164.       }
  165.       .width('100%')
  166.       .height('100%')
  167.       .padding({ left: 12, right: 12 })
  168.     }
  169.     .backgroundColor('#f1f2f3')
  170.     // 请将$r('app.string.list_nested_lazyLayout_title')替换为实际资源文件
  171.     // 在本示例中该资源文件的value值为"List嵌套懒加载布局容器"
  172.     .title($r('app.string.list_nested_lazyLayout_title'))
  173.   }
  174. }
ListNestedLazyLayout.ets

图3 List嵌套懒加载布局容器效果示例图

  • 通过LazyColumnLayout嵌套组合多种懒加载布局容器

利用LazyColumnLayout的嵌套能力，可以进一步实现更复杂的混合布局。例如，在一个页面中同时包含线性列表、网格和瀑布流三种排列方式的内容区域。

以下示例以Scroll组件作为可滚动父组件为例，使用LazyColumnLayout作为主布局容器，嵌套LazyColumnLayout（线性列表区域）、LazyVGridLayout（网格区域）和LazyVWaterFlowLayout（瀑布流区域），实现了多种布局方式的混合展示。

收起
自动换行
深色代码主题
复制
  1. import {
  2.   LengthMetrics,
  3.   LazyVWaterFlowLayout,
  4.   LazyVWaterFlowLayoutAttribute,
  5.   LazyColumnLayout,
  6.   LazyColumnLayoutAttribute
  7. } from '@kit.ArkUI';
  8. 

  9. class BasicDataSource<T> implements IDataSource {
  10.   private listeners: DataChangeListener[] = [];
  11.   protected dataArray: T[] = [];
  12. 

  13.   public totalCount(): number {
  14.     return this.dataArray.length;
  15.   }
  16. 

  17.   public getData(index: number): T {
  18.     return this.dataArray[index];
  19.   }
  20. 

  21.   registerDataChangeListener(listener: DataChangeListener): void {
  22.     if (this.listeners.indexOf(listener) < 0) {
  23.       this.listeners.push(listener);
  24.     }
  25.   }
  26. 

  27.   unregisterDataChangeListener(listener: DataChangeListener): void {
  28.     const pos = this.listeners.indexOf(listener);
  29.     if (pos >= 0) {
  30.       this.listeners.splice(pos, 1);
  31.     }
  32.   }
  33. 

  34.   notifyDataReload(): void {
  35.     this.listeners.forEach(listener => {
  36.       listener.onDataReloaded();
  37.     })
  38.   }
  39. 

  40.   notifyDataAdd(index: number): void {
  41.     this.listeners.forEach(listener => {
  42.       listener.onDataAdd(index);
  43.     })
  44.   }
  45. }
  46. 

  47. class MyDataSource<T> extends BasicDataSource<T> {
  48.   public pushData(data: T): void {
  49.     this.dataArray.push(data);
  50.     this.notifyDataAdd(this.dataArray.length - 1);
  51.   }
  52. }
  53. 

  54. @Entry
  55. @Component
  56. export struct LazyColumnLayoutNestedLazyLayout {
  57.   // 线性列表区域数据源
  58.   private listData: MyDataSource<number> = new MyDataSource<number>();
  59.   // 网格区域数据源
  60.   private gridData: MyDataSource<number> = new MyDataSource<number>();
  61.   // 瀑布流区域数据源
  62.   private flowData: MyDataSource<number> = new MyDataSource<number>();
  63. 

  64.   private itemHeight(index: number): number {
  65.     return 80 + (index * 37 % 121)
  66.   }
  67. 

  68.   private itemColor(index: number): string {
  69.     const colors: string[] = ['#FFE0B2', '#C8E6C9', '#BBDEFB', '#F8BBD0', '#D1C4E9', '#FFF9C4']
  70.     return colors[index % colors.length]
  71.   }
  72. 

  73.   aboutToAppear(): void {
  74.     for (let i = 0; i < 4; i++) {
  75.       this.listData.pushData(i);
  76.     }
  77.     for (let i = 0; i < 9; i++) {
  78.       this.gridData.pushData(i);
  79.     }
  80.     for (let i = 0; i < 100; i++) {
  81.       this.flowData.pushData(i);
  82.     }
  83.   }
  84. 

  85.   build() {
  86.     NavDestination() {
  87.       Column() {
  88.         Scroll() {
  89.           LazyColumnLayout() {
  90.             // 请将$r('app.string.lazyColumnLayout_nested_lazyLayout_following')替换为实际资源文件
  91.             // 在本示例中该资源文件的value值为"推荐关注"
  92.             Text($r('app.string.lazyColumnLayout_nested_lazyLayout_following'))
  93.               .fontSize(14)
  94.               .fontColor(Color.Gray)
  95.               .margin({ bottom: 8 })
  96. 

  97.             // 区域一：线性列表
  98.             LazyColumnLayout() {
  99.               LazyForEach(this.listData, (item: number) => {
  100.                 Row() {
  101.                   Text() {
  102.                     // 请将$r('app.string.lazyColumnLayout_nested_lazyLayout_item')替换为实际资源文件
  103.                     // 在本示例中该资源文件的value值为"列表项"
  104.                     Span($r('app.string.lazyColumnLayout_nested_lazyLayout_item'))
  105.                     Span(item.toString())
  106.                   }
  107. 

  108.                   Blank()
  109.                   SymbolGlyph($r('sys.symbol.chevron_forward'))
  110.                     .fontColor([Color.Gray])
  111.                 }
  112.                 .width('100%')
  113.                 .height(56)
  114.                 .padding({ left: 16, right: 16 })
  115.                 .borderRadius(8)
  116.                 .backgroundColor(Color.White)
  117.               }, (item: number) => item.toString())
  118.             }
  119.             .onVisibleIndexesChange((start: number, end: number) => {
  120.               console.info('LazyColumnLayout visible indexes: start: ' + start + ', end: ' + end);
  121.             })
  122.             .space(LengthMetrics.vp(10))
  123. 

  124.             // 请将$r('app.string.lazyColumnLayout_nested_lazyLayout_popular')替换为实际资源文件
  125.             // 在本示例中该资源文件的value值为"热门分类"
  126.             Text($r('app.string.lazyColumnLayout_nested_lazyLayout_popular'))
  127.               .fontSize(14)
  128.               .fontColor(Color.Gray)
  129.               .margin({ top: 12, bottom: 8 })
  130. 

  131.             // 区域二：网格布局
  132.             LazyVGridLayout() {
  133.               LazyForEach(this.gridData, (item: number) => {
  134.                 Column() {
  135.                   SymbolGlyph($r('sys.symbol.folder_fill'))
  136.                     .fontSize(32)
  137.                     .fontColor([Color.Orange])
  138.                   Text() {
  139.                     // 请将$r('app.string.lazyColumnLayout_nested_lazyLayout_category')替换为实际资源文件
  140.                     // 在本示例中该资源文件的value值为"分类"
  141.                     Span($r('app.string.lazyColumnLayout_nested_lazyLayout_category'))
  142.                     Span(item.toString())
  143.                   }
  144.                   .fontSize(14)
  145.                   .margin({ top: 6 })
  146.                 }
  147.                 .width('100%')
  148.                 .height(80)
  149.                 .borderRadius(8)
  150.                 .backgroundColor(Color.White)
  151.                 .justifyContent(FlexAlign.Center)
  152.               }, (item: number) => item.toString())
  153.             }
  154.             .onVisibleIndexesChange((start: number, end: number) => {
  155.               console.info('LazyVGridLayout visible indexes: start: ' + start + ', end: ' + end);
  156.             })
  157.             .columnsTemplate('1fr 1fr 1fr')
  158.             .rowsGap(LengthMetrics.vp(10))
  159.             .columnsGap(LengthMetrics.vp(10))
  160. 

  161.             // 请将$r('app.string.lazyColumnLayout_nested_lazyLayout_recommend')替换为实际资源文件
  162.             // 在本示例中该资源文件的value值为"为你推荐"
  163.             Text($r('app.string.lazyColumnLayout_nested_lazyLayout_recommend'))
  164.               .fontSize(14)
  165.               .fontColor(Color.Gray)
  166.               .margin({ top: 12, bottom: 8 })
  167. 

  168.             // 区域三：瀑布流布局
  169.             LazyVWaterFlowLayout() {
  170.               LazyForEach(this.flowData, (item: number) => {
  171.                 Text() {
  172.                   // 请将$r('app.string.lazyColumnLayout_nested_lazyLayout_recommendation')替换为实际资源文件
  173.                   // 在本示例中该资源文件的value值为"推荐内容"
  174.                   Span($r('app.string.lazyColumnLayout_nested_lazyLayout_recommendation'))
  175.                   Span(item.toString())
  176.                 }
  177.                 .height(this.itemHeight(item))
  178.                 .width('100%')
  179.                 .borderRadius(8)
  180.                 .backgroundColor(this.itemColor(item))
  181.                 .textAlign(TextAlign.Center)
  182.               }, (item: number) => item.toString())
  183.             }
  184.             .onVisibleIndexesChange((start: number, end: number) => {
  185.               console.info('LazyVWaterFlowLayout visible indexes: start: ' + start + ', end: ' + end);
  186.               // 即将触底时加载更多数据
  187.               if (end + 20 >= this.flowData.totalCount()) {
  188.                 let currentCount = this.flowData.totalCount();
  189.                 for (let i = currentCount; i < currentCount + 100; i++) {
  190.                   this.flowData.pushData(i);
  191.                 }
  192.               }
  193.             })
  194.             .columnsTemplate('1fr 1fr')
  195.             .rowsGap(LengthMetrics.vp(10))
  196.             .columnsGap(LengthMetrics.vp(10))
  197.           }
  198.           .alignItems(HorizontalAlign.Start)
  199.         }
  200.         .scrollable(ScrollDirection.Vertical)
  201.         .padding(12)
  202.         .width('100%')
  203.         .layoutWeight(1)
  204.       }
  205.       .width('100%')
  206.       .height('100%')
  207.       .padding({ left: 12, right: 12 })
  208.       .backgroundColor('#f1f2f3')
  209.     }
  210.     .backgroundColor('#f1f2f3')
  211.     // 请将$r('app.string.lazyColumnLayout_nested_lazyLayout_title')替换为实际资源文件
  212.     // 在本示例中该资源文件的value值为"LazyColumnLayout嵌套懒加载布局容器"
  213.     .title($r('app.string.lazyColumnLayout_nested_lazyLayout_title'))
  214.   }
  215. }
LazyColumnLayoutNestedLazyLayout.ets

在上面的示例中，整个页面仅使用一个Scroll组件提供滚动能力，由LazyColumnLayout作为主布局容器统一管理三个区域的排列。三个区域分别使用独立的LazyForEach数据源（listData、gridData、flowData），数据互不耦合，独立管理。滚动时，所有区域共享同一个Scroll的手势，无需额外的手势处理逻辑。每个区域中的子组件仅在进入可视区域时才会被创建和渲染，从而保障了页面的流畅体验。

图4 LazyColumnLayout嵌套懒加载布局容器效果示例图

分组展示与粘性标题

在混合布局页面中，不同内容区域通常需要分组展示，并配以独立的标题或操作栏，方便用户快速识别和定位内容。从API版本26.0.0开始，三种懒加载布局容器均提供了header和footer属性，分别用于展示分组标题，提示数据加载完毕（如“已经到底了”）或提供快捷操作（如“查看更多”）。同时，三种容器还提供了sticky属性，可以将header或footer在滚动过程中分别吸附在可视区域的顶部或底部，实现粘性标题效果，帮助用户识别当前所在的内容区域。

添加分组标题

可以通过header属性为懒加载布局容器添加头部组件，用于展示分组标题。以下示例使用@Builder构建了一个带参数的分组标题组件，并通过header属性设置到LazyVGridLayout中。

收起
自动换行
深色代码主题
复制
  1. // 内层分组header：显示月份标题，滚动时吸顶
  2. @Builder
  3. MonthHeaderBuilder(title: string, count: number) {
  4.   Row() {
  5.     Text(title)
  6.       .fontSize(16)
  7.       .fontWeight(FontWeight.Bold)
  8.     Blank()
  9.     // 请将$r('app.string.lazyLayout_photo_count')替换为实际资源文件，在本示例中该资源文件的value值为"%d张"，表示照片的张数
  10.     Text($r('app.string.lazyLayout_photo_count', count))
  11.       .fontSize(14)
  12.       .fontColor(Color.Gray)
  13.   }
  14.   .width('100%')
  15.   .height(48)
  16.   .padding({ left: 16, right: 16 })
  17.   .backgroundColor(Color.White)
  18.   .alignItems(VerticalAlign.Center)
  19. }
  20. 

  21. // ...
  22. 

  23. build() {
  24.   // ...
  25.           // 通过LazyForEach动态创建每个月份分组
  26.           LazyForEach(this.groupData, (group: PhotoGroup, index: number) => {
  27.             // 内层：每个分组为一个网格布局
  28.             LazyVGridLayout() {
  29.               LazyForEach(group.photos, (item: number) => {
  30.                 // ...
  31.               }, (item: number) => `${index}_${item}`)
  32.             }
  33.             // ...
  34.             .header(this.MonthHeaderBuilder(group.title, group.photos.totalCount())) // 内层分组header：显示月份标题
  35.             // ...
  36.           }, (group: PhotoGroup) => group.title)
  37.           // ...
  38. }
LazyLayoutGroup.ets

添加末尾提示

可以通过footer属性为懒加载布局容器添加尾部组件，用于提示数据加载完毕。以下示例使用@Builder构建了一个尾部提示组件，并通过footer属性设置到LazyColumnLayout中。

收起
自动换行
深色代码主题
复制
  1. // 外层footer：显示"已经到底了"
  2. @Builder
  3. GroupFooterBuilder() {
  4.   // 请将$r('app.string.lazyLayout_no_more_content')替换为实际资源文件，在本示例中该资源文件的value值为"—— 已经到底了 ——"
  5.   Text($r('app.string.lazyLayout_no_more_content'))
  6.     .fontSize(14)
  7.     .fontColor(Color.Gray)
  8.     .width('100%')
  9.     .height(48)
  10.     .textAlign(TextAlign.Center)
  11. }
  12. 

  13. build() {
  14.   // ...
  15.       Scroll() {
  16.         LazyColumnLayout() {
  17.           // ...
  18.         }
  19.         // ...
  20.         .footer(this.GroupFooterBuilder()) // 外层footer：显示"已经到底了"
  21.       }
  22.       .scrollable(ScrollDirection.Vertical)
  23.       .width('100%')
  24.       .layoutWeight(1)
  25.       // ...
  26. }
LazyLayoutGroup.ets

设置粘性标题

通过sticky属性，可以将header或footer在滚动过程中吸附在可视区域的顶部或底部，帮助用户在滚动时识别当前所在的内容区域。sticky属性支持以下模式。

  • StickyStyle.Header：仅header吸附在可视区域顶部，常用于分组标题吸顶。
  • StickyStyle.Footer：仅footer吸附在可视区域底部，常用于汇总信息或操作入口吸底。
  • StickyStyle.BOTH：同时支持header吸附在顶部和footer吸附在底部。

图5 三种StickyStyle效果示例图

展开
StickyStyle.Header StickyStyle.Footer StickyStyle.BOTH

由于浮点数计算精度，设置sticky后，在滚动过程中小概率产生缝隙，可以通过pixelRound指定当前组件向下像素取整解决该问题。

以下示例模拟图库页面，展示了分组展示与粘性标题的效果。外层LazyColumnLayout通过footer显示”已经到底了”，提示数据已全部加载；内层通过LazyForEach动态创建多个LazyVGridLayout展示各月份照片网格，每个LazyVGridLayout设置了header和sticky(StickyStyle.Header)，使月份标题在滚动时吸顶。

收起
自动换行
深色代码主题
复制
  1. import { LengthMetrics, LazyColumnLayout, LazyColumnLayoutAttribute } from '@kit.ArkUI';
  2. 

  3. class BasicDataSource<T> implements IDataSource {
  4.   private listeners: DataChangeListener[] = [];
  5.   protected dataArray: T[] = [];
  6. 

  7.   public totalCount(): number {
  8.     return this.dataArray.length;
  9.   }
  10. 

  11.   public getData(index: number): T {
  12.     return this.dataArray[index];
  13.   }
  14. 

  15.   registerDataChangeListener(listener: DataChangeListener): void {
  16.     if (this.listeners.indexOf(listener) < 0) {
  17.       this.listeners.push(listener);
  18.     }
  19.   }
  20. 

  21.   unregisterDataChangeListener(listener: DataChangeListener): void {
  22.     const pos = this.listeners.indexOf(listener);
  23.     if (pos >= 0) {
  24.       this.listeners.splice(pos, 1);
  25.     }
  26.   }
  27. 

  28.   notifyDataReload(): void {
  29.     this.listeners.forEach(listener => {
  30.       listener.onDataReloaded();
  31.     })
  32.   }
  33. 

  34.   notifyDataAdd(index: number): void {
  35.     this.listeners.forEach(listener => {
  36.       listener.onDataAdd(index);
  37.     })
  38.   }
  39. 

  40.   notifyDataDelete(index: number): void {
  41.     this.listeners.forEach(listener => {
  42.       listener.onDataDelete(index);
  43.     })
  44.   }
  45. }
  46. 

  47. class MyDataSource<T> extends BasicDataSource<T> {
  48.   public pushData(data: T): void {
  49.     this.dataArray.push(data);
  50.     this.notifyDataAdd(this.dataArray.length - 1);
  51.   }
  52. }
  53. 

  54. class PhotoGroup {
  55.   public title: string
  56.   public photos: MyDataSource<number> = new MyDataSource<number>()
  57. 

  58.   constructor(title: string) {
  59.     this.title = title
  60.   }
  61. }
  62. 

  63. @Entry
  64. @Component
  65. export struct LazyLayoutGroup {
  66.   private groupData: MyDataSource<PhotoGroup> = new MyDataSource<PhotoGroup>();
  67. 

  68.   aboutToAppear(): void {
  69.     // 初始化数据
  70.     const months: string[] = ['2026年1月', '2026年2月', '2026年3月'];
  71.     for (let m = 0; m < months.length; m++) {
  72.       let group = new PhotoGroup(months[m]);
  73.       let photoCount = 6 + m * 3;
  74.       for (let i = 0; i < photoCount; i++) {
  75.         group.photos.pushData(i);
  76.       }
  77.       this.groupData.pushData(group);
  78.     }
  79.   }
  80. 

  81.   // 底部工具栏
  82.   @Builder
  83.   BottomToolBarBuilder() {
  84.     Row() {
  85.       Column() {
  86.         SymbolGlyph($r('sys.symbol.picture_fill'))
  87.           .fontSize(24)
  88.           .fontColor(['#FF007DFF'])
  89.         // 请将$r('app.string.lazyLayout_photo')替换为实际资源文件，在本示例中该资源文件的value值为"照片"
  90.         Text($r('app.string.lazyLayout_photo'))
  91.           .fontSize(12)
  92.           .fontColor('#FF007DFF')
  93.           .margin({ top: 2 })
  94.       }
  95. 

  96.       Column() {
  97.         SymbolGlyph($r('sys.symbol.square_fill_grid_2x2'))
  98.           .fontSize(24)
  99.           .fontColor([Color.Gray])
  100.         // 请将$r('app.string.lazyLayout_album')替换为实际资源文件，在本示例中该资源文件的value值为"相册"
  101.         Text($r('app.string.lazyLayout_album'))
  102.           .fontSize(12)
  103.           .fontColor(Color.Gray)
  104.           .margin({ top: 2 })
  105.       }
  106.       .margin({ left: 36 })
  107. 

  108.       Blank()
  109.       // 请将$r('app.string.lazyLayout_select')替换为实际资源文件，在本示例中该资源文件的value值为"选择"
  110.       Text($r('app.string.lazyLayout_select'))
  111.         .fontSize(14)
  112.         .fontColor('#FF007DFF')
  113.     }
  114.     .width('100%')
  115.     .height(64)
  116.     .padding({ left: 16, right: 16 })
  117.     .backgroundColor(Color.White)
  118.     .alignItems(VerticalAlign.Center)
  119.   }
  120. 

  121.   // 内层分组header：显示月份标题，滚动时吸顶
  122.   @Builder
  123.   MonthHeaderBuilder(title: string, count: number) {
  124.     Row() {
  125.       Text(title)
  126.         .fontSize(16)
  127.         .fontWeight(FontWeight.Bold)
  128.       Blank()
  129.       // 请将$r('app.string.lazyLayout_photo_count')替换为实际资源文件，在本示例中该资源文件的value值为"%d张"，表示照片的张数
  130.       Text($r('app.string.lazyLayout_photo_count', count))
  131.         .fontSize(14)
  132.         .fontColor(Color.Gray)
  133.     }
  134.     .width('100%')
  135.     .height(48)
  136.     .padding({ left: 16, right: 16 })
  137.     .backgroundColor(Color.White)
  138.     .alignItems(VerticalAlign.Center)
  139.   }
  140. 

  141.   // 外层footer：显示"已经到底了"
  142.   @Builder
  143.   GroupFooterBuilder() {
  144.     // 请将$r('app.string.lazyLayout_no_more_content')替换为实际资源文件，在本示例中该资源文件的value值为"—— 已经到底了 ——"
  145.     Text($r('app.string.lazyLayout_no_more_content'))
  146.       .fontSize(14)
  147.       .fontColor(Color.Gray)
  148.       .width('100%')
  149.       .height(48)
  150.       .textAlign(TextAlign.Center)
  151.   }
  152. 

  153.   build() {
  154.     NavDestination() {
  155.       Column() {
  156.         Scroll() {
  157.           LazyColumnLayout() {
  158.             // 通过LazyForEach动态创建每个月份分组
  159.             LazyForEach(this.groupData, (group: PhotoGroup, index: number) => {
  160.               // 内层：每个分组为一个网格布局
  161.               LazyVGridLayout() {
  162.                 LazyForEach(group.photos, (item: number) => {
  163.                   Column() {
  164.                     SymbolGlyph($r('sys.symbol.picture'))
  165.                       .fontSize(24)
  166.                       .fontColor([Color.Gray])
  167.                   }
  168.                   .width('100%')
  169.                   .aspectRatio(1)
  170.                   .borderRadius(4)
  171.                   .backgroundColor('#e8e8e8')
  172.                   .justifyContent(FlexAlign.Center)
  173.                 }, (item: number) => `${index}_${item}`)
  174.               }
  175.               .columnsTemplate('1fr 1fr 1fr')
  176.               .rowsGap(LengthMetrics.vp(2))
  177.               .columnsGap(LengthMetrics.vp(2))
  178.               .header(this.MonthHeaderBuilder(group.title, group.photos.totalCount())) // 内层分组header：显示月份标题
  179.               .sticky(StickyStyle.Header) // header吸顶
  180.             }, (group: PhotoGroup) => group.title)
  181.           }
  182.           .space(LengthMetrics.vp(12))
  183.           .footer(this.GroupFooterBuilder()) // 外层footer：显示"已经到底了"
  184.         }
  185.         .scrollable(ScrollDirection.Vertical)
  186.         .width('100%')
  187.         .layoutWeight(1)
  188.         .scrollBar(BarState.Off)
  189.         .backgroundColor(Color.White)
  190. 

  191.         // 底部工具栏
  192.         this.BottomToolBarBuilder()
  193.       }
  194.       .width('100%')
  195.       .height('100%')
  196.     }
  197.     .backgroundColor('#f1f2f3')
  198.     // 请将$r('app.string.lazyLayout_group_title')替换为实际资源文件
  199.     // 在本示例中该资源文件的value值为"分组展示与粘性标题"
  200.     .title($r('app.string.lazyLayout_group_title'))
  201.   }
  202. }
LazyLayoutGroup.ets

图6 分组展示与粘性标题效果示例图

常见瀑布流操作
创建懒加载自定义布局 (LazyDynamicLayout)
相关推荐
文档创建懒加载自定义布局 (LazyDynamicLayout)
文档列表与网格概述
文档LazyVWaterFlowLayout
文档LazyVGridLayout
文档LazyColumnLayout
文档LazyDynamicLayout
文档创建瀑布流 (WaterFlow)
文档List
文档WaterFlow
文档使用瀑布流
简体中文
华为开发者联盟 版权所有 ©2026
问题反馈
使用条款
华为开发者联盟用户协议
关于华为开发者联盟与隐私的声明
Cookies
开源软件声明
在 指南 中进行搜索
请输入您想要搜索的关键词