Redis学习笔记(6)-SortedSet

package cn.com;

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

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

/**
 * 有序集合的所有操作方法
 *
 * */
public class Redis_SortedSet {

	public static Jedis redis = new Jedis("localhost", 6379);// 连接redis

	/**
	 * ZADD key score member [[score member] [score member] ...]
	 * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
	 * 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
	 * score 值可以是整数值或双精度浮点数。
	 * 如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。
	 * 当 key 存在但不是有序集类型时，返回一个错误。
	 * */
	public static void zadd(){
		redis.flushDB();//清除数据
		Map<String,Double> agemap=new HashMap<String,Double>();
		agemap.put("age1", 1.0);
		agemap.put("age2", 2.0);
		agemap.put("age4", 4.0);
		agemap.put("age3", 3.0);
		agemap.put("age9", 9.0);
		agemap.put("age5", 5.0);
		redis.zadd("user", agemap);
		Set<String> list=redis.zrange("user", 0, -1);
		for(String s:list){
			System.out.println(s);
		}

	}

	/**
	 * 返回有序集 key 的基数。
	 * */
	public static void zcard(){
		redis.flushDB();//清除数据
		Map<String,Double> agemap=new HashMap<String,Double>();
		agemap.put("age1", 1.0);
		agemap.put("age2", 2.0);
		agemap.put("age4", 4.0);
		agemap.put("age3", 3.0);
		agemap.put("age9", 9.0);
		agemap.put("age5", 5.0);
		redis.zadd("user", agemap);
		Long length=redis.zcard("user");
		System.out.println(length);
	}

	/**
	 * ZCOUNT key min max
	 * 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
	 * */
	public static void zcount(){
		redis.flushDB();//清除数据
		Map<String,Double> agemap=new HashMap<String,Double>();
		agemap.put("age1", 1.0);
		agemap.put("age2", 2.0);
		agemap.put("age4", 4.0);
		agemap.put("age3", 3.0);
		agemap.put("age9", 9.0);
		agemap.put("age5", 5.0);
		redis.zadd("user", agemap);
		Long number=redis.zcount("user", 5,9);
		System.out.println(number);

	}

	/**
	 * ZINCRBY key increment member
	 *为有序集 key 的成员 member 的 score 值加上增量 increment 。
	 *可以通过传递一个负数值 increment ，让 score 减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。
	 *当 key 不存在，或 member 不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。
	 *当 key 不是有序集类型时，返回一个错误。
	 *score 值可以是整数值或双精度浮点数
	 * */
	public static void zincrby(){
		redis.flushDB();//清除数据
		Map<String,Double> agemap=new HashMap<String,Double>();
		agemap.put("age1", 1.0);
		agemap.put("age2", 2.0);
		agemap.put("age4", 4.0);
		agemap.put("age3", 3.0);
		agemap.put("age9", 9.0);
		agemap.put("age5", 5.0);
		redis.zadd("user", agemap);
		redis.zincrby("user", 55,"age5");
		Set<String> list=redis.zrange("user", 0, -1);
		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
	 * 计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。
	 * 默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.
	 * */
	public static void zinterstore(){
		redis.flushDB();//清除数据

		redis.zadd("user", 1, "age1");
		redis.zadd("user", 3, "age3");
		redis.zadd("user", 6, "age6");
		redis.zadd("user", 2, "age2");
		redis.zadd("user", 8, "age8");

		redis.zadd("user1", 11, "age1");
		redis.zadd("user1", 33, "age3");
		redis.zadd("user1", 66, "age6");
		redis.zadd("user1", 22, "age2");
		redis.zadd("user1", 88, "age8");
		redis.zadd("user1", 99, "age9");

		redis.zinterstore("newset",new String[]{"user","user1"});

		Set<String> list=redis.zrange("newset", 0, -1);
		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
	 * 可选的 LIMIT 参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )，注意当 offset 很大时，定位 offset 的操作可能需要遍历整个有序集，此过程最坏复杂度为 O(N) 时间。
	 * 可选的 WITHSCORES 参数决定结果集是单单返回有序集的成员，还是将有序集成员及其 score 值一起返回。
	 * */
	public static void zrangeByScore(){
		redis.flushDB();//清除数据
		redis.zadd("user", 1, "age1");redis.zadd("user", 11, "age11");redis.zadd("user", 111, "age111");
		redis.zadd("user", 3, "age3");redis.zadd("user", 33, "age33");redis.zadd("user", 333, "age333");
		redis.zadd("user", 6, "age6");redis.zadd("user", 66, "age6");redis.zadd("user", 666, "age666");
		redis.zadd("user", 2, "age2");redis.zadd("user", 22, "age22");redis.zadd("user", 222, "age222");
		redis.zadd("user", 8, "age8");redis.zadd("user", 9, "age9");redis.zadd("user", 9, "age9");
		Set<String> list=redis.zrangeByScore("user", 100, 700);
		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * ZRANK key member
	 * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
	 * 排名以 0 为底，也就是说， score 值最小的成员排名为 0 。
	 * */
	public static void rand(){
		redis.flushDB();
		redis.zadd("user", 1, "age1");redis.zadd("user", 11, "age11");redis.zadd("user", 111, "age111");
		long number=redis.zrank("user", "age11");
		//number 显示的位1 低名是从0 开始 age11 排名为第一
		System.out.println(number);
	}

	/**
	 * ZREM key member [member ...]
 	 * 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
	 * 当 key 存在但不是有序集类型时，返回一个错误
	 * */
	public static void zrem(){
		redis.flushDB();
		redis.zadd("user", 1, "age1");
		redis.zadd("user", 2, "age2");
		redis.zadd("user", 3, "age3");
		redis.zadd("user", 4, "age4");
		redis.zadd("user", 5, "age5");
		redis.zrem("user", "age2","age5");
		Set<String> list=redis.zrange("user",0,-1);
		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * 取排名在stat -end 之间的Tuple (strt 和end 指的指的是在集合中的排名 并非是score)
	 * Tuple 包含key 和 score
	 * */
	public static void zrangeWithScores(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 33, "age3");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		Set<Tuple> list= redis.zrangeWithScores("user", 0, 2);
		for(Tuple s:list){
			System.out.println(s.getElement()+" store:"+s.getScore());

		}
	}

	/**
	 * 取排名在stat -end 之间的Tuple (strt 和end 指的是存储的score )
	 * Tuple 包含key 和 score
	 * */
	public static void zrangeByScoreWithScores(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 33, "age3");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		Set<Tuple> list=redis.zrangeByScoreWithScores("user", 0, 35);
		for(Tuple s:list){
			System.out.println(s.getElement()+" store:"+s.getScore());

		}
	}

	/**
	 * 删除 排序号在 strt-end 之间的元素
	 * */
	public static void zremrangeByRank(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 333, "age33");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		redis.zadd("user", 66, "age6");
		redis.zadd("user", 77, "age7");
		redis.zremrangeByRank("user", 0, 3);
		Set<String> list=redis.zrange("user", 0, -1);
		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * 倒序排列集合
	 * @param key (max最大score) (min 最小score)
	 * */
	public static void zrevrangeByScore(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 333, "age33");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		Set<String> list=redis.zrevrangeByScore("user", 55, 0);

		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * 倒序取score 范围 max-min 之间的元素
	 * */
	public static void zrevrangeByScoreWithScores(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 333, "age33");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		redis.zadd("user", 66, "age6");
		redis.zadd("user", 77, "age7");
		Set<Tuple> list=	redis.zrevrangeByScoreWithScores("user", 66, 22);
		for(Tuple s:list){
			System.out.println(s.getElement()+" store:"+s.getScore());
		}
	}

