图解Java Stack栈

2021-12-07 21:02:37 阅读：178 来源： 互联网

标签：Java 栈顶 System stack println 图解 Stack out

写在前面

从某种角度来说，栈的LIFO（last in first out）特性是一个非常有用的特性，正是这样的特性，让栈变得格外重要。

所谓的LIFO就是后进先出，后进来的元素先出去，就如同下图中一般。
在这里插入图片描述

而在Java中，Java类库已经为我们提供来了Stack类来实现栈，并且这个Stack类是范型类，它可以存储不同的数据类型。

那么接下来我们就来看一下，Java为我们提供了哪些Stack类方法。
在这里插入图片描述
在这几个方法中，有一个很频繁的概念就是栈顶对象，因为我们知道栈是一个像井一样的有深度的数据结构，而我们站在上面并不能看到这个栈的整体结构，我们能看到的只有最上面的一个元素，这个元素就被称为栈顶元素。
它具有很多作用，从某种程度上说，栈的各种操作都离不开栈顶元素。

我们一个一个来分析：
判断栈是否为空：
当我们站在上面往井里面看的时候，如果看到东西了，换句话说，就是我们看到了栈顶元素，那么这个井就不是空的。所以栈顶元素可以判断栈是否为空。

查看栈顶对象：
很多时候，我们在得知栈不为空之后，还需要知道栈顶元素是什么，因为我们对栈操作的时候，我们能看到的只是栈最顶部的元素，要把它拿出来，还是在它头上再加一层，都有一个前提就是，看到它，所以我们为栈顶元素取一个用来操作的名字peek。

所以，对于peek,我们有两个很常见的操作，一个是将它取出来，一个是在它头上再加一层。
那么就引出了两个方法：pop和push。

pop就是把栈顶元素peak顶出来，然后peak的下一层就成为了新的peak。如果没有下一层，栈就为空。
在这里插入图片描述

push就是把一个新的元素塞到栈里面去，这个元素就成为了新的peak。
在这里插入图片描述

好的，我们已经熟悉了栈的基本操作，接下来，我们来看一个简单的例子来运用一下Stack类的这些方法：

import java.util.Stack;
/**
 * Java Stack的基本使用
 * 
 * @作者（yequan17）
 * @版本（2021.12.6）
 */
public class JStackTest
{
    public static void main(String[] args){
        System.out.println("Integer类型：");
        Stack<Integer> stack=new Stack<Integer>();
        stack.push(1);
        stack.push(2);
        System.out.println("添加元素之后栈顶元素为："+stack.peek()+" 是否为空:"+stack.empty()+" 栈内所有元素:"+stack);
        stack.pop();
        stack.pop();
        System.out.println("移除元素之后:");
        System.out.println("是否为空:"+stack.empty());
        
        System.out.println();
        System.out.println("自定义类型：");
        Stack<MyObject> stackObject=new Stack<MyObject>();
        stackObject.push(new MyObject(3,"yequan3"));
        stackObject.push(new MyObject(4,"yequan4"));
        System.out.println("添加元素之后栈顶元素:" +stackObject.peek().name+ " 是否为空:"+stackObject.empty());
        stackObject.pop();
        stackObject.pop();
        System.out.println("移除元素之后");
        System.out.println("是否为空:"+stackObject.empty());
    }
    
    static class MyObject{
        Integer id;
        String name;
        
        MyObject(int id,String name){
            this.id=id;
            this.name=name;
        }
    }
}

在这里插入图片描述

在上面的代码中我们简单看过了Java中对栈Stack类的一些方法，那么接下来我们就来自己实现以下栈。

栈的两种实现方式

栈可以通过数组和链表来实现。

这两种方式各有优势和缺点：

利用数组来创建栈，可以得到连续的内存空间，但是扩容的时候会比较麻烦。
利用链表来实现栈时扩容简单，但是内存空间不连续。

接下来，我们先看一下如何用数组实现栈。

