Redis各种数据类型的实例

最新推荐文章于 2024-04-17 10:49:23 发布

老猫咪的春天

最新推荐文章于 2024-04-17 10:49:23 发布

阅读量402

点赞数

分类专栏： Redis

本文链接：https://blog.csdn.net/qq_42641261/article/details/107709093

版权

Redis 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

String类型实例

package com.zt.redis;

import redis.clients.jedis.Jedis;

import java.util.List;

public class RedisStringTesting {
    public static void main(String[] args) throws InterruptedException {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("192.168.91.100", 6379);
        //查看服务是否运行，打出pong表示OK
        System.out.println("connection is OK==========>: " + jedis.ping());

        // Set 设置指定 key 的值  || Get 获取指定 key 的值。
        System.out.println(jedis.get("k1"));
        jedis.set("k4", "k4_Redis");
        System.out.println("----------------------------------------");
        // 批量操作  mset   mget
        String mset = jedis.mset("str1", "v1", "str2", "v2", "str3", "v3");
        System.out.println(mset);
        // Jedis.mget 获取所有(一个或多个)给定 key 的值。
        List<String> mget = jedis.mget("str1", "str2", "str3");
        System.out.println(mget);

        // Jedis.getrange  返回 key 中字符串值的子字符
        jedis.set("mykey", "This is my test key");
        String mykey = jedis.getrange("mykey", 0, 3);
        System.out.println(mykey);

        //将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
        String set = jedis.getSet("mykey", "hello");
        System.out.println(set);

        //将值 value 关联到 key ，并将 key 的过期时间设为 seconds (以秒为单位)。
        jedis.setex("seconds_key", 1, "seconds_value");
        jedis.setex("seconds_key_1", 10, "seconds_value_1");
        Thread.sleep(1000);

        // 获取过期的数据  返回时null
        String seconds_key = jedis.get("seconds_key");

        // 获取没过期的数据 返回就原来的数据
        String seconds_key_1 = jedis.get("seconds_key_1");
        System.out.println(seconds_key);
        System.out.println(seconds_key_1);

        // Jedis.incr 将 key 所储存的值加上给定的增量值（increment）
        jedis.incr("num");
        System.out.println("+1 :" + jedis.get("num"));

        // Jedis.decr 将 key 中储存的数字值减一
        jedis.decr("num");
        System.out.println("+1 :" + jedis.get("num"));

        // jedis.incrBy 将 key 所储存的值加上给定的增量值（increment） 。
        jedis.incrBy("num", 10);
        System.out.println("+10 :" + jedis.get("num"));

        //Jedis.incrBy 将 key 所储存的值加上给定的浮点增量值（increment） 。
        jedis.decrBy("num", 10);
        System.out.println("-10 :" + jedis.get("num"));

        //如果 key 已经存在并且是一个字符串， APPEND 命令将指定的 value 追加到该 key 原来值（value）的末尾。
        jedis.append("mykey"," 帅哥！");
        System.out.println("mykey append 帅哥！："+jedis.get("mykey"));
    }
}

List实例

package com.zt.redis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.ListPosition;

/**
 * Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）
 * 一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)。
 */
public class RedisListTesting {
    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("192.168.91.100", 6379);
        //查看服务是否运行，打出pong表示OK
        System.out.println("connection is OK==========>: " + jedis.ping());
        //  List
        // 删除mylist原来的值
        jedis.del("mylist");
        //  Jedis.lpush  将一个或多个值插入到列表头部
        jedis.lpush("mylist", "list_1");
        jedis.lpush("mylist", "list_2");
        jedis.lpush("mylist", "list_3");
        jedis.lpush("mylist", "list_4");

        String[] strings = {"1", "2", "3"};
        jedis.del("mylist_1");
        jedis.lpush("mylist_1", strings);

        // Jedis.lrange 获取到0 到-1  的值 也就是所有的值
        System.out.println(jedis.lrange("mylist_1", 0, -1));
        System.out.println(jedis.lrange("mylist", 0, -1));

        //  Jedis.lpop 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
        jedis.lpop("mylist");
        System.out.println(jedis.lrange("mylist", 0, -1));

        //  Jedis.rpoplpush  移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
        jedis.rpoplpush("mylist", "mylist_1");
        System.out.println(jedis.lrange("mylist", 0, -1));
        System.out.println(jedis.lrange("mylist_1", 0, -1));

        // Jedis.lindex  通过索引获取列表中的元素
        String mylist = jedis.lindex("mylist", 1);
        System.out.println(mylist);