	/**
	 * 倒序排列集合
	 * @param key star-end 取排序范围
	 * */
	public static void zrevrangeWithScores(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 333, "age33");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		Set<Tuple> list=redis.zrevrangeWithScores("user", 0, 3);

		for(Tuple s:list){
			System.out.println(s.getElement()+" score:"+s.getScore());
		}
	}

	/**
	 * 删除 key 在 score的值在star-end 之间的值
	 * */
	public static void zremrangeByScore(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 33, "age3");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		redis.zremrangeByScore("user", 0, 22);
		Set<String> list=redis.zrange("user", 0, -1);
		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * 返回 key 中member 中的排名值
	 * */
	public static void zrevrank(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 33, "age3");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		long l=redis.zrevrank("user", "age3");

		System.out.println(l);

	}

	/**
	 * 返回有序集 key 中，指定区间内的成员。
	 * 其中成员的位置按 score 值递增(从小到大)来排序。
	 * 具有相同 score 值的成员按字典序(lexicographical order )来排列。
	 * */
	public static void zrange(){
		redis.flushDB();//清除数据
		Map<String,Double> agemap=new HashMap<String,Double>();
		agemap.put("age1", 1.0);
		agemap.put("age2", 2.0);
		agemap.put("age4", 4.0);
		agemap.put("age3", 3.0);
		agemap.put("age9", 9.0);
		agemap.put("age5", 5.0);
		redis.zadd("user", agemap);
		redis.zincrby("user", 55,"age5");
		Set<String> list=redis.zrange("user", 0, -1);
		for(String s:list){
			System.out.println(s);
		}

	}

	/**
	 * 求两个集合的并集
	 * */
	public static void zunionstore(){
		redis.flushDB();//清除数据
		redis.zadd("user", 1, "age1");
		redis.zadd("user", 3, "age3");
		redis.zadd("user", 6, "age6");
		redis.zadd("user", 2, "age2");
		redis.zadd("user", 10, "age10");

		redis.zadd("user1", 11, "age1");
		redis.zadd("user1", 33, "age3");
		redis.zadd("user1", 66, "age6");
		redis.zadd("user1", 22, "age2");
		redis.zadd("user1", 88, "age8");
		redis.zadd("user1", 99, "age9");

		redis.zunionstore("newset",new String[]{"user","user1"});
		Set<String> list=redis.zrange("newset", 0, -1);
		for(String s:list){
			System.out.println(s);
		}
	}

	public static void main(String [] args){
		zrevrangeByScoreWithScores();
	}
}

　　

