redis五种数据类型在Java中的常用方法

 首先介绍一下五种数据类型,及其使用场景

  1. 字符串(String):字符串是最基本的数据类型,存储的是二进制安全的字节序列。字符串可以存储任何类型的数据,例如文本、数字、JSON字符串等。常用的操作包括设置值、获取值、删除值等。

    特点和使用场景:

    • 适用于缓存、计数器、分布式锁等场景。
    • 支持各种字符串操作,如追加、截取、替换等。
    • 可以使用字符串作为简单的消息队列。
  2. 列表(List):列表是有序的字符串列表,允许重复的元素。列表的底层实现是双向链表。可以在列表的两端进行插入和删除操作,也可以根据索引进行访问和修改。

    特点和使用场景:

    • 适用于保存一系列有序的元素。
    • 可以通过索引、范围等方式获取部分元素。
    • 常用于实现消息队列、栈、历史记录等功能。
  3. 集合(Set):集合是无序、唯一的字符串集合。集合内部的元素是无序的,且不允许重复。支持集合的基本操作,如添加元素、删除元素、判断元素是否存在等。

    特点和使用场景:

    • 适用于存储唯一的、无序的元素。
    • 可以进行集合的交集、并集、差集等操作。
    • 常用于解决一些去重、关联、标签等问题。
  4. 哈希(Hash):哈希是一个字符串字段和值的映射表。每个哈希可以存储多个字段和对应的值,每个字段都有一个唯一的标识符。支持单个字段的读写操作,也可以同时获取或修改多个字段。

    特点和使用场景:

    • 适用于存储和访问结构化数据。
    • 可以方便地进行单个字段的读取和修改操作,不需要加载整个哈希。
    • 常用于存储对象、用户信息、配置信息等。
  5. 有序集合(Sorted Set):有序集合类似于集合,但每个元素都关联了一个分数(score)。分数用于对元素进行排序,使得有序集合中的元素是按照分数从小到大排列的。支持根据分数的范围或成员进行查询。

    特点和使用场景:

    • 适用于需要元素有序的场景。
    • 可以按照分数进行范围查找、获取某个元素的排名等操作。
    • 常用于排行榜、计数器、优先级队列等功能。

下面是我自己写的一个类,注释都有写方法的作用,这里我在最后给没一个redis都添加了有效期,防止redis数据存储过多的情况。

package com.example.demo3.control;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@RestController
public class RedisTest {
    @Autowired
    RedisTemplate redisTemplate;

    @GetMapping("/stringTest")
    public void redisStringTest() {
        System.out.println("redis测试请求");
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //设置redis值
        valueOperations.set("xiaoyu", "123");
        //获取
        Object xiaoyu = valueOperations.get("xiaoyu");

        System.out.println("拿到的数据为:" + xiaoyu);
        //追加字符串
        Integer append = valueOperations.append("xiaoyu", "4");
        System.out.println(append);
        System.out.println("追加之后的数据为:" + valueOperations.get("xiaoyu"));
        //自增操作
        valueOperations.increment("xiaoyu", 1);
        System.out.println("自增后的数据:" + valueOperations.get("xiaoyu"));
        //自减操作
        valueOperations.decrement("xiaoyu", 1);
        System.out.println("自减后的数据:" + valueOperations.get("xiaoyu"));

        System.out.println("数据:" + valueOperations.get("xiaoyu"));
        //设置过期时间
        valueOperations.set("xiaoyuTime", "小俞差不多吃饭了", 60, TimeUnit.HOURS);
        System.out.println("数据:" + valueOperations.get("xiaoyuTime"));
        Long xiaoyuTime = redisTemplate.getExpire("xiaoyuTime");
        System.out.println("剩余时间为:" + xiaoyuTime);

        //获取字符串的子串
        Boolean xiaoyu1 = redisTemplate.hasKey("xiaoyu");
        Boolean xiaoyu23 = redisTemplate.hasKey("xiaoyu23");
        System.out.println(xiaoyu1 + "  " + xiaoyu23);
        redisTemplate.expire("xiaoyu",60,TimeUnit.SECONDS);
        Long listKey3 = redisTemplate.getExpire("xiaoyu");
        System.out.println("剩余的时间为"+listKey3);
    }

