HarmonyOS 5.0应用开发——ArkTS容器类

【高心星出品】

容器类

线性容器类

线性容器实现能按顺序访问的数据结构，其底层主要通过数组实现，包括ArrayList、Vector（已废弃）、List、LinkedList、Deque、Queue、Stack七种。

ArrayList

一种数组对象，最简单的容器类型。

// arraylist元素
export function arraylist() {
  let al = new ArrayList()
  // 末尾新增元素
  al.add('str')
  al.add(10)
  // 某个位置插入元素
  al.insert(true, 1)
  // 循环遍历元素 for-of结构
  for (const element of al) {
    console.info(element+'   gxxt')
  }
  // foreach结构
  al.forEach((value, index) => {
    console.info(`${index}--${value}  gxxt`)
  }, value => JSON.stringify(value))
  // 更新某个元素的值
  al[0] = 'str1'
  //  查询是否有某个元素
  let hasstr1 = al.has('str1')
  console.info(hasstr1+'  gxxt')
  // 移除元素
  al.removeByIndex(0)
  //   移除某个范围内的元素
  al.removeByRange(0, 2)

}

List

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

相对于ArrayList，List的插入删除效率要更优秀。

// list 单链表  
export function list() {
  let list = new List()
  list.add('str')
  list.add(1)
  list.insert('ok', 1)
  // 根据下标取出元素
  let a = list.get(1)
  //  取出头元素
  let first = list.getFirst()
  //  取出尾元素
  let last = list.getLast()
  // 更新某个下标对应的元素
  list.set(1, 'gaga')
  console.info(`gxxt ${a}, ${first}, ${last}`)

}

list容器通用arraylist容器，并有自己的方法。

LinkedList

使用方式和List是一样的，只不过LinkedList是双向链表，LinkedList和List相比，LinkedList是双向链表，可以快速地在头尾进行增删，而List是单向链表，无法双向操作。

Queue

Queue可用来构造队列对象，存储元素遵循先进先出的规则。

export function queue()
{
  let que=new Queue()
  // 队尾加入元素
  que.add('str')
  que.add(1)
  que.add(true)
  // 获取队首元素
  let first=que.getFirst()
  // 出队元素便返回
  let ff=que.pop()
  let ff1=que.pop()
  console.info(`gxxt ${first}, ${ff}, ${ff1}`)
}

Stack

Stack可用来构造栈对象，存储元素遵循先进后出的规则。

// stack 栈对象
export function stack()
{
  let stack=new Stack()
  // 压入栈
  stack.push('str')
  stack.push(1)
  stack.push(true)
  // 获取栈顶元素
  let first=stack.peek()
  // 出栈
  let ff=stack.pop()
  console.log('gxxt '+first+'  '+ff)
  // 遍历stack
  stack.forEach((item,index)=>{
    console.log(item+'')
  })

}

非线性容器

HashMap

HashMap可用来存储具有关联关系的key-value键值对集合，存储元素中key是唯一的，每个key会对应一个value值。

// hashmap
  export function hashmap()
  {
    let hm=new HashMap()
    // 增加元素 无序
    hm.set('one','item1')
    hm.set(2,'item2')
    hm.set(3,'item3')
  //   取出元素
    if (hm.hasKey(2)) {
      let value = hm.get(2)
    }
    // 取出所有的键
    let keys=hm.keys()
    for (const element of keys) {
      console.info('gxxt '+element)
    }
    // 遍历所有的key和value
    hm.forEach((key,value)=>{
      console.info('gxxt  '+key+'=='+value)
    },key=>JSON.stringify(key))
    // 替换元素
    hm.replace(1,'item11')
    // 删除元素
    hm.remove('one')
  }

TreeMap

TreeMap可用来存储具有关联关系的key-value键值对集合，存储元素中key是唯一的，每个key会对应一个value值。

TreeMap和HashMap相比，HashMap依据键的hashCode存取数据，访问速度较快。而TreeMap是有序存取，效率较低。

// treemap
export function treemap() {
  let tm = new TreeMap()
  tm.set('one', 'item1')
  tm.set(2, 'item2')
  tm.set(3, 'item3')
  //  treemap是有序的 所以可以
  let fk = tm.getFirstKey()
  let lk = tm.getLastKey()
  console.info('gxxt  ' + fk + '  ' + lk)

}

HashSet

HashSet可用来存储一系列值的集合，存储元素中value是唯一的。

export function hashset()
{
  let hs=new HashSet()
  // 增加元素
  hs.add('item1')
  hs.add('item2')
  hs.add('item3')
  // 获取集合中元素
  let vs=hs.values()
  for (const element of vs) {
    console.info('gxxt '+element)
  }
  hs.forEach((value)=>{
    console.info('gxxt '+value)
  },value=>JSON.stringify(value))
//   删除元素
  hs.remove('item2')
}

TreeSet

TreeSet可用来存储一系列值的集合，存储元素中value是唯一的。

TreeSet和HashSet相比，HashSet中的数据无序存放，而TreeSet是有序存放。它们集合中的元素都不允许重复，但HashSet允许放入null值，TreeSet不建议插入空值，可能会影响排序结果。

// treeset
export function treeset()
{
  let ts=new TreeSet()
  ts.add('item1')
  ts.add('item2')
  ts.add('item3')
  // 获取第一个元素
  let fv=ts.getFirstValue()
  // 获取最后一个元素
  let lv=ts.getLastValue()
  console.info('gxxt '+fv+'=='+lv)
}