serializable怎么读,java 序列化

serializable怎么读,java 序列化详细介绍

本文目录一览： serializable 怎么读

金山词霸上的答案是错的，可以查一下有道词典上的读音，英式发音的重读音节在第一个字节，美式发音的重读音节在第三个音节。
serializable
英式读音：[s??r??la?'z?bl]
美式读音：[s??r?rla?'z?bl]
中文谐音：丝诶瑞来泽儿博欧
[词典] [计] 可串行化的;
[例句]Do this by creating a POJO that implements the "serializable" interface.
操作方法是创建一个实现这个“可序列化”接口的POJO。

序列化是什么

问题一：java 中的序列化是什么意思 序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
简单来说 序列化就是把Java对象储存在某一地方（硬盘、网络），以便于传输

问题二：什么是序列化 序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序俯化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。

问题三：java对象的序列化是什么意思 1、序列化是干什么的？
简单说就是为了保存在内存中的各种对象的状态，并且可以把保存的对象状态再读出来。虽然你可以 用自己的各种方法来保存Object states,
但是Java给你提供一种应该比你自己好的保存对象状态的机制、那就是序列化。
2、什么情况下需要序列化？
a)当你想把的内存中的对象保存到一个文件或者数据库中时候。
b)当你想用套接字在网络上传送对象的时候
c)当你想通过RMI传输对象的时候（RMI->Remote Method Invocation 远程方法调用）
3、当对一个对象实现序列化时，究竟发生了什么？
在没有序列化前，每个保存在堆（Heap）中的对象都有相应的状态（state），即实体变量（instance ariable）
例如：Foo myFoo=new Foo(); myFoo.setWidth(20); myFoo.setHeight(40);

问题四：Java中为什么要序列化？什么时候用到序列化？ 序列化可以将内存中的类写入文件或数据库中。比如将某个类序列化后存为文件，下次读取时只需将文件中的数据反序列化就可以将原先的类还原到内存中。也可以将类序列化为流数据进行传输。总的来说就是将一个已经实例化的类转成文件存储，下次需要实例化的时候只要反序列化即可将类实例化到内存中并保留序列化时类中的所有变量和状态。
例如：hibernate中实体类的钝化就是将类序列化后存入磁盘并释放内存空间。

问题五：JAVA中，序列化是指的什么？有何用途？ 序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
序列化:序列化是将对象转换为容易传输的格式的过程。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。
是对象永久化的一种机制。
确切的说应该是对象的序列化，一般程序在运行时，产生对象，这些对象随着程序的停止运行而消失，但如果我们想把某些对象（因为是对象，所以有各自不同的特性）保存下来，在程序终止运行后，这些对象仍然存在，可以在程序再次运行时读取这些对象的值，或者在其他程序中利用这些保存下来的对象。这种情况下就要用到对象的序列化。
对象序列化的最主要的用处就是在传递,和保存对象(object)的时候,保证对象的完整性和可传递性。譬如通过网络传输,或者把一个对象保存成一个文件的时候,要实现序列化接口

问题六：在JAVA中什么叫序列化和反序列化 30分 序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。

问题七：将数据序列化有什么作用啊？ 啊？序列化？应该是说一个数据结构，比如二叉树之类，序列化以后会变成一个char数组或者一个string字符串这样，方便你存到文件里面或者通过网络传输。然后要恢复的时候就是“反序列化”，把文件里读出来/从网络收到的char数组或者string恢复成一棵二叉树或者其他什么东西。
主要就是方便保存

问题八：C#序列化和反序列化到底是什么意思？ 序列化就是把一个对象保存到一个文件或数据库字段中去，反序列化就是在适当的时候把这个文件再转化成原来的对象使用。
我想最主要的作龚有：
1、在进程下次启动时读取上次保存的对象的信息
2、在不同的AppDomain或进程之间传递数据
3、在分布式应用系统中传递数据

