Format the Java codes with the Reat Hat extension.

codes/java/chapter_stack_and_queue/array_deque.java

@@ -10,8 +10,8 @@ import java.util.*;
 
 /* 基于环形数组实现的双向队列 */
 class ArrayDeque {
-    private int[] nums;  // 用于存储双向队列元素的数组
-    private int front;   // 队首指针，指向队首元素
+    private int[] nums; // 用于存储双向队列元素的数组
+    private int front; // 队首指针，指向队首元素
     private int queSize; // 双向队列长度
 
     /* 构造方法 */

codes/java/chapter_stack_and_queue/array_queue.java

@@ -10,8 +10,8 @@ import java.util.*;
 
 /* 基于环形数组实现的队列 */
 class ArrayQueue {
-    private int[] nums;  // 用于存储队列元素的数组
-    private int front;   // 队首指针，指向队首元素
+    private int[] nums; // 用于存储队列元素的数组
+    private int front; // 队首指针，指向队首元素
     private int queSize; // 队列长度
 
     public ArrayQueue(int capacity) {

codes/java/chapter_stack_and_queue/array_stack.java

@@ -11,6 +11,7 @@ import java.util.*;
 /* 基于数组实现的栈 */
 class ArrayStack {
     private ArrayList<Integer> stack;
+
     public ArrayStack() {
         // 初始化列表（动态数组）
         stack = new ArrayList<>();

codes/java/chapter_stack_and_queue/linkedlist_deque.java

@@ -10,9 +10,10 @@ import java.util.*;
 
 /* 双向链表节点 */
 class ListNode {
-    int val;       // 节点值
+    int val; // 节点值
     ListNode next; // 后继节点引用（指针）
     ListNode prev; // 前驱节点引用（指针）
+
     ListNode(int val) {
         this.val = val;
         prev = next = null;
@@ -22,7 +23,7 @@ class ListNode {
 /* 基于双向链表实现的双向队列 */
 class LinkedListDeque {
     private ListNode front, rear; // 头节点 front ，尾节点 rear
-    private int queSize = 0;      // 双向队列的长度
+    private int queSize = 0; // 双向队列的长度
 
     public LinkedListDeque() {
         front = rear = null;
@@ -55,7 +56,7 @@ class LinkedListDeque {
             // 将 node 添加至链表尾部
             rear.next = node;
             node.prev = rear;
-            rear = node;  // 更新尾节点
+            rear = node; // 更新尾节点
         }
         queSize++; // 更新队列长度
     }
@@ -85,17 +86,17 @@ class LinkedListDeque {
                 fNext.prev = null;
                 front.next = null;
             }
-            front = fNext;   // 更新头节点
+            front = fNext; // 更新头节点
         // 队尾出队操作
         } else {
-            val = rear.val;  // 暂存尾节点值
+            val = rear.val; // 暂存尾节点值
             // 删除尾节点
             ListNode rPrev = rear.prev;
             if (rPrev != null) {
                 rPrev.next = null;
                 rear.prev = null;
             }
-            rear = rPrev;    // 更新尾节点
+            rear = rPrev; // 更新尾节点
         }
         queSize--; // 更新队列长度
         return val;

codes/java/chapter_stack_and_queue/linkedlist_queue.java

@@ -10,7 +10,7 @@ import java.util.*;
 
 /* 基于链表实现的队列 */
 class LinkedListQueue {
-    private ListNode front, rear;  // 头节点 front ，尾节点 rear 
+    private ListNode front, rear; // 头节点 front ，尾节点 rear
     private int queSize = 0;
 
     public LinkedListQueue() {

codes/java/chapter_stack_and_queue/linkedlist_stack.java

@@ -11,9 +11,9 @@ import include.*;
 
 /* 基于链表实现的栈 */
 class LinkedListStack {
-    private ListNode stackPeek;  // 将头节点作为栈顶
-    private int stkSize = 0;   // 栈的长度
-    
+    private ListNode stackPeek; // 将头节点作为栈顶
+    private int stkSize = 0; // 栈的长度
+
     public LinkedListStack() {
         stackPeek = null;
     }