Jedis API 详细示例

Redis 简介

Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。

Redis 与其他 key - value 缓存产品有以下三个特点：

Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
Redis支持数据的备份，即master-slave模式的数据备份。

Redis 优势

性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。
丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。
丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。

Redis与其他key-value存储有什么不同？

Redis有着更为复杂的数据结构并且提供对他们的原子性操作，这是一个不同于其他数据库的进化路径。Redis的数据类型都是基于基本数据结构的同时对程序员透明，无需进行额外的抽象。
Redis运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，因为数据量不能大于硬件内存。在内存数据库方面的另一个优点是，相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，这样Redis可以做很多内部复杂性很强的事情。同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问。

redis 数据类型

Redis支持五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

maven依赖

<dependencies>
    <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.4.2</version>
    </dependency>
</dependencies>

Jedis API 操作示例

Jedis 连接池

连接Jedis线程安全单列模式可配置多个redis数据源的连接池。

public class JedisApi {

    private static final Logger LOG = LoggerFactory.getLogger(JedisApi.class);

    private volatile static JedisApi jedisApi;

    /**
     * 保存多个连接源
     */
    private static Map<String, JedisPool> poolMap = new HashMap<String, JedisPool>();

    private JedisApi() {
    }

    /**
     * @Description: jedisPool 池
     * @Param: [ip, port]
     * @return: redis.clients.jedis.JedisPool
     * @Author: imdalai
     * @Date: 2018/1/15
     */
    private static JedisPool getPool(String ip, int port) {

        try {
            String key = ip + ":" + port;
            JedisPool pool = null;
            if (!poolMap.containsKey(key)) {
                JedisPoolConfig config = new JedisPoolConfig();
                config.setMaxIdle(RedisConfig.MAX_IDLE);
                config.setMaxTotal(RedisConfig.MAX_ACTIVE);
                //  在获取连接的时候检查有效性, 默认false
                config.setTestOnBorrow(true);
                //  在空闲时检查有效性, 默认false
                config.setTestOnReturn(true);
                pool = new JedisPool(config, ip, port, RedisConfig.TIME_OUT);
                poolMap.put(key, pool);
            } else {
                pool = poolMap.get(key);
            }
            return pool;
        } catch (Exception e) {
            LOG.error("init jedis pool failed ! " + e.getMessage(), e);
        }
        return null;
    }

    /**
     * @Description: 线程安全单列模式
     * @Param: []
     * @return: JedisApi
     * @Author: imdalai
     * @Date: 2018/1/15
     */
    public static JedisApi getRedisApi() {

        if (jedisApi == null) {
            synchronized (JedisApi.class) {
                if (jedisApi == null) {
                    jedisApi = new JedisApi();
                }
            }
        }
        return jedisApi;
    }

    /**
     * @Description: 获取一个jedis连接
     * @Param: [ip, port]
     * @return: redis.clients.jedis.Jedis
     * @Author: imdalai
     * @Date: 2018/1/15
     */
    public Jedis getRedis(String ip, int port) {
        Jedis jedis = null;
        int count = 0;
        while (jedis == null && count <= RedisConfig.RETRY_NUM) {
            try {
                jedis = getPool(ip, port).getResource();
            } catch (Exception e) {
                LOG.error("get redis failed ! " + e.getMessage(), e);
                count++;
            }
        }
        return jedis;
    }

    /**
     * @Description: 释放jedis到jedisPool中
     * @Param: [jedis, ip, port]
     * @return: void
     * @Author: imdalai
     * @Date: 2018/1/15
     */
    public void closeRedis(Jedis jedis) {

        if (jedis != null) {
            try {
                jedis.close();
            } catch (Exception e) {
                LOG.error("colse jedis failed ! " + e.getMessage(), e);
            }
        }
    }
}

键（key）

