注意:直接使用./redis-server
方式启动使用的是redis-server这个shell脚本中默认配置
注意:默认的Redis安装完成之后在安装目录没有任何配置文件,需要在源码目录中复制redis.conf
配置文件到安装目录
Redis 默认端口:6379,可以通过自定义配置文件redis.conf
修改并启动
库:database 用来存放数据一个基本单元。一个库可以存放key-value键值对,redis中每一个库都有一个唯一名称|编号。
默认库的个数:16个,库的编号:0-15,默认使用是0号库。
切换库命令:SELECT dbid(库编号)
# 1. SELECT
作用: 切换到给定的数据库
# 2. FLUSHDB
作用: 清空当前库
# 3. FLUSHALL
作用: 情况所有库
# 4. redis客户端显示中文
在启动`redis-cli`时添加参数 `--raw`
# 1. DEL
作用:删除给定的一个或多个key,不存在的key会被忽略
# 2. EXISTS
作用:检查给定的key是否存在
# 3. EXPIRE
作用:为给定的key设置生存时间,当key过期时(生存时间为0),它会被自动删除
# 4. KEYS
作用:查找所有复核给定模式 pattern 的key。
语法:
KEYS * 匹配数据库中所有的key
KEYS h?llo 匹配hello,hallo和hollo等
KEYS h*llo 匹配hllo和heeeello等
KEYS h[ae]llo 匹配hello和hallo,但不匹配hillo,特殊符号用“\”隔开
# 5.MOVE
作用:将当前数据库的key移动到给定的数据库db中
# 6. PEXPIRE
作用:这个命令和EXPIRE命令的作用类似,但是它以毫秒为单位设置key的生存时间
# 7. TTL
作用:以秒为单位,返回给定key的剩余生存时间(TTL,time to live)
# 8. RANDOMKEY
作用:从当前数据库中随机返回(不删除)一个key
# 9. TYPE
作用:返回给定key所储存的值的类型
# 10. RENAME
作用:将key改名为newKey
命令 | 描述 |
---|---|
Redis Type 命令 | 返回 key 所储存的值的类型。 |
Redis PEXPIREAT 命令 | 设置 key 的过期时间亿以毫秒计。 |
Redis PEXPIREAT 命令 | 设置 key 过期时间的时间戳(unix timestamp) 以毫秒计 |
Redis Rename 命令 | 修改 key 的名称 |
Redis PERSIST 命令 | 移除 key 的过期时间,key 将持久保持。 |
Redis Move 命令 | 将当前数据库的 key 移动到给定的数据库 db 当中。 |
Redis RANDOMKEY 命令 | 从当前数据库中随机返回一个 key 。 |
Redis Dump 命令 | 序列化给定 key ,并返回被序列化的值。 |
Redis TTL 命令 | 以秒为单位,返回给定 key 的剩余生存时间(TTL, time to live)。 |
Redis Expire 命令 | seconds 为给定 key 设置过期时间。 |
Redis DEL 命令 | 该命令用于在 key 存在是删除 key。 |
Redis Pttl 命令 | 以毫秒为单位返回 key 的剩余的过期时间。 |
Redis Renamenx 命令 | 仅当 newkey 不存在时,将 key 改名为 newkey 。 |
Redis EXISTS 命令 | 检查给定 key 是否存在。 |
Redis Expireat 命令 | EXPIREAT 的作用和 EXPIRE 类似,都用于为 key 设置过期时间。 不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。 |
Redis Keys 命令 | 查找所有符合给定模式( pattern)的 key 。 |
命令 | 描述 |
---|---|
Redis Setnx 命令 | 只有在 key 不存在时设置 key 的值。 |
Redis Getrange 命令 | 返回 key 中字符串值的子字符 |
Redis Mset 命令 | 同时设置一个或多个 key-value 对。 |
Redis Setex 命令 | 将值 value 关联到 key ,并将 key 的过期时间设为 seconds (以秒为单位)。 |
Redis SET 命令 | 设置指定 key 的值 |
Redis Get 命令 | 获取指定 key 的值。 |
Redis Getbit 命令 | 对 key 所储存的字符串值,获取指定偏移量上的位(bit)。 |
Redis Setbit 命令 | 对 key 所储存的字符串值,设置或清除指定偏移量上的位(bit)。 |
Redis Decr 命令 | 将 key 中储存的数字值减一。 |
Redis Decrby 命令 | key 所储存的值减去给定的减量值(decrement) 。 |
Redis Strlen 命令 | 返回 key 所储存的字符串值的长度。 |
Redis Msetnx 命令 | 同时设置一个或多个 key-value 对,当且仅当所有给定 key 都不存在。 |
Redis Incrby 命令 | 将 key 所储存的值加上给定的增量值(increment) 。 |
Redis Incrbyfloat 命令 | 将 key 所储存的值加上给定的浮点增量值(increment) 。 |
Redis Setrange 命令 | 用 value 参数覆写给定 key 所储存的字符串值,从偏移量 offset 开始。 |
Redis Psetex 命令 | 这个命令和 SETEX 命令相似,但它以毫秒为单位设置 key 的生存时间,而不是像 SETEX 命令那样,以秒为单位。 |
Redis Append 命令 | 如果 key 已经存在并且是一个字符串, APPEND 命令将 value 追加到 key 原来的值的末尾。 |
Redis Getset 命令 | 将给定 key 的值设为 value ,并返回 key 的旧值(old value)。 |
Redis Mget 命令 | 获取所有(一个或多个)给定 key 的值。 |
Redis Incr 命令 | 将 key 中储存的数字值增一。 |
命令 | 描述 |
---|---|
Redis Lindex 命令 | 通过索引获取列表中的元素 |
Redis Rpush 命令 | 在列表中添加一个或多个值 |
Redis Lrange 命令 | 获取列表指定范围内的元素 |
Redis Rpoplpush 命令 | 移除列表的最后一个元素,并将该元素添加到另一个列表并返回 |
Redis Blpop 命令 | 移出并获取列表的第一个元素, 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。 |
Redis Brpop 命令 | 移出并获取列表的最后一个元素, 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。 |
Redis Brpoplpush 命令 | 从列表中弹出一个值,将弹出的元素插入到另外一个列表中并返回它; 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。 |
Redis Lrem 命令 | 移除列表元素 |
Redis Llen 命令 | 获取列表长度 |
Redis Ltrim 命令 | 对一个列表进行修剪(trim),就是说,让列表只保留指定区间内的元素,不在指定区间之内的元素都将被删除。 |
Redis Lpop 命令 | 移出并获取列表的第一个元素 |
Redis Lpushx 命令 | 将一个或多个值插入到已存在的列表头部 |
Redis Linsert 命令 | 在列表的元素前或者后插入元素 |
Redis Rpop 命令 | 移除并获取列表最后一个元素 |
Redis Lset 命令 | 通过索引设置列表元素的值 |
Redis Lpush 命令 | 将一个或多个值插入到列表头部 |
Redis Rpushx 命令 | 为已存在的列表添加值 |
命令 | 描述 |
---|---|
Redis Sunion 命令 | 返回所有给定集合的并集 |
Redis Scard 命令 | 获取集合的成员数 |
Redis Srandmember 命令 | 返回集合中一个或多个随机数 |
Redis Smembers 命令 | 返回集合中的所有成员 |
Redis Sinter 命令 | 返回给定所有集合的交集 |
Redis Srem 命令 | 移除集合中一个或多个成员 |
Redis Smove 命令 | 将 member 元素从 source 集合移动到 destination 集合 |
Redis Sadd 命令 | 向集合添加一个或多个成员 |
Redis Sismember 命令 | 判断 member 元素是否是集合 key 的成员 |
Redis Sdiffstore 命令 | 返回给定所有集合的差集并存储在 destination 中 |
Redis Sdiff 命令 | 返回给定所有集合的差集 |
Redis Sscan 命令 | 迭代集合中的元素 |
Redis Sinterstore 命令 | 返回给定所有集合的交集并存储在 destination 中 |
Redis Sunionstore 命令 | 所有给定集合的并集存储在 destination 集合中 |
Redis Spop 命令 | 移除并返回集合中的一个随机元素 |
命令 | 描述 |
---|---|
Redis Zrevrank 命令 | 返回有序集合中指定成员的排名,有序集成员按分数值递减(从大到小)排序 |
Redis Zlexcount 命令 | 在有序集合中计算指定字典区间内成员数量 |
Redis Zunionstore 命令 | 计算给定的一个或多个有序集的并集,并存储在新的 key 中 |
Redis Zremrangebyrank 命令 | 移除有序集合中给定的排名区间的所有成员 |
Redis Zcard 命令 | 获取有序集合的成员数 |
Redis Zrem 命令 | 移除有序集合中的一个或多个成员 |
Redis Zinterstore 命令 | 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中 |
Redis Zrank 命令 | 返回有序集合中指定成员的索引 |
Redis Zincrby 命令 | 有序集合中对指定成员的分数加上增量 increment |
Redis Zrangebyscore 命令 | 通过分数返回有序集合指定区间内的成员 |
Redis Zrangebylex 命令 | 通过字典区间返回有序集合的成员 |
Redis Zscore 命令 | 返回有序集中,成员的分数值 |
Redis Zremrangebyscore 命令 | 移除有序集合中给定的分数区间的所有成员 |
Redis Zscan 命令 | 迭代有序集合中的元素(包括元素成员和元素分值) |
Redis Zrevrangebyscore 命令 | 返回有序集中指定分数区间内的成员,分数从高到低排序 |
Redis Zremrangebylex 命令 | 移除有序集合中给定的字典区间的所有成员 |
Redis Zrevrange 命令 | 返回有序集中指定区间内的成员,通过索引,分数从高到底 |
Redis Zrange 命令 | 通过索引区间返回有序集合成指定区间内的成员 |
Redis Zcount 命令 | 计算在有序集合中指定区间分数的成员数 |
Redis Zadd 命令 | 向有序集合添加一个或多个成员,或者更新已存在成员的分数 |
命令 | 描述 |
---|---|
Redis Hmset 命令 | 同时将多个 field-value (域-值)对设置到哈希表 key 中。 |
Redis Hmget 命令 | 获取所有给定字段的值 |
Redis Hset 命令 | 将哈希表 key 中的字段 field 的值设为 value 。 |
Redis Hgetall 命令 | 获取在哈希表中指定 key 的所有字段和值 |
Redis Hget 命令 | 获取存储在哈希表中指定字段的值/td> |
Redis Hexists 命令 | 查看哈希表 key 中,指定的字段是否存在。 |
Redis Hincrby 命令 | 为哈希表 key 中的指定字段的整数值加上增量 increment 。 |
Redis Hlen 命令 | 获取哈希表中字段的数量 |
Redis Hdel 命令 | 删除一个或多个哈希表字段 |
Redis Hvals 命令 | 获取哈希表中所有值 |
Redis Hincrbyfloat 命令 | 为哈希表 key 中的指定字段的浮点数值加上增量 increment 。 |
Redis Hkeys 命令 | 获取所有哈希表中的字段 |
Redis Hsetnx 命令 | 只有在字段 field 不存在时,设置哈希表字段的值。 |
Redis官方提供了两种不同的持久化方法来将数据存储到硬盘里面。
这种方式可以将某一时刻的所有数据都写入硬盘中,当然这也是Redis的默认开启持久化方式,保存的文件时以.rdb
形式结尾的,因此这种方式也称为RDB方式。
BGSAVE
和 SAVE
指令# 1. 客户端方式之 BGSAVE
客户端可以使用 BGSAVE 命令来创建一个快照,当接收到客户端的 BGSAVE 命令时,Redis会调用fork来创建一个子线程,然后子线程负责将快照写入磁盘中,而父进程则继续处理命令请求。
fork解释:当一个进程创建子进程的时候,底层的操作系统会创建该进程的一个副本,在类unix系统中创建子进程的操作会进行优化。在刚开始的时候,父子进程共享相同内容,直到父进程或子进程对内存进行了写之后,对被写入的内存的共享才会结束服务。
# 2. 客户端方式之 SAVE
客户端还可以使用 SAVE 命令来创建一个快照,接收到 SAVE 命令的redis服务器在快照创建完毕之前将不再响应任何其他的命令。
注意:SAVE 命令并不常用,使用 SAVE 命令在快照创建完毕之前,redis会处于阻塞状态,无法对外提供服务。
# 3. 服务器配置方式之满足条件自动触发
如果用户在 redis.conf 中配置了save配置选项,redis会在save选项条件满足之后自动触发一次BGSAVE命令,如果设置多个save配置选项,当任意一个save配置选项条件满足时,redis也会触发一次BGSAVE命令。
# 4. 服务器接收客户端shutdown指令
当redis通过shutdown指令接收到关闭服务器的请求时,会执行一个save命令,阻塞所有的客户端,不再执行客户端执行发送的任何命令,并且在save命令执行完毕之后关闭服务器。
这种方式可以将所有客户端执行的写命令记录到日志文件中,AOF持久化会将被执行的写命令写到AOF的文件末尾,以此来记录数据发生的变化,因此只要redis从头到尾执行一个AOF文件所包含的所有写命令,就可以恢复AOF文件的记录的数据集。
在redis的默认配置中AOF持久化机制是没有开启的,需要在配置中打开。
AOF的方式也同时带来了另一个问题。持久化文件会变得越来越大。例如我们调用incr test
命令100次,文件中必须保存全部的100条命令,其实有99条都是多余的。因为要恢复数据库的状态其实文件中保存一条set test 100
就够了。
为了压缩AOF的持久化文件问题,Redis提供了AOF重写机制。
用来在一定程度上减小AOF文件的体积。
# 1. 客户端方式触发重写
执行 BGREWRITEAOF 命令,不会阻塞redis服务
# 2. 服务器配置方式自动触发
配置redis.conf中的auto-aof-rewrite-percentage选项
如果设置auto-aof-rewrite-percentage的值为100和auto-aof-rewrite-min-size 64mb,并且启动了AOF持久化时,那么当AOF文件体积大于64M,并且AOF文件的体积比上一次重写之后体积大了至少一倍(100%)时会自动触发,如果重写过于频繁,用户可以考虑将auto-aof-rewrite-percentage设置为更大
注意:重写AOF文件的操作,并没有读取旧的AOF文件,而是将整个内存中的数据库内容用命令的方式重写一个新的AOF文件,替换原有的文件,这点和快照有点类似。
# 重写流程
1. redis调用fork,现在有父子两个进程,子进程根据内存中的数据库生成快照,往临时文件中写入重建数据库状态的命令
2. 父进程继续处理客户端请求,除了把写命令写入到原来的aof文件中,同时把收到的写命令缓存起来。这样就能保证如果子进程重写失败的话并不会出现问题
3. 当子进程把快照内容以命令方式写入到临时文件后,子进程发信号通知父进程。然后父进程把缓存的写命令也写入到临时文件
4. 现在父进程可以使用临时文件替换老的aof文件并重命名,后面收到的写命令也开始往新的aof文件中追加
其实非常简单,只需要思考一下,RDB和AOF 谁的数据更全?
我们都是知道AOF是基于命令追加,,而RDB是基于快照,根据策略每隔一段时间保存一份数据快照,相比较之下,AOF更新频率更,数据更加完整,所以如果AOF和RDB同时存在的时候,Redis会优先使用从AOF文件来还原数据库状态,如果AOF关闭状态时,则从RDB中恢复。
两种持久化方案既可以同时使用,又可以单独使用,在某种情况下也可以都不使用,具体使用哪种持久化方案取决于用户的数据和应用决定。
无论使用AOF还是RDB持久化,将数据持久化到硬盘都是有必要的。除了持久化外,用户还应该对持久化的文件进行备份。
<!-- 引入jedis连接依赖 -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.3.0</version>
</dependency>
public class RedisDemo {
public static void main(String[] args) {
// 创建 jedis 客户端对象
// 如果连接失败,请检查redis配置文件的bind,默认是127.0.0.1,只能接受本机的访问请求
Jedis jedis = new Jedis("192.168.116.128", 6379);
// 选择一个库,默认是0
jedis.select(0);
// 获取redis中所有的key信息
Set<String> keys = jedis.keys("*");
keys.forEach(key -> System.out.println("key = " + key));
// 操作库相关
//jedis.flushDB(); // 清空当前库
//jedis.flushAll(); // 清空所有库
// 释放资源
jedis.close();
}
}
注意:如果连接失败,请检查redis配置文件的bind,默认是127.0.0.1,只能接受本机的访问请求
public class KeyDemo {
private Jedis jedis;
@Before
public void before() {
// 创建 jedis 客户端对象
this.jedis = new Jedis("192.168.116.128", 6379);
}
@After
public void after() {
// 释放资源
this.jedis.close();
}
// 测试key相关
@Test
public void testKeys() {
// 设置一个key
System.out.println(jedis.set("name", "ray")); // OK
// 获取一个key
System.out.println(jedis.get("name")); // ray
// 判断key是否存在
System.out.println(jedis.exists("name")); // true
// 删除一个key
System.out.println(jedis.del("name")); // 1
System.out.println("==============================");
System.out.println(jedis.set("age", "18")); // OK
// 设置一个key的超时时间
System.out.println(jedis.expire("age", 10)); // 1
// 获取一个key的超时时间
System.out.println(jedis.ttl("age")); // 10
}
}
public class StringDemo {
private Jedis jedis;
@Before
public void before() {
// 创建 jedis 客户端对象
this.jedis = new Jedis("192.168.116.128", 6379);
}
@After
public void after() {
// 清空当前表
this.jedis.flushDB();
// 释放资源
this.jedis.close();
}
// 测试String相关
@Test
public void test1() {
// 设置key和value
System.out.println(jedis.set("k1", "v1")); // OK
// 根据key获取值
System.out.println(jedis.get("k1")); // v1
// 往key追加value
System.out.println(jedis.append("k1", "hello")); // 7
// 根据key获取值
System.out.println(jedis.get("k1")); // v1hello
// 如果key不存在,相当于set
System.out.println(jedis.append("k2", "v2")); // 2
// 根据key获取值
System.out.println(jedis.get("k2")); // v2
// 返回字符串的长度
System.out.println(jedis.strlen("k1")); // 7
// 设置key和value
System.out.println(jedis.set("views", "0")); // OK
// 自增1
System.out.println(jedis.incr("views")); // 1
// 根据key获取值
System.out.println(jedis.get("views")); // 1
// 自减1
System.out.println(jedis.decr("views")); // 0
// 根据key获取值
System.out.println(jedis.get("views")); // 0
// 指定增加步长
System.out.println(jedis.incrBy("views", 10)); // 10
// 指定减去步长
System.out.println(jedis.decrBy("views", 10)); // 0
// 根据key获取值
System.out.println(jedis.get("views")); // 0
}
@Test
public void test2() {
// 如果 key 不存在,返回 null
System.out.println(jedis.getSet("db", "redis")); // null
// 设置 key 和 value
System.out.println(jedis.set("db", "redis")); // OK
// 根据 key 获取值
System.out.println(jedis.get("db")); // redis
// 如果 key 存在,获取旧值,并设置新值
System.out.println(jedis.getSet("db", "mongodb")); // redis
// 根据 key 获取值
System.out.println(jedis.get("db")); // mongodb
}
}
package com.ray.demo;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.ListPosition;
import java.util.List;
/**
* @Description: 测试 redis List
* @Author Administrator
* @Date 2020/11/28 17:19
* @Version 1.0
*/
public class ListDemo {
private Jedis jedis;
@Before
public void before() {
// 创建 jedis 客户端对象
this.jedis = new Jedis("192.168.116.128", 6379);
}
@After
public void after() {
// 清空当前表
this.jedis.flushDB();
// 释放资源
this.jedis.close();
}
// 测试List相关
@Test
public void test1() {
// 在队列左侧插入一个
System.out.println(jedis.lpush("list", "one")); // 1
// 在队列左侧插入多个
System.out.println(jedis.lpush("list", "two", "three")); // 3
// 获取list区间的值,-1代表最后一位
List<String> lrange = jedis.lrange("list", 0, -1);
lrange.forEach(v -> System.out.println("v = " + v));
// 在队列右侧插入一个
System.out.println(jedis.rpush("list", "zero")); // 4
// 通过下标获取值
System.out.println(jedis.lindex("list", 3)); // zero
// 移除头元素
System.out.println(jedis.lpop("list")); // three
// 移除列表1个zero
System.out.println(jedis.lrem("list", 1, "zero")); // 1
// 返回长度
System.out.println(jedis.llen("list")); // 2
}
@Test
public void test2() {
// # 在队列左侧插入多个
System.out.println(jedis.lpush("list", "v1", "v2", "v3", "v4")); // 4
// 获取list区间的值,-1代表最后一位
List<String> lrange = jedis.lrange("list", 0, -1);
lrange.forEach(v -> System.out.println("v = " + v));
// 移除列表的最后一个元素,添加到新的列表中
System.out.println(jedis.rpoplpush("list", "mylist")); // v1
// 获取list区间的值,-1代表最后一位
List<String> lrange2 = jedis.lrange("list", 0, -1);
System.out.println(lrange2.size()); // 3
// 获取list区间的值,-1代表最后一位
List<String> lrange3 = jedis.lrange("mylist", 0, -1);
System.out.println(lrange3.size()); // 1
// 将值v0插入到列表mylist中值为v1的前面
System.out.println(jedis.linsert("mylist", ListPosition.BEFORE, "v1", "v0")); // 2
// 获取list区间的值,-1代表最后一位
List<String> mylist = jedis.lrange("mylist", 0, -1);
mylist.forEach(v -> System.out.println("v = " + v));
}
}
public class SetDemo {
private Jedis jedis;
@Before
public void before() {
// 创建 jedis 客户端对象
this.jedis = new Jedis("192.168.116.128", 6379);
}
@After
public void after() {
// 清空当前表
this.jedis.flushDB();
// 释放资源
this.jedis.close();
}
// 测试Set相关
@Test
public void test1() {
// 添加单个元素
System.out.println(jedis.sadd("set", "v1")); // 1
// 添加多个元素
System.out.println(jedis.sadd("set", "v2", "v3", "v4", "v4")); // 3
// 返回集合所有成员
Set<String> set = jedis.smembers("set");
set.forEach(v -> System.out.println("v = " + v));
// 判断集合 list 是否包含 v2 元素
System.out.println(jedis.sismember("set", "v2")); // true
// 返回集合 list 中元素的数量
System.out.println(jedis.scard("set")); // 4
// 返回集合中的一个随机元素
System.out.println(jedis.srandmember("set")); // v2
// 随机移除一个元素
System.out.println(jedis.spop("set")); // v4
}
}
public class HashDemo {
private Jedis jedis;
@Before
public void before() {
// 创建 jedis 客户端对象
this.jedis = new Jedis("192.168.116.128", 6379);
}
@After
public void after() {
// 清空当前表
this.jedis.flushDB();
// 释放资源
this.jedis.close();
}
// 测试Hash相关
@Test
public void test1() {
// 设置单个元素
System.out.println(jedis.hset("myhash", "name", "ray")); // 1
// 返回指定的值
System.out.println(jedis.hget("myhash", "name")); // ray
// 设置多个元素
Map<String, String> values = new HashMap<>();
values.put("age", "18");
values.put("address", "gd");
System.out.println(jedis.hset("myhash", values)); // 2
// 返回所有的值
Map<String, String> myhash = jedis.hgetAll("myhash");
myhash.forEach((k,v) -> System.out.println("k = " + k + ", v = " + v));
// 返回数量
System.out.println(jedis.hlen("myhash"));
// 返回key中的所有域
Set<String> keys = jedis.hkeys("myhash");
keys.forEach(k -> System.out.println("k = " + k));
// 返回key中所有的值
List<String> vals = jedis.hvals("myhash");
vals.forEach(v -> System.out.println("v = " + v));
}
}
public class ZsetDemo {
private Jedis jedis;
@Before
public void before() {
// 创建 jedis 客户端对象
this.jedis = new Jedis("192.168.116.128", 6379);
}
@After
public void after() {
// 清空当前表
this.jedis.flushDB();
// 释放资源
this.jedis.close();
}
// 测试Zset相关
@Test
public void test1() {
// 添加一个值
System.out.println(jedis.zadd("myset", 1.0, "one")); // 1
// 添加多个值
Map<String, Double> map = new HashMap<>();
map.put("two", 2.0);
map.put("three", 3.0);
System.out.println(jedis.zadd("myset", map)); // 2
// 返回有序集 key 中,指定区间内的成员
Set<String> zrange = jedis.zrange("myset", 0, -1);
zrange.forEach(x -> System.out.println("x = " + x));
// 返回 score 值
System.out.println(jedis.zscore("myset", "one")); // 1.0
// 为 score 值加上增量
System.out.println(jedis.zincrby("myset", 99.0, "one")); // 100.0
// 返回 score 值
System.out.println(jedis.zscore("myset", "one")); // 100.0
// 返回有序集 key 的基数
System.out.println(jedis.zcard("myset")); // 3
// 计算 1-10 之间的人数
System.out.println(jedis.zcount("myset", 1, 10)); // 2
// 显示所有成员及其 score 值
Set<Tuple> myset = jedis.zrangeWithScores("myset", 0, -1);
myset.forEach(v -> System.out.println("v = " + v));
}
}