一个列表最多可以包含超过 40亿个元素
列表的常用命令（持续扩充）：
1、lpush key value1 [value2]： 将一个或多个值插入列表头部（左边）
通过执行lpush animal cat dog 向animal中左边同时插入 cat和dog，下方提示的（Integer）2,是指当前列表中元素的个数；
然后通过查询命令，我们可以看到排在第一个的是dog 第二个是cat，这是因为从左边插入，县插入cat，然后再在左侧插入dog，这就导致dog在cat的前面。
2、rpush key value1 [value2]： 将一个或多个值插入列表尾部（右边）
执行rpush animal monkey：向列表的右侧插入一个元素monkey，此时列表中的元素就有3个
通过查询命令我们可以看到monkey出现在了列表的尾部
3、lrange key start stop： 获取列表指定范围内的元素（包含start和stop）
执行lrange animal 1 2 查询物银列表的第2个和第3个元素（注意列表中的索引是从0开始计算的）
4、llen key： 获取列表长度
在前面几个步骤中我们一共插入了三个元素dog、cat、monkey
5、lpop key： 移出并获取列表的第一个元素
列表中第一个元素是dog，执行lpop animal后，d出左边第一个元素并燃蚂瞎返回，再次查询，我们看到只剩下两个元素
6、rpop key： 移出并获取列表的最后一个元素
执行rpop animal，移除并返回monkey，最后列表中只剩下cat一个元素
以php为例:
$redis = new Redis()$redis->connect('127.0.0.1', 6379)
$redis->set("arr", array(1,2,3,4,5),3600)
$str = $redis->get("arr")
print_r($str)
安装了redis插件, 开启了server-redis，那么就能运蔽氏行以上代码，打印出来的结果你会发现是Array。
这说明redis无法存储数组类型的变量。
可以将数组转化宏蚂散为字符串再进行物雀储存，在用的时候取出来再转为数组再用。
如果需要用链纯到Redis存储List对象，而list又不需要进行 *** 作，可以按照MC的方式进行存储，不过Jedis之类的客户端没有提供API，可以有两种思路实现：1. 分别序列化 elements ,然后 set 存储
2.序列化List对象，set存储
这两种方法都类似MC的 Object方法存储，运用这种方式意味着放弃Redis对List提供的 *** 作方法。
import net.spy.memcached.compat.CloseUtil
import net.spy.memcached.compat.log.Logger
import net.spy.memcached.compat.log.LoggerFactory
import redis.clients.jedis.Client
import redis.clients.jedis.Jedis
import redis.clients.jedis.JedisPool
import redis.clients.jedis.JedisPoolConfig
import java.io.*
import java.util.ArrayList
import java.util.List
import java.util.Random
/**
* Created by IntelliJ IDEA.
* User: lifeng.xu
* Date: 12-6-11
* Time: 上午11:10
* To change this template use File | Settings | File Templates.
*/
public class JedisTest {
private static Logger logger = LoggerFactory.getLogger(JedisTest.class)
/**
* Jedis Pool for Jedis Resource
* @return
*/
禅森public static JedisPool buildJedisPool(){
JedisPoolConfig config = new JedisPoolConfig()
config.setMaxActive(1)
config.setMinIdle(50)
config.setMaxIdle(3000)
config.setMaxWait(5000)
JedisPool jedisPool = new JedisPool(config,
"*****", ****)
return jedisPool
}
/**
* Test Data
* @return
*/
public static List<User>buildTestData(){
User a = new User()
a.setName("a")
User b = new User()
b.setName("b")
List<User>list = new ArrayList<User>棚袭咐()
list.add(a)
list.add(b)
return list
}
/**
* Test for
*/
public static void testSetElements(){
List<User>testData = buildTestData()
Jedis jedis = buildJedisPool().getResource()
String key = "testSetElements" + new Random(1000).nextInt()
jedis.set(key.getBytes(), ObjectsTranscoder.serialize(testData))
//验证
byte[] in = jedis.get(key.getBytes())
List<User>list = ObjectsTranscoder.deserialize(in)
for(User user : list){
System.out.println("testSetElements user name is:" + user.getName())
}
}
public static void testSetEnsemble(){
List<User>testData = buildTestData()
Jedis jedis = buildJedisPool().getResource()
String key = "testSetEnsemble" + new Random(1000).nextInt()
jedis.set(key.getBytes(), ListTranscoder.serialize(testData))
//验证
byte[] in = jedis.get(key.getBytes())
List<User>list = (List<User>)ListTranscoder.deserialize(in)
for(User user : list){
System.out.println("testSetEnsemble user name is:" + user.getName())
}
}
public static void main(String[] args) {
testSetElements()
testSetEnsemble()
}
public static void close(Closeable closeable) {
if (closeable != null) {
try {
closeable.close()
} catch (Exception e) {
logger.info("Unable to close %s", closeable, e)
}
}
}
static class User implements Serializable{
String name
public String getName() {
return name
}
public void setName(String name) {
this.name = name
}
}
static class ObjectsTranscoder{
public static byte[] serialize(List<User>value) {
if (value == null) {
throw new NullPointerException("Can't serialize null")
}
byte[] rv=null
ByteArrayOutputStream bos = null
ObjectOutputStream os = null
try {
bos = new ByteArrayOutputStream()
os = new ObjectOutputStream(bos)
for(User user : value){
os.writeObject(user)
}
os.writeObject(null)
os.close()
bos.close()
rv = bos.toByteArray()
} catch (IOException e) {
throw new IllegalArgumentException("Non-serializable object", e)
} finally {
close(os)
close(bos)
}
return rv
}
public static List<User>deserialize(byte[] in) {
List<User>list = new ArrayList<User>()
ByteArrayInputStream bis = null
ObjectInputStream is = null
try {
if(in != null) {
bis=new ByteArrayInputStream(in)
is=new ObjectInputStream(bis)
while (true) {
User user = (User) is.readObject()
if(user == null){
break
}else{
list.add(user)
}
}
is.close()
bis.close()
}
} catch (IOException e) {
logger.warn("Caught IOException decoding %d bytes of data",
in == null ? 0 : in.length, e)
} catch (ClassNotFoundException e) {
logger.warn("Caught CNFE decoding %d bytes of data",
in == null ? 0 : in.length, e)
} finally {
CloseUtil.close(is)
CloseUtil.close(bis)
}
return list
}
}
static class ListTranscoder{
public static byte[] serialize(Object value) {
if (value == null) {
throw new NullPointerException("Can't serialize null")
}
byte[] rv=null
ByteArrayOutputStream bos = null
ObjectOutputStream os = null
try {
bos = new ByteArrayOutputStream()
os = new ObjectOutputStream(bos)
os.writeObject(value)
os.close()
bos.close()
rv = bos.toByteArray()
} catch (IOException e) {
throw new IllegalArgumentException("Non-serializable object", e)
} finally {
close(os)
close(bos)
}
return rv
}
public static Object deserialize(byte[] in) {
Object rv=null
ByteArrayInputStream bis = null
ObjectInputStream is = null
try {
if(in != null) {
bis=new ByteArrayInputStream(in)
is=new ObjectInputStream(bis)
rv=is.readObject()
is.close()
bis.close()
}
} catch (IOException e) {
logger.warn("Caught IOException decoding %d bytes of data",
in == null ? 0 : in.length, e)
} catch (ClassNotFoundException e) {
logger.warn("Caught CNFE decoding %d bytes of data",
in == null ? 0 : in.length, e)
} finally {
CloseUtil.close(is)
CloseUtil.close(bis)
}
return rv
}
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）