24 redis常用数据结构命令及代码实现

vvEcho 2025-03-10 16:36:19
Categories: Tags:

string常用命令及代码操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
SET key value # 设置单个字段
SETEX key seconds value # 设置键值及过期时间(秒)
SETNX key value # 原子操作 1:键不存在且设置成功。0:键已存在,未执行操作
SET key value NX EX seconds # Redis 2.6.12+ 的 SET 命令支持原子性设置键值及过期时间
MSET key1 value1 key2 value2 ... # 原子性设置多个键值对
APPEND key value # 向现有值末尾追加内容

DEL key1 key2 ... # 删除一个或多个值

EXPIRE key seconds # 修改键值的过期时间
INCR key / DECR key # 原子性增减数值,适用于计数器或库存的扣减

GET key # 获取键对应的值,不存在返回null
MGET key1 key2 ... # 获取多个键的值列表
GETSET key new_value # 获取旧值并设置新值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
jedis.set("username", "Alice");  // 设置键为 username,值为 Alice
jedis.setex("temp_token", 300, "abc123"); // 有效期 5 分钟
Long result = jedis.setnx("counter", "0"); // 条件设置(仅当键不存在时)
jedis.mset("key1", "val1", "key2", "val2"); // 方式1:参数列表
// 或使用 Map
Map<String, String> data = new HashMap<>();
data.put("key3", "val3");
data.put("key4", "val4");
jedis.mset(data);
jedis.append("log", "new_message"); // 返回追加后的字符串长度

jedis.del("temp_token"); // 删除单个键
jedis.del("key1", "key2"); // 删除多个键

jedis.expire("session_id", 1800); // 30 分钟后过期

jedis.incr("page_view"); // 自增1
jedis.decrBy("stock", 5); // 自减5

String value = jedis.get("username");
System.out.println(value); // 输出:Alice
List<String> values = jedis.mget("key1", "key2");
String oldVal = jedis.getSet("counter", "100"); // 原子操作

hash常用命令及代码操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
HSET key field value
HSET user:1001 name "Alice" # 示例:设置用户1001的name为"Alice"

HDEL key field1 field2 ...
HDEL user:1001 email # 示例:删除用户1001的email字段

HGET key field
HGET user:1001 name # 示例:获取用户1001的name
HGETALL key
HGETALL user:1001 # 示例:获取用户1001全部信息
HKEYS key # 示例:HKEYS user:1001 → ["name", "age"]
HVALS key # 示例:HVALS user:1001 → ["Alice", "25"]

HINCRBY key field increment
HINCRBY user:1001 age 1 # 示例:用户年龄+1
HEXISTS key field # 存在返回1,否则0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// 引入依赖:Jedis 3.6.1+
Jedis jedis = new Jedis("localhost", 6379);

// 设置单个字段
jedis.hset("user:1001", "name", "Alice");

// 批量设置字段
Map<String, String> fields = new HashMap<>();
fields.put("age", "25");
fields.put("email", "alice@example.com");
jedis.hset("user:1001", fields); // 或 jedis.hmset("user:1001", fields);


// 获取单个字段值
String name = jedis.hget("user:1001", "name"); // → "Alice"
// 获取所有字段及值
Map<String, String> userData = jedis.hgetAll("user:1001");
// → {name=Alice, age=25, email=alice@example.com}
// 获取所有字段名
Set<String> fields = jedis.hkeys("user:1001"); // → [name, age, email]

// 删除单个字段
jedis.hdel("user:1001", "email");
// 删除多个字段
jedis.hdel("user:1001", "age", "name");

// 数值递增
jedis.hincrBy("user:1001", "age", 1); // age → 26
// 判断字段是否存在
boolean exists = jedis.hexists("user:1001", "email"); // → false

// 使用 Spring Data Redis
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// 对象转Hash存储
User user = new User(1001, "Alice", 25);
redisTemplate.opsForHash().putAll("user:1001", new Jackson2HashMapper(true).toHash(user));
// Hash转对象查询
Map<Object, Object> userMap = redisTemplate.opsForHash().entries("user:1001");
User user = (User) new Jackson2HashMapper(true).fromHash(userMap);

list常用命令及代码操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
LPUSH key value [value ...] #从列表左侧(头部)插入一个或多个元素
RPUSH key value [value ...] #从列表右侧(尾部)插入一个或多个元素
LINSERT key BEFORE|AFTER pivot value #在指定元素 pivot 的前或后插入新元素