时间： 2024-10-03 01:04:15

Redis学习笔记(6)-SortedSet的相关文章

Redis学习笔记

Redis学习笔记:Redis是什么?redis是开源BSD许可高级的key-vlue存储系统可以用来存储字符串哈希结构链表.结构.集合,因此常用来提供数据结构服务. redis和memcache相比的独特之处:1.redis可以用来做存储,而memcache是用来做缓存 这个特点主要因为其有"持久化"的功能.2.存储的数据有"结构",对于memcache来说,存储的数据只有1种类型"字符串"而 redis则可以存储字符串.链表.哈希机构.集合.

(转)redis 学习笔记(1)-编译、启动、停止

redis 学习笔记(1)-编译.启动.停止 一.下载.编译 redis是以源码方式发行的,先下载源码,然后在linux下编译 1.1 http://www.redis.io/download 先到这里下载Stable稳定版,目前最新版本是2.8.17 1.2 上传到linux,然后运行以下命令解压 tar xzf redis-2.8.17.tar.gz 1.3 编译 cd redis-2.8.17make 注:make命令需要linux上安装gcc,若机器上未安装gcc,redhat环境下,如

Redis学习笔记4-Redis配置具体解释

在Redis中直接启动redis-server服务时, 採用的是默认的配置文件.採用redis-server   xxx.conf 这种方式能够依照指定的配置文件来执行Redis服务. 依照本Redis学习笔记中Redis的依照方式依照后,Redis的配置文件是/etc/redis/6379.conf.以下是Redis2.8.9的配置文件各项的中文解释. #daemonize no 默认情况下, redis 不是在后台运行的.假设须要在后台运行,把该项的值更改为 yes daemonize ye

Redis学习笔记~目录

redis是一个key-value存储系统.和Memcached类似,它支持存储的value类型相对更多,包括string(字符串).list(链表).set(集合).zset(sorted set --有序集合)和hashs(哈希类型).这些数据类型都 支持push/pop.add/remove及取交集并集和差集及更丰富的操作,而且这些操作都是原子性的.在此基础上,redis支持各种不同方式的排 序.与memcached一样,为了保证效率,数据都是缓存在内存中.区别的是redis会周期性的把更

Redis学习笔记7--Redis管道（pipeline）

redis是一个cs模式的tcp server,使用和http类似的请求响应协议.一个client可以通过一个socket连接发起多个请求命令.每个请求命令发出后client通常会阻塞并等待redis服务处理,redis处理完后请求命令后会将结果通过响应报文返回给client.基本的通信过程如下: Client: INCR X Server: 1 Client: INCR X Server: 2 Client: INCR X Server: 3 Client: INCR X Server: 4

Redis学习笔记(简单了解与运行)

Redis学习笔记(简单了解与运行) 开源的非关系型数据库 是REmote Dictionary Server(远程字典服务器)的缩写,以字典结构存储数据 允许其他应用通过TCP协议读写字典中的内容. Redis支持存储的键值数据类型 字符串类型 散列类型 列表类型 集合类型 有序集合类型 Redis的特性 通过一个列子看出Mysql和Redis的存储区别 例如: (存储一篇文章,文章包括:标题(title),正文(content),阅读量(views),标签(tags)) 需求: 把数据存储在

Redis学习笔记4-Redis配置详解

原文:  http://blog.csdn.net/mashangyou/article/details/24555191 在Redis中直接启动redis-server服务时, 采用的是默认的配置文件.采用redis-server   xxx.conf 这样的方式可以按照指定的配置文件来运行Redis服务.按照本Redis学习笔记中Redis的按照方式按照后,Redis的配置文件是/etc/redis/6379.conf.下面是Redis2.8.9的配置文件各项的中文解释. 1 #daemon

Redis学习笔记(增删查)

Redis学习笔记(增删查) 向数据库中添加一个键 SET key value 获取数据库中的key KEYS pattern pattern支持glob风格通配符格式 " ? " 匹配一个字符 " * " 匹配任意字符 " [] " 匹配括号间的任一字符,可以使用" - "符号表示一个范围,例如:a[a-z]c " \x " 匹配字符x,用于转义字符.如需要匹配"?",就需要用 \?

redis学习笔记（9）---对象robject

robject 之前对redis基本的数据结构分别进行了简单的介绍,包括字符串.链表.哈希表.整数集合.压缩列表.压缩字典等,但是redis并不是直接使用这些数据结构来实现key-value对数据库的,而是基于这些数据结构为每一个对象创建一个对象robject.robject对象再根据数据类型,来选择合适的底层数据结构来存储数据. robject的定义如下: typedef struct redisObject { unsigned type:4; unsigned encoding:4; un