Java 如何将对象的ArrayList（ArrayList）转换为字节数组？

我目前有一个java程序，需要在客户端和服务器之间进行快速通信。在尝试了TCP和RMI之后，我决定使用UDP，这两种协议对我来说都太慢了

我有多个ArrayList存储在一个ArrayList中，然后将其发送到服务器。此方法在TCP和RMI中运行良好，但在UDP中需要将其更改为字节

ArrayList<Object> array = new ArrayList<Object>();
array.add(arrayList1);
array.add(arrayList2);
array.add(arrayList3);
array.add(arrayList4);
array.add(arrayList5);
array.add(arrayList6);

// Convert the ArrayList to bytes, then send to client

ArrayList数组=新的ArrayList（）；
add（arrayList1）；
add（arrayList2）；
add（arrayList3）；
add（arrayList4）；
array.add（arrayList5）；
add（arrayList6）；
//将ArrayList转换为字节，然后发送到客户端

添加到发送到客户端的ArrayList中的每个ArrayList都包含对象，每个ArrayList都包含不同类型的对象。大多数ArrayList包含由我创建的类生成的对象，但我认为没有必要显示它们

我在internet上搜索了将ArrayList中的ArrayList转换为字节的答案，但是.getBytes（）方法对ArrayList或其中的对象不起作用

如果您需要更多我正在使用的代码示例，请随时询问。上面的代码不是我真正的代码（因为对ArrayList进行编号会非常混乱），但它准确地表示了我试图实现的目标

多谢各位

这是你的解决方案

对于RMI，我就是这样做的

在客户看来

import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.ArrayList;
import javax.swing.table.DefaultTableModel;

public interface InterfaceUsuario extends Remote {   
  public ArrayList< User >getList() throws RemoteException;     
}

InterfaceUser or;
        or = (InterfaceUser)Naming.lookup ("or");            
ArrayList listUser = or.getList();

在服务器的视图中

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

private Session sesion;
private Transaction tx;

public class UserDAO {

public ArrayList<User> getListUser() throws Exception {
ArrayList<User> listContacts = null;  

try 
{ 
    sesion = HibernateUtil.getSessionFactory().openSession();
    tx = sesion.beginTransaction();
    listContacts = (ArrayList<User>) sesion.createQuery("from   User").list();           


}finally 
{ 
    sesion.close(); 
}  

return listContacts; 
}
}
}

import org.hibernate.hibernateeexception；
导入org.hibernate.Session；
导入org.hibernate.Transaction；
非公开会议；
私人交易；
公共类UserDAO{
公共ArrayList getListUser（）引发异常{
ArrayList listContacts=null；
尝试
{ 
sesion=HibernateUtil.getSessionFactory（）.openSession（）；
tx=sesion.beginTransaction（）；
listContacts=（ArrayList）sesion.createQuery（“来自用户”）.list（）；
}最后
{ 
sesion.close（）；
}  
返回列表联系人；
}
}
}

要在UDP中执行此操作，应该是这样的：

鉴于服务器：

public static byte[] serialize(Object obj) throws IOException {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    ObjectOutputStream os = new ObjectOutputStream(out);
    os.writeObject(obj);
    return out.toByteArray();
}
    public static Object deserialize(byte[] data) throws IOException,   ClassNotFoundException {
    ByteArrayInputStream in = new ByteArrayInputStream(data);
    ObjectInputStream is = new ObjectInputStream(in);
    return is.readObject();
}
public static void main(String[] args) {
    new Server();
    byte[] receiveData = new byte[65536];
    byte[] sendData = new byte[65536];
    try (DatagramSocket datagramSocket = new DatagramSocket(3333);) {
        Board.start = true;
        while (true) {
            try {
                DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
                datagramSocket.receive(receivePacket);
                ArrayList<Object> object1 = (ArrayList)deserialize(receivePacket.getData());
                InetAddress address = receivePacket.getAddress();
                int port = receivePacket.getPort();
                ArrayList<Object> array = new ArrayList<Object>();
                array.add(arrayList1);
                array.add(arrayList2);
                array.add(arrayList3);
                array.add(arrayList4);
                array.add(arrayList5);
                array.add(arrayList6);
                sendData = serialize(array);
                DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, address, port);
                datagramSocket.send(sendPacket);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }



        }

    } catch (IOException e) {
        e.printStackTrace();
    }
}

