Redis常用api大全（下）

最新推荐文章于 2024-05-30 01:33:53 发布
最新推荐文章于 2024-05-30 01:33:53 发布
阅读量637 收藏 4
点赞数
分类专栏： redis java 文章标签： java 列表 redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35364594/article/details/113094888
版权
java 同时被 2 个专栏收录
17 篇文章 0 订阅
订阅专栏
redis
4 篇文章 0 订阅
订阅专栏

接上文.....

5、Set类型常用api

  • Long add(K var1, V... var2):向变量中批量添加值 
    @Override
    public void run(String... args) throws Exception {
        Long add = redisTemplate.opsForSet().add("set_test", "A", "B", "C");
        log.info("添加数量:{}", add);
        log.info("success");
    }
  • Set<V> members(K var1):获取变量中的所有值 
    @Override
    public void run(String... args) throws Exception {
        Set<String> difference = redisTemplate.opsForSet().members("set_test");
        difference.forEach(s -> {
            log.info("值:{}", s);
        });
        log.info("success");
    }
  • Long size(K var1):查看set集合大小 
    @Override
    public void run(String... args) throws Exception {
        Long size = redisTemplate.opsForSet().size("set_test");
        log.info("集合大小:{}", size);
        log.info("success");
    }
  • Long remove(K var1, Object... var2):移除set集合中的数据（可传多个值） 
    @Override
    public void run(String... args) throws Exception {
        Long remove = redisTemplate.opsForSet().remove("set_test", "A", "B");
        log.info("移除数量:{}", remove);
        log.info("success");
    }
  • Set<V> difference(K var1, K var2):取两个集合中的差值（注意，参数都是set缓存的key，而不是自己定义一个字符串进去！该方法是求第一个参数的差值，举个例子:var1在缓存中对应的值为{1,2,3}，var2在缓存中对应的值为{2,3}，那么经过difference方法，返回的就是1，如果var1在缓存中对应的值为{2,3}，var2在缓存中对应的值为{1,2,3}，那么经过difference方法就什么都不会返回！） 
    @Override
    public void run(String... args) throws Exception {
        redisTemplate.opsForSet().add("set_test1", "C", "D");
        Set<String> difference = redisTemplate.opsForSet().difference("set_test1", "set_test");
        difference.forEach(s -> {
            log.info("差值:{}", s);
        });
        log.info("success");
    }
  • Set<V> difference(K var1, Collection<K> var2):与上个api不同的是，传进去的值是个集合，然后和原有的集合比较，返回差值 
    @Override
    public void run(String... args) throws Exception {
        List<String> stringList = new ArrayList<>();
        stringList.add("set_test");
        Set<String> difference = redisTemplate.opsForSet().difference("set_test1", stringList);
        difference.forEach(s -> {
            log.info("差值:{}", s);
        });
        log.info("success");
    }
  • Long differenceAndStore(K var1, K var2, K var3):将第一个集合与第二个集合的差集保存在第三个集合中 
    @Override
    public void run(String... args) throws Exception {
        Long differenceAndStore = redisTemplate.opsForSet().differenceAndStore("set_test1", "set_test", "set_test3");
        log.info("差集数量:{}", differenceAndStore);
        Set<String> setTest3 = redisTemplate.opsForSet().members("set_test3");
        setTest3.forEach(s -> {
            log.info("setTest3集合中的值:{}", s);
        });
        log.info("success");
    }
  • Long differenceAndStore(K var1, Collection<K> var2, K var3):将第一个集合与第二个参数列表集合的差集保存在第三个集合中 
    @Override
    public void run(String... args) throws Exception {
        List<String> list = new ArrayList<>();
        list.add("set_test");
        Long differenceAndStore = redisTemplate.opsForSet().differenceAndStore("set_test1", list, "set_test4");
        log.info("差集数量:{}", differenceAndStore);
        Set<String> setTest4 = redisTemplate.opsForSet().members("set_test4");
        setTest4.forEach(s -> {
            log.info("setTest4集合中的值:{}", s);
        });
        log.info("success");
    }
  • Set<V> intersect(K var1, K var2):获取第一个参数集合与第二个参数集合的交集 
    @Override
    public void run(String... args) throws Exception {
        Set<String> intersect = redisTemplate.opsForSet().intersect("set_test", "set_test1");
        intersect.forEach(s -> {
            log.info("交集值:{}", s);
        });
        log.info("success");
    }
  • Set<V> intersect(K var1, Collection<K> var2):获取第一个参数集合中与其他多个集合的交集 
    @Override
    public void run(String... args) throws Exception {
        List<String> list = new ArrayList<>();
        list.add("set_test1");
        Set<String> intersect = redisTemplate.opsForSet().intersect("set_test", list);
        intersect.forEach(s -> {
            log.info("交集值:{}", s);
        });
        log.info("success");
    }
  • Long intersectAndStore(K var1, K var2, K var3):获取第一个集合与第二个集合的交集内容保存到第三个集合 
    @Override
    public void run(String... args) throws Exception {
        Long intersectAndStore = redisTemplate.opsForSet().intersectAndStore("set_test", "set_test1", "set_inter_1");
        log.info("交集数量:{}", intersectAndStore);
        Set<String> setInter = redisTemplate.opsForSet().members("set_inter_1");
        setInter.forEach(s -> {
            log.info("setInter集合中的值:{}", s);
        });
        log.info("success");
    }
  • Long intersectAndStore(K var1, Collection<K> var2, K var3):获取第一个集合与第二个list集合的交集内容保存到第三个集合中 
    @Override
    public void run(String... args) throws Exception {
        List<String> list = new ArrayList<>();
        list.add("set_test1");
        Long intersectAndStore = redisTemplate.opsForSet().intersectAndStore("set_test", list, "set_inter_2");
        log.info("交集数量:{}", intersectAndStore);
        Set<String> setInter = redisTemplate.opsForSet().members("set_inter_2");
        setInter.forEach(s -> {
            log.info("setInter集合中的值:{}", s);
        });
        log.info("success");
    }
  • Set<V> union(K var1, K var2):获取两个集合的并集然后去重返回 
    @Override
    public void run(String... args) throws Exception {
        Set<String> union = redisTemplate.opsForSet().union("set_test3", "set_test4");
        union.forEach(s -> {
            log.info("并集值:{}", s);
        });
        log.info("success");
    }
  • Set<V> union(K var1, Collection<K> var2):获取多个集合的并集然后去重返回 
    @Override
    public void run(String... args) throws Exception {
        List<String> list = new ArrayList<>();
        list.add("set_test4");
        Set<String> union = redisTemplate.opsForSet().union("set_test3", list);
        union.forEach(s -> {
            log.info("并集值:{}", s);
        });
        log.info("success");
    }
  • Long unionAndStore(K var1, K var2, K var3):获取两个集合的并集然后去重保存在第三个集合，返回保存的集合大小 
    @Override
    public void run(String... args) throws Exception {
        Long aLong = redisTemplate.opsForSet().unionAndStore("set_test3", "set_test4", "set_test5");
        log.info("并集数量:{}", aLong);
        Set<String> setTest5 = redisTemplate.opsForSet().members("set_test5");
        setTest5.forEach(s -> {
            log.info("setTest5中的值:{}", s);
        });
        log.info("success");
    }
  • Long unionAndStore(K var1, Collection<K> var2, K var3):获取多个集合的并集然后去重保存在第三个集合中 
    @Override
    public void run(String... args) throws Exception {
        List<String> list = new ArrayList<>();
        list.add("set_test4");
        Long aLong = redisTemplate.opsForSet().unionAndStore("set_test3", list, "set_test6");
        log.info("并集数量:{}", aLong);
        Set<String> setTest6 = redisTemplate.opsForSet().members("set_test6");
        setTest6.forEach(s -> {
            log.info("setTest6中的值:{}", s);
        });
        log.info("success");
    }
  • Boolean isMember(K var1, Object var2):第一个参数是集合key，第二个参数是要判断的值，该方法作用是判断传进去的值是否存在于这个集合中 
    @Override
    public void run(String... args) throws Exception {
        Boolean member = redisTemplate.opsForSet().isMember("set_test", "C");
        log.info("是否存在:{}", member);
        log.info("success");
    }
  • Boolean move(K var1, V var2, K var3):将集合中的值移动到第三个集合（原集合减这个值，新集合加这个值） 
    @Override
    public void run(String... args) throws Exception {
        Boolean move = redisTemplate.opsForSet().move("set_test", "C", "move_test");
        log.info("是否转移:{}", move);
        Set<String> setTest = redisTemplate.opsForSet().members("set_test");
        if (setTest.size() == 0){
            log.info("set_test参数转移之后内容为null");
        }
        Set<String> moveTest = redisTemplate.opsForSet().members("move_test");
        moveTest.forEach(s -> {
            log.info("move_test转移之后的值:{}", s);
        });
        log.info("success");
    }
  • V pop(K var1):弹出一个值（就是获取并删除集合中的一个值） 
    @Override
    public void run(String... args) throws Exception {
        String test = (String) redisTemplate.opsForSet().pop("move_test");
        log.info("弹出的值:{}", test);
        Set<String> moveTest = redisTemplate.opsForSet().members("move_test");
        if (moveTest.size() == 0){
            log.info("弹出值之后原集合内容为空");
        }
        log.info("success");
    }
  • List<V> pop(K var1, long var2):弹出多个值 
    @Override
    public void run(String... args) throws Exception {
        List<String> test = redisTemplate.opsForSet().pop("set_test1", 2);
        test.forEach(s -> {
            log.info("弹出的值:{}", s);
        });
        Set<String> setTest1 = redisTemplate.opsForSet().members("set_test1");
        if (setTest1.size() == 0){
            log.info("弹出值之后原集合内容为空");
        }
        log.info("success");
    }
  • V randomMember(K var1):随机获取集合中的一个值，注意，这里获取到是不会删除原集合数据的 
    @Override
    public void run(String... args) throws Exception {
        String setTest4 = (String) redisTemplate.opsForSet().randomMember("set_test4");
        log.info("随机获取的值:{}", setTest4);
        log.info("success");
    }
  • List<V> randomMembers(K var1, long var2):随机获取集合中多个值，不会删除原集合数据 
    @Override
    public void run(String... args) throws Exception {
        List<String> setTest4 = redisTemplate.opsForSet().randomMembers("set_test4", 2);
        setTest4.forEach(s -> {
            log.info("随机获取的值:{}", s);
        });
        log.info("success");
    }
  • Set<V> distinctRandomMembers(K var1, long var2):去重随机获取多个值，不会删除原集合数据 
    @Override
    public void run(String... args) throws Exception {
        Set<String> setTest4 = redisTemplate.opsForSet().distinctRandomMembers("set_test4", 2);
        setTest4.forEach(s -> {
            log.info("随机获取的值:{}", s);
        });
        log.info("success");
    }
  • Long size(K var1):获取集合大小 
    @Override
    public void run(String... args) throws Exception {
        Long size = redisTemplate.opsForSet().size("set_test4");
        log.info("集合大小:{}", size);
        log.info("success");
    }
  • Boolean delete(K key):删除整个集合，想删除其中一个值的话请用remove方法 
    @Override
    public void run(String... args) throws Exception {
        Boolean delete = redisTemplate.delete("set_test4");
        log.info("是否删除:{}", delete);
        log.info("success");
    }

