Clients

Jedis Sets

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

Sets

Class 변수로 선언

String key = "myset";
String value = "value";
long idx = 1;

SADD

// SADD key member [member ...] -> Integer reply: the number of elements that were added to the set, 
// not including all the elements already present into the set
protected void sadd() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SADD key member [member ...] -> return Long");
	try {
		Long cnt = Redis.cmd.sadd(key, value+idx);
		System.out.println("sadd -> "+cnt);
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
}

SREM

// SREM key member [member ...] -> Integer reply: the number of members that were removed from the set, not including non existing members.
protected void srem() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SREM key member [member ...] -> return Long");
	try {
		Long cnt = Redis.cmd.srem(key, "value1");
		System.out.println("srem -> "+cnt);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SMEMBERS

// SMEMBERS key -> Array reply: all elements of the set.
protected void smembers() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SMEMBERS key -> return Set<String>");
	try {
		Set<String> set = Redis.cmd.smembers(key);
		System.out.println("smembers -> "+set);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SCARD

// SCARD key -> Integer reply: the cardinality (number of elements) of the set, or 0 if key does not exist.
protected void scard() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SCARD key -> return Long");
	try {
		Long size = Redis.cmd.scard(key);
		System.out.println("scard -> "+size);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SUNION

// SUNION key [key ...] -> Array reply: list with members of the resulting set.
protected void sunion() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SUNION key [key ...] -> return Set<String>");
	try {
		Redis.cmd.del("myset1", "myset2");
		Redis.cmd.sadd("myset1", "A", "B", "C");
		Redis.cmd.sadd("myset2", "B", "C", "D");
		Set<String> set = Redis.cmd.sunion("myset1", "myset2");
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, C, D]");
		System.out.println("sunion myset1 myset2 -> " +set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SINTER

// SINTER key [key ...] -> return Array reply: list with members of the resulting set.
protected void sinter() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SINTER key [key ...] -> return Set<String>");
	try {
		Redis.cmd.del("myset1", "myset2");
		Redis.cmd.sadd("myset1", "A", "B", "C");
		Redis.cmd.sadd("myset2", "B", "C", "D");
		Set<String> set = Redis.cmd.sinter("myset1", "myset2");
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, C, D]");
		System.out.println("sinter myset1 myset2 -> " +set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SDIFF

// SDIFF key [key ...] -> Array reply: list with members of the resulting set.
protected void sdiff() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SDIFF key [key ...] -> return Set<String>");
	try {
		Redis.cmd.del("myset1", "myset2");
		Redis.cmd.sadd("myset1", "A", "B", "C");
		Redis.cmd.sadd("myset2", "B", "D");
		Set<String> set = Redis.cmd.sdiff("myset1", "myset2");
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, D]");
		System.out.println("sdiff myset1 myset2 -> " +set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SUNIONSTORE

// SUNIONSTORE destination_key source_key [source_key ...] -> Integer reply: the number of elements in the resulting set
protected void sunionstore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SUNIONSTORE destination_key source_key [source_key ...] -> return Long");
	try {
		Redis.cmd.del("myset1", "myset2");
		Redis.cmd.sadd("myset1", "A", "B", "C");
		Redis.cmd.sadd("myset2", "B", "C", "D");
		Long count = Redis.cmd.sunionstore("dest_key", "myset1", "myset2");
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, C, D]");
		System.out.println("sunionstore dest_key myset1 myset2 -> " +count);
		Set<String> set = Redis.cmd.smembers("dest_key");
		System.out.println("smember dest_key -> " +set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SINTERSTORE

// SINTERSTORE destination_key source_key [source_key ...] -> Integer reply: the number of elements in the resulting set.
protected void sinterstore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SINTERSTORE destination_key source_key [source_key ...] -> return Long");
	try {
		Redis.cmd.del("myset1", "myset2");
		Redis.cmd.sadd("myset1", "A", "B", "C");
		Redis.cmd.sadd("myset2", "B", "C", "D");
		long count = Redis.cmd.sinterstore("dest_key", "myset1", "myset2");
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, C, D]");
		System.out.println("sinterstore dest_key myset1 myset2 -> " +count);
		Set<String> set = Redis.cmd.smembers("dest_key");
		System.out.println("smember dest_key -> " +set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SDIFFSTORE

// SDIFFSTORE destination_key source_key [source_key ...] -> Integer reply: the number of elements in the resulting set.
protected void sdiffstore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SDIFFSTORE destination_key source_key [source_key ...] -> return Long");
	try {
		Redis.cmd.del("myset1", "myset2");
		Redis.cmd.sadd("myset1", "A", "B", "C");
		Redis.cmd.sadd("myset2", "B", "D");
		long count = Redis.cmd.sdiffstore("dest_key", "myset1", "myset2");
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, D]");
		System.out.println("sdiffstore dest_key myset1 myset2 -> " +count);
		Set<String> set = Redis.cmd.smembers("dest_key");
		System.out.println("smember dest_key -> " +set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SISMEMBER

// SISMEMBER key member -> Integer reply, specifically:
// 		1 if the element is a member of the set.
// 		0 if the element is not a member of the set, or if key does not exist.
protected void sismember() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SISMEMBER key member -> return Boolean");
	try {
		Redis.cmd.del(key);
		Redis.cmd.sadd(key, "멤버_1", "멤버_2");
		Set<String> set = Redis.cmd.smembers(key);
		System.out.println("smembers "+key+" -> " +set.toString());
		Boolean is1 = Redis.cmd.sismember(key, "멤버_1");
		System.out.println("sismember "+key+" 멤버_1 -> " +is1);
		Boolean is2 = Redis.cmd.sismember(key, "멤버_X");
		System.out.println("sismember "+key+" 멤버_X -> " +is2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SMOVE

// SMOVE source_key destination_key member -> Integer reply, specifically:
//		1 if the element is moved.
//		0 if the element is not a member of source and no operation was performed.
protected void smove() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SMOVE source_key destination_key member -> return Long");
	try {
		Redis.cmd.del("src_key", "dest_key");
		Redis.cmd.sadd("src_key", "A", "B", "C");
		Redis.cmd.sadd("dest_key", "D");
		Set<String> src = Redis.cmd.smembers("src_key");
		System.out.println("smembers src_key -> " +src.toString());
		Set<String> dest = Redis.cmd.smembers("dest_key");
		System.out.println("smembers dest_key -> " +dest.toString());
		
		Long move = Redis.cmd.smove("src_key", "dest_key", "A");
		System.out.println("smove src_key dest_key A -> "+move);
		Set<String> src2 = Redis.cmd.smembers("src_key");
		System.out.println("smembers src_key -> " +src2.toString());
		Set<String> dest2 = Redis.cmd.smembers("dest_key");
		System.out.println("smembers dest_key -> " +dest2.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SPOP

// SPOP key [count] -> Bulk string reply: the removed element, or nil when key does not exist.
protected void spop() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SPOP key [count] -> return String or Set<String>");
	try {
		Redis.cmd.del(key);
		Redis.cmd.sadd(key, "멤버_1", "멤버_2", "멤버_3");
		String m = Redis.cmd.spop(key);
		System.out.println("spop "+key+" -> " +m);
		Set<String> set = Redis.cmd.spop(key, 2);
		System.out.println("spop "+key+" 2 -> " +set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SRANDMEMBER

// SRANDMEMBER key [count] -> Bulk string reply: without the additional count argument the command returns 
//			a Bulk Reply with the randomly selected element, or nil when key does not exist. 
//		Array reply: when the additional count argument is passed the command returns an array of elements, 
//			or an empty array when key does not exist.
protected void srandmember() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SRANDMEMBER key [count] -> return String or List<String>");
	try {
		Redis.cmd.del(key);
		Redis.cmd.sadd(key, "멤버_1", "멤버_2", "멤버_3", "멤버_4", "멤버_5", "멤버_6", "멤버_7", "멤버_8", "멤버_9");
		Set<String> src = Redis.cmd.smembers(key);
		System.out.println("smembers "+key+" -> " +src.toString());
		
		String m = Redis.cmd.srandmember(key);
		System.out.println("srandmember "+key+" -> " +m);
		// return set이 아니고 list이다. count가 음수이면 값이 중복될 수 있다.
		List<String> list = Redis.cmd.srandmember(key, 2);
		System.out.println("srandmember "+key+" 2 -> " +list.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SSCAN

// SSCAN key cursor [MATCH pattern] [COUNT count] -> array of elements is a list of Set members.
protected void sscan() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SSCAN key cursor [MATCH pattern] [COUNT count] -> return ScanResult<String>");
	try {
		Redis.cmd.del(key);
		Redis.cmd.sadd(key, "A1", "A2", "A3", "B1", "B2", "B3", "C1", "C2", "C3", "D1", "D2", "D3", "E1", "E2", "E3");
		Set<String> src = Redis.cmd.smembers(key);
		System.out.println("smembers "+key+" -> " +src.toString()+" "+src.size());
		
		ScanResult<String> set = Redis.cmd.sscan(key, "0");
		System.out.println(set.getResult()+" "+set.getStringCursor());
		do {
			set = Redis.cmd.sscan(key, set.getStringCursor());
			System.out.println(set.getResult()+" "+set.getStringCursor());
		} while ( !(set.getStringCursor().equals("0")) );

	} catch (Exception e) {
		System.out.println(e);
	}
}

<< Lists	Sets	ZSets >>

Email 답글이 올라오면 이메일로 알려드리겠습니다.