LPOP key #移除并返回列表左侧的第一个元素
RPOP key #移除并返回列表右侧的最后一个元素
LREM key count value #删除指定数量的匹配元素(count>0 从左删,count<0 从右删,count=0 全删)
LTRIM key start stop #截取列表保留指定范围内的元素

LSET key index value #通过索引修改指定位置的元素值

LRANGE key start stop #获取指定索引范围内的元素(0 到 -1 表示全部)
LINDEX key index #通过索引获取单个元素
LLEN key #获取列表长度
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Jedis jedis = new Jedis("localhost", 6379);
// 左侧插入多个元素
jedis.lpush("list1", "A", "B", "C"); // 结果:C -> B -> A
// 右侧插入单个元素
jedis.rpush("list1", "D"); // 结果:C -> B -> A -> D
// 在元素 "A" 后插入 "X"
jedis.linsert("list1", ListPosition.AFTER, "A", "X");

// 删除左侧第一个元素
String left = jedis.lpop("list1");
// 删除右侧最后一个元素
String right = jedis.rpop("list1");
// 删除所有值为 "B" 的元素
jedis.lrem("list1", 0, "B");
// 保留索引 0~2 的元素
jedis.ltrim("list1", 0, 2);

// 修改索引为 1 的元素为 "NewValue"
jedis.lset("list1", 1, "NewValue");

// 查询所有元素
List<String> all = jedis.lrange("list1", 0, -1);
// 查询索引为 0 的元素
String first = jedis.lindex("list1", 0);
// 获取列表长度
Long length = jedis.llen("list1");

set常用命令及代码操作

1
2
3
4
5
6
7
SADD myset "apple" "banana" "cherry"  # 返回成功添加的数量
SREM myset "apple" "unknown" # 返回实际删除的数量(例如:1)
SMEMBERS myset # 返回 ["banana", "cherry"]
SISMEMBER myset "apple" # 返回 0(不存在)
SINTER key1 key2 # 返回多个集合的交集。
SUNION key1 key2 # 返回多个集合的并集。
SDIFF key1 key2 # 返回第一个集合与其他集合的差集
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Long count = jedis.sadd("myset", "apple", "banana", "cherry");
System.out.println("新增元素数量:" + count); // 输出:3

Long removed = jedis.srem("myset", "apple", "unknown");
System.out.println("删除元素数量:" + removed); // 输出:1

Set<String> members = jedis.smembers("myset");
boolean exists = jedis.sismember("myset", "apple");
System.out.println("集合元素:" + members); // 输出:[banana, cherry]
System.out.println("元素是否存在:" + exists); // 输出:false

Set<String> inter = jedis.sinter("set1", "set2");
Set<String> union = jedis.sunion("set1", "set2");
Set<String> diff = jedis.sdiff("set1", "set2");
System.out.println("交集:" + inter);

zet常用命令及代码操作

1
2
3
4
5
6
7
8
9
# zset
ZADD key [NX|XX] [CH] [INCR] score member [score member ...] #新增
ZREM key member [member ...] #删除指定成员
ZINCRBY key increment member #调整成员分数(若成员不存在则新增)
ZRANGE key start stop [WITHSCORES] #按索引范围查询(正序)。
ZREVRANGE key start stop [WITHSCORES] #按索引范围逆序查询。
ZRANGEBYSCORE key min max [WITHSCORES] #按分数范围查询。
ZRANK key member #获取成员正序排名;
ZREVRANK #获取逆序排名
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 单条插入
Long res = jedis.zadd("zsetKey", 1.0, "member1");
// 批量插入
Map<String, Double> scoreMap = new HashMap<>();
scoreMap.put("member2", 2.0);
scoreMap.put("member3", 3.0);
Long count = jedis.zadd("zsetKey", scoreMap);

// 删除成员
Long res1 = jedis.zrem("zsetKey", "member1");
// 按排名删除前2名
Long res2 = jedis.zremrangeByRank("zsetKey", 0, 1);
// 按分数删除0-2分的成员
Long res3 = jedis.zremrangeByScore("zsetKey", 0, 2);

// 调整成员分数
Double newScore = jedis.zincrby("zsetKey", 5.0, "member1");


// 查询前3名(正序)
Set<String> members = jedis.zrange("zsetKey", 0, 2);
// 查询分数在1-3之间的成员(带分数)
Set<Tuple> scores = jedis.zrangeByScoreWithScores("zsetKey", 1, 3);
// 获取成员排名
Long rank = jedis.zrank("zsetKey", "member1");