HarmonyOS 鸿蒙Next中List懒加载更新问题

HarmonyOS 鸿蒙Next中List懒加载更新问题 List 使用 LazyForEach 加载数据，数据更新后，只有滑动列表，并且 ListItem 滑出屏幕后 ，UI 才更新。请教下这是为啥？我该怎么修改？ demo 如下:

@Entry
@Component
struct Index {
  @State entryHapRouter: NavPathStack = new NavPathStack()
  listData: string[] = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13"]
  newData: string[] = ['100', '101', "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113"]
  data: LazyDataSource<string> = new LazyDataSource()
  @State isRefreshing: boolean = false

  @Builder
  header() {
    Row() {
      Text("Header").fontColor(Color.White)
    }.backgroundColor(Color.Gray).width('100%').height(40)
  }

  build() {
    Navigation(this.entryHapRouter) {
      Refresh({ refreshing: this.isRefreshing }) {
        Column() {
          List() {
            ListItemGroup({ header: this.header() }) {
              LazyForEach(this.data, (item: string) => {
                ListItem() {
                  Text(item)
                }.width('100%').height(100).backgroundColor(Color.Orange)
              })
            }.divider({ strokeWidth: 1, color: Color.White })
          }
          .sticky(StickyStyle.Header)
          .listDirection(Axis.Vertical) // 排列方向
          .scrollBar(BarState.Off)
          .friction(0.6)
          .edgeEffect(EdgeEffect.None) // 边缘效果设置为Spring
          .nestedScroll({ scrollForward: NestedScrollMode.PARENT_FIRST, scrollBackward: NestedScrollMode.PARENT_FIRST })
        }
      }.onRefreshing(() => {
        setTimeout(() => {
          this.data.pushArrayData(this.newData)
          this.isRefreshing = false
        }, 2000)
      })
    }.hideTitleBar(true).hideBackButton(true).hideToolBar(true).hideToolBar(true)
  }

  aboutToAppear() {
    this.data.pushArrayData(this.listData)
  };
}

// ``` LazyDataSource ```
// import { ObservedArray } from './ObservedArray'

const TAG = '[BasicDataSource]';

export class BasicDataSource<T> implements IDataSource {
  private listeners: DataChangeListener[] = [];

  public totalCount(): number {
    return 0;
  }

  public getData(index: number): T | undefined {
    return undefined;
  }

  registerDataChangeListener(listener: DataChangeListener): void {
    if (this.listeners.indexOf(listener) < 0) {
      this.listeners.push(listener);
    }
  }

  unregisterDataChangeListener(listener: DataChangeListener): void {
    const pos = this.listeners.indexOf(listener);
    if (pos >= 0) {
      this.listeners.splice(pos, 1);
    }
  }

  notifyDataReload(): void {
    this.listeners.forEach(listener => {
      listener.onDataReloaded();
    })
  }

  notifyDataAdd(index: number): void {
    this.listeners.forEach(listener => {
      listener.onDataAdd(index);
    })
  }

  notifyDataChange(index: number): void {
    this.listeners.forEach(listener => {
      listener.onDataChange(index);
    })
  }

  notifyDataDelete(index: number): void {
    this.listeners.forEach(listener => {
      listener.onDataDelete(index);
    })
  }

  notifyDataMove(from: number, to: number): void {
    this.listeners.forEach(listener => {
      listener.onDataMove(from, to);
    })
  }
}

@Observed
export default class LazyDataSource<T> extends BasicDataSource<T> {
  dataArray: T[] = [];

  public totalCount(): number {
    return this.dataArray.length;
  }

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

  public addData(index: number, data: T): void {
    this.dataArray.splice(index, 0, data);
    this.notifyDataAdd(index);
  }

  public pushData(data: T): void {
    this.dataArray.push(data);
    this.notifyDataAdd(this.dataArray.length - 1);
  }

  public pushArrayData(newData: ObservedArray<T>): void {
    this.clear();
    this.dataArray.push(...newData);
    this.notifyDataReload();
  }

  public appendArrayData(addData: ObservedArray<T>): void {
    this.dataArray.push(...addData);
    this.notifyDataReload();
  }

  public deleteData(index: number): void {
    this.dataArray.splice(index, 1);
    this.notifyDataDelete(index);
  }

  public getDataList(): ObservedArray<T> {
    return this.dataArray;
  }

  public clear(): void {
    this.dataArray.splice(0, this.dataArray?.length);
  }

  public isEmpty(): boolean {
    return this.dataArray.length === 0;
  }
}

// ``` ObservedArray ``` @
Observed
export class ObservedArray<T> extends Array<T> {
  constructor(args?: T[]) {
    if (args instanceof Array) {
      super(...args);
    } else {
      super();
    }
  }
}