使用Java函数实现基本的数据结构操作（如栈、队列、链表等）

Java是一种面向对象的编程语言，它可以轻松地实现基本的数据结构操作，例如栈、队列、链表等。在Java中，我们可以使用类和接口来实现数据结构，这样可以让我们更加封装和抽象数据结构中的逻辑。

一、栈

栈是一种后进先出（LIFO）的数据结构，其中添加的元素总是放在栈顶，而删除的元素也总是从栈顶移除。Java中实现栈非常简单，我们可以使用java.util.Stack类或java.util.Deque接口来实现。

1. 使用Stack类实现栈

Stack类是Java中内置的一种实现栈的类，我们可以使用它来创建栈对象，并使用push()方法添加元素，使用pop()方法删除元素。以下是一个使用Stack类实现栈的示例。

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        // 创建一个栈对象
        Stack<Integer> stack = new Stack<>();

        // 添加元素到栈中
        stack.push(1);
        stack.push(2);
        stack.push(3);

        // 删除并返回栈顶元素
        int top = stack.pop();
        System.out.println("栈顶元素是：" + top);

        // 获取但不删除栈顶元素
        int peek = stack.peek();
        System.out.println("栈顶元素是：" + peek);

        // 判断栈是否为空
        boolean isEmpty = stack.isEmpty();
        System.out.println("栈是否为空：" + isEmpty);

        // 获取栈中元素个数
        int size = stack.size();
        System.out.println("栈中元素个数是：" + size);
    }
}

2. 使用Deque接口实现栈

Deque是Java中的一个双端队列接口，它可以用来实现栈。我们可以使用Deque中的push()方法将元素添加到栈顶，使用pop()方法将元素从栈顶取出。以下是一个使用Deque接口实现栈的示例。

import java.util.ArrayDeque;
import java.util.Deque;

public class StackExample {
    public static void main(String[] args) {
        // 创建一个双端队列对象
        Deque<Integer> stack = new ArrayDeque<>();

        // 添加元素到栈中
        stack.push(1);
        stack.push(2);
        stack.push(3);

        // 删除并返回栈顶元素
        int top = stack.pop();
        System.out.println("栈顶元素是：" + top);

        // 获取但不删除栈顶元素
        int peek = stack.peek();
        System.out.println("栈顶元素是：" + peek);

        // 判断栈是否为空
        boolean isEmpty = stack.isEmpty();
        System.out.println("栈是否为空：" + isEmpty);

        // 获取栈中元素个数
        int size = stack.size();
        System.out.println("栈中元素个数是：" + size);
    }
}

二、队列

队列是一种先进先出（FIFO）的数据结构，其中添加的元素总是放在队尾，而删除的元素总是从队头移除。Java中也可以使用类和接口实现队列，例如java.util.LinkedList类或java.util.Queue接口。

1. 使用LinkedList类实现队列

LinkedList类是Java中内置的一种实现队列的类，我们可以使用它来创建队列对象，并使用add()方法添加元素，使用remove()方法删除元素。以下是一个使用LinkedList类实现队列的示例。

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        // 创建一个队列对象
        Queue<Integer> queue = new LinkedList<>();

        // 添加元素到队列中
        queue.add(1);
        queue.add(2);
        queue.add(3);

        // 删除并返回队列头部元素
        int front = queue.remove();
        System.out.println("队列头部元素是：" + front);

        // 获取但不删除队列头部元素
        int peek = queue.peek();
        System.out.println("队列头部元素是：" + peek);

        // 判断队列是否为空
        boolean isEmpty = queue.isEmpty();
        System.out.println("队列是否为空：" + isEmpty);

        // 获取队列中元素个数
        int size = queue.size();
        System.out.println("队列中元素个数是：" + size);
    }
}

2. 使用Queue接口实现队列

Queue是Java中的一个接口，它定义了一些基本的队列操作。我们可以使用java.util.LinkedList类实现Queue接口，并使用offer()方法添加元素，使用poll()方法删除元素。以下是一个使用Queue接口实现队列的示例。

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        // 创建一个队列对象
        Queue<Integer> queue = new LinkedList<>();

        // 添加元素到队列中
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);

        // 删除并返回队列头部元素
        int front = queue.poll();
        System.out.println("队列头部元素是：" + front);

        // 获取但不删除队列头部元素
        int peek = queue.peek();
        System.out.println("队列头部元素是：" + peek);

        // 判断队列是否为空
        boolean isEmpty = queue.isEmpty();
        System.out.println("队列是否为空：" + isEmpty);

        // 获取队列中元素个数
        int size = queue.size();
        System.out.println("队列中元素个数是：" + size);
    }
}

三、链表

链表是一种数据元素相连的数据结构，每个元素包含一个数据域和一个指向下一个元素的指针。在Java中，我们可以使用类来实现链表。以下是一个使用Java类实现链表的示例。

public class Node {
    public int data;
    public Node next;

    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class LinkedList {
    public Node head;

    public LinkedList() {
        this.head = null;
    }

    public void add(int data) {
        Node newNode = new Node(data);
        if (this.head == null) {
            this.head = newNode;
        } else {
            Node node = this.head;
            while (node.next != null) {
                node = node.next;
            }
            node.next = newNode;
        }
    }

    public void remove(int data) {
        if (this.head == null) {
            return;
        }
        if (this.head.data == data) {
            this.head = this.head.next;
            return;
        }
        Node node = this.head;
        while (node.next != null) {
            if (node.next.data == data) {
                node.next = node.next.next;
                return;
            }
            node = node.next;
        }
    }

    public void print() {
        Node node = this.head;
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
        System.out.println();
    }
}

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();

        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        list.remove(3);

        list.print();
    }
}

在上面的示例中，我们使用一个Node类表示链表中的每个节点，这个类包含了一个data域和一个next指针。我们还定义了一个LinkedList类表示链表，它包含了一个head指针，表示链表的头部。我们可以使用add()方法向链表中添加元素，使用remove()方法删除元素，使用print()方法打印链表中的所有元素。

最后，在Java中实现基本的数据结构操作，我们还可以使用泛型来使代码更加通用和灵活。泛型可以让我们使用同一套代码来处理不同类型的数据，在实现数据结构时非常有用。