6、List类型常用api

  • Long leftPush(K var1, V var2):从列表左边插入一条数据，返回集合大小 
    @Override
    public void run(String... args) throws Exception {
        Long leftPush = redisTemplate.opsForList().leftPush("list_test", "A");
        log.info("集合大小:{}", leftPush);
        log.info("success");
    }
  • Long leftPush(K var1, V var2, V var3):第一个参数是key，将第三个参数值放在第二个参数值左边，如果第二个参数值存在的话 
    @Override
    public void run(String... args) throws Exception {
        Long size = redisTemplate.opsForList().leftPush("list_test", "A", "A-");
        log.info("集合大小:{}", size);
        log.info("success");
    }
  • Long leftPushAll(K var1, V... var2)与Long leftPushAll(K var1, Collection<V> var2):都是批量往列表中插入数据,从左边插入 
    @Override
    public void run(String... args) throws Exception {
        // 添加三个元素进去
        List<String> stringList = new ArrayList<>();
        stringList.add("A");
        stringList.add("A");
        stringList.add("A");
        redisTemplate.opsForList().leftPushAll("list_test", stringList);
        redisTemplate.opsForList().leftPushAll("list_test", "B", "C", "D");
        log.info("success");
    }
  • V leftPop(K var1):从左边弹出一个值并在原集合中删除 
    @Override
    public void run(String... args) throws Exception {
        String leftPop = (String) redisTemplate.opsForList().leftPop("list_test");
        log.info("左边弹出的值为:{}", leftPop);
        log.info("success");
    }
  • V leftPop(K var1, long var2, TimeUnit var4):从左边弹出数据，如果列表是空的，等待var2时间，超过这个时间，不管有没有值都会返回 
    @Override
    public void run(String... args) throws Exception {
        String leftPop = (String) redisTemplate.opsForList().leftPop("list_test", 5L, TimeUnit.SECONDS);
        log.info("左边弹出的值为:{}", leftPop);
        log.info("success");
    }
  • Long leftPushIfPresent(K var1, V var2):如果K这个集合存在，则从左边添加value，不存在则不添加 
    @Override
    public void run(String... args) throws Exception {
        Long aLong = redisTemplate.opsForList().leftPushIfPresent("list_test1", "B");
        log.info("添加数量:{}", aLong);
        log.info("success");
    }
  • Long rightPush(K var1, V var2):从列表右边插入一条数据，返回集合大小 
    @Override
    public void run(String... args) throws Exception {
        Long rightPush = redisTemplate.opsForList().rightPush("list_test", "B");
        log.info("集合大小:{}", rightPush);
        log.info("success");
    }
  • Long rightPush(K var1, V var2, V var3):第一个参数是key，将第三个参数值放在第二个参数值右边，如果第二个参数值存在的话 
    @Override
    public void run(String... args) throws Exception {
        Long size = redisTemplate.opsForList().rightPush("list_test", "B", "B-");
        log.info("集合大小:{}", size);
        log.info("success");
    }
  • Long rightPushAll(K var1, V... var2)与Long rightPushAll(K var1, Collection<V> var2):都是批量往列表中插入数据,从右边插入 
    @Override
    public void run(String... args) throws Exception {
        // 添加三个元素进去
        List<String> stringList = new ArrayList<>();
        stringList.add("E");
        stringList.add("E");
        stringList.add("E");
        redisTemplate.opsForList().rightPushAll("list_test", stringList);
        redisTemplate.opsForList().rightPushAll("list_test", "F", "G", "H");
        log.info("success");
    }
  • V rightPop(K var1):从右边弹出一个值并在原集合中删除 
    @Override
    public void run(String... args) throws Exception {
        String listTest = (String) redisTemplate.opsForList().rightPop("list_test");
        log.info("右边获取的值:{}", listTest);
        log.info("success");
    }
  • V rightPop(K var1, long var2, TimeUnit var4):从右边弹出数据，如果列表是空的，等待var2时间，超过这个时间，不管有没有值都会返回 
    @Override
    public void run(String... args) throws Exception {
        String rightPop = (String) redisTemplate.opsForList().rightPop("list_test", 5L, TimeUnit.SECONDS);
        log.info("左边弹出的值为:{}", rightPop);
        log.info("success");
    }
  • Long rightPushIfPresent(K var1, V var2):如果K这个集合存在，则从右边添加value，不存在则不添加 
    @Override
    public void run(String... args) throws Exception {
        Long aLong = redisTemplate.opsForList().rightPushIfPresent("list_test1", "a");
        log.info("添加数量:{}", aLong);
        log.info("success");
    }
  • V rightPopAndLeftPush(K var1, K var2):从右边弹出一个值，保存到一个新的列表中(从新集合左边插入) 
    @Override
    public void run(String... args) throws Exception {
        String rightPopAndLeftPush = (String) redisTemplate.opsForList().rightPopAndLeftPush("list_test", "list_test1");
        log.info("value:{}", rightPopAndLeftPush);
        log.info("success");
    }

  • V rightPopAndLeftPush(K var1, K var2, long var3, TimeUnit var5):从右边弹出一个值，如果列表是空的，则最多等待var3时间，保存到一个新的列表中(从新集合左边插入) 
    @Override
    public void run(String... args) throws Exception {
        String rightPopAndLeftPush = (String) redisTemplate.opsForList().rightPopAndLeftPush("list_test", "list_test1", 5L, TimeUnit.SECONDS);
        log.info("value:{}", rightPopAndLeftPush);
        log.info("success");
    }
  • Long size(K var1):返回列表大小 
    @Override
    public void run(String... args) throws Exception {
        Long size = redisTemplate.opsForList().size("list_test");
        log.info("集合大小:{}", size);
        log.info("success");
    }
  • Long remove(K var1, long var2, Object var4): 列表中的值是可重复的，这个方法的作用是从列表中删除值等于var4的元素。var2> 0：删除var2个从左到右移动的值等于var4的元素；var2< 0：删除var2个从右到左移动的值等于var4元素；var2 = 0：删除等于value的所有元素。 var2大于0: 
    @Override
    public void run(String... args) throws Exception {
        Long remove = redisTemplate.opsForList().remove("list_test", 2, "B-");
        log.info("移除数量:{}", remove);
        log.info("success");
    }

