java的对象和map结构是否一样

转载

mob64ca1406d617 2024-10-20 14:18:17

文章标签 java的对象和map结构是否一样 javascript 前端键值对键值 文章分类 Java 后端开发

实战中：最近开发中，在小程序中有使用到Map 和 Set ，应用于发布订阅的事件回调，还有 websocket。

Map

Map对象保存键值对。任何值(对象或者原始值) 都可以作为一个键或一个值。构造函数Map可以接受一个数组作为参数。

Map 和 object(常规对象)的区别

一个 Object 的键只能是字符串或者 Symbols (基本数据类型，独一无二)，但一个Map 的键可以是任意值。
Map 中的键值是有序的（FIFO 原则），而添加到对象中的键则不是。
Map 的键值对个数可以从 size 属性获取，而 Object 的键值对个数只能手动计算。
Object 都有自己的原型，原型链上的键名有可能和你自己在对象上的设置的键名产生冲突。

Map对象的方法

set(key, val)：向 Map 中添加新元素
get(key)：通过键值查找特定的数值并返回
has(key)：判断 Map 对象中是否有 key 所对应的值，有返回 true，没有返回 false
delete(key)：通过键值从 Map 中移除对应的数据
clear()：将整个 Map 的所有元素删除

Map 对象的属性

size：返回 Map 对象中所包含的键值对个数。

const m1 = new Map([['a', 333], ['b', 222]])
console.log(m1) // {"a" => 333, "b" => 222}
m1.get('a')  // 333

const m2 = new Map([['c', 3]])
const m3 = new Map(m2)
m3.get('c') // 3 通过键获取值
m3.has('c') // true // 判断c 这个键是否在这个集合中
m3.set('d', 555) // 设置一个 一个值
m3.get('d') // 555 // 获取集合中的某个值

Map 遍历的方法

keys()：返回键名的遍历器
values()：返回键值的遍历器
entries()：返回键值对的遍历器
forEach()：使用回调函数遍历每个成员

const map = new Map([['a', 11], ['b',  22]])

for (let key of map.keys()) {
  console.log(key)
}
// "a"
// "b"

for (let value of map.values()) {
  console.log(value)
}
// 11
// 22

for (let item of map.entries()) {
  console.log(item)
}
// ["a", 11]
// ["b", 22]

// 或者
for (let [key, value] of map.entries()) {
  console.log(key, value)
}
// "a" 11
// "b" 22

// for...of...遍历map等同于使用map.entries()

for (let [key, value] of map) {
  console.log(key, value)
}
// "a" 11
// "b" 22

map.forEach((item, key) => {
    console.log(item, key)
})
// 11 'a'
// 22 'b'

Map与对象的互换

const obj = {}

const map = new Map(['a', 11], ['b', 22])

for(let [key,value] of map) {
  obj[key] = value
}

console.log(obj) // {a:11, b: 22}

Set

Set 对象允许你存储任何类型的值，无论是原始值或者是对象引用。它类似于数组，但是成员的值都是唯一的，没有重复的值。

Set 本身是一个构造函数，用来生成Set 数据结构。Set函数可以接受一个数组（或者具有 iterable 接口的其他数据结构）作为参数，用来初始化。

Set 对象存储的值总是唯一的，所以需要判断两个值是否恒等。有几个特殊值需要特殊对待：

+0 与 -0 在存储判断唯一性的时候是恒等的，所以不重复
undefined 与 undefined 是恒等的，所以不重复
NaN 与 NaN 是不恒等的，但是在 Set 中认为NaN与NaN相等，所有只能存在一个，不重复。
{} {} 两个空对象的指针不一样，所以会重复

Set实例对象的属性:

size：返回Set实例的成员总数。

Set实例对象的方法:

add(val)：添加某个值，返回 Set 结构本身(可以链式调用)。
delete(val)：删除某个值，删除成功返回true，否则返回false。
has(val)：返回一个布尔值 true or false，表示该值是否为Set的成员。
clear()：清除所有成员，没有返回值。

const mySet = new Set(['a', 'a', 'b', 11, 22, 11])
console.log(mySet)  // {'a', 'b', 11, 22}
myset.add('c').add({'a': 1})
console.log(mySet) // {'a', 'b', 11, 22, 'c', {a: 1}}
console.log(mySet.size) // 6

mySet.has(22) // true

遍历方法

 - keys()：返回键名的遍历器。
 - values()：返回键值的遍历器。
 - entries()：返回键值对的遍历器。
 - forEach()：使用回调函数遍历每个成员。
 
由于Set结构没有键名，只有键值（**或者说键名和键值是同一个值**），所以keys方法和values方法的行为完全一致。

const set = new Set(['a', 'b', 'c'])

for (let item of set.keys()) {
  console.log(item)
}
// 获取得到是一个键组成的
// a
// b
// c

for (let item of set.values()) {
  console.log(item)
}
// a
// b
// c

for (let item of set.entries()) {
  console.log(item)
}
// ["a", "a"]
// ["b", "b"]
// ["c", "c"]

// 直接遍历set实例，等同于遍历set实例的values方法
for (let i of set) {
  console.log(i)
}
// a
// b
// c

set.forEach((value, key) => console.log(key + ' : ' + value))

// a: a
// b: b
// c: c


// 利用数组去重
const mySet = new Set([1, 2, 3, 4, 4])
[...mySet] // [1, 2, 3, 4]

// 合并两个set对象:
let a = new Set([1, 2, 3])
let b = new Set([4, 3, 2])
let union = new Set([...a, ...b]) // {1, 2, 3, 4}

// 交集
let a = new Set([1, 2, 3])
let b = new Set([2, 3, 6])
let intersect = new Set([...a].filter(x => b.has(x)))  // {2, 3} 利用数组的filter方法。

// 差集
let a = new Set([1, 2, 3])
let b = new Set([4, 3, 2])
let difference = new Set([...a].filter(x => !b.has(x))) //  {1}