锐客网

  1. 首页 > 睿知 > it技术 > >

JAVA串行代码案例 java可串行化接口

串口IT技术

java:什么是类的串行化？有什么作用？举个栗子呗 。对象的寿命通常随着生成该对象的程序的终止而终止 。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复 。我们把对象的这种能记录自己的状态以便将来再生的能力 。叫作对象的持续性(persistence) 。对象通过写出描述自己状态的数值来记录自己，这个过程叫对象的串行化(Serialization－连续)。串行化的主要任务是写出对象实例变量的数值 。如果变量是另一对象的引用，则引用的对象也要串行化 。这个过程是递归的，串行化可能要涉及一个复杂树结构的单行化 ， 包括原有对象、对象的对象、对象的对象的对象等等 。对象所有权的层次结构称为图表(graph) 。
Java对象的单行化的目标是为Java的运行环境提供一组特性，如下所示：
1) 尽量保持对象串行化的简单扼要，但要提供一种途径使其可根据开发者的要求进行扩展或定制 。
2) 串行化机制应严格遵守Java的对象模型。对象的串行化状态中应该存有所有的关于种类的安全特性的信息 。
3) 对象的串行化机制应支持Java的对象持续性 。
4) 对象的串行化机制应有足够的 可扩展能力以支持对象的远程方法调用(RMI) 。
【JAVA串行代码案例 java可串行化接口】5) 对象串行化应允许对象定义自身 的格式即其自身的数据流表示形式，可外部化接口来完成这项功能 。
利用JAVA实现串行通信的优点利用Java实现串口全双工通讯
内容：
1. SerialBean
2. SerialBuffer
3. ReadSerial
4. SerialExample
一个嵌入式系统通常需要通过串口与其主控系统进行全双工通讯，譬如一个流水线控制系统需要不断的接受从主控系统发送来的查询和控制信息，并将执行结果或查询结果发送回主控系统 。本文介绍了一个简单的通过串口实现全双工通讯的Java类库，该类库大大的简化了对串口进行操作的过程 。
本类库主要包括：SerialBean.java (与其他应用程序的接口), SerialBuffer.java (用来保存从串口所接收数据的缓冲区), ReadSerial.java (从串口读取数据的程序) 。另外本类库还提供了一个例程SerialExample.java 作为示范 。在下面的内容中将逐一对这几个部分进行详细介绍 。
1. SerialBean
SerialBean是本类库与其他应用程序的接口 。该类库中定义了SerialBean的构造方法以及初始化串口，从串口读取数据，往串口写入数据以及关闭串口的函数 。具体介绍如下：
public SerialBean(int PortID)
本函数构造一个指向特定串口的SerialBean，该串口由参数PortID所指定 。PortID = 1 表示COM1，PortID = 2 表示COM2，由此类推 。
public int Initialize()
本函数初始化所指定的串口并返回初始化结果 。如果初始化成功返回1，否则返回-1 。初始化的结果是该串口被SerialBean独占性使用，其参数被设置为9600, N, 8, 1 。如果串口被成功初始化，则打开一个进程读取从串口传入的数据并将其保存在缓冲区中 。
public String ReadPort(int Length)
本函数从串口(缓冲区)中读取指定长度的一个字符串 。参数Length指定所返回字符串的长度 。
public void WritePort(String Msg)
本函数向串口发送一个字符串 。参数Msg是需要发送的字符串 。
public void ClosePort()
本函数停止串口检测进程并关闭串口 。
SerialBean的源代码如下：
package serial;
import java.io.*;
import java.util.*;
import javax.comm.*;
/**
*
* This bean provides some basic functions to implement full dulplex
* information exchange through the srial port.
*
*/
public class SerialBean
{
static String PortName;
CommPortIdentifier portId;
SerialPort serialPort;
static OutputStream out;
static InputStreamin;
SerialBuffer SB;
ReadSerialRT;
/**
*
* Constructor
*
* @param PortID the ID of the serial to be used. 1 for COM1,
* 2 for COM2, etc.
*
*/
public SerialBean(int PortID)
{
PortName = "COM"PortID;
}
/**
*
* This function initialize the serial port for communication. It startss a
* thread which consistently monitors the serial port. Any signal capturred
* from the serial port is stored into a buffer area.
*
*/
public int Initialize()
{
int InitSuccess = 1;
int InitFail= -1;
try
{
portId = CommPortIdentifier.getPortIdentifier(PortName);
try
{
serialPort = (SerialPort)
portId.open("Serial_Communication", 2000);
} catch (PortInUseException e)
{
return InitFail;
}
//Use InputStream in to read from the serial port, and OutputStream
//out to write to the serial port.
try
{
in= serialPort.getInputStream();
out = serialPort.getOutputStream();
} catch (IOException e)
{
return InitFail;
}
//Initialize the communication parameters to 9600, 8, 1, none.
try
{
serialPort.setSerialPortParams(9600,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);
} catch (UnsupportedCommOperationException e)
{
return InitFail;
}
} catch (NoSuchPortException e)
{
return InitFail;
}
// when successfully open the serial port,create a new serial buffer,
// then create a thread that consistently accepts incoming signals from
// the serial port. Incoming signals are stored in the serial buffer.
SB = new SerialBuffer();
RT = new ReadSerial(SB, in);
RT.start();
// return success information
return InitSuccess;
}
/**
*
* This function returns a string with a certain length from the incomin
* messages.
*
* @param Length The length of the string to be returned.
*
*/
public String ReadPort(int Length)
{
String Msg;
Msg = SB.GetMsg(Length);
return Msg;
}
/**
*
* This function sends a message through the serial port.
*
* @param Msg The string to be sent.
*
*/
public void WritePort(String Msg)
{
int c;
try
{
for (int i = 0; iMsg.length(); i)
out.write(Msg.charAt(i));
} catch (IOException e){}
}
/**
*
* This function closes the serial port in use.
*
*/
public void ClosePort()
{
RT.stop();
serialPort.close();
}
}
2. SerialBuffer
SerialBuffer是本类库中所定义的串口缓冲区，它定义了往该缓冲区中写入数据和从该缓冲区中读取数据所需要的函数 。
public synchronized String GetMsg(int Length)
本函数从串口(缓冲区)中读取指定长度的一个字符串 。参数Length指定所返回字符串的长度 。
public synchronized void PutChar(int c)
本函数望串口缓冲区中写入一个字符，参数c 是需要写入的字符 。
在往缓冲区写入数据或者是从缓冲区读取数据的时候，必须保证数据的同步，因此GetMsg和PutChar函数均被声明为synchronized并在具体实现中采取措施实现的数据的同步 。
SerialBuffer的源代码如下：
package serial;
/**
*
* This class implements the buffer area to store incoming data from the serial
* port.
*
*/
public class SerialBuffer
{
private String Content = "";
private String CurrentMsg, TempContent;
private boolean available = false;
private int LengthNeeded = 1;
/**
*
* This function returns a string with a certain length from the incomin
* messages.
*
* @param Length The length of the string to be returned.
*
*/
public synchronized String GetMsg(int Length)
{
LengthNeeded = Length;
notifyAll();
if (LengthNeededContent.length())
{
available = false;
while (available == false)
{
try
{
wait();
} catch (InterruptedException e) { }
}
}
CurrentMsg= Content.substring(0, LengthNeeded);
TempContent = Content.substring(LengthNeeded);
Content = TempContent;
LengthNeeded = 1;
notifyAll();
return CurrentMsg;
}
/**
*
* This function stores a character captured from the serial port to the
* buffer area.
*
* @param t The char value of the character to be stored.
*
*/
public synchronized void PutChar(int c)
{
Character d = new Character((char) c);
Content = Content.concat(d.toString());
if (LengthNeededContent.length())
{
available = true;
}
notifyAll();
}
}
3. ReadSerial
ReadSerial是一个进程，它不断的从指定的串口读取数据并将其存放到缓冲区中 。
public ReadSerial(SerialBuffer SB, InputStream Port)
本函数构造一个ReadSerial进程，参数SB指定存放传入数据的缓冲区，参数Port指定从串口所接收的数据流 。
public void run()
ReadSerial进程的主函数，它不断的从指定的串口读取数据并将其存放到缓冲区中 。
ReadSerial的源代码如下：
package serial;
import java.io.*;
/**
*
* This class reads message from the specific serial port and save
* the message to the serial buffer.
*
*/
public class ReadSerial extends Thread
{
private SerialBuffer ComBuffer;
private InputStream ComPort;
/**
*
* Constructor
*
* @param SB The buffer to save the incoming messages.
* @param Port The InputStream from the specific serial port.
*
*/
public ReadSerial(SerialBuffer SB, InputStream Port)
{
ComBuffer = SB;
ComPort = Port;
}
public void run()
{
int c;
try
{
while (true)
{
c = ComPort.read();
ComBuffer.PutChar(c);
}
} catch (IOException e) {}
}
}
4. SerialExample
SerialExample是本类库所提供的一个例程 。它所实现的功能是打开串口COM1，对其进行初始化，从串口读取信息对其进行处理后将处理结果发送到串口 。
import serial.*;
import java.io.*;
/**
*
* This is an example of how to use the SerialBean. It opens COM1 and reads
* six messages with different length form the serial port.
*
*/
class SerialExample
{
public static void main(String[] args)
{
//TO DO: Add your JAVA codes here
SerialBean SB = new SerialBean(1);
String Msg;
SB.Initialize();
for (int i = 5; i = 10; i)
{
Msg = SB.ReadPort(i);
SB.WritePort("Reply: "Msg);
}
SB.ClosePort();
}
}
5. 编译与调试
本类库中使用了Java Communication API (javax.comm) 。这是一个Java扩展类库，并不包括在标准的Java SDK当中 。如果你尚未安装这个扩展类库的话，你应该从Sun公司的Java站点下载这个类库并将其安装在你的系统上 。在所下载的包里面包括一个安装说明，如果你没有正确安装这个类库及其运行环境的话，运行这个程序的时候你会找不到串口 。
正确安装Java Communication API并将上述程序编译通过以后，你可以按如下方法测试这个程序 。如果你只有一台机器，你可以利用一条RS-232电缆将COM1和COM2连接起来，在COM1上运行SerialExample，在COM2上运行Windows提供的超级终端程序 。如果你有两台机器的话，你可以利用一条RS-232电缆将两台机器的COM1(或者是COM2)连接起来，在一端运行例程，另外一端运行Windows提供的超级终端程序 。如果有必要的话，可以对SerialExample中所声明的串口进行相应改动 。
本程序在Windows 2000Java SDK 1.3环境下编译通过并成功运行 。
java定义一个举行类 ， 将其对象进行串行化和反串行化class Test implements Serializable
{
}
FileOutputStream fos = new FileOutputStream("a.dat");
fos.writeObject(new Test());
fos.close();
FileInputStream fis = new FileInputStream("a.dat");
Object o = fis.readObject();
fis.close();
java快速排序简单代码.example-btn{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.example-btn:hover{color:#fff;background-color:#47a447;border-color:#398439}.example-btn:active{background-image:none}div.example{width:98%;color:#000;background-color:#f6f4f0;background-color:#d0e69c;background-color:#dcecb5;background-color:#e5eecc;margin:0 0 5px 0;padding:5px;border:1px solid #d4d4d4;background-image:-webkit-linear-gradient(#fff,#e5eecc 100px);background-image:linear-gradient(#fff,#e5eecc 100px)}div.example_code{line-height:1.4em;width:98%;background-color:#fff;padding:5px;border:1px solid #d4d4d4;font-size:110%;font-family:Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;word-break:break-all;word-wrap:break-word}div.example_result{background-color:#fff;padding:4px;border:1px solid #d4d4d4;width:98%}div.code{width:98%;border:1px solid #d4d4d4;background-color:#f6f4f0;color:#444;padding:5px;margin:0}div.code div{font-size:110%}div.code div,div.code p,div.example_code p{font-family:"courier new"}pre{margin:15px auto;font:12px/20px Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;white-space:pre-wrap;word-break:break-all;word-wrap:break-word;border:1px solid #ddd;border-left-width:4px;padding:10px 15px}排序算法是《数据结构与算法》中最基本的算法之一 。排序算法可以分为内部排序和外部排序 ， 内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大 ， 一次不能容纳全部的排序记录，在排序过程中需要访问外存 。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等 。以下是快速排序算法：
快速排序是由东尼·霍尔所发展的一种排序算法 。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较 。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见 。事实上 ， 快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来 。
快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists） 。
快速排序又是一种分而治之思想在排序算法上的典型应用 。本质上来看 ， 快速排序应该算是在冒泡排序基础上的递归分治法 。
快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快 ， 而且效率高！它是处理大数据最快的排序算法之一了 。虽然 Worst Case 的时间复杂度达到了 O(n?)，但是人家就是优秀 ， 在大多数情况下都比平均时间复杂度为 O(n logn) 的排序算法表现要更好，可是这是为什么呢，我也不知道 。好在我的强迫症又犯了，查了 N 多资料终于在《算法艺术与信息学竞赛》上找到了满意的答案：
快速排序的最坏运行情况是 O(n?) ， 比如说顺序数列的快排 。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小 ， 比复杂度稳定等于 O(nlogn) 的归并排序要小很多 。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序 。
1. 算法步骤
从数列中挑出一个元素 ， 称为 "基准"（pivot）;
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边） 。在这个分区退出之后，该基准就处于数列的中间位置 。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
2. 动图演示
代码实现JavaScript实例functionquickSort ( arr ,left ,right ){
varlen=arr. length,
partitionIndex ,
left=typeofleft!='number'?0:left ,
right=typeofright!='number'?len-1:right ;
if( left
用java绘制DNA字符串输入一个整数且为奇数,表示DNA的串行,再输入一个整数表示？代码如下：
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
if (n % 2 == 0) {
if (n % 4 == 0) {
System.out.println("偶数 ， 可以被4整除 。");
} else {
System.out.println("偶数，不可以被4整除 。");
}
} else {
if (n % 5 == 0) {
System.out.println("奇数，可以被5整除 。");
} else {
System.out.println("奇数，不可以被5整除 。");
}
}
}
}
Java串行化怎么理解？什么是串行化？谁能通俗地给我讲讲?首先 ， 这个概念的原文是 Serialization，而串行化这个翻译并不是很好，个人倾向于序列化这个翻译，下面我都会用序列化这个名词 。
所谓序列化是指把一个对象通过某种规则转化为一串二进制串，字符串就是一种二进制串 。但为何要把对象转化为二进制串呢？因为我们需要保存或者在网络上传输它们，而存在于 JVM 内存中的对象并没有使用者可见的二进制形式 。虽然内存中的所有东西仍然是二进制的 ， 但 JVM 向我们屏蔽了内存操作相关的信息 ， 我们不一定能确定某个 JVM 实现是如何在内存中存储和组织一个 Java 对象的内容的（C/C就可以直接获取内存块来作为序列化的二进制串） 。
当然，光序列化是不够的 ， 我们还需要反序列化，也就是如何从二进制串重新转回对象 。这样当我们从文件中读取或者在网络的另一头收到某个对象的二进制串之后 ， 我们才能重新还原回那个对象 。
Java 默认实现了自己的序列化，就是使用的内存数据 。然而除了 Java 自己的序列化，我们还有很多中序列化方式，例如 hessian 。或者说将 Java 对象转成 json、xml 也是一种序列化 。
举一个非常简单的例子 ， 例如我们有一个对象 Integer v = 1; 。当我们使用 hessian 对其序列化的时候 ， 我们可能会拿到 I1 这样的字串（并不确定 hessian 生成的串是不是真的是这样，但是也差不多） ， 其中 i 表示类型是 Integer，而 1 就是这个变量的值，而 I1 就是序列化后的二进制串（一个字符串） 。
关于JAVA串行代码案例和java可串行化接口的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：c语言字符怎么查找，c语言查找字符串的位置

    下一篇：如何在IE服务器上删除代理设置？ ie服务器怎么删除代理