Java 结构体之 JavaStruct 使用教程<一> 初识 JavaStruct

最新推荐文章于 2022-07-11 07:35:00 发布
最新推荐文章于 2022-07-11 07:35:00 发布
阅读量2w 收藏 40
点赞数 13
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： Javastruct使用教程 Javastruct开发 Javastruct开发教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/JAZZSOLDIER/article/details/75570462
JavaStruct是一个第三方库，它允许开发者像处理C/C++结构体一样处理Java对象。适用于Java/Android应用程序与嵌入式设备或C/C++应用程序通讯时自定义协议格式的场景。相比Java默认序列化方法，JavaStruct能提供更简洁高效的代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Javastruct 是什么

简而言之，Javastruct 是一个第三方库，用于像处理 C 或者 C++ 结构体那样处理 java 对象。也即利用 Javastruct 可以在 java 上实现类似于结构体的功能和操作。

Javastruct 的用途

在 java 或者 Android 应用程序与一些嵌入式设备通讯或者C、C++ 应用程序通讯时，比如网络、无线、蓝牙、串口通讯等场景，由于实际传输时我们希望在通讯时使用自定义的协议格式，这样就必须进行字节流的处理。比如：协议格式为：“包头 + 命令码 + 长度 + 数据 + 校验 + 包尾“ 这种格式，使用 java 默认的方法就需要每条协议设置或解析每个 byte，十分繁琐。这时，会很怀念 C 语言的结构体和指针，这回极大节省我们的代码逻辑和工作量。这就是我要使用并介绍 JavaStruct 的原因了。除此之外，该库还可以用作一个简单但空间利用高效的序列化方法。

JavaStruct 库支持原语、数组、C字符串及嵌套类等。同时支持大端和小端字节序。 Javastruct 也可以使用 ArrayLengthMarker 注释来处理其他域中定义长度的域。 在后面的例程和文档中会逐步涉及到。

Javastruct 的性能

对于简单的类，JavaStruct 要比 Java 序列化更快速，对于复杂和嵌套的类，通常与 Java 序列化性能相同。通常 JavaStruct 产生小2到3倍的输出结果。

JavaStruct 未来工作

1. 更好的命名和统一的外观类

2. 详细的文档

3. 基于 ByteBuffer 的结构体序列化（目前是基于stream流的方式）

4. 更好的性能

5. 更多单元测试

6. 数据对齐支持

7. 位域

8. Union 联合体

运行条件

任何具有 Java 5 或者更高的 JVM 的系统

其他类似项目

 Javolution 也有很好的结构体实现，Javolution 结构体使用特殊类来表示域，JavaStruct 有不同途径并且使用 POJO 和 Java 5 注释。


关于 JavaStruct 应用的文章系列，可以移步至如下链接：

1. 《Java 结构体之 JavaStruct 使用教程<一> 初识 JavaStruct》

2. 《Java 结构体之 JavaStruct 使用教程<二> JavaStruct 用例分析》