var2小于0:

    @Override
    public void run(String... args) throws Exception {
        // 添加一个元素进去
        redisTemplate.opsForList().leftPush("list_test", "B-");
        Long remove = redisTemplate.opsForList().remove("list_test", -2, "B-");
        log.info("移除数量:{}", remove);
        log.info("success");
    }

var2等于0:

    @Override
    public void run(String... args) throws Exception {
        // 添加三个元素进去
        List<String> stringList = new ArrayList<>();
        stringList.add("A");
        stringList.add("A");
        stringList.add("A");
        redisTemplate.opsForList().leftPushAll("list_test", stringList);
        log.info("success");
    }
    @Override
    public void run(String... args) throws Exception {
        Long remove = redisTemplate.opsForList().remove("list_test", 0, "A");
        log.info("删除数量:{}", remove);
        log.info("success");
    }

  • List<V> range(K var1, long var2, long var4):获取指定区间的值，0，-1是获取所有 
    @Override
    public void run(String... args) throws Exception {
        List<String> listTest = redisTemplate.opsForList().range("list_test", 0, -1);
        listTest.forEach(s -> {
            log.info("value:{}", s);
        });
        log.info("success");
    }
  • V index(K var1, long var2):获取列表中指定位置的值（列表中的值不会被删除） 
    @Override
    public void run(String... args) throws Exception {
        String value = (String) redisTemplate.opsForList().index("list_test", 3);
        log.info("value:{}", value);
        log.info("success");
    }
  • Long indexOf(K var1, V var2):获取值第一次出现的下标 
    @Override
    public void run(String... args) throws Exception {
        Long aLong = redisTemplate.opsForList().indexOf("list_test", "A");
        log.info("第一次出现的下标:{}", aLong);
        log.info("success");
    }
  • Long lastIndexOf(K var1, V var2):获取值最后一次出现的下标 
