Redis支持5种数据类型：
string 字符串
hash 哈希
list 列表
set 集合
zset 有序集合

一、 string
是 redis 最基本的类型，你可以理解成与 Memcached 一模一样的类型，一个 key 对应一个 value。value其实不仅是String，也可以是数字。

使用场景：常规key-value缓存应用。常规计数: 微博数, 粉丝数。

二、Hash
是一个键值(key => value)对集合。Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。

应用场景：我们简单举个实例来描述下Hash的应用场景，比如我们要存储一个用户信息对象数据，包含以下信息：

用户ID为查找的key，存储的value用户对象包含姓名，年龄，生日等信息，如果用普通的key/value结构来存储，主要有以下2种存储方式：

第一种方式将用户ID作为查找key,把其他信息封装成一个对象以序列化的方式存储，这种方式的缺点是，增加了序列化/反序列化的开销，并且在需要修改其中一项信息时，需要把整个对象取回，并且修改操作需要对并发进行保护，引入CAS等复杂问题。

第二种方法是这个用户信息对象有多少成员就存成多少个key-value对儿，用用户ID+对应属性的名称作为唯一标识来取得对应属性的值，虽然省去了序列化开销和并发问题，但是用户ID为重复存储，如果存在大量这样的数据，内存浪费还是非常可观的。

三、list 有序的可以重复集合；
列表是简单的字符串列表，按照插入顺序排序。
应用场景：Redis list的应用场景非常多，也是Redis最重要的数据结构之一，比如twitter的关注列表，粉丝列表等都可以用Redis的list结构来实现。

四、set 无序 不可以重复集合，适合买东西限定一人一单的场景。
是string类型的无序集合。集合是通过hashtable实现的，概念和数学中个的集合基本类似，可以交集，并集，差集等等，set中的元素是没有顺序的。所以添加，删除，查找的复杂度都是O(1)。

应用场景：Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。

五、zset 适合积分排序的场景， 用score 控制；
和 set 一样也是string类型元素的集合,且不允许重复的成员。 zadd 命令：添加元素到集合，元素在集合中存在则更新对应score。 常用命令：zadd,zrange,zrem,zcard等

使用场景：Redis sorted set的使用场景与set类似，区别是set不是自动有序的，而sorted set可以通过用户额外提供一个优先级(score)的参数来为成员排序，并且是插入有序的，即自动排序。
————————————————
版权声明：本文为CSDN博主「kun_ser」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/kun_ers/article/details/125464188

String类型

1.设置当前的key以及value

redisTemplate.opsForValue().set(key, value);


 2.增减指定key的vaue值（正值则自增，负值则自减）

方式一:可同时修改value值

redisTemplate.opsForValue().increment(key, increment);

方式二:只对key存活时间操作

redisTemplate.expire(key,timeout,timeUnit);


 3.设置当前的key以及value值并且设置过期时间

redisTemplate.opsForValue().set(key, value, timeout, timeunit)
/*
timeunit使用
TimeUnit.DAYS //天
TimeUnit.HOURS //小时
TimeUnit.MINUTES //分钟
TimeUnit.SECONDS //秒
TimeUnit.MILLISECONDS //毫秒
*/


 4.判断指定key是否存在(存在返回true,相反返回false)

Boolean key= redisTemplate.hasKey(key);


5.判断添加key及value，如果key存则返回false无效操作，否则返回true进行添加 

redisTemplate.opsForValue().setIfAbsent(key, value);


6. 将指定key赋新的value并返回其该key原先的value

redisTemplate.opsForValue().getAndSet(key, value);


7.追加指定key的value字符串值

redisTemplate.opsForValue().append(key, value);


8.获取指定字符串的长度

redisTemplate.opsForValue().size(key);


 9.1将map集合添加到redis中

解释:map的key-value对应redis中key-value(支持批添)
redisTemplate.opsForValue().multiSet(map);

9.2对应的map集合名称不存在，则添加否则不做修改

redisTemplate.opsForValue().multiSetIfAbsent(valueMap); 
key存在返回false(无效操作) 效果图


key不存在,返回true,执行成功效果图


10.返回指定key所存储的值的类型

DataType keyType= redisTemplate.type(key);


11.修改指定key的名称

redisTemplate.rename(oldKey,newKey);


12. 判断key是否存在，存在则修改key名,不存在则报错

 redisTemplate.renameIfAbsent(oldKey,newKey);


13. 删除指定key

redisTemplate.delete(key);


14.返回指定key所对应的剩余过期时间

方式一:以秒为单位返回剩余生存时间

Long name = redisTemplate.getExpire(key);


