jedis操作redis方法说明

0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046
0047
0048
0049
0050
0051
0052
0053
0054
0055
0056
0057
0058
0059
0060
0061
0062
0063
0064
0065
0066
0067
0068
0069
0070
0071
0072
0073
0074
0075
0076
0077
0078
0079
0080
0081
0082
0083
0084
0085
0086
0087
0088
0089
0090
0091
0092
0093
0094
0095
0096
0097
0098
0099
0100
0101
0102
0103
0104
0105
0106
0107
0108
0109
0110
0111
0112
0113
0114
0115
0116
0117
0118
0119
0120
0121
0122
0123
0124
0125
0126
0127
0128
0129
0130
0131
0132
0133
0134
0135
0136
0137
0138
0139
0140
0141
0142
0143
0144
0145
0146
0147
0148
0149
0150
0151
0152
0153
0154
0155
0156
0157
0158
0159
0160
0161
0162
0163
0164
0165
0166
0167
0168
0169
0170
0171
0172
0173
0174
0175
0176
0177
0178
0179
0180
0181
0182
0183
0184
0185
0186
0187
0188
0189
0190
0191
0192
0193
0194
0195
0196
0197
0198
0199
0200
0201
0202
0203
0204
0205
0206
0207
0208
0209
0210
0211
0212
0213
0214
0215
0216
0217
0218
0219
0220
0221
0222
0223
0224
0225
0226
0227
0228
0229
0230
0231
0232
0233
0234
0235
0236
0237
0238
0239
0240
0241
0242
0243
0244
0245
0246
0247
0248
0249
0250
0251
0252
0253
0254
0255
0256
0257
0258
0259
0260
0261
0262
0263
0264
0265
0266
0267
0268
0269
0270
0271
0272
0273
0274
0275
0276
0277
0278
0279
0280
0281
0282
0283
0284
0285
0286
0287
0288
0289
0290
0291
0292
0293
0294
0295
0296
0297
0298
0299
0300
0301
0302
0303
0304
0305
0306
0307
0308
0309
0310
0311
0312
0313
0314
0315
0316
0317
0318
0319
0320
0321
0322
0323
0324
0325
0326
0327
0328
0329
0330
0331
0332
0333
0334
0335
0336
0337
0338
0339
0340
0341
0342
0343
0344
0345
0346
0347
0348
0349
0350
0351
0352
0353
0354
0355
0356
0357
0358
0359
0360
0361
0362
0363
0364
0365
0366
0367
0368
0369
0370
0371
0372
0373
0374
0375
0376
0377
0378
0379
0380
0381
0382
0383
0384
0385
0386
0387
0388
0389
0390
0391
0392
0393
0394
0395
0396
0397
0398
0399
0400
0401
0402
0403
0404
0405
0406
0407
0408
0409
0410
0411
0412
0413
0414
0415
0416
0417
0418
0419
0420
0421
0422
0423
0424
0425
0426
0427
0428
0429
0430
0431
0432
0433
0434
0435
0436
0437
0438
0439
0440
0441
0442
0443
0444
0445
0446
0447
0448
0449
0450
0451
0452
0453
0454
0455
0456
0457
0458
0459
0460
0461
0462
0463
0464
0465
0466
0467
0468
0469
0470
0471
0472
0473
0474
0475
0476
0477
0478
0479
0480
0481
0482
0483
0484
0485
0486
0487
0488
0489
0490
0491
0492
0493
0494
0495
0496
0497
0498
0499
0500
0501
0502
0503
0504
0505
0506
0507
0508
0509
0510
0511
0512
0513
0514
0515
0516
0517
0518
0519
0520
0521
0522
0523
0524
0525
0526
0527
0528
0529
0530
0531
0532
0533
0534
0535
0536
0537
0538
0539
0540
0541
0542
0543
0544
0545
0546
0547
0548
0549
0550
0551
0552
0553
0554
0555
0556
0557
0558
0559
0560
0561
0562
0563
0564
0565
0566
0567
0568
0569
0570
0571
0572
0573
0574
0575
0576
0577
0578
0579
0580
0581
0582
0583
0584
0585
0586
0587
0588
0589
0590
0591
0592
0593
0594
0595
0596
0597
0598
0599
0600
0601
0602
0603
0604
0605
0606
0607
0608
0609
0610
0611
0612
0613
0614
0615
0616
0617
0618
0619
0620
0621
0622
0623
0624
0625
0626
0627
0628
0629
0630
0631
0632
0633
0634
0635
0636
0637
0638
0639
0640
0641
0642
0643
0644
0645
0646
0647
0648
0649
0650
0651
0652
0653
0654
0655
0656
0657
0658
0659
0660
0661
0662
0663
0664
0665
0666
0667
0668
0669
0670
0671
0672
0673
0674
0675
0676
0677
0678
0679
0680
0681
0682
0683
0684
0685
0686
0687
0688
0689
0690
0691
0692
0693
0694
0695
0696
0697
0698
0699
0700
0701
0702
0703
0704
0705
0706
0707
0708
0709
0710
0711
0712
0713
0714
0715
0716
0717
0718
0719
0720
0721
0722
0723
0724
0725
0726
0727
0728
0729
0730
0731
0732
0733
0734
0735
0736
0737
0738
0739
0740
0741
0742
0743
0744
0745
0746
0747
0748
0749
0750
0751
0752
0753
0754
0755
0756
0757
0758
0759
0760
0761
0762
0763
0764
0765
0766
0767
0768
0769
0770
0771
0772
0773
0774
0775
0776
0777
0778
0779
0780
0781
0782
0783
0784
0785
0786
0787
0788
0789
0790
0791
0792
0793
0794
0795
0796
0797
0798
0799
0800
0801
0802
0803
0804
0805
0806
0807
0808
0809
0810
0811
0812
0813
0814
0815
0816
0817
0818
0819
0820
0821
0822
0823
0824
0825
0826
0827
0828
0829
0830
0831
0832
0833
0834
0835
0836
0837
0838
0839
0840
0841
0842
0843
0844
0845
0846
0847
0848
0849
0850
0851
0852
0853
0854
0855
0856
0857
0858
0859
0860
0861
0862
0863
0864
0865
0866
0867
0868
0869
0870
0871
0872
0873
0874
0875
0876
0877
0878
0879
0880
0881
0882
0883
0884
0885
0886
0887
0888
0889
0890
0891
0892
0893
0894
0895
0896
0897
0898
0899
0900
0901
0902
0903
0904
0905
0906
0907
0908
0909
0910
0911
0912
0913
0914
0915
0916
0917
0918
0919
0920
0921
0922
0923
0924
0925
0926
0927
0928
0929
0930
0931
0932
0933
0934
0935
0936
0937
0938
0939
0940
0941
0942
0943
0944
0945
0946
0947
0948
0949
0950
0951
0952
0953
0954
0955
0956
0957
0958
0959
0960
0961
0962
0963
0964
0965
0966
0967
0968
0969
0970
0971
0972
0973
0974
0975
0976
0977
0978
0979
0980
0981
0982
0983
0984
0985
0986
0987
0988
0989
0990
0991
0992
0993
0994
0995
0996
0997
0998
0999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
import java.util.List;
import java.util.Map;
import java.util.Set;
 
