Android 的 SparseArray 鸿蒙有什么可以替换？

在Android中，替代HashMap有如下方案：

1. 当元素数量不太大时（数量小于1000），使用ArrayMap，对应鸿蒙的ohos.utils.LightweightMap
2. 当key为int，使用稀疏数组SparseArray，可避免key自动装箱，对应鸿蒙的ohos.utils.PlainArray
3. 当key和val都为int，使用SparseIntArray，可避免key和val自动装箱，对应鸿蒙的ohos.utils.PlainIntArray

所以，你的问题的答案是ohos.utils.PlainArray

深入理解，大家可以参考：深度解读ArrayMap优势与缺陷

可以自己实现一个

public class SparseRawArray<K extends Number, E> {
 private final LinkedHashMap<K, E> mMap;
 private Iterator<K> mIterator;
 private int mIndex;
 private boolean mIndexDirty;
 private K mCurrentKey;

 public SparseRawArray() {
  mMap = new LinkedHashMap<>();
  resetIndex();
 }

 public E get(K key) {
  return get(key, null);
 }

 public E get(K key, E valueIfKeyNotFound) {
  E value = mMap.get(key);
  return value != null ? value : valueIfKeyNotFound;
 }

 public void delete(K key) {
  mMap.remove(key);
  mIndexDirty = true;
 }

 public void remove(K key) {
  delete(key);
 }

 public void put(K key, E value) {
  mMap.put(key, value);
  mIndexDirty = true;
 }

 public int size() {
  return mMap.size();
 }

 public K keyAt(int index, K keyIfIndexNotExist) {
  if (mIndex == index && !mIndexDirty) {
   return mCurrentKey;
  }

  if (mIndexDirty || mIndex > index) {
   resetIndex();
  }

  while (mIterator.hasNext()) {
   if (++mIndex == index) {
    mCurrentKey = mIterator.next();
    return mCurrentKey;
   }
  }

  mIndexDirty = true;

  return keyIfIndexNotExist;
 }

 public void clear() {
  mMap.clear();
  mIndexDirty = true;
 }

 private void resetIndex() {
  mIndex = -1;
  mIterator = mMap.keySet().iterator();
  mCurrentKey = null;
  mIndexDirty = false;
 }
}

public class SparseArray<E> extends SparseRawArray<Integer, E> {
 public int keyAt(int index) {
  return keyAt(index, -1);
 }
}