返回发烧友论坛
发 帖  

[文章]OpenHarmony 3.1 Beta版本关键特性解析——ArkUI容器类API介绍

OpenHarmony开发者
2022-04-24 14:58:16
阅读量0
OpenHarmonyAPI应用开发
0
1
（以下内容来自开发者分享，不代表 OpenHarmony 项目群工作委员会观点）


刘鑫


容器类，顾名思义就是存储的类，用于存储各种数据类型的元素，并具备一系列处理数据元素的方法。在 ArkUI 开发框架中，容器类采用了类似静态的语言来实现，并通过 NAPI 框架对外提供。通过对存储位置以及属性的限制，让每种类型的数据都能在完成自身功能的基础上剪除冗余分支，保证了数据的高效访问，提升了应用的性能。

本期，我们将为大家介绍 ArkUI 开发框架中容器类的各种类型以及相关 API 的使用。

一、容器类API介绍

在 ArkUI 开发框架中，提供了线性和非线性两类容器类，共 14 种，每种容器都有自身的特性及使用场景。下面，我们将为大家一一道来。

1.1线性容器类

线性容器类底层主要通过数组实现，包括 ArrayList、Vector、List、LinkedList、Deque、Queue、Stack 七种。线性容器类 API，充分考虑了数据访问的速度，实现了运行时（Runtime）通过一条指令就可以完成增删改查等操作。

1.1.1 ArrayList

ArrayList 即动态数组，可用来构造全局的数组对象。ArrayList 依据泛型定义，要求存储位置是一片连续的内存空间，初始容量大小为 10，并支持动态扩容，每次扩容大小为原始容量的 1.5 倍。ArrayList 进行增、删、改、查操作的相关 API 如下：


1.1.2 Vector

Vector 是指连续存储结构，可用来构造全局的数组对象。Vector 依据泛型定义，要求存储位置是一片连续的内存空间，初始容量大小为 10，并支持动态扩容，每次扩容大小为原始容量的2倍。

由于 Vector 扩容速度高于 ArrayList，所以适用于数据添加比较频繁的场景。Vector 在支持操作符访问的基础上，还增加了 get/set 接口，提供更为完善的校验及容错机制，满足用户不同场景下的需求。Vector 进行增、删、改、查操作的相关 API 如下：


1.1.3 List

List 可用来构造一个单向链表对象，即只能通过头结点开始访问到尾节点。List 依据泛型定义，在内存中的存储位置可以是不连续的。

可以通过 get/set 等接口对存储的元素进行修改，List 进行增、删、改、查操作的相关 API 如下：


1.1.4 LinkedList

LinkedList 可用来构造一个双向链表对象，可以在某一节点向前或者向后遍历 List。LinkedList 依据泛型定义，在内存中的存储位置可以是不连续的。

可以通过 get/set 等接口对存储的元素进行修改，LinkedList 进行增、删、改、查操作的相关 API 如下：


1.1.5 Queue

Queue 可用来构造队列对象，存储元素遵循先进先出的规则。Queue 依据泛型定义，要求存储位置是一片连续的内存空间，初始容量大小为 8，并支持动态扩容，每次扩容大小为原始容量的 2 倍。Queue 底层采用循环队列实现，入队及出队操作效率都比较高。Queue 进行增、删、改、查操作的相关 API 如下：


1.1.6 Deque

Deque 可用来构造双端队列对象，存储元素遵循先进先出的规则，双端队列可以分别从对头或者队尾进行访问。Deque 依据泛型定义，要求存储位置是一片连续的内存空间，其初始容量大小为 8，并支持动态扩容，每次扩容大小为原始容量的 2 倍。Deque 底层采用循环队列实现，入队及出队操作效率都比较高。Deque 进行增、删、改、查操作的相关 API 如下：


1.1.7 Stack

Stack 可用来构造栈对象，存储元素遵循后进先出的规则。Stack 依据泛型定义，要求存储位置是一片连续的内存空间，初始容量大小为 8，并支持动态扩容，每次扩容大小为原始容量的 1.5 倍。Stack 底层基于数组实现，入栈出栈均从数组的一端操作，Stack 进行增、删、改、查操作的相关 API 如下：


1.2非线性容器类

非线性容器类底层通过 hash 或者红黑树实现，包括 HashMap、HashSet、TreeMap、TreeSet、LightWeightMap、LightWeightSet、PlainArray 七种。非线性容器类中的 key 及 value 的类型均满足 ECMA 标准。

1.2.1 HashMap

HashMap 可用来存储具有关联关系的 key-value 键值对集合，存储元素中 key 是唯一的，每个 key 会对应一个 value 值。HashMap 依据泛型定义，集合中通过 key 的 hash 值确定其存储位置，从而快速找到键值对。HashMap 的初始容量大小为 16，并支持动态扩容，每次扩容大小为原始容量的 2 倍。HashMap 底层基于 HashTable 实现，冲突策略采用链地址法。HashMap 进行增、删、改、查操作的相关 API 如下：


