Redis安装、连接池和Jedis八种调用方式(事务、管道、分布式)介绍
jedis基础功能使用细则
使用Jedis直连
package qiu.ht.base;
import java.util.Set;
import redis.clients.jedis.Jedis;
public class Test_Jedis {
//Jedis直连
public static void main(String[] args) {
/**
*
* Jedis对象直连方式可以分为五个步骤:
1、导入redis.clients.jedis.Jedis类(jedis-2.9.0.jar)
2、新建Jedis对象,其构造方法 new Jedis(String host,int port) ,
host参数为Redis数据库ip地址,port为端口号。
3、调用jedis.connect()方法连接Redis
4、调用jedis内置方法操作数据并获得结果(Jedis API会在后面详细讲)
5、调用jedis.disconnect()方法关闭连接
*/
Jedis jedis=new Jedis("127.0.0.1",6379);
//设置密码可看这篇文章:https://blog.csdn.net/qq_41042595/article/details/86498790#t9
jedis.auth("1234");
//连接
jedis.connect();
//列出符合特定条件的key 其中pattern为匹配条件,填*则为列出所有
Set<String> keyList=jedis.keys("*");
// System.out.println("Hello World");
//foreach,将keyList的值,赋值于key,并打印,之后,下个keyList值,赋值于key并打印,以此类推,到最后,打印完,自动出"for(){}"往下运行
for(String key:keyList){
System.out.println("Hello,World!key=="+key);
}
//关闭连接
jedis.disconnect();
}
}
使用JedisPool
⒈
(有key-value时)
数据库db1里的key-value:
遍历查询key-value的代码:
package qiu.ht.base;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class Test_JedisPool {
//Jedis使用连接池
public static void main(String[] args) {
/**
* Jedis连接池管理方式连接Redis可以分为以下几个步骤:
1、导入包(jedis-2.9.0.jar和commons-pool2-2.4.2.jar)
2、获得连接池配置对象JedisPoolConfig
3、设置连接池信息(最大连接数、最大空闲连接数、最小空闲连接数等)
4、获得连接池(new JedisPool(GenericObjectPoolConfig poolConfig,String host,int port))
5、获得核心对象Jedis
6、用Jedis操作Redis数据并取得结果
7、关闭Jedis连接,关闭JedisPool连接池,释放资源
*/
//创建连接池配置对象
JedisPoolConfig config=new JedisPoolConfig();
config.setMaxTotal(25);//设置最大连接数
config.setMaxIdle(20);
config.setMinIdle(5);
JedisPool pool=new JedisPool(config,"127.0.0.1",6379);
//获取核心对象
Jedis jedis=pool.getResource();
//验证redis密码,如果没有设置密码这段可以省略
jedis.auth("1234");//登录
jedis.select(1);//选择DB1数据库
Set<String> keyList=jedis.keys("*");
for(String key:keyList){
//jedis.type(String key)返回给定key所储存的值的类型。 none(key不存在),string(字符串),list(列表),set(集合),zset(有序集),hash(哈希表)
System.out.println("Hello,World!key=="+key+",type="+jedis.type(key));
if(jedis.type(key).equals("string")){
System.out.println("String!value= "+jedis.get(key));
}else if(jedis.type(key).equals("hash")){
System.out.println("Hash!value= "+jedis.hgetAll(key));
Map<String,String> map=jedis.hgetAll(key);
Set<String> set=map.keySet();
Iterator<String> iterator=set.iterator();
while(iterator.hasNext()){
// System.out.println(iterator+"=="+iterator.next());//打印语句里面不能使用hasNext(),否则导致死循环!!!
String field=iterator.next();
System.out.println(field+"==hash=="+map.get(field));
}
}else if(jedis.type(key).equals("list")){
//从此看出String key的length()数字不准确,List的llen()数字才准确,用于jedis.lrange()中,要记得"-1",虽然可以不用"-1",但是为了减少运行量,最好还是要"-1"
System.out.println("List!value= "+jedis.lrange(key, 0,key.length())+" key.length==="+key.length()+" List的length函数==="+jedis.llen(key));
System.out.println("List!value= "+jedis.lrange(key, 0,-1));
//使用了key.length()函数,但是获取的stop的index有问题!!!
// List<String> list=jedis.lrange(key, 0,key.length()-1);
//下面这两个,才是stop的index正确获取方法
// List<String> list=jedis.lrange(key, 0,-1);
//stop从0开始,List获取长度:llen(),Hash获取长度:hlen()
List<String> list=jedis.lrange(key, 0,jedis.llen(key)-1);
for(String keys:list){
System.out.println("List_key="+keys);
}
}else if(jedis.type(key).equals("set")){
System.out.println("Set!value= "+jedis.smembers(key));
Set<String> set=jedis.smembers(key);
for(String sets:set){
System.out.println("Set_value="+sets);
}
}else if(jedis.type(key).equals("zset")){
System.out.println("Zset");
// }else{//zset类型
}
}
//检查给定key是否存在 ,返回一个boolean
if(jedis.exists("nihaonihao")){
System.out.println("Hey !!!!! "+jedis.get("nihaonihao"));
//将key1改名为key2,当key1和key2相同或者key1不存在时,返回一个错误
// jedis.rename("nihaonihao", "why2");
// System.out.println("Hey !!!!! 新名字的值 "+jedis.get("why2")+" 旧名字的值 "+jedis.get("nihaonihao"));
}else{
System.out.println("nihaonihao这个key 没有!!!!!!");
}
jedis.close();
pool.close();
}
}
打印结果:
Hello,World!key==testHash,type=hash
Hash!value= {field1=value1, field4=value44, field3=value3, field2=value1}
field1==hash==value1
field4==hash==value44
field3==hash==value3
field2==hash==value1
Hello,World!key==pushlist,type=list
List!value= [1, 2, 3, 3, 4, 4, 5, 6, 7] key.length===8 List的length函数===9
List!value= [1, 2, 3, 3, 4, 4, 5, 6, 7]
List_key=1
List_key=2
List_key=3
List_key=3
List_key=4
List_key=4
List_key=5
List_key=6
List_key=7
Hello,World!key==hashwhat,type=list
List!value= [water is flowing over a waterfall, commit a crime, miss her] key.length===8 List的length函数===3
List!value= [water is flowing over a waterfall, commit a crime, miss her]
List_key=water is flowing over a waterfall
List_key=commit a crime
List_key=miss her
Hello,World!key==settest,type=set
Set!value= [want, something, with, my, do you like it?, to, I, do, it, my lover]
Set_value=want
Set_value=something
Set_value=with
Set_value=my
Set_value=do you like it?
Set_value=to
Set_value=I
Set_value=do
Set_value=it
Set_value=my lover
Hello,World!key==setwhat,type=set
Set!value= [with whom did you see this movie?, do you like it?]
Set_value=with whom did you see this movie?
Set_value=do you like it?
Hello,World!key==testHash2,type=hash
Hash!value= {field5=value5, field4=value4, field3=value3}
field5==hash==value5
field4==hash==value4
field3==hash==value3
nihaonihao这个key 没有!!!!!!
补充:(遍历所有Hash的key-value,可以不用Iterator迭代器)
Map<String,String> maphash=jedis.hgetAll("testHash2");
for(Map.Entry<String,String> map : maphash.entrySet()){
System.out.println(map.getKey()+"==testHash所有=="+map.getValue());
}
⒉
(新增key-value时【连接Redis步骤在“⒈”中有讲,在此不重复了】)
①
String类型的新增 的代码:
//Jedis使用连接池
public static void main(String[] args) {
JedisPoolConfig config=new JedisPoolConfig();
config.setMaxTotal(25);
config.setMaxIdle(20);
config.setMinIdle(5);
JedisPool pool=new JedisPool(config,"127.0.0.1",6379);
Jedis jedis=pool.getResource();
jedis.auth("1234");
jedis.select(1);
Set<String> keyList=jedis.keys("*");
//返回key的个数
System.out.println("key的个数== "+jedis.dbSize());
for(String key:keyList){
System.out.println("Hello,World!key=="+key+",type="+jedis.type(key));
}
//字符串值value关联到key,如果key不存在则会新增一个key
jedis.set("nihaonihao", "whywhy");
System.out.println("Hey !!!!! "+jedis.get("nihaonihao"));
// //移出给定的一个或多个key,如果key不存在,则忽略该命令
// jedis.del("nihaonihao");
// //打印:无????? null
// System.out.println("无????? "+jedis.get("nihaonihao"));
//检查给定key是否存在 ,返回一个boolean
if(jedis.exists("nihaonihao")){
System.out.println("Hey !!!!! "+jedis.get("nihaonihao"));
//将key1改名为key2,当key1和key2相同或者key1不存在时,返回一个错误
// jedis.rename("nihaonihao", "why2");
// System.out.println("Hey !!!!! 新名字的值 "+jedis.get("why2")+" 旧名字的值 "+jedis.get("nihaonihao"));
}else{
System.out.println("nihaonihao这个key 没有!!!!!!");
}
}
打印结果:
key的个数== 6
Hello,World!key==testHash,type=hash
Hello,World!key==pushlist,type=list
Hello,World!key==hashwhat,type=list
Hello,World!key==settest,type=set
Hello,World!key==setwhat,type=set
Hello,World!key==testHash2,type=hash
Hey !!!!! whywhy
Hey !!!!! whywhy
我放开“Rename”注释:
打印结果:
key的个数== 7
Hello,World!key==pushlist,type=list
Hello,World!key==settest,type=set
Hello,World!key==testHash2,type=hash
Hello,World!key==nihaonihao,type=string
Hello,World!key==testHash,type=hash
Hello,World!key==hashwhat,type=list
Hello,World!key==setwhat,type=set
Hey !!!!! whywhy
Hey !!!!! whywhy
Hey !!!!! 新名字的值 whywhy 旧名字的值 null
我再放开“Delete”注释(将“Rename”注释):
打印结果:
Hello,World!key==testHash,type=hash
Hello,World!key==hashwhat,type=list
Hello,World!key==setwhat,type=set
Hello,World!key==why2,type=string
Hey !!!!! whywhy
无????? null
nihaonihao这个key 没有!!!!!!
若先“Delete”再“Rename”也是可以的,打印结果也一样,因为“Delete and Rename”都在"Set"后面,当然“Delete”与“Rename”同时放开注释,打印结果与“Delete”的结果一样,因为Delete了nihaonihao这个key,就不存在“nihaonihao”了,则进入if-else的else中:
“Expire”设置key的生存时间 的代码:
JedisPoolConfig config=new JedisPoolConfig();
config.setMaxTotal(25);
config.setMaxIdle(20);
config.setMinIdle(5);
JedisPool pool=new JedisPool(config,"127.0.0.1",6379);
Jedis jedis=pool.getResource();
jedis.auth("1234");
jedis.select(1);
Set<String> keyList=jedis.keys("*");
//返回key的个数
System.out.println("key的个数== "+jedis.dbSize());
for(String key:keyList){
System.out.println("Hello,World!key=="+key+",type="+jedis.type(key));
}
//设置key生存时间,当key过期时,它会被自动删除。 Time为秒数
jedis.expire("why2",1000);
System.out.println("why2_value="+jedis.get("why2")+" , 剩下时间(为-1说明过期)="+jedis.ttl("why2"));
打印结果:
key的个数== 7
Hello,World!key==pushlist,type=list
Hello,World!key==settest,type=set
Hello,World!key==testHash2,type=hash
Hello,World!key==testHash,type=hash
Hello,World!key==hashwhat,type=list
Hello,World!key==setwhat,type=set
Hello,World!key==why2,type=string
why2_value=whywhy , 剩下时间(为-1说明过期)=1000
注释“Expire”代码后,运行一次:(“TTL”查看key的生存时间的剩余时间,若为-1,说明key已过期)
打印结果:
key的个数== 7
Hello,World!key==pushlist,type=list
Hello,World!key==settest,type=set
Hello,World!key==testHash2,type=hash
Hello,World!key==testHash,type=hash
Hello,World!key==hashwhat,type=list
Hello,World!key==setwhat,type=set
Hello,World!key==why2,type=string
why2_value=whywhy , 剩下时间(为-1说明过期)=869
“Persist”移出给定key的生存时间 的代码:
JedisPoolConfig config=new JedisPoolConfig();
config.setMaxTotal(25);
config.setMaxIdle(20);
config.setMinIdle(5);
JedisPool pool=new JedisPool(config,"127.0.0.1",6379);
Jedis jedis=pool.getResource();
jedis.auth("1234");
jedis.select(1);
Set<String> keyList=jedis.keys("*");
//返回key的个数
System.out.println("key的个数== "+jedis.dbSize());
for(String key:keyList){
System.out.println("Hello,World!key=="+key+",type="+jedis.type(key));
}
//移出给定key的生存时间(设置这个key永不过期)
jedis.persist("why2");
System.out.println("why2_value="+jedis.get("why2")+" , 剩下时间(为-1说明已经移除了)="+jedis.ttl("why2"));
打印结果:
key的个数== 7
Hello,World!key==pushlist,type=list
Hello,World!key==settest,type=set
Hello,World!key==testHash2,type=hash
Hello,World!key==testHash,type=hash
Hello,World!key==hashwhat,type=list
Hello,World!key==setwhat,type=set
Hello,World!key==why2,type=string
why2_value=whywhy , 剩下时间(为-1说明已经移除了)=-1
在确定“生存时间不为-1”时,persist移除key的生存时间,TTL会为-1,但对于key来说,是死而复生,从“易失”变“持续”,所以删除“持续”的key,要么手动“delete”,要么不理这个key!!!
注:TTL为“-1”,一: 是用于Expire(给key设置生存时间)后的TTL,说明,该key过期了,而且移除了(在控制台打印,最低值为“-1”);二:是Persist后的TTL,说明,该key的生存时间被移除,key不会易失去,删除,只能手动移除了
“Setex”函数的作用:(用于String类型的命令)
将值 value 关联到 key ,并将 key 的生存时间设为 seconds (以秒为单位)。如果 key 已经存在, SETEX 命令将覆写旧值。
这个命令类似于以下两个命令:
SET key value EXPIRE key seconds # 设置生存时间
不同之处是, SETEX 是一个原子性(atomic)操作,关联值和设置生存时间两个动作会在同一时间内完成,该命令在 Redis 用作缓存时,非常实用。
补充:(但Hash类型的key也可以使用这个(我已新增了个Hash类型的key“nihao”),不过后果就是:Hash类型的key变成String类型的key,这样做其实并没有意义)
其使用代码:
打印结果:
②
Hash类型的新增的代码:
package qiu.ht.base;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class Test_JedisPool {
//Jedis使用连接池
public static void main2(String[] args) {
/**
* Jedis连接池管理方式连接Redis可以分为以下几个步骤:
1、导入包(jedis-2.9.0.jar和commons-pool2-2.4.2.jar)
2、获得连接池配置对象JedisPoolConfig
3、设置连接池信息(最大连接数、最大空闲连接数、最小空闲连接数等)
4、获得连接池(new JedisPool(GenericObjectPoolConfig poolConfig,String host,int port))
5、获得核心对象Jedis
6、用Jedis操作Redis数据并取得结果
7、关闭Jedis连接,关闭JedisPool连接池,释放资源
*/
//创建连接池配置对象
JedisPoolConfig config=new JedisPoolConfig();
config.setMaxTotal(25);//设置最大连接数
config.setMaxIdle(20);
config.setMinIdle(5);
JedisPool pool=new JedisPool(config,"127.0.0.1",6379);
//获取核心对象
Jedis jedis=pool.getResource();
//验证redis密码,如果没有设置密码这段可以省略
jedis.auth("1234");//登录
Set<String> keyList=jedis.keys("*");
// System.out.println("Hello World");
for(String key:keyList){
//返回给定key所储存的值的类型。 none(key不存在),string(字符串),list(列表),set(集合),zset(有序集),hash(哈希表)
System.out.println("Hello,World!key=="+key+",type="+jedis.type(key));
if(jedis.type(key).equals("string")){
System.out.println("String!value= "+jedis.get(key));
}else if(jedis.type(key).equals("hash")){
System.out.println("Hash!value= "+jedis.hgetAll(key));
Set<String> set=jedis.hkeys(key);
// List<String> list=jedis.hvals(key);
// for(String lists:list){
// System.out.println("Hash_value="+list);
// }
Map<String,String> map=jedis.hgetAll(key);
Set<String> set=map.keySet();
// for(String sets:set){
// System.out.println("Hash_field="+sets);
// }
Iterator<String> iterator=set.iterator();
while(iterator.hasNext()){
// System.out.println(iterator+"=="+iterator.next());//打印语句里面不能使用hasNext(),否则导致死循环!!!
String field=iterator.next();
System.out.println(field+"==hash=="+map.get(field));
}
}else if(jedis.type(key).equals("list")){
System.out.println("List!value= "+jedis.lrange(key, 0,key.length())+" key.length==="+key.length());
System.out.println("List!value= "+jedis.lrange(key, 0,-1));
//这个使用了key.length()函数,但是获取的stop的index有问题!!!
// List<String> list=jedis.lrange(key, 0,key.length()-1);
//下面这两个,才是stop的index正确获取方法
// List<String> list=jedis.lrange(key, 0,-1);//0表示第一个,-1表示最后一个
List<String> list=jedis.lrange(key, 0,jedis.llen(key)-1);//通过llen方法返回list的长度
for(String keys:list){
System.out.println("List_key="+keys);
}
}else if(jedis.type(key).equals("set")){
System.out.println("Set!value= "+jedis.smembers(key));
Set<String> set=jedis.smembers(key);
for(String sets:set){
System.out.println("Set_value="+sets);
}
}else if(jedis.type(key).equals("zset")){
System.out.println("Zset");
// }else{//zset类型
}
}
//字符串值value关联到key,如果key不存在则会新增一个key
// jedis.set("nihaonihao", "whywhy");
// System.out.println("Hey !!!!! "+jedis.get("nihaonihao"));
// //移出给定的一个或多个key,如果key不存在,则忽略该命令
// jedis.del("nihaonihao");
// //打印:无????? null
// System.out.println("无????? "+jedis.get("nihaonihao"));
//检查给定key是否存在 ,返回一个boolean
if(jedis.exists("nihaonihao")){
// System.out.println("Hey !!!!! "+jedis.get("nihaonihao"));
//将key1改名为key2,当key1和key2相同或者key1不存在时,返回一个错误
jedis.rename("nihaonihao", "why2");
System.out.println("Hey !!!!! 新名字的值 "+jedis.get("why2")+" 旧名字的值 "+jedis.get("nihaonihao"));
}else{
System.out.println("nihaonihao这个key 没有!!!!!!");
}
jedis.close();
pool.close();
}
public static void main(String[] args) {
JedisPoolConfig config=new JedisPoolConfig();
config.setMaxTotal(25);
config.setMaxIdle(20);
config.setMinIdle(5);
JedisPool pool=new JedisPool(config,"127.0.0.1",6379);
Jedis jedis=pool.getResource();
jedis.auth("1234");
jedis.select(1);//选择db1数据库
Set<String> keyList=jedis.keys("*");
//返回key的个数
System.out.println("key的个数== "+jedis.dbSize());
for(String key:keyList){
System.out.println("Hello,World!key=="+key+",type="+jedis.type(key));
}
//设置key生存时间,当key过期时,它会被自动删除。 Time为秒数
// jedis.expire("why2", 60);
//移出给定key的生存时间(设置这个key永不过期)
// jedis.persist("why2");
// System.out.println("why2_value="+jedis.get("why2")+" , 剩下时间="+jedis.ttl("why2"));
//setex之后
// jedis.persist("nihao_hash");
// System.out.println("why2_value="+jedis.get("nihao_hash")+" , 剩下时间(为-1说明已经移除了)="+jedis.ttl("nihao_hash"));
/**
* 打印语句会报异常:(因为nihao_hash的值不可获取了)
* Exception in thread "main" redis.clients.jedis.exceptions.JedisDataException: WRONGTYPE Operation against a key holding the wrong kind of value
at redis.clients.jedis.Protocol.processError(Protocol.java:127)
*/
//将值value关联到key,并将key的生存时间设为seconds(秒),不管原来nihao_hash是什么类型,运行setex之后,变String类型,值覆盖为“ni1 ni1”。
// jedis.setex("nihao_hash",1000, "ni1 ni1");
// Set<String> keyList2=jedis.keys("*");
// for(String key:keyList2){
// System.out.println("Hello,World!key=="+key+",type="+jedis.type(key));
// }
/**
* 这个setex之后,不再是hash类型了,否则会报错:
* 127.0.0.1:6379> hgetall nihao_hash
1) "nihao"
2) "hao"
3) "OK"
4) "K"
5) "ni"
6) "ni"
7) "hao"
8) "ni"
127.0.0.1:6379> hgetall nihao_hash【开始使用setex函数】
(error) WRONGTYPE Operation against a key holding the wrong kind of value【对持有错误类型值的键执行错误的操作】
127.0.0.1:6379> exists nihao_hash
(integer) 1
127.0.0.1:6379> hmset nihao_hash ni ni nihao hao O OK K OK how ??
(error) WRONGTYPE Operation against a key holding the wrong kind of value
127.0.0.1:6379> hset nihao_hash ni ni
(error) WRONGTYPE Operation against a key holding the wrong kind of value
127.0.0.1:6379> get nihao_hash【setex之后hash类型变成string类型了,要用get才获取得了value】
"ni1 ni1"
*/
//清空整个redis实例所有的key
// jedis.flushAll();
//清空redis当前数据库所有的key
// jedis.flushDB();
//flushDB之后没有任何个key了
// Set<String> keyList2=jedis.keys("*");
// for(String key:keyList2){
// System.out.println("Hello,World!key=="+key+",type="+jedis.type(key));
// }
//------------------------------------------------------------------------Hash----------------
//设置一张hash表的两种方式:
// //1、分别给哈希表key中的域设置值,分别对key中的字段1、字段2设置值
// jedis.hset("testHash" , "field1" , "value1");
// jedis.hset("testHash" , "field2" , "value1");
// //2、用一个JAVA中的HashMap直接存储为redis中的哈希表
// Map map = new HashMap();
// map.put("field11" , "value11");
// map.put("field12" , "value11");
// jedis.hmset("testHash2" , map);
//返回哈希表key中给定字段field的值,返回对应值的类型
// System.out.println("testHash的第二个field=="+jedis.hget("testHash" ,"field2")+",testHash2的第二个field=="+jedis.hget("testHash2" ,"field12"));
//返回哈希表key中给定多个字段的值,返回一个List
// List<String> listhash=jedis.hmget("testHash2" ,"field3","field4");
// for(String key:listhash){
// System.out.println("111111 testHash2的指定field的值,value=="+key);
// }
//返回哈希表key中的所有字段和值,返回一个Map<String,String>
// Map<String,String> maphash=jedis.hgetAll("testHash2");
// Set<String> set=maphash.keySet();
// Iterator<String> iterator=set.iterator();
// while(iterator.hasNext()){
// String field=iterator.next();
// System.out.println(field+"==testHash所有=="+maphash.get(field));
// }
//删除哈希表key中的一个或多个指定字段
// jedis.hdel("testHash2","field12","field11");
//查看哈希表key中,给定字段field是否存在。
// if(jedis.hexists("testHash2","field12")){
// System.out.println("在testHash2这个key中存在field12域");
// }else{
// System.out.println("删除成功!!");
// }
// //返回哈希表key中的所有字段
// Set<String> sethash=jedis.hkeys("testHash2");
// //返回哈希表key中的所有值
// List<String> listhash2=jedis.hvals("testHash2");
//
// for(String key:sethash){
// System.out.println("222222 testHash2的所有key,key=="+key);
// }
// for(String key:listhash2){
// System.out.println("333333 testHash2的所有value,value=="+key);
// }
//---------------------------------------------------------------------List----------------------
//将值value插入到列表key的表头。
// jedis.lpush("listpush" ,"what","how","1","0哈哈哈哈");
// //返回列表key中指定区间内的元素,区间以偏移量start和stop指定. 下标(index)参数start和stop从0开始; 负数下标代表从后开始(-1表示列表的最后一个元素,-2表示列表的倒数第二个元素,以此类推) 返回一个List
// //返回列表key的长度 , 返回一个Int -----------jedis.llen(keyname);
// List<String> listlist=jedis.lrange("listpush" , 0,jedis.llen("listpush")-1);
// for(String key:listlist){
// System.out.println("444444 listpush的所有value,value=="+key);
// }
//---------------------------------------------------------------------Set--------------------
// //将member元素加入到集合key当中。
// jedis.sadd("settest" , "I","want","to","do","something","it","with","my","my lover");
// //返回集合key的元素的数量
// System.out.println("移除前,,,,,,有多少value了? "+jedis.scard("settest"));
// //移除集合中的多个member元素。
jedis.srem("settest" , "it");
// System.out.println("移除后,,,,,,有多少value了? "+jedis.scard("settest"));
// //判断元素是否是集合key的成员
// if(jedis.sismember("settest" , "it")){
// System.out.println("存在it");
// }else{
// System.out.println("移除it成功!!!!!!");
// }
// //返回集合key中的所有成员。返回一个set
// Set<String> setset=jedis.smembers("settest");
// for (String string : setset) {
// System.out.println("settest中的所有value=="+string);
// }
// //返回一个集合的全部成员,该集合是所有给定集合的交集
// Set<String> setset2=jedis.sinter("settest" , "setwhat");
// for (String string : setset2) {
// System.out.println("setwhat与settest中的相同的value=="+string);
// }
// //返回一个集合的全部成员,该集合是所有给定集合的并集
// Set<String> setset3=jedis.sunion("settest" ,"setwhat");
// for (String string : setset3) {
// System.out.println("settest与setwhat的并集value=="+string);
// }
// //返回一个集合的全部成员,该集合是所有给定集合的差集
// Set<String> setset4=jedis.sdiff("settest" , "setwhat");
// for (String string : setset4) {
// System.out.println("settest对于setwhat来说,差了什么(除了setwhat交集的值剩下的value),value=="+string);
// }
// Set<String> setset5=jedis.sdiff("setwhat","settest");
// for (String string : setset5) {
// System.out.println("setwhat差了settest的值是"+string);
// }
jedis.close();
pool.close();
}
}