Redis学习笔记(2)-String

package cn.com;

import java.util.List;

import redis.clients.jedis.Jedis;

public class Redis_String {

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

	public static void main(String[] args) throws InterruptedException {
		incr_deincr();
	}

	/**
	 * SET 设置值
	 * GET 获取值
	 * */
	public static void set_get(){
		redis.set("name", "wangzhang");
		redis.set("id", "123456");
		redis.set("address", "guangzhou");

		String name=redis.get("name");
		String address=redis.get("address");
		System.out.println("name:"+name);
		System.out.println("address:"+address);
		 redis.flushDB();//清楚数据
	}

	/**
	 * MSET key value
	 * 同时设置一个或多个key-value对,下面是三对分别是haha-111,xixi-222,wawa-333。
	 * MGET key value
	 * 获取多个key的值 传递的事key 的字符串数组,字符串素组不存在的key则返回null
	 * */
	public static void mset_mget(){
		redis.mset("haha", "111", "xixi", "222","wawa","333");
		//MGET key value 获取多个key的值 传递的事key 的字符串数组,字符串素组不纯在则返回null
		List<String> mgetList=redis.mget(new String[]{"haha","xixi1"});
		for(String mget:mgetList){
			System.out.println("mget:"+mget);
		}
		 redis.flushDB();//清楚数据
	}

	/**
	 * APPEND key value
	 * 追加字符串到对应的key上：APPEND myphone "nokia"。对不存在的 key 进行 APPEND ，等同于 SET myphone "nokia"
	 * 返回的是字符串最后结果的长度.
	 * */
	public static void append_exists(){
		redis.set("name", "liliang");
		redis.set("id", "123456");
		redis.set("address", "guangzhou");

		boolean e_name1=redis.exists("name");
		boolean e_name2=redis.exists("name1");
		System.out.println("e_name1:"+e_name1);
		System.out.println("e_name2:"+e_name2);

		//key存在的情况
		Long size=redis.append("name", "-lalala");
		System.out.println("append 之后的长度:"+size);
		String name=redis.get("name");
		System.out.println("name:"+name);

		//key 不存在
		Long user_size=redis.append("username", "-lalala");
		System.out.println("key 不存在 append 之后的长度:"+user_size);
		String username=redis.get("username");
		System.out.println("username"+username);
		redis.flushDB();//清除数据
	}

	/**
	 * SETBIT key offset value
	 * 设置key的指定位移上的值(0/1)
	 * 当 key 不存在时，自动生成一个新的字符串值。
	 * 字符串会进行伸展(grown)以确保它可以将 value 保存在指定的偏移量上。当字符串值进行伸展时，空白位置以 0 填充;
	 * 也就是说 设置了第一个为1，然后直接设置第100位位1其他2-99 未知默认用0 填充。
	 * offset 参数必须大于或等于 0 ，小于 2^32 (bit 映射被限制在 512 MB 之内)。
	 * 下面例子设置 在0,2,4 上面为1； 1,3,5 上面为 0;
	 * 应用场景:记得一周登陆过的用户；只要用户登陆过就设置id对应的位为 1.那么一个用户是否登陆用一个位就可以代替。
	 * */
	public static void setbit_getbit(){

		redis.setbit("login", 0, true);redis.setbit("login", 2, true);redis.setbit("login", 100, true);
		redis.setbit("login", 1, false);redis.setbit("login", 3, false);redis.setbit("login", 3, false);
		System.out.println("获取key=login 上 第 0位的值:"+redis.getbit("login", 0));
		System.out.println("获取key=login 上 第 1位的值:"+redis.getbit("login", 1));
		redis.flushDB();//清除数据
	}

	/**
	 * BITCOUNT key [start] [end]
	 * 计算给定字符串中，被设置为 1 的比特位的数量,可不指定具体的位移默认全部。
	 * start 和 end 参数的设置和 GETRANGE 命令类似,
	 * 都可以使用负数值：比如 -1 表示最后一个位，而 -2 表示倒数第二个位，以此类推。
	 * */
	public static void bitcount(){

		redis.setbit("login", 0, true);redis.setbit("login", 2, true);redis.setbit("login", 100, true);
		redis.setbit("login", 1, false);redis.setbit("login", 3, false);redis.setbit("login", 3, false);
		Long count=redis.bitcount("login");
		System.out.println("count:"+count);

		System.out.println("================");

		Long count1=redis.bitcount("login", 0, 3);
		System.out.println("count1:"+count1);
	}

	/**
	 * SETEX key seconds value
	 * 设置key：foo 的值 value:haha ,如果key 存在覆盖值，不存在等同于set
	 * 同时设置5秒后过期，并将key的生存时间设为seconds(以秒为单位)。
	 * 实现：先暂停一秒 通过ttl 查看剩余时间(单位以秒计算) ，在休眠5秒应该就是过期了，在查看key 是否攒在
	 * psetex 和setex 唯一的区别就是psetex以毫秒计算 setex 以秒计算
	 * @throws InterruptedException
	 * */
	public static void setex_ttl() throws InterruptedException{

		redis.setex("foo", 5, "haha");
		System.out.println("foo1:"+redis.get("foo"));
		Thread.sleep(1000);
		Long time=redis.ttl("foo");
		System.out.println("剩余过期时间(单位以秒计算):"+time);
		Thread.sleep(5000);
		System.out.println("foo2:"+redis.get("foo"));
		 redis.flushDB();//清除数据
	}

