使用LazyForEach嵌套LazyForEach（或ForEach）显示异常。

class MyDataSource implements IDataSource { 
 private listener: DataChangeListener 
 // 构建嵌套场景下的二维数据列表 
 private dataArray: Array<Array<number>>; 
  
 public initialize() { 
   // 初始化二维数据列表 
   this.dataArray = new Array(); 
   for (let a: number = 0; a < 5; ++a) { 
     this.dataArray[a] = new Array(); 
     for (let b: number = 0; b < 5; ++b) { 
       this.dataArray[a][b] = a * 5 + b; 
     } 
   } 
 } 
  
 public totalCount(): number { 
   return 5 * 5 
 } 
  
 public getData(index: number): any { 
   // 基于二维数组的行列计算index对应的位置及数据。 
   return this.dataArray[Math.floor(index / 5)][index % 5] 
 } 
  
 registerDataChangeListener(listener: DataChangeListener): void { 
   this.listener = listener 
 } 
  
 unregisterDataChangeListener(listener: DataChangeListener): void { 
   this.listener = undefined 
 } 
} 
  
@Entry 
@Component 
struct MyComponent { 
 private data: MyDataSource = new MyDataSource() 
  
 aboutToAppear() { 
   this.data.initialize(); 
 } 
  
 build() { 
   List({ space: 3 }) { 
     LazyForEach(this.data, (item: number) => { 
       ListItem() { 
         Row() { 
           Text(item.toString()).fontSize(20).margin({ left: 10 }) 
         }.margin({ left: 10, right: 10 }) 
       } 
     }) 
   }.width('100%').height('100%') 
 } 
}

// MyDataSource处理二维数据的行数据信息。 
class MyDataSource extends MyBaseDataSource { 
 private dataArray: Array<number> = [1, 2, 3, 4, 5]; 
  
 public totalCount(): number { 
   return 5; 
 } 
  
 public getData(index: number): any { 
   return this.dataArray[index]; 
 } 
} 
  
// ChildDataSource通过二维数据的行信息处理二维数据的列数据。 
class ChildDataSource extends MyBaseDataSource { 
 private rowNum: number; 
 private dataArray: Array<number> = [1, 2, 3, 4, 5]; 
  
 constructor(rowNum: number) { 
   this.rowNum = rowNum; 
 } 
  
 public totalCount(): number { 
   return 5; 
 } 
  
 public getData(index: number): any { 
   return this.dataArray[index] + 5 * this.rowNum; 
 } 
} 
  
@Component 
struct ChildComponent { 
 private data: ChildDataSource; 
 private rowNum: number; 
  
 aboutToAppear() { 
   this.data = new ChildDataSource(this.rowNum) 
 } 
  
 build() { 
   Column() { 
     // 基于二维数据的行信息构建列数据对应的子组件。 
     LazyForEach(this.data, (item) => { 
       Row() { 
         Text(item.toString()).fontSize(20).margin({ left: 10 }) 
       }.margin({ left: 10, right: 10 }) 
     }) 
   } 
 } 
} 
  
@Entry 
@Component 
struct MyComponent { 
 private data: MyDataSource = new MyDataSource() 
  
 build() { 
   List({ space: 3 }) { 
     LazyForEach(this.data, (item: number) => { 
       // 构建二维数据行信息对应的子组件。 
       ListItem() { 
         ChildComponent({ rowNum: item - 1 }) 
       } 
     }) 
   }.width('100%').height('100%') 
 } 
}

@Entry 
@Component 
struct MyComponent { 
 @State data: Array<Array<number>> = [] 
  
 aboutToAppear() { 
   // 初始化二维数据列表 
   this.data = new Array(); 
   for (let a: number = 0; a < 5; ++a) { 
     this.data[a] = new Array(); 
     for (let b: number = 0; b < 5; ++b) { 
       this.data[a][b] = a * 5 + b; 
     } 
   } 
 } 
  
 build() { 
   List({ space: 3 }) { 
     ForEach(this.data, (item: Array<number>) => { 
       // 使用ForEach嵌套结构 
       ForEach(item, (item: number) => { 
         ListItem() { 
           Row() { 
             Text(item.toString()).fontSize(20).margin({ left: 10 }) 
           }.margin({ left: 10, right: 10 }) 
         } 
       }) 
     }) 
   }.width('100%').height('100%') 
 } 
}