Redis的八种数据类型介绍

Redis 是一个高性能的键值存储，它支持多种丰富的数据类型。每种数据类型都有其特定的用途和底层实现。下面我将介绍 Redis 支持的主要数据类型及其背后的数据结构。
本人这里还有几篇详细的Redis用法文章，可以用来进阶康康！
1. 字符串 (String)

数据结构

字符串是 Redis 中最基本的数据类型，可以是文本、数字、二进制数据等。它在 Redis 内部是以动态字符串 (SDS, Simple Dynamic String) 实现的。SDS 除了字符串本身，还有额外的属性来缓存长度。

• 简朴动态字符串 (SDS)：
  
  
  
  • length：当前已使用的字符串长度。
    
  • free：未使用的预分配空间长度。
    
  • buf：现实存储字符串的缓冲区。
    
  
  

用法示例

1. Jedis jedis = new Jedis("localhost");
2. jedis.set("key", "value");  // 设置键值对
3. String value = jedis.get("key");  // 获取值
4. System.out.println(value);
5. jedis.close();

复制代码

2. 哈希 (Hash)

数据结构

哈希是键值对的集合，得当表现对象的属性。最常用的是用来存储对象。内部实现主要有两种：

• 压缩列表 (ziplist)：当哈希数量较少且每个键值对的长度较短时会使用。
  
• 哈希表 (hashtable)：当哈希数量增多或其中某个键或值变长后，主动转为哈希表。
  

用法示例

1. Jedis jedis = new Jedis("localhost");
2. jedis.hset("user:1000", "name", "John");
3. jedis.hset("user:1000", "age", "30");
4. String name = jedis.hget("user:1000", "name");
5. System.out.println(name);
6. jedis.close();

复制代码

3. 列表 (List)

数据结构

列表是一组有序的字符串，可以从列表的头部或尾部添加或删除元素。内部实现有以下两种：

• 压缩列表 (ziplist)：元素数量较少且每个元素较短时使用。
  
• 双向链表 (linkedlist)：元素数量多时，会主动转为双向链表。
  

用法示例

1. Jedis jedis = new Jedis("localhost");
2. jedis.lpush("tasks", "Task1");  // 从头部插入
3. jedis.rpush("tasks", "Task2");  // 从尾部插入
4. String task = jedis.lpop("tasks");  // 从头部弹出
5. System.out.println(task);
6. jedis.close();

复制代码

4. 集合 (Set)

数据结构

集合是无序且唯一的字符串集合。内部采用哈希表 (hashtable) 实现，哈希表的键是集合的值，值是 null。
用法示例

1. Jedis jedis = new Jedis("localhost");
2. jedis.sadd("tags", "java");
3. jedis.sadd("tags", "redis");
4. jedis.sadd("tags", "java");  // 不会重复添加
5. Set<String> tags = jedis.smembers("tags");
6. System.out.println(tags);
7. jedis.close();

复制代码

5. 有序集合 (Sorted Set)

数据结构

有序集合雷同集合，但每个元素都会关联一个分数（score），元素按分数排序。内部使用一种结构：跳表 (skiplist) 和哈希表 (hashtable) 结合。

• 跳表 (skiplist)：快速实现范围查询和排序。
  
• 哈希表 (hashtable)：快速定位元素。
  

用法示例

1. Jedis jedis = new Jedis("localhost");
2. jedis.zadd("leaderboard", 100, "Player1");
3. jedis.zadd("leaderboard", 200, "Player2");
4. Set<String> topPlayers = jedis.zrange("leaderboard", 0, -1);  // 按分数排序获取元素
5. System.out.println(topPlayers);
6. jedis.close();

复制代码

6. 位图 (Bitmap)

数据结构

位图将字符串值视为一个位数组，可以进行位操作。内部存储采用字符串，最大长度可达 512 MB。

• 字节数组 (byte array)：现实存储位图数据的结构，是一个一连的内存地区。
  

用法示例

1. Jedis jedis = new Jedis("localhost");
2. jedis.setbit("user:active", 1, true);  // 设置第2位为1
3. boolean isActive = jedis.getbit("user:active", 1);
4. System.out.println(isActive);
5. jedis.close();

复制代码

7. HyperLogLog

数据结构