方式二:指定返回时间单位(秒/分钟/小时/天) 

Long name = redisTemplate.getExpire(key,timeunit);
/*
TimeUnit.DAYS //天
TimeUnit.HOURS //小时
TimeUnit.MINUTES //分钟
TimeUnit.SECONDS //秒
TimeUnit.MILLISECONDS //毫秒
*/


15:设置指定key永久保护,移除存活时间 

redisTemplate.persist(key);


16.将指定的key从当前(移除)数据库移动到指定redis中数据库当中

redisTemplate.move(key, dbIndex)

List类型

1.1向指定list的队列头部添加value

redisTemplate.opsForList().leftPush(key, value)


 1.2向指定list的队列头部批量添加value

redisTemplate.opsForList().leftPushAll(key, value1 [value,...])


2.向指定list的队列尾部添加value

redisTemplate.opsForList().rightPush(key,value);


 2.2向指定list的队列尾部批量添加value 

redisTemplate.opsForList().rightPushAll(key, value1 [value,...])


3.通过索引获取指定key的value

Object value= redisTemplate.opsForList().index(key,index);


4.获取指定key指定范围内的value(start开始位置, 0是开始位置，end 结束位置, -1返回所有)

List list = redisTemplate.opsForList().range(key, startindex, endindex);


 返回所有



5.判断List是否存在,存在则向指定key的(头部/尾部)添加单个value(不存在则无效操作)

redisTemplate.opsForList().leftPushIfPresent(key,value)
redisTemplate.opsForList().rightPushIfPresent(key,value)


6.设置指定索引处指定key的value(覆盖旧值)

redisTemplate.opsForList().set(key, index, value)


 7.移除并获取指定list中(队列-头部/尾部)第一个元素

如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
Object list = redisTemplate.opsForList().leftPop(key);
Object list2 = redisTemplate.opsForList().rightPop(key);


8. 将一个队列的右边弹出一个元素并将这个元素放入另一个指定队列的最左边

redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey)


9.删除指定key集合中值等于value的元素

index=0, 删除所有值等于value的元素
index>0, 从头部开始删除第一个值等于value的元素
index<0, 从尾部开始删除第一个值等于value的元素
redisTemplate.opsForList().remove(key, index, value)
10.剪裁指定key(list列表)

redisTemplate.opsForList().trim(key, start, end)


11.获取指定key(List列表)长度

redisTemplate.opsForList().size(key)

Set类型

1.向指定key(set)中添加元素(支持批添)

redisTemplate.opsForSet().add(key, value [value,...])


2.移除指定key(set)的元素(单个、多个)

redisTemplate.opsForSet().remove(key, value [value,...])


3.获取指定key(集合)的元素个数

redisTemplate.opsForSet().size(key)


4.判断指定set集合是否包含value(包含返回true,不包含返回false)

redisTemplate.opsForSet().isMember(key, value)


5.获取两个集合的交集(key对应的无序集合与otherKey对应的无序集合共同拥有的元素)

redisTemplate.opsForSet().intersect(key, otherKey)


6.将key集合与otherKey集合的交集存储到destKey集合中(其中otherKey可以为单个值或者集合)

redisTemplate.opsForSet().intersectAndStore(key, otherKey, destKey)


7.获取两个或者多个集合的并集(otherKeys可以为单个值或者是集合)

redisTemplate.opsForSet().union(key, otherKeys)


8.key集合与otherKey集合的并集存储到destKey中(otherKeys可以为单个值或者是集合)

redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey)


9.获取两个或者多个集合的差集(otherKeys可以为单个值或者是集合)

redisTemplate.opsForSet().difference(key, otherKeys)
获取key中otherKeys没有的元素 


10.将key和otherKets差集存储到destKey中(otherKeys可以为单个值或者集合)

redisTemplate.opsForSet().differenceAndStore(key, otherKey, destKey)


11.获取指定(key)集合中的所有元素

redisTemplate.opsForSet().members(key)


12.随机获取集合中任意(count)个元素

redisTemplate.opsForSet().randomMembers(key, count)


13.随机获取集合中的一个元素

redisTemplate.opsForSet().randomMember(key)

ZSet类型

ZSetOperations提供了一系列方法对有序集合进行操作
1.1添加元素(有序集合是按照元素的score值由小到大进行排列)

redisTemplate.opsForZSet().add(key, value, score)


2.删除指定key对应的value(value可以为多个值)

redisTemplate.opsForZSet().remove(key, value ,[value ...])


3.增加指定key(zset)元素value的score值，并返回增加后的值

