将php序列化到数据库的对象饭序列化成java对象

php的对象序列化到数据库中，形如a:3:{i:0;i:1241;i:1;i:4;i:2;i:16;}

但是java需要取出这样的对象，转换成java的对象

/* PHPSerializer.java * * Author: Ma Bingyao <[e-mail]>  * Copyright: CoolCode.CN  * Version: 2.1  * LastModified: 2006-08-09  * This library is free. You can redistribute it and/or modify it.  * http://www.coolcode.cn/?p=202 */package org.phprpc.util; import java.io.*; import java.util.*; import java.lang.reflect.*; class UnSerializeResult {  public Object value;  public int hv;  public UnSerializeResult() {}  public UnSerializeResult(Object value, int hv) {  this.value = value;  this.hv = hv; }}public class PHPSerializer {  private static Package[] __packages = Package.getPackages();  private static final byte __Quote = 34;  private static final byte __0 = 48;  private static final byte __1 = 49;  private static final byte __Colon = 58;  private static final byte __Semicolon = 59;  private static final byte __C = 67;  private static final byte __N = 78;  private static final byte __O = 79;  private static final byte __R = 82;  private static final byte __U = 85;  private static final byte __Slash = 92;  private static final byte __a = 97;  private static final byte __b = 98;  private static final byte __d = 100;  private static final byte __i = 105;  private static final byte __r = 114;  private static final byte __s = 115;  private static final byte __LeftB = 123;  private static final byte __RightB = 125;  private static final String __NAN = new String("NAN");  private static final String __INF = new String("INF");  private static final String __NINF = new String("-INF");  private PHPSerializer() {}  public static byte[] serialize(Object obj) {  return serialize(obj,"UTF-8"); } public static byte[] serialize(Object obj, String charset) {  HashMap ht = new HashMap();  int hv = 1;  ByteArrayOutputStream stream = new ByteArrayOutputStream();  hv = serialize(stream, obj, ht, hv, charset);  byte[] result = stream.toByteArray();  try { stream.close(); } catch (Exception e) {}  return result; } public static int serialize(ByteArrayOutputStream stream, Object obj, HashMap ht, int hv, String charset) {  if (obj == null) { hv++;writeNull(stream); } else {  if (obj instanceof Boolean) { hv++; writeBoolean(stream, ((Boolean) obj).booleanValue() ? __1 : __0);  } else if ((obj instanceof Byte) || (obj instanceof Short)  || (obj instanceof Integer)) { hv++; writeInteger(stream, getBytes(obj));  } else if (obj instanceof Long) { hv++; writeDouble(stream, getBytes(obj));  } else if (obj instanceof Float) { hv++; Float f = (Float) obj;  if (f.isNaN()) {  writeDouble(stream, getBytes(__NAN));  } else if (f.isInfinite()) {  if (f.floatValue() > 0) {  writeDouble(stream, getBytes(__INF));  } else {  writeDouble(stream, getBytes(__NINF)); } } else {  writeDouble(stream, getBytes(f)); } } else if (obj instanceof Double) { hv++; Double d = (Double) obj;  if (d.isNaN()) {  writeDouble(stream, getBytes(__NAN));  } else if (d.isInfinite()) {  if (d.doubleValue() > 0) {  writeDouble(stream, getBytes(__INF));  } else {  writeDouble(stream, getBytes(__NINF)); } } else {  writeDouble(stream, getBytes(d)); } } else if ((obj instanceof Character) || (obj instanceof String)) { hv++; writeString(stream, getBytes(obj, charset));  } else if (obj.getClass().isArray()) {  if (ht.containsKey(new Integer(obj.hashCode()))) {  writePointRef(stream, getBytes(ht.get(new Integer(obj.hashCode()))));  } else {  ht.put(new Integer(obj.hashCode()), new Integer(hv++));  hv = writeArray(stream, obj, ht, hv, charset); } } else if (obj instanceof ArrayList) {  if (ht.containsKey(new Integer(obj.hashCode()))) {  writePointRef(stream, getBytes(ht.get(new Integer(obj.hashCode()))));  } else {  ht.put(new Integer(obj.hashCode()), new Integer(hv++));  hv = writeArrayList(stream, (ArrayList) obj, ht, hv, charset); } } else if (obj instanceof HashMap) {  if (ht.containsKey(new Integer(obj.hashCode()))) {  writePointRef(stream, getBytes(ht.get(new Integer(obj.hashCode()))));  } else {  ht.put(new Integer(obj.hashCode()), new Integer(hv++));  hv = writeHashMap(stream, (HashMap) obj, ht, hv, charset); } } else {  if (ht.containsKey(new Integer(obj.hashCode()))) { hv++; writeRef(stream, getBytes(ht.get(new Integer(obj.hashCode()))));  } else {  ht.put(new Integer(obj.hashCode()), new Integer(hv++));  hv = writeObject(stream, obj, ht, hv, charset); }}} return hv; } private static void writeNull(ByteArrayOutputStream stream) { stream.write(__N);stream.write(__Semicolon);} private static void writeRef(ByteArrayOutputStream stream, byte[] r) { stream.write(__r);stream.write(__Colon); stream.write(r, 0, r.length); stream.write(__Semicolon);} private static void writePointRef(ByteArrayOutputStream stream, byte[] p) { stream.write(__R);stream.write(__Colon); stream.write(p, 0, p.length); stream.write(__Semicolon);} private static void writeBoolean(ByteArrayOutputStream stream, byte b) { stream.write(__b);stream.write(__Colon);stream.write(b);stream.write(__Semicolon);} private static void writeInteger(ByteArrayOutputStream stream, byte[] i) { stream.write(__i);stream.write(__Colon); stream.write(i, 0, i.length); stream.write(__Semicolon);} private static void writeDouble(ByteArrayOutputStream stream, byte[] d) { stream.write(__d);stream.write(__Colon); stream.write(d, 0, d.length); stream.write(__Semicolon);} private static void writeString(ByteArrayOutputStream stream, byte[] s) {  byte[] slen = getBytes(new Integer(s.length)); stream.write(__s);stream.write(__Colon); stream.write(slen, 0, slen.length); stream.write(__Colon);stream.write(__Quote); stream.write(s, 0, s.length); stream.write(__Quote);stream.write(__Semicolon);} private static int writeArray(ByteArrayOutputStream stream, Object a, HashMap ht, int hv, String charset) {  int len = Array.getLength(a);  byte[] alen = getBytes(new Integer(len)); stream.write(__a);stream.write(__Colon); stream.write(alen, 0, alen.length); stream.write(__Colon);stream.write(__LeftB); for (int i = 0; i < len; i++) {  writeInteger(stream, getBytes(new Integer(i)));  hv = serialize(stream, Array.get(a, i), ht, hv, charset); }stream.write(__RightB); return hv; } private static int writeArrayList(ByteArrayOutputStream stream, ArrayList a, HashMap ht, int hv, String charset) {  int len = a.size();  byte[] alen = getBytes(new Integer(len)); stream.write(__a);stream.write(__Colon); stream.write(alen, 0, alen.length); stream.write(__Colon);stream.write(__LeftB); for (int i = 0; i < len; i++) {  writeInteger(stream, getBytes(new Integer(i)));  hv = serialize(stream, a.get(i), ht, hv, charset); }stream.write(__RightB); return hv; } private static int writeHashMap(ByteArrayOutputStream stream, HashMap h, HashMap ht, int hv, String charset) {  int len = h.size();  byte[] hlen = getBytes(new Integer(len)); stream.write(__a);stream.write(__Colon); stream.write(hlen, 0, hlen.length); stream.write(__Colon);stream.write(__LeftB); for (Iterator keys = h.keySet().iterator(); keys.hasNext();) {  Object key = keys.next();  if ((key instanceof Byte) || (key instanceof Short)  || (key instanceof Integer)) {  writeInteger(stream, getBytes(key));  } else if (key instanceof Boolean) {  writeInteger(stream, new byte[] { ((Boolean) key).booleanValue() ? __1 : __0 });  } else {  writeString(stream, getBytes(key, charset)); } hv = serialize(stream, h.get(key), ht, hv, charset); }stream.write(__RightB); return hv; } private static int writeObject(ByteArrayOutputStream stream, Object obj, HashMap ht, int hv, String charset) {  Class cls = obj.getClass();  if (obj instanceof java.io.Serializable) {  byte[] className = getBytes(getClassName(cls), charset);  byte[] classNameLen = getBytes(new Integer(className.length));  if (obj instanceof org.phprpc.util.Serializable) {  byte[] cs = ((org.phprpc.util.Serializable) obj).serialize();  byte[] cslen = getBytes(new Integer(cs.length)); stream.write(__C);stream.write(__Colon); stream.write(classNameLen, 0, classNameLen.length); stream.write(__Colon);stream.write(__Quote); stream.write(className, 0, className.length); stream.write(__Quote);stream.write(__Colon); stream.write(cslen, 0, cslen.length); stream.write(__Colon);stream.write(__LeftB); stream.write(cs, 0, cs.length); stream.write(__RightB); } else {  Method __sleep;  try {  __sleep = cls.getMethod("__sleep", new Class[0]);  } catch (Exception e) {  __sleep = null; } int fl = 0;  Field[] f;  if (__sleep != null) {  String[] fieldNames;  try { __sleep.setAccessible(true); fieldNames = (String[]) __sleep.invoke(obj, new Object[0]);  } catch (Exception e) {  fieldNames = null; } f = getFields(obj, fieldNames);  } else {  f = getFields(obj); } AccessibleObject.setAccessible(f, true);  byte[] flen = getBytes(new Integer(f.length)); stream.write(__O);stream.write(__Colon); stream.write(classNameLen, 0, classNameLen.length); stream.write(__Colon);stream.write(__Quote); stream.write(className, 0, className.length); stream.write(__Quote);stream.write(__Colon); stream.write(flen, 0, flen.length); stream.write(__Colon);stream.write(__LeftB); for (int i = 0, len = f.length; i < len; i++) {  int mod = f[i].getModifiers();  if (Modifier.isPublic(mod)) {  writeString(stream, getBytes(f[i].getName(), charset));  } else if (Modifier.isProtected(mod)) { writeString(stream, getBytes("*"+ f[i].getName(), charset));  } else { writeString(stream,getBytes(""+ getClassName(f[i].getDeclaringClass())  +""+ f[i].getName(), charset));} Object o;  try {  o = f[i].get(obj);  } catch (Exception e) {  o = null; } hv = serialize(stream, o, ht, hv, charset); }stream.write(__RightB);} } else { writeNull(stream);} return hv; } private static byte[] getBytes(Object obj) {  try {  return obj.toString().getBytes("US-ASCII");  } catch (Exception e) {  return obj.toString().getBytes(); }} private static byte[] getBytes(Object obj, String charset) {  try {  return obj.toString().getBytes(charset);  } catch (Exception e) {  return obj.toString().getBytes(); }} private static String getString(byte[] data, String charset) {  try {  return new String(data, charset);  } catch (Exception e) {  return new String(data); }} private static Class getClass(String className) {  try {  Class cls = Class.forName(className);  return cls;  } catch (Exception e) {}  for (int i = 0; i < __packages.length; i++) {  try {  Class cls = Class.forName(  __packages[i].getName() +"."+ className);  return cls;  } catch (Exception e) {} } return null; } private static String getClassName(Class cls) {  return cls.getName().substring(cls.getPackage().getName().length() + 1); } private static Field getField(Object obj, String fieldName) {  Class cls = obj.getClass();  while (cls != null) {  try {  Field result = cls.getDeclaredField(fieldName);  int mod = result.getModifiers();  if (Modifier.isFinal(mod) || Modifier.isStatic(mod)) {  return null; } return result;  } catch (Exception e) {}  cls = cls.getSuperclass(); } return null; } private static Field[] getFields(Object obj, String[] fieldNames) {  if (fieldNames == null) {  return getFields(obj); } int n = fieldNames.length;  ArrayList fields = new ArrayList(n);  for (int i = 0; i < n; i++) {  Field f = getField(obj, fieldNames[i]);  if (f != null) { fields.add(f);}} return (Field[]) fields.toArray(new Field[0]); } private static Field[] getFields(Object obj) {  ArrayList fields = new ArrayList();  Class cls = obj.getClass();  while (cls != null) {  Field[] fs = cls.getDeclaredFields();  for (int i = 0; i < fs.length; i++) {  int mod = fs[i].getModifiers();  if (!Modifier.isFinal(mod) && !Modifier.isStatic(mod)) { fields.add(fs[i]);}} cls = cls.getSuperclass(); } return (Field[]) fields.toArray(new Field[0]); } public static Object newInstance(Class cls) {  try {  Constructor ctor = cls.getConstructor(new Class[0]);  int mod = ctor.getModifiers();  if (Modifier.isPublic(mod)) {  return ctor.newInstance(new Object[0]); } } catch (Exception e) {}  try {  Constructor ctor = cls.getConstructor(new Class[] { Integer.TYPE });  int mod = ctor.getModifiers();  if (Modifier.isPublic(mod)) {  return ctor.newInstance(new Object[] { new Integer(0) }); } } catch (Exception e) {}  try {  Constructor ctor = cls.getConstructor(new Class[] { Boolean.TYPE });  int mod = ctor.getModifiers();  if (Modifier.isPublic(mod)) {  return ctor.newInstance(new Object[] { new Boolean(false) }); } } catch (Exception e) {}  try {  Constructor ctor = cls.getConstructor(new Class[] { String.class });  int mod = ctor.getModifiers();  if (Modifier.isPublic(mod)) {  return ctor.newInstance(new Object[] {""}); } } catch (Exception e) {}  Field[] f = cls.getFields();  for (int i = 0; i < f.length; i++) {  if (f[i].getType() == cls && Modifier.isStatic(f[i].getModifiers())) {  try {  return f[i].get(null);  } catch (Exception e) {} }} Method[] m = cls.getMethods();  for (int i = 0; i < m.length; i++) {  if (m[i].getReturnType() == cls  && Modifier.isStatic(m[i].getModifiers())) {  try {  return m[i].invoke(null, new Object[0]);  } catch (Exception e) {}  try {  return m[i].invoke(null, new Object[] { new Integer(0) });  } catch (Exception e) {}  try {  return m[i].invoke(null, new Object[] { new Boolean(false) });  } catch (Exception e) {}  try {  return m[i].invoke(null, new Object[] {""});  } catch (Exception e) {} }} return null; } public static Number cast(Number n, Class destClass) {  if (destClass == Byte.class) {  return new Byte(n.byteValue()); } if (destClass == Short.class) {  return new Short(n.shortValue()); } if (destClass == Integer.class) {  return new Integer(n.intValue()); } if (destClass == Long.class) {  return new Long(n.longValue()); } if (destClass == Float.class) {  return new Float(n.floatValue()); } if (destClass == Double.class) {  return new Double(n.doubleValue()); } return n; } public static Object cast(Object obj, Class destClass) {  if (obj == null || destClass == null) {  return obj;  } else if (obj.getClass() == destClass) {  return obj;  } else if (obj instanceof Number) {  return cast((Number) obj, destClass);  } else if ((obj instanceof String) && destClass == Character.class) {  return new Character(((String)obj).charAt(0));  } else if ((obj instanceof ArrayList) && destClass.isArray()) {  return toArray((ArrayList) obj, destClass.getComponentType());  } else if ((obj instanceof ArrayList) && destClass == HashMap.class) {  return toHashMap((ArrayList) obj);  } else {  return obj; }} private static HashMap toHashMap(ArrayList a) {  int n = a.size();  HashMap h = new HashMap(n);  for (int i = 0; i < n; i++) {  h.put(new Integer(i), a.get(i)); } return h; } private static Object toArray(ArrayList obj, Class componentType) {  int n = obj.size();  Object a = Array.newInstance(componentType, n);  for (int i = 0; i < n; i++) {  Array.set(a, i, cast(obj.get(i), componentType)); } return a; } private static int getPos(ByteArrayInputStream stream) {  try {  Field pos = stream.getClass().getDeclaredField("pos"); pos.setAccessible(true); return pos.getInt(stream);  } catch (Exception e) {  return 0; }} private static void setPos(ByteArrayInputStream stream, int p) {  try {  Field pos = stream.getClass().getDeclaredField("pos"); pos.setAccessible(true); pos.setInt(stream, p);  } catch (Exception e) {} } public static Object unserialize(byte[] ss) throws IllegalAccessException {  return unserialize(ss, null,"UTF-8"); } public static Object unserialize(byte[] ss, String charset) throws IllegalAccessException {  return unserialize(ss, null, charset); } public static Object unserialize(byte[] ss, Class cls) throws IllegalAccessException {  return unserialize(ss, cls,"UTF-8"); } public static Object unserialize(byte[] ss, Class cls, String charset) throws IllegalAccessException {  int hv = 1;  ByteArrayInputStream stream = new ByteArrayInputStream(ss);  Object result = unserialize(stream, new HashMap(), hv, new HashMap(), charset).value;  try { stream.close(); } catch (Exception e) {}  return cast(result, cls); } private static UnSerializeResult unserialize(ByteArrayInputStream stream, HashMap ht, int hv, HashMap rt, String charset) throws IllegalAccessException {  Object obj;  switch (stream.read()) {  case __N:  obj = readNull(stream);  ht.put(new Integer(hv++), obj);  return new UnSerializeResult(obj, hv);  case __b:  obj = readBoolean(stream);  ht.put(new Integer(hv++), obj);  return new UnSerializeResult(obj, hv);  case __i:  obj = readInteger(stream);  ht.put(new Integer(hv++), obj);  return new UnSerializeResult(obj, hv);  case __d:  obj = readDouble(stream);  ht.put(new Integer(hv++), obj);  return new UnSerializeResult(obj, hv);  case __s:  obj = readString(stream, charset);  ht.put(new Integer(hv++), obj);  return new UnSerializeResult(obj, hv);  case __U:  obj = readUnicodeString(stream);  ht.put(new Integer(hv++), obj);  return new UnSerializeResult(obj, hv);  case __r:  return readRef(stream, ht, hv, rt);  case __a:  return readArray(stream, ht, hv, rt, charset);  case __O:  return readObject(stream, ht, hv, rt, charset);  case __C:  return readCustomObject(stream, ht, hv, charset);  case __R:  return readPointRef(stream, ht, hv, rt); default: return null; }} private static String readNumber(ByteArrayInputStream stream) {  StringBuffer sb = new StringBuffer();  int i = stream.read();  while ((i != __Semicolon) && (i != __Colon)) {  sb.append((char) i);  i = stream.read(); } return sb.toString(); } private static Object readNull(ByteArrayInputStream stream) { stream.skip(1); return null; } private static Boolean readBoolean(ByteArrayInputStream stream) { stream.skip(1); Boolean b = new Boolean(stream.read() == __1); stream.skip(1); return b; } private static Number readInteger(ByteArrayInputStream stream) { stream.skip(1); String i = readNumber(stream);  try {  return new Byte(i);  } catch (Exception e1) {  try {  return new Short(i);  } catch (Exception e2) {  return new Integer(i); }}} private static Number readDouble(ByteArrayInputStream stream) { stream.skip(1); String d = readNumber(stream);  if (d.equals(__NAN)) {  return new Double(Double.NaN); } if (d.equals(__INF)) {  return new Double(Double.POSITIVE_INFINITY); } if (d.equals(__NINF)) {  return new Double(Double.NEGATIVE_INFINITY); } try {  return new Long(d);  } catch (Exception e1) {  try {  Float f = new Float(d);  if (f.isInfinite()) {  return new Double(d);  } else {  return f; } } catch (Exception e2) {  return new Float(0); }}} private static String readString(ByteArrayInputStream stream, String charset) { stream.skip(1); int len = Integer.parseInt(readNumber(stream)); stream.skip(1); byte[] buf = new byte[len];  stream.read(buf, 0, len);  String s = getString(buf, charset); stream.skip(2); return s; } private static String readUnicodeString(ByteArrayInputStream stream) { stream.skip(1); int l = Integer.parseInt(readNumber(stream)); stream.skip(1); StringBuffer sb = new StringBuffer(l);  int c;  for (int i = 0; i < l; i++) {  if ((c = stream.read()) == __Slash) {  char c1 = (char) stream.read();  char c2 = (char) stream.read();  char c3 = (char) stream.read();  char c4 = (char) stream.read(); sb.append( (char) (Integer.parseInt(  new String(new char[] { c1, c2, c3, c4 }), 16)));  } else {  sb.append((char) c); }}stream.skip(2); return sb.toString(); } private static UnSerializeResult readRef(ByteArrayInputStream stream, HashMap ht, int hv, HashMap rt) { stream.skip(1); Integer r = new Integer(readNumber(stream));  if (rt.containsKey(r)) {  rt.put(r, new Boolean(true)); } Object obj = ht.get(r);  ht.put(new Integer(hv++), obj);  return new UnSerializeResult(obj, hv); } private static UnSerializeResult readPointRef(ByteArrayInputStream stream, HashMap ht, int hv, HashMap rt) { stream.skip(1); Integer r = new Integer(readNumber(stream));  if (rt.containsKey(r)) {  rt.put(r, new Boolean(true)); } Object obj = ht.get(r);  return new UnSerializeResult(obj, hv); } private static UnSerializeResult readArray(ByteArrayInputStream stream, HashMap ht, int hv, HashMap rt, String charset) throws IllegalAccessException { stream.skip(1); int n = Integer.parseInt(readNumber(stream)); stream.skip(1); HashMap h = new HashMap(n);  ArrayList al = new ArrayList(n);  Integer r = new Integer(hv);  rt.put(r, new Boolean(false));  int p = getPos(stream);  ht.put(new Integer(hv++), h);  for (int i = 0; i < n; i++) {  Object key;  switch (stream.read()) {  case __i:  key = cast(readInteger(stream), Integer.class); break; case __s:  key = readString(stream, charset); break; case __U:  key = readUnicodeString(stream); break;default: return null; } UnSerializeResult result = unserialize(stream, ht, hv, rt, charset);  hv = result.hv;  if (al != null) {  if ((key instanceof Integer) && (((Integer) key).intValue() == i)) { al.add(result.value); } else {  al = null; }} h.put(key, result.value); } if (al != null) {  ht.put(r, al);  if (((Boolean) (rt.get(r))).booleanValue()) {  hv = r.intValue() + 1;  setPos(stream, p);  for (int i = 0; i < n; i++) {  int key;  switch (stream.read()) {  case __i:  key = ((Integer) cast(readInteger(stream), Integer.class)).intValue(); break;default: return null; } UnSerializeResult result = unserialize(stream, ht, hv, rt, charset); hv = result.hv;  al.set(key, result.value); }}}rt.remove(r);stream.skip(1); return new UnSerializeResult(ht.get(r), hv); } private static UnSerializeResult readObject(ByteArrayInputStream stream, HashMap ht, int hv, HashMap rt, String charset) throws IllegalAccessException { stream.skip(1); int len = Integer.parseInt(readNumber(stream)); stream.skip(1); byte[] buf = new byte[len];  stream.read(buf, 0, len);  String cn = getString(buf, charset); stream.skip(2); int n = Integer.parseInt(readNumber(stream)); stream.skip(1); Class cls = getClass(cn);  Object o;  if (cls != null) {  if ((o = newInstance(cls)) == null) {  o = new HashMap(n); } } else {  o = new HashMap(n); } ht.put(new Integer(hv++), o);  for (int i = 0; i < n; i++) {  String key;  switch (stream.read()) {  case __s:  key = readString(stream, charset); break; case __U:  key = readUnicodeString(stream); break;default: return null; } if (key.charAt(0) == (char) 0) {  key = key.substring(key.indexOf("", 1) + 1); } UnSerializeResult result = unserialize(stream, ht, hv, rt, charset);  hv = result.hv;  if (o instanceof HashMap) {  ((HashMap) o).put(key, result.value);  } else {  Field f = getField(o, key); f.setAccessible(true); f.set(o, result.value); }}stream.skip(1); Method __wakeup = null;  try {  __wakeup = o.getClass().getMethod("__wakeup", new Class[0]);  __wakeup.invoke(o, new Object[0]);  } catch (Exception e) {}  return new UnSerializeResult(o, hv); } private static UnSerializeResult readCustomObject(ByteArrayInputStream stream, HashMap ht, int hv, String charset) { stream.skip(1); int len = Integer.parseInt(readNumber(stream)); stream.skip(1); byte[] buf = new byte[len];  stream.read(buf, 0, len);  String cn = getString(buf, charset); stream.skip(2); int n = Integer.parseInt(readNumber(stream)); stream.skip(1); Class cls = getClass(cn);  Object o;  if (cls != null) {  o = newInstance(cls);  } else {  o = null; } ht.put(new Integer(hv++), o);  if (o == null) { stream.skip(n); } else if (o instanceof org.phprpc.util.Serializable) {  byte[] b = new byte[n];  stream.read(b, 0, n);  ((org.phprpc.util.Serializable) o).unserialize(b);  } else { stream.skip(n);}stream.skip(1); return new UnSerializeResult(o, hv); } public static void main(String[] args) throws IllegalAccessException { List list = (List)PHPSerializer.unserialize("a:3:{i:0;i:1241;i:1;i:4;i:2;i:16;}".getBytes()); for(Object o : list){System.out.println(o.toString());}System.out.println(list.size());}}