欢迎光临Java中的客“栈”

就目前而言，相信大家对数组、链表还有栈都基本已经有了一些了解，本篇文章将以栈为主体，探究栈和数组，栈和链表之间的一些联系。

当然在开始对栈的学习之前，我们先回顾有关数组、链表的基础知识点。

学习代码就是一个不断遗忘且巩固的过程，如何让敲出来的代码在心中印象更为深刻呢？不妨为这些有规律的字母的排列组合赋予一些当下事物的灵动性。

在这里我不得不提到当下的热梗：诸如来自歌手2024中的“五旬老太守国门”、“叶赫那拉氏大战八国联军”等等，既然咱们英子在这期舞台上是那么的孤单无助，在本篇代码里我将在循环取出栈中元素时，为英子来点助力，毕竟，57岁正是拼搏的年龄，咱们英子不能输，一个不够就来俩，两个不够我就来N个，真舞台咱也上不去，那就只能在代码里为我们的歌手们呐喊助威了！（见三）

天天抖手，精神抖擞！

一、链表与数组（Array and LinkedList）

1.关于数组 Array

2.关于链表 LinkedList

二、栈（Stack）

1.泛型简介

2.什么是栈

3.数组与栈

1）栈的存与取

2）数组和栈删除之间的区别

3）代码实现

4.链表与栈

1）栈中数据的插入与删除

2）基本代码实现

3）头插法与尾插法

三、整体代码

一、链表与数组（Array and LinkedList）

1.关于数组 Array

数组在内存中是一段连续的空间，每段的编号都是从0开始的，依次递增，也称为数组的下标。

数组可以通过索引（下标）访问其任意位置的元素。

数组不能够自动扩容且长度固定不可变。

除了掌握数组的创建，还需要会使用的就是数组的存和取。

int[] array1 = new int[10];//动态初始化
int[] array2 = {1,2,3,4,5};//静态初始化

在整数型数组的动态初始化里，每个元素的初始值都为0，不同类型的数组初始值不同。

public class Test {//存public static void main(String[] args) {int[] array = new int[5];for (int i = 0; i < array.length; i++) {array[i] = i * 2 + 1;}for (int i = 0; i < array.length; i++) {System.out.println("array[" + i + "] = " + array[i]);}}
}

