redis的5种数据类型

最新推荐文章于 2023-09-05 19:30:40 发布
最新推荐文章于 2023-09-05 19:30:40 发布
阅读量166 收藏 1
点赞数
分类专栏： 关于redis 文章标签： redis java 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40095187/article/details/116064993
版权

简单记录一下redis的五种基本类型

一、String： key-value

命令

set key value
get key

二、Hash：key-filed-value

相当于1个key 对应一个map

在这里插入图片描述

hset key filed value 设置值
hget key filed 　获取值

三、List
List 有顺序可重复

lpush list 1 2 3 4 从左添加元素　
rpush list 1 2 3 4 从右添加元素
lrange list 0 -1 (从0 到-1 元素查看：也就表示查看所有)
lpop list （从左边取，删除）
rpop list (从右边取，删除)

四、SortedSet（zset）
　　
有顺序，不能重复

适合做排行榜 排序需要一个分数属性

zadd zset1 9 a 8 c 10 d 1 e （添加元素 zadd key score member ）

(ZRANGE key start stop [WITHSCORES])(查看所有元素：zrange key 0 -1 withscores)

如果要查看分数，加上withscores.

zrange zset1 0 -1 (从小到大)

zrevrange zset1 0 -1 (从大到小)

zincrby zset2 score member (对元素member 增加 score)

小结

最后放上一个自己写的redis工具类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

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