1.2.2 HashSet

HashSet 可用来存储一系列值的集合，存储元素中 value 是唯一的。依据泛型定义。集合中通过 value 的 hash 值确定其存储位置，从而快速找到该值。HashSet 初始容量大小为 16，支持动态扩容，每次扩容大小为原始容量的 2 倍。value 的类型满足 ECMA 标准中要求的类型。HashSet 底层基于 HashTable 实现，冲突策略采用链地址法。HashSet 进行增、删、改、查操作的相关 API 如下：


1.2.3 TreeMap

TreeMap 可用来存储具有关联关系的 key-value 键值对集合，存储元素中 key 是唯一的，每个 key 会对应一个 value 值。TreeMap 依据泛型定义，集合中的 key 值是有序的，TreeMap 的底层是一棵二叉树，可以通过树的二叉查找快速地找到键值对。key 的类型满足 ECMA 标准中要求的类型。TreeMap 中的键值是有序存储的。TreeMap 底层基于红黑树实现，可以进行快速地插入和删除。TreeMap 进行增、删、改、查操作的相关 API 如下：


1.2.4 TreeSet

TreeSet 可用来存储一系列值的集合，存储元素中 value 是唯一的。TreeSet 依据泛型定义，集合中的 value 值是有序的，TreeSet 的底层是一棵二叉树，可以通过树的二叉查找快速地找到该 value 值，value 的类型满足 ECMA 标准中要求的类型。TreeSet 中的值是有序存储的。TreeSet 底层基于红黑树实现，可以进行快速地插入和删除。TreeSet 进行增、删、改、查操作的相关 API 如下：


1.2.5 LightWeightMap

LigthWeightMap 可用来存储具有关联关系的 key-value 键值对集合，存储元素中 key 是唯一的，每个 key 会对应一个 value 值。LigthWeightMap 依据泛型定义，采用更加轻量级的结构，集合中的 key 值的查找依赖于 hash 值以及二分查找算法，通过一个数组存储 hash 值，然后映射到其他数组中的 key 值以及 value 值，key 的类型满足 ECMA 标准中要求的类型。

初始默认容量大小为 8，每次扩容大小为原始容量的 2 倍。LigthWeightMap 底层标识唯一 key 通过 hash 实现，其冲突策略为线性探测法，查找策略基于二分查找法。LigthWeightMap 进行增、删、改、查操作的相关 API 如下：


1.2.6 LightWeightSet

LigthWeightSet 可用来存储一系列值的集合，存储元素中 value 是唯一的。LigthWeightSet 依据泛型定义，采用更加轻量级的结构，初始默认容量大小为 8，每次扩容大小为原始容量的 2 倍。集合中的 value 值的查找依赖于 hash 以及二分查找算法，通过一个数组存储 hash 值，然后映射到其他数组中的 value 值，value 的类型满足 ECMA 标准中要求的类型。

LigthWeightSet 底层标识唯一 value 基于 hash 实现，其冲突策略为线性探测法，查找策略基于二分查找法。LigthWeightSet 进行增、删、改、查操作的相关 API 如下：


1.2.7 PlainArray

PlainArray 可用来存储具有关联关系的键值对集合，存储元素中 key 是唯一的，并且对于 PlainArray 来说，其 key 的类型为 number 类型。每个 key 会对应一个 value 值，类型依据泛型的定义，PlainArray 采用更加轻量级的结构，集合中的 key 值的查找依赖于二分查找算法，然后映射到其他数组中的 value 值。

初始默认容量大小为 16，每次扩容大小为原始容量的 2 倍。PlainArray 的查找策略基于二分查找法。PlainArray 进行增、删、改、查操作的相关 API 如下：


二、容器类的实现

下面我们将以 ArrayList 为例，为大家介绍，容器类的实现。包括容器类的初始化、容器类的接口调用、容器类对象模型的构建以及拦截器处理。

2.1 容器类初始化

在 ArkUI 开发框架中，通过 NAPI 的统一框架对外层提供容器类。下面，我们将以 ArrayList 为例，介绍基于 NAPI 的容器类的加载。如下图所示，是容器类初始化流程，在 NAPI 加载的过程中，会通过 ArkPrivate.Load 接口加载对应的容器类。ArrayList 在引擎中会初始化 Constructor 以及 Prototype 并返回，最后应用侧可以获得该容器类并使用。


2.2 容器类接口调用

在 ArkUI 开发框架中，容器类 API 的调用流程如下，用户先通过 new ArrayList 进入引擎得到对应的 arraylist 对象，然后可以通过 add 接口向对象中添加元素，元素最终会添加到一片和该 arraylist 绑定的内存空间。可以通过 [] 操作符进行元素获取，对于容器类而言，引擎会直接通过快速路径访问到元素存储位置，返回该值。


2.3 容器类对象模型

在 ArkUI 开发框架中，构造容器类对象模型的流程如下图所示，在运行时禁止再向对象上添加 Properties 属性，ArrayList 借用对象模型中的 elements 位置存储元素。


