序列化java.util.Enumeration

如何将

枚举对象序列化为文件，然后对其进行
反序列化？我试图将其转换为
ArrayList
，但此选项对我无效。我尝试了以下代码：

FileOutputStream fos            = null;
ObjectOutputStream outs         = null;
Enumeration<TreePath> stateEnum = com.jidesoft.tree.TreeUtils.saveExpansionStateByTreePath(tree);
ArrayList<TreePath> pathList    = new ArrayList<TreePath>();

while(stateEnum.hasMoreElements()){
    pathList.add(stateEnum.nextElement());
}
try {
    fos = new FileOutputStream(TREE_STATE_FILE);
    outs = new ObjectOutputStream(fos);
    outs.writeObject(pathList);
    outs.close();
} catch (IOException e) {
    _log.info("Failed to create " + TREE_STATE_FILE + " file: ", e);
}

FileOutputStream=null；
ObjectOutputStream outs=null；
枚举状态enum=com.jidesoft.tree.TreeUtils.saveExpansionStateByTreePath（树）；
ArrayList路径列表=新建ArrayList（）；
while（stateEnum.hasMoreElements（））{
add（stateEnum.nextElement（））；
}
试一试{
fos=新文件输出流（树状态文件）；
outs=新对象输出流（fos）；
outs.writeObject（路径列表）；
out.close（）；
}捕获（IOE异常）{
_log.info（“未能创建”+树状态文件+”文件：，e）；
}

但是当我尝试对它进行
序列化时，我得到了空值。
感谢您使用的代码TreePath也必须是可序列化的，因为pathList的元素是TreePath对象。
我不确定这是否是您的意思，但请看一下这段代码：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.NoSuchElementException;


@SuppressWarnings("unchecked")
public class SerializableEnumeration
   extends ArrayList
   implements Enumeration
{
   /** The serialVersionUID */
   private static final long serialVersionUID = 8678951571196067510L;
   private int index;

   public SerializableEnumeration () {
      index = 0;
   }

   public SerializableEnumeration (Collection c) {
      super(c);
      index = 0;
   }

   public SerializableEnumeration (int initialCapacity) {
      super(initialCapacity);
      index = 0;
   }

   public boolean hasMoreElements() {
      return (index < size());
   }

   public Object nextElement() throws NoSuchElementException
   {
      try {
         Object nextObj = get(index);
         index++;
         return nextObj;
      }
      catch (IndexOutOfBoundsException e) {
         throw new NoSuchElementException();
      }
   }

   private void writeObject(java.io.ObjectOutputStream out)
      throws java.io.IOException
   {
      // the only thing to write is the index field
      out.defaultWriteObject();
   }

   private void readObject(java.io.ObjectInputStream in)
      throws java.io.IOException, ClassNotFoundException
   {
      in.defaultReadObject();
   }
}

import java.util.ArrayList；
导入java.util.Collection；
导入java.util.Enumeration；
导入java.util.NoSuchElementException；
@抑制警告（“未选中”）
公共类SerializableEnumeration
扩展ArrayList
实现枚举
{
/**SerialVersionId*/
私有静态最终长serialVersionUID=86789515711196067510L；
私有整数索引；
公共SerializableEnumeration（）{
指数=0；
}
公共SerializableEnumeration（集合c）{
超级（c）；
指数=0；
}
公共SerializableEnumeration（int initialCapacity）{
超级（初始容量）；
指数=0；
}
公共布尔值hasMoreElements（）{
返回（索引<大小（））；
}
public Object nextElement（）抛出NoTouchElementException
{
试一试{
对象nextObj=get（索引）；
索引++；
返回nextObj；
}
catch（IndexOutOfBoundsException e）{
抛出新的NoTouchElementException（）；
}
}
私有void writeObject（java.io.ObjectOutputStream-out）
抛出java.io.IOException
{
//唯一要写的是索引字段
out.defaultWriteObject（）；
}
私有void readObject（java.io.ObjectInputStream-in）
抛出java.io.IOException，ClassNotFoundException
{
in.defaultReadObject（）；
}
}

