RedisTemplate相关API

文章目录

0. 通用API
1. 字符串(String)相关API
2. Hash相关API
3. List相关API
4. Set相关API
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);
    }

原文链接：https://blog.csdn.net/weixin_42871989/article/details/108045386