        //  Jedis.linsert 在列表的元素前或者后插入元素
        jedis.linsert("mylist", ListPosition.BEFORE, "list_2", "12121");
        jedis.linsert("mylist", ListPosition.AFTER, "list_2", "123456789");
        System.out.println(jedis.lrange("mylist", 0, -1));

        //   jedis.llen 获取列表长度
        Long len = jedis.llen("mylist");
        System.out.println("mylist的长度：" + len);

        //  移出并获取列表的第一个元素
        String val = jedis.lpop("mylist");
        System.out.println("mylist移除：" + val);
        System.out.println(jedis.lrange("mylist", 0, -1));

        // Jedis.lrem   移除列表元素
        jedis.lrem("mylist", -1, "list_2");
        System.out.println(jedis.lrange("mylist", 0, -1));

        // Jedis.ltrim  对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除
        jedis.ltrim("mylist", 0, 0);
        System.out.println(jedis.lrange("mylist", 0, -1));

    }
}

Keys实例

package com.zt.redis;

import redis.clients.jedis.Jedis;

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

public class RedisKeysTesting {

  public static void main(String[] args) {
    //连接本地的 Redis 服务
    Jedis jedis = new Jedis("192.168.91.100",6379);
    //查看服务是否运行，打出pong表示OK
    System.out.println("connection is OK==========>: "+jedis.ping());

     // keys *
    jedis.set("k1","v1");
    jedis.set("k2","v2");
    jedis.set("k3","v3");
    // 获取到set的无序的
    Set<String> keys = jedis.keys("*");
    for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
      String key = (String) iterator.next();
      System.out.println(key+":"+jedis.get(key));
    }
  }
}

数据库选择实例

package com.zt.redis;

import redis.clients.jedis.Jedis;

public class RedisDbChoiceTesting {

    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("192.168.91.100", 6379);
        //查看服务是否运行，打出pong表示OK
        System.out.println("connection is OK==========>: " + jedis.ping());

        jedis.select(0);
        // keys  里面  是一个正则表达式
        System.out.println("0库所有的keys"+ jedis.keys("*"));
        // 跟换库
        jedis.select(1);
        jedis.set("db2","db2_value");
        System.out.println("1库里面key值为db2的值:"+jedis.get("db2"));
    }
}

Hash实例

package com.zt.redis;

import redis.clients.jedis.Jedis;

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

/**
 * Redis hash 是一个 string 类型的 field（字段） 和 value（值） 的映射表，hash 特别适合用于存储对象。
 * Redis 中每个 hash 可以存储 232 - 1 键值对（40多亿）
 *
 */
public class RedisHashTesting {
    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("192.168.91.100", 6379);
        //查看服务是否运行，打出pong表示OK
        System.out.println("connection is OK==========>: " + jedis.ping());

        // Jedis.hset  将哈希表 key 中的字段 field 的值设为 value
        jedis.hset("hash", "1", "1");
        jedis.hset("hash", "2", "2");
        jedis.hset("hash", "3", "3");

        // Jedis.hget 获取所有给定字段的值
        System.out.println(jedis.hget("hash", "1"));
        System.out.println(jedis.hget("hash", "2"));
        System.out.println(jedis.hget("hash", "3"));

        // Jedis.hvals 获取哈希表中所有值。
        List<String> hash = jedis.hvals("hash");
        System.out.println(hash);

        //   jedis.hdel  删除一个或多个哈希表字段
        //   查看哈希表 key 中，指定的字段是否存在
        Boolean hexists = jedis.hexists("hash", "2");
        System.out.println("jedis.hexists('hash', '2')存在状态： " + hexists);
        //  删除一个值
        jedis.hdel("hash", "2");
        hexists = jedis.hexists("hash", "2");
        System.out.println("jedis.hexists('hash', '2')存在状态： " + hexists);

        //  Jedis.hincrBy  为哈希表 key 中的指定字段的整数值加上增量 increment
        jedis.hincrBy("hash", "num", 3);

        //  Jedis.hgetAll 获取在哈希表中指定 key 的所有字段和值
        Map<String, String> hashMap = jedis.hgetAll("hash");
        System.out.println(hashMap.toString());

        //  获取所有哈希表中的字段
        Set<String> hashSet = jedis.hkeys("hash");
        System.out.println("所有哈希表中的字段:" + hashSet);

        // Jedis.hlen  获取哈希表中字段的数量
        Long hashLen = jedis.hlen("hash");
        System.out.println("所有哈希表中的长度:" + hashLen);