@Override
    public void run(String... args) throws Exception {
        Long aLong = redisTemplate.opsForList().lastIndexOf("list_test", "A");
        log.info("最后一次出现的下标:{}", aLong);
        log.info("success");
    }
  • void set(K var1, long var2, V var4):在集合的指定位置插入元素,如果指定位置已有元素，则覆盖，没有则新增，超过集合下标+n则会报错 
    @Override
    public void run(String... args) throws Exception {
        redisTemplate.opsForList().set("list_test", 0, "GG");
        log.info("success");
    }
  • void trim(K var1, long var2, long var4):将列表中的数据进行截取，只保留指定的数据 
    @Override
    public void run(String... args) throws Exception {
        redisTemplate.opsForList().trim("list_test", 0, 1);
        log.info("success");
    }
  • Boolean delete(K key):删除整个集合，想删除其中一个值的话请用remove方法 
    @Override
    public void run(String... args) throws Exception {
        Boolean delete = redisTemplate.delete("list_test");
        log.info("是否删除:{}", delete);
        log.info("success");
    }

7、Zset类型常用api

  • Boolean add(K var1, V var2, double var3):添加元素到变量中同时指定元素的分值(K,V已存在的情况下,score覆盖) 
    @Override
    public void run(String... args) throws Exception {
        Boolean add = redisTemplate.opsForZSet().add("zset_test", "A", 1);
        log.info("是否添加:{}", add);
        log.info("success");
    }
  • Long add(K var1, Set<ZSetOperations.TypedTuple<V>> var2):通过TypedTuple方式新增数据 
    @Override
    public void run(String... args) throws Exception {
        ZSetOperations.TypedTuple<Object> typedTuple = new DefaultTypedTuple("B", 2.0);
        ZSetOperations.TypedTuple<Object> typedTuple3 = new DefaultTypedTuple("C", 3.0);
        Set<ZSetOperations.TypedTuple<Object>> typedTupleSet = new HashSet<ZSetOperations.TypedTuple<Object>>();
        typedTupleSet.add(typedTuple);
        typedTupleSet.add(typedTuple3);
        Long zsetTest = redisTemplate.opsForZSet().add("zset_test", typedTupleSet);
        log.info("数量:{}", zsetTest);
        log.info("success");
    }
  • Set<V> range(K var1, long var2, long var4):正序获取指定区间的值，0，-1是获取所有 
    @Override
    public void run(String... args) throws Exception {
        Set<String> setTest = redisTemplate.opsForZSet().range("zset_test", 0, -1);
        setTest.forEach(s -> {
            log.info("value:{}", s);
        });
        log.info("success");
    }
  • Set<V> reverseRange(K var1, long var2, long var4):倒序获取指定区间的值，0，-1是获取所有 
    @Override
    public void run(String... args) throws Exception {
        Set<String> setTest = redisTemplate.opsForZSet().reverseRange("zset_test", 0, -1);
        setTest.forEach(s -> {
            log.info("value:{}", s);
        });
        log.info("success");
    }
  • Set<V> rangeByScore(K var1, double var2, double var4):根据分值获取值 
    @Override
    public void run(String... args) throws Exception {
        Set<String> test = redisTemplate.opsForZSet().rangeByScore("zset_test", 0, 7);
        test.forEach(s -> {
            log.info("value:{}", s);
        });
        log.info("success");
    }
  • Long remove(K var1, Object... var2):移除集合中的数据 
    @Override
    public void run(String... args) throws Exception {
        Long remove = redisTemplate.opsForZSet().remove("zset_test", "A", "B");
        log.info("移除数量:{}", remove);
        log.info("success");
    }
  • Long removeRange(K var1, long var2, long var4):移除指定位置的数据 
    @Override
    public void run(String... args) throws Exception {
        Long remove = redisTemplate.opsForZSet().removeRange("zset_test", 0, 1);
        log.info("移除数量:{}", remove);
        log.info("success");
    }
  • Long zCard(K var1):获取变量中元素的个数（set集合中不能有重复的值） 
    @Override
    public void run(String... args) throws Exception {
        redisTemplate.opsForZSet().add("zset_test", "A", 1);
        redisTemplate.opsForZSet().add("zset_test", "B", 2);
        redisTemplate.opsForZSet().add("zset_test", "A", 3);
        Long card = redisTemplate.opsForZSet().zCard("zset_test");
        log.info("元素的个数:{}", card);
        log.info("success");
    }
  • Long size(K var1):获取集合大小 
    @Override
    public void run(String... args) throws Exception {
        Long size = redisTemplate.opsForZSet().size("zset_test");
        log.info("集合大小:{}", size);
        log.info("success");
    }
  • Long removeRangeByScore(K var1, double var2, double var4):根据分值移除区间元素 
    @Override
    public void run(String... args) throws Exception {
        Long removeRangeByScore = redisTemplate.opsForZSet().removeRangeByScore("zset_test", 0, 2);
        log.info("移除区间元素个数:{}", removeRangeByScore);
        log.info("success");
    }
  • Long count(K var1, double var2, double var4):根据分值查询元素个数 
    @Override
    public void run(String... args) throws Exception {
        redisTemplate.opsForZSet().add("zset_test", "F",6);
        Long count = redisTemplate.opsForZSet().count("zset_test", 0, 3);
        log.info("元素个数:{}", count);
        log.info("success");
    }
  • Double incrementScore(K var1, V var2, double var3):修改元素的分值（原子增加相应的值，注意是相加） 
    @Override
    public void run(String... args) throws Exception {
        Double aDouble = redisTemplate.opsForZSet().incrementScore("zset_test", "A", 5);
        log.info("修改之后的值:{}", aDouble);
        log.info("success");
    }
  • Long intersectAndStore(K var1, K var2, K var3):获取两个集合的交集放到第三个集合中，分值相加 
    @Override
    public void run(String... args) throws Exception {
        redisTemplate.opsForZSet().add("zset_test1", "A", 1);
        Long aLong = redisTemplate.opsForZSet().intersectAndStore("zset_test", "zset_test1", "zset_test2");
        log.info("交集数量:{}", aLong);
        log.info("success");
    }
  • Long intersectAndStore(K var1, Collection<K> var2, K var3):获取第一个集合与多个集合的交集放在第三个集合中 
    @Override
    public void run(String... args) throws Exception {
        List<String> stringList = new ArrayList<>();
        stringList.add("zset_test1");
        Long aLong = redisTemplate.opsForZSet().intersectAndStore("zset_test", stringList, "zset_test3");
        log.info("交集数量:{}", aLong);
        log.info("success");
    }
  • Long unionAndStore(K var1, K var2, K var3):获取两个集合中的并集数据放入第三个集合中 
    @Override
    public void run(String... args) throws Exception {
        Long unionAndStore = redisTemplate.opsForZSet().unionAndStore("zset_test", "zset_test1", "zset_test4");
        log.info("并集数量:{}", unionAndStore);
        log.info("success");
    }
  • Long unionAndStore(K var1, Collection<K> var2, K var3):获取多个集合的并集数据放入第三个集合中 
    @Override
    public void run(String... args) throws Exception {
        List<String> stringList = new ArrayList<>();
        stringList.add("zset_test1");
        Long unionAndStore = redisTemplate.opsForZSet().unionAndStore("zset_test", stringList, "zset_test5");
        log.info("并集数量:{}", unionAndStore);
        log.info("success");
    }
  • Double score(K var1, Object var2):获取元素的分值 
    @Override
    public void run(String... args) throws Exception {
        Double score = redisTemplate.opsForZSet().score("zset_test", "A");
        log.info("分值:{}", score);
        log.info("success");
    }
  • Set<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K var1, double var2, double var4):通过分值获取RedisZSetCommands.Tuples的区间值 
    @Override
    public void run(String... args) throws Exception {
        Set<ZSetOperations.TypedTuple<String>> zsetTest = redisTemplate.opsForZSet().rangeByScoreWithScores("zset_test", 1, 7);
        Iterator<ZSetOperations.TypedTuple<String>> iterator = zsetTest.iterator();
        while (iterator.hasNext()){
            ZSetOperations.TypedTuple<String> next = iterator.next();
            log.info("value:{}", next.getValue());
            log.info("score:{}", next.getScore());
        }
        log.info("success");
    }
  • Set<ZSetOperations.TypedTuple<V>> reverseRangeByScoreWithScores(K var1, double var2, double var4):根据分值倒叙排序获取区间值 
    @Override
    public void run(String... args) throws Exception {
        Set<ZSetOperations.TypedTuple<String>> zsetTest = redisTemplate.opsForZSet().reverseRangeByScoreWithScores("zset_test", 1, 10);
        Iterator<ZSetOperations.TypedTuple<String>> iterator = zsetTest.iterator();
        while (iterator.hasNext()){
            ZSetOperations.TypedTuple<String> next = iterator.next();
            log.info("value:{}", next.getValue());
            log.info("score:{}", next.getScore());
        }
        log.info("success");
    }