用数组来实现栈：只需要定义一个栈顶指针指向栈顶元素即可，当要添加数据时指针往后移动，当要取出数据的时候指针往前移动。

在入栈的时候，如果栈已经满了，那么需要拓展内存，在出栈的时候，如果栈为空返回null。

具体代码如下：

import java.util.Arrays;
/**
 * Stack的数组实现
 * 
 * @作者（yequan17）
 * @版本（2021.12.7）
 */
public class JStackArray
{
    //范型类型、创建的时候指定数据类型
    public static class ArrayStack<E>{
        private Object[] stack;
        private int index;
        ArrayStack() {
            stack=new Object[10];
            index=0;//栈顶地址
        }
        
        public boolean isEmpty(){
            return index==0;
        }
        
        public  E peek(){
            if(isEmpty()){
                return null;
            }
            return (E)stack[index-1];
        }
        
        public E pop(){
            if (isEmpty()) {
            return null;
            }
            index--;
            return (E)stack[index];
        }
        
        //拓展内存
        private void ensureCapacity(int index) {
            if (index > stack.length) {
                int len = stack.length + 10;
                stack = Arrays.copyOf(stack, len);
            }
        }

        public E push(E e) {
            ensureCapacity(index+1);
            stack[index++] = e;
            return e;
        }
    }
    
    public static void main(String[] args){
        ArrayStack<String> stack = new ArrayStack<>();
        stack.push("a");
        stack.push("b");
    
        System.out.println("栈顶元素："+stack.peek());
        System.out.println("栈顶元素出栈："+stack.pop());
        System.out.println("栈顶元素出栈："+stack.pop());
        System.out.println("栈顶元素出栈："+stack.pop());
    }
}

在这里插入图片描述

栈的链表实现：当添加节点的时候栈顶元素为新添加的节点，该节点的next指向之前的节点，当删除元素时候当前节点指向下一个节点即可。

代码实现：


/**
 * Stack的链表实现
 * 
 * @作者（yequan17）
 * @版本（2021.12.7）
 */
public class JStackList
{
    //链表数据结构
    static class Node<E> {
        Node<E> next = null;    
        E data;
        public Node(E data) {
        this.data = data;
        }
    }

    //链表实现栈数据结构
    static class ListNodeStack<E> {
        Node<E> top = null;

        boolean isEmpty() {
            return top == null;
        }

        public void push(E item) {
            Node<E> node = new Node<E>(item);
            node.next = top;
            top = node;
        }

        public E pop() {
            if (this.isEmpty()) return null;
            E data = top.data;
            top = top.next;
            return data;
        }

        public E peek() {
            if (this.isEmpty()) return null;
            return top.data;
        }
    }
    
    public static void main(String[] args) {
        ListNodeStack<Integer> stack = new ListNodeStack<>();
        System.out.println("入栈");
        stack.push(1);
        stack.push(2);
        System.out.println("出栈:"+stack.pop());
        System.out.println("出栈:"+stack.pop());
        System.out.println("栈是否为空："+stack.isEmpty());
    }   
    
}

在这里插入图片描述

总结

在实际使用中，并不需要我们自己实现Stack,Java已经完全帮我们做好了封装，只需要引入java.util.Stack就可以直接使用Stack了。

一个思考问题：
为什么数组实现栈的时候，数组的长度要选为10，而不是其他数呢？以及如何扩容呢？

我们来看一下Java关于Stack的源码就会得知，真正实现Stack的并不是简单的数组，而是Vector类，Vector类实现了可扩展的对象数组。像数组一样，它包含可以使用整数索引访问的组件。但是， Vector的大小可以根据需要增长或缩小，以适应在创建Vector之后添加和删除项目。
在这里插入图片描述

而Vector的默认容量是10，其扩容增量为原本容量的一倍，也就是说，最开始的Vector的容量为10，扩容一次就会变成20。

标签：Java,栈顶,System,stack,println,图解,Stack,out
来源： https://blog.csdn.net/idler123/article/details/121771752

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

图解Java Stack栈

写在前面

栈的两种实现方式

总结