	/**
	 * SETEX key seconds value
	 * 设置key：foo 的值 value:haha ,如果key 存在覆盖值，不存在等同于set
	 * 同时设置5秒后过期，并将key的生存时间设为seconds(以毫秒为单位)。
	 * 实现：先暂停一秒 通过ttl 查看剩余时间 ，在休眠5秒应该就是过期了，在查看key 是否攒在
	 * psetex 和setex 唯一的区别就是psetex以毫秒计算 setex 以秒计算
	 * @throws InterruptedException
	 * */
	public static void psetex_pttl() throws InterruptedException{

		//psetex 和setex 唯一的区别就是psetex以毫秒计算 setex 以秒计算

		redis.psetex("foo", 5000, "haha");
		System.out.println("foo1:"+redis.get("foo"));
		Thread.sleep(1000);
		Long time=redis.pttl("foo");
		System.out.println("剩余过期时间:"+time);
		Thread.sleep(5000);
		System.out.println("foo2:"+redis.get("foo"));
		 redis.flushDB();//清除数据
	}

	/**
	 * SETNX key value
	 * 将 key 的值设为 value ，当且仅当 key 不存在。
	 * 若给定的 key 已经存在，则 SETNX 不做任何动作。
	 * */
	public static void setnx(){
		redis.set("name", "liliang");

		redis.setnx("name", "liliang-001");
		redis.setnx("age", "18");

		System.out.println("已经存在的key 在设置将不做改变:"+redis.get("name"));

		System.out.println("不存在的key:"+redis.get("age"));
		redis.flushDB();//清除数据
	}

	/**
	 * MSETNX key value [key value ...]
	 * 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。
	 * 即使只有一个给定 key 已存在， MSETNX 也会拒绝执行所有给定 key 的设置操作。
	 * MSETNX 是原子性的 所有字段要么全被设置，要么全不被设置。
	 * */
	public static void msetnx(){

		//不存在的情况
		Long size=redis.msetnx("name","liliang","id","123456");
		System.out.println("size:"+size);
		List<String> list=redis.mget("name","id");
		for(String s:list){
			System.out.println("s:"+s);
		}
		redis.flushDB();//清除数据

		System.out.println("=================");
		//key有存在的情况
		redis.set("name", "liliangabc");//设置一个key 让下面的设置多个key时存在key=name的。
		Long size1=redis.msetnx("name","liliang123","id","123456abc");
		System.out.println("size1:"+size1);
		List<String> list1=redis.mget("name","id");
		for(String s:list1){
			System.out.println("s1:"+s);
		}
		redis.flushDB();//清除数据
	}

	/**
	 * STRLEN key
	 * 返回 key 所储存的字符串值的长度。
	 * 当 key 储存的不是字符串值时，返回一个错误。
	 * */
	public static void strlen(){
		redis.set("name", "liliang");
		Long length=redis.strlen("name");
		System.out.println("key=name 存在:"+length);

		Long length1=redis.strlen("name1");
		System.out.println("key=name1 不存在:"+length1);

		redis.flushDB();//清除数据
	}

	/**
	 * SETRANGE key offset value
	 * 用 value 参数覆写(overwrite)给定 key 所储存的字符串值，从偏移量 offset 开始。
	 * 不存在的 key 在位移offset前面的用空字符串代替处理。
	 * 注意你能使用的最大偏移量是 2^29-1(536870911) ，因为 Redis 字符串的大小被限制在 512 兆(megabytes)以内。
	 * 如果你需要使用比这更大的空间，你可以使用多个 key 。
	 * */
	public static void setrange(){

		//key=name 存在
		redis.set("name", "abcdefghijk");
		redis.setrange("name", 3, "123");
		System.out.println(redis.get("name"));

		//key=name1 不存在，在位移3 前面的用空字符串代替
		redis.setrange("name1", 3, "123");
		System.out.println(redis.get("name1"));
		redis.flushDB();//清除数据
	}

	/**
	 * GETRANGE key start end
	 * 返回 key 中字符串值的子字符串，
	 * 字符串的截取范围由 start(开始位置) 和 end(结束位置) 两个偏移量决定(包括 start 和 end 在内)。
	 * -1代表到最后,如果end超过字符串的长度，超过的长度被忽略
	 * */
	public static void getrange(){
		redis.set("name", "abcdefghijk");
		String s=redis.getrange("name", 3, 5);
		String s1=redis.getrange("name", 3, -1);
		String s2=redis.getrange("name", 3, 1000000);
		System.out.println(s);
		System.out.println(s1);
		System.out.println(s2);
	}

	/**
	 * DECR key
	 * 将 key 中储存的数字值减一;/
	 * ===============================================
	 * DECRBy key  decrement
	 * 将 key 中储存的数字值减 decrement;/
	 *
	 * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作；两个方法都一样.
	 * */
	public static void decr_decrby(){

		Long num=redis.decr("num");
		System.out.println("num:"+num);

		Long age=redis.decrBy("age", 10);
		System.out.println("age:"+age);

		redis.flushDB();//清除数据
	}

	/**
	 * INCR key
	 * 将 key 中储存的数字值加一;/
	 * ===============================================
	 * INCRBy key  decrement
	 * 将 key 中储存的数字值加 decrement;/
	 *
	 * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作；两个方法都一样.
	 * */
	public static void incr_deincr(){
		Long num=redis.incr("num");
		System.out.println("num:"+num);

		Long age=redis.incrBy("age", 10);
		System.out.println("age:"+age);

		//redis.flushDB();//清除数据
	}

}