redis接口手冊

String類型數據結構

set(String key, Object value)

使用:set("name","tom")
結果:get("name")  輸出結果為tom

setExpire(String key, Object value, long expireTime, TimeUnit timeUnit)

使用:setExpire("name","tom",10, TimeUnit.SECONDS)
結果:get("name")  由於設置的是10秒失效，十秒之內查詢有結果，十秒之后返回為null

setOffset(String key, Object value, long offset)

value 參數覆寫(overwrite)給定 key 所儲存的字符串值，從偏移量 offset 開始

使用:setOffset("key","hello world")
setOffset("key","redis", 6)
結果:get("key")  輸出結果為hello redis

setIfAbsent(String key, Object value)

設置value時先判斷該值原來是否存在

使用:setIfAbsent("multi1","multi1")//multi1之前已經存在
setIfAbsent("multi111","multi111")//multi111之前不存在
結果:false
true

multiSet(Map< String, Object> map)

為多個鍵分別設置它們的值

使用：Map<String,String> maps = new HashMap<String, String>();
        maps.put("multi1","multi1");
        maps.put("multi2","multi2");
        maps.put("multi3","multi3");
        multiSet(maps);
        List<String> keys = new ArrayList<String>();
        keys.add("multi1");
        keys.add("multi2");
        keys.add("multi3");
        System.out.println(multiGet(keys));
結果：[multi1, multi2, multi3]

multiSetIfAbsent(Map<String, Object> map)

為多個鍵分別設置它們的值，如果存在則返回false，不存在返回true

使用：Map<String,String> maps = new HashMap<String, String>();
        maps.put("multi11","multi11");
        maps.put("multi22","multi22");
        maps.put("multi33","multi33");
        Map<String,String> maps2 = new HashMap<String, String>();
        maps2.put("multi1","multi1");
        maps2.put("multi2","multi2");
        maps2.put("multi3","multi3");
        System.out.println(multiSetIfAbsent(maps));
        System.out.println(multiSetIfAbsent(maps2));
結果：true
false

get(String key)

獲取key對應的值

使用：set("key","hello world");
        System.out.println(get("key"));
結果：hello world

getAndSet(String key, String value)

設置鍵的字符串值並返回其舊值

使用：set("getSetTest","test");
        System.out.println(getAndSet("getSetTest","test2"));
結果：test

List< Object> multiGet(Collection< String> collection)

為多個鍵分別取出它們的值

使用：Map<String,String> maps = new HashMap<String, String>();
        maps.put("multi1","multi1");
        maps.put("multi2","multi2");
        maps.put("multi3","multi3");
        multiSet(maps);
        List<String> keys = new ArrayList<String>();
        keys.add("multi1");
        keys.add("multi2");
        keys.add("multi3");
        System.out.println(multiGet(keys));
結果：[multi1, multi2, multi3]

increment(String key, long value)

支持整數

使用：increment("increlong",1);
        System.out.println(get("increlong"));
結果：2

increment(String key, double value)

支持浮點數

使用：increment("increlong",1.2);
        System.out.println(get("increlong"));
結果：2.2

append(String key, String value)

如果key已經存在並且是一個字符串，則該命令將該值追加到字符串的末尾。如果鍵不存在，則它被創建並設置為空字符串，因此APPEND在這種特殊情況下將類似於SET。

使用：append("appendTest","Hello");
        System.out.println(get("appendTest"));
        append("appendTest","world");
        System.out.println(get("appendTest"));
結果：Hello
        Helloworld

sub(String key, long start, long end)

截取key所對應的value字符串

使用：appendTest對應的value為Helloworld
System.out.println(sub("appendTest",0,5));
結果：Hellow
使用：System.out.println(sub("appendTest",0,-1));
結果：Helloworld
使用：System.out.println(sub("appendTest",-3,-1));
結果：rld

size(String key)

返回key所對應的value值得長度

使用：set("key","hello world");
    System.out.println(size("key"));
結果：11

setBit(String key, long offset, boolean value)

對 key 所儲存的字符串值，設置或清除指定偏移量上的位(bit)
key鍵對應的值value對應的ascii碼,在offset的位置(從左向右數)變為value

使用：set("bitTest","a");
        // 'a' 的ASCII碼是 97。轉換為二進制是：01100001
        // 'b' 的ASCII碼是 98  轉換為二進制是：01100010
        // 'c' 的ASCII碼是 99  轉換為二進制是：01100011
        //因為二進制只有0和1，在setbit中true為1，false為0，因此我要變為'b'的話第六位設置為1，第七位設置為0
        setBit("bitTest",6, true);
        setBit("bitTest",7, false);
        System.out.println(get("bitTest"));
