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();
}
}