问题九：c#中什么叫序列化操作？ 在C#中序列化操作简单点来理解就是把内存的东西写到硬盘中，当然也可以写到内存中，而反序列化就是从硬盘中把信息读到内存中。 下面以 BinaryFormatter序列化类Book作为例子说明下什么是序列化。定义类Book: [Serializable]
public class Book
{
string name;
float price;
string author; public Book(string bookname, float bookprice, string bookauthor)
{
name = bookname;
price = bookprice;
author = bookauthor;
}
} 在类的上面增加了属性:Serializable.(如果不加这个属性,将抛出SerializationException异常). 通过这个属性将Book标志为可以序列化的.当然也有另一种方式使类Book可以序列化,那就是实行ISerializable接口了.在这里要注意了:Serializable属性是不能被继承的咯!!! 如果你不想序列化某个变量,该怎么处理呢?很简单,在其前面加上属性[NonSerialized] .比如我不想序列化 string author; 那我只需要 [NonSerialized] string author; 好了,现在请看怎么实现序列化: 我们使用namespace: using System; using System.IO; using System.Runtime.Serialization.Formatters.Binary; 首先创建Book实例,like this: Book book = new Book(Day and Night, 30.0f, Bruce); 接着当然要创建一个文件了,这个文件就是用来存放我们要序列化的信息了. FileStream fs = new FileStream(@C:\book.dat, FileMode.Create); 序列化的实现也很简单,like this: BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(fs, book); 很简单吧!现在我列出整个原代码,包括反序列化. static void Main(string[] args)
{
Book book = new Book(Day and Night, 30.0f, Bruce); using(FileStream fs = new FileStream(@C:\book.dat, FileMode.Create))
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(fs, book);
} book = null; using(FileStream fs = new FileStream(@C:\book.dat, FileMode.Open))
{
......>>

问题十：php 什么是序列化 string serialize ( mixed value )
serialize() 返回字符串，此字符串包含了表示 value 的字节流，可以存储于任何地方。
这有利于存储或传递 PHP 的值，同时不丢失其类型和结构。
想要将已序列化的字符串变回 PHP 的值，可使用 unserialize()。serialize() 可处理除了 resource 之外的任何类型。甚至可以 serialize() 那些包含了指向其自身引用的数组。你正 serialize() 的数组／对象中的引用也将被存储。
当序列化对象时，PHP 将试图在序列动作之前调用该对象的成员函数 __sleep()。这样就允许对象在被序列化之前做任何清除操作。类似的，当使用 unserialize() 恢复对象时， 将调用 __wakeup() 成员函数。
注: 在 PHP 3 中，对象属性将被序列化，但是方法则会丢失。PHP 4 打破了此限制，可以同时存储属性和方法。请参见类与对象中的序列化对象部分获取更多信息。
例子 1. serialize() 示例

C#里serializable是什么意思？

序列化后的对象可以在网络之间进行传输！
序列化。将ojbect用字符的形式储存起来。
序列化
序列化是指存储和获取磁盘文件、内存或其他地方中的对象。在序列化时，所有的实例数据都保存到存储介质上，在取消序列化时，对象会被还原，且不能与其原实例区别开来。
只需给类添加Serializable属性，就可以实现序列化实例的成员。
并行化是序列化的逆过程，数据从存储介质中读取出来，并赋给类的实例变量。
[Serializable]
public class Person
{
public Person()
{
}
public int Age;
public int WeightInPounds;
}
下面来看一个小例子，首先要添加命名空间
using System.Runtime.Serialization.Formatters.Binary;
下面的代码将对象Person进行序列化并存储到一个文件中
Person me = new Person();
me.Age = 34;
me.WeightInPounds = 200;
Stream s = File.Open("Me.dat",FileMode.Create);
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(s,me);
s.Close();
如果需要对部分字段序列化部分不序列化时，我们可以按照如下设置实现
[Serializable]
public class Person
{
public Person()
{ }
public int Age;
[NonSerialized]
public int WeightInPounds;
}

android 组件间、进程间数据传输和限制

1、Bunder 传递对象为什么需要序列化?

1》因为 bundle 传递数据时只支持基本数据类型，所以在传递对象时需要序列化转

换成可存储或可传输的本质状态(字节流)。序列化后的对象可以在网络、IPC

(比如启动另一个进程的 Activity、Service 和 Reciver)之间进行传输，也可以 存储到本地。

2》序列化，表示将一个对象转换成可存储或可传输的状态。序列化的原因基本三种 情况:

1.永久性保存对象，保存对象的字节序列到本地文件中; 2.对象在网络中传递;

3.对象在 IPC 间传递。

2、序列化Serializable 和Parcelable 的区别
Serializable(Java 自带):

1》Serializable 是序列化的意思，表示将一个对象转换成存储或可传输的状态。序列化后的对象可以在网络上进传输，也可以存储到本地。

2》Serializable 会使用反射，序列化和反序列化过程需要大量 I/O 操作。

Parcelable(android 专用):

1》除了 Serializable 之外，使用 Parcelable 也可以实现相同的效果，不过不同于将 对象进行序列化，Parcelable 方式的实现原理是将一个完整的对象进行分解，而分解后的每一部分都是 Intent 所支持的数据类型，这也就实现传递对象的功能 了。

2》Parcelable 自已实现封送和解封(marshalled &unmarshalled)操作不需要用反 射，数据也存放在 Native 内存中，效率要快很多。

两者最大的区别在于 存储媒介的不同，Serializable 使用 I/O 读写存储在硬盘 上，而 Parcelable 是直接 在内存中读写。很明显，内存的读写速度通常大于 IO 读写，所以在 Android 中传递数据优先选择 Parcelable。

3、bundle传输的数据是否有限制，是多少，为什么要限制?

1》Intent 在传递数据时是有大小限制的，大约限制在 1MB 之内，你用 Intent 传递 数据，实际上走的是跨进程通信(IPC)，跨进程通信需要把数据从内核 copy到进程中，每一个进程有一个接收内核数据的缓冲区，默认是 1M;如果一次传 递的数据超过限制，就会出现异常。

2》不同厂商表现不一样有可能是厂商修改了此限制的大小，也可能同样的对象在不 同的机器上大小不一样。

3》传递大数据，不应该用 Intent;考虑使用 ContentProvider 或者直接匿名共享内 存。简单情况下可以考虑分段传输。

4、匿名共享内存（https://www.jianshu.com/p/d9bc9c668ba6）

事务的隔离级别

Read uncommitted 、Read committed 、Repeatable read 、Serializable 。
事务的隔离级别一共有四种，由低到高分别为Read uncommitted 、Read committed 、Repeatable read 、Serializable 。而且，在事务的并发操作中可能会出现脏读，不可重复读，幻读。
Read uncommitted是读未提交，就是一个事务可以读取另一个未提交事务的数据。Read committed是读提交，就是一个事务要等另一个事务提交后才能读取数据。Repeatable read是重复读，就是在开始读取数据（事务开启）时，不再允许修改操作。
Serializable 是最高的事务隔离级别，在该级别下，事务串行化顺序执行，可以避免脏读、不可重复读与幻读。但是这种事务隔离级别效率低下，比较耗数据库性能，一般不使用。大多数数据库默认的事务隔离级别是Read committed，Mysql默认隔离级别是Repeatable read。

在类前面加上【Serializable】有什么左右，麻烦不要说的太书面，太概念，理解不了，说的通俗点

表明该类的对象可以序列化的。序列化的好处是让对象可以存储在磁盘上或者在网络里面传输。
Serializable是一个标记性的接口，仅仅是标记这个类的对象可以被序列化，也就是说标记它可以被写入硬盘、网络传递。。。一般JavaBean的类都要用Serializable来标记一下它可以被序列化。

java 序列化

首先解释两个概念,何为序列化?何为反序列化?序列化:将对象转化成流的过程称为序列化反序列化:将流转化成对象的过程称之为反序列化序列化与反序列化必须遵守的原则a) Java对象在java中要想使一个java对象可以实现序列化与反序列化,必须让该类实现java.io.Serializable接口java.io.Serializable接口定义如下:publicinterface Serializable {}从上述定义中可以看到该接口中未定义任何方法,这大大的简化了开发者b) 序列化主要依赖java.io.ObjectOutputStream类,该类对java.io.FileOutputStream进一步做了封装,这里主要使用ObjectOutputStream类的writeObject()方法实现序列化功能Demo:/** *将对象序列化到磁盘文件中 *@paramo *@throwsException */ publicstaticvoid writeObject(Object o) throws Exception{ File f=new File("d:""user.tmp"); if(f.exists()){ f.delete(); } FileOutputStream os=new FileOutputStream(f); //ObjectOutputStream 核心类 ObjectOutputStream oos=new ObjectOutputStream(os); oos.writeObject(o); oos.close(); os.close(); }c) 反序列化主要依赖java.io.ObjectInputStream类,该类对java.io.InputStream进一步做了封装,这里主要使用ObjectInputStream类的readObject()方法实现序列化功能Demo:/** *反序列化,将磁盘文件转化为对象 *@paramf *@return *@throwsException */ publicstatic User readObject(File f) throws Exception{ InputStream is=new FileInputStream(f); //ObjectOutputStream 核心类 ObjectInputStream ois=new ObjectInputStream(is); return (User)ois.readObject(); }
序列化就是把对象的状态保存到一个文件上。反序列化就是把根据文件升成对应的对象。
不知道怎么说。。。直接网上找的：1、序列化是干什么的？
简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保 存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。
2、什么情况下需要序列化
a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
b）当你想用套接字在网络上传送对象的时候；
c）当你想通过RMI传输对象的时候； 下面再给个jdk宝典里的例子吧，这样你就应该知道怎么用了：package book.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Date;
/**
* 序列化和反序列化对象
*/
public class SerializeObject {
// 一个内部类，用于被序列化和反序列化。
//一定要实现Serializable才能够被序列化和反序列化。
static class MyClass implements Serializable{
//一般的实例变量会被序列化和反序列化
private int a,b;
//transient实例变量 不会 被序列化和反序列化
private transient int c;
// 类变量 不会 被序列化和反序列化
private static int d;
public MyClass(){
}
public MyClass(int a, int b, int c, int d){
this.a = a;
this.b = b;
this.c = c;
MyClass.d = d;
}
public String toString(){
return this.a + " " + this.b + " " + this.c + " " + MyClass.d;
}
} /**
* 序列化对象到文件
*/
public static void serialize(String fileName) throws Exception{
//创建一个对象输出流，将对象输出到文件
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(fileName));
//序列化一个字符串对象到文件
out.writeObject("Today:");
//序列化当前日期对象到文件
out.writeObject(new Date());
//序列化一个MyClass对象
MyClass my1 = new MyClass(5, 6, 7, 8);
out.writeObject(my1);
out.close();
}
/**
* 从文件反序列化到对象
*/
public static void deserialize(String fileName) throws Exception{
//创建一个对象输入流，从文件读取对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileName));
//注意读对象时必须按照序列化对象时的顺序读，否则会出错
//读取字符串对象
String today = (String)(in.readObject());
System.out.println(today);
//读日期对象
Date date = (Date)(in.readObject());
System.out.println(date.toString());
//读MyClass对象，并调用它的add方法。
MyClass my1 = (MyClass)(in.readObject());
System.out.println(my1.toString());
in.close();
//当恢复对象的时候，对象中的所有域被自动的恢复。如果不希望某个域被序列化，可以在它前面
//加上transient关键字，例如下面的代码：transient int noSer = 0;
//类似的，如果类中的某个域为静态，它不会被序列化。
}
/**
* @param args
*/
public static void main(String[] args) throws Exception{
String fileName = "c:/temp/MyClass.ser";
SerializeObject.serialize(fileName);
//注释掉第二行，只运行下面一行，将会发现输出不同
SerializeObject.deserialize(fileName);
}
}

