Java实现stack

好的，Java实现stack可以使用Java提供的Stack类，也可以使用LinkedList类来实现。下面是使用LinkedList实现stack的示例代码：

import java.util.LinkedList;

public class MyStack<T> {
    private LinkedList<T> list;

    public MyStack() {
        list = new LinkedList<>();
    }

    public void push(T item) {
        list.addLast(item);
    }

    public T pop() {
        return list.removeLast();
    }

    public boolean isEmpty() {
        return list.isEmpty();
    }

    public int size() {
        return list.size();
    }
}

这个示例代码实现了一个泛型的stack，可以存储任意类型的数据。push方法将数据添加到stack的末尾，pop方法从stack末尾取出数据并删除它，isEmpty方法判断stack是否为空，size方法返回stack中元素的个数。

相关问题

java实现stack并测试_JUnit3.8实现模拟堆栈的测试 | 学步园

好的，下面是Java实现stack并测试的步骤：

1. 创建一个Stack类，该类应该包含以下方法：

- push(Object obj): 将元素obj压入堆栈中
- pop(): 弹出并返回堆栈顶部的元素
- peek(): 返回堆栈顶部的元素，但不弹出它
- isEmpty(): 如果堆栈为空，则返回true，否则返回false

2. 使用JUnit3.8编写测试用例，测试Stack类中的所有方法。测试用例应该包含以下测试：

- 测试push()方法是否能够将元素正确地压入堆栈中
- 测试pop()方法是否能够弹出并返回堆栈顶部的元素
- 测试peek()方法是否能够返回堆栈顶部的元素，但不弹出它
- 测试isEmpty()方法是否能够正确返回堆栈是否为空的状态

下面是一个示例代码，可以参考一下：

Stack.java

import java.util.ArrayList;

public class Stack {
    private ArrayList<Object> stack = new ArrayList<Object>();

    public void push(Object obj) {
        stack.add(obj);
    }

    public Object pop() {
        Object obj = stack.get(stack.size() - 1);
        stack.remove(stack.size() - 1);
        return obj;
    }

    public Object peek() {
        return stack.get(stack.size() - 1);
    }

    public boolean isEmpty() {
        return stack.isEmpty();
    }
}

StackTest.java

import junit.framework.TestCase;

public class StackTest extends TestCase {
    private Stack stack;

    protected void setUp() throws Exception {
        super.setUp();
        stack = new Stack();
    }

    protected void tearDown() throws Exception {
        super.tearDown();
        stack = null;
    }

    public void testPush() {
        stack.push("Hello");
        stack.push("World");
        assertFalse(stack.isEmpty());
    }

    public void testPop() {
        stack.push("Hello");
        stack.push("World");
        assertEquals("World", stack.pop());
        assertEquals("Hello", stack.pop());
        assertTrue(stack.isEmpty());
    }

    public void testPeek() {
        stack.push("Hello");
        stack.push("World");
        assertEquals("World", stack.peek());
        assertFalse(stack.isEmpty());
    }

    public void testIsEmpty() {
        assertTrue(stack.isEmpty());
        stack.push("Hello");
        assertFalse(stack.isEmpty());
    }
}

这是一个简单的实现，你可以根据自己的需求进行修改和扩展。希望对你有所帮助！

stack实现 java

### 如何在 Java 中实现栈数据结构

#### 使用数组实现栈
一种简单的方法是通过数组来创建栈。下面是一个简单的 `MyStack` 类，它展示了如何使用数组作为底层存储机制。

public class MyStack {
    private int maxSize;
    private int[] stackArray;
    private int top;

    public MyStack(int size) {
        maxSize = size;
        stackArray = new int[maxSize];
        top = -1;
    }

    public void push(int value) {
        if (top < maxSize - 1) {
            stackArray[++top] = value;
        } else {
            System.out.println("Stack is full");
        }
    }

    public int pop() {
        if (top >= 0) {
            return stackArray[top--];
        } else {
            throw new RuntimeException("Stack is empty");
        }
    }

    public boolean isEmpty() {
        return (top == -1);
    }

    public int peek() {
        if (!isEmpty()) {
            return stackArray[top];
        } else {
            throw new RuntimeException("Stack is empty");
        }
    }
}

此代码定义了一个名为 `MyStack` 的类[^3]，该类具有基本的栈操作方法：`push()` 添加新元素到栈顶；`pop()` 移除并返回栈顶元素；`peek()` 返回但不移除栈顶元素；以及 `isEmpty()` 判断栈是否为空。

#### 使用链表实现栈
另一种常见的做法是以单向链表为基础构建栈。这种方式允许动态调整大小而无需预先指定容量限制。

class Node {
    int data;
    Node next;

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

public class LinkedListBasedStack {

    private Node head;

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

    public void push(int newData){
        Node newNode=new Node(newData);
        newNode.next=head;
        head=newNode;
    }

    public int pop(){
        if(head==null){
            throw new RuntimeException("Stack underflow");
        }
        int poppedValue= head.data;
        head=(head).next;
        return poppedValue;
    }

    public boolean isEmpty(){
         return head == null ;
    }

    public int peek(){
       if(isEmpty()){
           throw new RuntimeException("Stack UnderFlow");  
       }
       return head.data;
    }
}

这段程序实现了基于链接节点列表的栈功能[^1]。每当我们调用 `push()` 方法时，会在链表头部插入一个新的节点；当执行 `pop()` 或者 `peek()` 操作的时候，则是从链表头读取或删除最上面的一个节点。

这两种方式都可以有效地模拟 LIFO（Last In First Out）行为，即最后进入的数据最先被取出，这是栈的核心特性之一[^2]。