RedisTemplate相关API
文章目录1. 字符串(String)相关API1.1 新增一个键值对 : set(K key, V value)1.2 设置变量值并设置过期时间 : set(K key, V value, long timeout, TimeUnit unit)1.3源码:1. 字符串(String)相关API1.1 新增一个键值对 : set(K key, V value)@Testpublic void te
·
文章目录
- 0. 通用API
- 0.1 hasKey(K key) : 判断是否有key所对应的值，有则返回true，没有则返回false
- 0.2 delete(K key) : 删除单个key值
- 0.3 delete(Collection keys) : 批量删除key
- 0.4 dump(K key) : 将当前传入的key值序列化为byte[]类型
- 0.5 expire(K key, long timeout, TimeUnit unit) : 设置过期时间
- 0.6 expireAt(K key, Date date) : 设置过期时间(指定具体时间)
- 0.7 keys(K pattern) : 查找匹配的key值，返回一个Set集合类型
- 0.8 rename(K oldKey, K newKey) : 修改redis中key的名称
- 0.9 type(K key) : 返回传入key所存储的值的类型
- 0.10 renameIfAbsent(K oldKey, K newKey) : 如果旧键存在时，将旧键名称改为新键名称并且返回true,如果不存在就会抛出异常
- 0.11 randomKey() : 从redis中随机取出一个key
- 0.12 getExpire(K key) : 返回当前key所对应的剩余过期时间
- 0.13 getExpire(K key, TimeUnit timeUnit) : 返回剩余过期时间并且指定时间单位
- 0.14 persist(K key) : 将key持久化保存
- 0.15 move(K key, int dbIndex) : 将当前数据库的key移动到指定redis中数据库当中
- 1. 字符串(String)相关API
- 1.1 set(K var1, V var2) : 新增一个键值对
- 1.2 set(K var1, V var2, long var3, TimeUnit var4) : 设置变量值并设置过期时间
- 1.3 set(K key, V value, Duration timeout) : 设置变量值并设置过期时间
- 1.4 get(Object var1) : 获取指定key对应的值
- 1.5 get(K var1, long var2, long var3) : 获取var1键所对应的值从var2位置开始到var3位置之间的字符串
- 1.6 append(K var1, String var2) : 在原有的值基础上新增字符串到末尾
- 1.7 getAndSet(K var1, V var2) : 将旧的key设置为value，并且返回旧的key
- 1.8 size(K var1) : 获取键对应值的长度
- 1.9 setIfAbsent(K var1, V var2) : 如果键不存在则新增,存在则不改变已经有的值如果键不存在则新增,存在则不改变已经有的值
- 1.10 setBit(K var1, long var2, boolean var3) : var1键对应的值var2对应的ascii码,在offset的位置(从左向右数)变为var3
- 1.11 getBit(K var1, long var2) : 判断指定的位置ASCII码的bit位是否为1
- 1.12 increment(K var1, long/double var2) : 以增量的方式将double值存储在变量中
- 1.13 set(K var1, V var2, long var3) : 覆盖从指定位置开始的值(用 var2 参数覆写给定 var1 所储存的字符串值，从偏移量 var3 开始)
- 1.14 get(K var1, long var2, long var3) : 返回键中指定索引区间内的值
- 1.15 multiGet(Collection var1) : 批量获取值
- 1.16 multiSet(Map<? extends K, ? extends V> var1) : 设置map集合到redis
- 1.17 multiSetIfAbsent(Map<? extends K, ? extends V> var1) : 如果对应的map集合名称不存在，则添加否则不做修改(有一个值存在所有的都不做修改)
- 2. Hash相关API
- 2.1 put(H var1, HK var2, HV var3) : 新增hashMap值
- 2.2 values(H var1) : 获取hash表中存在的所有的值
- 2.3 entries(H var1) : 获取变量中的键值对
- 2.4 get(H var1, Object var2) : 获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null
- 2.5 hasKey(H var1, Object var2) : 判断变量中是否有指定的map键,有就返回true,没有就返回false
- 2.6 keys(H var1) : 获取变量中的键
- 2.7 size(H var1) : 获取变量的长度
- 2.8 increment(H var1, HK var2, long/double var3) : 使变量中的键以long/double值的大小进行自增长
- 2.9 multiGet(H var1, Collection var2) : 以集合的方式获取变量中的值
- 2.10 putAll(H var1, Map<? extends HK, ? extends HV> var2) : 以map集合的形式添加键值对
- 2.11 putIfAbsent(H var1, HK var2, HV var3) : 如果变量值存在，在变量中可以添加不存在的的键值对，如果变量不存在，则新增一个变量，同时将键值对添加到该变量
- 2.12 delete(H var1, Object... var2) : 删除变量中的键值对，可以传入多个参数，删除多个键值对
- 2.13 scan(H var1, ScanOptions var2)
- 3. List相关API
- 3.1 leftPush(K var1, V var2) : 在变量左边添加元素值
- 3.2 leftPush(K var1, V var2, V var3) : 如果var2存在就在var2的前面添加var3
- 3.3 index(K var1, long var2) : 获取集合指定位置的值
- 3.4 range(K var1, long var2, long var3) : 获取指定区间的值
- 3.5 leftPushAll(K var1, V... var2) : 向左边批量添加参数元素
- 3.6 leftPushAll(K var1, Collection var2) : 以集合的方式向左边批量添加元素
- 3.7 leftPushIfPresent(K var1, V var2) : 如果存在集合则添加元素
- 3.8 rightPush(K var1, V var2) : 向集合最右边添加元素
- 3.9 rightPush(K key, V pivot, V value) : 向集合中pivot的右边插入值value
- 3.10 rightPushAll(K var1, V... var2) : 向右边批量添加元素
- 3.11 rightPushAll(K var1, Collection var2) : 以集合方式向右边添加元素
- 3.12 rightPushIfPresent(K var1, V var2) : 向已存在的集合中添加元素
- 3.13 size(K var1) : 获取集合长度
- 3.14 leftPop(K var1) : 移除集合中的左边第一个元素
- 3.15 leftPop(K var1, long var2, TimeUnit var3) : 移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出
- 3.16 rightPop(K var1) : 移除集合中的右边第一个元素
- 3.17 rightPop(K var1, long var2, TimeUnit var3) : 移除集合中右边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出
- 3.18 rightPopAndLeftPush(K var1, K var2) : 移除集合中最右边的元素，同时在最左边加入一个元素,返回移除的值
- 3.19 rightPopAndLeftPush(K var1, K var2, long var3, TimeUnit var4) : 移除集合中最右边的元素，同时在最左边加入一个元素,返回移除的值，如果超过等待的时间仍没有元素则退出
- 3.20 set(K var1, long var2, V var3) : 在集合的指定位置插入元素,如果指定位置已有元素，则覆盖，没有则新增,如果索引超过集合的大小会报错
- 3.21 remove(K var1, long var2, Object var4) : 删除集合中值等于value的元素(var2=0, 删除所有值等于var4的元素; var2>0, 从头部开始删除第一个值等于var4的元素; var2<0, 从尾部开始删除第一个值等于var4的元素)
- 3.22 trim(K var1, long var2, long var3) : 截取集合元素长度，保留长度内的数据(相当于对List列表进行剪裁)
- 4. Set相关API
- 4.1 add(K var1, V... var2) : 向变量中批量添加值
- 4.2 members(K var1) : 获取集合中的所有元素
- 4.3 size(K var1) : 获取集合的大小
- 4.4 randomMember(K var1) : 随机获得集合中的元素
- 4.5 randomMembers(K var1, long var2) : 随机获取集合中var2个元素
- 4.6 isMember(K var1, Object var2) : 判断集合是否包含var2,包含返回true,否则返回false
- 4.7 move(K var1, V var2, K var3) : 将原集合中的值移动到目标集合
- 4.8 pop(K var1) : 删除并且返回一个随机的元素
- 4.9 remove(K var1, Object... var2) : 批量移除变量中的元素
- 4.10 scan(K var1, ScanOptions var2) : 匹配值,遍历set类似于Interator
- 4.11 difference(K var1, Collection var2) : 获取两个或者多个集合的差集
- 4.12 difference(K var1, K var2) : 获取两个或者多个集合的差集
- 4.13 differenceAndStore(K var1, Collection var2, K var3) : 将var1与var2 比较的差值存放在var3中
- 4.14 differenceAndStore(K var1, K var2, K var3) : 将var1与var2 比较的差值存放在var3中
- 4.15 distinctRandomMembers(K var1, long var2) : 获取去重的随机元素
- 4.16 intersect(K var1, Collection var2) : 获取set列表和集合的交集
- 4.17 intersect(K var1, K var2) : 获取两个set列表的交集
- 4.18 intersectAndStore(K var1, Collection var2, K var3) : 将set列表和集合的交集存放到另一个set列表中
- 4.19 intersectAndStore(K var1, K var2, K var3) : 将两个set列表的交集存放到另一个set列表中
- 4.20 union(K var1, Collection var2) : 获取set列表和集合的并集
- 4.21 union(K var1, K var2) : 获取两个set列表的并集
- 4.22 unionAndStore(K var1, Collection var2, K var3) : 将set列表和集合的并集存放到另一个set列表中
- 4.23 unionAndStore(K var1, K var2, K var3) : 将另个set列表的并集存放到另一个set列表中
- 5. zSet相关API
链接：https://pan.baidu.com/s/1RuKe1lGAf7z47resAPUp1w
提取码：5prs
0. 通用API
0.1 hasKey(K key) : 判断是否有key所对应的值，有则返回true，没有则返回false
@Test
public void commonTest01(){
/**
* 判断是否有key所对应的值，有则返回true，没有则返回false
* Boolean hasKey(K key)
*/
Boolean result = redisTemplate.hasKey("STRING-SET03");
System.out.println(result);
}
0.2 delete(K key) : 删除单个key值
@Test
public void commonTest02(){
/**
* 删除单个key值
* Boolean delete(K key)
*/
Boolean result = redisTemplate.delete("STRING-SET03");
System.out.println(result);
}
0.3 delete(Collection keys) : 批量删除key
@Test
public void commonTest03(){
List<String> list = new ArrayList<>();
list.add("STRING-SET03");
list.add("STRING-SET04");
list.add("STRING-SET05");
/**
* 批量删除key
* Long delete(Collection<K> keys)
* return : 删除的key的个数
*/
Long result = redisTemplate.delete(list);
System.out.println(result);
}
0.4 dump(K key) : 将当前传入的key值序列化为byte[]类型
@Test
public void commonTest04(){
/**
* 将当前传入的key值序列化为byte[]类型
* byte[] dump(K key)
*/
byte[] dump = redisTemplate.dump("STRING-SET03");
}
0.5 expire(K key, long timeout, TimeUnit unit) : 设置过期时间
@Test
public void commonTest05(){
/**
* 设置过期时间
* Boolean expire(K key, long timeout, TimeUnit unit)
* key : 键
* timeout : 过期时长
* unit : 时长单位
* TimeUnit.SECONDS : 秒
* TimeUnit.MINUTES : 分钟
* TimeUnit.HOURS : 小时
* TimeUnit.DAYS : 天
* TimeUnit.MILLISECONDS : 毫秒
* TimeUnit.NANOSECONDS : 毫微秒
* TimeUnit.MICROSECONDS : 微秒
*/
redisTemplate.expire("STRING-SET5",10, TimeUnit.SECONDS);
}
0.6 expireAt(K key, Date date) : 设置过期时间(指定具体时间)
@Test
public void commonTest06() throws ParseException {
String dateStr = "2020-08-17 22:28:00";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = sdf.parse(dateStr);
/**
* 设置过期时间(指定具体时间)
* Boolean expireAt(K key, Date date)
* key : 键
* date : 具体时间
*/
redisTemplate.expireAt("STRING-SET04",date);
}
0.7 keys(K pattern) : 查找匹配的key值，返回一个Set集合类型
@Test
public void commonTest07(){
/**
* 查找匹配的key值，返回一个Set集合类型
* Set<K> keys(K pattern)
* pattern : 匹配的格式
*/
Set keys = redisTemplate.keys("STRING*");
System.out.println(keys);
}
0.8 rename(K oldKey, K newKey) : 修改redis中key的名称
@Test
public void commonTest08(){
/**
* 修改redis中key的名称
* void rename(K oldKey, K newKey)
* oldKey : 旧的键的名称
* newKey : 新的键的名称
*/
redisTemplate.rename("STRING-SET03","STRING-SET03-new");
}
0.9 type(K key) : 返回传入key所存储的值的类型
@Test
public void commonTest09(){
/**
* 返回传入key所存储的值的类型
* DataType type(K key)
* key : 键
*/
DataType type = redisTemplate.type("STRING-SET02");
System.out.println(type);
}
0.10 renameIfAbsent(K oldKey, K newKey) : 如果旧键存在时，将旧键名称改为新键名称并且返回true,如果不存在就会抛出异常
@Test
public void commonTest10(){
/**
* 如果旧键存在时，将旧键名称改为新键名称并且返回true,如果不存在就会抛出异常
* Boolean renameIfAbsent(K oldKey, K newKey)
* oldKey ; 旧键名称
* newKey : 新键名称
*/
Boolean result = redisTemplate.renameIfAbsent("STRING-SET03-new", "STRING-SET03");
System.out.println(result);
}
0.11 randomKey() : 从redis中随机取出一个key
@Test
public void commonTest11(){
/**
* 从redis中随机取出一个key
* K randomKey()
*/
Object result = redisTemplate.randomKey();
System.out.println(result);
}
0.12 getExpire(K key) : 返回当前key所对应的剩余过期时间
@Test
public void commonTest12(){
/**
* 返回当前key所对应的剩余过期时间
* Long getExpire(K key)
*/
Long expire = redisTemplate.getExpire("STRING-SET05");
System.out.println(expire);
}
0.13 getExpire(K key, TimeUnit timeUnit) : 返回剩余过期时间并且指定时间单位
@Test
public void commonTest13(){
/**
* 返回剩余过期时间并且指定时间单位
* Long getExpire(K key, TimeUnit timeUnit)
* key : 键
* timeUnit : 时间单位
* TimeUnit.SECONDS : 秒
* TimeUnit.MINUTES : 分钟
* TimeUnit.HOURS : 小时
* TimeUnit.DAYS : 天
* TimeUnit.MILLISECONDS : 毫秒
* TimeUnit.NANOSECONDS : 毫微秒
* TimeUnit.MICROSECONDS : 微秒
*/
Long expire = redisTemplate.getExpire("STRING-SET05", TimeUnit.SECONDS);
System.out.println(expire);
}
0.14 persist(K key) : 将key持久化保存
@Test
public void commonTest14(){
/**
* 将key持久化保存
* Boolean persist(K key)
*/
redisTemplate.persist("STRING-SET05");
}
0.15 move(K key, int dbIndex) : 将当前数据库的key移动到指定redis中数据库当中
@Test
public void commonTest15(){
/**
* 将当前数据库的key移动到指定redis中数据库当中
* Boolean move(K key, int dbIndex)
* key : 键
* dbIndex : 数据库的索引
*/
redisTemplate.move("STRING-SET05",2);
}
1. 字符串(String)相关API
1.1 set(K var1, V var2) : 新增一个键值对
@Test
public void test01(){
/**
* set(K var1, V var2)
* key : 键
* value : 值
*/
redisTemplate.opsForValue().set("STRING-SET01","hello");
}
1.2 set(K var1, V var2, long var3, TimeUnit var4) : 设置变量值并设置过期时间
//设置变量值并设置过期时间
@Test
public void test02(){
/**
* set(K var1, V var2, long var3, TimeUnit var4)
* var1 : 键
* var2 : 值
* var3 : 过期时长
* var4 : 过期时长单位
* TimeUnit.SECONDS : 秒
* TimeUnit.MINUTES : 分钟
* TimeUnit.HOURS : 小时
* TimeUnit.DAYS : 天
* TimeUnit.MILLISECONDS : 毫秒
* TimeUnit.NANOSECONDS : 毫微秒
* TimeUnit.MICROSECONDS : 微秒
*/
redisTemplate.opsForValue().set("STRING-SET02","hello,time",30, TimeUnit.SECONDS);
}
1.3 set(K key, V value, Duration timeout) : 设置变量值并设置过期时间
@Test
public void stringTest03(){
/**
* 设置变量值并设置过期时间
* set(K key, V value, Duration timeout)
* key : 键
* value : 值
* timeout : 过期时间
* Duration.ofSeconds(30) : 秒
* Duration.ofMinutes(30) : 分钟
* Duration.ofHours(30) : 小时
* Duration.ofDays(30) : 天
* Duration.ofMillis(30) : 毫秒
* Duration.ofNanos(30) : 毫微秒
*/
redisTemplate.opsForValue().set("STRING-SET03","hello,time,01", Duration.ofNanos(30));
}
1.4 get(Object var1) : 获取指定key对应的值
@Test
public void stringTest04(){
/**
* 获取指定key对应的值
* get(Object var1)
* var1 ; 键
*/
Object result = redisTemplate.opsForValue().get("STRING-SET01");
System.out.println(result);
}
1.5 get(K var1, long var2, long var3) : 获取var1键所对应的值从var2位置开始到var3位置之间的字符串
@Test
public void stringTest05(){
/**
* 获取var1键所对应的值从var2位置开始到var3位置之间的字符串
* get(K var1, long var2, long var3)
*/
String result = redisTemplate.opsForValue().get("STRING-SET01", 2, 3);
System.out.println(result);
}
1.6 append(K var1, String var2) : 在原有的值基础上新增字符串到末尾
@Test
public void stringTest06(){
/**
* 在原有的值基础上新增字符串到末尾
* append(K var1, String var2)
* var1 : 键
* var2 : 拼接的值
*/
redisTemplate.opsForValue().append("STRING-SET01","01");
}
1.7 getAndSet(K var1, V var2) : 将旧的key设置为value，并且返回旧的key
@Test
public void stringTest07(){
/**
* 将旧的key设置为value，并且返回旧的value
* getAndSet(K var1, V var2)
* var1 : 键
* var2 : 新值
*/
Object result = redisTemplate.opsForValue().getAndSet("STRING-SET01", "hello01");
System.out.println(result);
}
1.8 size(K var1) : 获取键对应值的长度
@Test
public void stringTest08(){
/**
*获取键对应值的长度
* Long size(K var1)
* var1 : 键
*
* return : 值的长度
*/
Long size = redisTemplate.opsForValue().size("STRING-SET01");
System.out.println(size);
}
1.9 setIfAbsent(K var1, V var2) : 如果键不存在则新增,存在则不改变已经有的值如果键不存在则新增,存在则不改变已经有的值
@Test
public void stringTest09(){
/**
* 如果键不存在则新增,存在则不改变已经有的值如果键不存在则新增,存在则不改变已经有的值
* Boolean setIfAbsent(K var1, V var2)
*/
redisTemplate.opsForValue().setIfAbsent("STRING-SET02","hello02");
//Boolean setIfAbsent(K var1, V var2, long var3, TimeUnit var5) 设置超时时间,同set()方法
//setIfAbsent(K var1, V var2, long var3, TimeUnit var5) 设置超时时间,同set()方法
}
1.10 setBit(K var1, long var2, boolean var3) : var1键对应的值var2对应的ascii码,在offset的位置(从左向右数)变为var3
@Test
public void stringTest10(){
/**
* ???? 暂时未理解什么用途
* var1键对应的值var2对应的ascii码,在offset的位置(从左向右数)变为var3
* Boolean setBit(K var1, long var2, boolean var3)
*/
redisTemplate.opsForValue().setBit("STRING-SET02",1,false);
}
1.11 getBit(K var1, long var2) : 判断指定的位置ASCII码的bit位是否为1
@Test
public void stringTest11(){
/**
* ???? 暂时未理解什么用途
* 判断指定的位置ASCII码的bit位是否为1
* Boolean getBit(K var1, long var2)
*/
Boolean bit = redisTemplate.opsForValue().getBit("STRING-SET02", 1);
System.out.println(bit);
}
1.12 increment(K var1, long/double var2) : 以增量的方式将double值存储在变量中
@Test
public void stringTest12(){
/**
* 以增量的方式将double值存储在变量中
* Long increment(K var1, long/double var2)
*/
Long increment = redisTemplate.opsForValue().increment("STRING-SET03",2);
System.out.println(increment);
//如果没有传var2值,默认每次增加1
// redisTemplate.opsForValue().increment("STRING-SET03");
}
1.13 set(K var1, V var2, long var3) : 覆盖从指定位置开始的值(用 var2 参数覆写给定 var1 所储存的字符串值，从偏移量 var3 开始)
@Test
public void stringTest13(){
/**
* 覆盖从指定位置开始的值(用 var2 参数覆写给定 var1 所储存的字符串值，从偏移量 var3 开始)
* void set(K var1, V var2, long var3)
* var1 : 键
* var2 : 值
* var3 : 偏移量
*/
redisTemplate.opsForValue().set("STRING-SET01","abc",3);
}
1.14 get(K var1, long var2, long var3) : 返回键中指定索引区间内的值
@Test
public void stringTest14(){
/**
* 返回键中指定索引区间内的值
* String get(K var1, long var2, long var3)
* var1 : 键
* var2 : 开始索引
* var3 : 结束索引
*/
String result = redisTemplate.opsForValue().get("STRING-SET01", 1, 3);
System.out.println(result);
}
1.15 multiGet(Collection var1) : 批量获取值
@Test
public void stringTest15(){
List<String> list = new ArrayList<>();
list.add("STRING-SET01");
list.add("STRING-SET02");
list.add("STRING-SET03");
/**
* 批量获取值
* List<V> multiGet(Collection<K> var1)
* var1 : 键的集合
*/
List list1 = redisTemplate.opsForValue().multiGet(list);
System.out.println(list1);
}
1.16 multiSet(Map<? extends K, ? extends V> var1) : 设置map集合到redis
@Test
public void stringTest16(){
Map<String, String> map = new HashMap<>();
map.put("value1","11");
map.put("value2","22");
map.put("value3","33");
/**
* 设置map集合到redis
* void multiSet(Map<? extends K, ? extends V> var1)
*/
redisTemplate.opsForValue().multiSet(map);
}
1.17 multiSetIfAbsent(Map<? extends K, ? extends V> var1) : 如果对应的map集合名称不存在，则添加否则不做修改(有一个值存在所有的都不做修改)
@Test
public void stringTest17(){
Map<String, String> map = new HashMap<>();
map.put("value2","22");
map.put("value3","33");
map.put("value4","44");
/**
* 如果对应的map集合名称不存在，则添加否则不做修改(有一个值存在所有的都不做修改)
* Boolean multiSetIfAbsent(Map<? extends K, ? extends V> var1)
*/
redisTemplate.opsForValue().multiSetIfAbsent(map);
}
2. Hash相关API
2.1 put(H var1, HK var2, HV var3) : 新增hashMap值
@Test
public void hashTest01(){
/**
* 新增hashMap值
* void put(H var1, HK var2, HV var3)
* var1 : 键
* var2 : map中的键
* var3 : map中的值
*/
redisTemplate.opsForHash().put("HASH-01","map1","value1");
redisTemplate.opsForHash().put("HASH-01","map2","value2");
}
2.2 values(H var1) : 获取hash表中存在的所有的值
@Test
public void hashTest02(){
/**
* 获取hash表中存在的所有的值
* List<HV> values(H var1)
* var1 : 键
*/
List result = redisTemplate.opsForHash().values("HASH-01");
System.out.println(result);
}
2.3 entries(H var1) : 获取变量中的键值对
@Test
public void hashTest03(){
/**
* 获取变量中的键值对
* Map<HK, HV> entries(H var1)
* var1 : 键
*/
Map entries = redisTemplate.opsForHash().entries("HASH-01");
System.out.println(entries);
}
2.4 get(H var1, Object var2) : 获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null
@Test
public void hashTest04(){
/**
* 获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null
* HV get(H var1, Object var2)
* var1 : 键
* var2 : map中的键
*/
Object result = redisTemplate.opsForHash().get("HASH-01", "map1");
System.out.println(result);
}
2.5 hasKey(H var1, Object var2) : 判断变量中是否有指定的map键,有就返回true,没有就返回false
@Test
public void hashTest05(){
/**
* 判断变量中是否有指定的map键,有就返回true,没有就返回false
* Boolean hasKey(H var1, Object var2)
* var1 : 键
* var2 ; map中的键
*/
Boolean map1 = redisTemplate.opsForHash().hasKey("HASH-01", "map1");
Boolean map4 = redisTemplate.opsForHash().hasKey("HASH-01", "map4");
System.out.println(map1);
System.out.println(map4);
}
2.6 keys(H var1) : 获取变量中的键
@Test
public void hashTest06(){
/**
* 获取变量中的键
* Set<HK> keys(H var1)
* var1 ; 键
*/
Set keys = redisTemplate.opsForHash().keys("HASH-01");
System.out.println(keys);
}
2.7 size(H var1) : 获取变量的长度
@Test
public void hashTest07(){
/**
* 获取变量的长度
* Long size(H var1)
* var1 ; 键
*/
Long size = redisTemplate.opsForHash().size("HASH-01");
System.out.println(size);
}
2.8 increment(H var1, HK var2, long/double var3) : 使变量中的键以long/double值的大小进行自增长
@Test
public void hashTest08(){
/**
* 使变量中的键以long/double值的大小进行自增长
* Long/Double increment(H var1, HK var2, long/double var3)
*/
redisTemplate.opsForHash().increment("HASH-01","map3",2);
}
2.9 multiGet(H var1, Collection var2) : 以集合的方式获取变量中的值
@Test
public void hashTest09(){
List<String> list = new ArrayList<>();
list.add("map1");
list.add("map2");
/**
* 以集合的方式获取变量中的值
* List<HV> multiGet(H var1, Collection<HK> var2)
* var1 : 键
* var2 : map键的集合
*/
List result = redisTemplate.opsForHash().multiGet("HASH-01", list);
System.out.println(result);
}
2.10 putAll(H var1, Map<? extends HK, ? extends HV> var2) : 以map集合的形式添加键值对
@Test
public void hashTest10(){
Map<String, String> map = new HashMap<>();
map.put("map4","value4");
map.put("map5","value5");
/**
* 以map集合的形式添加键值对
* void putAll(H var1, Map<? extends HK, ? extends HV> var2)
* var1 : 键
* var2 : 添加的map
*/
redisTemplate.opsForHash().putAll("HASH-01",map);
}
2.11 putIfAbsent(H var1, HK var2, HV var3) : 如果变量值存在，在变量中可以添加不存在的的键值对，如果变量不存在，则新增一个变量，同时将键值对添加到该变量
@Test
public void hashTest11(){
/**
* 如果变量值存在，在变量中可以添加不存在的的键值对，如果变量不存在，则新增一个变量，同时将键值对添加到该变量
* Boolean putIfAbsent(H var1, HK var2, HV var3)
* var1 ; 键
* var2 : map中的键
* var3 : map中的值
*/
redisTemplate.opsForHash().putIfAbsent("HASH-01","map5","value5");
redisTemplate.opsForHash().putIfAbsent("HASH-01","map6","value6");
}
2.12 delete(H var1, Object… var2) : 删除变量中的键值对，可以传入多个参数，删除多个键值对
@Test
public void hashTest12(){
/**
* 删除变量中的键值对，可以传入多个参数，删除多个键值对
* Long delete(H var1, Object... var2)
* var1 : 键
* var2 : 删除的map的键
*/
redisTemplate.opsForHash().delete("HASH-01","map5","map6");
}
2.13 scan(H var1, ScanOptions var2)
@Test
public void hashTest13(){
/**
* Cursor<Entry<HK, HV>> scan(H var1, ScanOptions var2)
* 匹配获取键值对，ScanOptions.NONE为获取全部键对
* ScanOptions.scanOptions().match("map1").build() 匹配获取键位map1的键值对,不能模糊匹配
*/
Cursor<Map.Entry<Object,Object>> cursor = redisTemplate.opsForHash().scan("HASH-01", ScanOptions.scanOptions().match("map1").build());
// Cursor<Map.Entry<Object,Object>> cursor = redisTemplate.opsForHash().scan("HASH-01", ScanOptions.NONE);
while (cursor.hasNext()){
System.out.println(cursor.next());
}
}
3. List相关API
3.1 leftPush(K var1, V var2) : 在变量左边添加元素值
@Test
public void listTest01(){
/**
* 在变量左边添加元素值
* Long leftPush(K var1, V var2)
* var1 : 键
* var2 : 值
*/
redisTemplate.opsForList().leftPush("LIST-01","a");
redisTemplate.opsForList().leftPush("LIST-01","b");
redisTemplate.opsForList().leftPush("LIST-01","c");
}
3.2 leftPush(K var1, V var2, V var3) : 如果var2存在就在var2的前面添加var3
@Test
public void listTest02(){
/**
* 如果var2存在就在var2的前面添加var3
* Long leftPush(K var1, V var2, V var3)
* var1 : 键
* var2 : 值1
* var3 : 值2
*/
redisTemplate.opsForList().leftPush("LIST-01","c","d");
}
3.3 index(K var1, long var2) : 获取集合指定位置的值
@Test
public void listTest03(){
/**
* 获取集合指定位置的值
* V index(K var1, long var2)
* var1 : 键
* var2 : 索引位置
*/
Object result = redisTemplate.opsForList().index("LIST-01", 2);
System.out.println(result);
}
3.4 range(K var1, long var2, long var3) : 获取指定区间的值
@Test
public void listTest04(){
/**
* 获取指定区间的值
* List<V> range(K var1, long var2, long var3)
* var1 : 键
* var2 : 开始索引
* var3 : 结束索引
*/
List range = redisTemplate.opsForList().range("LIST-01", 1, 3);
System.out.println(range);
}
3.5 leftPushAll(K var1, V… var2) : 向左边批量添加参数元素
@Test
public void listTest05(){
/**
* 向左边批量添加参数元素
* Long leftPushAll(K var1, V... var2)
* var1 : 键
* var2 : 值,可以是多个值
*/
redisTemplate.opsForList().leftPushAll("LIST-02","e","f","g");
}
3.6 leftPushAll(K var1, Collection var2) : 以集合的方式向左边批量添加元素
@Test
public void listTest06(){
List<String> list = new ArrayList<>();
list.add("11");
list.add("22");
list.add("33");
/**
* 以集合的方式向左边批量添加元素
* Long leftPushAll(K var1, Collection<V> var2)
* var1 ; 键
* var2 : 插入的集合
*/
redisTemplate.opsForList().leftPushAll("LIST-03",list);
}
3.7 leftPushIfPresent(K var1, V var2) : 如果存在集合则添加元素
@Test
public void listTest07(){
/**
* 如果存在集合则添加元素
* Long leftPushIfPresent(K var1, V var2)
* var1 : 键
* var2 : 值
*/
redisTemplate.opsForList().leftPushIfPresent("LIST-01","e");
}
3.8 rightPush(K var1, V var2) : 向集合最右边添加元素
@Test
public void listTest08(){
/**
* 向集合最右边添加元素
* Long rightPush(K var1, V var2)
* var1 : 键
* var2 : 值
*/
redisTemplate.opsForList().rightPush("LIST-11","a");
redisTemplate.opsForList().rightPush("LIST-11","b");
redisTemplate.opsForList().rightPush("LIST-11","c");
}
3.9 rightPush(K key, V pivot, V value) : 向集合中pivot的右边插入值value
@Test
public void listTest09(){
/**
* 向集合中pivot的右边插入值value
* Long rightPush(K key, V pivot, V value)
* key : 键
* pivot : 集合中的值
* value : 要插入的值
*/
redisTemplate.opsForList().rightPush("LIST-11","c","d");
}
3.10 rightPushAll(K var1, V… var2) : 向右边批量添加元素
@Test
public void listTest10(){
/**
* 向右边批量添加元素
* Long rightPushAll(K var1, V... var2)
* var1 : 键
* var2 : 值,可以是多个
*/
redisTemplate.opsForList().rightPushAll("LIST-12","a","b","c");
}
3.11 rightPushAll(K var1, Collection var2) : 以集合方式向右边添加元素
@Test
public void listTest11(){
List<String> list = new ArrayList<>();
list.add("11");
list.add("22");
list.add("33");
/**
* 以集合方式向右边添加元素
* Long rightPushAll(K var1, Collection<V> var2)
* var1 : 键
* var2 : 要插入的集合
*/
redisTemplate.opsForList().rightPushAll("LIST-12",list);
}
3.12 rightPushIfPresent(K var1, V var2) : 向已存在的集合中添加元素
@Test
public void listTest12(){
/**
* 向已存在的集合中添加元素
* Long rightPushIfPresent(K var1, V var2)
* var1 : 键
* var2 : 值
*/
redisTemplate.opsForList().rightPushIfPresent("LIST-11","e");
}
3.13 size(K var1) : 获取集合长度
@Test
public void listTest13(){
/**
* 获取集合长度
* Long size(K var1)
* var1 ; 键
*/
Long size = redisTemplate.opsForList().size("LIST-01");
System.out.println(size);
}
3.14 leftPop(K var1) : 移除集合中的左边第一个元素
@Test
public void listTest14(){
/**
* 移除集合中的左边第一个元素
* V leftPop(K var1)
* var1 ; 键
*/
Object result = redisTemplate.opsForList().leftPop("LIST-01");
System.out.println(result);
}
3.15 leftPop(K var1, long var2, TimeUnit var3) : 移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出
@Test
public void listTest15(){
/**
* 移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出
* V leftPop(K var1, long var2, TimeUnit var3)
* var1 : 键
* var2 : 等待时长
* var3 : 时长单位
* TimeUnit.SECONDS : 秒
* TimeUnit.MINUTES : 分钟
* TimeUnit.HOURS : 小时
* TimeUnit.DAYS : 天
* TimeUnit.MILLISECONDS : 毫秒
* TimeUnit.NANOSECONDS : 毫微秒
* TimeUnit.MICROSECONDS : 微秒
*/
Object result = redisTemplate.opsForList().leftPop("LIST-01", 10, TimeUnit.SECONDS);
System.out.println(result);
}
3.16 rightPop(K var1) : 移除集合中的右边第一个元素
@Test
public void listTest16(){
/**
* 移除集合中的右边第一个元素
* V rightPop(K var1)
* var1 ; 键
*/
Object result = redisTemplate.opsForList().rightPop("LIST-01");
System.out.println(result);
}
3.17 rightPop(K var1, long var2, TimeUnit var3) : 移除集合中右边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出
@Test
public void listTest17(){
/**
* 移除集合中右边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出
* V rightPop(K var1, long var2, TimeUnit var3)
* var1 : 键
* var2 : 等待时长
* var3 : 时长单位
* TimeUnit.SECONDS : 秒
* TimeUnit.MINUTES : 分钟
* TimeUnit.HOURS : 小时
* TimeUnit.DAYS : 天
* TimeUnit.MILLISECONDS : 毫秒
* TimeUnit.NANOSECONDS : 毫微秒
* TimeUnit.MICROSECONDS : 微秒
*/
Object result = redisTemplate.opsForList().rightPop("LIST-01", 10, TimeUnit.SECONDS);
System.out.println(result);
}
3.18 rightPopAndLeftPush(K var1, K var2) : 移除集合中最右边的元素，同时在最左边加入一个元素,返回移除的值
@Test
public void listTest18(){
/**
* 移除集合中最右边的元素，同时在最左边加入一个元素,返回移除的值
* V rightPopAndLeftPush(K var1, K var2)
* var1 : 键
* var2 : 插入的值
* return : 移除的值
*/
Object result = redisTemplate.opsForList().rightPopAndLeftPush("LIST-01", "e");
System.out.println(result);
}
3.19 rightPopAndLeftPush(K var1, K var2, long var3, TimeUnit var4) : 移除集合中最右边的元素，同时在最左边加入一个元素,返回移除的值，如果超过等待的时间仍没有元素则退出
@Test
public void listTest19(){
/**
* 移除集合中最右边的元素，同时在最左边加入一个元素,返回移除的值，如果超过等待的时间仍没有元素则退出
* V rightPopAndLeftPush(K var1, K var2, long var3, TimeUnit var4)
* var1 : 键
* var2 ; 要插入的值
* var3 : 等待时长
* var4 : 时长单位
* TimeUnit.SECONDS : 秒
* TimeUnit.MINUTES : 分钟
* TimeUnit.HOURS : 小时
* TimeUnit.DAYS : 天
* TimeUnit.MILLISECONDS : 毫秒
* TimeUnit.NANOSECONDS : 毫微秒
* TimeUnit.MICROSECONDS : 微秒
* return : 移除的值
*/
Object result = redisTemplate.opsForList().rightPopAndLeftPush("LIST-01","",e 10, TimeUnit.SECONDS);
System.out.println(result);
}
3.20 set(K var1, long var2, V var3) : 在集合的指定位置插入元素,如果指定位置已有元素，则覆盖，没有则新增,如果索引超过集合的大小会报错
@Test
public void listTest20(){
/**
* 在集合的指定位置插入元素,如果指定位置已有元素，则覆盖，没有则新增,如果索引超过集合的大小会报错
* void set(K var1, long var2, V var3)
* var1 : 键
* var2 : 索引位置
* var3 : 新值
*
*/
redisTemplate.opsForList().set("LIST-01",2,"a");
}
3.21 remove(K var1, long var2, Object var4) : 删除集合中值等于value的元素(var2=0, 删除所有值等于var4的元素; var2>0, 从头部开始删除第一个值等于var4的元素; var2<0, 从尾部开始删除第一个值等于var4的元素)
@Test
public void listTest21(){
/**
* 删除集合中值等于value的元素(var2=0, 删除所有值等于var4的元素; var2>0, 从头部开始删除第一个值等于var4的元素; var2<0, 从尾部开始删除第一个值等于var4的元素)
* Long remove(K var1, long var2, Object var4)
* var1 :键
* var2 ; var2=0, 删除所有值等于var4的元素; var2>0, 从头部开始删除第一个值等于var4的元素; var2<0, 从尾部开始删除第一个值等于var4的元素
* var3 ; 要删除额值
*/
redisTemplate.opsForList().remove("LIST-01",0,"a");
}
3.22 trim(K var1, long var2, long var3) : 截取集合元素长度，保留长度内的数据(相当于对List列表进行剪裁)
@Test
public void listTest22(){
/**
* 截取集合元素长度，保留长度内的数据(相当于对List列表进行剪裁)
* void trim(K var1, long var2, long var3)
* var1 ; 键
* var2 : 开始索引
* var3 : 结束索引
*/
redisTemplate.opsForList().trim("LIST-12",0,2);
}
4. Set相关API
4.1 add(K var1, V… var2) : 向变量中批量添加值
@Test
public void setTest01(){
/**
* 向变量中批量添加值
* Long add(K var1, V... var2)
* var1 : 键
* var2 : 值,可以是多个
*/
redisTemplate.opsForSet().add("SET-01","a","a","b","b","c");
}
4.2 members(K var1) : 获取集合中的所有元素
@Test
public void setTest02(){
/**
* 获取集合中的所有元素
* Set<V> members(K var1)
* var1 : 键
*/
Set members = redisTemplate.opsForSet().members("SET-01");
System.out.println(members);
}
4.3 size(K var1) : 获取集合的大小
@Test
public void setTest03(){
/**
* 获取集合的大小
* Long size(K var1)
* var1 : 键
*/
Long size = redisTemplate.opsForSet().size("SET-01");
System.out.println(size);
}
4.4 randomMember(K var1) : 随机获得集合中的元素
@Test
public void setTest04(){
/**
* 随机获得集合中的元素
* V randomMember(K var1)
* var1 : 键
*/
Object result = redisTemplate.opsForSet().randomMember("SET-01");
System.out.println(result);
}
4.5 randomMembers(K var1, long var2) : 随机获取集合中var2个元素
@Test
public void setTest05(){
/**
* 随机获取集合中var2个元素
* List<V> randomMembers(K var1, long var2)
* var1 : 键
* var2 : 获取元素的个数
*/
List list = redisTemplate.opsForSet().randomMembers("SET-01", 5);
System.out.println(list);
}
4.6 isMember(K var1, Object var2) : 判断集合是否包含var2,包含返回true,否则返回false
@Test
public void setTest06(){
/**
* 判断集合是否包含var2,包含返回true,否则返回false
* Boolean isMember(K var1, Object var2)
* var1 : 键
* var2 : 查询的值
*/
Boolean result1 = redisTemplate.opsForSet().isMember("SET-01", "a");
Boolean result2 = redisTemplate.opsForSet().isMember("SET-01", "d");
System.out.println(result1);
System.out.println(result2);
}
4.7 move(K var1, V var2, K var3) : 将原集合中的值移动到目标集合
@Test
public void setTest07(){
/**
* 将原集合中的值移动到目标集合
* Boolean move(K var1, V var2, K var3)
* var1 : 原集合的键
* var2 : 移动的值
* var3 : 目标集合的键
*/
redisTemplate.opsForSet().move("SET-01","a","SET-02");
}
4.8 pop(K var1) : 删除并且返回一个随机的元素
@Test
public void setTest08(){
/**
* 删除并且返回一个随机的元素
* V pop(K var1)
* var1 : 键
*/
Object pop = redisTemplate.opsForSet().pop("SET-01");
System.out.println(pop);
}
4.9 remove(K var1, Object… var2) : 批量移除变量中的元素
@Test
public void setTest09(){
/**
* 批量移除变量中的元素
* Long remove(K var1, Object... var2)
* var1 : 键
* var2 : 移除的元素,可以是多个
*/
redisTemplate.opsForSet().remove("SET-01","a","g");
}
4.10 scan(K var1, ScanOptions var2) : 匹配值,遍历set类似于Interator
@Test
public void setTest10(){
/**
* 匹配值,遍历set类似于Interator
* Cursor<V> scan(K var1, ScanOptions var2)
* var1 : 键
* var2 : 匹配获取键值对，ScanOptions.NONE为获取全部键值对
* ScanOptions.scanOptions().match("C").build() 不能模糊匹配。
*/
Cursor cursor = redisTemplate.opsForSet().scan("SET-01", ScanOptions.NONE);
while (cursor.hasNext()){
System.out.println(cursor.next());
}
System.out.println("=================================");
Cursor c = redisTemplate.opsForSet().scan("SET-01", ScanOptions.scanOptions().match("c").build());
while (c.hasNext()){
System.out.println(c.next());
}
}
4.11 difference(K var1, Collection var2) : 获取两个或者多个集合的差集
@Test
public void setTest11(){
List<String> list = new ArrayList<>();
list.add("b");
list.add("b");
list.add("y");
list.add("z");
/**
* 获取两个或者多个集合的差集
* Set<V> difference(K var1, Collection<K> var2)
* var1 : 键
* var2 : 集合
*/
Set difference = redisTemplate.opsForSet().difference("SET-01", list);
System.out.println(difference);
}
4.12 difference(K var1, K var2) : 获取两个或者多个集合的差集
@Test
public void setTest12(){
/**
* 获取两个或者多个集合的差集
* Set<V> difference(K var1, K var2)
* var1 : set列表键
* var2 : 另一个set列表键
*/
Set difference = redisTemplate.opsForSet().difference("SET-01", "SET-02");
System.out.println(difference);
}
4.13 differenceAndStore(K var1, Collection var2, K var3) : 将var1与var2 比较的差值存放在var3中
@Test
public void setTest13(){
List<String> list = new ArrayList<>();
list.add("b");
list.add("b");
list.add("y");
list.add("z");
/**
* 将var1与var2 比较的差值存放在var3中
* Long differenceAndStore(K var1, Collection<K> var2, K var3)
* var1 : 键
* var2 : 集合
* var3 : 差值存放的键
*/
redisTemplate.opsForSet().differenceAndStore("SET-01",list,"SET-03");
}
4.14 differenceAndStore(K var1, K var2, K var3) : 将var1与var2 比较的差值存放在var3中
@Test
public void setTest14(){
/**
* 将var1与var2 比较的差值存放在var3中
* Long differenceAndStore(K var1, K var2, K var3)
* var1 : set列表的键
* var2 : 另一个set列表的键
* var3 : 存放差值的set列表的键
*/
redisTemplate.opsForSet().differenceAndStore("SET-01","SET-02","SET-03");
}
4.15 distinctRandomMembers(K var1, long var2) : 获取去重的随机元素
@Test
public void setTest15(){
/**
* 获取去重的随机元素
* Set<V> distinctRandomMembers(K var1, long var2)
* var1 : 键
* var2 : 获取元素个数
*/
Set set = redisTemplate.opsForSet().distinctRandomMembers("SET-01", 9);
System.out.println(set);
}
4.16 intersect(K var1, Collection var2) : 获取set列表和集合的交集
@Test
public void setTest16(){
List<String> list = new ArrayList<>();
list.add("b");
list.add("b");
list.add("y");
list.add("z");
/**
* 获取set列表和集合的交集
* Set<V> intersect(K var1, Collection<K> var2)
* var1 : set列表的键
* var2 ; 结合
*/
Set intersect = redisTemplate.opsForSet().intersect("SET-01", list);
System.out.println(intersect);
}
4.17 intersect(K var1, K var2) : 获取两个set列表的交集
@Test
public void setTest17(){
/**
* 获取两个set列表的交集
* Set<V> intersect(K var1, K var2)
* var1 : set列表的键
* var2 : 另一个set列表的键
*/
Set intersect = redisTemplate.opsForSet().intersect("SET-01", "SET-01");
System.out.println(intersect);
}
4.18 intersectAndStore(K var1, Collection var2, K var3) : 将set列表和集合的交集存放到另一个set列表中
@Test
public void setTest18(){
List<String> list = new ArrayList<>();
list.add("b");
list.add("b");
list.add("y");
list.add("z");
/**
* 将set列表和集合的交集存放到另一个set列表中
* Long intersectAndStore(K var1, Collection<K> var2, K var3)
* var1 : set列表的键
* var2 : 集合
* var3 : 存放交集的set列表的键
*/
redisTemplate.opsForSet().intersectAndStore("SET-01",list,"SET-03");
}
4.19 intersectAndStore(K var1, K var2, K var3) : 将两个set列表的交集存放到另一个set列表中
@Test
public void setTest19(){
/**
* 将两个set列表的交集存放到另一个set列表中
* Long intersectAndStore(K var1, K var2, K var3)
* var1 : set列表的键
* var2 : 另一个set列表的键
* var3 : 存放交集的set列表的键
*/
redisTemplate.opsForSet().intersectAndStore("SET-01","SET-02","SET-03");
}
4.20 union(K var1, Collection var2) : 获取set列表和集合的并集
@Test
public void setTest20(){
List<String> list = new ArrayList<>();
list.add("b");
list.add("b");
list.add("y");
/**
* 获取set列表和集合的并集
* Set<V> union(K var1, Collection<K> var2)
* var1 : set列表的键
* var2 : 集合
*/
Set union = redisTemplate.opsForSet().union("SET-01", list);
System.out.println(union);
}
4.21 union(K var1, K var2) : 获取两个set列表的并集
@Test
public void setTest21(){
/**
* 获取两个set列表的并集
* Set<V> union(K var1, K var2)
* var1 : set列表的键
* var2 : 另一个set列表的键
*/
Set union = redisTemplate.opsForSet().union("SET-01", "SET-02");
System.out.println(union);
}
4.22 unionAndStore(K var1, Collection var2, K var3) : 将set列表和集合的并集存放到另一个set列表中
@Test
public void setTest22(){
List<String> list = new ArrayList<>();
list.add("b");
list.add("b");
list.add("y");
/**
* 将set列表和集合的并集存放到另一个set列表中
* Long unionAndStore(K var1, Collection<K> var2, K var3)
* var1 : set列表的键
* var2 : 集合
* var3 : 存放并集的set列表的键
*/
redisTemplate.opsForSet().unionAndStore("SET-01",list,"SET-03");
}
4.23 unionAndStore(K var1, K var2, K var3) : 将另个set列表的并集存放到另一个set列表中
@Test
public void setTest23(){
/**
* 将另个set列表的并集存放到另一个set列表中
* Long unionAndStore(K var1, K var2, K var3)
* var1 : set列表的键
* var2 : 另一个set列表的键
* var3: 存放并集的set列表的键
*/
redisTemplate.opsForSet().unionAndStore("SET-01","SET-02","SET-03");
}
5. zSet相关API
5.1 add(K var1, V var2, double var3) : 添加元素(有序集合是按照元素的var3值由小到大进行排列)
@Test
public void zSetTest01(){
/**
* 添加元素(有序集合是按照元素的var3值由小到大进行排列)
* Boolean add(K var1, V var2, double var3)
* var1 : 键
* var2 : 值
* var3 : 根据这个值排序
*/
redisTemplate.opsForZSet().add("ZSET-01","b",2);
redisTemplate.opsForZSet().add("ZSET-01","e",4);
redisTemplate.opsForZSet().add("ZSET-01","c",3);
redisTemplate.opsForZSet().add("ZSET-01","a",1);
}
5.2 range(K var1, long var2, long var3) : 获取变量指定区间的元素
@Test
public void zSetTest02(){
/**
* 获取变量指定区间的元素
* Set<V> range(K var1, long var2, long var3)
* var1 : 键
* var2 : 开始索引
* var3 : 结束索引
*/
Set range = redisTemplate.opsForZSet().range("ZSET-01", 1, 3);
System.out.println(range);
}
5.3 rangeByLex(K var1, Range var2)
@Test
public void zSetTest03(){
RedisZSetCommands.Range range = new RedisZSetCommands.Range();
range.gte("c");
// range.gt("c");
// range.lte("c");
// range.lt("c");
// range.getMax();
// range.getMin();
/**
* Set<V> rangeByLex(K var1, Range var2)
* var1 : 键
* var2 :
*/
Set set = redisTemplate.opsForZSet().rangeByLex("ZSET-01", range);
System.out.println(set);
}
5.4 rangeByLex(“ZSET-01”,range,limit)
@Test
public void zSetTest04(){
RedisZSetCommands.Range range = new RedisZSetCommands.Range();
range.gte("c");
RedisZSetCommands.Limit limit = new RedisZSetCommands.Limit();
limit.count(2);
// limit.offset(2);
// limit.getCount();
// limit.getOffset();
// limit.isUnlimited();
/**
* Set<V> rangeByLex(K var1, Range var2, Limit var3)
*/
redisTemplate.opsForZSet().rangeByLex("ZSET-01",range,limit);
}
5.5 add(K var1, Set<ZSetOperations.TypedTuple> var2) : 通过TypedTuple方式新增数据
@Test
public void zSetTest05(){
DefaultTypedTuple typedTuple1 = new DefaultTypedTuple("x",5d);
DefaultTypedTuple typedTuple2 = new DefaultTypedTuple("y",6d);
Set<ZSetOperations.TypedTuple<Object>> set = new HashSet<>();
set.add(typedTuple1);
set.add(typedTuple2);
/**
* 通过TypedTuple方式新增数据
* Long add(K var1, Set<ZSetOperations.TypedTuple<V>> var2)
*/
redisTemplate.opsForZSet().add("ZSET-01",set);
}
5.6 rangeByScore(K var1, double var2, double var3) : 根据设置的score获取区间值
@Test
public void zSetTest06(){
/**
* 根据设置的score获取区间值
* Set<V> rangeByScore(K var1, double var2, double var3)
* var1 : 键
* var2 : score的开始值
* var3 : score的结值
*/
Set set = redisTemplate.opsForZSet().rangeByScore("ZSET-01", 1, 3);
System.out.println(set);
}
5.7 rangeByScore(K var1, double var2, double var3, long var4, long var5) : 根据设置的score获取区间值从给定下标和给定长度获取最终值
@Test
public void zSetTest07(){
/**
* 根据设置的score获取区间值从给定下标和给定长度获取最终值
* Set<V> rangeByScore(K var1, double var2, double var3, long var4, long var5)
* var1 : 键
* var2 : score的开始值
* var3 : score的开始值
* var4 :下标
* var5 : 长度
*/
Set set = redisTemplate.opsForZSet().rangeByScore("ZSET-01", 1, 2, 2, 3);
System.out.println(set);
}
5.8 rangeWithScores(K var1, long var2, long var3) : 获取RedisZSetCommands.Tuples的区间值
@Test
public void zSetTest08(){
/**
* 获取RedisZSetCommands.Tuples的区间值
* Set<ZSetOperations.TypedTuple<V>> rangeWithScores(K var1, long var2, long var3)
* var1 : 键
* var2 : 开始值
* var3 : 结束值
*
*/
Set<ZSetOperations.TypedTuple<Object>> set = redisTemplate.opsForZSet().rangeWithScores("ZSET-01", 1, 3);
Iterator<ZSetOperations.TypedTuple<Object>> iterator = set.iterator();
while (iterator.hasNext()){
ZSetOperations.TypedTuple<Object> next = iterator.next();
Double score = next.getScore();
Object value = next.getValue();
System.out.println("score : " + score + "==value : " + value);
}
}
5.9 rangeByScoreWithScores(K var1, double var2, double var3) : 获取RedisZSetCommands.Tuples的区间值通过score值
@Test
public void zSetTest09(){
/**
* 获取RedisZSetCommands.Tuples的区间值通过score值
* Set<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K var1, double var2, double var3)
* var1 : 键
* var2 : 开始值
* var3 : 结束值
*
*/
Set<ZSetOperations.TypedTuple<Object>> set = redisTemplate.opsForZSet().rangeByScoreWithScores("ZSET-01", 1, 3);
Iterator<ZSetOperations.TypedTuple<Object>> iterator = set.iterator();
while (iterator.hasNext()){
ZSetOperations.TypedTuple<Object> next = iterator.next();
Double score = next.getScore();
Object value = next.getValue();
System.out.println("score : " + score + "==value : " + value);
}
}
5.10 rangeByScoreWithScores(K var1, double var2, double var3, long var4, long var5) : 获取RedisZSetCommands.Tuples的区间值从给定下标和给定长度获取最终值通过分值
@Test
public void zSetTest10(){
/**
* 获取RedisZSetCommands.Tuples的区间值从给定下标和给定长度获取最终值通过分值
* Set<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K var1, double var2, double var3, long var4, long var5)
* var1 : 键
* var2 : score开始值
* var3 : score结束值
* var4 : 下标
* var5 ; 长度
*
*/
Set<ZSetOperations.TypedTuple<Object>> set = redisTemplate.opsForZSet().rangeByScoreWithScores("ZSET-01", 1, 3,2,3);
Iterator<ZSetOperations.TypedTuple<Object>> iterator = set.iterator();
while (iterator.hasNext()){
ZSetOperations.TypedTuple<Object> next = iterator.next();
Double score = next.getScore();
Object value = next.getValue();
System.out.println("score : " + score + "==value : " + value);
}
}
5.11 count(K var1, double var2, double var3) : 根据score值获取集合元素数量
@Test
public void zSetTest11(){
/**
* 根据score值获取集合元素数量
* Long count(K var1, double var2, double var3)
* var1 : 键
* var2 : 开始score值
* var3 :结束score值
*/
Long count = redisTemplate.opsForZSet().count("ZSET-01", 2, 4);
System.out.println(count);
}
5.12 rank(K var1, Object var2) : 获取变量中元素的索引,下标开始位置为0
@Test
public void zSetTest12(){
/**
* 获取变量中元素的索引,下标开始位置为0
* Long rank(K var1, Object var2)
* var1 : 键
* var2 :值
* return : 返回下标值,从0开始
*/
Long b = redisTemplate.opsForZSet().rank("ZSET-01", "b");
System.out.println(b);
}
5.13 scan(K var1, ScanOptions var2) : 匹配值,遍历zset类似于Interator
@Test
public void zSetTest13(){
/**
* 匹配值,遍历zset类似于Interator
* Cursor<ZSetOperations.TypedTuple<V>> scan(K var1, ScanOptions var2)
* var2 : 匹配获取键值对，ScanOptions.NONE为获取全部键值对
* ScanOptions.scanOptions().match("C").build() 不能模糊匹配。
*/
Cursor<ZSetOperations.TypedTuple<Object>> cursor = redisTemplate.opsForZSet().scan("ZSET-01", ScanOptions.NONE);
while (cursor.hasNext()){
ZSetOperations.TypedTuple<Object> next = cursor.next();
System.out.println("value:" + next.getValue() + "== score" + next.getScore());
}
System.out.println("=================================");
Cursor<ZSetOperations.TypedTuple<Object>> c = redisTemplate.opsForZSet().scan("ZSET-01", ScanOptions.scanOptions().match("c").build());
while (c.hasNext()){
ZSetOperations.TypedTuple<Object> next = c.next();
System.out.println("value:" + next.getValue() + "== score" + next.getScore());
}
}
5.14 score(K var1, Object var2) : 获取元素的分值(score)
@Test
public void zSetTest14(){
/**
* 获取元素的分值(score)
* Double score(K var1, Object var2)
* var1 : 键
* var2 : 值
*/
Double score = redisTemplate.opsForZSet().score("ZSET-01", "b");
System.out.println(score);
}
5.15 zCard(K var1) : 获取变量中元素的个数
@Test
public void zSetTest15(){
/**
* 获取变量中元素的个数
* Long zCard(K var1)
* var1 : 键
*/
Long result = redisTemplate.opsForZSet().zCard("ZSET-01");
System.out.println(result);
}
5.16 size(K var1) : 获取变量中元素的个数
@Test
public void zSetTest16(){
/**
* 获取变量中元素的个数
* Long size(K var1)
* var1 : 键
*/
Long size = redisTemplate.opsForZSet().size("ZSET-01");
System.out.println(size);
}
5.17 incrementScore(K var1, V var2, double var3) : 增加元素的score值，并返回增加后的值
@Test
public void zSetTest17(){
/**
* 增加元素的score值，并返回增加后的值
* Double incrementScore(K var1, V var2, double var3)
* var1 : 键
* var2 : 值
* var3 : 增加的分值(score)
*/
Double b = redisTemplate.opsForZSet().incrementScore("ZSET-01", "b", 6);
System.out.println(b);
}
5.18 reverseRange(K var1, long var2, long var4) : 索引倒序排列指定区间元素
@Test
public void zSetTest18(){
/**
* 索引倒序排列指定区间元素
* Set<V> reverseRange(K var1, long var2, long var4)
* var1 : 键
* var2 : 开始索引
* var3 : 结束索引
*/
Set set = redisTemplate.opsForZSet().reverseRange("ZSET-01", 2, 3);
System.out.println(set);
}
5.19 reverseRangeByScore(K var1, double var2, double var3) : 按照Score值区间查询集合中的元素，结果从小到大排序
@Test
public void zSetTest19(){
/**
* 按照Score值区间查询集合中的元素，结果从小到大排序
* Set<V> reverseRangeByScore(K var1, double var2, double var3)
* var1 : 键
* var2 : 最小score值
* var3 : 最大score值
*/
Set set = redisTemplate.opsForZSet().reverseRangeByScore("ZSET-01", 3, 11);
System.out.println(set);
}
5.20 reverseRangeByScoreWithScores(K var1, double var2, double var3) : 按照Score值区间查询集合中的RedisZSetCommands.Tuple元素，结果从小到大排序
@Test
public void zSetTest20(){
/**
* 按照Score值区间查询集合中的RedisZSetCommands.Tuple元素，结果从小到大排序
* Set<ZSetOperations.TypedTuple<V>> reverseRangeByScoreWithScores(K var1, double var2, double var3)
* var1 : 键
* var2 : 最小score值
* var3 : 最大score值
*/
Set<ZSetOperations.TypedTuple<Object>> set = redisTemplate.opsForZSet().reverseRangeByScoreWithScores("ZSET-01", 3, 11);
Iterator<ZSetOperations.TypedTuple<Object>> iterator = set.iterator();
while (iterator.hasNext()){
ZSetOperations.TypedTuple<Object> next = iterator.next();
System.out.println("value : " + next.getValue() + "== value : " + next.getValue());
}
}
5.21 reverseRangeByScore(K var1, double var2, double var3, long var4, long var5) : 倒序排列从给定下标和给定长度分值区间元素
@Test
public void zSetTest21(){
/**
* 从高到低的排序集中获取score在最小和最大值之间的元素
* Set<V> reverseRangeByScore(K var1, double var2, double var3, long var4, long var5)
* var1 : 键
* var2 : 最小score值
* var3 : 最大score值
* var4 : 开始索引
* var5 : 结束索引
*/
Set set = redisTemplate.opsForZSet().reverseRangeByScore("ZSET-01", 3, 11, 3, 1);
System.out.println(set);
}
5.22 reverseRangeByScoreWithScores(K var1, double var2, double var3, long var4, long var5) : 从高到低的排序集中获取score在最小和最大值之间的RedisZSetCommands.Tuple元素
@Test
public void zSetTest22(){
/**
* 从高到低的排序集中获取score在最小和最大值之间的RedisZSetCommands.Tuple元素
* Set<ZSetOperations.TypedTuple<V>> reverseRangeByScoreWithScores(K var1, double var2, double var3, long var4, long var5)
* var1 : 键
* var2 : 最小score值
* var3 : 最大score值
* var4 : 开始索引
* var5 : 结束索引
*/
Set<ZSetOperations.TypedTuple<Object>> set = redisTemplate.opsForZSet().reverseRangeByScoreWithScores("ZSET-01", 3, 11, 0, 2);
Iterator<ZSetOperations.TypedTuple<Object>> iterator = set.iterator();
while (iterator.hasNext()){
ZSetOperations.TypedTuple<Object> next = iterator.next();
System.out.println("value : " + next.getScore() + "== value : " + next.getValue());
}
}
5.23 reverseRangeWithScores(K var1, long var2, long var3) : 倒叙获取集合中给定区间的元素(start 开始位置，end 结束位置, -1查询所有)
@Test
public void zSetTest23(){
/**
* 倒叙获取集合中给定区间的元素(start 开始位置，end 结束位置, -1查询所有)
* Set<ZSetOperations.TypedTuple<V>> reverseRangeWithScores(K var1, long var2, long var3)
* var1 :键
* var2 : 开始索引
* var: 结束索引
*
*/
Set<ZSetOperations.TypedTuple<Object>> set = redisTemplate.opsForZSet().reverseRangeWithScores("ZSET-01", 0, 2);
// Set<ZSetOperations.TypedTuple<Object>> set = redisTemplate.opsForZSet().reverseRangeWithScores("ZSET-01", 1, -1);
Iterator<ZSetOperations.TypedTuple<Object>> iterator = set.iterator();
while (iterator.hasNext()){
ZSetOperations.TypedTuple<Object> next = iterator.next();
System.out.println(next.getValue() + "===" + next.getScore());
}
}
5.24 reverseRank(K var1, Object var2) : 获取倒序排列的索引值
@Test
public void zSetTest24(){
/**
* 获取倒序排列的索引值
* Long reverseRank(K var1, Object var2)
* var1 : 键
* var2 : 值
* return : 返回的是元素倒叙的索引值
*/
Long a = redisTemplate.opsForZSet().reverseRank("ZSET-01", "a");
Long b = redisTemplate.opsForZSet().reverseRank("ZSET-01", "b");
System.out.println(a);
System.out.println(b);
}
5.25 intersectAndStore(K var1, K var2, K var3) : 获取2个变量的交集存放到第3个变量里面,返回交集的个数
@Test
public void zSetTest25(){
/**
* 获取2个变量的交集存放到第3个变量里面,返回交集的个数
* Long intersectAndStore(K var1, K var2, K var3)
* var1 : zset列表的键
* var2 : 另一个zset列表的键
* var3 : 存放交集的zset列表的键
*/
Long aLong = redisTemplate.opsForZSet().intersectAndStore("ZSET-01", "ZSET-02", "ZSET-04");
System.out.println(aLong);
}
5.26 intersectAndStore(K var1, Collection var2, K var3) : 获取多个变量的交集存放到第3个变量里面,返回交集的个数
@Test
public void zSetTest26(){
List<String> list = new ArrayList<>();
list.add("ZSET-02");
list.add("ZSET-03");
/**
* 获取多个变量的交集存放到第3个变量里面,返回交集的个数
* Long intersectAndStore(K var1, Collection<K> var2, K var3)
* var1 : zset列表的键
* var2 : 存放其他多个zset列表的键的集合
* var3 : 存放交集的zset列表的键
*/
Long aLong = redisTemplate.opsForZSet().intersectAndStore("ZSET-01", list, "ZSET-05");
System.out.println(aLong);
}
5.27 unionAndStore(K var1, K var2, K var3) : 获取2个变量的并集存放到第3个变量里面,返回并集后的个数
@Test
public void zSetTest27(){
/**
* 获取2个变量的并集存放到第3个变量里面,返回并集后的个数
* Long unionAndStore(K var1, K var2, K var3)
* var1 : zset列表的键
* var2 : 另一个zset列表的键
* var3 : 存放并集的zset列表的键
*/
Long aLong = redisTemplate.opsForZSet().unionAndStore("ZSET-01", "ZSET-02", "ZSET-06");
System.out.println(aLong);
}
5.28 unionAndStore(K var1, Collection var2, K var3) : 获取多个变量的并集存放到第3个变量里面,返回并集后的个数
@Test
public void zSetTest28(){
List<String> list = new ArrayList<>();
list.add("ZSET-02");
list.add("ZSET-03");
/**
* 获取多个变量的并集存放到第3个变量里面,返回并集后的个数
* Long unionAndStore(K var1, Collection<K> var2, K var3)
* var1 : zset列表的键
* var2 : 存放其他多个zset列表的键的集合
* var3 : 存放并集的zset列表的键
*/
Long aLong = redisTemplate.opsForZSet().unionAndStore("ZSET-01", list, "ZSET-05");
System.out.println(aLong);
}
5.29 remove(K var1, Object… var2) : 批量移除元素根据元素值,返回移除的个数
@Test
public void zSetTest29(){
/**
* 批量移除元素根据元素值,返回移除的个数
* Long remove(K var1, Object... var2)
* var1 ; 键
* var2: 值,可以是多个
*/
Long remove = redisTemplate.opsForZSet().remove("ZSET-05", "a", "b");
System.out.println(remove);
}
5.30 removeRangeByScore(K var1, double var2, double var3) : 根据分值移除区间元素,返回移除的元素个数
@Test
public void zSetTest30(){
/**
* 根据分值移除区间元素,返回移除的元素个数
* Long removeRangeByScore(K var1, double var2, double var3)
* var1 : 键
* var2 : 最小score值
* var3 : 最大score值
*/
Long aLong = redisTemplate.opsForZSet().removeRangeByScore("ZSET-05", 2, 4);
System.out.println(aLong);
}
5.31 removeRange(K var1, long var2, long var3) : removeRange(K var1, long var2, long var3)
@Test
public void zSetTest31(){
/**
* 根据索引值移除区间元素,返回移除元素的个数
* Long removeRange(K var1, long var2, long var3)
* var1 : 键
* var2 : 起始索引位置
* var3 ; 结束索引位置
*/
Long aLong = redisTemplate.opsForZSet().removeRange("ZSET-06", 0, 2);
System.out.println(aLong);
}
CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！
更多推荐
4
0- 0
已为社区贡献1条内容
所有评论(0)