你好，我是田哥

常見的面試題：redis可以存儲哪些類型的數(shù)據(jù)結(jié)構(gòu)鄙皇？

我在做模擬面試中發(fā)現(xiàn)芜赌，大部分人根本就沒用過Redis，答案基本靠背伴逸。

能去背缠沈，肯定是好事，證明你對面試還挺上進错蝴。

但洲愤，我們?yōu)槭裁床荒芸焖倏纯催@些數(shù)據(jù)結(jié)構(gòu)是如何操作的呢？

也許顷锰，你看完這些相關(guān)操作后對你的背效果會更好柬赐。

Redis存儲的是key-value結(jié)構(gòu)的數(shù)據(jù)，其中key是字符串類型官紫，value數(shù)據(jù)類型有：

• 字符串 string
• 哈希hash
• 列表list
• 集合 set
• 有序集合 sorted set / zset
• （地理空間）特殊類型 GeoSpatial
• 超級基數(shù)統(tǒng)計 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 操作

設(shè)置一個字符串鍵值對：

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

獲取一個字符串鍵的值：

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

獲取多個字符串鍵的值：

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

批量設(shè)置多個字符串鍵值對：

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);

設(shè)置字符串的新值肛宋，并返回舊值：

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

設(shè)置字符串的新值，并指定過期時間（單位：秒）：

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

設(shè)置字符串的新值束世，并指定過期時間（單位：毫秒）：

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

如果鍵不存在酝陈，則設(shè)置字符串的值：

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

同時設(shè)置多個字符串鍵值對，如果有任何一個鍵已經(jīng)存在毁涉，則操作不執(zhí)行：

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

對字符串鍵的值進行自增操作：

jedis.incr("key");

對字符串鍵的值進行自增操作后添，并指定增加的步長：

jedis.incrBy("key", increment);

對字符串鍵的值進行浮點數(shù)自增操作，并指定增加的步長：

jedis.incrByFloat("key", increment);

對字符串鍵的值進行自減操作：

jedis.decr("key");

對字符串鍵的值進行自減操作薪丁，并指定減少的步長：

jedis.decrBy("key", decrement);

對字符串鍵的值進行浮點數(shù)自減操作遇西，并指定減少的步長：

jedis.decrByFloat("key", decrement);

對字符串鍵的值進行位操作，并指定操作類型（AND严嗜、OR粱檀、XOR、NOT）和另一個字符串鍵的值：

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

對字符串鍵的值進行位操作漫玄，并指定操作類型（AND茄蚯、OR、XOR睦优、NOT）和位操作的結(jié)果保存的新鍵：

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

對字符串鍵的值進行位操作渗常，并指定操作類型（AND、OR汗盘、XOR皱碘、NOT）和另一個字符串鍵的值，并返回操作結(jié)果的字符串表示：

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

獲取字符串鍵的位圖中指定位的值：

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

設(shè)置字符串鍵的位圖中指定位的值：

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

獲取字符串鍵的位圖中指定范圍內(nèi)的位的值：

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

設(shè)置字符串鍵的位圖中指定范圍內(nèi)的位的值：

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

刪除一個字符串鍵：

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

刪除多個字符串鍵：

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

請注意隐孽，上述代碼中的"key"和"value"應(yīng)替換為實際的鍵和值癌椿。

hash操作

HSET命令：將哈希表key中的字段field的值設(shè)為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（域-值）對設(shè)置到哈希表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命令操作，你可以根據(jù)需要使用其他hash命令琳钉，并根據(jù)具體情況處理返回結(jié)果世舰。

list操作

下面是使用Java實現(xiàn)Redis中所有List相關(guān)命令操作的示例代碼：

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命令：獲取列表中指定范圍內(nèi)的元素

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

LREM命令：從列表中移除指定數(shù)量的元素

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

LSET命令：通過索引設(shè)置列表中的元素

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

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

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

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

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

注意：以上代碼中的"listKey"為列表的鍵名，根據(jù)實際情況進行替換槽卫。

set操作

以下是使用Java實現(xiàn)Redis中所有set相關(guān)的命令操作的示例代碼：

import redis.clients.jedis.Jedis;

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

public class RedisSetCommands {
    public static void main(String[] args) {
        // 連接Redis服務(wù)器
        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);

        // 獲取集合的元素數(shù)量
        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);

        // 關(guān)閉Redis連接
        jedis.close();
    }
}

sort set操作