結果：b

getBit(String key, long offset)

獲取鍵對應值的ascii碼的在offset處位值

使用：System.out.println(getBit("bitTest",7));
結果：false

Hash數據結構

hdelete(String key, Object... hashKeys)

刪除給定的哈希hashKeys

使用：System.out.println(hdelete("redisHash","name"));
        System.out.println(entries("redisHash"));
結果：1
{class=6, age=28.1}

hasKey(String key, Object hashKey)

確定哈希hashKey是否存在

使用：System.out.println(hasKey("redisHash","age"));
        System.out.println(hasKey("redisHash","ttt"));
結果：true
false

hget(String key, Object hashKey)

從鍵中的哈希獲取給定hashKey的值

使用：System.out.println(hget("redisHash","age"));
結果：26

hmultiGet(String key, Collection< Object> hashKeys)

從哈希中獲取給定hashKey的值

使用：List<Object> kes = new ArrayList<Object>();
        kes.add("name");
        kes.add("age");
        System.out.println(hmultiGet("redisHash",kes));
結果：[jack, 28.1]

hincrement(String key, Object hashKey, long value)

通過給定的delta增加散列hashKey的值（整型）

使用：System.out.println(hget("redisHash","age"));
    System.out.println(hincrement("redisHash","age",1));
結果：26
27

hincrement(String key, Object hashKey, double value)

通過給定的delta增加散列hashKey的值（浮點數）

使用：System.out.println(hget("redisHash","age"));
    System.out.println(hincrement("redisHash","age",1.1));
結果：27
28.1

hkeys(String key)

獲取key所對應的散列表的key

使用：System.out.println(hkeys("redisHash1"));
//redisHash1所對應的散列表為{class=1, name=jack, age=27}
結果：[name, class, age]

hsize(String key)

獲取key所對應的散列表的大小個數

使用：System.out.println(hsize("redisHash1"));
//redisHash1所對應的散列表為{class=1, name=jack, age=27}
結果：3

putAll(String key, Map<Object, Object> map)

使用m中提供的多個散列字段設置到key對應的散列表中

使用：Map<String,Object> testMap = new HashMap();
        testMap.put("name","jack");
        testMap.put("age",27);
        testMap.put("class","1");
       putAll("redisHash1",testMap);
        System.out.println(entries("redisHash1"));
結果：{class=1, name=jack, age=27}

put(String key, Object hashKey, Object value)

設置散列hashKey的值

使用：put("redisHash","name","tom");
        put("redisHash","age",26);
        put("redisHash","class","6");
System.out.println(entries("redisHash"));
結果：{age=26, class=6, name=tom}

putIfAbsent(String key, Object hashKey, Object value)

僅當hashKey不存在時才設置散列hashKey的值。

使用：System.out.println(putIfAbsent("redisHash","age",30));
System.out.println(putIfAbsent("redisHash","kkk","kkk"));
結果：false
true

values(String key)

獲取整個哈希存儲的值根據密鑰

使用：System.out.println(values("redisHash"));
結果：[tom, 26, 6]

entries(String key)

獲取整個哈希存儲根據密鑰

使用：System.out.println(entries("redisHash"));
結果：{age=26, class=6, name=tom}

hscan(String key, ScanOptions options)

使用Cursor在key的hash中迭代，相當於迭代器。

