• 只需5分钟，完成Redis所有命令操作~

    你好，我是田哥

    常见的面试题：redis可以存储哪些类型的数据结构？

    我在做模拟面试中发现，大部分人根本就没用过Redis，答案基本靠背。

    能去背，肯定是好事，证明你对面试还挺上进。

    但，我们为什么不能快速看看这些数据结构是如何操作的呢？

    也许，你看完这些相关操作后对你的背效果会更好。

    Redis存储的是key-value结构的数据，其中key是字符串类型，value数据类型有：

    • 字符串 string

    • 哈希 hash

    • 列表 list

    • 集合 set

    • 有序集合 sorted set / zset

    • （地理空间）特殊类型 GeoSpatial

    • 超级基数统计 HyperLogLog

    • 位图 BitMap

    在pom.xml中引入依赖（redis的java客户端之一Jedis）：

    2.     redis.clients
    3.     jedis
    4.     4.4.3

    获取redis连接：

    Jedis jedis = new Jedis("localhost", 6379);

    string 操作

    设置一个字符串键值对：

    jedis.set("key", "value");

    获取一个字符串键的值：

    String value = jedis.get("key");

    获取多个字符串键的值：

    List values = jedis.mget("key1", "key2", "key3");

    批量设置多个字符串键值对：

    1. Map keyValuePairs = new HashMap<>();
    2. keyValuePairs.put("key1", "value1");
    3. keyValuePairs.put("key2", "value2");
    4. jedis.mset(keyValuePairs);

    批量获取多个字符串键的值：

    List values = jedis.mget("key1", "key2", "key3");

    获取字符串的长度：

    long length = jedis.strlen("key");

    在键的值后面追加字符串：

    jedis.append("key", "appendValue");

    获取字符串的子串：

    String substring = jedis.getrange("key", start, end);

    设置字符串的新值，并返回旧值：

    String oldValue = jedis.getSet("key", "newValue");

    设置字符串的新值，并指定过期时间（单位：秒）：

    jedis.setex("key", seconds, "value");

    设置字符串的新值，并指定过期时间（单位：毫秒）：

    jedis.psetex("key", milliseconds, "value");

    如果键不存在，则设置字符串的值：

    jedis.setnx("key", "value");

    同时设置多个字符串键值对，如果有任何一个键已经存在，则操作不执行：

    1. Map keyValuePairs = new HashMap<>();
    2. keyValuePairs.put("key1", "value1");
    3. keyValuePairs.put("key2", "value2");
    4. jedis.msetnx(keyValuePairs);

    对字符串键的值进行自增操作：

    jedis.incr("key");

    对字符串键的值进行自增操作，并指定增加的步长：

    jedis.incrBy("key", increment);

    对字符串键的值进行浮点数自增操作，并指定增加的步长：

    jedis.incrByFloat("key", increment);

    对字符串键的值进行自减操作：

    jedis.decr("key");

    对字符串键的值进行自减操作，并指定减少的步长：

    jedis.decrBy("key", decrement);

    对字符串键的值进行浮点数自减操作，并指定减少的步长：

    jedis.decrByFloat("key", decrement);

    对字符串键的值进行位操作，并指定操作类型（AND、OR、XOR、NOT）和另一个字符串键的值：

    jedis.bitop(BitOP op, String destKey, String... srcKeys);

    对字符串键的值进行位操作，并指定操作类型（AND、OR、XOR、NOT）和位操作的结果保存的新键：

    jedis.bitop(BitOP op, String destKey, String... srcKeys);

    对字符串键的值进行位操作，并指定操作类型（AND、OR、XOR、NOT）和另一个字符串键的值，并返回操作结果的字符串表示：

    String result = jedis.bitop(BitOP op, String destKey, String... srcKeys);

    获取字符串键的位图中指定位的值：

    boolean bitValue = jedis.getbit("key", offset);

    设置字符串键的位图中指定位的值：

    boolean previousBitValue = jedis.setbit("key", offset, bitValue);

    获取字符串键的位图中指定范围内的位的值：

    BitSet bitSet = jedis.getrangebit("key", start, end);

    设置字符串键的位图中指定范围内的位的值：

    long numberOfBitsSet = jedis.setrangebit("key", offset, "bitSet");

    删除一个字符串键：

    long numberOfDeletedKeys = jedis.del("key");

    删除多个字符串键：

    long numberOfDeletedKeys = jedis.del("key1", "key2", "key3");

    请注意，上述代码中的"key"和"value"应替换为实际的键和值。

    hash操作

    HSET命令：将哈希表key中的字段field的值设为value。

    jedis.hset("myhash", "field1", "value1");

    HGET命令：获取哈希表key中给定字段field的值。

    1. Jedis jedis = new Jedis("localhost");
    2. String value = jedis.hget("myhash", "field1");
    3. System.out.println(value);

    HMSET命令：同时将多个field-value（域-值）对设置到哈希表key中。

    1. Jedis jedis = new Jedis("localhost");
    2. Map hash = new HashMap<>();
    3. hash.put("field1", "value1");
    4. hash.put("field2", "value2");
    5. jedis.hmset("myhash", hash);

    HMGET命令：获取哈希表key中，一个或多个给定字段的值。

    1. Jedis jedis = new Jedis("localhost");
    2. List values = jedis.hmget("myhash", "field1", "field2");
    3. for (String value : values) {
    4.     System.out.println(value);
    5. }

    HGETALL命令：获取哈希表key中的所有字段和值。

    1. Jedis jedis = new Jedis("localhost");
    2. Map hash = jedis.hgetAll("myhash");
    3. for (Map.Entry entry : hash.entrySet()) {
    4.     System.out.println(entry.getKey() + ": " + entry.getValue());
    5. }

    HDEL命令：删除哈希表key中的一个或多个指定字段。

    1. Jedis jedis = new Jedis("localhost");
    2. Long result = jedis.hdel("myhash", "field1");
    3. System.out.println(result);

    这些示例代码只是演示了一些常见的hash命令操作，你可以根据需要使用其他hash命令，并根据具体情况处理返回结果。

    list操作

    下面是使用Java实现Redis中所有List相关命令操作的示例代码：

    LPUSH命令：将一个或多个值插入到列表的头部

    jedis.lpush("listKey", "value1", "value2", "value3");

    RPUSH命令：将一个或多个值插入到列表的尾部

    jedis.rpush("listKey", "value4", "value5", "value6");

    LLEN命令：获取列表的长度

    Long length = jedis.llen("listKey");

    LPOP命令：移除并返回列表的头部元素

    String element = jedis.lpop("listKey");

    RPOP命令：移除并返回列表的尾部元素

    String element = jedis.rpop("listKey");

    LINDEX命令：通过索引获取列表中的元素

    String element = jedis.lindex("listKey", 2);

    LRANGE命令：获取列表中指定范围内的元素

    List elements = jedis.lrange("listKey", 0, -1);

    LREM命令：从列表中移除指定数量的元素

    Long count = jedis.lrem("listKey", 2, "value");

    LSET命令：通过索引设置列表中的元素

    jedis.lset("listKey", 0, "newValue");

    LINSERT命令：在列表中指定元素的前面或后面插入新元素

    jedis.linsert("listKey", ListPosition.BEFORE, "existingValue", "newValue");

    LTRIM命令：截取列表中指定范围的元素

    jedis.ltrim("listKey", 0, 2);

    注意：以上代码中的"listKey"为列表的键名，根据实际情况进行替换。

    set操作

    以下是使用Java实现Redis中所有set相关的命令操作的示例代码：

    1. import redis.clients.jedis.Jedis;
    2.  
    3. import java.util.List;
    4. import java.util.Set;
    5.  
    6. public class RedisSetCommands {
    7.     public static void main(String[] args) {
    8.         // 连接Redis服务器
    9.         Jedis jedis = new Jedis("localhost");
    10.  
    11.         // 添加元素到集合
    12.         jedis.sadd("set1", "element1", "element2", "element3");
    13.  
    14.         // 获取集合中的所有元素
    15.         Set set1 = jedis.smembers("set1");
    16.         System.out.println("set1: " + set1);
    17.  
    18.         // 判断元素是否存在于集合中
    19.         boolean exists = jedis.sismember("set1", "element1");
    20.         System.out.println("element1 exists in set1: " + exists);
    21.  
    22.         // 获取集合的元素数量
    23.         long size = jedis.scard("set1");
    24.         System.out.println("set1 size: " + size);
    25.  
    26.         // 从集合中随机获取一个元素
    27.         String randomElement = jedis.srandmember("set1");
    28.         System.out.println("Random element from set1: " + randomElement);
    29.  
    30.         // 从集合中移除指定的元素
    31.         jedis.srem("set1", "element2");
    32.  
    33.         // 获取集合的差集
    34.         jedis.sadd("set2", "element2", "element4");
    35.         Set difference = jedis.sdiff("set1", "set2");
    36.         System.out.println("Difference between set1 and set2: " + difference);
    37.  
    38.         // 获取集合的交集
    39.         Set intersection = jedis.sinter("set1", "set2");
    40.         System.out.println("Intersection of set1 and set2: " + intersection);
    41.  
    42.         // 获取集合的并集
    43.         Set union = jedis.sunion("set1", "set2");
    44.         System.out.println("Union of set1 and set2: " + union);
    45.  
    46.         // 将集合的元素移动到另一个集合
    47.         jedis.smove("set1", "set2", "element3");
    48.  
    49.         // 获取多个集合的并集并存储到新集合中
    50.         jedis.sunionstore("set3", "set1", "set2");
    51.         Set set3 = jedis.smembers("set3");
    52.         System.out.println("set3: " + set3);
    53.  
    54.         // 获取多个集合的交集并存储到新集合中
    55.         jedis.sinterstore("set4", "set1", "set2");
    56.         Set set4 = jedis.smembers("set4");
    57.         System.out.println("set4: " + set4);
    58.  
    59.         // 获取多个集合的差集并存储到新集合中
    60.         jedis.sdiffstore("set5", "set1", "set2");
    61.         Set set5 = jedis.smembers("set5");
    62.         System.out.println("set5: " + set5);
    63.  
    64.         // 关闭Redis连接
    65.         jedis.close();
    66.     }
    67. }

    sort set操作

    以下是使用Java实现Redis中所有sorted set相关的命令操作的示例代码：

    1. import redis.clients.jedis.Jedis;
    2. import redis.clients.jedis.Tuple;
    3. import redis.clients.jedis.ZParams;
    4.  
    5. import java.util.Map;
    6. import java.util.Set;
    7.  
    8. public class RedisSortedSetExample {
    9.     public static void main(String[] args) {
    10.         // 创建连接
    11.         Jedis jedis = new Jedis("localhost", 6379);
    12.  
    13.         // 添加元素到有序集合
    14.         jedis.zadd("myset", 1, "one");
    15.         jedis.zadd("myset", 2, "two");
    16.         jedis.zadd("myset", 3, "three");
    17.  
    18.         // 获取有序集合的成员数量
    19.         long count = jedis.zcard("myset");
    20.         System.out.println("Count: " + count);
    21.  
    22.         // 获取指定元素的分数
    23.         double score = jedis.zscore("myset", "two");
    24.         System.out.println("Score: " + score);
    25.  
    26.         // 增加指定元素的分数
    27.         jedis.zincrby("myset", 2, "two");
    28.  
    29.         // 获取有序集合中指定范围的成员
    30.         Set range = jedis.zrange("myset", 0, -1);
    31.         System.out.println("Range: " + range);
    32.  
    33.         // 获取有序集合中指定分数范围的成员
    34.         Set rangeByScore = jedis.zrangeByScore("myset", 1, 3);
    35.         System.out.println("Range by score: " + rangeByScore);
    36.  
    37.         // 获取有序集合中指定分数范围的成员和分数
    38.         Set rangeByScoreWithScores = jedis.zrangeByScoreWithScores("myset", 1, 3);
    39.         for (Tuple tuple : rangeByScoreWithScores) {
    40.             System.out.println("Member: " + tuple.getElement() + ", Score: " + tuple.getScore());
    41.         }
    42.  
    43.         // 获取有序集合中指定成员的排名（从0开始）
    44.         long rank = jedis.zrank("myset", "two");
    45.         System.out.println("Rank: " + rank);
    46.  
    47.         // 获取有序集合中指定成员的排名（从1开始）
    48.         long reverseRank = jedis.zrevrank("myset", "two");
    49.         System.out.println("Reverse rank: " + reverseRank);
    50.  
    51.         // 移除指定成员
    52.         jedis.zrem("myset", "two");
    53.  
    54.         // 获取有序集合中指定范围排名的成员
    55.         Set rangeByRank = jedis.zrange("myset", 0, -1);
    56.         System.out.println("Range by rank: " + rangeByRank);
    57.  
    58.         // 获取有序集合中指定范围排名的成员和分数
    59.         Set rangeByRankWithScores = jedis.zrangeWithScores("myset", 0, -1);
    60.         for (Tuple tuple : rangeByRankWithScores) {
    61.             System.out.println("Member: " + tuple.getElement() + ", Score: " + tuple.getScore());
    62.         }
    63.  
    64.         // 获取有序集合中指定范围内的成员数量
    65.         long rangeCount = jedis.zcount("myset", 1, 3);
    66.         System.out.println("Range count: " + rangeCount);
    67.  
    68.         // 获取有序集合中指定成员的分数范围内的成员数量
    69.         long rangeByScoreCount = jedis.zcount("myset", "(" + 1, "(" + 3);
    70.         System.out.println("Range by score count: " + rangeByScoreCount);
    71.  
    72.         // 获取有序集合中指定成员的分数范围内的成员数量（包括边界值）
    73.         long rangeByScoreCountInclusive = jedis.zcount("myset", 1, 3);
    74.         System.out.println("Range by score count inclusive: " + rangeByScoreCountInclusive);
    75.  
    76.         // 使用ZParams设置有序集合操作的参数
    77.         ZParams params = new ZParams();
    78.         params.aggregate(ZParams.Aggregate.MAX);
    79.         params.weightsByDouble(2, 3);
    80.  
    81.         // 执行有序集合的交集操作，并将结果存储到新的有序集合
    82.         jedis.zinterstore("newset", params, "myset1", "myset2");
    83.  
    84.         // 获取新的有序集合中指定范围的成员
    85.         Set newSetRange = jedis.zrange("newset", 0, -1);
    86.         System.out.println("New set range: " + newSetRange);
    87.  
    88.         // 获取新的有序集合中指定范围的成员和分数
    89.         Set newSetRangeWithScores = jedis.zrangeWithScores("newset", 0, -1);
    90.         for (Tuple tuple : newSetRangeWithScores) {
    91.             System.out.println("Member: " + tuple.getElement() + ", Score: " + tuple.getScore());
    92.         }
    93.  
    94.         // 关闭连接
    95.         jedis.close();
    96.     }
    97. }

    这个示例代码演示了如何使用Java操作Redis中的sorted set。它包括添加元素、获取成员数量、获取指定元素的分数、增加指定元素的分数、获取指定范围的成员、获取指定范围分数的成员、获取成员的排名、移除指定成员、获取指定范围排名的成员数量等操作。还演示了如何使用ZParams设置参数并执行交集操作。请根据自己的实际需求进行修改和扩展。

    GeoSpatial 操作

    以下是一些常用的GeoSpatial命令操作的示例：

    添加地理位置：

    1. Jedis jedis = new Jedis("localhost", 6379);
    2. jedis.geoadd("locations", 116.397128, 39.916527, "Beijing");
    3. jedis.geoadd("locations", 121.473701, 31.230416, "Shanghai");

    获取地理位置的经纬度：

    1. List coordinates = jedis.geopos("locations", "Beijing", "Shanghai");
    2. for (GeoCoordinate coordinate : coordinates) {
    3.     System.out.println("Longitude: " + coordinate.getLongitude());
    4.     System.out.println("Latitude: " + coordinate.getLatitude());
    5. }

    计算两个地理位置之间的距离：

    1. double distance = jedis.geodist("locations", "Beijing", "Shanghai", GeoUnit.KM);
    2. System.out.println("Distance: " + distance + " km");

    获取指定地理位置附近的其他地理位置：

    1. List nearbyLocations = jedis.georadius("locations", 116.397128, 39.916527, 200, GeoUnit.KM);
    2. for (GeoRadiusResponse location : nearbyLocations) {
    3.     System.out.println("Location: " + location.getMemberByString());
    4.     System.out.println("Distance: " + location.getDistance());
    5. }

    这些示例展示了如何在Java中使用Jedis库实现Redis中的GeoSpatial命令操作。你可以根据需要进行调整和扩展。

    HyperLogLog 操作

    以下代码来实现HyperLogLog相关的命令操作：

    1. import redis.clients.jedis.Jedis;
    2. import redis.clients.jedis.Pipeline;
    3. import redis.clients.jedis.Response;
    4.  
    5. public class HyperLogLogExample {
    6.     public static void main(String[] args) {
    7.         // 连接到Redis服务器
    8.         Jedis jedis = new Jedis("localhost", 6379);
    9.         
    10.         // 添加元素到HyperLogLog
    11.         jedis.pfadd("hll_key", "element1", "element2", "element3");
    12.         
    13.         // 获取HyperLogLog的基数
    14.         Long count = jedis.pfcount("hll_key");
    15.         System.out.println("基数为: " + count);
    16.         
    17.         // 使用Pipeline批量执行HyperLogLog命令
    18.         Pipeline pipeline = jedis.pipelined();
    19.         Response response1 = pipeline.pfadd("hll_key2", "element4", "element5");
    20.         Response response2 = pipeline.pfcount("hll_key2");
    21.         pipeline.sync();
    22.         
    23.         Long count2 = response2.get();
    24.         System.out.println("基数为: " + count2);
    25.         
    26.         // 关闭Redis连接
    27.         jedis.close();
    28.     }
    29. }

    在上面的代码中，我们首先通过jedis.pfadd命令将元素添加到HyperLogLog中，并使用jedis.pfcount命令获取HyperLogLog的基数。接下来，我们使用Pipeline来批量执行HyperLogLog命令，以提高性能。

    BitMap 操作

    下面是一些常见的BitMap命令操作的示例：

    设置指定位的值：

    1. // 设置第5个位的值为1
    2. jedis.setbit("mybitmap", 5, true);

    获取指定位的值：

    1. Jedis jedis = new Jedis("localhost");
    2.  
    3. // 获取第5个位的值
    4. boolean bitValue = jedis.getbit("mybitmap", 5);

    统计指定范围内值为1的位的数量：

    1. Jedis jedis = new Jedis("localhost");
    2.  
    3. // 统计mybitmap中值为1的位的数量
    4. long bitCount = jedis.bitcount("mybitmap");

    对多个BitMap进行逻辑运算（AND、OR、XOR、NOT）：

    1. Jedis jedis = new Jedis("localhost");
    2.  
    3. // 对多个BitMap进行OR运算，并将结果保存到新的BitMap中
    4. jedis.bitop(BitOP.OR, "result", "bitmap1", "bitmap2", "bitmap3");

    获取指定范围内值为1的位的位置：

    1. Jedis jedis = new Jedis("localhost");
    2.  
    3. // 获取mybitmap中值为1的位的位置，从偏移量为0开始，最多返回10个结果
    4. List bitPos = jedis.bitpos("mybitmap", true, new BitPosParams(0, 10));

    这些是一些常见的BitMap相关的命令操作，你可以根据需要进行相应的调用和处理。

    Redis使用场景

    学完这些操作命令后，再来看看Redis的场景使用场景：

    • 缓存

    • 分布式锁

    • 全局id

    • 计数器

    • 限流

    • 位统计

    • 购物车

    • 消息队列

    • 点赞

    • 签到

    • 打卡

    • 排行榜

    • 商品标签

    • 商品筛选

    • 用户关注

    • ....

    另外，本文中使用的是Jedis客户端，关于java的redis客户端有很多，我们下次再来聊这个话题。

    Java面经小程序版

    回复77获取《面试小抄2.0版》

    回复电子书获取Java程序员必备电子书籍

    推荐

    MySQL 开发规范，非常详细，建议收藏！

    16k面试中的10个问题

    从0开始搭建公司技术栈，yyds

    简历写成这样，CTO会主动联系你

    全程面试辅导，保驾护航！

  • 相关阅读:
    Android AMS——创建APP进程（五）
    Android Canvas save()和restore()作用简析
    认真啃透，带你玩转网络开发框架中的Spring——Netty
    怎么避免电脑数据被拷贝？电脑如何禁用USB功能？
    Day 5 C++
    基于ASP．NET的Web应用系统架构探讨
    Java初阶数据结构二叉树实现+练习完整（工程文件后序会进行上传）
    Endpoint Central的IT资产管理(ITAM)
    SQL Server教程 - T-SQL-事务（TRANSACTION）
    原生XMLHttpRequest发起请求
  • 原文地址：https://blog.csdn.net/o9109003234/article/details/134389652