public class Test {//取public static void main(String[] args) {int[] arr1 = {1,2,3,4,5};for (int i = 0; i < arr1.length; i++) {System.out.print(arr1[i]+" ");}System.out.print("\n");int[] arr2 = new int[5];for (int j  = 0;j < arr2.length; j++){int value = arr2[j];System.out.print(value+" ");}}}

运行结果：

1 2 3 4 5
0 0 0 0 0

2.关于链表 LinkedList

这里主要回顾单向链表。链表长度可变，且可以实现自动扩容，但不能通过下标进行访问。

链表使用节点对象储存数据，节点之间相互存储地址建立连接。

链表主要几个概念：头节点和尾结点。

头节点（head）：链表的第一个节点称为头节点，通常用来表示整个链表的起始位置。

尾节点（last）：链表的最后一个节点称为尾节点，其指针通常指向 null，表示链表的结束。

但与数组不同，链表中的元素在内存中不是连续存储的，而是通过指针（引用）相互连接起来。

图示的为链表的一个节点node，value是这个节点的所存储的数据值，next为下一节点的地址。

二、栈（Stack）

1.泛型简介

为什么叫泛型？一般提到关于“泛”的都是联想到广泛、宽泛、空泛、泛泛之交等词语、所以不难得出泛具有适用性广、通用性强等特征。所以在Java中的泛型一般用在尚不确定的数据类型中，可以暂替多种数据类型，以下段代码为例。

public class pandora_box<T> {private T value;public void setValue(T value){this.value=value;System.out.println(value);}public T getValue(){System.out.println(value);return value;}public static void main(String[] args) {pandora_box<String> box1 = new pandora_box<>();box1.getValue();box1.setValue("潘多拉魔盒");pandora_box<Integer> box2 = new pandora_box<>();box2.setValue(111);box2.getValue();}
}

输出结果：

null
潘多拉魔盒
111
111

2.什么是栈

栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。

底层可以使用数组或链表进行实现。

采取先进后出（LIFO：last in first of）原则: 即先存入的数据,最后才能取出

类比：放羽毛球的盒子，最先放进去的是最后一个拿出来的，或一个单向闭口的管道（最先存入的为栈底、最后一个存入的为栈顶）。

总结：栈的操作只涉及栈顶元素，而不会涉及栈底或中间的元素。

3.数组与栈

数组可以理解成为一种固定长度的栈。

1）栈的存与取

存：按照下标正常存入

取：从最后的元素开始依次向前

2）数组和栈删除之间的区别

数组：找到对应的下标，将改下标后一位置的元素逐一向前挪一个

栈：倒着一一取出直至找到需要删除的数据

对于插入数据数据呢？会很麻烦，一旦越过最后一个要取前面的步骤就会很繁琐。

3）代码实现

Object[ ]是一个数组，其中每个元素的类型都是Object。在 Java 中，Object 是所有类的祖先，因此 Object[ ] 数组可以存储任何类型的对象，包括基本数据类型的包装类对象和用户自定义的类对象。

由于Object是所有类的直接或间接父类，因此 Object[ ] 数组可以存储任意类型的对象，例如String、Integer、Double 等。当你不确定数组中需要存储哪种类型的对象时，可以使用 Object[ ] 数组作为一种通用的容器。（类比泛型的思想）

public class ArrayStack<E> {Object[] stackArr = new Object[10];int size=0;public void add(E e){//定义了一个公有的方法 add，用于向栈中添加元素//该方法使用泛型类型 T 作为参数类型，表示可以接受任意类型的对象(即传入)if (stackArr.length==size){System.out.println("小二提示：您的客栈已满！");return;}stackArr[size++]=e; //这行代码相当于stackArr[size]=e;size++;//将传入的元素 t 添加到栈顶（数组中的下一个空位置），并将 size 自增//这里利用 size 变量来记录当前栈中元素的个数，并在添加元素后更新 size}public E get(){//当你从栈中取出元素时，根据栈的特性，应当从栈顶开始取出元素!!!E element =(E)stackArr[size-1];//具体理解见wordstackArr[size-1]=null;size--;return element;}public String toString() {StringBuilder sb = new StringBuilder();sb.append("stackArr:{ ");for (int i = 0; i < size; i++) {sb.append(stackArr[i]).append(" "); // 将每个元素的值拼接到 str 中}sb.append("}");return sb.toString();}public static void main(String[] args) {ArrayStack<Object> arrStack = new ArrayStack<>();for (int i = 0; i < 10; i++){arrStack.add(i);}System.out.println("存-"+arrStack.toString());for (int i = 0; i < 10; i++){System.out.print("取-"+arrStack.get()+" ");}}
}

输出结果：

存-stackArr:{ 0 1 2 3 4 5 6 7 8 9 }
取-9 取-8 取-7 取-6 取-5 取-4 取-3 取-2 取-1 取-0

4.链表与栈

链表可以理解为实现一种长度不固定的栈。

1）栈中数据的插入与删除

由于栈只能从栈顶开始对其中的数据进行取出，所以我们只能倒着一一取出直至找到需要删除的数据，那么对于插入数据数据呢？一样也很麻烦，一旦越过最后一个数据要取出前面的就会很麻烦。

2）基本代码实现

链表通过将数据存入节点对象中，而节点类的构造一般包括属性、数据变量、下一个节点对象变量（其中存储的为地址）。

添加或查找数据都可以通过一个头节点依次向下找。

class Node<E>{E value;//数据变量Node<E> next;public Node(E value){this.value=value;}public Node<E> setNext(){return next;}public void getNext(){this.next=next;}}public class myLinkedList<E> {Node<E> head;int size;public void add(E e){Node<E> node = new Node<>(e);//如果头节点为空if(head==null){head=node;size++;return;}else{//遍历链表找到最后一个节点，将新节点挂在最后一个节点上//利用递归的思想Node<E> current = head;while (current.next != null){current=current.next;}current.next=node;size++;}}public static void main(String[] args) {myLinkedList<Integer> myll = new myLinkedList<>();long startTime = System.currentTimeMillis();for (int i = 0; i<100000;i++){myll.add(i);}long endTime = System.currentTimeMillis();System.out.println("人工链表用时："+(endTime-startTime)+"ms");LinkedList<Integer> linkedList = new LinkedList<>();long startTime1 = System.currentTimeMillis();for (int i = 0; i<100000;i++){linkedList.add(i);}long endTime1 = System.currentTimeMillis();System.out.println("系统链表用时："+(endTime1-startTime1)+"ms");}}

运行结果：

人工链表用时：5728ms

系统链表用时：4ms

思考：为何自制的链表与java系统自带的耗时差异如此之大？

可能的原因：在遍历上耗时过多。

3）头插法与尾插法

So如果我们不是通过找到头节点后再遍历循环挂到末尾上，直接让新节点成为头节点是不是就可以略去遍历循环的时间了呢？（头插法）

public void addFirst(E e){Node<E> node = new Node<>(e);if(head==null){head=node;size++;return;}else{node.next=head;//此时假设新节点node已经成为头节点，则当时的头节点的位置处于新节点的下一个head=node;//原本头节点的位置size++;}
}

运行结果

人工链表用时：98ms

系统链表用时：33ms

下面是尾插法的代码实现部分。

public void addLast(E e) {Node<E> node = new Node<>(e);if (head == null) {head = node;last = node;//此时头结点也是尾结点size++;return;} else {last.next = node;//此时假设新节点node已经成为头节点，则当时的头节点的位置处于新节点的下一个last = node;//原本头节点的位置size++;}
}

运行结果：

人工链表用时：94ms

系统链表用时：96ms

不难看出：尾插法的运行速度甚至比头插法还有java自带的耗时更少。

三、整体代码（叶赫那拉大战八国联军）

class Node<E>{E value;//数据变量Node<E> next;public Node(E value){this.value=value;}public void setNext(Node<E> next){this.next=next;}public Node<E> getNext(){return next;}}public class myLinkedList<E> {Node<E> head;Node<E> last;int size;public void addFirst(E e){Node<E> node = new Node<>(e);if(head==null){head=node;size++;return;}else{node.next=head;//此时假设新节点node已经成为头节点，则当时的头节点的位置处于新节点的下一个head=node;//原本头节点的位置size++;}}public void addLast(E e) {Node<E> node = new Node<>(e);if (head == null) {head = node;last = node;//此时头结点也是尾结点size++;return;} else {last.next = node;//此时假设新节点node已经成为头节点，则当时的头节点的位置处于新节点的下一个last = node;//原本头节点的位置size++;}}public void add(E e){Node<E> node = new Node<>(e);//如果头节点为空if(head==null){head=node;size++;return;}else{//遍历链表找到最后一个节点，将新节点挂在最后一个节点上//利用递归的思想Node<E> current = head;while (current.next != null){current=current.next;}current.next=node;size++;}}@Overridepublic String toString(){String str = "{";Node<E> current = head;while (current.next!=null){str+=current.value+",";current=current.next;}str+=current.value+"}";return str;}public E get(int point){if(point<0 || point>=size){System.out.println("不好意思这位大人您越界了");return null;}Node<E> current = head;for (int i =0; i<point;i++){current=current.next;}return current.value;}public static void main(String[] args) {myLinkedList<String> stringList = new myLinkedList<>();for (int i=0;i<6;i++){stringList.addLast("叶赫那拉"+i);}for (int i=0;i<2;i++){stringList.addFirst("八国联军"+i);}//注意顺序不能调换！！！System.out.println(stringList.toString());System.out.println(stringList.get(3));}public static void test(){myLinkedList<Integer> myll = new myLinkedList<>();long startTime = System.currentTimeMillis();for (int i = 0; i<1000000;i++){//myll.add(i);myll.addFirst(i);//myll.addLast(i);}long endTime = System.currentTimeMillis();System.out.println("人工链表用时："+(endTime-startTime)+"ms");LinkedList<Integer> linkedList = new LinkedList<>();long startTime1 = System.currentTimeMillis();for (int i = 0; i<1000000;i++){linkedList.add(i);}long endTime1 = System.currentTimeMillis();System.out.println("系统链表用时："+(endTime1-startTime1)+"ms");}}

运行结果：

{八国联军1,八国联军0,叶赫那拉0,叶赫那拉1,叶赫那拉2,叶赫那拉3,叶赫那拉4,叶赫那拉5}
叶赫那拉1

写到最后发现这篇的结构与内容有点杂乱，可能是因为有段时间没有写博客的原因，让我逐渐调整调整，争取下一篇是那种短小精悍的小短篇，后续关于链表、数组、栈的内容还会出现，这次就当做一个初步了解啦。