链表的基本概念
在数据结构中,链表是一种线性存储结构，与数组不同的是，链表的元素在内存中不是连续存储的，而是通过节点之间的指针链接而成，每个链表节点包含两部分：数据域（存储实际数据）和指针域（存储下一个节点的地址），Java中实现链表节点需要明确节点的结构，并通过类来封装数据域和指针域，从而构建完整的链表。
链表节点的类定义
在Java中,链表节点通常通过自定义类来实现，一个基本的链表节点类需要包含两个核心成员变量：data用于存储节点数据，next用于指向下一个节点，定义一个存储整数的链表节点类可以这样写：
class ListNode {
int data; // 数据域，存储节点数据
ListNode next; // 指针域，指向下一个节点
// 构造方法1：无参构造，初始化空节点
public ListNode() {
this.next = null;
}
// 构造方法2：带参构造，初始化数据域
public ListNode(int data) {
this.data = data;
this.next = null;
}
}
上述代码中,ListNode类定义了两个成员变量，并通过构造方法简化节点的创建，无参构造用于创建空节点（通常作为链表头节点），带参构造用于直接初始化节点的数据。
链表节点的创建方式
创建链表节点主要有两种方式：通过构造方法直接创建，或通过 setter 方法动态赋值。
通过构造方法创建
构造方法是创建对象时最直接的方式,创建一个数据为10的节点，只需调用带参构造：
ListNode node1 = new ListNode(10); // 创建数据为10的节点 ListNode node2 = new ListNode(20); // 创建数据为20的节点
node1和node2的next字段默认为null，表示它们暂时没有后续节点。
通过 setter 方法动态赋值
如果需要在创建节点后修改数据或指向其他节点,可以定义 setter 方法，在ListNode类中添加以下方法：
public void setData(int data) {
this.data = data;
}
public void setNext(ListNode next) {
this.next = next;
}
通过 setter 方法，可以灵活调整节点内容：
ListNode node3 = new ListNode(); // 无参构造创建空节点 node3.setData(30); // 设置数据为30 node3.setNext(node1); // 指向node1节点
单向链表的构建
单向链表是链表中最基础的结构,每个节点仅包含一个指向下一个节点的指针，通过将多个节点通过next字段串联，即可构建单向链表，构建一个包含10、20、30三个节点的链表：
public class LinkedListDemo {
public static void main(String[] args) {
// 创建节点
ListNode head = new ListNode(10); // 头节点
ListNode node2 = new ListNode(20);
ListNode node3 = new ListNode(30);
// 连接节点
head.next = node2; // head指向node2
node2.next = node3; // node2指向node3
// 遍历链表
ListNode current = head;
while (current != null) {
System.out.print(current.data + " -> ");
current = current.next;
}
System.out.println("null"); // 输出：10 -> 20 -> 30 -> null
}
}
上述代码中,head作为链表的头节点，通过next字段依次连接后续节点，最终形成一条单向链表，遍历链表时，从头节点开始，通过current指针依次访问每个节点，直到current为null（即链表末尾）。
双向链表的节点创建
除了单向链表,双向链表也是常见的一种结构，双向链表的每个节点包含两个指针：next指向下一个节点，prev指向前一个节点，定义双向链表节点类如下：
class DoublyListNode {
int data;
DoublyListNode prev; // 指向前一个节点
DoublyListNode next; // 指向下一个节点
public DoublyListNode(int data) {
this.data = data;
this.prev = null;
this.next = null;
}
}
创建双向链表节点时,需要同时维护prev和next指针，构建一个包含10、20、30的双向链表：
DoublyListNode doublyHead = new DoublyListNode(10); DoublyListNode doublyNode2 = new DoublyListNode(20); DoublyListNode doublyNode3 = new DoublyListNode(30); // 连接节点 doublyHead.next = doublyNode2; doublyNode2.prev = doublyHead; // doublyNode2的前驱指向doublyHead doublyNode2.next = doublyNode3; doublyNode3.prev = doublyNode2; // doublyNode3的前驱指向doublyNode2
循环链表的节点创建
循环链表是一种特殊链表,其尾节点的next指针指向头节点，形成闭环，单向循环链表的节点创建与单向链表类似，只需将尾节点的next指向头节点即可。
ListNode cycleHead = new ListNode(10); ListNode cycleNode2 = new ListNode(20); ListNode cycleNode3 = new ListNode(30); // 连接节点 cycleHead.next = cycleNode2; cycleNode2.next = cycleNode3; cycleNode3.next = cycleHead; // 尾节点指向头节点，形成循环
在遍历循环链表时,需要注意避免无限循环，通常通过设置一个计数器或标记已访问的节点来控制遍历次数。
链表节点的常用操作
创建链表节点后,还需要掌握节点的插入、删除和查找等基本操作。
节点插入
在链表头部插入节点（头插法）：
ListNode newNode = new ListNode(5); newNode.next = head; // 新节点指向原头节点 head = newNode; // 更新头节点
在链表尾部插入节点（尾插法）：
ListNode tail = head;
while (tail.next != null) {
tail = tail.next; // 找到尾节点
}
tail.next = newNode; // 新节点连接到尾节点
节点删除
删除指定值的节点：
ListNode dummy = new ListNode(0); // 哑节点，简化头节点删除逻辑
dummy.next = head;
ListNode current = dummy;
while (current.next != null) {
if (current.next.data == 20) { // 假设删除数据为20的节点
current.next = current.next.next; // 跳过待删除节点
break;
}
current = current.next;
}
head = dummy.next; // 更新头节点
节点查找
查找链表中是否存在某个值的节点：
ListNode current = head;
while (current != null) {
if (current.data == 20) {
System.out.println("节点存在，数据为：" + current.data);
break;
}
current = current.next;
}
if (current == null) {
System.out.println("节点不存在");
}
在Java中创建链表节点,核心是通过类定义节点的数据域和指针域，并通过构造方法或setter方法初始化节点，根据链表类型（单向、双向、循环），节点结构有所不同，但基本原理一致，掌握节点的创建、连接以及基本操作（插入、删除、查找）是学习链表的基础，也是后续实现复杂链表算法（如反转链表、检测环等）的前提，通过合理封装节点类和操作方法，可以构建出高效、易用的链表结构。
