对字节流ByteArrayInputStream的读取操作问题

[sunh_li]

首先请耐心把如下代码看完，这个类是对字节流的操作，如果对字节流熟悉的话不是很理解。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

public class Serializer {
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 __N = 78;
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 __s = 115;
private static final byte __LeftB = 123;
private static final byte __RightB = 125;
private static final String __NAN = "NAN";
private static final String __INF = "INF";
private static final String __NINF = "-INF";
private static final String charset="UTF-8";

public static String serialize(Object obj) {}


public static Object unserialize(String ss,int state){
return unserialize(ss, charset, state);
}

@SuppressWarnings("unchecked")
public static Object unserialize(String ss, String charset,int state){
ByteArrayInputStream stream =null;
try {
stream = new ByteArrayInputStream(ss.getBytes(charset));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
Object result = unserialize(stream, charset, state);
return result;
}

@SuppressWarnings("unchecked")
private static Object unserialize(ByteArrayInputStream stream, String charset,int state) {
switch (stream.read()) {
case __N:
return readNull(stream);
case __b:
return readBoolean(stream);
case __i:
return readInteger(stream);
case __d:
return readDouble(stream);
case __s:
return readString(stream, charset);
case __U:
return readUnicodeString(stream);
case __a:
return readArray(stream, charset, state);
default:
System.out.println("Serializer.unserialize: The DataType Is invalid,state="+state);
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 = stream.read() == __1;
stream.skip(1);
return b;
}
private static Number readInteger(ByteArrayInputStream stream) {
stream.skip(1);
String i = readNumber(stream);
return Integer.parseInt(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);
}
if ((d.indexOf('.') > 0) || (d.indexOf('e') > 0) || (d.indexOf('E') > 0)) {
return new Double(d);
}
int len = d.length();
char c = d.charAt(0);
if ((len < 19) || ((c == '-') && (len < 20))) {
return new Long(d);
}
if ((len > 20) || ((c != '-') && (len > 19))) {
return new Double(d);
}
try {
return new Long(d);
}
catch (Exception e) {
return new Double(d);
}
}

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);
stream.skip(2);
try {
return new String(buf, charset);
} catch (Exception e) {
return new String(buf);
}
}

private static String readUnicodeString(ByteArrayInputStream stream) {
stream.skip(1);
int len = Integer.parseInt(readNumber(stream));
stream.skip(1);
StringBuffer sb = new StringBuffer(len);
int c;
for (int i = 0; i < len; i++) {
if ((c = stream.read()) == __Slash) {
char[] chs=new char[4];
chs[0] = (char) stream.read();
chs[1] = (char) stream.read();
chs[2] = (char) stream.read();
chs[3] = (char) stream.read();
sb.append((char) (Integer.parseInt(new String(chs), 16)));
}
else {
sb.append((char) c);
}
}
stream.skip(2);
return sb.toString();
}

@SuppressWarnings("unchecked")
private static Object readArray(ByteArrayInputStream stream, String charset,int state) {
stream.skip(1);
int n = Integer.parseInt(readNumber(stream));
stream.skip(1);
Map map = null;
List list = null;
if(state==0){
list=new ArrayList(n);
state=-1;
}else if(state==1){
map=new TreeMap();
}else {
map=new HashMap(n);
}

for (int i = 0; i < n; i++) {
Object key;
switch (stream.read()) {
case __i:
key = readInteger(stream);
break;
case __s:
key = readString(stream, charset);
break;
case __U:
key = readUnicodeString(stream);
break;
default:
return null;
}
Object result = unserialize(stream, charset, state);
if (list != null) {
if ((key instanceof Integer) && (((Integer) key).intValue() == i)) {
list.add(result);
} else {
list = null;
}
}else{
map.put(key, result);
}
}
stream.skip(1);
if (list != null) {
return list;
}else{
return map;
}
}
}

数据库里面的ByteArrayInputStream是下面样子:
a:2:{i:1;a:3:{s:5:\"title\";s:6:\"威望\";s:12:\"showinthread\";s:0:\"\";s:9:\"available\";s:1:\"1\";}i:2;a:3:{s:5:\"title\";s:6:\"金钱\";s:12:\"showinthread\";s:0:\"\";s:9:\"available\";s:1:\"1\";}}

请问下这个类的最后一个方法中的 stream.skip(1);是什么意思，对上面字节流读取后是Map类还是List类。谢谢啊

[Jlins]

skip 就是跳过多少个byte的意思