Custom Palindrome of a link list

package com.kartik.linklist;

public class Palindrome<T> {

 public static class Node<T> {

    // This signifies the reference to the next node in the series, or null if there is no additional node.

    Node<T> next;

    // The data associated with this node may be of any type you require.

    T data;

    // Constructor for the Node class

    public Node(T dataValue) {

     next = null;

     data = dataValue;

    }

    // Alternative constructor allowing specification of the next node.

    public Node(T dataValue, Node<T> nextValue) {

     next = nextValue;

     data = dataValue;

    }

    // Method to retrieve the data from the node

    public T getData() {

     return data;

    }

    public void setData(T dataValue) {

     data = dataValue;

    }

    public Node<T> getNext() {

     return next;

    }

    public void setNext(Node<T> nextValue) {

     next = nextValue;

    }

   }

   private Node<T> head;

   private Node<T> tail;

   /**

    * Default constructor for the Palindrome class.

    */

   public Palindrome() {

   }

  /**

* Constructor that initializes the list with a specified element.

*

* @param data The initial data for the list.

*/

   Palindrome(T data) {

    Node<T> n1 = new Node<T>(data);

    this.head = n1;

    this.tail = n1;

   }

   /**

* Adds the specified element to the end of the list.

*

* @param data The data to be added.

*/

   public void add(T data) {

    // If the list is empty, create a new list and set its head and tail.

    if (this.head == null) {

     Palindrome<T> linkList = (new Palindrome<T>(data));

     this.head = linkList.head;

     this.tail = linkList.tail;

     return;

    }

    // Create a new node to be added at the end of the list.

    Node<T> n = new Node<T>(data);

    Node<T> current = this.head, prev = null;

    while (current != null) {

     prev = current;

     current = current.next;

    }

    prev.next = n;

    this.tail = n; // Update the tail information as well.

   }

   public String toString() {

    String output = "";

    if (head != null) {

     Node<T> n = head.getNext();

     output += "[" + head.getData().toString() + "]-->";

     while (n != null) {

      output += "[" + n.getData().toString() + "]-->";

      n = n.getNext();

     }

    }

    return output;

   }

/**

* <ul>

* <li>The Tortoise (slow pointer) and the Hare (fast pointer) begin at the

* start of the linked list.</li>

* <li>During each iteration, the slow pointer advances by one step while the fast pointer advances by two steps.</li>

* <li>If a loop exists, the fast pointer will circle around the loop and eventually meet the slow pointer.</li>

* <li>If no loop is present, the fast pointer will reach the end of the list without encountering the slow pointer.</li>

* </ul>

*

* @purpose This function identifies the middle element in a linked list.

* */

   public Node<T> findMiddleNode(Node<T> head) {

    Node<T> slowPointer, fastPointer;

    slowPointer = fastPointer = head;

    while (fastPointer != null) {

     fastPointer = fastPointer.next;

     if (fastPointer != null && fastPointer.next != null) {

      slowPointer = slowPointer.next;

      fastPointer = fastPointer.next;

     }

    }

    return slowPointer;

   }

/**

* <ul>

* <li>Initially, determine the middle node of the linked list.</li>

* <li>Next, reverse the second half of the linked list from the middle to the end.</li>

* <li>Finally, compare the first node with the last node of the reversed section.</li>

* </ul>

*

* @purpose Function to verify whether the linked list is a palindrome.

* @return

*/

   public boolean checkPalindrome() {

    Node<T> fastPtr = head;

    //Identify the middle node by employing the slow and fast pointer technique. 

    Node<T> middleNode = findMiddleNode(fastPtr);

    // This will lead us to the head of the second segment,

    Node<T> secondHead = middleNode.next;

    // marking the conclusion of the first segment of the linked list.

    middleNode.next = null;

    // Subsequently, obtain the reversed linked list for the second segment.

    Node<T> reverseSecondHead = reverseLinkedList(secondHead);

    while (fastPtr != null && reverseSecondHead != null) {

     if (fastPtr.data == reverseSecondHead.data) {

      fastPtr = fastPtr.next;

      reverseSecondHead = reverseSecondHead.next;

      continue;

     } else {

      return false;

     }

    }

    return true;

   }

/**

* @purpose This function is designed to reverse a linked list.

* @param currentNode

* The current node being processed.

* @return The previousNode of the Node<T> object.

*/

   public Node<T> reverseLinkedList(Node<T> currentNode) {

   // For the initial node, previousNode will be set to null.

    Node<T> previousNode = null;

    Node<T> nextNode;

    while (currentNode != null) {

     nextNode = currentNode.next;

     // Reversing the link direction.

     currentNode.next = previousNode;

     // Advancing both currentNode and previousNode by one node.

     previousNode = currentNode;

     currentNode = nextNode;

    }

    return previousNode;

   }

 public static void main(String[] args) {

   System.out.println("------------------Integer-------------------");

      Palindrome<Integer> list = new Palindrome<Integer>();

      list.add(5);

      list.add(6);

      list.add(3);

      list.add(3);

      list.add(6);

      list.add(5);

      System.out.println(list.toString());

      System.out.println("Linked list palidrome: "+list.checkPalindrome());

      System.out.println();

      System.out.println("------------------String-------------------");

      Palindrome<String> list2 = new Palindrome<String>();

      list2.add("Kartik");

      list2.add("Mandal");

      list2.add("Saharda");

      list2.add("kharagpur");

      list2.add("Westbengal");

      list2.add("India");

      list2.add("India");

      list2.add("Westbengal");

      list2.add("kharagpur");

      list2.add("Saharda");

      list2.add("Mandal");

      list2.add("Kartik");

      System.out.println(list2.toString());

      System.out.println("Linked list palidrome: "+list2.checkPalindrome());

   }

 }

------------------Integer-------------------

[5]-->[6]-->[3]-->[3]-->[6]-->[5]-->

Linked list palindrome: true

------------------String-------------------

[Kartik]-->[Mandal]-->[Saharda]-->[kharagpur]-->[Westbengal]-->[India]-->[India]-->[Westbengal]-->[kharagpur]-->[Saharda]-->[Mandal]-->[Kartik]-->

Linked list palindrome: true