栈和队列是什么？
是概念！是逻辑结构！不是真是存在的！寄托载体不固定！
栈和队列的特征？
栈：先进后出，队列：先进先出
int、double……是数据类型
array、list、map都有各自固定的格式和样式
而栈和队列可以是一个线性表、可以是一个数组……只要是符合“先进后出”结构就可以理解为栈，只要是符合“先进先出”结构就可以理解为队列

一下是用java写出的栈和队列的代码示例：

1、定义数据节点，类名为 NodeClass ，数据类型不定用泛型 T 代替 ，内部定义一个存放数据的私有变量 Data ，其数据类型不定 也用泛型 T 代替；一个指向下一个节点的指针 next 。

package Stack;

public class NodeClass<T> {
    private T data;
    private NodeClass<T> next;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public NodeClass<T> getNext() {
        return next;
    }

    public void setNext(NodeClass<T> next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "NodeClass{" +
                "data=" + data +
                ", next=" + next +
                '}';
    }
}

2、定义一个学生类，用于填在节点的数据域，学生类中包括学生的学号，姓名，其他信息（就是一些比较随便的可以用来区分不同学生的信息）

package Stack;


public class Student {
    private int stuNum;
    private String name;
    private String otherInfo;

    public int getStuNum() {
        return stuNum;
    }

    public void setStuNum(int stuNum) {
        this.stuNum = stuNum;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getOtherInfo() {
        return otherInfo;
    }

    public void setOtherInfo(String otherInfo) {
        this.otherInfo = otherInfo;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuNum=" + stuNum +
                ", name='" + name + '\'' +
                ", otherInfo='" + otherInfo + '\'' +
                '}';
    }
}

3->1、定义一个栈结构类，定义栈顶指针，和入栈出栈的方法

package que;

import Stack.NodeClass;

public class StackClass<Student> {

    private NodeClass<Student> que; //这是一个栈结构，栈的指针

    public NodeClass<Student> getQue() {
        return que;
    }

    public void setQue(NodeClass<Student> que) {
        this.que = que;
    }
        //入栈的方法，将NodeClass类型 的节点 添加到栈中
    public void add( NodeClass<Student>  add ){
        if( que == null ){//判断如果此时que是空的，则将节点直接添加到que所指部分
            que = add;
        }else{
            add.setNext(que);//将所加节点的指向现有栈顶元素
            que = add;//将que指向新增加的元素
        }
    }

    public NodeClass<Student> pop(){
        NodeClass<Student> result = que;//新定义一个节点用来储存目前的栈顶元素
        if( que != null ){
            que = que.getNext();//将que指向栈中上一个节点
        }
        return result;//返回栈顶元素，同时删除此元素
    }

    public void look(){
        System.out.println(que.toString());
    }
}

3->2、定义一个队列的结构类，有头指针和尾指针，定义从尾指针入队的方法和从头指针出队的方法

package que;

import Stack.NodeClass;

public class QueClass<T> {

    private NodeClass<T>  que; //是我们滴队列
    private NodeClass<T>  end; //是我们滴队列滴尾巴

    public NodeClass<T> getQue() {
        return que;
    }

    public void setQue(NodeClass<T> que) {
        this.que = que;
    }

    public NodeClass<T> getEnd() {
        return end;
    }

    public void setEnd(NodeClass<T> end) {
        this.end = end;
    }

    //入队函数，从队尾入队
    public void add( NodeClass<T>  add ){
            if( que == null ){//如果头指针是空，将que指向当前 所添加元素 ，将尾指针也指向此元素，此时，队列中只有一个元素
                que = add;
                end = que;
            }else{//如果队列不是空，将尾指针的next指针指向新加元素add，
                end.setNext(add);
                end = end.getNext();//将end向后移动一位，此时队列中元素个数增加一个
            }
    }

    //出队函数，从队头出队
    public NodeClass<T> pop(){
        NodeClass<T> result = que;//定义一个NodeClass类型的节点用来储存 当前队头的元素
        if( que != null ){//进行判断，观察此时que指向是不是为空，不为空即将que向后移动一位，即删除que指向的元素
            que = que.getNext();
        }
        return result;//返回刚才的队头元素
    }

    public void look(){
        System.out.println(que.toString());
    }
}

**

4、测试类，建立栈的测试类，对其进行入栈和出栈的操作

**

package Stack;

import que.StackClass;


public class TestClass {
    public static void main(String[] a){
        String[] studentNames = new String[]{
                "学生1","学生2","学生3","学生4","学生5","学生6","学生7","学生8",
                "学生9","学生10"
        };

        StackClass<Student> que = new StackClass<Student>();//创建栈结构对象

        //循环将学生信息添加都对应节点数据域中，并将节点连接到栈结构中
          for( int i = 0; i < studentNames.length; i++ ){
              NodeClass<Student> flag = new NodeClass<Student>();//定义一个数据节点。用来接收数据
              Student stu = new Student();//创建一个学生对象，并对他进行赋值
              stu.setName( studentNames[i] );
              stu.setStuNum(i);
              stu.setOtherInfo("我是班里帅哥榜排第" + ( i + 1 ) + "的人");

              flag.setData(stu);//将已经赋值完成的学生对象添加到新定义的数据节点猴中

              que.add(flag);//qeu指向此节点，将此节点链接到栈结构中
              if( i == 3 || i == 6 || i == 9 ){//为体验栈结构“后进先出”的感念，将第3,6,9个元素入栈后直接出栈
                    NodeClass<Student> as = que.pop();
                    if( as == null ){//判断此时元素是不是为空，为空即输出“空”
                        System.out.println("空了");
                        break;
                    }else{
                        System.out.println(as.getData().getName());
                    }
              }
          }

          for(;;){//循环输出，遍历整个栈
                NodeClass<Student> as = que.pop();
                if( as == null ){
                    System.out.println("空了");
                    break;
                }else{
                    System.out.println(as.getData().getName());
                }
          }

    }
}

5、测试类实现队列

package Stack;

import que.QueClass;

/**
 * Created by Administrator on 2019/9/21.
 */
public class TestClass2 {
    public static void main(String[] args) {
        //建立一个队列结构对象
        QueClass<Student> que=new QueClass<Student>();

//        QueClass<Student> end=new QueClass<Student>();//尾指针

        String[] name=new String[]{
          "qinshuaihang","zhongjainjun","liyuhang","daishubo ","zhaohengfei","yangjianxing","jinxu","liweichen"
        };

        //入队
        for (int i=0;i<name.length;i++){
            NodeClass<Student> flag=new NodeClass<>();
            Student stu=new Student();
            stu.setName(name[i]);
            stu.setStuNum(i+1);
            stu.setOtherInfo("我是第"+(i+1)+"个入队的");
            //将学生放进去节点

            flag.setData(stu);
            que.add(flag);//将节点加入队列
        }

        //出队
        while (true){
            if (que.getQue()==null){
               break;
            }else{
                NodeClass<Student> result = que.pop();
//                System.out.println(result.getData().getName());
                System.out.println("出队"+ result.getData().toString());
            }
        }



    }
}

6、补充

a、判断栈是否为空，可以在定义站结构时给头指针一个初始值-1.来进行判断
判断队列是否为空，可以用头指针和尾指针是否相等来进行判断