精华内容
下载资源
问答
  • java list序列化

    2012-04-21 10:29:00
    编图书馆的时候用了很多ArrayList,发现了反序列化后出现了如下问题:序列化前两个ArrayList中的某一元素指向同一对象,经过序列化再反序列化过程后,他们居然指向了不同对象,出现了不同步的问题,那是为什么呢?...

    编图书馆的时候用了很多ArrayList,发现了反序列化后出现了如下问题:序列化前两个ArrayList中的某一元素指向同一对象,经过序列化再反序列化过程后,他们居然指向了不同对象,出现了不同步的问题,那是为什么呢?

    查看一下Java.util里面的ArrayList源代码,发现ArrayList 重写了writeObject方法和readObject方法:

    /**

    * Save the state of the <tt>ArrayList</tt> instance to a stream (that

    * is, serialize it).

    *

    *@serialDataThe length of the array backing the <tt>ArrayList</tt>

    * instance is emitted (int), followed by all of its elements

    * (each an <tt>Object</tt>) in the proper order.

    */

    privatevoidwriteObject(java.io.ObjectOutputStream s)

    throwsjava.io.IOException{

    // Write out element count, and any hidden stuff

    intexpectedModCount = modCount;

    s.defaultWriteObject();

    // Write out array length

    s.writeInt(elementData.length);

    // Write out all elements in the proper order.

    for(inti=0; i<size; i++)

    s.writeObject(elementData[i]);

    if(modCount != expectedModCount) {

    thrownewConcurrentModificationException();

    }

    }

    /**

    * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,

    * deserialize it).

    */

    privatevoidreadObject(java.io.ObjectInputStream s)

    throwsjava.io.IOException, ClassNotFoundException {

    // Read in size, and any hidden stuff

    s.defaultReadObject();

    // Read in array length and allocate array

    intarrayLength = s.readInt();

    Object[] a = elementData =newObject[arrayLength];

    // Read in all elements in the proper order.

    for(inti=0; i<size; i++)

    a[i] = s.readObject();

    }

    经过分析源代码以及实践证明:像Arraylist之类的引用序列化仍然是有效的,但是序列化之前ArrayList中指向同一对象的引用经过序列化和反序列化之后,这个关系将被破坏,即他们不再指向同一个对象,而是指向了两个不同的对象。原因在于序列化的时候是直接把Arraylist中每个元素指向的对象写到文件中,反序列化时再一一读出。这点值得大家在编程的时候注意。

    展开全文
  • Java List序列化的实现

    千次阅读 2019-02-19 22:27:00
    概述 java中的序列化与反序列化都要求对象实现Serializable接口(其实就是声明一下),而对于List这种动态改变的集合默认是不实现这个接口的,也就是不能直接序列化。但是数组是可以序列化的,所以我们只需要将List...

    概述
    java中的序列化与反序列化都要求对象实现Serializable接口(其实就是声明一下),而对于List这种动态改变的集合默认是不实现这个接口的,也就是不能直接序列化。但是数组是可以序列化的,所以我们只需要将List集合与数组进行转换就可以实现序列化与反序列化了。

    序列化
    Object对象

    public class TestObject implements Serializable{

    private String name;
    private String address;

    public String getName() {
    return name;
    }
    public void setName(String name) {
    this.name = name;
    }
    public String getAddress() {
    return address;
    }
    public void setAddress(String address) {
    this.address = address;
    }

    }

    实例化对象,加点数据,然后执行序列化

    public class Test {

    public static void main(String[] args)
    {
    //创建要序列化的集合对象
    List<TestObject> list = new ArrayList<>();
    //加数据
    for (int i = 0; i < 5; i++)
    {
    TestObject testObject = new TestObject();
    testObject.setName("MJJ-"+i);
    testObject.setAddress("HangZhou");
    list.add(testObject);
    }

    File file = new File("object.adt");
    try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file)))
    {
    //将List转换成数组
    TestObject[] obj = new TestObject[list.size()];
    list.toArray(obj);
    //执行序列化存储
    out.writeObject(obj);
    }
    catch (IOException e)
    {
    e.printStackTrace();
    }
    }
    }


    反序列化
    public class Test {

    public static void main(String[] args)
    {
    File file = new File("object.adt");
    try (ObjectInputStream out = new ObjectInputStream(new FileInputStream(file)))
    {
    //执行反序列化读取
    TestObject[] obj = (TestObject[]) out.readObject();
    //将数组转换成List
    List<TestObject> listObject = Arrays.asList(obj);
    }
    catch (IOException e)
    {
    e.printStackTrace();
    }
    catch (ClassNotFoundException e)
    {
    e.printStackTrace();
    }
    }
    }


    封装
    利用泛型把序列化和反序列化的方法封装起来,方便使用。

    工具类
    public class StreamUtils {

    /**
    * 序列化,List
    */
    public static <T> boolean writeObject(List<T> list,File file)
    {
    T[] array = (T[]) list.toArray();
    try(ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file)))
    {
    out.writeObject(array);
    out.flush();
    return true;
    }
    catch (IOException e)
    {
    e.printStackTrace();
    return false;
    }
    }

    /**
    * 反序列化,List
    */
    public static <E> List<E> readObjectForList(File file)
    {
    E[] object;
    try(ObjectInputStream out = new ObjectInputStream(new FileInputStream(file)))
    {
    object = (E[]) out.readObject();
    return Arrays.asList(object);
    }
    catch (IOException e)
    {
    e.printStackTrace();
    }
    catch (ClassNotFoundException e)
    {
    e.printStackTrace();
    }
    return null;
    }
    }


    使用工具类
    //序列化
    StreamUtils.<TestObject>writeObject(list, new File("object.adt"));
    //反序列化
    List<TestObject> re = StreamOfByte.<TestObject>readObjectForList(new File("object.txt"));
    ---------------------
    作者:M家杰
    来源:CSDN
    原文:https://blog.csdn.net/tyzlmjj/article/details/50332815
    版权声明:本文为博主原创文章,转载请附上博文链接!

    转载于:https://www.cnblogs.com/renjiaqi/p/10403783.html

    展开全文
  • 序列化 json对象 ----------- JSONObject -------JSONObject.toJSONString(str); 解析:JSONObject.parseArray(str,T.class);  list<T> 序列化 json数组 ----------- JSONArray -------J...

       list<T> 序列化   json对象   ----------- JSONObject -------JSONObject.toJSONString(str);  解析:JSONObject.parseArray(str,T.class);

       list<T> 序列化   json数组   ----------- JSONArray -------JSONArray.toJSONString(str);    解析; JSONArray.parseArray

    转载于:https://www.cnblogs.com/xdcr/p/7273687.html

    展开全文
  • 系列对象 public static <T> byte[] enSeri(T obj) { Class<T> cls = (Class<T>) obj.getClass(); LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE); .....

    系列化对象

    public static <T> byte[] enSeri(T obj) {
    	    Class<T> cls = (Class<T>) obj.getClass();
    	    LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
    	    try {
    	        Schema<T> schema = getSchema(cls);
    	        return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
    	    } catch (Exception e) {
    	        throw new IllegalStateException(e.getMessage(), e);
    	    } finally {
    	        buffer.clear();
    	    }
    	}
    

    反序列化对象

    public static <T> T deSeri(byte[] data, Class<T> cls) {
    	    try {
    	        T message = objenesis.newInstance(cls);
    	        Schema<T> schema = getSchema(cls);
    	        ProtostuffIOUtil.mergeFrom(data, message, schema);
    	        return message;
    	    } catch (Exception e) {
    	        throw new IllegalStateException(e.getMessage(), e);
    	    }
    	}
    	private static Objenesis objenesis = new ObjenesisStd(true);
    	private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<>();
    
    	private static <T> Schema<T> getSchema(Class<T> cls) {
    	    Schema<T> schema = (Schema<T>) cachedSchema.get(cls);
    	    if (schema == null) {
    	        schema = RuntimeSchema.createFrom(cls);
    	        if (schema != null) {
    	            cachedSchema.put(cls, schema);
    	        }
    	    }
    	    return schema;
    	}
    

    序列化List集合

    private static <T> byte[] enSeriList(List<T> list) throws RuntimeException, IOException {
    		if (list == null || list.size() == 0) {
    			throw new RuntimeException("集合不能为空!");
    		}
    		@SuppressWarnings("unchecked")
    		RuntimeSchema<T> schema = (RuntimeSchema<T>) RuntimeSchema.getSchema(list.get(0).getClass());
    		ByteArrayOutputStream out = new ByteArrayOutputStream();
    		ProtostuffIOUtil.writeListTo(out, list, schema, LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
    		byte[] byteArray = out.toByteArray();
    		return byteArray;
    	}
    

    反序列化List集合

    private static <T> List<T> deSeriList(byte[] data, Class<T> clazz) throws IOException {
    		if (data == null || data.length == 0) {
    			return null;
    		}
    		RuntimeSchema<T> schema = RuntimeSchema.createFrom(clazz);
    		List<T> result = ProtostuffIOUtil.parseListFrom(new ByteArrayInputStream(data), schema);
    		return result;
    	}
    
    展开全文
  • java gson 序列化和反序列化 一、序列化 import com.google.gson.reflect.TypeToken; JsonObject jsonObject=new JsonObject(); jsonObject.addProperty("key","value") //字符串 //也可以是由set转jsonArray 将下方...
  • 对象序列化 序列化:将对象的状态存储到特定存储介质中的过程 实现对象序列化 使用reader读取文件内容 ...序列化存储集合list 修改文件
  • java序列化php序列化的对象 1、原始数据为一个字符串 2、原始数据为一个对象 3、原始数据为一个集合(List 或Map) 1、反序列化为java字符串 s:21:"这是一个字符串"; String str = "s:21:\"这是一个字符...
  • 某些情况下序列化实例类型不仅仅局限于单JavaBean个对象,还有很多其他如Map、list、int、boolean等类型。 九、自定义序列化 十、子类序列化 十一、序列化ID 序列化ID=属性名+时间戳,反序列化的前提
  • Java对象序列化成字符串和反序列化

    千次阅读 2015-05-24 22:31:41
    1、序列化序列化后保存在一个字符串变量中 package com.lxh.ser.test; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; import java.util.ArrayList; ...
  • 使用序列化流实现对List的深拷贝 深拷贝 为新的对象重新开辟一个内存空间,拷贝原有对象的数据结构和值;新的对象的值修改不会涉及原对象的值(请注意性能问题)。 实现序列化拷贝的条件 实体对象实现...
  • java序列化和反序列化

    2020-07-24 09:12:49
    //序列化 ObjectMapper objectMapper = new ObjectMapper(); String jsonStr = objectMapper.writeValueAsString(list); System.out.println(jsonStr); //反序列化 List<Video> temp = objectMapper....
  • //实现序列化必须实现的接口,这就是一个空接口,起到标识的作用 import java.io.Serializable; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.io.*; //电影类型 ...
  • 用的是上文list和map的Classes类,把Classes实例化的对象序列化,写入名为"FileTest"的文件。这个文件如果不存在,会自动创建。下面是代码演示。 package com.app.listmap; import java.io.FileInputStream; ...
  • Java序列化与反序列化

    2015-12-31 15:56:43
    近期将ehcache迁移到redis时,通过jedis访问服务端,需要将 普通实体类、Map 、list存到缓存里,而jedis仅仅支持String,byte[]两种,因此想到把 普通实体类、Map 、list进行序列化方便存储,然后再反序列化从缓存中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,272
精华内容 508
关键字:

javalist序列化

java 订阅