public static void testKey() {
    System.out.println("====key功能展示====");
    try {
        jedis.select(0);
        System.out.println("清除数据：" + jedis.flushDB());
        System.out.println("判断某个键是否存在：" + jedis.exists("1"));
        System.out.println("新增{1，a}键值对:" + jedis.set("1", "a"));
        System.out.println(jedis.exists("1"));
        System.out.println("新增{2，b}键值对:" + jedis.set("2", "b"));
        System.out.println("系统中所有的键如下：" + jedis.keys("*").toString());
        System.out.println("删除键 1:" + jedis.del("1"));
        System.out.println("判断键 1是否存在：" + jedis.exists("1"));
        System.out.println("设置键 2的过期时间为5s:" + jedis.expire("2", 5));
        TimeUnit.SECONDS.sleep(2);
        System.out.println("查看键 2的剩余生存时间：" + jedis.ttl("2"));
        System.out.println("移除键 2的生存时间：" + jedis.persist("2"));
        System.out.println("查看键 2的剩余生存时间：" + jedis.ttl("2"));
        System.out.println("查看键 2所存储的值的类型：" + jedis.type("2"));
        System.out.println("查看键 2的值：" + jedis.get("2"));

        System.out.println("");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

输出结果：

====key功能展示====
清除数据：OK
判断某个键是否存在：false
新增{1，a}键值对:OK
true
新增{2，b}键值对 :OK
系统中所有的键如下：[1, 2]
删除键 1:1
判断键 1是否存在：false
设置键 2的过期时间为5s:1
查看键 2的剩余生存时间：3
移除键 2的生存时间：1
查看键 2的剩余生存时间：-1
查看键 2所存储的值的类型：string
查看键 2的值：b

字符串、整型和浮点数

string是redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。

string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象。

string类型是Redis最基本的数据类型，一个键最大能存储512MB。

字符串

public static void testString() {
    try {
        jedis.select(1);
        jedis.flushDB();
        System.out.println("====字符串功能展示====");
        System.out.println("增:");
        System.out.println(jedis.set("a", "1"));
        System.out.println(jedis.set("b", "2"));
        System.out.println(jedis.set("c", "3"));
        System.out.println("删除键 a:" + jedis.del("a"));
        System.out.println("获取键 a:" + jedis.get("a"));
        System.out.println("修改键 b:" + jedis.set("b", "bChanged"));
        System.out.println("获取键 b 的值:" + jedis.get("b"));
        System.out.println("在键 c后面加入值：" + jedis.append("c", "End"));
        System.out.println("获取键 c的值：" + jedis.get("c"));
        System.out.println("增加多个键值对：" + jedis.mset("key01", "value01", "key02", "value02", "key03", "value03"));
        System.out.println("获取多个键值对：" + jedis.mget("key01", "key02", "key03"));
        System.out.println("获取多个键值对：" + jedis.mget("key01", "key02", "key03", "key04"));
        System.out.println("删除多个键值对：" + jedis.del(new String[]{"key01", "key02"}));
        System.out.println("获取多个键值对：" + jedis.mget("key01", "key02", "key03"));

        jedis.flushDB();
        System.out.println("新增键值对防止覆盖原先值:");
        System.out.println(jedis.setnx("key001", "value001"));
        System.out.println(jedis.setnx("key002", "value002"));
        System.out.println(jedis.setnx("key002", "value002-new"));
        System.out.println("获取键key001的值：" + jedis.get("key001"));
        System.out.println("获取键key002的值：" + jedis.get("key002"));

        System.out.println("新增键值对并设置有效时间:");
        System.out.println(jedis.setex("key003", 2, "value003"));
        System.out.println("获取键key003的值：" + jedis.get("key003"));
        TimeUnit.SECONDS.sleep(3);
        System.out.println("获取键key003的值：" + jedis.get("key003"));

        System.out.println("获取原值，更新为新值:");
        System.out.println(jedis.getSet("key002", "key2GetSet"));
        System.out.println("获取键key002的值：" + jedis.get("key002"));

        System.out.println("截取key002的值的字符串：" + jedis.getrange("key002", 2, 5));

        System.out.println("");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

输出结果：

====字符串功能展示====
增:
OK
OK
OK
删除键 a:1
获取键 a:null
修改键 b:OK
获取键 b 的值:bChanged
在键 c后面加入值：4
获取键 c的值：3End
增加多个键值对：OK
获取多个键值对：[value01, value02, value03]
获取多个键值对：[value01, value02, value03, null]
删除多个键值对：2
获取多个键值对：[null, null, value03]
新增键值对防止覆盖原先值:
1
1
0
获取键key001的值：value001
获取键key002的值：value002
新增键值对并设置有效时间:
OK
获取键key003的值：value003
获取键key003的值：null
获取原值，更新为新值:
value002
获取键key002的值：key2GetSet
截取key002的值的字符串：y2Ge

整数和浮点数

public static void testNumber() {
    try {
        jedis.select(2);
        jedis.flushDB();
        System.out.println("====整数和浮点数功能展示====");
        jedis.set("key001", "1");
        jedis.set("key002", "2");
        jedis.set("key003", "3.3");
        System.out.println("获取键key001的值：" + jedis.get("key001"));
        System.out.println("获取键key002的值：" + jedis.get("key002"));
        System.out.println("将键key001的值+1：" + jedis.incr("key001"));
        System.out.println("获取键key001的值：" + jedis.get("key001"));
        System.out.println("将键key002的值-1：" + jedis.decr("key002"));
        System.out.println("获取键key002的值：" + jedis.get("key002"));
        System.out.println("将key001的值加上整数5：" + jedis.incrBy("key001", 5));
        System.out.println("获取key001的值：" + jedis.get("key001"));
        System.out.println("将key002的值减去整数5：" + jedis.decrBy("key002", 5));
        System.out.println("获取key002的值：" + jedis.get("key002"));

        System.out.println("");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

输出结果：

====整数和浮点数功能展示====
获取键key001的值：1
获取键key002的值：2
将键key001的值+1：2
获取键key001的值：2
将键key002的值-1：1
获取键key002的值：1
将key001的值加上整数5：7
获取key001的值：7
将key002的值减去整数5：-4
获取key002的值：-4

List（列表）

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。

public static void testList() {

    jedis.select(3);
    jedis.flushDB();
    System.out.println("====列表list功能展示====");
    jedis.lpush("collections", "ArrayList", "LinkedList", "Vector", "Stack", "queue");
    jedis.lpush("collections", "HashMap");
    jedis.lpush("collections", "HashMap");
    jedis.lpush("collections", "HashMap");
    jedis.lpush("collections", "HashMap");
    jedis.lpush("number", "1");
    jedis.lpush("number", "2");
    jedis.lpush("number", "3");
    // -1 代表倒数第一个
    System.out.println("collections 的内容：" + jedis.lrange("collections", 0, -1));
    System.out.println("collections区间0-2内容：" + jedis.lrange("collections", 0, 2));
    System.out.println("=================");
    // 删除列表指定的值 ，第二个参数为删除的个数（有重复时），后add进去的值先被删，类似于出栈
    System.out.println("删除指定元素个数：" + jedis.lrem("collections", 2, "HashMap"));
    System.out.println("collections 的内容：" + jedis.lrange("collections", 0, -1));
    System.out.println("删除区间0-4以外的数据：" + jedis.ltrim("collections", 0, 4));
    System.out.println("collections 的内容：" + jedis.lrange("collections", 0, -1));
    System.out.println("collections列表出栈（左端）：" + jedis.lpop("collections"));
    System.out.println("collections的内容：" + jedis.lrange("collections", 0, -1));
    System.out.println("collections添加元素，从列表右端，与lpush相对应：" + jedis.rpush("collections", "EnumMap"));
    System.out.println("collections的内容：" + jedis.lrange("collections", 0, -1));
    System.out.println("collections列表出栈（右端）：" + jedis.rpop("collections"));
    System.out.println("collections的内容：" + jedis.lrange("collections", 0, -1));
    System.out.println("修改collections指定下标1的内容：" + jedis.lset("collections", 1, "LinkedArrayList"));
    System.out.println("collections的内容：" + jedis.lrange("collections", 0, -1));
    System.out.println("=================");
    System.out.println("collections的长度：" + jedis.llen("collections"));
    System.out.println("获取collections下标为2的元素：" + jedis.lindex("collections", 2));
    System.out.println("=================");
    jedis.lpush("sortedList", "3", "6", "2", "0", "7", "4");
    System.out.println("sortedList排序前：" + jedis.lrange("sortedList", 0, -1));
    System.out.println(jedis.sort("sortedList"));
    System.out.println("sortedList排序后：" + jedis.lrange("sortedList", 0, -1));
    
    System.out.println("");  
}

输出结果：

====列表list功能展示====
collections 的内容：[HashMap, HashMap, HashMap, HashMap, queue, Stack, Vector, LinkedList, ArrayList]
collections区间0-2内容：[HashMap, HashMap, HashMap]
=================
删除指定元素个数：2
collections 的内容：[HashMap, HashMap, queue, Stack, Vector, LinkedList, ArrayList]
删除区间0-4以外的数据：OK
collections 的内容：[HashMap, HashMap, queue, Stack, Vector]
collections列表出栈（左端）：HashMap
collections的内容：[HashMap, queue, Stack, Vector]
collections添加元素，从列表右端，与lpush相对应：5
collections的内容：[HashMap, queue, Stack, Vector, EnumMap]
collections列表出栈（右端）：EnumMap
collections的内容：[HashMap, queue, Stack, Vector]
修改collections指定下标1的内容：OK
collections的内容：[HashMap, LinkedArrayList, Stack, Vector]
=================
collections的长度：4
获取collections下标为2的元素：Stack
================
sortedList排序前：[4, 7, 0, 2, 6, 3]
[0, 2, 3, 4, 6, 7]
sortedList排序后：[4, 7, 0, 2, 6, 3]

集合（Set）

Redis的Set是string类型的无序集合。

集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。

public static void testSet() {
    try {
        jedis.select(4);
        jedis.flushDB();
        System.out.println("========测试集合（set）=========");
        System.out.println("集合set添加数据：" + jedis.sadd("setElement", "e1", "e7", "e3", "e6", "e0", "e4"));
        System.out.println(jedis.sadd("setElement", "e6"));
        System.out.println("setElement的所有元素：" + jedis.smembers("setElement"));
        System.out.println("删除元素e0:" + jedis.srem("setElement", "e0"));
        System.out.println("setElement的所有元素：" + jedis.smembers("setElement"));
        System.out.println("删除两个元素e7和e6：" + jedis.srem("setElement", "e7", "e6"));
        System.out.println("setElement的所有元素为：" + jedis.smembers("setElement"));
        System.out.println("随机的移除集合中的一个元素：" + jedis.spop("setElement"));
        System.out.println("随机的移除集合中的一个元素：" + jedis.spop("setElement"));
        System.out.println("setElement的所有元素为：" + jedis.smembers("setElement"));
        System.out.println("setElement中包含元素的个数：" + jedis.scard("setElement"));
        System.out.println("e3是否在setElement中：" + jedis.sismember("setElement", "e3"));
        System.out.println("e1是否在setElement中：" + jedis.sismember("setElement", "e1"));

        System.out.println("=================");
        System.out.println(jedis.sadd("setElement1", "e1", "e2", "e4", "e3", "e0", "e8", "e7", "e5"));
        System.out.println(jedis.sadd("setElement2", "e1", "e2", "e4", "e3", "e0", "e8"));
        System.out.println("将setElement1中删除e1并存入setElement3中：" + jedis.smove("setElement1", "setElement3", "e1"));
        System.out.println("将setElement1中删除e2并存入setElement3中：" + jedis.smove("setElement1", "setElement3", "e2"));
        System.out.println("setElement1中的元素：" + jedis.smembers("setElement1"));
        System.out.println("setElement3中的元素：" + jedis.smembers("setElement3"));

        System.out.println("集合运算:");
        System.out.println("setElement1中的元素：" + jedis.smembers("setElement1"));
        System.out.println("setElement2中的元素：" + jedis.smembers("setElement2"));
        System.out.println("setElement1和setElement2的交集:" + jedis.sinter("setElement1", "setElement2"));
        System.out.println("setElement1和setElement2的并集:" + jedis.sunion("setElement1", "setElement2"));
        // setElement1中有，setElement2中没有
        System.out.println("setElement1和setElement2的差集:" + jedis.sdiff("setElement1", "setElement2"));

        System.out.println("");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

输出结果：

========测试集合（set）=========
集合set添加数据：6
0
setElement的所有元素：[e3, e6, e1, e7, e0, e4]
删除元素e0:1
setElement的所有元素：[e6, e3, e1, e7, e4]
删除两个元素e7和e6：2
setElement的所有元素为：[e3, e1, e4]
随机的移除集合中的一个元素：e3
随机的移除集合中的一个元素：e4
setElement的所有元素为：[e1]
setElement中包含元素的个数：1
e3是否在setElement中：false
e1是否在setElement中：true
=================
8
6
将setElement1中删除e1并存入setElement3中：1
将setElement1中删除e2并存入setElement3中：1
setElement1中的元素：[e5, e8, e3, e7, e0, e4]
setElement3中的元素：[e1, e2]
集合运算:
setElement1中的元素：[e5, e8, e3, e7, e0, e4]
setElement2中的元素：[e3, e4, e2, e8, e1, e0]
setElement1和setElement2的交集:[e3, e4, e8, e0]
setElement1和setElement2的并集:[e5, e8, e3, e1, e7, e0, e2, e4]
setElement1和setElement2的差集:[e5, e7]

hash

Redis hash 是一个键值(key=>value)对集合。

Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。

public static void testHash() {

    try {
        System.out.println("=======集合（Set）=======");
        jedis.select(5);
        jedis.flushDB();
        Map<String, String> map = new HashMap<String, String>();
        map.put("key001", "value001");
        map.put("key002", "value002");
        map.put("key003", "value003");
        jedis.hmset("hash", map);
        jedis.hset("hash", "key004", "value004");
        // return Map<String,String>
        System.out.println("散列hash的所有键值对为：" + jedis.hgetAll("hash"));
        // return Set<String>
        System.out.println("散列hash的所有键为：" + jedis.hkeys("hash"));
        // return List<String>
        System.out.println("散列hash的所有值为：" + jedis.hvals("hash"));
        System.out.println("将key006保存的值加上一个整数，如果key006不存在则添加key006：" + jedis.hincrBy("hash", "key006", 6));
        System.out.println("散列hash的所有键值对为：" + jedis.hgetAll("hash"));
        System.out.println("将key006保存的值加上一个整数，如果key006不存在则添加key006：" + jedis.hincrBy("hash", "key006", 3));
        System.out.println("散列hash的所有键值对为：" + jedis.hgetAll("hash"));
        System.out.println("删除一个或者多个键值对：" + jedis.hdel("hash", "key002"));
        System.out.println("散列hash的所有键值对为：" + jedis.hgetAll("hash"));
        System.out.println("散列hash中键值对的个数：" + jedis.hlen("hash"));
        System.out.println("判断hash中是否存在key002：" + jedis.hexists("hash", "key002"));
        System.out.println("判断hash中是否存在key003：" + jedis.hexists("hash", "key003"));
        System.out.println("获取hash中的值：" + jedis.hmget("hash", "key003"));
        System.out.println("获取hash中的值：" + jedis.hmget("hash", "key003", "key004"));

        System.out.println("");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

输出结果：

=======集合（Set）=======
散列hash的所有键值对为：{key004=value004, key003=value003, key002=value002, key001=value001}
散列hash的所有键为：[key004, key003, key002, key001]
散列hash的所有值为：[value001, value003, value002, value004]
将key006保存的值加上一个整数，如果key006不存在则添加key006：6
散列hash的所有键值对为：{key004=value004, key003=value003, key006=6, key002=value002, key001=value001}
将key006保存的值加上一个整数，如果key006不存在则添加key006：9
散列hash的所有键值对为：{key004=value004, key003=value003, key006=9, key002=value002, key001=value001}
删除一个或者多个键值对：1
散列hash的所有键值对为：{key004=value004, key003=value003, key006=9, key001=value001}
散列hash中键值对的个数：4
判断hash中是否存在key002：false
判断hash中是否存在key003：true
获取hash中的值：[value003]
获取hash中的值：[value003, value004]

有序集合

zset(sorted set：有序集合)
Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

zset的成员是唯一的,但分数(score)却可以重复。

public static void testSortSet() {

    try {
        System.out.println("=======有序集合=======");
        jedis.select(6);
        jedis.flushDB();
        Map<String, Double> map = new HashMap<String, Double>();
        map.put("key2", 1.2);
        map.put("key3", 4.0);
        map.put("key4", 5.0);
        map.put("key5", 0.2);
        System.out.println(jedis.zadd("zset", 3, "key1"));
        System.out.println(jedis.zadd("zset", map));
        System.out.println("zset中的所有元素：" + jedis.zrange("zset", 0, -1));
        System.out.println("zset中的所有元素：" + jedis.zrangeWithScores("zset", 0, -1));
        System.out.println("zset中的所有元素：" + jedis.zrangeByScore("zset", 0, 100));
        System.out.println("zset中的所有元素：" + jedis.zrangeByScoreWithScores("zset", 0, 100));
        System.out.println("zset中key2的分值：" + jedis.zscore("zset", "key2"));
        System.out.println("zset中key2的排名：" + jedis.zrank("zset", "key2"));
        System.out.println("删除zset中的元素key3：" + jedis.zrem("zset", "key3"));
        System.out.println("zset中的所有元素：" + jedis.zrange("zset", 0, -1));
        System.out.println("zset中元素的个数：" + jedis.zcard("zset"));
        System.out.println("zset中分值在1-4之间的元素的个数：" + jedis.zcount("zset", 1, 4));
        System.out.println("key2的分值加上5：" + jedis.zincrby("zset", 5, "key2"));
        System.out.println("key3的分值加上4：" + jedis.zincrby("zset", 4, "key3"));
        System.out.println("zset中的所有元素：" + jedis.zrange("zset", 0, -1));

        System.out.println("");

    } catch (Exception e) {
        e.printStackTrace();
    }
}

输出结果：

=======有序集合=======
1
4
zset中的所有元素：[key5, key2, key1, key3, key4]
zset中的所有元素：[[[107, 101, 121, 53],0.2], [[107, 101, 121, 50],1.2], [[107, 101, 121, 49],3.0], [[107, 101, 121, 51],4.0], [[107, 101, 121, 52],5.0]]
zset中的所有元素：[key5, key2, key1, key3, key4]
zset中的所有元素：[[[107, 101, 121, 53],0.2], [[107, 101, 121, 50],1.2], [[107, 101, 121, 49],3.0], [[107, 101, 121, 51],4.0], [[107, 101, 121, 52],5.0]]
zset中key2的分值：1.2
zset中key2的排名：1
删除zset中的元素key3：1
zset中的所有元素：[key5, key2, key1, key4]
zset中元素的个数：4
zset中分值在1-4之间的元素的个数：2
key2的分值加上5：6.2
key3的分值加上4：4.0
zset中的所有元素：[key5, key1, key3, key4, key2]

参考

redisAPI简单使用
 API整理原处-朱小斯

Contents

Redis 简介

Redis 优势

Redis与其他key-value存储有什么不同？

redis 数据类型

maven依赖

Jedis API 操作示例

Jedis 连接池

键（key）

字符串、整型和浮点数

List（列表）

集合（Set）

hash

有序集合

参考