/**
 * Common interface for sharded and non-sharded Jedis
 */public interface JedisCommands {
 
    /**
     * 存储数据到缓存中,若key已存在则覆盖 value的长度不能超过1073741824 bytes (1 GB)
     *
     * @param key
     * @param value
     * @return
     */    String set(String key, String value);
 
    /**
     * 存储数据到缓存中,并制定过期时间和当Key存在时是否覆盖。
     *
     * @param key
     * @param value
     * @param nxxx
     *            nxxx的值只能取NX或者XX,如果取NX,则只有当key不存在是才进行set,如果取XX,则只有当key已经存在时才进行set
     * @param expx
     *            expx的值只能取EX或者PX,代表数据过期时间的单位,EX代表秒,PX代表毫秒。
     * @param time
     *            过期时间,单位是expx所代表的单位。
     * @return
     */    String set(String key, String value, String nxxx, String expx, long time);
 
    /**
     * 从缓存中根据key取得其String类型的值,如果key不存在则返回null,如果key存在但value不是string类型的, 则返回一个error。这个方法只能从缓存中取得value为string类型的值。
     *
     * @param key
     * @return
     */    String get(String key);
 
    /**
     * 检查某个key是否在缓存中存在,如果存在返回true,否则返回false;需要注意的是,即使该key所对应的value是一个空字符串, 也依然会返回true。
     *
     * @param key
     * @return
     */    Boolean exists(String key);
 
    /**
     * 如果一个key设置了过期时间,则取消其过期时间,使其永久存在。
     *
     * @param key
     * @return 返回1或者0,1代表取消过期时间成功,0代表不成功(只有当key不存在时这种情况才会发生)
     */    Long persist(String key);
 
    /**
     * 返回某个key所存储的数据类型,返回的数据类型有可能是"none", "string", "list", "set", "zset", "hash". "none"代表key不存在。
     *
     * @param key
     * @return
     */    String type(String key);
 
    /**
     * 为key设置一个特定的过期时间,单位为秒。过期时间一到,redis将会从缓存中删除掉该key。 即使是有过期时间的key,redis也会在持久化时将其写到硬盘中,并把相对过期时间改为绝对的Unix过期时间。
     * 在一个有设置过期时间的key上重复设置过期时间将会覆盖原先设置的过期时间。
     *
     * @param key
     * @param seconds
     * @return 返回1表示成功设置过期时间,返回0表示key不存在。
     */    Long expire(String key, int seconds);
 
    /**
     * 机制同{@link expire}一样,只是时间单位改为毫秒。
     *
     * @param key
     * @param milliseconds
     * @return 返回值同 {@link expire}一样。
     */    Long pexpire(String key, long milliseconds);
 
    /**
     * 与{@link expire}不一样,expireAt设置的时间不是能存活多久,而是固定的UNIX时间(从1970年开始算起),单位为秒。
     *
     * @param key
     * @param unixTime
     * @return
     */    Long expireAt(String key, long unixTime);
 
    /**
     * 同{@link expireAt}机制相同,但单位为毫秒。
     *
     * @param key
     * @param millisecondsTimestamp
     * @return
     */    Long pexpireAt(String key, long millisecondsTimestamp);
 
    /**
     * 返回一个key还能活多久,单位为秒
     *
     * @param key
     * @return 如果该key本来并没有设置过期时间,则返回-1,如果该key不存在,则返回-2
     */    Long ttl(String key);
 
    /**
     * 设置或者清除指定key的value上的某个位置的比特位,如果该key原先不存在,则新创建一个key,其value将会自动分配内存, 直到可以放下指定位置的bit值。
     *
     * @param key
     * @param offset
     * @param value
     *            true代表1,false代表0
     * @return 返回原来位置的bit值是否是1,如果是1,则返回true,否则返回false。
     */    Boolean setbit(String key, long offset, boolean value);
 
    /**
     * 设置或者清除指定key的value上的某个位置的比特位,如果该key原先不存在,则新创建一个key,其value将会自动分配内存, 直到可以放下指定位置的bit值。
     *
     * @param key
     * @param offset
     * @param value
     *            只能是"1"或者"0"
     * @return 返回原来位置的bit值是否是1,如果是1,则返回true,否则返回false。
     */    Boolean setbit(String key, long offset, String value);
 
    /**
     * 取得偏移量为offset的bit值。
     *
     * @param key
     * @param offset
     * @return true代表1,false代表0
     */    Boolean getbit(String key, long offset);
 
    /**
     * 这个命令的作用是覆盖key对应的string的一部分,从指定的offset处开始,覆盖value的长度。 如果offset比当前key对应string还要长,
     * 那这个string后面就补0以达到offset。不存在的keys被认为是空字符串,所以这个命令可以确保key有一个足够大的字符串 能在offset处设置value。
     *
     * @param key
     * @param offset
     * @param value
     * @return 该命令修改后的字符串长度
     */    Long setrange(String key, long offset, String value);
 
    /**
     * 获得start - end之间的子字符串,若偏移量为负数,代表从末尾开始计算,例如-1代表倒数第一个,-2代表倒数第二个
     *
     * @param key
     * @param startOffset
     * @param endOffset
     * @return
     */    String getrange(String key, long startOffset, long endOffset);
 
    /**
     * 自动将key对应到value并且返回原来key对应的value。如果key存在但是对应的value不是字符串,就返回错误。
     *
     * @param key
     * @param value
     * @return
     */    String getSet(String key, String value);
 
    /**
     * 参考 {@link set(String key, String value, String nxxx, String expx, long time)}
     *
     * @param key
     * @param value
     * @return
     */    Long setnx(String key, String value);
 
    /**
     * 参考 {@link set(String key, String value, String nxxx, String expx, long time)}
     *
     * @param key
     * @param seconds
     * @param value
     * @return
     */    String setex(String key, int seconds, String value);
 
    /**
     * 将指定key的值减少某个值
     *
     * @param key
     * @param integer
     * @return 返回减少后的新值
     */    Long decrBy(String key, long integer);
 
    /**
     * 将指定Key的值减少1
     *
     * @param key
     * @return 返回减少后的新值
     */    Long decr(String key);
 
    /**
     * 将指定的key的值增加指定的值
     *
     * @param key
     * @param integer
     * @return 返回增加后的新值
     */    Long incrBy(String key, long integer);
 
    /**
     * 将指定的key的值增加指定的值(浮点数)
     *
     * @param key
     * @param value
     * @return 返回增加后的新值
     */    Double incrByFloat(String key, double value);
 
    /**
     * 将指定的key的值增加1
     *
     * @param key
     * @return 返回增加后的新值
     */    Long incr(String key);
 
    /**
     * 若key存在,将value追加到原有字符串的末尾。若key不存在,则创建一个新的空字符串。
     *
     * @param key
     * @param value
     * @return 返回字符串的总长度
     */    Long append(String key, String value);
 
    /**
     * 返回start - end 之间的子字符串(start 和 end处的字符也包括在内)
     *
     * @param key
     * @param start
     * @param end
     * @return 返回子字符串
     */    String substr(String key, int start, int end);
 
    /**
     * 设置hash表里field字段的值为value。如果key不存在,则创建一个新的hash表
     *
     * @param key
     * @param field
     * @param value
     * @return 如果该字段已经存在,那么将会更新该字段的值,返回0.如果字段不存在,则新创建一个并且返回1.
     */    Long hset(String key, String field, String value);
 
    /**
     * 如果该key对应的值是一个Hash表,则返回对应字段的值。 如果不存在该字段,或者key不存在,则返回一个"nil"值。
     *
     * @param key
     * @param field
     * @return
     */    String hget(String key, String field);
 
    /**
     * 当字段不存在时,才进行set。
     *
     * @param key
     * @param field
     * @param value
     * @return 如果该字段已经存在,则返回0.若字段不存在,则创建后set,返回1.
     */    Long hsetnx(String key, String field, String value);
 
    /**
     * 设置多个字段和值,如果字段存在,则覆盖。
     *
     * @param key
     * @param hash
     * @return 设置成功返回OK,设置不成功则返回EXCEPTION
     */    String hmset(String key, Map<String, String> hash);
 
    /**
     * 在hash中获取多个字段的值,若字段不存在,则其值为nil。
     *
     * @param key
     * @param fields
     * @return 按顺序返回多个字段的值。
     */    List<String> hmget(String key, String... fields);
 
    /**
     * 对hash中指定字段的值增加指定的值
     *
     * @param key
     * @param field
     * @param value
     * @return 返回增加后的新值
     */    Long hincrBy(String key, String field, long value);
 
    /**
     * 判断hash中指定字段是否存在
     *
     * @param key
     * @param field
     * @return 若存在返回1,若不存在返回0
     */    Boolean hexists(String key, String field);
 
    /**
     * 删除hash中指定字段
     *
     * @param key
     * @param field
     * @return 删除成功返回1, 删除不成功返回0
     */    Long hdel(String key, String... field);
 
    /**
     * 返回 key 指定的哈希集包含的字段的数量
     *
     * @param key
     * @return 哈希集中字段的数量,当 key 指定的哈希集不存在时返回 0
     */    Long hlen(String key);
 
    /**
     * 返回 key 指定的哈希集中所有字段的名字。
     *
     * @param key
     * @return 哈希集中的字段列表,当 key 指定的哈希集不存在时返回空列表。
     */    Set<String> hkeys(String key);
 
    /**
     * 返回 key 指定的哈希集中所有字段的值。
     *
     * @param key
     * @return 哈希集中的值的列表,当 key 指定的哈希集不存在时返回空列表。
     */    List<String> hvals(String key);
 
    /**
     * 返回 key 指定的哈希集中所有的字段和值
     *
     * @param key
     * @return 返回 key 指定的哈希集中所有的字段和值,若key不存在返回空map。
     */    Map<String, String> hgetAll(String key);
 
    /**
     * 向存于 key 的列表的尾部插入所有指定的值。如果 key 不存在,那么会创建一个空的列表然后再进行 push 操作。 当 key 保存的不是一个列表,那么会返回一个错误。
     * 可以使用一个命令把多个元素打入队列,只需要在命令后面指定多个参数。元素是从左到右一个接一个从列表尾部插入。 比如命令 RPUSH mylist a b c 会返回一个列表,其第一个元素是 a ,第二个元素是 b ,第三个元素是
     * c。
     *
     * @param key
     * @param string
     * @return 在 push 操作后的列表长度。
     */    Long rpush(String key, String... string);
 
    /**
     * 将所有指定的值插入到存于 key 的列表的头部。如果 key 不存在,那么在进行 push 操作前会创建一个空列表。 如果 key 对应的值不是一个 list 的话,那么会返回一个错误。 可以使用一个命令把多个元素 push
     * 进入列表,只需在命令末尾加上多个指定的参数。元素是从最左端的到最右端的、一个接一个被插入到 list 的头部。 所以对于这个命令例子 LPUSH mylist a b c,返回的列表是 c 为第一个元素, b 为第二个元素,
     * a 为第三个元素。
     *
     * @param key
     * @param string
     * @return 在 push 操作后的列表长度。
     */    Long lpush(String key, String... string);
 
    /**
     * 返回存储在 key 里的list的长度。 如果 key 不存在,那么就被看作是空list,并且返回长度为 0。 当存储在 key 里的值不是一个list的话,会返回error。
     *
     * @param key
     * @return key对应的list的长度。
     */    Long llen(String key);
 
    /**
     * 返回存储在 key 的列表里指定范围内的元素。 start 和 end 偏移量都是基于0的下标,即list的第一个元素下标是0(list的表头),第二个元素下标是1,以此类推。
     * 偏移量也可以是负数,表示偏移量是从list尾部开始计数。 例如, -1 表示列表的最后一个元素,-2 是倒数第二个,以此类推。
     *
     * @param key
     * @param start
     * @param end
     * @return 指定范围里的列表元素。
     */    List<String> lrange(String key, long start, long end);
 
    /**
     * 修剪(trim)一个已存在的 list,这样 list 就会只包含指定范围的指定元素。start 和 stop 都是由0开始计数的, 这里的 0 是列表里的第一个元素(表头),1 是第二个元素,以此类推。
     *
     * @param key
     * @param start
     * @param end
     * @return
     */    String ltrim(String key, long start, long end);
 
    /**
     * 返回列表里的元素的索引 index 存储在 key 里面。 下标是从0开始索引的,所以 0 是表示第一个元素, 1 表示第二个元素,并以此类推。 负数索引用于指定从列表尾部开始索引的元素。在这种方法下,-1
     * 表示最后一个元素,-2 表示倒数第二个元素,并以此往前推。 当 key 位置的值不是一个列表的时候,会返回一个error。
     *
     * @param key
     * @param index
     * @return 请求的对应元素,或者当 index 超过范围的时候返回 nil。
     */    String lindex(String key, long index);
 
    /**
     * 设置 index 位置的list元素的值为 value。 当index超出范围时会返回一个error。
     *
     * @param key
     * @param index
     * @param value
     * @return 状态恢复
     */    String lset(String key, long index, String value);
 
    /**
     * 从存于 key 的列表里移除前 count 次出现的值为 value 的元素。 这个 count 参数通过下面几种方式影响这个操作: count > 0: 从头往尾移除值为 value 的元素。 count < 0:
     * 从尾往头移除值为 value 的元素。 count = 0: 移除所有值为 value 的元素。 比如, LREM list -2 "hello" 会从存于 list 的列表里移除最后两个出现的 "hello"。
     * 需要注意的是,如果list里没有存在key就会被当作空list处理,所以当 key 不存在的时候,这个命令会返回 0。
     *
     * @param key
     * @param count
     * @param value
     * @return 返回删除的个数
     */    Long lrem(String key, long count, String value);
 
    /**
     * 移除并且返回 key 对应的 list 的第一个元素。
     *
     * @param key
     * @return 返回第一个元素的值,或者当 key 不存在时返回 nil。
     */    String lpop(String key);
 
    /**
     * 移除并返回存于 key 的 list 的最后一个元素。
     *
     * @param key
     * @return 最后一个元素的值,或者当 key 不存在的时候返回 nil。
     */    String rpop(String key);
 
    /**
     * 添加一个或多个指定的member元素到集合的 key中.指定的一个或者多个元素member 如果已经在集合key中存在则忽略.如果集合key 不存在,则新建集合key,并添加member元素到集合key中. 如果key
     * 的类型不是集合则返回错误.
     *
     * @param key
     * @param member
     * @return 返回新成功添加到集合里元素的数量,不包括已经存在于集合中的元素.
     */    Long sadd(String key, String... member);
 
    /**
     * 返回key集合所有的元素. 该命令的作用与使用一个参数的SINTER 命令作用相同.
     *
     * @param key
     * @return 集合中的所有元素.
     */    Set<String> smembers(String key);
 
    /**
     * 在key集合中移除指定的元素. 如果指定的元素不是key集合中的元素则忽略 如果key集合不存在则被视为一个空的集合,该命令返回0. 如果key的类型不是一个集合,则返回错误.
     *
     * @param key
     * @param member
     * @return 从集合中移除元素的个数,不包括不存在的成员.
     */    Long srem(String key, String... member);
 
    /**
     * 移除并返回一个集合中的随机元素 该命令与 SRANDMEMBER相似,不同的是srandmember命令返回一个随机元素但是不移除.
     *
     * @param key
     * @return 被移除的元素, 当key不存在的时候返回 nil .
     */    String spop(String key);
 
    /**
     * 移除并返回多个集合中的随机元素
     *
     * @param key
     * @param count
     * @return 被移除的元素, 当key不存在的时候值为 nil .
     */    Set<String> spop(String key, long count);
 
    /**
     * 返回集合存储的key的基数 (集合元素的数量).
     *
     * @param key
     * @return 集合的基数(元素的数量),如果key不存在,则返回 0.
     */    Long scard(String key);
 
    /**
     * 返回成员 member 是否是存储的集合 key的成员.
     *
     * @param key
     * @param member
     * @return 如果member元素是集合key的成员,则返回1.如果member元素不是key的成员,或者集合key不存在,则返回0
     */    Boolean sismember(String key, String member);
 
    /**
     * 仅提供key参数,那么随机返回key集合中的一个元素.该命令作用类似于SPOP命令, 不同的是SPOP命令会将被选择的随机元素从集合中移除, 而SRANDMEMBER仅仅是返回该随记元素,而不做任何操作.
     *
     * @param key
     * @return 返回随机的元素,如果key不存在则返回nil
     */    String srandmember(String key);
 
    /**
     * 如果count是整数且小于元素的个数,返回含有 count 个不同的元素的数组,如果count是个整数且大于集合中元素的个数时,仅返回整个集合的所有元素 ,当count是负数,则会返回一个包含count的绝对值的个数元素的数组
     * ,如果count的绝对值大于元素的个数,则返回的结果集里会出现一个元素出现多次的情况.
     *
     * @param key
     * @param count
     * @return 返回一个随机的元素数组,如果key不存在则返回一个空的数组.
     */    List<String> srandmember(String key, int count);
 
    /**
     * 返回key的string类型value的长度。如果key对应的非string类型,就返回错误。
     *
     * @param key
     * @return key对应的字符串value的长度,或者0(key不存在)
     */    Long strlen(String key);
 
    /**
     * 该命令添加指定的成员到key对应的有序集合中,每个成员都有一个分数。你可以指定多个分数/成员组合。如果一个指定的成员已经在对应的有序集合中了, 那么其分数就会被更新成最新的
     * ,并且该成员会重新调整到正确的位置,以确保集合有序。如果key不存在,就会创建一个含有这些成员的有序集合,就好像往一个空的集合中添加一样 。如果key存在,但是它并不是一个有序集合,那么就返回一个错误。
     * 分数的值必须是一个表示数字的字符串,并且可以是double类型的浮点数。
     *
     * @param key
     * @param score
     * @param member
     * @return 返回添加到有序集合中元素的个数,不包括那种已经存在只是更新分数的元素。
     */    Long zadd(String key, double score, String member);
 
    /**
     * 该命令添加指定的成员到key对应的有序集合中,每个成员都有一个分数。你可以指定多个分数/成员组合。如果一个指定的成员已经在对应的有序集合中了, 那么其分数就会被更新成最新的
     * ,并且该成员会重新调整到正确的位置,以确保集合有序。如果key不存在,就会创建一个含有这些成员的有序集合,就好像往一个空的集合中添加一样 。如果key存在,但是它并不是一个有序集合,那么就返回一个错误。
     * 分数的值必须是一个表示数字的字符串,并且可以是double类型的浮点数。
     *
     * @param key
     * @param scoreMembers
     * @return 返回添加到有序集合中元素的个数,不包括那种已经存在只是更新分数的元素。
     */    Long zadd(String key, Map<String, Double> scoreMembers);
 
    /**
     * 返回有序集key中,指定区间内的成员。其中成员按score值递增(从小到大)来排序。具有相同score值的成员按字典序来排列。
     * 如果你需要成员按score值递减(score相等时按字典序递减)来排列,请使用ZREVRANGE命令。 下标参数start和stop都以0为底,也就是说,以0表示有序集第一个成员,以1表示有序集第二个成员,以此类推。
     * 你也可以使用负数下标,以-1表示最后一个成员,-2表示倒数第二个成员,以此类推。 超出范围的下标并不会引起错误。如果start的值比有序集的最大下标还要大,或是start >
     * stop时,ZRANGE命令只是简单地返回一个空列表。 另一方面,假如stop参数的值比有序集的最大下标还要大,那么Redis将stop当作最大下标来处理。
     *
     * @param key
     * @param start
     * @param end
     * @return 指定范围的元素列表
     */    Set<String> zrange(String key, long start, long end);
 
    /**
     * 从集合中删除指定member元素,当key存在,但是其不是有序集合类型,就返回一个错误。
     *
     * @param key
     * @param member
     * @return 返回的是从有序集合中删除的成员个数,不包括不存在的成员。
     */    Long zrem(String key, String... member);
 
    /**
     * 为有序集key的成员member的score值加上增量increment。如果key中不存在member,就在key中添加一个member,
     * score是increment(就好像它之前的score是0.0)。如果key不存在,就创建一个只含有指定member成员的有序集合。 当key不是有序集类型时,返回一个错误。
     * score值必须整数值或双精度浮点数。也有可能给一个负数来减少score的值。
     *
     * @param key
     * @param score
     * @param member
     * @return member成员的新score值.
     */    Double zincrby(String key, double score, String member);
 
    /**
     * 返回有序集key中成员member的排名。其中有序集成员按score值递增(从小到大)顺序排列。排名以0为底,也就是说, score值最小的成员排名为0。
     * 使用ZREVRANK命令可以获得成员按score值递减(从大到小)排列的排名。
     *
     * @param key
     * @param member
     * @return 如果member是有序集key的成员,返回member的排名的整数。 如果member不是有序集key的成员,返回 nil。
     */    Long zrank(String key, String member);
 
    /**
     * 返回有序集key中成员member的排名,其中有序集成员按score值从大到小排列。排名以0为底,也就是说,score值最大的成员排名为0。 使用ZRANK命令可以获得成员按score值递增(从小到大)排列的排名。
     *
     * @param key
     * @param member
     * @return 如果member是有序集key的成员,返回member的排名。整型数字。 如果member不是有序集key的成员,返回Bulk reply: nil.
     */    Long zrevrank(String key, String member);
 
    /**
     * 返回有序集key中,指定区间内的成员。其中成员的位置按score值递减(从大到小)来排列。具有相同score值的成员按字典序的反序排列。
     * 除了成员按score值递减的次序排列这一点外,ZREVRANGE命令的其他方面和ZRANGE命令一样。
     *
     * @param key
     * @param start
     * @param end
     * @return 指定范围的元素列表(可选是否含有分数)。
     */    Set<String> zrevrange(String key, long start, long end);
 
    /**
     * 返回有序集key中,指定区间内的成员。其中成员按score值递增(从小到大)来排序。具有相同score值的成员按字典序来排列。
     * 如果你需要成员按score值递减(score相等时按字典序递减)来排列,请使用ZREVRANGE命令。 下标参数start和stop都以0为底,也就是说,以0表示有序集第一个成员,以1表示有序集第二个成员,以此类推。
     * 你也可以使用负数下标,以-1表示最后一个成员,-2表示倒数第二个成员,以此类推。 超出范围的下标并不会引起错误。如果start的值比有序集的最大下标还要大,或是start >
     * stop时,ZRANGE命令只是简单地返回一个空列表。 另一方面,假如stop参数的值比有序集的最大下标还要大,那么Redis将stop当作最大下标来处理。
     * 使用WITHSCORES选项,来让成员和它的score值一并返回,返回列表以value1,score1, ...,
     * valueN,scoreN的格式表示,而不是value1,...,valueN。客户端库可能会返回一些更复杂的数据类型,比如数组、元组等。
     *
     * @param key
     * @param start
     * @param end
     * @return 指定范围的元素列表(以元组集合的形式)。
     */    Set<Tuple> zrangeWithScores(String key, long start, long end);
 
    /**
     * 返回有序集key中,指定区间内的成员。其中成员的位置按score值递减(从大到小)来排列。具有相同score值的成员按字典序的反序排列。
     * 除了成员按score值递减的次序排列这一点外,ZREVRANGE命令的其他方面和ZRANGE命令一样。
     *
     * @param key
     * @param start
     * @param end
     * @return 指定范围的元素列表(可选是否含有分数)。
     */    Set<Tuple> zrevrangeWithScores(String key, long start, long end);
 
    /**
     * 返回key的有序集元素个数。
     *
     * @param key
     * @return key存在的时候,返回有序集的元素个数,否则返回0。
     */    Long zcard(String key);
 
    /**
     * 返回有序集key中,成员member的score值。 如果member元素不是有序集key的成员,或key不存在,返回nil。
     *
     * @param key
     * @param member
     * @return member成员的score值(double型浮点数)
     */    Double zscore(String key, String member);
 
    /**
     * 对一个集合或者一个列表排序 对集合,有序集合,或者列表的value进行排序。默认情况下排序只对数字排序,双精度浮点数。
     *
     * @see #sort(String, String)
     * @see #sort(String, SortingParams)
     * @see #sort(String, SortingParams, String)
     * @param key
     * @return 假设集合或列表包含的是数字元素,那么返回的将会是从小到大排列的一个列表。
     */    List<String> sort(String key);
 
    /**
     * 根据指定参数来对列表或集合进行排序.
     * <p>
     * <b>examples:</b>
     * <p>
     * 一下是一些例子列表或者key-value:
     *
     * <pre>
     * x = [1, 2, 3]
     * y = [a, b, c]
     *
     * k1 = z
     * k2 = y
     * k3 = x
     *
     * w1 = 9
     * w2 = 8
     * w3 = 7
     * </pre>
     *
     * 排序:
     *
     * <pre>
     * sort(x) or sort(x, sp.asc())
     * -> [1, 2, 3]
     *
     * sort(x, sp.desc())
     * -> [3, 2, 1]
     *
     * sort(y)
     * -> [c, a, b]
     *
     * sort(y, sp.alpha())
     * -> [a, b, c]
     *
     * sort(y, sp.alpha().desc())
     * -> [c, b, a]
     * </pre>
     *
     * Limit (e.g. for Pagination):
     *
     * <pre>
     * sort(x, sp.limit(0, 2))
     * -> [1, 2]
     *
     * sort(y, sp.alpha().desc().limit(1, 2))
     * -> [b, a]
     * </pre>
     *
     * 使用外部键来排序:
     *
     * <pre>
     * sort(x, sb.by(w*))
     * -> [3, 2, 1]
     *
     * sort(x, sb.by(w*).desc())
     * -> [1, 2, 3]
     * </pre>
     *
     * Getting external keys:
     *
     * <pre>
     * sort(x, sp.by(w*).get(k*))
     * -> [x, y, z]
     *
     * sort(x, sp.by(w*).get(#).get(k*))
     * -> [3, x, 2, y, 1, z]
     * </pre>
     *
     * @see #sort(String)
     * @see #sort(String, SortingParams, String)
     * @param key
     * @param sortingParameters
     * @return a list of sorted elements.
     */    List<String> sort(String key, SortingParams sortingParameters);
 
    /**
     * 返回有序集key中,score值在min和max之间(默认包括score值等于min或max)的成员。
     *
     * @param key
     * @param min
     * @param max
     * @return 指定分数范围的元素个数。
     */    Long zcount(String key, double min, double max);
 
    /**
     * 返回有序集key中,score值在min和max之间(默认包括score值等于min或max)的成员。
     *
     * @param key
     * @param min
     * @param max
     * @return 指定分数范围的元素个数。
     */    Long zcount(String key, String min, String max);
 
    /**
     * 返回key的有序集合中的分数在min和max之间的所有元素(包括分数等于max或者min的元素)。元素被认为是从低分到高分排序的。 具有相同分数的元素按字典序排列
     *
     * @param key
     * @param min
     * @param max
     * @return 指定分数范围的元素列表
     */    Set<String> zrangeByScore(String key, double min, double max);
 
    /**
     * 返回key的有序集合中的分数在min和max之间的所有元素(包括分数等于max或者min的元素)。元素被认为是从低分到高分排序的。 具有相同分数的元素按字典序排列
     *
     * @param key
     * @param min
     * @param max
     * @return 指定分数范围的元素列表
     */    Set<String> zrangeByScore(String key, String min, String max);
 
    /**
     * 返回key的有序集合中的分数在min和max之间的所有元素(包括分数等于max或者min的元素)。元素被认为是从低分到高分排序的。 具有相同分数的元素按字典序排列, 指定返回结果的数量及区间。
     *
     * @param key
     * @param min
     * @param max
     * @param offset
     * @param count
     * @return 指定分数范围的元素列表
     */    Set<String> zrangeByScore(String key, double min, double max, int offset, int count);
 
    /**
     * 返回key的有序集合中的分数在min和max之间的所有元素(包括分数等于max或者min的元素)。元素被认为是从低分到高分排序的。 具有相同分数的元素按字典序排列, 指定返回结果的数量及区间。
     *
     * @param key
     * @param min
     * @param max
     * @param offset
     * @param count
     * @return 指定分数范围的元素列表
     */    Set<String> zrangeByScore(String key, String min, String max, int offset, int count);
 
    /**
     * 返回key的有序集合中的分数在min和max之间的所有元素(包括分数等于max或者min的元素)。元素被认为是从低分到高分排序的。 具有相同分数的元素按字典序排列。返回元素和其分数,而不只是元素。
     *
     * @param key
     * @param min
     * @param max
     * @return
     */    Set<Tuple> zrangeByScoreWithScores(String key, double min, double max);
 
    /**
     * 返回key的有序集合中的分数在min和max之间的所有元素(包括分数等于max或者min的元素)。元素被认为是从低分到高分排序的。 具有相同分数的元素按字典序排列, 指定返回结果的数量及区间。 返回元素和其分数,而不只是元素。
     *
     * @param key
     * @param min
     * @param max
     * @param offset
     * @param count
     * @return
     */    Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count);
 
    /**
     * 返回key的有序集合中的分数在min和max之间的所有元素(包括分数等于max或者min的元素)。元素被认为是从低分到高分排序的。 具有相同分数的元素按字典序排列。返回元素和其分数,而不只是元素。
     *
     * @param key
     * @param min
     * @param max
     * @return
     */    Set<Tuple> zrangeByScoreWithScores(String key, String min, String max);
 
    /**
     * 返回key的有序集合中的分数在min和max之间的所有元素(包括分数等于max或者min的元素)。元素被认为是从低分到高分排序的。 具有相同分数的元素按字典序排列, 指定返回结果的数量及区间。 返回元素和其分数,而不只是元素。
     *
     * @param key
     * @param min
     * @param max
     * @param offset
     * @param count
     * @return
     */    Set<Tuple> zrangeByScoreWithScores(String key, String min, String max, int offset, int count);
 
    /**
     * 机制与zrangeByScore一样,只是返回结果为降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @return
     */    Set<String> zrevrangeByScore(String key, double max, double min);
 
    /**
     * 机制与zrangeByScore一样,只是返回结果为降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @return
     */    Set<String> zrevrangeByScore(String key, String max, String min);
 
    /**
     * 机制与zrangeByScore一样,只是返回结果为降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @param offset
     * @param count
     * @return
     */    Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count);
 
    /**
     * 机制与zrangeByScoreWithScores一样,只是返回结果为降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @return
     */    Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min);
 
    /**
     * 机制与zrangeByScore一样,只是返回结果为降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @param offset
     * @param count
     * @return
     */    Set<String> zrevrangeByScore(String key, String max, String min, int offset, int count);
 
    /**
     * 机制与zrangeByScoreWithScores一样,只是返回结果为降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @return
     */    Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min);
 
    /**
     * 机制与zrangeByScoreWithScores一样,只是返回结果为降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @param offset
     * @param count
     * @return
     */    Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count);
 
    /**
     * 机制与zrangeByScoreWithScores一样,只是返回结果为降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @param offset
     * @param count
     * @return
     */    Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count);
 
    /**
     * 移除有序集key中,指定排名(rank)区间内的所有成员。下标参数start和stop都以0为底,0处是分数最小的那个元素。这些索引也可是负数,
     * 表示位移从最高分处开始数。例如,-1是分数最高的元素,-2是分数第二高的,依次类推。
     *
     * @param key
     * @param start
     * @param end
     * @return 被移除成员的数量。
     */    Long zremrangeByRank(String key, long start, long end);
 
    /**
     * 移除有序集key中,所有score值介于min和max之间(包括等于min或max)的成员。 自版本2.1.6开始,score值等于min或max的成员也可以不包括在内,语法请参见ZRANGEBYSCORE命令。
     *
     * @param key
     * @param start
     * @param end
     * @return 删除的元素的个数
     */    Long zremrangeByScore(String key, double start, double end);
 
    /**
     * 移除有序集key中,所有score值介于min和max之间(包括等于min或max)的成员。 自版本2.1.6开始,score值等于min或max的成员也可以不包括在内,语法请参见ZRANGEBYSCORE命令。
     *
     * @param key
     * @param start
     * @param end
     * @return 删除的元素的个数
     */    Long zremrangeByScore(String key, String start, String end);
 
    /**
     * 当插入到有序集合中的元素都具有相同的分数时,这个命令可以返回min和max指定范围内的元素的数量。
     *
     * @param key
     * @param min
     * @param max
     * @return
     */    Long zlexcount(final String key, final String min, final String max);
 
    /**
     * 把 value 插入存于 key 的列表中在基准值 pivot 的前面或后面。 当 key 不存在时,这个list会被看作是空list,任何操作都不会发生。 当 key 存在,但保存的不是一个list的时候,会返回error。
     *
     * @param key
     * @param where
     * @param pivot
     *            前或后
     * @param value
     * @return 在 insert 操作后的 list 长度。
     */    Long linsert(String key, Client.LIST_POSITION where, String pivot, String value);
 
    /**
     * 只有当 key 已经存在并且存着一个 list 的时候,在这个 key 下面的 list 的头部插入 value。 与 LPUSH 相反,当 key 不存在的时候不会进行任何操作。
     *
     * @param key
     * @param string
     * @return 在 push 操作后的 list 长度。
     */    Long lpushx(String key, String... string);
 
    /**
     * 将值 value 插入到列表 key 的表尾, 当且仅当 key 存在并且是一个列表。 和 RPUSH 命令相反, 当 key 不存在时,RPUSHX 命令什么也不做。
     *
     * @param key
     * @param string
     * @return 在Push操作后List的长度
     */    Long rpushx(String key, String... string);
 
    /**
     * @deprecated unusable command, this will be removed in 3.0.0.
     */    @Deprecated
    List<String> blpop(String arg);
 
    /**
     * BLPOP 是阻塞式列表的弹出原语。 它是命令 LPOP 的阻塞版本,这是因为当给定列表内没有任何元素可供弹出的时候, 连接将被 BLPOP 命令阻塞。 当给定多个 key 参数时,按参数 key
     * 的先后顺序依次检查各个列表,弹出第一个非空列表的头元素。 {@link http ://www.redis.cn/commands/blpop.html}
     *
     * @param timeout
     * @param key
     * @return
     */    List<String> blpop(int timeout, String key);
 
    /**
     * @deprecated unusable command, this will be removed in 3.0.0.
     */    @Deprecated
    List<String> brpop(String arg);
 
    /**
     * BRPOP 是一个阻塞的列表弹出原语。 它是 RPOP 的阻塞版本,因为这个命令会在给定list无法弹出任何元素的时候阻塞连接。 该命令会按照给出的 key 顺序查看 list,并在找到的第一个非空 list
     * 的尾部弹出一个元素。 请在 BLPOP 文档 中查看该命令的准确语义,因为 BRPOP 和 BLPOP 基本是完全一样的,除了它们一个是从尾部弹出元素,而另一个是从头部弹出元素。 {@link http
     * ://www.redis.cn/commands/brpop.html}
     *
     * @param timeout
     * @param key
     * @return
     */    List<String> brpop(int timeout, String key);
 
    /**
     * 删除一个Key,如果删除的key不存在,则直接忽略。
     *
     * @param key
     * @return 被删除的keys的数量
     */    Long del(String key);
 
    /**
     * 回显
     *
     * @param string
     * @return 回显输入的字符串
     */    String echo(String string);
 
    /**
     * 将当前数据库的 key 移动到给定的数据库 db 当中。 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ,或者 key 不存在于当前数据库,那么 MOVE 没有任何效果。
     * 因此,也可以利用这一特性,将 MOVE 当作锁(locking)原语(primitive)。
     *
     * @param key
     * @param dbIndex
     * @return 移动成功返回 1 失败则返回 0
     */    Long move(String key, int dbIndex);
 
    /**
     * 统计字符串的字节数
     *
     * @param key
     * @return 字节数
     */    Long bitcount(final String key);
 
    /**
     * 统计字符串指定起始位置的字节数
     *
     * @param key
     * @param start
     * @param end
     * @return
     */    Long bitcount(final String key, long start, long end);
 
    /**
     * 迭代hash里面的元素
     *
     * @param key
     * @param cursor
     * @return
     */    ScanResult<Map.Entry<String, String>> hscan(final String key, final String cursor);
 
    /**
     * 迭代set里面的元素
     *
     * @param key
     * @param cursor
     * @return
     */    ScanResult<String> sscan(final String key, final String cursor);
 
    /**
     * 迭代zset里面的元素
     *
     * @param key
     * @param cursor
     * @return
     */    ScanResult<Tuple> zscan(final String key, final String cursor);
 
}

发表评论

欢迎阅读『jedis操作redis方法说明|Java、开发语言、框架算法|Nick Tan-梓潼Blog』