以下是使用Java實現(xiàn)Redis中所有sorted set相關(guān)的命令操作的示例代碼：

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) {
        // 創(chuàng)建連接
        Jedis jedis = new Jedis("localhost", 6379);

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

        // 獲取有序集合的成員數(shù)量
        long count = jedis.zcard("myset");
        System.out.println("Count: " + count);

        // 獲取指定元素的分?jǐn)?shù)
        double score = jedis.zscore("myset", "two");
        System.out.println("Score: " + score);

        // 增加指定元素的分?jǐn)?shù)
        jedis.zincrby("myset", 2, "two");

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

        // 獲取有序集合中指定分?jǐn)?shù)范圍的成員
        Set<String> rangeByScore = jedis.zrangeByScore("myset", 1, 3);
        System.out.println("Range by score: " + rangeByScore);

        // 獲取有序集合中指定分?jǐn)?shù)范圍的成員和分?jǐn)?shù)
        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);

        // 獲取有序集合中指定范圍排名的成員和分?jǐn)?shù)
        Set<Tuple> rangeByRankWithScores = jedis.zrangeWithScores("myset", 0, -1);
        for (Tuple tuple : rangeByRankWithScores) {
            System.out.println("Member: " + tuple.getElement() + ", Score: " + tuple.getScore());
        }

        // 獲取有序集合中指定范圍內(nèi)的成員數(shù)量
        long rangeCount = jedis.zcount("myset", 1, 3);
        System.out.println("Range count: " + rangeCount);

        // 獲取有序集合中指定成員的分?jǐn)?shù)范圍內(nèi)的成員數(shù)量
        long rangeByScoreCount = jedis.zcount("myset", "(" + 1, "(" + 3);
        System.out.println("Range by score count: " + rangeByScoreCount);

        // 獲取有序集合中指定成員的分?jǐn)?shù)范圍內(nèi)的成員數(shù)量（包括邊界值）
        long rangeByScoreCountInclusive = jedis.zcount("myset", 1, 3);
        System.out.println("Range by score count inclusive: " + rangeByScoreCountInclusive);

        // 使用ZParams設(shè)置有序集合操作的參數(shù)
        ZParams params = new ZParams();
        params.aggregate(ZParams.Aggregate.MAX);
        params.weightsByDouble(2, 3);

        // 執(zhí)行有序集合的交集操作，并將結(jié)果存儲到新的有序集合
        jedis.zinterstore("newset", params, "myset1", "myset2");

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

        // 獲取新的有序集合中指定范圍的成員和分?jǐn)?shù)
        Set<Tuple> newSetRangeWithScores = jedis.zrangeWithScores("newset", 0, -1);
        for (Tuple tuple : newSetRangeWithScores) {
            System.out.println("Member: " + tuple.getElement() + ", Score: " + tuple.getScore());
        }

        // 關(guān)閉連接
        jedis.close();
    }
}

這個示例代碼演示了如何使用Java操作Redis中的sorted set胰蝠。它包括添加元素歼培、獲取成員數(shù)量、獲取指定元素的分?jǐn)?shù)茸塞、增加指定元素的分?jǐn)?shù)躲庄、獲取指定范圍的成員、獲取指定范圍分?jǐn)?shù)的成員钾虐、獲取成員的排名噪窘、移除指定成員、獲取指定范圍排名的成員數(shù)量等操作效扫。還演示了如何使用ZParams設(shè)置參數(shù)并執(zhí)行交集操作倔监。請根據(jù)自己的實際需求進行修改和擴展。

GeoSpatial 操作

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

添加地理位置：

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

獲取地理位置的經(jīng)緯度：

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庫實現(xiàn)Redis中的GeoSpatial命令操作菌仁。你可以根據(jù)需要進行調(diào)整和擴展浩习。

HyperLogLog 操作

以下代碼來實現(xiàn)HyperLogLog相關(guān)的命令操作：

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服務(wù)器
        Jedis jedis = new Jedis("localhost", 6379);
        
        // 添加元素到HyperLogLog
        jedis.pfadd("hll_key", "element1", "element2", "element3");
        
        // 獲取HyperLogLog的基數(shù)
        Long count = jedis.pfcount("hll_key");
        System.out.println("基數(shù)為: " + count);
        
        // 使用Pipeline批量執(zhí)行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("基數(shù)為: " + count2);
        
        // 關(guān)閉Redis連接
        jedis.close();
    }
}

在上面的代碼中，我們首先通過jedis.pfadd命令將元素添加到HyperLogLog中济丘，并使用jedis.pfcount命令獲取HyperLogLog的基數(shù)谱秽。接下來，我們使用Pipeline來批量執(zhí)行HyperLogLog命令摹迷，以提高性能疟赊。

BitMap 操作

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

設(shè)置指定位的值：

// 設(shè)置第5個位的值為1
jedis.setbit("mybitmap", 5, true);

獲取指定位的值：

Jedis jedis = new Jedis("localhost");

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

統(tǒng)計指定范圍內(nèi)值為1的位的數(shù)量：

Jedis jedis = new Jedis("localhost");

// 統(tǒng)計mybitmap中值為1的位的數(shù)量
long bitCount = jedis.bitcount("mybitmap");

對多個BitMap進行邏輯運算（AND、OR峡碉、XOR近哟、NOT）：

Jedis jedis = new Jedis("localhost");

// 對多個BitMap進行OR運算，并將結(jié)果保存到新的BitMap中
jedis.bitop(BitOP.OR, "result", "bitmap1", "bitmap2", "bitmap3");

獲取指定范圍內(nèi)值為1的位的位置：

Jedis jedis = new Jedis("localhost");

// 獲取mybitmap中值為1的位的位置鲫寄，從偏移量為0開始椅挣，最多返回10個結(jié)果
List<Long> bitPos = jedis.bitpos("mybitmap", true, new BitPosParams(0, 10));

這些是一些常見的BitMap相關(guān)的命令操作头岔，你可以根據(jù)需要進行相應(yīng)的調(diào)用和處理。

Redis使用場景

學(xué)完這些操作命令后鼠证，再來看看Redis的場景使用場景：

• 緩存
• 分布式鎖
• 全局id
• 計數(shù)器
• 限流
• 位統(tǒng)計
• 購物車
• 消息隊列
• 點贊
• 簽到
• 打卡
• 排行榜
• 商品標(biāo)簽
• 商品篩選
• 用戶關(guān)注
• ....