使用Java函数实现常用数据结构

Java是一种广泛应用于各种场景下的编程语言，它提供了丰富的类库和API，可以方便地实现各种常用的数据结构。下面我将介绍几种常见的数据结构，并用Java函数实现它们。

1. 数组（Array）：数组是一种用于存储固定大小元素的数据结构。在Java中，我们可以使用构造函数和索引来操作数组。例如，我们可以使用以下函数创建一个整数数组并给定初始值：

   public static int[] createArray(int size, int initialValue) {
       int[] array = new int[size];
       for (int i = 0; i < size; i++) {
           array[i] = initialValue;
       }
       return array;
   }
   

2. 栈（Stack）：栈是一种后进先出（LIFO）的数据结构，我们可以使用数组或链表来实现它。以下是一个使用链表实现栈的例子：

   class Stack {
       class Node {
           int data;
           Node next;
   
           Node(int data) {
               this.data = data;
           }
       }
   
       Node top;
   
       public void push(int data) {
           Node newNode = new Node(data);
           if (top == null) {
               top = newNode;
           } else {
               newNode.next = top;
               top = newNode;
           }
       }
   
       public int pop() {
           if (top == null) {
               throw new EmptyStackException();
           }
           int data = top.data;
           top = top.next;
           return data;
       }
   }
   

3. 队列（Queue）：队列是一种先进先出（FIFO）的数据结构。可以使用数组或链表来实现它。以下是一个使用数组实现队列的例子：

   class Queue {
       int[] array;
       int capacity;
       int front;
       int rear;
       int size;
   
       public Queue(int capacity) {
           this.capacity = capacity;
           array = new int[capacity];
           front = 0;
           rear = -1;
           size = 0;
       }
   
       public void enqueue(int data) {
           if (isFull()) {
               throw new FullQueueException();
           }
           rear = (rear + 1) % capacity;
           array[rear] = data;
           size++;
       }
   
       public int dequeue() {
           if (isEmpty()) {
               throw new EmptyQueueException();
           }
           int data = array[front];
           front = (front + 1) % capacity;
           size--;
           return data;
       }
   
       public boolean isEmpty() {
           return size == 0;
       }
   
       public boolean isFull() {
           return size == capacity;
       }
   }
   

4. 链表（LinkedList）：链表是一种由节点组成的数据结构，每个节点包含数据和指向下一个节点的引用。以下是一个使用链表实现简单单向链表的例子：

   class Node {
       int data;
       Node next;
   
       Node(int data) {
           this.data = data;
       }
   }
   
   class LinkedList {
       Node head;
   
       public void add(int data) {
           Node newNode = new Node(data);
           if (head == null) {
               head = newNode;
           } else {
               Node current = head;
               while (current.next != null) {
                   current = current.next;
               }
               current.next = newNode;
           }
       }
   
       public void delete(int data) {
           if (head == null) {
               return;
           }
           if (head.data == data) {
               head = head.next;
               return;
           }
           Node current = head;
           while (current.next != null) {
               if (current.next.data == data) {
                   current.next = current.next.next;
                   return;
               }
               current = current.next;
           }
       }
   }
   

以上是几种常见的数据结构在Java中的实现。通过使用Java提供的类库和API，我们可以方便地使用这些数据结构，以实现各种功能。当然，这只是数据结构的基础，还有很多高级的数据结构可以在Java中实现，比如树、图等。希望这些例子能帮助你理解并应用数据结构在Java中的实现。