精华内容
下载资源
问答
  •  一般而言,要使得一个类可以序列化,只需简单实现java.io.Serializable接口即可(还要实现无参数的构造方法)。该接口是一个标记式接口,它本身不包含任何内容,实现了该接口则表示这个类准备支持序列化的功能。...
  • 废话不多说直接上代码 ... import org.springframework.stereotype.Component; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io....import java.io.ObjectOutputS

    废话不多说直接上代码

    package com.example.mq1.util;
    
    import org.springframework.stereotype.Component;
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    
    @Component
    public class ObjectAndByte {
    
        /**
         * 对象转数组
         * @param obj
         */
        public byte[] toByteArray (Object obj) {
            byte[] bytes = null;
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            try {
                ObjectOutputStream oos = new ObjectOutputStream(bos);
                oos.writeObject(obj);
                oos.flush();
                bytes = bos.toByteArray ();
                oos.close();
                bos.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            return bytes;
        }
    
        /**
         * 数组转对象
         * @param bytes
         */
        public Object toObject (byte[] bytes) {
            Object obj = null;
            try {
                ByteArrayInputStream bis = new ByteArrayInputStream (bytes);
                ObjectInputStream ois = new ObjectInputStream (bis);
                obj = ois.readObject();
                ois.close();
                bis.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            } catch (ClassNotFoundException ex) {
                ex.printStackTrace();
            }
            return obj;
        }
    
    }
    
    
    展开全文
  • Java对象数组序列化序列化

    千次阅读 2014-12-05 22:56:41
    先创建一个Java Bean /**一个low的Java Bean*/ public class Box implements Serializable{ private int width; private int height; public Box(){ } public Box(int width,int height){ ...
    先创建一个Java Bean
    /**一个low的Java Bean*/
    public class Box implements Serializable{
    	private int width;
    	private int height;
    	
    	public Box(){
    		
    	}
    	
    	public Box(int width,int height){
    		this.width = width;
    		this.height = height;
    	}
    	
    	public void setWidth(int width){
    		this.width = width;
    	}
    	public void setHeight(int height){
    		this.height = height;
    	} 
    	
    	public int getWidth(){
    		return width;
    	}
    	
    	public int getHeight(){
    		return height;
    	}
    }
    

    一般都是直接把一个对象序列化,如果我们有多个同一个类的对象,那么可以将这多个对象存进一个数组中,这个数组可以时静态数组也可以是动态数组,因为数组本身也是一个对象,将这个数组对象进行序列化,最后反序列化的时候也将得到一个数组对象。
    public class SerializaToFlatFile {
    	public static void main(String[] args) throws Exception {
    		SerializaToFlatFile ser = new SerializaToFlatFile();
    		// 将Box对象数组存进动态数组ArrayList中
    		ArrayList
         
           array = new ArrayList
          
           ();
    		Box boxOne = new Box(816, 523);
    		Box boxTwo = new Box(823, 324);
    		Box boxThree = new Box(111, 222);
    		array.add(boxOne);
    		array.add(boxTwo);
    		array.add(boxThree);
    		// 序列化
    		ser(array);
    		// 反序列化
    		array = dSer();
    		// 反序列化后的处理
    		printObj(array);
    	}
    
    	/** 序列化 */
    	public static void ser(Object object) throws Exception {
    		FileOutputStream fos = new FileOutputStream("foo.ser");
    		ObjectOutputStream oos = new ObjectOutputStream(fos);
    		oos.writeObject(object);
    		oos.flush();
    		oos.close();
    
    	}
    
    	/** 反序列化 */
    	public static ArrayList
           
             dSer() throws Exception {
    		FileInputStream fis = new FileInputStream("foo.ser");
    		ObjectInputStream ois = new ObjectInputStream(fis);
    		ArrayList
            
              array = (ArrayList
             
              ) ois.readObject(); return array; } /** 反序列化后的处理 */ public static void printObj(ArrayList
              
                array) { for (int i = 0; i < array.size(); i++) { System.out.println("width = " + ((Box) array.get(i)).getWidth() + "\r\n" + "height = " + ((Box) array.get(i)).getHeight()); } } } 
              
             
            
           
          
         

    展开全文
  • 序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。一般将一个对象存储至一个储存媒介,例如档案或是记亿体缓冲等。在网络传输过程中,可以是字节或是XML等...这个相反的过程又称为反序列化
  • 1、json与java中的数组序列化序列化 /*json与java中的数组序列化序列化*/ @Test public void arrayBetweenJsonJava(){ Gson gson = new Gson(); /*把java中数组序列化为json形式*/ String[] src = {&...

    1、json与java中的数组序列化与反序列化

        /*json与java中的数组序列化与反序列化*/
        @Test
        public void arrayBetweenJsonJava(){
            Gson gson = new Gson();
            /*把java中数组序列化为json形式*/
            String[] src = {"a", "b", "c"};
            String json = gson.toJson(src);
            System.out.println("json : " + json);
    
            /*把json反序列化为java中的数组*/
            String[] fromJson = gson.fromJson(json, String[].class);
            System.out.println("java : " + Arrays.toString(fromJson));
        }

    运行程序,输出结果:

    json : ["a","b","c"]
    java : [a, b, c]

    2、json与java中集合序列化与反序列化

        /*json与java中集合序列化与反序列化*/
        @Test
        public void ListBetweenJsonJava(){
            Gson gson = new Gson();
            /*把集合序列化为json*/
            List<String> list = new ArrayList<String>();
            list.add("lzj");
            list.add("Bob");
            String json = gson.toJson(list);
            System.out.println("json : " + json);
    
            /*把json反序列化为集合*/
            List<String> fromJson = gson.fromJson(json, new TypeToken<List<String>>(){}.getType());
            System.out.println("java : " + fromJson);
        }

    运行程序,输出:

    json : ["lzj","Bob"]
    java : [lzj, Bob]

    3、json与java中的泛型序列化与反序列化

    public class Person<T> {
        private int id;
        private String name;
        private T age;
        /*省略set/get/toString*/
    }
        /*json与java中的泛型序列化与反序列化*/
        @Test
        public void extensiveTypeBetweenJsonJava(){
            Gson gson = new Gson();
            /*java中泛型序列化为json*/
            Person<Integer> person = new Person<Integer>();
            person.setId(1);
            person.setName("lzj");
            person.setAge(27);
            String json = gson.toJson(person);
            System.out.println("json : " + json);
    
            /*把json反序列化为json中的集合*/
            Person<Integer> fromJson = gson.fromJson(json, new TypeToken<Person<Integer>>(){}.getType());
            System.out.println("java : " + fromJson);
        }

    运行程序输出:

    json : {"id":1,"name":"lzj","age":27}
    java : Person [id=1, name=lzj, age=27]
    展开全文
  • Java中 byte[]数组序列化和fastjson序列化区别 Java中,对于对象可以通过序列化成byte数组或者序列化成json形式,这里做下两者的对比。 首先看下实现方式: 1 byte数组序列化 这里由两个方法,一个是对象序列...

    Java中 byte[]数组序列化和fastjson序列化区别

    Java中,对于对象可以通过序列化成byte数组或者序列化成json形式,这里做下两者的对比。

    首先看下实现方式:

    1 byte数组序列化

    这里由两个方法,一个是对象序列化为字节数组,一个是字节数组序列化为对象,这里需要注意的是对象的serialVersionUID 必须设置为一样才能序列化,否则哪怕两个类长得一模一样都会报错。

    private static byte[] ObjectToByte(Object obj) {
        byte[] bytes = null;
        try {
            // object to bytearray
            ByteArrayOutputStream bo = new ByteArrayOutputStream();
            ObjectOutputStream oo = new ObjectOutputStream(bo);
            oo.writeObject(obj);
    
    
            bytes = bo.toByteArray();
    
    
            bo.close();
            oo.close();
        } catch (Exception e) {
            System.out.println("translation" + e.getMessage());
            e.printStackTrace();
        }
        return bytes;
    }
    
    
    /**
     * byte转对象
     * @param bytes
     * @return
     */
    private static Object ByteToObject(byte[] bytes) {
        Object obj = null;
        try {
            // bytearray to object
            ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
            ObjectInputStream oi = new ObjectInputStream(bi);
    
    
            obj = oi.readObject();
            bi.close();
            oi.close();
        } catch (Exception e) {
            System.out.println("translation" + e.getMessage());
            e.printStackTrace();
        }
        return obj;
    }
    

    2 fastjson序列化

    这里选择了fastJson来序列化对象,实现方式如下:

    public static <T> T get(String data, Class<T> clazz) {
        T body = JSON.parseObject(data, clazz);
        return body;
    }
    
    
    public static String toJson(Object o) {
        return JSONObject.toJSONString(o);
    }
    

    fastJson实现方法比较简单。

    下面对性能进行了对比:

    类别1000次5000次10000次100000次1000000次
    byte数组82ms147ms213ms827ms5707ms
    fastJson114ms157ms146ms174ms412ms

    此数据来自i7 16g内存windows eclipse软件测试得来。

    可以看出来在大规模数据的情况下fastJson还是非常快的。

    展开全文
  • java对象序列化数组反序列化

    千次阅读 2014-05-23 11:33:59
    package serializable;...import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream;   public cl
  • 支持Java对象到字节数组序列化,和从字节数组Java对象的反序列化。 Maven:  <groupId>com.github.xsonorg</groupId>  <artifactId>xson-core  <version>1.0.1 支持的对象: 1.Java POJO对象 2.基本...
  • 数组 / 集合序列化 采用数组的形式 gson.fromJson(json, XXX[].class); 采用集合List的形式 gson.fromJson(json, new TypeToken&lt;XXX&gt;() {}.getType());2.基本类/** * 基本类 * @author ...
  • 遇到这个 Java Serializable 序列化这个接口,我们可能会有如下的问题a,什么叫序列化反序列化 b,作用。为啥要实现这个 Serializable 接口,也就是为啥要序列化 c,serialVersionUID 这个的值到底是在怎么设置的...
  • 极好的序列化与发序列化代码。可以处理array集合,数组或者单个对象等的序列化反序列化
  • 序列化过程中,其对象想要被序列化,那么它的类就要实现 此接口,这个对象的所有属性(包括private属性、包括其引用的对象)都可以被序列化反序列化来保存、传递。 比如:在本实例中,DivSort必须实现Serializable...
  • 如何使用Jackson来反序列化对象数组 Jackson数据绑定文档表明Jackson支持反序列化“所有受支持类型的数组”,但是我无法确定确切的语法。 对于单个对象,我可以这样做: //json input { "id" : "junk", ...
  • byte[]的写入和读取,为了就是存储对象,因为我们知道,Java中存储对象,我们可以利用集合List或者Set亦或者HashTable来存储,但是在redis中,想要存储对象,必须先序列化对象,反之,读取的时候,在将对象反序列化...
  • 当我们想要将数组值存储到数据库时,就可以对数组进行序列化操作,然后将序列化后的值存储到数据库中。...对PHP数组进行序列化和序列化操作...一、PHP数组序列化:serialize $arr = array('PHP','Java','Python','...
  • 场景:在某通讯场景中发送和接收的消息都是JSON字符串格式(这里不讨论那种格式对于通信更高效)。 其中payload是[]byte格式,在发送时将数据部分进行打包放入map,然后JSON.toJSONString(map);...
  • 对象序列化(serialization)和反序列化(deserialization)是将对象转化为便于传输的...java序列化就是将对象转化为字节流,以便在进程或网络之间进行传输,而在接收方,需要以相同的方式对字节流进行反序列化,...
  • 说到Java对象的序列化反序列化,我们首先想到的应该是Java的Serializable接口,这玩意在两个系统之间的DTO对象里面可能会用到,用于系统之间的数据传输。或者在RPC(远程方法调用)时可能会用到。 本文要说的是...
  • 最近在做SSH项目应用层缓存(redis+protobuf)时,遇到一个超级蛋疼的问题,Protostuff居然不支持序列化/反序列化数组、集合等对象,版本1.5.9。开始以为版本问题,升级到最新版1.6.0,仍然不能解决问题,最后参考...
  • JSON序列化反序列化用途,比如, (1)要求:本地有100个员工对象信息,如何把这100个员工的信息传递给另外一个系统? 方法:可以将100个员工的信息JSON序列化,然后传递给另外一个系统;另一个系统接受收后,...
  • } 3、反序 String jsonStr = "[{"channelId":"28f9cad5-7e12-449d-b857-fc2d4d4bd9d9","description":"张三、王五","channelTypeId":"2d92e906-e550-46c5-b95d-f8e855a45bf3"},{"channelId":"564a8339-ff19-4c6b-...
  • 公司以前的系统是用PHP写的,有些数据库字段是通过PHP的serialize()方法序列化之后存进数据库的,如下所示a:2:{i:0;a:2:{s:7:"orderid";s:2:"62";s:5:"level";i:1;}i:1;a:2:{s:7:"orderid";s:2:
  • 实现两个函数,分别用来序列化反序列化二叉树 思路 序列化:把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串,从而使得内存中简历起来的二叉树可以持久保存 反序列化:根据某种遍历方式得到的...
  • 常见的java序列化/反序列化几种类型

    千次阅读 2019-01-11 01:02:34
    Java序列化是指把Java对象转换为字节序列的过程,Java反序列化是指把字节序列恢复为Java对象的过程 主要有两种用途: 把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中; 在网络上传送对象的字节序列。...
  • 因此可以通过序列化储存java对象,再通过反序列化得到对象。 新建一个maven项目,添加相关的Jar包依赖。 <dependencies> <!-- https://mvnrepository.com/artifact/redis.clients/jedis --> ...
  • 本篇博客仅分析Thrift对象的序列化反序列化的字节数组,以及Thrift对象的序列化反序列化原理。其他源码分析会另开章节~ 1.准备工作 定义一个 Thrift 文件 struct Person { 1: required i32 age; 2: required ...
  • 主要介绍了JAVA基于SnakeYAML实现解析与序列化YAML,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 序列化——反序列化数组

    千次阅读 2016-11-01 13:23:24
    序列化——反序列化数组
  • 在深拷贝与浅拷贝中,提到可以采用「序列化反序列化」的方式来实现深拷贝,今天主要来填一下序列化的坑。 其中,序列化是一种对象持久化的手段,普遍应用于网络传输和远程方法调用(RMI)等场景中,建议关注。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 184,191
精华内容 73,676
关键字:

java实现数组序列化反序列化

java 订阅