redisTemplate.opsForZSet().incrementScore(key, value, delta)


4.返回指定key(zset)元素在集合的排名

有序集合是按照元素的score值由小到大排列(返回下标)
redisTemplate.opsForZSet().rank(key, value)


5.返回指定key(zset)元素在集合的排名

按元素的score值由大到小排列(返回下标)
redisTemplate.opsForZSet().reverseRank(key, value)


6.获取指定集合中给定区间(下标)的元素 

(start 开始位置，end 结束位置, -1查询所有)
(仅显示value,不显示score,下一个显示score)
score由小到大显示

redisTemplate.opsForZSet().range(key, start,end)


 score由大到小显示

redisTemplate.opsForZSet().reverseRange(key, start,end)


7.获取指定集合按照Score值范围查询集合中的元素+score

查询min~max之间的score元素
score从小到大排序

Set<ZSetOperations.TypedTuple<Object>> zset = redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);


score结果从大到小排序

Set<ZSetOperations.TypedTuple<Object>> zset = redisTemplate.opsForZSet().reverseRangeByScore(key, min, max)


8.获取指定集合按score从高到底指定score与下标范围内的元素

score范围内 min~max
strat~end下标范围内
按score从高到底获取
redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, start, end)


9.获取指定集合的score范围内的元素数量

 Long count= redisTemplate.opsForZSet().count(key, min, max)


10.获取指定集合的大小(元素个数)

Long count= redisTemplate.opsForZSet().size(key)


11.获取集合中key、value元素对应的score值

redisTemplate.opsForZSet().score(key, value)


12.删除指定索引区间范围内的所有元素

start 开始位置，end 结束位置, -1查询所有
redisTemplate.opsForZSet().removeRange(key, start, end)


13.移除指定score范围的集合成员

redisTemplate.opsForZSet().removeRangeByScore(key, min, max)


14.获取key和otherKey的并集并存储在destKey中

otherKeys可以为单个字符串或者字符串集合
redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey)


15.获取key和otherKey的交集并存储在destKey中

其中otherKeys可以为单个字符串或者字符串集合
redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey)


16.遍历指定集合（和iterator一模一样）

获取value和score
Cursor<ZSetOperations.TypedTuple<Object>> scan = opsForZSet.scan(key, ScanOptions.NONE);
while (scan.hasNext()){
    ZSetOperations.TypedTuple<Object> next= scan.next();
    System.out.println(next.getValue() + ":" + next.getScore());
}

Hash类型

1.新增hashMap值

方式一:单个添加key-value

redisTemplate.opsForHash().put(key, hashKey, value)


 方式二:批量添加key-value

redisTemplate.opsForHash().putAll(key, maps);


方式三:仅当hashKey不存在时才设置 

redisTemplate.opsForHash().putIfAbsent(key, hashKey, value)


2.获取变量中的键值对

redisTemplate.opsForHash().entries(key)


3.获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null。

redisTemplate.opsForHash().get(key, field)


4.使指定hash中的键以long值的大小进行自增长。

redisTemplate.opsForHash().increment(H key, HK hashKey, long delta)


5.删除指定hash中一个或者多个键

redisTemplate.opsForHash().delete(key, fields)


6.判断指定hash中是否有指定的map键

redisTemplate.opsForHash().hasKey(key, field);


7.给指定哈希表key中的指定键的整数/小数值加上增量increment

redisTemplate.opsForHash().increment(key, field, increment);


8.获指定hash中所有键

redisTemplate.opsForHash().keys(key)


9.获取hash表中存在的所有的值

redisTemplate.opsForHash().values(key);


10.获取指定hash表中键的数量

redisTemplate.opsForHash().size(key)


11.Scan匹配获取键值对

方式一:ScanOptions.NONE为获取全部键对

Cursor<Map.Entry<Object,Object>> cursor = redisTemplate.opsForHash().scan("Goods",ScanOptions.NONE);
        while (cursor.hasNext()){
            Map.Entry<Object,Object> next = cursor.next();
            System.out.println(next.getKey() + ":" + next.getValue());
        }
方式二:ScanOptions.scanOptions().match("price").build() 匹配获取键位map1的键值对,不能模糊匹配

Cursor<Map.Entry<Object,Object>> cursor = redisTemplate.opsForHash().scan("Goods",ScanOptions.scanOptions().match("price").build());
        while (cursor.hasNext()){
            Map.Entry<Object,Object> next = cursor.next();
            System.out.println(next.getKey() + ":" + next.getValue());
        }
 

————————————————
版权声明：本文为CSDN博主「北九二七」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_62866192/article/details/121438008