HyperLogLog 是基数估算数据结构，用于估算不重复元素的数量。利用概率算法实现，毛病率约 0.81%。用于大规模数据去重计数。

• 希奇矩阵 (Sparse Representation)：当元素少时，用压缩方法存储。
  
• 麋集矩阵 (Dense Representation)：当元素多到肯定水平时，转为麋集表现。
  

用法示例

1. Jedis jedis = new Jedis("localhost");
2. jedis.pfadd("unique_visitors", "user1");
3. jedis.pfadd("unique_visitors", "user2");
4. jedis.pfadd("unique_visitors", "user1");
5. long uvCount = jedis.pfcount("unique_visitors");
6. System.out.println(uvCount);
7. jedis.close();

复制代码

8. 地理空间 (Geospatial)

数据结构

Redis 的地理空间扩展答应存储地理坐标，并提供地理范围查询、间隔计算等功能。内部使用有序集合 (Sorted Set) 数据类型实现，利用 GeoHash 编码。

• GeoHash 编码 (geohash)：将地理坐标编码为字符串，保证地理位置靠近的两个编码也是靠近的。
  
• 跳表 (skiplist) 和哈希表 (hashtable)：与有序集合共享的实现，支持半径查询和排序。
  

用法示例

1. Jedis jedis = new Jedis("localhost");
2. jedis.geoadd("locations", 13.361389, 38.115556, "Palermo");
3. jedis.geoadd("locations", 15.087269, 37.502669, "Catania");
5. List<GeoCoordinate> coordinates = jedis.geopos("locations", "Palermo");
6. System.out.println(coordinates);
8. double distance = jedis.geodist("locations", "Palermo", "Catania", GeoUnit.KM);
9. System.out.println(distance);
10. jedis.close();

复制代码

结论

Redis 提供了丰富的数据结构，每种数据结构都有其特定的应用场景和优势。在实践中，可以根据详细需求选择符合的数据类型，进步体系性能与效率。了解这些数据结构的底层实现有助于更好地明白和使用 Redis，优化数据存储和操作。
另（口试突出加分项）：
跳表（SkipList）是一种用于有序集合的高效数据结构，支持快速的插入、删除和查找操作。它的时间复杂度为 O(log N)，靠近于平衡二叉树，但实现相对简朴。跳表是 Redis 中 Sorted Set（有序集合）数据类型的主要底层实现之一。

跳表的数据结构

跳表由多层有序链表组成，下层链表包含全部元素，每一层链表是其下一层链表的抽样。跳表的最底层是一条完整的有序链表，从头至尾包含全部的元素。每一层往上淘汰一部分元素，通过跳过一些元素使操作更高效。

• Level 0：包含全部节点，构成最底层链表。
  
• Level 1：包含部分节点，跳过一些元素，形成较高层次的链表。
  
• Level k：最高层链表，包含最少的元素。
  

跳表的节点

每个节点包含多个指针，每个指针指向该层中的下一个节点。节点结构如下：

• score：用于排序的分数。
  
• member：现实存储的值。
  
• forward pointers：指向各层下一个节点的指针数组。
  

跳表的操作

跳表支持插入、删除和查找操作，详细步骤如下：
插入操作

• 从最高层开始，找到要插入的位置。
  
• 随机生成节点的高度（层数）。
  
• 将新节点插入到对应的每一层链表中。
  

删除操作

• 从最高层开始，找到要删除的节点。
  
• 更新指针，跳过该节点。
  
• 逐层删除该节点。
  

查找操作

• 从最高层开始，根据分数找到目标位置。
  
• 假如当前层找不到，降到下一层继续查找。
  
• 直到找到目标节点或确认节点不存在。
  

跳表在 Redis 中的实现

以下是 Redis 跳表的数据结构和主要操作的实现：
节点结构

1. typedef struct zskiplistNode {
2.     struct zrobj *obj; // 存储成员对象（value）
3.     double score;      // 分数，用于排序
4.     struct zskiplistNode *backward; // 后退指针
5.     struct zskiplistLevel {
6.         struct zskiplistNode *forward; // 前进指针
7.         unsigned int span;             // 跨度
8.     } level[]; // 层指针数组
9. } zskiplistNode;

复制代码

跳表结构

