Serializable与java.io.Serializable的区别
即使你没有用过对象序列化(serialization),你可能也知道它。但你是否知道 Java 还支持另外一种形式的对象持久化,外部化(externalization)?下面是序列化和外部化在代码级的关联方式:public interface Serializable {}public interface Externalizable extends Serializable {void readExternal(ObjectInput in);void writeExternal(ObjectOutput out);}序列化和外部化的主要区别外部化和序列化是实现同一目标的两种不同方法。下面让我们分析一下序列化和外部化之间的主要区别。通过Serializable接口对对象序列化的支持是内建于核心 API 的,但是java.io.Externalizable的所有实现者必须提供读取和写出的实现。Java 已经具有了对序列化的内建支持,也就是说只要制作自己的类java.io.Serializable,Java 就会试图存储和重组你的对象。如果使用外部化,你就可以选择完全由自己完成读取和写出的工作,Java 对外部化所提供的唯一支持是接口:voidreadExternal(ObjectInput in)void writeExternal(ObjectOutput out)现在如何实现readExternal() 和writeExternal() 就完全看你自己了。序列化会自动存储必要的信息,用以反序列化被存储的实例,而外部化则只保存被存储的类的标识。当你通过java.io.Serializable接口序列化一个对象时,有关类的信息,比如它的属性和这些属性的类型,都与实例数据一起被存储起来。在选择走Externalizable这条路时,Java 只存储有关每个被存储类型的非常少的信息。每个接口的优点和缺点Serializable接口? 优点:内建支持? 优点:易于实现? 缺点:占用空间过大? 缺点:由于额外的开销导致速度变比较慢Externalizable接口? 优点:开销较少(程序员决定存储什么)? 优点:可能的速度提升? 缺点:虚拟机不提供任何帮助,也就是说所有的工作都落到了开发人员的肩上。在两者之间如何选择要根据应用程序的需求来定。Serializable通常是最简单的解决方案,但是它可能会导致出现不可接受的性能问题或空间问题;在出现这些问题的情况下,Externalizable可能是一条可行之路。
java中,如果一个类A implements Serializable, 对该类的序列化过程的启动是自动的吗
java序列化的作用就是把存储在内存中的文件可以转存为文件的形式。实现Serializable这个接口就是一个标记,说明这个对象是可以序列化的一般Object.clone()就需要有序列化的标记。
java.io.NotSerializableException:
我已经解决了这个问题
java中有一个错误是说:serializable类NumberGame未声明类型为long的静态终态serialVersionUID字段
这个是警告吧,应该不是错误,楼主让eclipse给你自动生成一个就行了
什么时候一定要implement Serializable?
Serializable接口属于支持序列化的一个接口,只有一个实现它的对象可以被序列化工具存储和回复,也就是说方便对象类的存储,复制等。Serializable接口没有定义任何成员,只用来表示一个累可以被序列化,若该类可以序列化,那么它的所有子类都可以。 下面是关于序列化的一个实例: 程序名称:SerializationDemo.java 程序主题:实现对象的序列化和反序列化 程序说明:该程序由实例化一个MyClass类的对象开始,该对象有三个实例变量,类型分别为String、int、double,是希望存储和恢复的信息。 import java.io.*; public class SerializationDemo{ public static void main(String args[]){ //Object serialization try{ MyClass object1=new MyClass("Hello",-7,2.7e10); System.out.println("object1:"+object1); FileOutputStream fos=new FileOutputStream("serial"); ObjectOutputStream oos=new ObjectOutputStream(fos); oos.writeObject(object1); oos.flush(); oos.close(); } catch(Exception e){ System.out.println("Exception during serialization:"+e); System.exit(0); } //Object deserialization try{ MyClass object2; FileInputStream fis=new FileInputStream("serial"); ObjectInputStream ois=new ObjectInputStream(fis); object2=(MyClass)ois.readObject(); ois.close(); System.out.println("object2:"+object2); } catch(Exception e){ System.out.println("Exception during deserialization:"+e); System.exit(0); } } } class MyClass implements Serializable{ String s; int i; double d; public MyClass(String s,int i,double d){ this.s=s; this.i=i; this.d=d; } public String toString(){ return "s="+s+";i="+i+";d="+d; } } 程序运行结果:object1和object2的实例变量是一样的,输出如下: object1:s=Hello;i=-7;d=2.7E10 object2:s=Hello;i=-7;d=2.7E10
idea 怎么生成serializable
如果你implements 了 Serializable接口 但是没写 UID,eclipse会在你的类名边上有一个警告,你点击一下,有一个选项自动生成 UID,所以请用eclipse写java代码
serializable 类HI未声明类型为long的静态终态serialVersionUID字段
要运行的话,需要有main方法
继承serializable接口,必须重写hashcode和equals方法吗
hashCode 的常规协定是:在 Java 应用程序执行期间,在同一对象上多次调用 hashCode 方法时,必须一致地返回相同的整数,前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行,该整数无需保持一致。如果根据 equals(Object) 方法,两个对象是相等的,那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。以下情况不 是必需的:如果根据 equals(java.lang.Object) 方法,两个对象不相等,那么在两个对象中的任一对象上调用hashCode 方法必定会生成不同的整数结果。但是,程序员应该知道,为不相等的对象生成不同整数结果可以提高哈希表的性能。实际上,由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。(这一般是通过将该对象的内部地址转换成一个整数来实现的,但是 JavaTM 编程语言不需要这种实现技巧。)这么理解,在你调用equals()方法比较两个对象的时候,编译器会自动调用hashCode()来比较两个对象是否产生相同的整数结果.equals()返回true,则hashCode()必返回true.equals()返回false,则hashCode()必返回false.那么你重写equals()方法,肯定必须重写hashCode方法来保证二者的同步关系(暂且称这种关系为同步关系).
对象序列化除了实现serializable接口,还有什么方法
没有 当然也可以通过持久化来代替!
如果父类实现了Serializable并生成了serialVersionUID,而子类并没有写重新生成serialVersionUID的语句?
Android-added: Notes about serialVersionUID, using serialization judiciously, JSON.Serializability of a class is enabled by the class implementing the* java.io.Serializable interface. Classes that do not implement this* interface will not have any of their state serialized or* deserialized. All subtypes of a serializable class are themselves* serializable. The serialization interface has no methods or fields* and serves only to identify the semantics of being serializable. <p>翻译:实现Serializable 接口就能序列化。实现serializable的类的子类也是serializable的。这个序列化接口没有方法或者fields,只是语法标记为可以序列化上面说如果父类是序列化的,则子类也是序列化的,我们来做一个测试父类public class BaseBean implements Serializable { public static final int serialVersionUID = 1; public String property1; public String property2;}子类public class TestBean extends BaseBean { public String desc; @Override public String toString() { return "TestBean{" + "desc="" + desc + """ + ", property1="" + property1 + """ + ", property2="" + property2 + """ + "}"; }}测试 public void serialization(View view) { try { TestBean testBean = new TestBean(); testBean.property1 = "属性22882288"; testBean.property2 = "属性6666"; testBean.desc = "我是testbean"; ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("/sdcard/aaatest.txt")); objectOutputStream.writeObject(testBean); } catch (IOException e) { e.printStackTrace(); } } public void deserialization(View view) { ObjectInputStream objectInputStream = null; try { objectInputStream = new ObjectInputStream(new FileInputStream("/sdcard/aaatest.txt")); TestBean testBean = (TestBean) objectInputStream.readObject(); Log.i(TAG,"deserialization"+testBean.toString()); } catch (Exception e) { e.printStackTrace(); } }实测下来,可以正常序列化和反序列化,没有问题
内部类还需要实现serializable吗
在Android的Intent中传递实体的时候,需要对对象进行序列化,然后通过Bundle的putSerializable()、getSerializable()或者putParcelable()、getParcelable()方法实体存储和取出,方便我们在两个不同Activity之间传递实体,序列化的方式有:实现Parcelable、实现Serializable
Serializable接口被继承的时候为什么会有红线?我要导入什么还是创建什么?java新手求指导!!!
public class ss implements java.io.Serializable
C#里[]表示什么?比如[System.Serializable]
这是个很缠脚的问题。通俗点说,那做‘元数据"让C#编译器看的。。[System.Serializable]代表类序列化标记
请问在什么时候要用C#serializable
类需要序列化的时候
java里面Serializable long int 之间关系 又怎么互相转型
你想表达什么?long转intlong l = 111111l; int i = (int) l;Integer.parseInt()只能将String转换成int
Android Parcelable和Serializable的区别
1、作用Serializable的作用是为了保存对象的属性到本地文件、数据库、网络流、rmi以方便数据传输,当然这种传输可以是程序内的也可以是两个程序间的。而Android的Parcelable的设计初衷是因为Serializable效率过慢,为了在程序内不同组件间以及不同Android程序间(AIDL)高效的传输数据而设计,这些数据仅在内存中存在,Parcelable是通过IBinder通信的消息的载体。从上面的设计上我们就可以看出优劣了。2、效率及选择Parcelable的性能比Serializable好,在内存开销方面较小,所以在内存间数据传输时推荐使用Parcelable,如activity间传输数据,而Serializable可将数据持久化方便保存,所以在需要保存或网络传输数据时选择Serializable,因为android不同版本Parcelable可能不同,所以不推荐使用Parcelable进行数据持久化3、编程实现对于Serializable,类只需要实现Serializable接口,并提供一个序列化版本id(serialVersionUID)即可。而Parcelable则需要实现writeToParcel、describeContents函数以及静态的CREATOR变量,实际上就是将如何打包和解包的工作自己来定义,而序列化的这些操作完全由底层实现。
serializable这个接口内部什么也没有,实现它有什么意义?怎么就能标示他是可序列化?
一个对象序列化的接口,一个类只有实现了Serializable接口,它的对象才是可序列化的。因此如果要序列化某些类的对象,这些类就必须实现Serializable接口。而实际上,Serializable是一个空接口,没有什么具体内容,它的目的只是简单的标识一个类的对象可以被序列化。好处:a)比如说你的内存不够用了,那计算机就要将内存里面的一部分对象暂时的保存到硬盘中,等到要用的时候再读入到内存中,硬盘的那部分存储空间就是所谓的虚拟内存。在比如过你要将某个特定的对象保存到文件中,我隔几天在把它拿出来用,那么这时候就要实现Serializable接口;b)在进行java的Socket编程的时候,你有时候可能要传输某一类的对象,那么也就要实现Serializable接口;最常见的你传输一个字符串,它是JDK里面的类,也实现了Serializable接口,所以可以在网络上传输。c)如果要通过远程的方法调用(RMI)去调用一个远程对象的方法,如在计算机A中调用另一台计算机B的对象的方法,那么你需要通过JNDI服务获取计算机B目标对象的引用,将对象从B传送到A,就需要实现序列化接口。
Android Parcelable和Serializable的区别
Parcelable和Serializable的作用、效率、区别及选择:1、作用Serializable的作用是为了保存对象的属性到本地文件、数据库、网络流、rmi以方便数据传输,当然这种传输可以是程序内的也可以是两个程序间的。而Android的Parcelable的设计初衷是因为Serializable效率过慢,为了在程序内不同组件间以及不同Android程序间(AIDL)高效的传输数据而设计,这些数据仅在内存中存在,Parcelable是通过IBinder通信的消息的载体。从上面的设计上我们就可以看出优劣了。2、效率及选择Parcelable的性能比Serializable好,在内存开销方面较小,所以在内存间数据传输时推荐使用Parcelable,如activity间传输数据,而Serializable可将数据持久化方便保存,所以在需要保存或网络传输数据时选择Serializable,因为android不同版本Parcelable可能不同,所以不推荐使用Parcelable进行数据持久化3、编程实现对于Serializable,类只需要实现Serializable接口,并提供一个序列化版本id(serialVersionUID)即可。而Parcelable则需要实现writeToParcel、describeContents函数以及静态的CREATOR变量,实际上就是将如何打包和解包的工作自己来定义,而序列化的这些操作完全由底层实现。Parcelable的一个实现例子如下[java] view plaincopypublic class MyParcelable implements Parcelable { private int mData; private String mStr; public int describeContents() { return 0; } // 写数据进行保存 public void writeToParcel(Parcel out, int flags) { out.writeInt(mData); out.writeString(mStr); } // 用来创建自定义的Parcelable的对象 public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() { public MyParcelable createFromParcel(Parcel in) { return new MyParcelable(in); } public MyParcelable[] newArray(int size) { return new MyParcelable[size]; } }; // 读数据进行恢复 private MyParcelable(Parcel in) { mData = in.readInt(); mStr = in.readString(); } } 从上面我们可以看出Parcel的写入和读出顺序是一致的。如果元素是list读出时需要先new一个ArrayList传入,否则会报空指针异常。如下:list = new ArrayList<String>();in.readStringList(list); PS: 在自己使用时,read数据时误将前面int数据当作long读出,结果后面的顺序错乱,报如下异常,当类字段较多时务必保持写入和读取的类型及顺序一致。11-21 20:14:10.317: E/AndroidRuntime(21114): Caused by: java.lang.RuntimeException: Parcel android.os.Parcel@4126ed60: Unmarshalling unknown type code 3014773 at offset 1644、高级功能上Serializable序列化不保存静态变量,可以使用Transient关键字对部分字段不进行序列化,也可以覆盖writeObject、readObject方法以实现序列化过程自定义
Serializable接口怎么用?
public interface Serializable类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段,仅用于标识可序列化的语义。例如:当遍历一个图形时,可能会遇到不支持可序列化接口的对象。在此情况下,将抛出 NotSerializableException,并将标识不可序列化对象的类。在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法:private void writeObject(java.io.ObjectOutputStream out)throws IOExceptionprivate void readObject(java.io.ObjectInputStream in)throws IOException, ClassNotFoundException;writeObject 方法负责写入特定类的对象的状态,以便相应的 readObject 方法可以还原它。通过调用 out.defaultWriteObject 可以调用保存 Object 的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。简介如下:public interface Serializable类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段,仅用于标识可序列化的语义。要允许不可序列化类的子类型序列化,可以假定该子类型负责保存和还原超类型的公用 (public)、受保护的 (protected) 和(如果可访问)包 (package) 字段的状态。仅在子类型扩展的类(父类)有一个可访问的无参数构造方法来初始化该类的状态时,才可以假定子类型有此责任。如果不是这种情况,则声明一个类为可序列化类是错误的。该错误将在运行时检测到。在反序列化过程中,将使用该类的公用或受保护的无参数构造方法初始化不可序列化类的字段。可序列化的子类必须能够访问无参数的构造方法。可序列化子类的字段将从该流中还原。
serializable 怎么读
金山词霸上的答案是错的,可以查一下有道词典上的读音,英式发音的重读音节在第一个字节,美式发音的重读音节在第三个音节。
类继承了object类并实现了serializable这句话正确吗?
不正确serializable是一个attribute,不需要实现。
java的Serializable接口为什么没有接口方法?
在定义Serializable接口时,就没有定义任何的抽象方法,它只是作为对象序列化的一个标志而已,没有这个标志则该对象不能实现序列化与反序列化
、什么是java序列化,如何实现java序列化?或者请解 释Serializable接口的作用。
我们有时候将一个java 对象变成字节流的形式传出去或者从一个字节流中恢复成一个java 对象,例如,要将java 对象存储到硬盘或者传送给网络上的其他计算机,这个过程我们可以自己写代码去把一个java 对象变成某个格式的字节流再传输,但是,jre 本身就提供了这种支持,我们可以调用OutputStream的writeObject方法来做,如果要让java帮我们做,要被传输的对象必须实现serializable 接口,这样,javac 编译时就会进行特殊处理,编译的类才可以被writeObject方法操作,这就是所谓的序列化。需要被序列化的类必须实现Serializable 接口,该接口是一个mini 接口,其中没有需要实现的方法,implements Serializable只是为了标注该对象是可被序列化的。例如,在web 开发中,如果对象被保存在了Session 中,tomcat 在重启时要把Session对象序列化到硬盘,这个对象就必须实现Serializable接口。如果对象要经过分布式系统进行网络传输或通过rmi 等远程调用,这就需要在网络上传输对象,被传输的对象就必须实现Serializable接口。还有什么问题可以百度hi我
java里实现了Serializable接口,序列化是什么意思呢
有关java的问题,这里都有很详细的讲解,你可以参考一下,方法有很多参考资料:http://www.baidu.com/s?wd=%B1%B1%B7%E7%CD%F8&rsv_bp=0&rsv_spt=3&inputT=422
Java(JDK1.4) Serializable 的类型转换
int:Integerlong:Longjdk1.5自动装箱,int会自转换为Integer,而Integer是实现了Serializable的,所以可以。jdk1.4不自动装箱拆箱,所以要手动构造new Integer(int) new Long(long)/** * Constructs a newly allocated <code>Integer</code> object that * represents the <code>int</code> value indicated by the * <code>String</code> parameter. The string is converted to an * <code>int</code> value in exactly the manner used by the * <code>parseInt</code> method for radix 10. * * @param s the <code>String</code> to be converted to an * <code>Integer</code>. * @exception NumberFormatException if the <code>String</code> does not * contain a parsable integer. * @see java.lang.Integer#parseInt(java.lang.String, int) */ public Integer(String s) throws NumberFormatException { this.value = parseInt(s, 10); }
如何使用serializable传递list
Intent是Activity与Activity之间,Activity与Service之间传递参数的介质 Intent.putExtras(key, value)几乎可以包括各种类型的值,但是却没有类似List<Object>之类的传递参数 再加班无聊的时候,我试了试,发现可以把list强转成Serializable类型,然后通过putExtras(key, (Serializable)list)方法传递过去,接受的时候用(List<YourObject>) getIntent().getSerializable(key)就可以接受到List<YourObject>数据了 但是最重要的一点是:你的YourObject类必须要实现Serializable接口,切记切记,不然会报错,运行时异常(与parcel相关) 总结:保证你自己定义的类实现了Serializable接口,然后传递list的时候强转成Serializable类型,接受的时候再转换回来就可以了!
参数是Serializable类型,是什么意思
得这个不是一个接口吗?public interface Serializable类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段,仅用于标识可序列化的语义建议同
标记了Serializable() 为什么不能序列化?
这是什么新语法,传统的 Serializable 是:public class DeviceSession implements java.io.Serializable { ...}, 记得标记一个类可序列化之后,它的所有非 transient 和 static 的成员属性对应的类都需要是能够 Serializable 的,如果你并不打算把所有 非 static 字段序列化,那就把它标记为 transient .
怎样实现serializable接口
当遍历一个图形时,可能会遇到不支持可序列化接口的对象。在此情况下,将抛出 NotSerializableException,并将标识不可序列化对象的类。在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法:private void writeObject(java.io.ObjectOutputStream out)throws IOExceptionprivate void readObject(java.io.ObjectInputStream in)throws IOException, ClassNotFoundException;writeObject 方法负责写入特定类的对象的状态,以便相应的 readObject 方法可以还原它。通过调用 out.defaultWriteObject 可以调用保存 Object 的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。readObject 方法负责从流中读取并还原类字段。它可以调用 in.defaultReadObject 来调用默认机制,以还原对象的非静态和非瞬态字段。defaultReadObject 方法使用流中的信息来分配流中通过当前对象中相应命名字段保存的对象的字段。这用于处理类发展后需要添加新字段的情形。将对象写入流时需要指定要使用的替代对象的可序列化类,应使用准确的签名来实现此特殊方法:ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;此 writeReplace 方法将由序列化调用,前提是如果此方法存在,而且它可以通过被序列化对象的类中定义的一个方法访问。因此,该方法可以拥有私有 (private)、受保护的 (protected) 和包私有 (package-private) 访问。子类对此方法的访问遵循 java 访问规则。在从流中读取类的一个实例时需要指定替代的类应使用的准确签名来实现此特殊方法。ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;此 readResolve 方法遵循与 writeReplace 相同的调用规则和访问规则。序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联,该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同,则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 "serialVersionUID" 的字段(该字段必须是静态 (static)、最终 (final) 的 long 型字段)显式声明其自己的 serialVersionUID:ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;如果可序列化类未显式声明 serialVersionUID,则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值,如“Java(TM) 对象序列化规范”中所述。不过,强烈建议 所有可序列化类都显式声明 serialVersionUID 值,原因计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性,根据编译器实现的不同可能千差万别,这样在反序列化过程中可能会导致意外的 InvalidClassException。因此,为保证 serialVersionUID 值跨不同 java 编译器实现的一致性,序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修改器显示声明 serialVersionUID(如果可能),原因是这种声明仅应用于立即声明类 -- serialVersionUID 字段作为继承成员没有用处。--------------------------实现java.io.Serializable 接口的类是可序列化的。没有实现此接口的类将不能使它们的任一状态被序列化或逆序列化。序列化类的所有子类本身都是可序列化的。这个序列化接口没有任何方法和域,仅用于标识序列化的语意。允许非序列化类的子类型序列化,子类型可以假定负责保存和恢复父类型的公有的、保护的和(如果可访问)包的域的状态。只要该类(即父类)有一个无参构造子,可初始化它的状态,那么子类型就可承担上述职责;如果该类没有无参构造函数,在这种情况下申明一个可序列化的类是一个错误。此错误将在运行时被检测。例如:Integer实现了Serializable,所以可以把一个Integer的对象用IO写到文件里,之后再可以从文件里读出,如你开始写入的时候那个对象的intValue() 是5的话,那读出来之后也是5。这一点体现了用序化类的作用,即用来传送类的对象。当一个JavaBean在构造工具内被用户化,并与其它Bean建立连接之后,它的所有状态都应当可被保存,下一次被load进构造工具内或在运行时,就应当是上一次修改完的信息。为了能做到这一点,要把Bean的某些字段的信息保存下来,在定义Bean时要使它实现Java.io.Serializable接口。例如:public class Button implements Java.io.Serializable {……}实现了序列化接口的Bean中字段的信息将被自动保存。若不想保存某些字(这里的Bean中字段的信息将被自动保存是什么意思?这个自动保存是怎么实现的?)段的信息则可在这些字段前冠以transient或static关键字,transient和static变量的信息是不可被保存的。通常,一个Bean所有公开出来的属性都应当是被保存的,也可有选择地保存内部状态。Bean开发者在修改软件时,可以添加字段,移走对其它类的引用,改变一个字段的private、protected或public状态,这些都不影响类的存储结构关系。然而,当从类中删除一个字段,改变一个变量在类体系中的位置,把某个字段改成transient/static,或原来是transient/static,现改为别的特性时,都将引起存储关系的变化。所谓的Serializable,就是java提供的通用数据保存和读取的接口。至于从什么地方读出来和保存到哪里去都被隐藏在函数参数的背后了。这样子,任何类型只要实现了Serializable接口,就可以被保存到文件中,或者作为数据流通过网络发送到别的地方。也可以用管道来传输到系统的其他程序中。这样子极大的简化了类的设计。只要设计一个保存一个读取功能就能解决上面说得所有问题。
java 怎么对没有实现serializable 序列化
我们有时候将一个java 对象变成字节流的形式传出去或者从一个字节流中恢复成一个java 对象,例如,要将java 对象存储到硬盘或者传送给网络上的其他计算机,这个过程我们可以自己写代码去把一个java 对象变成某个格式的字节流再传输,但是,jre 本身就提供了这种支持,我们可以调用OutputStream的writeObject方法来做,如果要让java帮我们做,要被传输的对象必须实现serializable 接口,这样,javac 编译时就会进行特殊处理,编译的类才可以被writeObject方法操作,这就是所谓的序列化。需要被序列化的类必须实现Serializable 接口,该接口是一个mini 接口,其中没有需要实现的方法,implements Serializable只是为了标注该对象是可被序列化的。例如,在web 开发中,如果对象被保存在了Session 中,tomcat 在重启时要把Session对象序列化到硬盘,这个对象就必须实现Serializable接口。如果对象要经过分布式系统进行网络传输或通过rmi 等远程调用,这就需要在网络上传输对象,被传输的对象就必须实现Serializable接口。
java 里面实现serializable接口,就能序列化是什么意思,为什么实现了该接口就能实例化
类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段,仅用于标识可序列化的语义。要允许不可序列化类的子类型序列化,可以假定该子类型负责保存和恢复超类型的公用 (public)、受保护的 (protected) 和(如果可访问)包 (package) 字段的状态。仅在子类型扩展的类有一个可访问的无参数构造方法来初始化该类的状态时,才可以假定子类型有此职责。如果不是这种情况,则声明一个类为可序列化类是错误的。该错误将在运行时检测到。
java中,什么时候不能用Serializable
一般是关注什么时候需要用Serializable 换个角度吧...
serializable接口的作用
继承了serializable 就是表示这个类可以序列化使用序列化保存数据比直接写在文件里更有安全性 而且读取的时候处理也简单还有一个更重要的用途就是在rmi和ejb使用的时候 作为参数传递的对象必须是serializable的
java序列化为什么要实现serializable
不一定要 根据需求 序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作,也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现:将需要被序列化的类实现Serializable接口,该接口没有需要实现的方法,implements Serializable只是为了标注该对象是可被序列化的,然后使用一个输出流(如:FileOutputStream)来构造一个ObjectOutputStream(对象流)对象,接着,使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态),要恢复的话则用输入流。 序列化:序列化是将对象转换为容易传输的格式的过程。例如,可以序列化一个对象,然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。在另一端,反序列化将从该流重新构造对象。是对象永久化的一种机制。 确切的说应该是对象的序列化,一般程序在运行时,产生对象,这些对象随着程序的停止运行而消失,但如果我们想把某些对象(因为是对象,所以有各自不同的特性)保存下来,在程序终止运行后,这些对象仍然存在,可以在程序再次运行时读取这些对象的值,或者在其他程序中利用这些保存下来的对象。这种情况下就要用到对象的序列化。 只有序列化的对象才可以存储在存储设备上。为了对象的序列化而需要继承的接口也只是一个象征性的接口而已,也就是说继承这个接口说明这个对象可以被序列化了,没有其他的目的。之所以需要对象序列化,是因为有时候对象需要在网络上传输,传输的时候需要这种序列化处理,从服务器硬盘上把序列化的对象取出,然后通过网络传到客户端,再由客户端把序列化的对象读入内存,执行相应的处理。 对象序列化是java的一个特征,通过该特征可以将对象写作一组字节码,当在其他位置读到这些字节码时,可以依此创建一个新的对象,而且新对象的状态与原对象完全相同。为了实现对象序列化,要求必须能够访问类的私有变量,从而保证对象状态能够正确的得以保存和恢复。相应的,对象序列化API能够在对象重建时,将这些值还原给私有的数据成员。这是对java语言访问权限的挑战。通常用在服务器客户端的对象交换上面,另外就是在本机的存储。 对象序列化的最主要的用处就是在传递,和保存对象(object)的时候,保证对象的完整性和可传递性。譬如通过网络传输,或者把一个对象保存成一个文件的时候,要实现序列化接口
为什么实体类要实现serializable接口序列化
当客户端访问可以打开会话功能的资源时,web服务器会创建一个与客户端对应的HttpSession对象,每个HttpSession对象都会使用一定的内存空间。如果在一定时间内有大量用户访问网站,那么大量的HttpSession对象就会堆积在web服务器的内存中,这会消耗大量的服务器内存。即使用户已经离开或关闭了浏览器,web服务器仍然会保留相应的HttpSession对象,这将占用web服务器的内存资源,直到它们超时。 Web服务器通常会将那些暂时处于非活动状态但尚未超时的HttpSession对象传输到文件系统或数据库中进行存储,然后在服务器想要使用它们时将它们从文件系统或数据库加载到内存中。这项技术被称为会话持久性。 要将HttpSession对象保存到文件系统或数据库,需要将HttpSession对象中的每个属性对象序列化到文件系统或数据库。当从文件系统或数据库(如内存)加载HttpSession对象时,需要对其进行反序列化,以恢复HttpSession对象中的每个属性对象。因此,存储在HttpSession对象中的每个属性对象都必须实现Serializable接口。 简言之,就是为了 将对象的状态保存在存储媒体中以便可以在以后重新创建出完全相同的副本。实现 Serializable接口还能 按值将对象从一个应用程序域发送至另一个应用程序域。
java类实现serializable有什么好处或意义
是一个接口 当你想要序列化对象时就要实现这个接口 把方法都封装好了 你直接调用就好了
c# [Serializable]什么意思
~是析构,[Serializable]是可序列化
什么时候要用到Serializable呢
涉及到线程安全,继承一下比较好.
C#里serializable是什么意思?
序列化。将ojbect用字符的形式储存起来。
[Serializable]在C#中的作用是什么呀
申明自定义结构为可序列化,可以搜索一下关键词“序列化”,有很多相关的文章。
java序列化--java.io.Serializable接口解析
使用java以来 序列化随处可见 至于为什么要用序列化 序列化能解决什么问题 作为一个普通的码农 一般不怎么会去深入研究 由于最近在看mina和公司内部涉及到nio框架的一些源码 里面涉及到hession java这两种序列化 至于hession序列化为什么会诞生以及在apache项目中使用如此广泛 以及java本身序列化存在哪些缺陷 甚是不解 为了解答上面抛出来的疑惑 以及进一步了解java的序列化机制 这里开个小头 从java的序列化接口Serializable开始说起 jdk包里的Serializable接口的注释主要说明了以下几点 类通过实现Serializable接口来启用序列化 否则该类的任何状态将无法被序列化 同时也无法用于反序列化 若继承的父类没有实现Serializable接口 但是又想让子类可序列化 有三个注意事项 a) 子类实现Serializable接口 b) 子类必须有可访问的无参构造方法 用于保存和恢复父类的public或protected或同包下的package字段的状态 否则在序列化或反序列化时会抛出RuntimeException异常 c) 对于序列化后的子类 在进行反序列化时 理论上无法初始化父类中private(不可访问)对象变量的状态或值 在对可序列化类中的属性进行序列化时 如果遇到不可序列化的对象变量 此时会针对不可序列化的类抛出NotSerializableException异常 对于可序列化的非数组类 强烈建议显示声明static型 long型 final型serialVersionUID字段用于标识当前序列化类的版本号 否则在跨操作系统 跨编译器之间进行序列化和反序列化时容易出现InvalidClassException异常 对于可序列化类中的static transient对象变量 在序列化时无法保存其状态或值 static对象变量在反序列化时取得的值为当前jvm中对应类中对应static变量的值 而transient(瞬态)关键字则一般用于标识那些在序列化时不需要传递的状态变量 简单的测试代码 import java io FileInputStream import java io FileNotFoundException import java io FileOutputStream import java io IOException import java io ObjectInputStream import java io ObjectOutputStream import java io Serializable /** * 序列化测试 * * @author sume * */ public class SerializableImpl implements Serializable { private static final long serialVersionUID = L static String staticVal = static transient String transientVal = transient String val = val /** * main */ public static void main(String[] args) throws FileNotFoundException IOException ClassNotFoundException { // 序列化 SerializableImpl sila = new SerializableImpl() ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream( Serializable txt )) objectOutputStream writeObject(sila ) objectOutputStream close() // 反序列化 SerializableImpl staticVal = static ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream( Serializable txt )) SerializableImpl sila = (SerializableImpl) objectInputStream readObject() objectInputStream close() // 比较各个属性的值 System out println(sila staticVal) System out println(sila transientVal) System out println(sila val) } }输出结果 static null val 从输出结果可以看出 反序列化后类中static型变量staticVal的值为当前jvm中对应static变量的值 为 static 而不是序列化时的值 static transient关键字标识的变量的状态并没有在序列化中被保存 因此反序列化后 transientVal变量的值为null 第三个为常见的对象状态在序列化和反序列化过程中的传递 lishixinzhi/Article/program/Java/hx/201311/26282
某些java类为什么要实现Serializable接口
Serializable接口是启用其序列化功能的接口。实现java.io.Serializable接口的类是可序列化的。没有实现此接口的类将不能使它们的任一状态被序列化或逆序列化。使用情况:当遍历一个图形时,可能会遇到不支持可序列化接口的对象。在此情况下,将抛出NotSerializableException,并将标识不可序列化对象的类。在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法:privatevoidwriteObject(java.io.ObjectOutputStreamout)throwsIOExceptionprivatevoidreadObject(java.io.ObjectInputStreamin)throwsIOException,ClassNotFoundException;writeObject方法负责写入特定类的对象的状态,以便相应的readObject方法可以还原它。通过调用out.defaultWriteObject可以调用保存Object的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用writeObject方法或使用DataOutput支持的用于基本数据类型的方法将各个字段写入ObjectOutputStream来保存的。readObject方法负责从流中读取并还原类字段。它可以调用in.defaultReadObject来调用默认机制,以还原对象的非静态和非瞬态字段。defaultReadObject方法使用流中的信息来分配流中通过当前对象中相应命名字段保存的对象的字段。这用于处理类发展后需要添加新字段的情形。将对象写入流时需要指定要使用的替代对象的可序列化类,应使用准确的签名来实现此特殊方法:ANY-ACCESS-MODIFIERObjectwriteReplace()throwsObjectStreamException;此writeReplace方法将由序列化调用,前提是如果此方法存在,而且它可以通过被序列化对象的类中定义的一个方法访问。因此,该方法可以拥有私有(private)、受保护的(protected)和包私有(package-private)访问。子类对此方法的访问遵循java访问规则。在从流中读取类的一个实例时需要指定替代的类应使用的准确签名来实现此特殊方法。ANY-ACCESS-MODIFIERObjectreadResolve()throwsObjectStreamException;此readResolve方法遵循与writeReplace相同的调用规则和访问规则。序列化运行时使用一个称为serialVersionUID的版本号与每个可序列化类相关联,该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的serialVersionUID与对应的发送者的类的版本号不同,则反序列化将会导致InvalidClassException。可序列化类可以通过声明名为"serialVersionUID"的字段(该字段必须是静态(static)、最终(final)的long型字段)显式声明其自己的serialVersionUID:ANY-ACCESS-MODIFIERstaticfinallongserialVersionUID=42L;如果可序列化类未显式声明serialVersionUID,则序列化运行时将基于该类的各个方面计算该类的默认serialVersionUID值,如“Java(TM)对象序列化规范”中所述。不过,强烈建议所有可序列化类都显式声明serialVersionUID值,原因计算默认的serialVersionUID对类的详细信息具有较高的敏感性,根据编译器实现的不同可能千差万别,这样在反序列化过程中可能会导致意外的InvalidClassException。因此,为保证serialVersionUID值跨不同java编译器实现的一致性,序列化类必须声明一个明确的serialVersionUID值。还强烈建议使用private修改器显示声明serialVersionUID(如果可能),原因是这种声明仅应用于立即声明类--serialVersionUID字段作为继承成员没有用处。--------------------------实现java.io.Serializable接口的类是可序列化的。没有实现此接口的类将不能使它们的任一状态被序列化或逆序列化。序列化类的所有子类本身都是可序列化的。这个序列化接口没有任何方法和域,仅用于标识序列化的语意。允许非序列化类的子类型序列化,子类型可以假定负责保存和恢复父类型的公有的、保护的和(如果可访问)包的域的状态。只要该类(即父类)有一个无参构造子,可初始化它的状态,那么子类型就可承担上述职责;如果该类没有无参构造函数,在这种情况下申明一个可序列化的类是一个错误。此错误将在运行时被检测。例如:Integer实现了Serializable,所以可以把一个Integer的对象用IO写到文件里,之后再可以从文件里读出,如你开始写入的时候那个对象的intValue()是5的话,那读出来之后也是5。这一点体现了用序化类的作用,即用来传送类的对象。当一个JavaBean在构造工具内被用户化,并与其它Bean建立连接之后,它的所有状态都应当可被保存,下一次被load进构造工具内或在运行时,就应当是上一次修改完的信息。为了能做到这一点,要把Bean的某些字段的信息保存下来,在定义Bean时要使它实现Java.io.Serializable接口。例如:publicclassButtonimplementsJava.io.Serializable{……}实现了序列化接口的Bean中字段的信息将被自动保存。若不想保存某些字(这里的Bean中字段的信息将被自动保存是什么意思?这个自动保存是怎么实现的?)段的信息则可在这些字段前冠以transient或static关键字,transient和static变量的信息是不可被保存的。通常,一个Bean所有公开出来的属性都应当是被保存的,也可有选择地保存内部状态。Bean开发者在修改软件时,可以添加字段,移走对其它类的引用,改变一个字段的private、protected或public状态,这些都不影响类的存储结构关系。然而,当从类中删除一个字段,改变一个变量在类体系中的位置,把某个字段改成transient/static,或原来是transient/static,现改为别的特性时,都将引起存储关系的变化。所谓的Serializable,就是java提供的通用数据保存和读取的接口。至于从什么地方读出来和保存到哪里去都被隐藏在函数参数的背后了。这样子,任何类型只要实现了Serializable接口,就可以被保存到文件中,或者作为数据流通过网络发送到别的地方。也可以用管道来传输到系统的其他程序中。这样子极大的简化了类的设计。只要设计一个保存一个读取功能就能解决上面说得所有问题。
为什么要实现Serializable
最重要的两个原因是: 1、将对象的状态保存在存储媒体中以便可以在以后重新创建出完全相同的副本; 2、按值将对象从一个应用程序域发送至另一个应用程序域。 实现serializable接口的作用是就是可以把对象存到字节流,然后可以恢复。所以你想如果你的对象没实现序列化怎么才能进行网络传输呢,要网络传输就得转为字节流,所以在分布式应用中,你就得实现序列化,如果你不需要分布式应用,那就没那个必要实现序列化。
Serializable和Parcelable的区别
我们知道Serializable和Parcelable都是用来序列化的。 比如我们在Activity之间传递数据的时候,无法直接把对象从一个Activity传递到另一个Activity,所以这时就需要我们把对象序列化,转换成可传输或可存储的状态。序列化后的对象可以在网络进行传输,也可以存储到本地。 1.实现Serializable接口 因为这种方式书写简单,我们可能在平时使用这种方式比较多一些: 2.实现Parcelable接口 1.Serializable是Java提供的序列化接口,Parcelable是Android提供的序列化接口。Android中设计Parcelable的初衷是因为Serializable太慢。为了在程序内不同组件间以及不同Android程序间(AIDL)高效的传输数据而设计,这些数据仅在内存中存在,Parcelable是通过IBinder通信的消息的载体。 2.如果想实现数据持久化保存使用Serializable,Binder通信中的AIDL使用Parcelable。Serializable是序列化到硬盘上。Serializable序列化实际上是用到了反射技术,反射会产生大量的临时对象,进而引起频繁的GC。
java中serializable是什么意思?有什么作用?
一个对象序列化的接口,一个类只有实现了Serializable接口,它的对象才是可序列化的。因此如果要序列化某些类的对象,这些类就必须实现Serializable接口。而实际上,Serializable是一个空接口,没有什么具体内容,它的目的只是简单的标识一个类的对象可以被序列化。好处:a)比如说你的内存不够用了,那计算机就要将内存里面的一部分对象暂时的保存到硬盘中,等到要用的时候再读入到内存中,硬盘的那部分存储空间就是所谓的虚拟内存。在比如过你要将某个特定的对象保存到文件中,我隔几天在把它拿出来用,那么这时候就要实现Serializable接口;b)在进行java的Socket编程的时候,你有时候可能要传输某一类的对象,那么也就要实现Serializable接口;最常见的你传输一个字符串,它是JDK里面的类,也实现了Serializable接口,所以可以在网络上传输。c)如果要通过远程的方法调用(RMI)去调用一个远程对象的方法,如在计算机A中调用另一台计算机B的对象的方法,那么你需要通过JNDI服务获取计算机B目标对象的引用,将对象从B传送到A,就需要实现序列化接口。
serializable接口的作用是什么
本文操作环境:Windows7系统,Dell G3电脑。 serializable接口的作用: Serializable接口是启用其序列化功能的接口。实现java.io.Serializable 接口的类是可序列化的。没有实现此接口的类将不能使它们的任意状态被序列化或逆序列化。 个人理解: 这个介绍非常的不接地气,于是我与去看了几篇博客,有一个小姐姐的博客引起了我的注意,她是这样理解的: 序列化的过程,就是一个“freeze”的过程,它将一个对象freeze(冷冻)住,然后进行存储,等到再次需要的时候,再将这个对象de-freeze就可以立即使用。 我们以为的没有进行序列化,其实是在声明的各个不同变量的时候,由具体的数据类型帮助我们实现了序列化操作。 如果有人打开过Serializable接口的源码,就会发现,这个接口其实是个空接口,那么这个序列化操作,到底是由谁去实现了呢?其实,看一下接口的注释说明就知道,当我们让实体类实现Serializable接口时,其实是在告诉JVM此类可被序列化,可被默认的序列化机制序列化。 序列化的作用: *序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化,它将流转换为对象。这两个过程结合起来,可以轻松地存储和传输数据。 1,存储对象在存储介质中,以便在下次使用的时候,可以很快捷的重建一个副本。也就是When the resulting series of bits is reread according to the serialization format, it can be used to create a semantically identical clone of the original object. 问题:我没有实现序列化的时候,我一样可以存入到我的sqlserver或者MySQL、Oracle数据库中啊,为什么一定要序列化才能存储呢???? 2,便于数据传输,尤其是在远程调用的时候 实现java.io.Serializable这个接口是为序列化,serialVersionUID 用来表明实现序列化类的不同版本间的兼容性。如果你修改了此类, 要修改此值。 否则以前用老版本的类序列化的类恢复时会出错。 实现后如果你用的是工具的话会出来警告,他会提示你,可以自动生成private static final long serialVersionUID = 1L; 为了在反序列化时,确保类版本的兼容性,最好在每个要序列化的类中加入private static final long serialVersionUID这个属性,具体数值自己定义. 关于serialVersionUID的解释 serialVersionUID作用: 序列化时为了保持版本的兼容性,即在版本升级时反序列化仍保持对象的唯一性。 你可以随便写一个,在Eclipse中它替你生成一个,有两种生成方式: 一个是默认的1L,比如: private static final long serialVersionUID = 1L;一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段,比如: private static final long serialVersionUID = -8940196742313994740L;
serializable是什么意思
serializable 英[su026au0259ru026au0259lau026a"zu0259bl] 美[su026au0259ru026arlau026a"zu0259bl] [词典] [计] 可串行化的; [例句]Do this by creating a POJO that implements the "serializable" interface.操作方法是创建一个实现这个“可序列化”接口的POJO。