1.反序列化java.io.EOFException
刚开始在反序列化流的时候，抛出了EOFException异常；
处理办法：
自定义类中有没有实现Serializable接口；
在反序列化流的时候需要将ovbject强转自定义类
Student obj = (Student) ois.readObject();
相关博文：https://blog.csdn.net/ysk_xh_521/article/details/77396696
并不一定正确，仅供参考，
2.byte保存数值超过127,如何存储？是否影响计算？不影响位运算，影响普通的数学运算.
byte short int long 等字符类型具体在计算机里保存数据的方式
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
byte：
- byte 数据类型是8位、有符号的，以二进制补码表示的整数；
- 最小值是 -128（-2^7）；
- 最大值是 127（2^7-1）；
- 默认值是 0；
- byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
- 例子：byte a = 100，byte b = -50。
short：
- short 数据类型是 16 位、有符号的以二进制补码表示的整数
- 最小值是 -32768（-2^15）；
- 最大值是 32767（2^15 - 1）；
- Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
- 默认值是 0；
- 例子：short s = 1000，short r = -20000。
int：
- int 数据类型是32位、有符号的以二进制补码表示的整数；
- 最小值是 -2,147,483,648（-2^31）；
- 最大值是 2,147,483,647（2^31 - 1）；
- 一般地整型变量默认为 int 类型；
- 默认值是 0 ；
- 例子：int a = 100000, int b = -200000。
long：
- long 数据类型是 64 位、有符号的以二进制补码表示的整数；
- 最小值是 -9,223,372,036,854,775,808（-2^63）；
- 最大值是 9,223,372,036,854,775,807（2^63 -1）；
- 这种类型主要使用在需要比较大整数的系统上；
- 默认值是 0L；
- 例子： long a = 100000L，Long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。
float：
- float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
- float 在储存大型浮点数组的时候可节省内存空间；
- 默认值是 0.0f；
- 浮点数不能用来表示精确的值，如货币；
- 例子：float f1 = 234.5f。
double：
- double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
- 浮点数的默认类型为double类型；
- double类型同样不能表示精确的值，如货币；
- 默认值是 0.0d；
- 例子：double d1 = 123.4。
boolean：
- boolean数据类型表示一位的信息；
- 只有两个取值：true 和 false；
- 这种类型只作为一种标志来记录 true/false 情况；
- 默认值是 false；
- 例子：boolean one = true。
char：
- char类型是一个单一的 16 位 Unicode 字符；
- 最小值是 \u0000（即为0）；
- 最大值是 \uffff（即为65,535）；
- char 数据类型可以储存任何字符；
- 例子：char letter = 'A';。
3.两个byte如何转char 移位操作
//char转化为byte
public static byte[] charToByte2(char c) {
byte[] b = new byte[2];
b[0] = (byte) ((c & 0xFF00) >> 8);
b[1] = (byte) (c & 0xFF);
return b;
}
//byte转换为char
public static char byteToChar(byte[] b) {
char c = (char) (((b[0] & 0xFF) << 8) | (b[1] & 0xFF));
return c;
}4.11位数字（电话）转BDC(6)
/**
* 12位 字符串电话转BCD[6]
* @param phone
* @return
*/
public static byte[] phoneToBytes(String phone) {
byte[] phoneBytes = new byte[6];
if (phone.length() != 12) return phoneBytes;
for (int i = 0; i < 12; i++)
{
int high = Integer.parseInt(phone.substring(i, 1));
i++;
int low = Integer.parseInt(phone.substring(i, 1));
phoneBytes[i] =(byte)(high*16+low);
}
return phoneBytes;
}
/**
* BCD[6] 转12位 String电话
* @param bytes
* @return
*/
public static String bytesToPhone(byte[] bytes) {
StringBuffer sb = new StringBuffer();
for (byte b : bytes) {
int high = (int) ((b & 0xF0) >> 4);
sb.append(high);
int low = (int) (b & 0x0F);
sb.append(low);
}
return sb.toString();
}5.序列化与反序列化操作，对应的对象头要加上一句：implements Serializable
//序列化
public static byte[] serialize(Object obj){
ObjectOutputStream obi=null;
ByteArrayOutputStream bai=null;
try {
bai=new ByteArrayOutputStream();
obi=new ObjectOutputStream(bai);
obi.writeObject(obj);
byte[] byt=bai.toByteArray();
return byt;
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
obi.close();
bai.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
//反序列化
public static Object unserizlize(byte[] data){
ObjectInputStream oii=null;
ByteArrayInputStream bis=null;
Object obj = null;
try {
bis=new ByteArrayInputStream(data);
oii=new ObjectInputStream(bis);
obj=oii.readObject();
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
oii.close();
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return obj;
}6.打印16进制的byte数组
public static void printByteData(byte[] data) {
for (byte b : data) {
System.out.print("0x");
if((b&0xF0)>>4==10)
System.out.print("A");
else if((b&0xF0)>>4==11)
System.out.print("B");
else if((b&0xF0)>>4==12)
System.out.print("C");
else if((b&0xF0)>>4==13)
System.out.print("D");
else if((b&0xF0)>>4==14)
System.out.print("E");
else if((b&0xF0)>>4==15)
System.out.print("F");
else
System.out.print((b&0xF0)>>4);
if((b&0x0F)==10)
System.out.print("A");
else if((b&0x0F)==11)
System.out.print("B");
else if((b&0x0F)==12)
System.out.print("C");
else if((b&0x0F)==13)
System.out.print("D");
else if((b&0x0F)==14)
System.out.print("E");
else if((b&0x0F)==15)
System.out.print("F");
else
System.out.print(b&0x0F);
System.out.print(" ");
}
System.out.println();
}7.java除法保留小数操作，把被除数强转double or float,如果没有这个操作，结果是个整数
long a= (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
return (double)a/(double)1000000; 保留多少位数据的操作。示例：保留两位小数：
public static void main(String[] args) throws ParseException {
int a=1099;
int b=93;
double f1 = new BigDecimal((float)a/b).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
System.out.println("ddd==="+f1);
}
public static void main(String[] args) throws ParseException {
int a=1099;
int b=93;
DecimalFormat df = new DecimalFormat("0.00");//格式化小数
String num = df.format((float)a/b);//返回的是String类型
System.out.println("ddd==="+num);
}8.对byte[]里出现的特殊数值进行的替换操作技巧 利用流操作 示例：
/**
* 对消息里出现的特殊byte 0x7e 0x7d进行转义
* @param msg 消息
* @return
*/
public static byte[] escapeCode(byte[] msg) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
for(int i=0;i<msg.length;i++) {
out.write(msg[i]);
if(i>0&&i<msg.length-1) {
if(msg[i]==0x7e) {
out.write(0x02);
}
if(msg[i]==0x7d) {
out.write(0x01);
}
}
}
return out.toByteArray();
}9.两个byte[] 合并
/**
* 两个byte[]数组合并
* @param data1
* @param data2
* @return
*/
public static byte[] addBytes(byte[] data1, byte[] data2) {
byte[] data3 = new byte[data1.length + data2.length];
System.arraycopy(data1, 0, data3, 0, data1.length);
System.arraycopy(data2, 0, data3, data1.length, data2.length);
return data3;
}10.建立连接后发现客户端（服务端）回传消息每次都一样，我们需要考虑接收流和发送流的问题。
11.每个操作完成时记住要关闭流，但是在某些情况下不一样。在TCP通信，接收完数据关闭流会导致socket关闭？尚不知道什么原因。如果有回传消息，流对象要在所有操作完毕后再关闭流对象。
12.流的清空操作 os.reset is.reset 有些时候并不好用？据说可以用BufferOutputStream,BufferInpputStream包装一下即可以？保持怀疑。
13.如何遍历key:value（key不是固定变量）这种结构的json数据。
参考操作：字符串截取获取key，再根据key获取value