你好，我是田哥

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

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

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

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

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

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

• 字符串 string
• 哈希hash
• 列表list
• 集合 set
• 有序集合 sorted set / zset
• （地理空间）特殊类型 GeoSpatial
• 超级基数统计 HyperLogLog
• 位图 BitMap

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

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.4.3</version>
</dependency>

获取redis连接：

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

string 操作

设置一个字符串键值对：

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

获取一个字符串键的值：

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

获取多个字符串键的值：

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

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

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

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

List<String> 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");

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

Map<String, String> keyValuePairs = new HashMap<>();
keyValuePairs.put("key1", "value1");
keyValuePairs.put("key2", "value2");
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的值。

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

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

Jedis jedis = new Jedis("localhost");
Map<String, String> hash = new HashMap<>();
hash.put("field1", "value1");
hash.put("field2", "value2");
jedis.hmset("myhash", hash);

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

Jedis jedis = new Jedis("localhost");
List<String> values = jedis.hmget("myhash", "field1", "field2");
for (String value : values) {
    System.out.println(value);
}

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

Jedis jedis = new Jedis("localhost");
Map<String, String> hash = jedis.hgetAll("myhash");
for (Map.Entry<String, String> entry : hash.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

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

Jedis jedis = new Jedis("localhost");
Long result = jedis.hdel("myhash", "field1");
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<String> 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相关的命令操作的示例代码：

import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.Set;

public class RedisSetCommands {
    public static void main(String[] args) {
        // 连接Redis服务器
        Jedis jedis = new Jedis("localhost");

        // 添加元素到集合
        jedis.sadd("set1", "element1", "element2", "element3");

        // 获取集合中的所有元素
        Set<String> set1 = jedis.smembers("set1");
        System.out.println("set1: " + set1);

        // 判断元素是否存在于集合中
        boolean exists = jedis.sismember("set1", "element1");
        System.out.println("element1 exists in set1: " + exists);

        // 获取集合的元素数量
        long size = jedis.scard("set1");
        System.out.println("set1 size: " + size);

        // 从集合中随机获取一个元素
        String randomElement = jedis.srandmember("set1");
        System.out.println("Random element from set1: " + randomElement);

        // 从集合中移除指定的元素
        jedis.srem("set1", "element2");

        // 获取集合的差集
        jedis.sadd("set2", "element2", "element4");
        Set<String> difference = jedis.sdiff("set1", "set2");
        System.out.println("Difference between set1 and set2: " + difference);

        // 获取集合的交集
        Set<String> intersection = jedis.sinter("set1", "set2");
        System.out.println("Intersection of set1 and set2: " + intersection);

        // 获取集合的并集
        Set<String> union = jedis.sunion("set1", "set2");
        System.out.println("Union of set1 and set2: " + union);

        // 将集合的元素移动到另一个集合
        jedis.smove("set1", "set2", "element3");

        // 获取多个集合的并集并存储到新集合中
        jedis.sunionstore("set3", "set1", "set2");
        Set<String> set3 = jedis.smembers("set3");
        System.out.println("set3: " + set3);

        // 获取多个集合的交集并存储到新集合中
        jedis.sinterstore("set4", "set1", "set2");
        Set<String> set4 = jedis.smembers("set4");
        System.out.println("set4: " + set4);

        // 获取多个集合的差集并存储到新集合中
        jedis.sdiffstore("set5", "set1", "set2");
        Set<String> set5 = jedis.smembers("set5");
        System.out.println("set5: " + set5);

        // 关闭Redis连接
        jedis.close();
    }
}

sort set操作

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

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;
import redis.clients.jedis.ZParams;

import java.util.Map;
import java.util.Set;

public class RedisSortedSetExample {
    public static void main(String[] args) {
        // 创建连接
        Jedis jedis = new Jedis("localhost", 6379);

        // 添加元素到有序集合
        jedis.zadd("myset", 1, "one");
        jedis.zadd("myset", 2, "two");
        jedis.zadd("myset", 3, "three");

        // 获取有序集合的成员数量
        long count = jedis.zcard("myset");
        System.out.println("Count: " + count);

        // 获取指定元素的分数
        double score = jedis.zscore("myset", "two");
        System.out.println("Score: " + score);

        // 增加指定元素的分数
        jedis.zincrby("myset", 2, "two");

        // 获取有序集合中指定范围的成员
        Set<String> range = jedis.zrange("myset", 0, -1);
        System.out.println("Range: " + range);

        // 获取有序集合中指定分数范围的成员
        Set<String> rangeByScore = jedis.zrangeByScore("myset", 1, 3);
        System.out.println("Range by score: " + rangeByScore);

        // 获取有序集合中指定分数范围的成员和分数
        Set<Tuple> rangeByScoreWithScores = jedis.zrangeByScoreWithScores("myset", 1, 3);
        for (Tuple tuple : rangeByScoreWithScores) {
            System.out.println("Member: " + tuple.getElement() + ", Score: " + tuple.getScore());
        }

        // 获取有序集合中指定成员的排名（从0开始）
        long rank = jedis.zrank("myset", "two");
        System.out.println("Rank: " + rank);

        // 获取有序集合中指定成员的排名（从1开始）
        long reverseRank = jedis.zrevrank("myset", "two");
        System.out.println("Reverse rank: " + reverseRank);

        // 移除指定成员
        jedis.zrem("myset", "two");

        // 获取有序集合中指定范围排名的成员
        Set<String> rangeByRank = jedis.zrange("myset", 0, -1);
        System.out.println("Range by rank: " + rangeByRank);

        // 获取有序集合中指定范围排名的成员和分数
        Set<Tuple> rangeByRankWithScores = jedis.zrangeWithScores("myset", 0, -1);
        for (Tuple tuple : rangeByRankWithScores) {
            System.out.println("Member: " + tuple.getElement() + ", Score: " + tuple.getScore());
        }

        // 获取有序集合中指定范围内的成员数量
        long rangeCount = jedis.zcount("myset", 1, 3);
        System.out.println("Range count: " + rangeCount);

        // 获取有序集合中指定成员的分数范围内的成员数量
        long rangeByScoreCount = jedis.zcount("myset", "(" + 1, "(" + 3);
        System.out.println("Range by score count: " + rangeByScoreCount);

        // 获取有序集合中指定成员的分数范围内的成员数量（包括边界值）
        long rangeByScoreCountInclusive = jedis.zcount("myset", 1, 3);
        System.out.println("Range by score count inclusive: " + rangeByScoreCountInclusive);

        // 使用ZParams设置有序集合操作的参数
        ZParams params = new ZParams();
        params.aggregate(ZParams.Aggregate.MAX);
        params.weightsByDouble(2, 3);

        // 执行有序集合的交集操作，并将结果存储到新的有序集合
        jedis.zinterstore("newset", params, "myset1", "myset2");

        // 获取新的有序集合中指定范围的成员
        Set<String> newSetRange = jedis.zrange("newset", 0, -1);
        System.out.println("New set range: " + newSetRange);

        // 获取新的有序集合中指定范围的成员和分数
        Set<Tuple> newSetRangeWithScores = jedis.zrangeWithScores("newset", 0, -1);
        for (Tuple tuple : newSetRangeWithScores) {
            System.out.println("Member: " + tuple.getElement() + ", Score: " + tuple.getScore());
        }

        // 关闭连接
        jedis.close();
    }
}

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

GeoSpatial 操作

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

添加地理位置：

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

获取地理位置的经纬度：

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

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

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

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

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

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

HyperLogLog 操作

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

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Response;

public class HyperLogLogExample {
    public static void main(String[] args) {
        // 连接到Redis服务器
        Jedis jedis = new Jedis("localhost", 6379);
        
        // 添加元素到HyperLogLog
        jedis.pfadd("hll_key", "element1", "element2", "element3");
        
        // 获取HyperLogLog的基数
        Long count = jedis.pfcount("hll_key");
        System.out.println("基数为: " + count);
        
        // 使用Pipeline批量执行HyperLogLog命令
        Pipeline pipeline = jedis.pipelined();
        Response<Long> response1 = pipeline.pfadd("hll_key2", "element4", "element5");
        Response<Long> response2 = pipeline.pfcount("hll_key2");
        pipeline.sync();
        
        Long count2 = response2.get();
        System.out.println("基数为: " + count2);
        
        // 关闭Redis连接
        jedis.close();
    }
}

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

BitMap 操作

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

设置指定位的值：

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

获取指定位的值：

Jedis jedis = new Jedis("localhost");

// 获取第5个位的值
boolean bitValue = jedis.getbit("mybitmap", 5);

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

Jedis jedis = new Jedis("localhost");

// 统计mybitmap中值为1的位的数量
long bitCount = jedis.bitcount("mybitmap");

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

Jedis jedis = new Jedis("localhost");

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

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

Jedis jedis = new Jedis("localhost");

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

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

Redis使用场景

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

• 缓存
• 分布式锁
• 全局id
• 计数器
• 限流
• 位统计
• 购物车
• 消息队列
• 点赞
• 签到
• 打卡
• 排行榜
• 商品标签
• 商品筛选
• 用户关注
• ....