        //  Jedis.hmget获取所有给定字段的值
        String[] str = {"1", "3"};
        List<String> strKey = jedis.hmget("hash", str);
        System.out.println("获取所有给定字段的值："+strKey);

        //  同时将多个 field-value (域-值)对设置到哈希表 key 中
        HashMap<String, String> map = new HashMap<>();
        map.put("12121","12121");
        map.put("22222","2222");
        jedis.hmset("hmsetMap",map);

    }
}

Set实例

package com.zt.redis;

import redis.clients.jedis.Jedis;

import java.util.Set;

/**
 * Redis 的 Set 是 String 类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。
 * Redis 中集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。
 * 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。
 */
public class RedisSetTesting {

    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("192.168.91.100", 6379);
        //查看服务是否运行，打出pong表示OK
        System.out.println("connection is OK==========>: " + jedis.ping());

        //  Jedis.sadd 向集合添加一个或多个成员
        Long sadd = jedis.sadd("mySet", "set1", "set2");
        System.out.println(sadd);

        // Jedis.scard 获取集合的成员数
        Long mySet = jedis.scard("mySet");
        System.out.println("获取Set的数量:"+mySet);

        // 返回第一个集合与其他集合之间的差异。
        Long mySet_1 = jedis.sadd("mySet_1", "set13", "set2");
        Set<String> sdiff = jedis.sdiff("mySet", "mySet_1");
        System.out.println("获取到set里面的不同的值:"+sdiff);

        // jedis.sdiffstore 返回给定所有集合的差集并存储在 destination 中
        // jedis.smembers  获取所有的成员变量
        jedis.sdiffstore("mySet_2", "mySet_1", "mySet");
        System.out.println("mySet_1相对mySet的差值:"+jedis.smembers("mySet_2"));
        jedis.sdiffstore("mySet_2", "mySet", "mySet_1");
        System.out.println("mySet相对mySet_1的差值:"+jedis.smembers("mySet_2"));

       // 将 member 元素从 source 集合移动到 destination 集合   再移动后mySet_2中的移动元素会消失
        Long smove = jedis.smove("mySet_2", "mySet_3", "set1");
        System.out.println(jedis.smembers("mySet_3"));
        System.out.println(jedis.smembers("mySet_2"));

        //

    }
}

有序set的实例

package com.zt.redis;

import redis.clients.jedis.Jedis;

/**
 * Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。
 * 不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
 * 有序集合的成员是唯一的,但分数(score)却可以重复。
 * 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。
 */
public class RedisSortedSetTesting {

    public static void main(String[] args) {
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("192.168.91.100", 6379);
        //查看服务是否运行，打出pong表示OK
        System.out.println("connection is OK==========>: " + jedis.ping());

       // 向有序集合添加一个或多个成员，或者更新已存在成员的分数
        jedis.zadd("SortedSetKeyOne",111,"222");
        jedis.zadd("SortedSetKeyOne",1,"1");
        jedis.zadd("SortedSetKeyOne",2,"2");

        //获取有序集合的成员数
        Long sortedSetKeyOne = jedis.zcard("SortedSetKeyOne");
        System.out.println("获取到有序集合的数量:"+sortedSetKeyOne);

        //计算在有序集合中指定区间分数的成员数
        sortedSetKeyOne = jedis.zcount("SortedSetKeyOne", 1, 2);
        System.out.println("有序集合中指定区间分数的成员数:"+sortedSetKeyOne);

        //  有序集合中对指定成员的分数加上增量 increment
        Double sortedSetKeyOne1 = jedis.zincrby("SortedSetKeyOne", 10, "1");
        System.out.println("有序集合中"+sortedSetKeyOne1);

        //  移除有序集合中的一个或多个成员
        Long sortedSetKeyOne2 = jedis.zrem("SortedSetKeyOne", "1");
        System.out.println("删除SortedSetKeyOne的成员'1'的状态:"+sortedSetKeyOne2);

        // 返回有序集中，成员的分数值
        Double sortedSetKeyOne3 = jedis.zscore("SortedSetKeyOne", "222");
        System.out.println("SortedSetKeyOne的成员222的分数:"+sortedSetKeyOne3);

    }
}

老猫咪的春天

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Redis各种数据类型的实例

String类型实例package com.zt.redis;import redis.clients.jedis.Jedis;import java.util.List;public class RedisStringTesting { public static void main(String[] args) throws InterruptedException { //连接本地的 Redis 服务 Jedis jedis = new Jed.
复制链接

扫一扫