java中serializable是什么

java Serializable,就是java提供的通用数据保存和读取的接口。
序列化类的所有子类本身都是可序列化的。这个序列化接口没有任何方法和域，仅用于标识序列化的语意。允许非序列化类的子类型序列化，子类型可以假定负责保存和恢复父类型的公有的、保护的和(如果可访问)包的域的状态。只要该类(扩展)有一个无参构造子，可初始化它的状态，那么子类型就可承担上述职责。在这种情况下申明一个可序列化的类是一个错误。此错误将在运行时被检测。就是可以把对象存到字节流，然后可以恢复
一个对象序列化的接口，一个类只有实现了Serializable接口，它的对象才是可序列化的。因此如果要序列化某些类的对象，这些类就必须实现Serializable接口。而实际上，Serializable是一个空接口，没有什么具体内容，它的目的只是简单的标识一个类的对象可以被序列化。

事务隔离的四个级别是什么？

事务隔离的四个级别是未提交读（Read Uncommitted）、提交读（Read Committed）、可重复读（Repeable Read）、可串行化（Serializable）。
1、未提交读（Read Uncommitted）：事务可以读取未提交的数据，也称作脏读（Dirty Read）。一般很少使用。
2、提交读（Read Committed）：是大都是DBMS（如：Oracle，SQLServer）默认事务隔离。执行两次同意的查询却有不同的结果，也叫不可重复读。
3、可重复读（Repeable Read）：是MySQL默认事务隔离级别。能确保同一事务多次读取同一数据的结果是一致的。可以解决脏读的问题，但理论上无法解决幻读（Phantom Read）的问题。
4、可串行化（Serializable）：是最高的隔离级别。强制事务串行执行，会在读取的每一行数据上加锁，这样虽然能避免幻读的问题，但也可能导致大量的超时和锁争用的问题。很少会应用到这种级别，只有在非常需要确保数据的一致性且可以接受没有并发的应用场景下才会考虑。
事务隔离级别特点比较
从事务隔离级别的定义上可以看出，Serializable级别隔离性最高，但是其效率也最低，因为其要求所有操作相同记录的事务都串行的执行。
对于MySql而言，其默认事务级别是Repeatable read，虽然在定义上讲，这种隔离级别无法解决幻读的问题，但是MySql使用了一种Next key-lock的算法来实现Repeatable read，这种算法是能够解决幻读问题的。
关于Next key-lock算法，在进行查询时，其不仅会将当前的操作记录锁住，也会将查询所涉及到的范围锁住。
也就是说，其他事务如果想要在当前事务查询的范围内进行数据操作，那么其是会被阻塞的，因而MySql在Repeatable read隔离级别下就已经具备了Serializable隔离级别的事务隔离性。
以上内容参考：百度百科-隔离级别

