IDEA中使用Jedis实现对Redis数据库数据的操作，实现对数据类型String，Hash，List，Set，SortSet的操作_在idea中redis中的set如何输出

作者：我家小花儿 | 2024-03-15 11:30:13

踩

在idea中redis中的set如何输出

准备

如果项目为maven项目，要添加Redis需要使用的包,下面是pom.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.hyx</groupId>
    <artifactId>test</artifactId>
    <version>1.0-SNAPSHOT</version>
    
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.10.2</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.3.1</version>
            <scope>compile</scope>
        </dependency>


    </dependencies>

    <build>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.0.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.7.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.20.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

建立工具类与配置信息，使用连接池连接Redis数据库

配置文件

redis.maxTotal=100
redis.maxIdle=30
redis.minIdle=10
redis.url=主机名
redis.port=6379
1
2
3
4
5

工具类

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class JedisPoolUtil {
    private static JedisPool pool = null;
    static {
        //加载配置文件
        InputStream in = JedisPoolUtil.class.getClassLoader().getResourceAsStream("redis.properties");
        Properties pro = new Properties();
        try {
            pro.load(in);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("加载文件失败");
        }
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(Integer.parseInt( pro.get("redis.maxTotal").toString()));
        poolConfig.setMaxIdle(Integer.parseInt( pro.get("redis.maxIdle").toString()));
        poolConfig.setMinIdle(Integer.parseInt( pro.get("redis.minIdle").toString()));
        pool = new JedisPool(poolConfig, pro.get("redis.url").toString(),Integer.parseInt( pro.get("redis.port")
                .toString()));
    }

    public static Jedis getJedis(){
        return pool.getResource();
    }
    
    public static void release(Jedis jedis){
        if(null != jedis){
            jedis.close();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

实现对String的操作

import org.junit.jupiter.api.Test;
import uilts.JedisPoolUtil;
import redis.clients.jedis.Jedis;

public class StringDemo {
    private static Jedis jedis = JedisPoolUtil.getJedis();

    //添加和获取
    @Test
    public void fun1(){
        jedis.set( "num","1" );
        System.out.println(jedis.get( "num" ));
    }

    //删除
    @Test
    public void fun2(){
        jedis.del( "num" );
        System.out.println(jedis.get( "num" ));
    }
    //自增和自减
    @Test
    public void fun3(){
        jedis.set( "num","1" );
        jedis.decr( "num" ); //i--
        System.out.println(jedis.get( "num" ));
        jedis.incr( "num" );//i++


    }
    //自增和自减 一个数
    @Test
    public void fun4(){
        jedis.set( "num","1" );
        jedis.decrBy( "num" ,5); //i=i-5
        System.out.println(jedis.get( "num" ));
        jedis.incrBy( "num",10 );//i= i+10;
        System.out.println(jedis.get( "num" ));
    }

    //字符串拼接
    @Test
    public void fun5(){
        jedis.set( "name","yx" );
        Long append = jedis.append( "name", "h" ); //返回长度
        System.out.println(append);
        System.out.println(jedis.get( "name" ));//feisong
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

实现对Hash的操作

import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;
import uilts.JedisPoolUtil;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

//Hash操作和JavaMap是一样
public class HashDemo {
    private static Jedis jedis = JedisPoolUtil.getJedis();
    //存储和获取
    @Test
    public void fun1(){
        Long aLong = jedis.hset( "user", "uname", "sun");
        System.out.println(aLong);
        Long bLong = jedis.hset( "user", "age", "18" );
        System.out.println(bLong);
        String uname = jedis.hget( "user", "uname" );
        System.out.println(uname);
    }
    //一次性存储多个key
    @Test
    public void fun2(){
        HashMap<String, String> user = new HashMap<>();
        user.put( "name","zs" );
        user.put( "age","88" );
        jedis.hmset( "user1",user );

    }
    //一次性或所有值
    @Test
    public void fun3(){
        Map<String, String> user1 = jedis.hgetAll( "user1" );
        System.out.println(user1);
    }
    //删除、增长,判定是否存储,获取键值对个数
    @Test
    public void fun4(){
        Long hdel = jedis.hdel( "user1", "name" );
        jedis.hincrBy( "user1","age",10 );
        jedis.hexists( "user1","age" );
        Long hlen = jedis.hlen( "user1" );
        System.out.println(hdel);
    }
    //获取所有Keys、value
    @Test
    public void fun5(){
        Set<String> keys = jedis.hkeys( "user" );
        List<String> valus = jedis.hvals( "user" );
        System.out.println(keys);
        System.out.println(valus);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

实现对List 的操作

import org.junit.jupiter.api.Test;
import redis.clients.jedis.BinaryClient;
import redis.clients.jedis.Jedis;
import uilts.JedisPoolUtil;
import java.util.List;

public class ListTest {
    public static Jedis jedis = JedisPoolUtil.getJedis();

    //    lpush头部添加
    //    rpush尾部添加
    @Test
    public void fun1(){

        jedis.lpush("mylist","list00","list01","list02");
        jedis.rpush("mylist","list00","list01","list02");

    }
    @Test
    //    查看列表  参数 名字  start  end -1代表最后一个元素 -2倒数第二个
    public void fun2(){
        List<String> mylist = jedis.lrange("mylist", 0, -1);
        System.out.println(mylist);
    }
    //查看第一个
    @Test
    public void fun3(){
        String ltop = jedis.lpop("mylist");
        System.out.println(ltop);
    }
    //查看最后一个
    @Test
    public void fun4(){
        String llast = jedis.rpop("mylist");
        System.out.println(llast);
    }
    @Test
    //判断有没有存在的键有就插入没有就不插入，不会创建

    public void fun5(){
        List<String> mylist = jedis.lrange("mylist", 0, -1);
        System.out.println(mylist);
        Long num = jedis.lpushx("mylist", "1");
        mylist = jedis.lrange("mylist1", 0, -1);
        System.out.println(num);
        System.out.println(mylist);
    }
    @Test
    //  移除元素返回移除的个数>0从前往后删除 <0从后往前删除
    //返回删除元素个数
    public void fun6(){
        Long num = jedis.lrem("mylist", 5, "list00");
        System.out.println(num);
    }
    @Test
    //    设置值
    public void fun7(){
        jedis.lset("mylist",2,"abasdfasdf");
        List<String> mylist = jedis.lrange("mylist", 0, -1);
        System.out.println(mylist);
    }
    @Test
//    在中间插入值 如果该值不存在则返回-1
//    如果存在返回这个list的长度
    public void fun8(){
        Long num = jedis.linsert("mylist", BinaryClient.LIST_POSITION.BEFORE, "123", "list01" );
        System.out.println(num);
        jedis.lset("mylist",3,"abasdfasdf");
        List<String> mylist = jedis.lrange("mylist", 0, -1);
        System.out.println(mylist);
    }
    @Test
    //    在第一个列表尾巴中弹出，在第二个列表中压入头
    /*
    * 使用场景，这样做可以保证原有数据的安全性，如果
    * 从第一个列表中拆出来，直接释放掉那么一旦发生了异常
    * 数据就不能回复了，我们还可以加上一个守护进程，更加确保
    * 数据的安全性
    * */
    public void fun9(){
        String rpoplpush = jedis.rpoplpush("mylist", "mylist1");
        List<String> mylist = jedis.lrange("mylist", 0, -1);
        System.out.println(mylist);
        List<String> mylist1 = jedis.lrange("mylist1", 0, -1);
        System.out.println(mylist1);
        System.out.println(rpoplpush);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

操作Set

import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;
import uilts.JedisPoolUtil;
import java.util.Set;

public class SetTest {
    public static Jedis jedis = JedisPoolUtil.getJedis();
    @Test
    /*添加元素删除元素*/
    public void fun(){
        Long sadd = jedis.sadd("myset", "set1", "set3", "set2","5","set6");
        System.out.println(sadd);
        Long set1 = jedis.srem("myset","set1");
        System.out.println(set1);
    }
    @Test
    /*获得元素*/
    public void fun1(){
        Set<String> myset = jedis.smembers("myset");
        System.out.println(myset);
    }
    @Test
    /*移除元素*/
    public void fun2(){
        Long set1 = jedis.srem("myset","set1");
        System.out.println(set1);
    }
    @Test
    //判断是否这个set中存在某个值
    public void fun3(){
        Boolean sismember = jedis.sismember("myset", "set2");
        System.out.println(sismember);
    }
    @Test
    //获得A-B 获得差集合
    public void fun4(){
        Set<String> sdiff = jedis.sdiff("myset", "myadd");
        System.out.println(sdiff);
    }
    @Test
    //获得交集
    public void fun5(){
        Set<String> sinter = jedis.sinter("myset", "myadd");
        System.out.println(sinter);
    }
    @Test
//    获得并集合
    public void fun6(){
        Set<String> sunion = jedis.sunion("myset", "myadd");
        System.out.println(sunion);
    }
    @Test
//    成员数量
    public void fun7(){
        Set<String> smenmber = jedis.smembers("myset");
        System.out.println("smenmber="+smenmber);
    }
    @Test
//    获得随机的一个成员
    public void fun8(){
        String srandmember = jedis.srandmember("myset");
         System.out.println("srandmember= "+srandmember);
    }
    @Test
//    将相差的成员放到一个新的set中同理交集和并集都可以后面均
//    加上一个store即可
//    并返回新的长度
    public void fun9(){
        Set<String> sdiff = jedis.sdiff("myset", "myadd");
        for(String s :sdiff){
            Long sadd = jedis.sadd("newset", s);
            System.out.println(sadd);
        }
        Set<String> newset = jedis.smembers("newset");
        System.out.println(newset.size());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

操作SortSet

import org.junit.Assert;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.Tuple;
import uilts.JedisPoolUtil;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
和set极为的类似，他们是字符串的集合，没有重复的数据
差别是sortedset每个成员中都会有一个分数（score）与之关联
，redis正是通过分数来为集合中的成员进行从小到大的排序
sortedset中数据必须单一但是他的score可以是重复的
 */
public class SortedsetTest {
    public static Jedis jedis = JedisPoolUtil.getJedis();
//    添加元素
    @Test
    public void fun(){
        Map<String,Double> map = new HashMap<String,Double>();
        for(int i=0;i<=10;i++){
            map.put("value:"+i,Double.valueOf(i)); //覆盖了上面的赋值
        }
        jedis.zadd("sortedSet",map);
        //返回共有多少元素
        Long sortedSet = jedis.zcard("sortedSet");
        //返回指定区域元素
        Long sortedSet1 = jedis.zcount("sortedSet", 2, 6);
        //返回指定区域所有键与值
        Set<String> sortedSet2 = jedis.zrange("sortedSet", 0l, 10l);
        System.out.println(sortedSet);
        System.out.println(sortedSet1);
        System.out.println(sortedSet2);
    }

    @Test
    public void testZAddAndZCardAndZScore(){
        //zadd 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
        //zcard 返回有序集 key 的基数。
        //zscore 返回有序集 key 中，成员 member 的 score 值。
        jedis.zadd("sortedSet",1111,"value:10");
        Map<String,Double> map = new HashMap<String,Double>();
        for(int i=0;i<=10;i++){
            map.put("value:"+i,Double.valueOf(i)); //覆盖了上面的赋值
        }
        jedis.zadd("sortedSet",map);
        Assert.assertTrue(jedis.zscore("sortedSet","value:10")==10);
        Assert.assertTrue(jedis.zcard("sortedSet")==11);
        Assert.assertTrue(jedis.del("sortedSet")==1);
    }

    @Test
    public void testZCount(){
        //zcount 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
        Map<String,Double> map = new HashMap<String,Double>();
        for(int i=0;i<10;i++){
            map.put("value:"+i,Double.valueOf(i));
        }
        jedis.zadd("sortedSet",map);
        Long count = jedis.zcount("sortedSet",0,9);
        System.out.println(count);
        Assert.assertTrue(count==10);
        Assert.assertTrue(jedis.del("sortedSet")==1);
    }

    @Test
    public void testZincrby(){
        //zincrby 为有序集 key 的成员 member 的 score 值加上增量 increment 。
        jedis.zadd("sortedSet",1111,"value:10");
        jedis.zincrby("sortedSet",-111.1,"value:10");
        Assert.assertTrue(jedis.zscore("sortedSet","value:10")==999.9);
        Assert.assertTrue(jedis.del("sortedSet")==1);
    }

    @Test
    public void testZRangeAndZRevRange(){
        /** zrange
         * 返回有序集 key 中，指定区间内的成员。
         其中成员的位置按 score 值递增(从小到大)来排序。 rev则相反
         具有相同 score 值的成员按字典序(lexicographical order )来排列。
         */
        Map<String,Double> map = new HashMap<String,Double>();
        for(int i=0;i<10;i++){
            map.put("value:"+i,Math.random()*100);
        }
        jedis.zadd("sortedSet",map);
        Set<String> set = jedis.zrange("sortedSet",0,-1); //递增
        Set<String> revSet = jedis.zrevrange("sortedSet",0,-1); //递减
        for(String ss:set){
            System.out.println(ss+":"+jedis.zscore("sortedSet",ss));
        }
        System.out.println("rev----------");
        for(String ss:revSet){
            System.out.println(ss+":"+jedis.zscore("sortedSet",ss));
        }
        Assert.assertTrue(jedis.del("sortedSet")==1);
    }

    @Test
    public void testZRangeByScoreAndZRevRangeByScore(){
        //返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
        //有序集成员按 score 值递增(从小到大)次序排列。  rev递减
        Map<String,Double> map = new HashMap<String,Double>();
        for(int i=0;i<10;i++){
            map.put("value:"+i,Math.random()*100);
        }
        jedis.zadd("sortedSet",map);
        Set<String> set = jedis.zrangeByScore("sortedSet",25,75);
        Set<String> revSet = jedis.zrevrangeByScore("sortedSet",75,25);
        for(String ss:set){
            System.out.println(ss+":"+jedis.zscore("sortedSet",ss));
        }
        System.out.println("rev----------");
        for(String ss:revSet){
            System.out.println(ss+":"+jedis.zscore("sortedSet",ss));
        }
        Assert.assertTrue(jedis.del("sortedSet")==1);
    }

    @Test
    public void testZRankAndZRevRank(){
        //zrank 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。从0开始，rev表示从大到小
        Map<String,Double> map = new HashMap<String,Double>();
        for(int i=0;i<10;i++){
            map.put("value:"+i,Double.valueOf(i));
        }
        jedis.zadd("sortedSet",map);
        Assert.assertTrue(jedis.zrank("sortedSet","value:5")==5);
        Assert.assertTrue(jedis.zrevrank("sortedSet","value:5")==4);
        Assert.assertTrue(jedis.del("sortedSet")==1);
    }

    @Test
    public void testZRem(){
        //zrem 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
        Map<String,Double> map = new HashMap<String,Double>();
        for(int i=0;i<10;i++){
            map.put("value:"+i,Double.valueOf(i));
        }
        jedis.zadd("sortedSet",map);
        Assert.assertTrue(jedis.zrem("sortedSet","value:0","value:1","dertcfghvjbk")==2);
        Assert.assertTrue(jedis.zcard("sortedSet")==8);
        Assert.assertTrue(jedis.del("sortedSet")==1);
    }

    @Test
    public void testZRemRangeByRank(){
        //zremrangeByRank 移除有序集 key 中，指定排名(rank)区间内的所有成员。
        Map<String,Double> map = new HashMap<String,Double>();
        for(int i=0;i<10;i++){
            map.put("value:"+i,Double.valueOf(i));
        }
        jedis.zadd("sortedSet",map);
        jedis.zremrangeByRank("sortedSet",1,3);
        Assert.assertTrue(jedis.zcard("sortedSet")==7);
        Assert.assertTrue(jedis.del("sortedSet")==1);
    }

    @Test
    public void testZRemRangeByScore(){
        //zremrangeByScore 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
        Map<String,Double> map = new HashMap<String,Double>();
        for(int i=0;i<10;i++){
            map.put("value:"+i,Double.valueOf(i));
        }
        jedis.zadd("sortedSet",map);
        jedis.zremrangeByScore("sortedSet",1,3);
        Assert.assertTrue(jedis.zcard("sortedSet")==7);
        Assert.assertTrue(jedis.del("sortedSet")==1);
    }

    @Test
    public void testZUnionStore(){
        //计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。
        Map<String,Double> map = new HashMap<String,Double>();
        for(int i=0;i<10;i++){
            map.put("value:"+i,Double.valueOf(i));
        }
        jedis.zadd("keya",map);
        for(int i=0;i<10;i++){
            map.put("value:"+i,Double.valueOf(i+3));
        }
        map.put("adsad",123d);
        jedis.zadd("keyb",map);
        jedis.zunionstore("destination","keya","keyb");
        Assert.assertTrue(jedis.zcard("destination")==11);
        Assert.assertTrue(jedis.del("keya","keyb","destination")==3);
    }

    @Test
    public void testZInterStore(){
        //计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination
        Map<String,Double> map = new HashMap<String,Double>();
        for(int i=0;i<10;i++){
            map.put("value:"+i,Double.valueOf(i)); //覆盖了上面的赋值
        }
        jedis.zadd("keya",map);
        for(int i=0;i<10;i++){
            map.put("value:"+i,Double.valueOf(i+3)); //覆盖了上面的赋值
        }
        map.put("adsad",123d);
        jedis.zadd("keyb",map);
        jedis.zinterstore("destination","keya","keyb");
        Assert.assertTrue(jedis.zcard("destination")==10);
        Assert.assertTrue(jedis.del("keya","keyb","destination")==3);
        Assert.assertTrue(jedis.del("keya","keyb","destination")==3);
    }

    @Test
    public void testZRangeByLex(){
        //当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序（lexicographical ordering）来进行排序，
        // 而这个命令则可以返回给定的有序集合键 key 中， 值介于 min 和 max 之间的成员。
        jedis.zadd("中文",123d,"a");
        jedis.zadd("中文",123d,"b");
        jedis.zadd("中文",123d,"c");
        jedis.zadd("中文",123d,"d");
        jedis.zadd("中文",123d,"e");
        Set<String> set = jedis.zrangeByLex("中文","(b","[e");
//        Set<String> set = jedis.zrangeByLex("中文","-","+");
//        System.out.println(set.toString());
        Assert.assertTrue(set.size()==3);
        Assert.assertTrue(jedis.del("中文")==1);
    }

    @Test
    public void testZLexCount(){
        //对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会返回该集合中， 成员介于 min 和 max 范围内的元素数量。
        jedis.zadd("key",123d,"a");
        jedis.zadd("key",123d,"b");
        jedis.zadd("key",123d,"c");
        jedis.zadd("key",123d,"d");
        jedis.zadd("key",123d,"e");
        Assert.assertTrue(jedis.zlexcount("key","-","+")==5);
        Assert.assertTrue(jedis.zlexcount("key","(b","[e")==3);
        Assert.assertTrue(jedis.del("key")==1);
    }

    @Test
    public void testZRemRangeByLex(){
        //对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会移除该集合中， 成员介于 min 和 max 范围内的所有元素。
        jedis.zadd("key",123d,"a");
        jedis.zadd("key",123d,"b");
        jedis.zadd("key",123d,"c");
        jedis.zadd("key",123d,"d");
        jedis.zadd("key",123d,"e");
        Assert.assertTrue(jedis.zremrangeByLex("key","(b","[e")==3);
        Assert.assertTrue(jedis.zlexcount("key","-","+")==2);
    }

    @Test
    public void testZScan(){
        Pipeline pipeline = jedis.pipelined();
        for(int i=0;i<1000;i++){
            pipeline.zadd("key",Math.random()*100,"value:"+i);
        }
        pipeline.sync();
        int cursor = 0;
        int count = 0;
        do{
            ScanResult<Tuple> result =  jedis.zscan("key",cursor);
            cursor = Integer.valueOf(result.getStringCursor());
            for(Tuple tuple :result.getResult()){
//                System.out.print(new String(tuple.getBinaryElement())+":"+tuple.getScore());
                count++;
            }

        }
        while (cursor!=0);
        System.out.println(count);
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275

sort代码出处https://blog.csdn.net/a1031397017/article/details/69484193

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/240395