    @GetMapping("/hashTest")
    public void redisHashTest() {
        HashOperations hashOperations = redisTemplate.opsForHash();
        //存储hash值
        hashOperations.put("hashKey", "fileKey", "123");
        hashOperations.put("hashKey", "xiaoyu", "1232");
        //获取hash值
        Object value = hashOperations.get("hashKey", "fileKey");
        System.out.println("获取到的hash值:" + value);
        System.out.println("获取到的hash值:" + hashOperations.get("hashKey", "xiaoyu"));
        //判断是否存在
        Boolean hasKey = hashOperations.hasKey("hashKey", "xiaoyu");
        System.out.println(hasKey + "  " + hashOperations.hasKey("hashKey", "xiaoyu1" + "  "));
        Boolean aBoolean = hashOperations.hasKey("hashKey1", "xiaoyu");
        System.out.println(aBoolean);
        //获取所有的值
        Set keys = hashOperations.keys("hashKey");
        //遍历
        for (Object key : keys) {
            System.out.println(key);
        }
        System.out.println();
        //获取所有的字段和值
        Map<Object,Object> hashKey = hashOperations.entries("hashKey");
        for (Map.Entry<Object, Object> entry:hashKey.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        //获取字段个数
        Long size = hashOperations.size("hashKey");
        System.out.println(size);
        //删除字段
//        hashOperations.delete("hashKey","fileKey");
//        System.out.println("删除后数据的长度为:"+hashOperations.size("hashKey"));
        //获取多个字段的值
        List<Object> list = hashOperations.multiGet("hashKey", Arrays.asList("xiaoyu", "fileKey"));
        for (Object values:list) {
            System.out.println(values);
        }
        //设置过期时间
        redisTemplate.expire("hashKey",60,TimeUnit.SECONDS);
        Long hashKey1 = redisTemplate.getExpire("hashKey");
        System.out.println("剩余过期时间为:"+hashKey1);

    }
    @GetMapping("/listTest")
    public void redisListTest(){
        ListOperations listOperations = redisTemplate.opsForList();
        //尾部增加数据
        listOperations.rightPush("listKey", "xiaoyu1");
        listOperations.rightPush("listKey", "xiaoyu2");
        listOperations.rightPush("listKey", "xiaoyu3");
        //头部增加数据
        listOperations.leftPush("listKey", "xiaoyu0");
        //获取指定范围内的值
        List<Object> range = listOperations.range("listKey", 0, -1);
        for (Object value : range) {
            System.out.println(value);
        }
        //获取指定位置的值
        Object listKey = listOperations.index("listKey", 1);
        System.out.println("获取指定位置元素的值"+listKey);
        //获取列表长度
        Long listKey1 = listOperations.size("listKey");
        System.out.println("列表的长度:"+listKey1);
        //删除尾部的一个值
        listOperations.rightPop("listKey");
        //删除头部的一个值
        listOperations.leftPop("listKey");
        List<Object> range1 = listOperations.range("listKey", 0, -1);
        for (Object value : range1) {
            System.out.println("删除后的元素为"+value);
        }
        System.out.println();
        //删除其他元素只保留指定范围内的元素
        List<Object> range3 = listOperations.range("listKey", 0, -1);
        for (Object value : range3) {
            System.out.println("删除前"+value);
        }
        System.out.println();
        listOperations.trim("listKey",0,4);
        List<Object> range4 = listOperations.range("listKey", 0, -1);
        for (Object value : range4) {
            System.out.println("删除后"+value);
        }
        //删除指定位置之后的若干个元素
        /**
         * remove 方法的第一个参数为列表的键名,第二个参数为要移除元素的数量,第三个参数为要移除的元素值。移除数量可以为正数、负数或零,具体含义如下:
         * 正数:从列表头开始,移除指定数量的与给定值相等的元素;
         * 负数:从列表尾开始,移除指定数量的与给定值相等的元素;
         * 零:移除所有与给定值相等的元素。
         */
        listOperations.remove("listKey",2,"xiaoyu1");
        List<Object> range5 = listOperations.range("listKey", 0, -1);
        for (Object value : range5) {
            System.out.println("移除指定元素之后:"+value);
        }
        listOperations.set("listKey",0,"小俞123");
        Object listKey2 = listOperations.index("listKey", 0);
        System.out.println("修改后的值为:"+listKey2);
        //设置过期时间
        redisTemplate.expire("listKey",60,TimeUnit.SECONDS);
        Long listKey3 = redisTemplate.getExpire("listKey");
        System.out.println("剩余的时间为"+listKey3);
    }
    @GetMapping("/setTest")
    public void redisSetTest(){
        SetOperations setOperations = redisTemplate.opsForSet();
        //给集合添加元素
        setOperations.add("setTest","xiaoyu1","xiaoyu2","xiaoyu3");
        Set setTest = setOperations.members("setTest");
        System.out.println("获取到集合的值"+setTest);
        //判断是否有指定元素
        Boolean member = setOperations.isMember("setTest", "xiaoyu1");
        System.out.println(member);
        //集合大小
        Long size = setOperations.size("setTest");
        System.out.println("set集合大小:"+size);
        //移除指定一个或多个元素
        Long remove = setOperations.remove("setTest", "xiaoyu1", "xiaoyu2");
        System.out.println("移除的个数为:"+remove);
        Long remove2 = setOperations.remove("setTest", "xiaoyu0", "xiaoyu3");
        System.out.println("移除的个数为:"+remove2);
        //两个集合的差集(只属于前一集合的元素)
        setOperations.add("set1","1","2","3","5");
        setOperations.add("set2","1","2","3","4");
        Set difference = setOperations.difference("set1", "set2");
        System.out.println("集合1和集合2的差集"+difference);
        Set difference1 = setOperations.difference("set2", "set1");
        System.out.println("集合2和集合1的差集"+difference1);
        System.out.println("集合1和集合1的差集"+setOperations.difference("set1", "set1"));
        //两个集合的交集
        Set intersect = setOperations.intersect("set2", "set1");
        System.out.println("两个集合的交集:"+intersect);
        //两个集合的并集
        Set union = setOperations.union("set2", "set1");
        System.out.println("两个集合的并集:"+union);

        redisTemplate.expire("setTest",60,TimeUnit.SECONDS);
        redisTemplate.expire("set1",60,TimeUnit.SECONDS);
        redisTemplate.expire("set2",60,TimeUnit.SECONDS);
    }
    @GetMapping("/zSetTest")
    public void redisZSetTest(){
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
        //添加zset集合元素
        zSetOperations.add("zSetTest","xiaoyu0",0);
        zSetOperations.add("zSetTest","xiaoyu1",3);
        zSetOperations.add("zSetTest","xiaoyu2",4);
        zSetOperations.add("zSetTest","xiaoyu3",2);
        //获取所有集合元素 0 -1表示获取所有的,也可以获取指定范围内的
        Set zSetTest = zSetOperations.range("zSetTest", 0, -1);
        System.out.println("集合的元素为:"+zSetTest);
        //获取集合数量
        Long zSetTest1 = zSetOperations.size("zSetTest");
        System.out.println("集合的大小为:"+zSetTest1);
        //有序集合中元素的排名(从小到大)
        Long rank = zSetOperations.rank("zSetTest", "xiaoyu2");
        System.out.println("获取集合的排名为:"+rank);
        //根据范围获取集合的元素
        Set zSetTest2 = zSetOperations.rangeByScore("zSetTest", 2, 3);
        System.out.println("在范围内的集合元素为:"+zSetTest2);
        //为空
        System.out.println(zSetOperations.rangeByScore("zSetTest", 4, 3));
        //给某一个元素添加或减少分数
        Double aDouble = zSetOperations.incrementScore("zSetTest", "xiaoyu0", 1);
        System.out.println("增加后的分数为:"+aDouble);
        zSetOperations.remove("zSetTest","xiaoyu1");
        System.out.println("移除元素后的集合数据为:"+zSetOperations.range("zSetTest",0,-1));
        
        redisTemplate.expire("zSetTest",60,TimeUnit.SECONDS);
        Long zSetTest3 = redisTemplate.getExpire("zSetTest");
        System.out.println("集合剩余的有效时间为:"+zSetTest3);
    }
}

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值