从IMO来看，
枚举的序列化实际上没有多大意义。
枚举
仅仅是数据结构或其他业务逻辑顶部的浮动视图。为了序列化，您最好坚持序列化备份接口。为了可视化我正在编写的内容，我设置了一个小代码段：

import java.io.*;
import java.util.*;

import javax.swing.tree.TreePath;

public class EnumTest {

  public class MyEnumerator<T> {

    // set holding data
    List<T> data;

    public MyEnumerator(List<T> data) {
      this.data = data;
    }

    public List<T> getData() {
      return data;
    }

    public Enumeration<T> enumerate() {
      return new Enumeration<T>() {
        transient int i = 0;

        @Override
        public boolean hasMoreElements() {
          return i < data.size();
        }

        @Override
        public T nextElement() {
          return data.get(i++);
        }
      };
    }
  }

  public EnumTest() throws Exception {
    List<TreePath> TreePaths = Arrays.asList(new TreePath[] { new TreePath("3"), new TreePath("4"), new TreePath("5") });
    MyEnumerator<TreePath> myEnum1 = new MyEnumerator<TreePath>(TreePaths);
    print(myEnum1);

    FileOutputStream fos = new FileOutputStream("test.out");
    ObjectOutputStream oos = new ObjectOutputStream(fos);
    oos.writeObject(myEnum1.getData());
    oos.close();
    fos.close();

    System.out.println("* Serialization complete");

    FileInputStream fis = new FileInputStream("test.out");
    ObjectInputStream ois = new ObjectInputStream(fis);
    @SuppressWarnings("unchecked")
    List<TreePath> data = (List<TreePath>) ois.readObject();
    MyEnumerator<TreePath> myEnum2 = new MyEnumerator<TreePath>(data);
    print(myEnum2);

    System.out.println("* Deserialization complete");
  }

  private void print(MyEnumerator<TreePath> myEnum1) {
    Enumeration<TreePath> enm = myEnum1.enumerate();
    while (enm.hasMoreElements()) {
      System.out.println(enm.nextElement());
    }
  }

  public static void main(String[] args) throws Exception {
    new EnumTest();
  }
}

import java.io.*；
导入java.util.*；
导入javax.swing.tree.TreePath；
公共类枚举测试{
公共类分子{
//设置保持数据
列出数据；
公共分子（列表数据）{
这个数据=数据；
}
公共列表getData（）{
返回数据；
}
公共枚举枚举（）{
返回新枚举（）{
瞬态积分i=0；
@凌驾
公共布尔值hasMoreElements（）{
返回i

这项工作围绕着序列化
枚举
本身的主题展开，方法是持久化包含的数据，然后重构包装类
MyEnumerator
。通过序列化/反序列化循环，您将得到一个不同的对象，但它在语义上是相同的。
我说的是java.util.Enumeration接口“此选项不适用于我”非常模糊。请详细说明您尝试了什么（使用代码示例）以及出现了什么问题。@Feras-Odeh，啊，对您来说太糟糕了：）@FerasOdeh:I get nulls到底是什么意思？您是否已验证是否已将所有内容正确复制到ArrayList？TreePath本身支持序列化吗？再次反序列化时会出现问题吗？是可序列化的。检查stateEnum的元素可能为null，或者TreePath的序列化被破坏，而写入null。如果您正在从另一个版本的swing中读取javax.swing.tree.TreePath对象，则Java文档中的此注释是相关的：“警告：此类的序列化对象将与将来的Swing版本不兼容。当前的序列化支持适用于运行同一版本Swing的应用程序之间的短期存储或RMI。从1.4开始，java.beans包中添加了对所有JavaBeansTM的长期存储的支持。请参阅XMLEncoder。“我已经检查了它是否被正确序列化。请检查我上面上传的示例。我试图理解为什么他在序列化时会得到多个空值。您的示例有效，所以我