使用：Cursor<Map.Entry<Object, Object>> curosr = hscan("redisHash", ScanOptions.ScanOptions.NONE);
        while(curosr.hasNext()){
            Map.Entry<Object, Object> entry = curosr.next();
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
結果：age:28.1
class:6
kkk:kkk

List數據結構

lrange(String key, long start, long end)

返回存儲在鍵中的列表的指定元素。偏移開始和停止是基於零的索引，其中0是列表的第一個元素（列表的頭部），1是下一個元素

使用：System.out.println(lrange("list",0,-1));
結果:[c#, c++, python, java, c#, c#]

trim(String key, long start, long end)

裁剪現有列表，使其只包含指定的指定范圍的元素，起始和停止都是基於0的索引

使用：System.out.println(lrange("list",0,-1));
trim("list",1,-1);//裁剪第一個元素
System.out.println(lrange("list",0,-1));
結果:[c#, c++, python, java, c#, c#]
[c++, python, java, c#, c#]

lsize(String key)

返回存儲在鍵中的列表的長度。如果鍵不存在，則將其解釋為空列表，並返回0。當key存儲的值不是列表時返回錯誤。

使用：System.out.println(lsize("list"));
結果:6

leftPush(String key, Object value)

將所有指定的值插入存儲在鍵的列表的頭部。如果鍵不存在，則在執行推送操作之前將其創建為空列表。（從左邊插入）

使用：leftPush("list","java");
        leftPush("list","python");
        leftPush("list","c++");
結果:返回的結果為推送操作后的列表的長度

leftPushAll(String key, Object... values)

批量把一個數組插入到列表中

使用：String[] stringarrays = new String[]{"1","2","3"};
        leftPushAll("listarray",stringarrays);
        System.out.println(lrange("listarray",0,-1));
結果:[3, 2, 1]

leftPushAll(String key, Collection< Object> values)

批量把一個集合插入到列表中

使用：List<Object> strings = new ArrayList<Object>();
        strings.add("1");
        strings.add("2");
        strings.add("3");
        leftPushAll("listcollection4", strings);
        System.out.println(lrange("listcollection4",0,-1));
結果:[3, 2, 1]

leftPushIfPresent(String key, Object value)

只有存在key對應的列表才能將這個value值插入到key所對應的列表中

使用：System.out.println(leftPushIfPresent("leftPushIfPresent","aa"));
        System.out.println(leftPushIfPresent("leftPushIfPresent","bb"));
==========分割線===========
System.out.println(leftPush("leftPushIfPresent","aa"));
        System.out.println(leftPushIfPresent("leftPushIfPresent","bb"));
結果:
0
0
==========分割線===========
1
2

leftPush(String key, Object pivot, Object value)

把value值放到key對應列表中pivot值的左面，如果pivot值存在的話

使用：leftPush("list","java","oc");
        System.out.print(lrange("list",0,-1));
結果：[c++, python, oc, java, c#, c#]

rightPush(String key, Object value)

將所有指定的值插入存儲在鍵的列表的頭部。如果鍵不存在，則在執行推送操作之前將其創建為空列表。（從右邊插入）

使用：rightPush("listRight","java");
        rightPush("listRight","python");
        rightPush("listRight","c++");
結果:
1
2
3

rightPushAll(String key, Object... values)

使用：String[] stringarrays = new String[]{"1","2","3"};
        rightPushAll("listarrayright",stringarrays);
        System.out.println(lrange("listarrayright",0,-1));
結果:[1, 2, 3]

rightPushAll(String key, Collection< Object> values)

使用：List<Object> strings = new ArrayList<Object>();
        strings.add("1");
        strings.add("2");
        strings.add("3");
        rightPushAll("listcollectionright", strings);
        System.out.println(lrange("listcollectionright",0,-1));
結果:[1, 2, 3]

rightPushIfPresent(String key, Object value)

只有存在key對應的列表才能將這個value值插入到key所對應的列表中

使用：System.out.println(rightPushIfPresent("rightPushIfPresent","aa"));
        System.out.println(rightPushIfPresent("rightPushIfPresent","bb"));
        System.out.println("==========分割線===========");
        System.out.println(rightPush("rightPushIfPresent","aa"));
        System.out.println(rightPushIfPresent("rightPushIfPresent","bb"));
結果:0
0
==========分割線===========
1
2

rightPush(String key, Object pivot, Object value)

把value值放到key對應列表中pivot值的右面，如果pivot值存在的話

使用：System.out.println(lrange("listRight",0,-1));
        rightPush("listRight","python","oc");
        System.out.println(lrange("listRight",0,-1));
結果:[java, python, c++]
[java, python, oc, c++]

lset(String key, long index, Object value)

在列表中index的位置設置value值

使用：System.out.println(lrange("listRight",0,-1));
        lset("listRight",1,"setValue");
        System.out.println(lrange("listRight",0,-1));
結果:[java, python, oc, c++]
[java, setValue, oc, c++]

remove(String key, long count, Object value)

從存儲在鍵中的列表中刪除等於值的元素的第一個計數事件。
計數參數以下列方式影響操作：
count> 0：刪除等於從頭到尾移動的值的元素。
count <0：刪除等於從尾到頭移動的值的元素。
count = 0：刪除等於value的所有元素。

使用：System.out.println(lrange("listRight",0,-1));
        remove("listRight",1,"setValue");//將刪除列表中存儲的列表中第一次次出現的“setValue”。
        System.out.println(lrange("listRight",0,-1));
結果:[java, setValue, oc, c++]
[java, oc, c++]

index(String key, long index)

根據下表獲取列表中的值，下標是從0開始的

使用：System.out.println(lrange("listRight",0,-1));
System.out.println(index("listRight",2));
結果:[java, oc, c++]
c++

leftPop(String key)

彈出最左邊的元素，彈出之后該值在列表中將不復存在

使用：System.out.println(lrange("list",0,-1));
        System.out.println(leftPop("list"));
        System.out.println(lrange("list",0,-1));
結果:
[c++, python, oc, java, c#, c#]
c++
[python, oc, java, c#, c#]

leftPop(String key, long timeout, TimeUnit timeUnit)

移出並獲取列表的第一個元素， 如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止。

使用：用法與 leftPop(String key);一樣

rightPop(String key)

彈出最右邊的元素，彈出之后該值在列表中將不復存在

使用： System.out.println(lrange("list",0,-1));
        System.out.println(rightPop("list"));
        System.out.println(lrange("list",0,-1));
結果:[python, oc, java, c#, c#]
c#
[python, oc, java, c#]

rightPop(String key, long timeout, TimeUnit timeUnit)

移出並獲取列表的最后一個元素， 如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止。

使用：用法與 rightPop(String key);一樣

rightPopAndLeftPush(String sourceKey, String destinationKey)

用於移除列表的最后一個元素，並將該元素添加到另一個列表並返回。

使用：System.out.println(lrange("list",0,-1));
rightPopAndLeftPush("list","rightPopAndLeftPush");
    System.out.println(lrange("list",0,-1));
    System.out.println(lrange("rightPopAndLeftPush",0,-1));
結果:[oc, java,c#]
[oc, java]
[c#]

rightPopAndLeftPush(String sourceKey, String destinationKey, long timeout, TimeUnit timeUnit)

用於移除列表的最后一個元素，並將該元素添加到另一個列表並返回，如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止。

使用：用法與rightPopAndLeftPush(K sourceKey, K destinationKey)一樣

Set數據結構

add(String key, Object... values)

無序集合中添加元素，返回添加個數
也可以直接在add里面添加多個值 如：add("setTest","aaa","bbb")

使用：String[] strarrays = new String[]{"strarr1","sgtarr2"};
        System.out.println(add("setTest", strarrays));
結果：2

sremove(String key, Object... values)

移除集合中一個或多個成員

使用：String[] strarrays = new String[]{"strarr1","sgtarr2"};
System.out.println(sremove("setTest",strarrays));
結果：2

pop(String key)

移除並返回集合中的一個隨機元素

使用：System.out.println(pop("setTest"));
System.out.println(members("setTest"));
結果：bbb
[aaa, ccc]

move(String key, Object value, String destKey)

將 member 元素從 source 集合移動到 destination 集合

使用：move("setTest","aaa","setTest2");
        System.out.println(members("setTest"));
        System.out.println(members("setTest2"));
結果：[ccc]
[aaa]

ssize(String key)

無序集合的大小長度

使用：System.out.println(ssize("setTest"));
結果：1

isMember(String key, Object value)

判斷 member 元素是否是集合 key 的成員

使用：System.out.println(isMember("setTest","ccc"));
        System.out.println(isMember("setTest","asd"));
結果：true
false

intersect(String key, String otherKey)

key對應的無序集合與otherKey對應的無序集合求交集

使用：System.out.println(members("setTest"));
        System.out.println(members("setTest2"));
        System.out.println(intersect("setTest","setTest2"));
結果：[aaa, ccc]
[aaa]
[aaa]

intersect(String key, Collection< String> otherKeys)

key對應的無序集合與多個otherKey對應的無序集合求交集

使用：System.out.println(members("setTest"));
        System.out.println(members("setTest2"));
        System.out.println(members("setTest3"));
        List<String> strlist = new ArrayList<String>();
        strlist.add("setTest2");
        strlist.add("setTest3");
        System.out.println(intersect("setTest",strlist));
結果：[aaa, ccc]
[aaa]
[ccc, aaa]
[aaa]

sintersectAndStore(String key, String otherKey, String destKey)

key無序集合與otherkey無序集合的交集存儲到destKey無序集合中

使用：System.out.println("setTest:" + members("setTest"));
System.out.println("setTest2:" + members("setTest2"));
System.out.println(sintersectAndStore("setTest","setTest2","destKey1"));
System.out.println(members("destKey1"));
結果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
2
[aaa, ccc]

sintersectAndStore(String key, Collection< String> otherKeys, String destKey)

key對應的無序集合與多個otherKey對應的無序集合求交集存儲到destKey無序集合中

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println("setTest3:" + members("setTest3"));
        List<String> strlist = new ArrayList<String>();
        strlist.add("setTest2");
        strlist.add("setTest3");
        System.out.println(sintersectAndStore("setTest",strlist,"destKey2"));
        System.out.println(members("destKey2"));
結果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
setTest3:[ccc, aaa]
2
[aaa, ccc]

union(String key, String otherKey)

key無序集合與otherKey無序集合的並集

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println(union("setTest","setTest2"));
結果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
[ccc, aaa, ddd, bbb]

union(String key, Collection< String> otherKeys)

key無序集合與多個otherKey無序集合的並集

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println("setTest3:" + members("setTest3"));
        List<String> strlist = new ArrayList<String>();
        strlist.add("setTest2");
        strlist.add("setTest3");
        System.out.println(union("setTest",strlist));
結果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
setTest3:[xxx, ccc, aaa]
[ddd, xxx, bbb, aaa, ccc]

sunionAndStore(String key, String otherKey, String destKey)

key無序集合與otherkey無序集合的並集存儲到destKey無序集合中

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println(sunionAndStore("setTest","setTest2","unionAndStoreTest1"));
        System.out.println("unionAndStoreTest1:" + members("unionAndStoreTest1"));
結果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
4
unionAndStoreTest1:[ccc, aaa, ddd, bbb]

sunionAndStore(String key, Collection< String> otherKeys, String destKey)

key無序集合與多個otherkey無序集合的並集存儲到destKey無序集合中

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println("setTest3:" + members("setTest3"));
        List<String> strlist = new ArrayList<String>();
        strlist.add("setTest2");
        strlist.add("setTest3");
        System.out.println(sunionAndStore("setTest",strlist,"unionAndStoreTest2"));
        System.out.println("unionAndStoreTest2:" + members("unionAndStoreTest2"));
結果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
setTest3:[xxx, ccc, aaa]
5
unionAndStoreTest2:[ddd, xxx, bbb, aaa, ccc]

difference(String key, String otherKey)

key無序集合與otherKey無序集合的差集

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println(difference("setTest","setTest2"));
結果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
[bbb, ddd]

difference(String key, Collection< String> otherKeys)

key無序集合與多個otherKey無序集合的差集

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println("setTest3:" + members("setTest3"));
        List<String> strlist = new ArrayList<String>();
        strlist.add("setTest2");
        strlist.add("setTest3");
        System.out.println(difference("setTest",strlist));
結果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
setTest3:[xxx, ccc, aaa]
[bbb, ddd]

differenceAndStore(String key, String otherKey, String destKey)

key無序集合與otherkey無序集合的差集存儲到destKey無序集合中

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println(differenceAndStore("setTest","setTest2","differenceAndStore1"));
        System.out.println("differenceAndStore1:" + members("differenceAndStore1"));
結果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
2
differenceAndStore1:[bbb, ddd]

differenceAndStore(String key, Collection< String> otherKeys, String destKey)

key無序集合與多個otherkey無序集合的差集存儲到destKey無序集合中

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println("setTest3:" + members("setTest3"));
        List<String> strlist = new ArrayList<String>();
        strlist.add("setTest2");
        strlist.add("setTest3");
        System.out.println(differenceAndStore("setTest",strlist,"differenceAndStore2"));
        System.out.println("differenceAndStore2:" + members("differenceAndStore2"));
結果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
setTest3:[xxx, ccc, aaa]
2
differenceAndStore2:[bbb, ddd]

members(String key)

返回集合中的所有成員

使用：System.out.println(members("setTest"));
結果：[ddd, bbb, aaa, ccc]

randomMember(String key)

隨機獲取key無序集合中的一個元素

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTestrandomMember:" + randomMember("setTest"));
        System.out.println("setTestrandomMember:" + randomMember("setTest"));
        System.out.println("setTestrandomMember:" + randomMember("setTest"));
        System.out.println("setTestrandomMember:" + randomMember("setTest"));
結果：setTest:[ddd, bbb, aaa, ccc]
setTestrandomMember:aaa
setTestrandomMember:bbb
setTestrandomMember:aaa
setTestrandomMember:ddd

distinctRandomMembers(String key, long count)

獲取多個key無序集合中的元素（去重），count表示個數

使用：System.out.println("randomMembers:" + distinctRandomMembers("setTest",5));
結果：randomMembers:[aaa, bbb, ddd, ccc]

randomMembers(String key, long count)

獲取多個key無序集合中的元素，count表示個數

使用：System.out.println("randomMembers:" + randomMembers("setTest",5));
結果：randomMembers:[ccc, ddd, ddd, ddd, aaa]

sscan(String key, ScanOptions options)

遍歷set

使用： Cursor<Object> curosr = sscan("setTest", ScanOptions.NONE);
        while(curosr.hasNext()){
            System.out.println(curosr.next());
        }
結果：ddd
bbb
aaa
ccc

ZSet數據結構

add(String key, Object value, double score)

新增一個有序集合，存在的話為false，不存在的話為true

使用：System.out.println(add("zset1","zset-1",1.0));
結果：true

add(String key, Set<ZSetOperations.TypedTuple< Object>> tuples)

新增一個有序集合

使用：ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<Object>("zset-5",9.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<Object>("zset-6",9.9);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<ZSetOperations.TypedTuple<Object>>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        System.out.println(add("zset1",tuples));
        System.out.println(range("zset1",0,-1));
結果：[zset-1, zset-2, zset-3, zset-4, zset-5, zset-6]

remove(String key, Object... values)

從有序集合中移除一個或者多個元素

使用：System.out.println(range("zset1",0,-1));
        System.out.println(remove("zset1","zset-6"));
        System.out.println(range("zset1",0,-1));
結果：[zset-1, zset-2, zset-3, zset-4, zset-5, zset-6]
1
[zset-1, zset-2, zset-3, zset-4, zset-5]

incrementScore(String key, Object value, double score)

增加元素的score值，並返回增加后的值

使用：System.out.println(incrementScore("zset1","zset-1",1.1));  //原為1.1
結果：2.2

rank(String key, Object value)

返回有序集中指定成員的排名，其中有序集成員按分數值遞增(從小到大)順序排列

使用：System.out.println(range("zset1",0,-1));
        System.out.println(rank("zset1","zset-2"));
結果：[zset-2, zset-1, zset-3, zset-4, zset-5]
0   //表明排名第一

reverseRank(String key, Object value)

返回有序集中指定成員的排名，其中有序集成員按分數值遞減(從大到小)順序排列

使用：System.out.println(range("zset1",0,-1));
        System.out.println(reverseRank("zset1","zset-2"));
結果：[zset-2, zset-1, zset-3, zset-4, zset-5]
4 //遞減之后排到第五位去了

range(String key, long start, long end)

通過索引區間返回有序集合成指定區間內的成員，其中有序集成員按分數值遞增(從小到大)順序排列

使用：System.out.println(range("zset1",0,-1));
結果：[zset-2, zset-1, zset-3, zset-4, zset-5]

rangeWithScores(String key, long start, long end)

通過索引區間返回有序集合成指定區間內的成員對象，其中有序集成員按分數值遞增(從小到大)順序排列

使用：Set<ZSetOperations.TypedTuple<Object>> tuples = rangeWithScores("zset1",0,-1);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
結果：value:zset-2score:1.2
value:zset-1score:2.2
value:zset-3score:2.3
value:zset-4score:6.6
value:zset-5score:9.6

rangeByScore(String key, double min, double max)

通過分數返回有序集合指定區間內的成員，其中有序集成員按分數值遞增(從小到大)順序排列

使用：System.out.println(rangeByScore("zset1",0,5));
結果：[zset-2, zset-1, zset-3]

rangeByScoreWithScores(String key, double min, double max)

使用：Set<ZSetOperations.TypedTuple<Object>> tuples = rangeByScoreWithScores("zset1",0,5);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
結果：value:zset-2score:1.2
value:zset-1score:2.2
value:zset-3score:2.3

通過分數返回有序集合指定區間內的成員對象，其中有序集成員按分數值遞增(從小到大)順序排列

rangeByScore(String key, double min, double max, long offset, long count)

通過分數返回有序集合指定區間內的成員，並在索引范圍內，其中有序集成員按分數值遞增(從小到大)順序排列

使用： System.out.println(rangeByScore("zset1",0,5));
    System.out.println(rangeByScore("zset1",0,5,1,2));
結果：[zset-2, zset-1, zset-3]
[zset-1, zset-3]

rangeByScoreWithScores(String key, double min, double max, long offset, long count)

通過分數返回有序集合指定區間內的成員對象，並在索引范圍內，其中有序集成員按分數值遞增(從小到大)順序排列

使用：Set<ZSetOperations.TypedTuple<Object>> tuples = rangeByScoreWithScores("zset1",0,5,1,2);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
結果：value:zset-1score:2.2
value:zset-3score:2.3

reverseRange(String key, long start, long end)

通過索引區間返回有序集合成指定區間內的成員，其中有序集成員按分數值遞減(從大到小)順序排列

使用：System.out.println(reverseRange("zset1",0,-1));
結果：[zset-5, zset-4, zset-3, zset-1, zset-2]

reverseRangeWithScores(String key, long start, long end)

通過索引區間返回有序集合成指定區間內的成員對象，其中有序集成員按分數值遞減(從大到小)順序排列

使用：Set<ZSetOperations.TypedTuple<Object>> tuples = reverseRangeWithScores("zset1",0,-1);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
結果：value:zset-5score:9.6
value:zset-4score:6.6
value:zset-3score:2.3
value:zset-1score:2.2
value:zset-2score:1.2

reverseRangeByScore(String key, double min, double max)

使用：與rangeByScore調用方法一樣，其中有序集成員按分數值遞減(從大到小)順序排列

reverseRangeByScoreWithScores(String key, double min, double max)

使用：與rangeByScoreWithScores調用方法一樣，其中有序集成員按分數值遞減(從大到小)順序排列

reverseRangeByScore(String key, double min, double max, long offset, long count)

使用：與rangeByScore調用方法一樣，其中有序集成員按分數值遞減(從大到小)順序排列

reverseRangeByScoreWithScores(String key, double min, double max, long offset, long count)

使用：與rangeByScoreWithScores調用方法一樣，其中有序集成員按分數值遞減(從大到小)順序排列

count(String key, double min, double max)

通過分數返回有序集合指定區間內的成員個數

使用：System.out.println(rangeByScore("zset1",0,5));
        System.out.println(count("zset1",0,5));
結果：[zset-2, zset-1, zset-3]
3

zsize(String key)

獲取有序集合的成員數，內部調用的就是zCard方法

使用：System.out.println(zsize("zset1"));
結果：6

zCard(String key)

獲取有序集合的成員數

使用：System.out.println(zCard("zset1"));
結果：6

score(String key, Object value)

獲取指定成員的score值

使用：System.out.println(score("zset1","zset-1"));
結果：2.2

removeRange(String key, long start, long end)

移除指定索引位置的成員，其中有序集成員按分數值遞增(從小到大)順序排列

使用：System.out.println(range("zset2",0,-1));
        System.out.println(removeRange("zset2",1,2));
        System.out.println(range("zset2",0,-1));
結果：[zset-1, zset-2, zset-3, zset-4]
2
[zset-1, zset-4]

removeRangeByScore(String key, double min, double max)

根據指定的score值得范圍來移除成員

使用：//System.out.println(add("zset2","zset-1",1.1));
        //System.out.println(add("zset2","zset-2",1.2));
        //System.out.println(add("zset2","zset-3",2.3));
        //System.out.println(add("zset2","zset-4",6.6));
System.out.println(range("zset2",0,-1));
System.out.println(removeRangeByScore("zset2",2,3));
    System.out.println(range("zset2",0,-1));
結果：[zset-1, zset-2, zset-3,zset-4]
1
[zset-1, zset-2, zset-4]

unionAndStore(String key, String otherKey, String destKey)

計算給定的一個有序集的並集，並存儲在新的 destKey中，key相同的話會把score值相加

使用：System.out.println(add("zzset1","zset-1",1.0));
        System.out.println(add("zzset1","zset-2",2.0));
        System.out.println(add("zzset1","zset-3",3.0));
        System.out.println(add("zzset1","zset-4",6.0));

        System.out.println(add("zzset2","zset-1",1.0));
        System.out.println(add("zzset2","zset-2",2.0));
        System.out.println(add("zzset2","zset-3",3.0));
        System.out.println(add("zzset2","zset-4",6.0));
        System.out.println(add("zzset2","zset-5",7.0));
        System.out.println(unionAndStore("zzset1","zzset2","destZset11"));

        Set<ZSetOperations.TypedTuple<Object>> tuples = rangeWithScores("destZset11",0,-1);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
結果：value:zset-1score:2.0
value:zset-2score:4.0
value:zset-3score:6.0
value:zset-5score:7.0
value:zset-4score:12.0

unionAndStore(String key, Collection< String> otherKeys, String destKey)

計算給定的多個有序集的並集，並存儲在新的 destKey中

使用：//System.out.println(add("zzset1","zset-1",1.0));
        //System.out.println(add("zzset1","zset-2",2.0));
        //System.out.println(add("zzset1","zset-3",3.0));
        //System.out.println(add("zzset1","zset-4",6.0));
        //
        //System.out.println(add("zzset2","zset-1",1.0));
        //System.out.println(add("zzset2","zset-2",2.0));
        //System.out.println(add("zzset2","zset-3",3.0));
        //System.out.println(add("zzset2","zset-4",6.0));
        //System.out.println(add("zzset2","zset-5",7.0));

        System.out.println(add("zzset3","zset-1",1.0));
        System.out.println(add("zzset3","zset-2",2.0));
        System.out.println(add("zzset3","zset-3",3.0));
        System.out.println(add("zzset3","zset-4",6.0));
        System.out.println(add("zzset3","zset-5",7.0));

        List<String> stringList = new ArrayList<String>();
        stringList.add("zzset2");
        stringList.add("zzset3");
        System.out.println(unionAndStore("zzset1",stringList,"destZset22"));

        Set<ZSetOperations.TypedTuple<Object>> tuples = rangeWithScores("destZset22",0,-1);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
結果：value:zset-1score:3.0
value:zset-2score:6.0
value:zset-3score:9.0
value:zset-5score:14.0
value:zset-4score:18.0

intersectAndStore(String key, String otherKey, String destKey)

計算給定的一個或多個有序集的交集並將結果集存儲在新的有序集合 key 中

使用：System.out.println(intersectAndStore("zzset1","zzset2","destZset33"));

        Set<ZSetOperations.TypedTuple<Object>> tuples = rangeWithScores("destZset33",0,-1);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
結果：value:zset-1score:2.0
value:zset-2score:4.0
value:zset-3score:6.0
value:zset-4score:12.0

intersectAndStore(String key, Collection< String> otherKeys, String destKey)

計算給定的一個或多個有序集的交集並將結果集存儲在新的有序集合 key 中

使用：List<String> stringList = new ArrayList<String>();
        stringList.add("zzset2");
        stringList.add("zzset3");
        System.out.println(intersectAndStore("zzset1",stringList,"destZset44"));

        Set<ZSetOperations.TypedTuple<Object>> tuples = rangeWithScores("destZset44",0,-1);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
結果：value:zset-1score:3.0
value:zset-2score:6.0
value:zset-3score:9.0
value:zset-4score:18.0

zscan(String key, ScanOptions options)

遍歷zset

使用： Cursor<ZSetOperations.TypedTuple<Object>> cursor = zscan("zzset1", ScanOptions.NONE);
        while (cursor.hasNext()){
            ZSetOperations.TypedTuple<Object> item = cursor.next();
            System.out.println(item.getValue() + ":" + item.getScore());
        }
結果：zset-1:1.0
zset-2:2.0
zset-3:3.0
zset-4:6.0

key操作

expire(String key, long timeout, TimeUnit unit)

設置key的失效時間，timeout是時間參數，timeunit是時間單位

expireAt(String key, Date date)

設置key在一個時間點失效

getExpire(String key)

獲取key的存活時間

getExpire(String key, TimeUnit timeUnit)

獲取key的存活時間，加上了時間單位

sort(SortQuery< String> query)

對列表、集合、有序集合的key進行排序，SortQuery是封裝的對redis查詢的類，返回值類型是List< Object>

SortQuery<String> query = SortQueryBuilder.sort("hanlist")// 排序的key
                                    //.by("pattern")       key的正則過濾
                                    .noSort()            //不使用正則過濾key
                                    .get("2")            //在value里過濾正則，可以連續寫多個get
                                    .limit(0, 5)         //分頁，和mysql一樣
                                    .order(Order.DESC)   //正序or倒序
                                    .alphabetical(true)  //ALPHA修飾符用於對字符串進行排序，false的話只針對數字排序 
                                    .build();
redisTemplate.sort(query);

sort(SortQuery< String> query, BulkMapper<Object, Object> bulkMapper)

對列表、集合、有序集合的key進行排序，SortQuery是封裝的對redis查詢的類，BulkMapper可以把從redis里取出的元素轉化成我們想要的對象，返回值類型是List< T>

BulkMapper<UserToken, Object> hm = new BulkMapper<UserToken, Object>() {
            @Override
            public UserToken mapBulk(List<Object> bulk) {// 實現BulkMapper接口的方法，來把獲取到的排序的數據轉換為我們需要的返回類型
                Iterator<Object> iterator = bulk.iterator();  
                UserToken userToken = new UserToken();
                userToken.setUserId((String)iterator.next());
                userToken.setLastTime((long)iterator.next());
                userToken.setElementids((LinkedList<String>)iterator.next());
                return userToken;
            }
        }; 
redisTemplate.sort(query, hm);

delete(String key)

刪除指定key的緩存

delete(Collection< String> keys)

批量刪除指定的key的緩存

hasKey(String key)

判斷指定的key是否存在

rename(String oldKey, String newKey)

重新命名key

renameIfAbsent(String oldKey, String newKey)

重新命名key，如果key存在

keys(String pattern)

獲取匹配正則的所有key