3. 《Java 结构体之 JavaStruct 使用教程<三> JavaStruct 数组进阶》
Go编程基础教程：初识Go语言
AI天才研究院
10-30 198
Go语言（也称为Golang）是一种开源编程语言，由Google开发，旨在提供高效、可靠的软件开发工具。
【go从入门到精通】结构体嵌套
热门推荐
网易搬砖头
04-19 4万+
先后在 IBM PlatformComputing从事网格计算，淘米网，网易从事游戏服务器开发，拥有丰富的C++，go等语言开发经验，mysql，mongo，redis等数据库，设计模式和网络库开发经验，对战棋类，回合制，moba类页游，手游有丰富的架构设计和开发经验。
Struts2 之配置文件编写,动作类(01)
卡式优雅的博客
07-22 550
学习路线:1.struts入门(配置文件编写,动作类的编写及其访问方式) 2.封装数据和访问Servlet的api 3.ognl和值栈 4.拦截器和注解开发struts2基本概念Struts2是一种基于MVC模式的轻量级Web框架. Struts2是Struts1的下一代产品，是在 Struts1和WebWork技术的基础上进行合并后的全新框架（WebWork是由OpenSymphony组织
JavaStruct.jar
06-27
这是原来在Google code上的Java结构体类库——JavaStruct的jar包和使用文档，现在已经不好找了，特此放出来供大家使用，哈哈。
java 三大结构之Struct
github_36601823的博客
03-03 1万+
java的三大框架分别是struct，spring和Hiberate。这里我们先来看看struct。 目前，运用广泛的是struct2，及MVC框架。M是指model，V是指view，C是指controller。主要是使用一个名为FilterDispatcher的过滤器来处理客户端的请求。 其工作流程如下： 1、判断客户端是否以.action请求，如果不适，直接交由servlet引擎
JavaStruct
tansuoliming的博客
05-08 5485
javastruct A library to treat java objects as C structs. 一个将java对象视为C结构的库 窗体顶端   窗体底端   Project HomeDownloadsWikiIssuesSource Search 窗体顶端  for  窗体底端     HowToUseJavaStruct  ...
JavaSE-04 Struct语法结构
m0_46507516的博客
05-10 479
JavaSE 四、Struct语法结构 ShunXunDemo:顺序结构 //顺序结构就按顺序呗 public static void main(String[] args) { System.out.println("hello1"); System.out.println("hello2"); System.out.println("hello3"); } 选择结构 ​ 2.1if结构
java Struct
Creak_Phone的专栏
03-09 1095
http://code.google.com/p/javastruct/wiki/HowToUseJavaStruct http://javolution.org/
Frida Hook 常用函数、java 层 hook、so 层 hook、RPC、群控
墨鱼菜鸡
07-11 4661
From：Frida hook 常用函数分享：https://www.52pojie.cn/thread-1196917-1-1.html From：Frida Hook Android 常用方法：https://blog.youkuaiyun.com/zhy025907/article/details/89512096 Frida 使用：https://z...
史上最强C语言教程----万字初识C语言
m0_67402341的博客
06-21 2067
目录1.什么是C语言？2. 第一个C语言程序3. 数据类型3. 变量、常量3.1 定义变量的方法3.2 变量的分类3.3 变量的使用3.4 变量的作用域和生命周期3.5 常量4. 字符串+转义字符+注释4.1 字符串4.2 转义字符5. 注释6. 选择语句7. 循环语句8. 函数9. 数组9.1 数组定义9.2 数组的下标?9.3 数组的使用10. 操作符11. 常见关键字?11.1 关键字 typedef11.2 关键字static11.2.1 修饰局部变量11.2.2 修饰全局变量11.2.3 修饰函数
javaStruct
04-13
利用java语言写的结构体 @StructClasspublic class Foo{ @StructField(order = 0) public byte b; @StructField(order = 1) public int i;}
C语言基础从零开始初识语言多图超详解-超万字教程
06-29
### C语言基础从零开始初识语言多图超详解-超万字教程 #### 1. 什么是C语言 ##### 1.1 计算机与机器语言 计算机是一种能够执行预设指令集的电子设备，它能进行数值计算、逻辑运算，并具备存储功能。为了与计算机...
Java框架（二）——Structs
许德鹏
09-23 6722
Structs是Java三大框架之一，Struts是采用JavaServlet/JavaServer Pages技术，开发Web应用程序的开放源码的Framework。采用Structs开发是基于MVC的应用框架。        首先简单再说一下MVC（Model/View/Controller）：       M是指数据模型，在Structs中通常由ActionForm Bean表示
JavaStruct-java类序列化与c结构体交互
qq_40298231的博客
03-09 1253
https://blog.youkuaiyun.com/jazzsoldier/article/details/75570462
使用Javastruct（一）
weixin_42141668的博客
03-03 1577
1.jar包 链接：https://pan.baidu.com/s/1jT3cdI_In0HRBEdIX6ODog 提取码：qzph 2.由于中央仓库中没有这个jar包，所以需要安装到本地maven仓库 在Windows打开cmd，运行以下命令： mvn install:install-file -DgroupId=com.javastruct : 设置项目代码的包名 -DartifactId=javastruct : 设置项目名或模块名 -Dversion=0..
JAVA实现Python中struct.pack()和struct.unpack()方法,并增加比特类型支持
Jelly_dong的博客
08-20 2181
package jelly.command.coder.util; import jelly.command.coder.exception.CmdCodecException; import com.google.common.primitives.Ints; import com.google.common.primitives.Longs; import com.google.common.primitives.Shorts; import com.sun.org.apache.xerces.in.
Java 结构体之 JavaStruct 使用教程<三> JavaStruct 数组进阶
SoldierJazz的专栏
07-21 1万+
经过前面两篇博客的介绍，相信对于 JavaStruct 的认识以及编程使用，读者已经有一定的基础了。只要理解和实践结合起来，掌握还是很容易的。下面进行一些数组使用方面的实例说明及演示。 在结构体类中使用数组有几种方式，可以使用静态指定大小的方式也可以通过使用 ArrayLengthMaker 进行动态分配。数组的大小既可以在类中定义，也可以在定义对象后通过对象进行指定。 静态指定方法 如下所
java结构体_javastruct()关于java结构体.doc
weixin_33055757的博客
02-19 517
javastruct()关于java结构体javastructA library to treat java objects as C structs.窗体顶端窗体底端HYPERLINK "/p/javastruct/"Project HomeHYPERLINK "/p/javastruct/downloads/list"DownloadsHYPERLINK "/p/javastruct/w/li...
Java 结构体之 JavaStruct 使用教程<二> JavaStruct 用例分析
SoldierJazz的专栏
07-21 3万+
使用环境 前一篇在介绍 JavaStruct 类时指定了使用库使用环境为 Java 5 及以上，也即开发我们使用的 JDK 版本为1.5及以上就可以了。以下讲解的用例可以直接将 code 直接粘贴到 java 的 main 函数中执行就可以了，后面会给出测试用例和结果。 使用方法 JavaStruct 类用于打包和解包结构体，也即使用方法为用该类的 pack 与 unpack 方法将定义的
给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。 示例1： 输入：head = [1,2,3,4,5], k = 2 输出：[4,5,1,2,3] 示例2： 输入：head = [0,1,2], k = 4 输出：[2,0,1] 提示： 链表中节点的数目在范围 [0, 500] 内 -100 <= Node.val <= 100 0 <= k <= 2 * 109.c++完整代码，不要用到容器，要用到using，namespace，std。以下面为核心 class Solution { public ListNode rotateRight(ListNode head, int k) { // 判断头结点是否存在，头结点下一个结点是否为空，返回头结点 if(head == null || head.next == null){ return head; } //定义链表初识长度为0 int length = 0; // 定义p指针指向头结点 ListNode p = head; // 求链表长度 while(p != null){ // p不为空，头结点长度也要算上 length++; p = p.next; } // 计算偶棉结点移动的长度 k = k % length; // 如果移动的位置为0，那么返回头结点 if(k == 0){ return head; } // 如果k>0的话，定义移动的长度位置，slow,fast ListNode slow = head; ListNode fast = head; // 移动位置的范围长度 while(k > 0){ fast = fast.next; k--; } // 往后移动的条件，看fast条件 while(fast != null && fast.next != null){ // 范围端点往后移动 slow = slow.next; fast = fast.next; } // 定义新的链表的头结点 ListNode newHead = slow.next; // 新链表的尾结点设置为空 slow.next = null; // 新链表 结点链接 fast.next = head; return newHead; } }
最新发布
04-01
<think>好的，我现在需要解决这个问题：旋转链表，将每个节点向右移动k个位置。首先，我得仔细理解题目要求。题目给了一个链表的头节点head和一个整数k，要求将链表向右旋转k次，然后返回新的头节点。比如示例1中，输入是[1,2,3,4,5]，k=2，结果应该是[4,5,1,2,3]。看起来每次旋转就是把最后一个节点移到最前面，这样的操作重复k次。但直接模拟k次旋转的话，当k很大时效率会很低，所以必须找到一种更高效的方法。 接下来，我需要分析如何高效地实现这个旋转。首先，应该注意到当链表长度L时，旋转L次相当于没有旋转。因此，有效的旋转次数应该是k % L。这样就能减少不必要的重复操作。例如示例2中链表长度是3，k=4，所以实际有效的k是4%3=1，也就是旋转1次即可得到结果。 那如何找到旋转后的新头节点呢？假设链表长度为L，有效旋转次数是k。旋转后的新头节点应该是原链表的第L - k个节点。比如示例1中，L=5，k=2，所以新头节点是第3个节点（索引从0开始的话是第3个节点，即节点4）。不过这里可能需要仔细确认索引的计算是否正确。 接下来，如何找到这个位置呢？可以使用快慢指针的方法。首先，让快指针先走k步，然后同时移动快慢指针，直到快指针到达最后一个节点。此时，慢指针的位置就是新的尾节点，而慢指针的下一个节点就是新的头节点。这样就能将链表分成两部分，然后将后半部分连接到前面。 但是，需要注意链表长度的计算，以及处理k可能为0的情况。此外，当链表为空或只有一个节点时，直接返回即可，无需处理。 现在，我需要将Java的示例代码转换为C++代码。需要注意C++中的链表结构，比如struct的定义，以及内存管理的问题。不过题目要求不使用容器，所以应该直接操作指针。 首先，定义链表节点结构体。通常在C++中，可以这样定义： struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(nullptr) {} }; 然后，在Solution类中的rotateRight函数。需要处理的情况包括： 1. 链表为空或只有一个节点，直接返回head。 2. 计算链表的长度。 3. 计算实际需要旋转的次数k = k % length。如果k为0，直接返回head。 4. 使用快慢指针找到新的头节点位置。 5. 调整指针连接，形成新的链表。 步骤详细说明： 步骤1：处理特殊情况。如果head为空或head->next为空，直接返回head。 步骤2：计算链表长度。遍历链表直到nullptr，统计长度length。 步骤3：计算k的有效值：k = k % length。如果k为0，返回原链表。 步骤4：初始化快慢指针slow和fast，都指向head。 步骤5：将fast指针向前移动k步。例如，当k=2时，fast先走到第二个节点（假设链表长度足够）。 步骤6：同时移动slow和fast，直到fast的next为空。此时，fast指向原链表的最后一个节点，而slow指向新链表的尾节点（即新的尾节点是slow，而新的头节点是slow->next）。 步骤7：断开链表，将slow的next置为nullptr，然后将原链表的尾部（即fast）的next指向原来的头节点head。此时，新的头节点是slow->next。 这样操作后，链表就被正确旋转了。 现在，将这些步骤用C++实现。需要注意指针的操作，避免空指针异常。 例如，示例1中，链表是1->2->3->4->5。计算长度5，k=2%5=2。快指针先移动2步到3。然后快慢指针一起移动直到fast->next为null。此时slow在3的位置，fast在5的位置。slow->next是4，即新头节点。将slow->next设为null，原链表变成1->2->3->null，而4->5->null。然后将fast->next指向原头节点1，得到4->5->1->2->3->null。 需要注意的是，当k等于链表长度时，旋转后的链表与原链表相同，所以取模后的k为0，直接返回原链表。 现在，编写代码： 首先，计算链表长度： int length = 0; ListNode* p = head; while(p != nullptr) { length++; p = p->next; } 然后计算k的有效值： k = k % length; if (k == 0) return head; 然后移动快指针k步： ListNode* fast = head; while(k--) { fast = fast->next; } 但是，这里有个问题。如果k等于0的话，已经返回了。所以此时k必须大于0，且fast不会超过链表长度。假设此时fast移动k步之后，可能到达nullptr吗？比如，当k等于链表长度的话，但此时已经处理了k%length，所以k此时是0，已经被处理了。所以此时，k的有效值是大于0且小于length的。例如，原length为5，k=2，移动两次，fast指向第三个节点。这样对吗？ 例如原链表长度是5，k=2。此时快指针移动两次，从head开始： 初始：fast指向1（head） 第一次移动：fast指向2 第二次移动：fast指向3 此时，快指针在第三个节点。然后，slow和fast同时移动，直到fast->next为null。这时，fast会走到5，slow走到3。此时slow->next是4，即新头节点。 是的，这样是正确的。 然后，slow和fast一起移动： ListNode* slow = head; while(fast->next != nullptr) { slow = slow->next; fast = fast->next; } 此时，fast指向最后一个节点，slow指向第L -k -1的位置？或者需要重新计算？ 例如，原链表长度是5，k=2： 初始：slow在1，fast在3。 第一次循环： fast->next是4，不为空。所以slow移动到2，fast到4. 第二次循环： fast->next是5，不为空。slow到3，fast到5. 第三次循环： fast->next是null，退出循环。 此时，slow在3，fast在5。slow的下一个节点是4，即新头节点。slow此时是新的尾节点，所以需要断开，slow->next置空。然后，fast的next指向原head。 所以，新头是slow->next，也就是4。然后将fast->next（原最后节点5的next）指向原头节点1。这样整个链表变成4->5->1->2->3->null。 所以，代码中的步骤是正确的。 现在，将这些步骤转换为C++代码： class Solution { public: ListNode* rotateRight(ListNode* head, int k) { if (head == nullptr || head->next == nullptr) { return head; } int length = 0; ListNode* p = head; while (p != nullptr) { length++; p = p->next; } k = k % length; if (k == 0) { return head; } ListNode* fast = head; for (int i = 0; i < k; ++i) { fast = fast->next; } ListNode* slow = head; while (fast->next != nullptr) { slow = slow->next; fast = fast->next; } ListNode* newHead = slow->next; slow->next = nullptr; fast->next = head; return newHead; } }; 但这里有一个可能的错误：当快指针移动k步之后，是否有可能超出链表长度？比如，假设链表长度是3，k=2，那么k%3=2，快指针移动两次。初始链表是0->1->2->null。第一次移动到1，第二次到2。此时，fast是节点2。然后，进入循环，条件是fast->next不为空。此时，fast->next是null，所以循环不执行。此时slow还是head，也就是0。新头节点是slow->next即1。slow->next被设置为null，所以原链表变成0->null，新头是1->2，然后fast->next（即2的next）指向原头节点0。得到1->2->0->null。这符合示例2的情况吗？ 示例2输入是[0,1,2]，k=4。实际k=4%3=1。所以正确的处理是旋转1次，变成2->0->1。即原链表移动1次，把最后一个节点2移动到头部。但是按照上述代码，当k=1时，快指针移动1步到1。然后，slow和fast一起移动直到fast->next为null。此时，fast是1，其next是2。循环条件满足，slow移动一次到0，fast到2。此时fast->next为null，退出循环。此时slow是0，slow->next是1，即新头节点。将slow->next设为null，原链表是0->null。然后将fast->next（即2的next）指向原头节点0。得到的新链表是1->2->0->null。但正确的答案应该是2->0->1。这说明代码有问题。 这时候发现我的思路有问题。比如，在示例2的情况下，当k=1的时候，正确的旋转应该是将最后一个节点（2）移动到前面，所以新头节点应该是2，而原链表变成2->0->1。 那代码哪里出错了？ 看步骤： 当k=1时，链表长度是3。快指针移动1步到节点1。然后，slow和fast同时移动直到fast->next为空。此时： 初始状态： slow = 0（head）, fast =1. 进入循环，因为fast->next是2，不为空，所以循环执行： slow =0->next是1，fast=1->next是2. 此时，fast->next是null，所以循环退出。 此时，slow是1，fast是2. 新头节点是slow->next即2。断开slow->next为null，所以原链表的前半部分是0->1->null，后半部分是2->null。然后将fast->next（2的next）指向原头节点0。得到的新链表是2->0->1->null。这样是正确的，所以代码是正确的？ 那为什么之前的示例2的输出应该是[2,0,1]，而代码得到的结果是2->0->1，这正确吗？ 是的。所以这说明之前的分析中的示例2的代码是正确的。那之前的分析中为什么会认为代码有问题？ 哦，可能是我在手动模拟的时候犯了错误。让我再仔细看示例2的情况： 原链表是0->1->2，k=4。k%3=1. 代码中，快指针移动1步到1，然后slow和fast一起移动直到fast->next为null： 此时，初始slow=0，fast=1. 第一次循环，fast->next是2，所以执行循环体： slow=1，fast=2. 此时fast->next是null，所以退出循环。 slow是1，所以newHead是slow->next即2。断开slow.next=null，原链表变成0->1->null，然后将fast.next=2的next指向原head=0。所以新链表是2->0->1->null。这确实是正确的输出。所以示例2的代码是正确的。 那为什么之前我手动模拟k=1的情况时，得到的是正确的输出呢？这说明代码是正确的。 可能我之前犯了一个错误，现在纠正了。所以代码是正确的。 那现在，代码是否正确？ 看来是的。那现在需要将Java代码转换为C++，并确保正确。 注意C++中的节点定义，以及在函数中使用指针的正确性。比如，函数参数是ListNode* head，返回类型是ListNode*。 综上，最终的C++代码应该如上述所示。</think>```cpp #include <iostream> using namespace std; struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(nullptr) {} }; class Solution { public: ListNode* rotateRight(ListNode* head, int k) { // 处理空链表或单节点链表 if (head == nullptr || head->next == nullptr) return head; // 计算链表长度 int length = 0; ListNode* p = head; while (p != nullptr) { length++; p = p->next; } // 计算有效旋转次数 k = k % length; if (k == 0) return head; // 快指针先走k步 ListNode* fast = head; for (int i = 0; i < k; ++i) { fast = fast->next; } // 同步移动快慢指针找到断开点 ListNode* slow = head; while (fast->next != nullptr) { slow = slow->next; fast = fast->next; } // 重组链表 ListNode* newHead = slow->next; slow->next = nullptr; fast->next = head; return newHead; } }; // 辅助函数：打印链表 void printList(ListNode* head) { while (head != nullptr) { cout << head->val << " "; head = head->next; } cout << endl; } // 测试用例 int main() { // 示例1 ListNode* head1 = new ListNode(1); head1->next = new ListNode(2); head1->next->next = new ListNode(3); head1->next->next->next = new ListNode(4); head1->next->next->next->next = new ListNode(5); Solution().rotateRight(head1, 2); printList(head1); // 实际测试需先执行旋转后打印新头节点，此处仅为示意 // 示例2 ListNode* head2 = new ListNode(0); head2->next = new ListNode(1); head2->next->next = new ListNode(2); ListNode* result2 = Solution().rotateRight(head2, 4); printList(result2); // 输出应为 2 0 1 return 0; } ``` ### 分步解释： 1. **特殊处理**：若链表为空或仅有一个节点，直接返回原链表 2. **计算长度**：遍历链表统计节点总数$L$ 3. **有效旋转次数**：$k = k \% L$，当$k=0$时无需旋转 4. **快指针移动**：快指针先移动$k$步，与慢指针形成间距 5. **同步移动**：快慢指针同步移动直至快指针到达末尾，此时慢指针指向新链表的尾节点 6. **重组链表**：将慢指针的`next`设为新头节点，原链表尾部连接到原头部 ### 关键点： - 时间复杂度$O(n)$，空间复杂度$O(1)$ - 通过模运算减少无效旋转次数 - 双指针法精确定位断开位置，避免多次遍历
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值