IsolationLevel.ReadCommitted是什么意思？

朋友，我可以为你找资料。但是我计算机水平肯定不如你啊。呵呵
朋友是计算机高手啊，我查阅了下，供你参考
Isolation Level.
隔离级别
Read Committed
ReadCommitted是许多数据库的缺省级别，这个隔离级别上，不会出现读取未提交的数据问题，但仍然无法避免不可重复读（包括幻影读）的问题。当你的系统对并发控制的要求非常严格时，这种默认的隔离级别可能无法提供数据有效的保护，但对于决大多数应用来讲，这种隔离级别就够用了。
===供朋友参考
READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ、SERIALIZABLE
一个比一个级别高
READ UNCOMMITTED：完全不管其他直接读，可能其他的一个transaction才写了一半的数据也可以读出来（这就是脏读）
READ COMMITTED：必须没其他事务在写（都写完了）的时候可以读，不会读到别人写了一半的数据，但是在同一个transaction里面执行两次READ COMMITTED，别人可以在中间写数据，就是两次读出来可以不一致（就是所谓不可重复读）
REPEATABLE READ：在读的时候加行锁，第一次读了之后这行不能在被别人写，两次读同一行必定一样，但是如果用select * from xxTable第一次和第二次在这个transaction出来的行数可能都不同（就是所谓幻读），多了一些，因为别人可以在之中加入新的行（因为只加了行锁）
SERIALIZABLE：在读的时候加表锁，可以保证在transaction的多次读操作没有脏读，不可重复读，幻读的问题，但是并发性最差，因为整个表被锁住了