1. typedef struct zskiplist {
2.     struct zskiplistNode *header, *tail; // 头尾指针
3.     unsigned long length;                // 节点数量
4.     int level;                           // 当前最大层数
5. } zskiplist;

复制代码

插入操作

1. zskiplistNode *zslInsert(zskiplist *zsl, double score, robj *obj) {
2.     // 临时存储每一层的前一个节点
3.     zskiplistNode *update[ZSKIPLIST_MAXLEVEL];
4.     zskiplistNode *x;
5.     int i, level;
6.    
7.     x = zsl->header;
8.     for (i = zsl->level-1; i >= 0; i--) {
9.         while (x->level[i].forward &&
10.                (x->level[i].forward->score < score ||
11.                (x->level[i].forward->score == score &&
12.                 compareStringObjects(x->level[i].forward->obj, obj) < 0))) {
13.             x = x->level[i].forward;
14.         }
15.         update[i] = x;
16.     }
17.    
18.     level = zslRandomLevel(); // 随机生成节点层数
19.     if (level > zsl->level) {
20.         for (i = zsl->level; i < level; i++) {
21.             update[i] = zsl->header;
22.         }
23.         zsl->level = level;
24.     }
26.     x = zslCreateNode(level, score, obj); // 创建新节点
27.     for (i = 0; i < level; i++) {
28.         x->level[i].forward = update[i]->level[i].forward;
29.         update[i]->level[i].forward = x;
30.     }
31.     x->backward = (update[0] == zsl->header ? NULL : update[0]);
32.     if (x->level[0].forward)
33.         x->level[0].forward->backward = x;
34.     else
35.         zsl->tail = x;
36.     zsl->length++;
37.     return x;
38. }

复制代码

删除操作

1. int zslDelete(zskiplist *zsl, double score, robj *obj) {
2.     zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
3.     int i;
4.    
5.     x = zsl->header;
6.     for (i = zsl->level-1; i >= 0; i--) {
7.         while (x->level[i].forward &&
8.                (x->level[i].forward->score < score ||
9.                (x->level[i].forward->score == score &&
10.                 compareStringObjects(x->level[i].forward->obj, obj) < 0))) {
11.             x = x->level[i].forward;
12.         }
13.         update[i] = x;
14.     }
16.     x = x->level[0].forward;
17.     if (x && score == x->score && compareStringObjects(x->obj, obj) == 0) {
18.         for (i = 0; i < zsl->level; i++) {
19.             if (update[i]->level[i].forward == x) {
20.                 update[i]->level[i].forward = x->level[i].forward;
21.             }
22.         }
23.         if (x->level[0].forward) {
24.             x->level[0].forward->backward = x->backward;
25.         } else {
26.             zsl->tail = x->backward;
27.         }
28.         while (zsl->level > 1 && zsl->header->level[zsl->level-1].forward == NULL) {
29.             zsl->level--;
30.         }
31.         zsl->length--;
32.         zslFreeNode(x);
33.         return 1;
34.     }
35.     return 0;
36. }

复制代码

查找操作

1. zskiplistNode *zslFind(zskiplist *zsl, double score, robj *obj) {
2.     zskiplistNode *x = zsl->header;
3.     int i;
5.     for (i = zsl->level-1; i >= 0; i--) {
6.         while (x->level[i].forward &&
7.                (x->level[i].forward->score < score ||
8.                (x->level[i].forward->score == score &&
9.                 compareStringObjects(x->level[i].forward->obj, obj) < 0))) {
10.             x = x->level[i].forward;
11.         }
12.     }
13.     x = x->level[0].forward;
14.     if (x && score == x->score && compareStringObjects(x->obj, obj) == 0) {
15.         return x;
16.     }
17.     return NULL;
18. }

复制代码

跳表的长处

• 高效性：查找、插入、删除的平均时间复杂度为 O(log N)。
  
• 简朴性：相较于平衡树，跳表的实现和维护更为简朴。
  
• 机动性：能够快速应对动态变革的数据，有较好的顺应性。
  

在 Redis 中的应用

跳表主要用于 Redis 的有序集合 (Sorted Set) 数据类型。通过跳表，可以高效实现按分数排序的多种操作，如范围查询、排名查询等。它与哈希表结合使用，实现了元素的快速访问和分数范围内的高效查询。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。