实现说明：通过 elements 存储数组元素，Length 为数组中元素个数，数组 Capatity 可以通过 elements 的长度获取。
扩容策略：ArrayList –> 1.5 倍
初始分配容量：ArrayList -> 10
  （注：TS 中的实现，扩容策略及初始分配容量不感知)

2.4 拦截器处理

拦截器处理，是指通过禁止掉一些影响对象行为的操作，比如 delete、setPrototype 等，在运行时（Runtime）维护一个高效的容器类对象。以 ArrayList 为例，ArkCompiler 内部拦截的操作主要涉及 DeleteProperty、DefineProperty、GetProperty、SetPrototype、GetOwnPropertyKeys、HasProperty 等操作限制数组的 holy 添加，以及更改属性的 attributes 等操作，保证了不需要做 JSArray 必须做的 holy 判断、writable 判断等操作。


三、容器类API的使用

通过上文的介绍，相信大家对容器类已经有了比较深刻的认识。那么，我们怎么使用容器类 API 呢？本文列举常用的典型容器的使用示例，包括导入模块、增加元素、访问元素及修改等操作：

  1. // ArrayList
  2. import ArrayList from '@ohos.util.ArrayList' // 导入ArrayList模块
  3. let arrayList = new ArrayList();
  4. arrayList.add("a");
  5. arrayList.add(1);    // 增加元素
  6. print(arrayList[0]); // 访问元素
  7. arrayList[0] = one"; // 修改元素
  8. print(arrayList[0]);

  10. // Vector
  11. import Vector from '@ohos.util.Vector'  // 导入Vector模块
  12. let vector = new Vector();
  13. vector.add("a");
  14. let b = [1, 2, 3];
  15. vector.add(b);
  16. vector.add(false); // 增加元素
  17. print(vector[0]);  // 访问元素
  18. print(vector.getFirstElement()); // 访问元素

  20. // Deque
  21. import Deque from '@ohos.util.Deque'  // 导入Deque模块
  22. let deque = new Deque;
  23. deque.insertFront("a");
  24. deque.insertFront(1); // 增加元素
  25. print(deque[0]);      // 访问元素
  26. deque[0] = "one";     // 修改元素
  27. print(deque[0]);

  29. // Stack
  30. import Stack from '@ohos.util.Stack'  // 导入Stack模块  
  31. let stack = new Stack();
  32. stack.push("a");
  33. stack.push(1);   // 增加元素
  34. print(stack[0]); // 访问元素
  35. stack.pop();     // 弹出元素
  36. print(stack.length);

  38. // List
  39. import List from '@ohos.util.List'  // 导入List模块
  40. let list = new List;
  41. list.add("a");
  42. list.add(1);
  43. let b = [1, 2, 3];
  44. list.add(b);        // 增加元素
  45. print(list[0]);     // 访问元素
  46. print(list.get(0)); // 访问元素

  48. // HashMap
  49. import HashMap from '@ohos.util.HashMap'   // 导入HashMap模块
  50. let hashMap = new HashMap();
  51. hashMap.set("a", 123);
  52. hashMap.set(4, 123);      // 增加元素
  53. print(hashMap.hasKey(4)); // 判断是否含有某元素
  54. print(hashMap.get("a"));  // 访问元素

  56. // TreeMap
  57. import TreeMap from '@ohos.util.TreeMap'   // 导入TreeMap模块
  58. let treeMap = new TreeMap();
  59. treeMap.set("a", 123);
  60. treeMap.set("6", 356);           // 增加元素
  61. print(treeMap.get("a"));         // 访问元素
  62. print(treeMap.getFirstKey("a")); // 访问首元素
  63. print(treeMap.getLastKey("a"));  // 访问尾元素

  65. // LightWeightMap
  66. import LightWeightMap from '@ohos.util.LightWeightMap' // 导入LightWeightMap模块
  67. let lightWeightMap = new LightWeightMap();
  68. lightWeightMap.set("x", 123);
  69. lightWeightMap.set("8", 356);   // 增加元素
  70. print(lightWeightMap.get("a")); // 访问元素
  71. print(lightWeightMap.get("x")); // 访问元素
  72. print(lightWeightMap.getIndexOfKey("8")); // 访问元素

  74. // PlainArray
  75. import PlainArray from '@ohos.util.PlainArray'   // 导入PlainArray模块
  76. let plainArray = new PlainArray();
  77. plainArray.add(1, "sdd");
  78. plainArray.add(2, "sff");      // 增加元素
  79. print(plainArray.get(1));      // 访问元素
  80. print(plainArray.getKeyAt(1)); // 访问元素
复制代码

至此以上就是本期全部内容，期待广大开发者通过 ArkUI 开发框架的容器类开发出更多高性能的应用。



举报

回帖

声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容图片侵权或者其他问题，请联系本站作侵删。 侵权投诉
链接复制成功，分享给好友