publicstaticbyte[]序列化（objectobj）引发IOException{
ByteArrayOutputStream out=新建ByteArrayOutputStream（）；
ObjectOutputStream os=新的ObjectOutputStream（输出）；
os.writeObject（obj）；
return out.toByteArray（）；
}
公共静态对象反序列化（字节[]数据）引发IOException，ClassNotFoundException{
ByteArrayInputStream in=新的ByteArrayInputStream（数据）；
ObjectInputStream is=新的ObjectInputStream（in）；
返回值为.readObject（）；
}
公共静态void main（字符串[]args）{
新服务器（）；
字节[]接收数据=新字节[65536]；
字节[]sendData=新字节[65536]；
try（DatagramSocket-DatagramSocket=newdatagramsocket（3333）；）{
Board.start=true；
while（true）{
试一试{
DatagramPacket receivePacket=新的DatagramPacket（receiveData，receiveData.length）；
datagramSocket.receive（接收数据包）；
ArrayList object1=（ArrayList）反序列化（receivePacket.getData（））；
InetAddress地址=receivePacket.getAddress（）；
int port=receivePacket.getPort（）；
ArrayList数组=新的ArrayList（）；
add（arrayList1）；
add（arrayList2）；
add（arrayList3）；
add（arrayList4）；
array.add（arrayList5）；
add（arrayList6）；
sendData=序列化（数组）；
DatagramPacket sendPacket=新的DatagramPacket（sendData，sendData.length，address，port）；
数据包发送（sendPacket）；
}catch（classnotfounde异常）{
e、 printStackTrace（）；
}
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}

鉴于客户：

public static byte[] serialize(Object obj) throws IOException {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    ObjectOutputStream os = new ObjectOutputStream(out);
    os.writeObject(obj);
    return out.toByteArray();
}
public static Object deserialize(byte[] data) throws IOException, ClassNotFoundException {
    ByteArrayInputStream in = new ByteArrayInputStream(data);
    ObjectInputStream is = new ObjectInputStream(in);
    return is.readObject();
}
public static void main(String[] args) {
    new Client();
    try {
        DatagramSocket clientSocket = new DatagramSocket();
        byte[] sendData = new byte[65536];
        byte[] receiveData = new byte[65536];

        while (true) {
            try {
                ArrayList<Object> fromUser = new ArrayList<Object>();
                fromUser.add(arrayList1);
                fromUser.add(arrayList2);
                sendData = serialize(fromUser);
                InetAddress address = InetAddress.getByName("localhost");
                DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, address, 3333);
                clientSocket.send(sendPacket);

                DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
                clientSocket.receive(receivePacket);
                ArrayList<Object> object = (ArrayList)deserialize(receivePacket.getData());
                arrayList1 = (ArrayList<Object>)object.get(0);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }   
        }
    } catch (UnknownHostException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    } catch (IOException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
}

publicstaticbyte[]序列化（objectobj）引发IOException{
ByteArrayOutputStream out=新建ByteArrayOutputStream（）；
ObjectOutputStream os=新的ObjectOutputStream（输出）；
os.writeObject（obj）；
return out.toByteArray（）；
}
公共静态对象反序列化（字节[]数据）引发IOException，ClassNotFoundException{
ByteArrayInputStream in=新的ByteArrayInputStream（数据）；
ObjectInputStream is=新的ObjectInputStream（in）；
返回值为.readObject（）；
}
公共静态void main（字符串[]args）{
新客户机（）；
试一试{
DatagramSocket clientSocket=新DatagramSocket（）；
字节[]sendData=新字节[65536]；
字节[]接收数据=新字节[65536]；
while（true）{
试一试{
ArrayList fromUser=新建ArrayList（）；
添加（arrayList1）；
添加（arrayList2）；
sendData=序列化（fromUser）；
InetAddress=InetAddress.getByName（“localhost”）；
DatagramPacket sendPacket=新的DatagramPacket（sendData，sendData.length，address，3333）；
clientSocket.send（sendPacket）；
DatagramPacket receivePacket=新的DatagramPacket（receiveData，receiveData.length）；
clientSocket.receive（receivePacket）；
ArrayList对象=（ArrayList）反序列化（receivePacket.getData（））；
ArrayList 1=（ArrayList）对象。获取（0）；
}catch（classnotfounde异常）{
e、 printStackTrace（）；
}   
}
}捕获（未知后异常e1）{
//TODO自动生成的捕捉块
e1.printStackTrace（）；
}捕获（IOE1异常）{
//TODO自动生成的捕捉块
e1.printStackTrace（）；
}
}

我发现此解决方案适用于Java UDP，使用序列化方法

public static byte[] serialize(Object obj) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream os = new ObjectOutputStream(out);
os.writeObject(obj);
return out.toByteArray();
}
public static Object deserialize(byte[] data) throws IOException,   ClassNotFoundException {
ByteArrayInputStream in = new ByteArrayInputStream(data);
ObjectInputStream is = new ObjectInputStream(in);
return is.readObject();
}

发送ArrayList

ArrayList<Object> array = new ArrayList<Object>();
array.add(arrayList1);
array.add(arrayList2);
array.add(arrayList3);
array.add(arrayList4);

sendData = serialize(array);
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, address, port);
datagramSocket.send(sendPacket);

ArrayList数组=新的ArrayList（）；
add（arrayList1）；
DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
clientSocket.receive(receivePacket);
ArrayList<Object> object = (ArrayList)deserialize(receivePacket.getData());
ArrayList<Object> arrayList = (ArrayList<Object>)object.get(0);