@Component
public class RedisUtil {
    @Autowired
    RedisTemplate<String, Object> redisTemplate;

    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    //=============================common============================
    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
//	public boolean expire(String key,long time){
    public boolean setTime(String key,long time){
        try {
            //	if(time>0){
            redisTemplate.expire(key, time, TimeUnit.SECONDS);
            //	}
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回	-1：永久有效 ； -2：已失效或不存在
     */
    //public long getExpire(String key){
    public long getTime(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String ... key){
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key,Object value,long time){
        try {
            if(time>0){
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            }else{
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 增加<BR/>
     * 对key的value为数值的value进行增加运算
     * @param key 键
     * @param num 要增加几(大于0增加，小于0减少)
     * @return
     */
    public long increment(String key, long num){
        return redisTemplate.opsForValue().increment(key, num);
    }

    //================================Map=================================
    /**
     * HashGet
     * @param key 键 不能为null
     * @param hashKey 项 不能为null
     * @return 值
     */
    public Object hGetHashValue(String key,String hashKey){
        return redisTemplate.opsForHash().get(key, hashKey);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object,Object> hGetHashMap(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hSetHashMap(String key, Map<String,Object> map){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hSetHashMap(String key, Map<String,Object> map, long time){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if(time>0){
                //expire(key, time);
                setTime(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param hashKey 项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hSetHashValue(String key,String hashKey,Object value) {
        try {
            redisTemplate.opsForHash().put(key, hashKey, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param hashKey 项
     * @param value 值
     * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hSetHashValue(String key,String hashKey,Object value,long time) {
        try {
            redisTemplate.opsForHash().put(key, hashKey, value);
            if(time>0){
//				expire(key, time);
                setTime(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param hashKey 项 可以使多个 不能为null
     */
    public long hDeleteHashKey(String key, Object... hashKey){
        return redisTemplate.opsForHash().delete(key,hashKey);
    }

    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param hashKey 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasHashKey(String key, String hashKey){
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
     * Hash值增加num----value需为数值类型	<BR/>
     * 如果不存在,就会创建一个，并把 num 作为value返回
     * @param key 			键
     * @param hashKey 	HashMap的键
     * @param num 		要增加几(大于0增加，小于0减少)
     * @return
     */
    public double hPlusHashValue(String key, String hashKey,double num){
        return redisTemplate.opsForHash().increment(key, hashKey, num);
    }

    /**
     * Hash值减少num----value需为数值类型	<BR/>
     * 如果不存在,就会创建一个，并把 num 作为value返回
     * @param key			键
     * @param hashKey 	HashMap的键
     * @param num			要减少几(大于0减少，小于0增加)
     * @return
     */
    public double hMinusHashValue(String key, String hashKey,double num){
        return redisTemplate.opsForHash().increment(key, hashKey,-num);
    }

    //============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set<Object> sGetSet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 查询该value是否在键为key的Set中
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasValueOnSet(String key,Object value){
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入Set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetSet(String key, Object...values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将Set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetSets(String key,long time,Object...values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            //	if(time>0) expire(key, time);
            if(time>0){
                setTime(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取Set缓存的长度
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 从Set中移除值为value的值
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long sRemoveSet(String key, Object ...values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    //===============================list=================================

    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束  0 到 -1代表所有值
     * @return
     */
    public List<Object> lGetList(String key, long start, long end){
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
    public long lGetListSize(String key){
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     * @param key 键
     * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetListByIndex(String key,long index){
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值(Object)
     * @return
     */
    public boolean lSetlist(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值(List)
     * @return
     */
    @SuppressWarnings("rawtypes")
    public boolean lSetListAll(String key, List value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值(Object)
     * @param time 时间(秒)
     * @return
     */
    public boolean lSetlist(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            //        if (time > 0) expire(key, time);
            if (time > 0) {
                setTime(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值(List)
     * @param time 时间(秒)
     * @return
     */
    @SuppressWarnings("rawtypes")
    public boolean lSetListAll(String key,  List value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            //		if (time > 0) expire(key, time);
            if (time > 0){
                setTime(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateListByIndex(String key, long index,Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemoveList(String key,long count,Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

}
JudeDong
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis支持的五种基本数据类型总结
小李的博客
05-24 502
Redis支持的五种基本数据类型总结 Redis五种数据类型 数据类型 底层原理 备注 最大存储容量 字符串 字符串 字符串类型是最基本的数据类型，也是其他四种数据类型的基础 512MB 散列 字典结构(哈希表) 散列类型的键值是一种字典结构，其存储了字段和字段值的映射，但字段值只能是字符串类型 2的32次幂-1个子段 列表 双向链表 向链表两端添加元素的时间复杂度O(1)，获取头部或尾部两端的元素速度极快，但是获取中间和通过索引访问元素比较慢 2的32次幂-1个元素 集合 散列
redis五种数据类型的使用场景
07-25
介绍redis的五种数据类型的使用场景，更便于学习redis的操作，了解使用！
Redis中的五种基本数据类型
北辰
05-28 211
2.Hash类型 Hash类型是String类型的field和value的映射表，或者说是一个String集合，它特别适合存储对象。相比较而言，将一个对象类型存储在Hash类型里要比存储在String类型里占用更少的内存空间，并方便存取整个对象。 2.3 hmset hmset命令可以进行批量存储多个键值对： hmset user id 1 name zhangsan age 25 2.4 hmget hmget命令进行批量获取多个键值对： hmget user id name a..
redis的五种基本数据类型
g1607058603的专栏
08-02 184
1、String(字符类型，即key-value数据类型，memecached也支持此类型。） 命令使用举例： set s1 66 ：设置字符串s1的值是66        get s1 del s1 incr s1 ：自增1 decr s1：自减1 2、Hash（Map，散列类型） 它提供了字段和字段的值的映射，字段值只能是字符串类型，不支持散列类型、集合类型等其他类型。如下： ...
Redis五大基本数据类型
qq_35597828的博客
08-15 240
String redis的string类型可以把它想成Byte，它有关于字符串、字节数组、数值、位图bitmap的操作 set命令 127.0.0.1:6379> set k1 hello OK 127.0.0.1:6379> get k1 "hello" 可以看出 set命令除了接 key value，还可以追加过期时间，还有两个值[NX|XX]，nx的意思是不存在的时候才去设置，可以当做分布式锁使用，哪个线程设置成功了代表拿到了锁，xx的意识是存在的时候采取设置。 除了单挑的get se
简单介绍redis五种数据类型
qq_58595750的博客
03-28 2454
1.String数据类型 string 是 redis 最基本的数据类型，最大能存储 512MB，一个 key 对应一个 value，是二进制安全的，意思是 redis 的 string 可以包含任何数据（比如jpg图片或者序列化的对象）。 2.List 数据类型 redis 列表是简单的字符串列表，按照插入顺序排序。可以添加一个元素到列表的头部（左边）或者尾部（右边）. 3.Hash数据类型（散列类型） redis中的散列可以看成具有String key和String value的map容器，可
Redis数据类型及应用场景
01-07
2、Redis的每个数据类型是处理不同业务场景而诞生，基本数据类型为5种，从redis5.0版发布后新增了Stream数据类型，如下思路图： 3、其中跳表为插入，删除，查询比较快的动态数据结构，跳表是一个值有序的链表建立...
Redis的5种数据类型与常用命令讲解
12-16
1.redis的5种数据类型： string 字符串（可以为整形、浮点型和字符串，统称为元素） list 列表（实现队列,元素不唯一，先入先出原则） set 集合（各不相同的元素） hash hash散列值（hash的key必须是唯一的） ...
Redis 数据类型
12-16
Redis 数据类型是 Redis 内存数据存储的基础，它支持五种主要的数据结构，分别是 String、Hash、List、Set 以及 Sorted Set（ZSet）。每种数据类型都有其独特的特性和用途，下面将详细介绍这些类型。 1. **String...
详解Redis 数据类型
09-08
本文将详细介绍 Redis 支持的五种数据类型：String、Hash、List、Set 和 Zset（Sorted Set）。 1. String（字符串） String 是 Redis 最基础的数据类型，它是一个二进制安全的类型，可以存储任何数据，包括文本、...
Redis有哪五种不同类型的值？应用场景有哪些？
徐明晓的博客
08-06 477
Redis有哪五种不同类型的值？应用场景有哪些？[1] String（字符串）[2] Hash（哈希）[3] List（列表）[4] Set（集合）[5] zset (sorted set：有序集合) string：redis 中字符串 value 最大可为512M.可以用来做一些计数器（也是实际工作中最常见的）. hash：键值对集合，是一个字符串类型的 Key和 Value 的映射表，也就是说其存储的Value是一个键值对（Key- Value）.可以用来存放一些具有特定结构的信息.用于用户信息管理.
redisTemplate的操作
weixin_44858201的博客
08-30 1390
Redis是一个key, value的非关系型数据库，数据是保存在内存中，可以避免频繁访问数据库而增大数据库的压力，同时提高数据响应速度，Redis数据是存放在内存中，因为他的瓶颈是内存。 使用redisTemplate Spring封装了一个比较强大的模板，也就是redisTemplate，方便在开发的时候操作Redis缓存。在Redis中可以存储String、List、Set、Hash、Zset。下面将针对List和Hash分别介绍。 引入redisTemplate 引入pom依赖 <depend
【Redis】Redis使用和RedisTemplate的方法介绍
最新发布
别倒在黎明之前的博客
09-05 2362
leftPush ：从集合左边插入值 | | 从集合左边开始在v值后边插入新值v1leftPushAll ：从左边批量插入新值 | | 从左边批量插入新值(同上)leftPushIfPresent ：如果key存在，从左边插入新值leftPop ：默认移除key中最左的一个值| |指定过期时间后删除key最左的一个值rightPopAndLeftPush ：移除k1中最右的值，并将移除的值插入k2中最左侧| |指定过期时间后，移除k1中最右的值，并将移除的值插入k2中最左侧（同上）
Redis的简单笔记
人类所有真实的快乐，一定是恒久的努力
03-04 1148
本文章《Redis的简单笔记》只是简单的记录，仅是入门的文章。 学习视频：[【狂神说Java】Redis最新超详细版教程通俗易懂](https://www.bilibili.com/video/BV1S54y1R7SB?) 截图均来来自于视频。文中还穿插着其他大佬的文章。 最后，感谢大佬们的分享。*★,°*:.☆(￣▽￣)/$:*.°★* 。 运行时异常（1/0，存在语法错误）,事务中的错误命令会不执行，其他命令依旧执行。 ...
RedisTemplate.opsForSet()用法简介并举例
一起coding，一起嗨。
08-08 3653
是RedisTemplate类提供的用于操作Set类型的方法。它可以用于对Redis中的Set数据结构进行各种操作，如添加元素、获取元素、删除元素等。请注意，示例中的"myset"是集合的键名，“value1”、"value2"等是要添加、移除或判断的元素值。方法的常见用法，你可以根据具体的业务需求选择适合的方法进行操作。
RedisTemplate的各种操作（set、hash、list、string）
热门推荐
lichuangcsdn的博客
06-30 9万+
注入以下RedisTemplate @Autowired private RedisTemplate&lt;String,String&gt; redisTemplate; 1、保存和读取Set： 代码示例： SetOperations&lt;String, String&gt; set = redisTemplate.opsForSet(); set.add("set1","22...
Spring data redis-StringRedisTemplate 用法
fengzheku的专栏
11-09 4万+
Spring data redis 的用法
RedisTemplate使用说明_04_opsForSet
皮球
04-24 1504
ScanOptions.scanOptions().match(“C”).build()匹配获取键位map1的键值对,不能模糊匹配。获取多个变量的交集并保存到最后一个参数上。获取多个变量的合集并保存到最后一个参数上。通过给定的key求2个set变量的差值。获取2个变量交集后保存到最后一个参数上。获取2个变量合集后保存到最后一个参数上。随机获取变量中指定个数的元素。转移变量的元素值到目的变量。获取多个变量之间的交集。随机获取变量中的元素。获取2个变量中的交集。获取2个变量的合集。获取多个变量的合集。
RedisTemplate常用方法总结（参考官方文档2.6.2）
凡的博客
02-27 5833
title: RedisTemplate常用方法总结（参考官方文档2.6.2） date: 2022-02-27 03:40:27 tags: Redis categories: Redis cover: https://cover.png feature: false 1. 简介 RedisTemplate 是 Spring Data Redis 提供给用户的最高级的抽象客户端，用户可直接通过 RedisTemplate进行多种操作。 1.1 类继承关系 public class RedisTem.
redis每种数据类型用途
07-28
回答: Redis中常用的5种数据类型分别是String字符串类型、List列表类型、Hash哈希类型、Set集合类型和Zset有序集合类型。每种数据类型都有不同的用途和适用场景。String字符串类型适用于存储单个值，比如存储用户...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值