5、结尾

下两篇文章要记录的应该是RocketMq和Netty了！

如果你觉得我的文章对你有帮助话，欢迎关注我的微信公众号:"一个快乐又痛苦的程序员"（无广告，单纯分享原创文章、已pj的实用工具、各种Java学习资源，期待与你共同进步)

人做事
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
collections求和方法_collections——高性能容器数据类型
weixin_39617685的博客
12-20 329
由于最近对机器学习算法感兴趣，一直知道python有一个包collections封装了一些比dict,list之类高级点的类，所以抽空研究下，为接下来的工作准备。主要参考是https://docs.python.org/2/library/collections.html#defaultdict-objects官方的文档，根据不高的英文水平翻译和理解总结出来的，如果有错误欢迎提醒，万一，您有兴趣转...
JavaSE进阶：332-357抽象类和接口
qq_43568982的博客
10-29 225
抽象类 抽象类就没办法实例化对象了 抽象类和抽象类还可以往上抽象 抽象类也属于引用数据类型 [修饰符列表] abstract class 类名 { 类体; } 抽象类是用于子类来继承的，子类可以实例化 abstract 和 final不能同时出现，同时联用就报错，两个关键字是对立的 无参构造自带super，调用父类无参； 但如果给了有参构造，无参就没办法继承了 至于什么时候申明abstract，以后再做分析 ...
Collectors.groupingBy 排序
zh_404的博客
06-21 8677
Collectors.groupingBy排序
Redis基础操作-增删查改
最新发布
Loading82_的博客
05-30 1053
基础的redis增删查改操作，适合0基础的同学阅读，未涉及缓存配置
redis学习(二）--- 数据结构和常用命令
LinDongTian
06-09 255
前言： Redis可以存储键与5种不同数据结构类型之间的映射，这5种数据结构类型分别为String（字符串）、List（列表）、Set（集合）、Hash（散列）和 Zset（有序集合）。 RedisTemplate中定义了对5种数据结构操作 redisTemplate.opsForValue();//操作字符串 redisTemplate.opsForHash();//操作hash...
【Java 基础】Collectors 使用小结
z69183787的专栏
06-28 2445
stream()
RedisAPI与常用数据类型简介
02-26
首先，不得不说Redis官方提供了众多的API开发包，但是目前Redis官方版本不支持.Net直接进行连接，需要使用一些第三方的开源类库。目前最流行的就是ServiceStack.Redis这个开源项目，其在GitHub上的下载地址为：...
redis常用命令小结
09-10
Redis常用命令小结 Redis是一种基于内存的NoSQL数据库，具有高性能、低延迟和高可扩展性的特点。下面将介绍一些Redis常用的命令，这些命令可以帮助用户更好地使用Redis。 1. Redis-Benchmark命令 Redis-Benchmark...
redis常用操作
02-24
Jedis是Java语言中的一个Redis客户端，提供了丰富的API以便于与Redis服务器进行交互。以下将详细讲解Redis的常用操作以及如何通过Jedis进行实现。 一、测试连通性 在使用Jedis与Redis服务器建立连接前，我们通常会...
SpringDataRedis对Redis的数据类型的常用操作API的使用代码举例.zip
03-23
这个压缩包文件“SpringDataRedis对Redis的数据类型的常用操作API的使用代码举例.zip”显然包含了关于如何利用Spring Data Redis进行Redis数据类型操作的示例代码。下面我们将深入探讨Spring Data Redis对Redis主要...
mongodb创建图书管理_索引及集合管理 - MongoDB从入门到删库
weixin_32135505的博客
12-31 330
MongoTemplate提供了一些用于管理索引和集合的方法。这些方法被收集到一个名为IndexOperations的帮助接口中。您可以通过调用indexOps方法并传入集合名或实体的java.lang.Class来访问这些操作(集合名称来自 .class，或名称，或注释元数据)。创建索引您可以使用MongoTemplate类在集合上创建索引，以提高查询性能，还可以使用IndexDefinitio...
collections求和方法_java集合求和最大值最小值示例分享
weixin_39576133的博客
12-20 268
package com.happyelements.athene.game.util;import static com.google.common.base.Preconditions.checkNotNull;import java.util.Collection;import com.google.common.collect.Lists;/*** Math工具类** @version 1....
Spring中使用Redis之有序集合类型
weixin_42146366的博客
04-27 1410
一、Redis有序集合简介 有序集合和集合类似，只是说它的有序的，和无序集合的主要区别在于每一个元素除了值以外，它还会多一个分数。分数是一个浮点数，在Java中是使用双精度来表示的，根据分数，Redis就可以支持对分数从小到大或者从大到小到排序。这里和无序集合一样，对于每一个元素都是唯一到，但是对于不同元素而言，它的分数可以是一样的。元素也String数据类型，也是一种基于Hash的存储结构。集合...
collections求和方法_Groovy: 对Collection进行sum操作
weixin_39919089的博客
12-20 898
在Groovy里， 如果要对一个Collection或数组里的元素求和，只需要调用一下sum方法既可def list = [1,2,3,4,5,6,7,8];println list.sum(); // Output：36println list.sum(10); // Output：46sum可以有参数， 也可以没有参数。 有参数的话参数也会被记入总和。不仅仅是数值类型的collection可以...
collections求和方法_获取两个列表的元素求和的最快方法
weixin_39953244的博客
12-20 116
I can do elementwise operation like sum using Zipped function. Let I have two Lists L1 and L2 as shown belowval L1 = List(1,2,3,4)val L2 = List(5,6,7,8)I can take element wise sum in following way(L1,...
CollectorUtils工具类实现求和、求平均值等方法
ego_rainki
08-12 590
CollectorUtils工具类实现求和、求平均值等方法
collections求和方法_Java8中Collectors求和功能的自定义扩展
weixin_39883374的博客
12-20 373
起因业务中需要将一组数据分类后收集总和，原本可以使用Collectors.summingInt()，但是我们的数据源是BigDecimal类型的，而Java8原生只提供了summingInt、summingLong、summingDouble三种基础类型的方法。于是就自己动手丰衣足食吧。。期望目标：Map result = Arrays.stream(records).parallel().col...
js 中转换成list集合_java stream中Collectors的用法
weixin_30362743的博客
12-26 813
简介在java stream中，我们通常需要将处理后的stream转换成集合类，这个时候就需要用到stream.collect方法。collect方法需要传入一个Collector类型，要实现Collector还是很麻烦的，需要实现好几个接口。于是java提供了更简单的Collectors工具类来方便我们构建Collector。下面我们将会具体讲解Collectors的用法。假如我们有这样两个li...
collections求和方法_collection中sum求和
weixin_39886619的博客
12-20 633
# collection中sum求和## 计算下列数组中`order_products`下数组元素`price`的和开始前，使用 `composer require illuminate/support`，获得collect的相关支持。```// 引入packagerequire __DIR__ . '/vendor/autoload.php';$orders = [['id' ...
springboot整合redis常用api
05-13
Spring Boot整合Redis，需要使用Redis的Java客户端库，通常使用Jedis或Lettuce。在使用Jedis或Lettuce时，需要在pom.xml文件中添加对应的依赖。...以上是Redis常用的一些API，可以根据自己的需求选择合适的API。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值