栈（Stack）基础知识及常见面试题

说到栈，我们需要先了解这些概念：
寄存器：最快的存储区, 由编译器根据需求进行分配，程序中无法控制。
栈：存放基本类型的变量数据和对象的引用，但栈不存对象本身，对象本身存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中）

堆：存放所有new出来的对象。
静态域：存放静态成员（static定义的）
常量池：存放字符串常量和基本类型常量（public static final）。
非RAM存储：硬盘等永久存储空间

栈和常量池中的对象可以共享，对于堆中的对象不可以共享。

栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会消失。堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定，具有很大的灵活性。

对于字符串：其对象的引用都是存储在栈中的，如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中。对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。

public static void main(String[] args) {
        String s1 = "china";
        String s2 = "china";
        String s3 = "china";
        String ss1 = new String("china");
        String ss2 = new String("china");
        String ss3 = new String("china");
    }

当通过new产生一个字符串（比如”china”）时，会先去常量池中查找该对象是否已经存在，如果没有则会在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”china”对象的拷贝对象。

对于基础类型的变量和常量：变量和引用存储在栈中，常量存储在常量池中。

对于成员变量和局部变量：成员变量就是方法外部，类的内部定义的变量；局部变量就是方法或语句块内部定义的变量。局部变量必须初始化。
形式参数是局部变量，局部变量的数据存在于栈内存中。栈内存中的局部变量随着方法的消失而消失。
成员变量存储在堆中的对象里面，由垃圾回收器负责回收。

int i1 = 9;
int i2 = 9;
int i3 = 9;
public static final int INT1 = 9;
public static final int INT2 = 9;
public static final int INT3 = 9;

class BirthDate {  
    private int day;  
    private int month;  
    private int year;      
    public BirthDate(int d, int m, int y) {  
        day = d;   
        month = m;   
        year = y;  
    }  
    省略get,set方法………  
}  
  
public class Test{  
    public static void main(String args[]){  
        int date = 9;  
        Test test = new Test();        
        test.change(date);   
        BirthDate d1= new BirthDate(7,7,1970);         
    }    
  
    public void change1(int i){  
        i = 1234;  
    }  

对于第2段代码，date为局部变量，i、d、m、y都是形参为局部变量，day、month、year为成员变量，代码执行时候的变化：

1. main方法开始执行：int date = 9;
   date局部变量，基础类型，引用和值都存在栈中。

2. Test test = new Test();
   test为对象引用，存在栈中，对象new Test()存在堆中。

3. test.change(date);
   i为局部变量，引用和值存在栈中。当方法change执行完成后，i就会从栈中消失。

4. BirthDate d1= new BirthDate(7,7,1970);
   d1为对象引用，存在栈中，对象(new BirthDate())存在堆中，其中d，m，y为局部变量存储在栈中，且它们的类型为基础类型，因此它们的数据也存储在栈中。day,month,year为成员变量，它们存储在堆中(new BirthDate()里面)。当BirthDate构造方法执行完之后，d,m,y将从栈中消失。

5.main方法执行完之后，date变量，test，d1引用将从栈中消失，new Test(),new BirthDate()将等待垃圾回收。

常见面试题
1、String s = new String(“xyz”)会产生几个对象？
A、1个 B、2个 C、A和B都对 D、A和B都不对
正确答案，选择C，一个或两个，如果常量池中原来没有”xyz”，就是两个。

2、判断下面进出栈输出结果是true还是false?
inseq = {1,2,3,4,5} outseq={5,4,3,2,1} 返回true；

inseq = {1,2,3,4,5} outseq={4,3,2,1,5} 返回true；

inseq = {1,2,3,4,5} outseq={2,3,5,1,4} 返回false。

栈出入规则，一定是遵从后进先出！

3、如何用数组实现一个栈结构？（常常问到）
栈中存在5个方法，即：empty()、peek()、pop()、push()、search()。要想实现一个站结构，我们需要分别构造相应的方法，使之达到预期的效果，所以先定接口：

//栈先进后出==只能在栈顶(top)对数据项进行插入和删除
public interface IStack {
    int push(int element); // 向栈顶插入元素

    int pop(); // 从栈顶取出元素

    int peek(); // 获得当前栈顶元素

    boolean isEmpty(); // 栈是否为空

    int search(); // 查找元素在栈中的位置

}

import java.util.EmptyStackException;

/**
 * Java数组实现栈结构
 */
public class Stack implements IStack {
    // 默认容量
    private static final int DEFAULT_CAPITILY = 10;
    // 扩容倍数
    private static final int FACTOR = 2;
    // 元素个数
    private int listSize = 0;

    // 数组，注意数组的长度>=集合长度(coreArray.length>=listSize)
    private int[] coreArray = new int[DEFAULT_CAPITILY];

    @Override
    public int push(int element) {
        // 判断是否需要扩容
        if (listSize >= coreArray.length) {
            int[] newArray = new int[coreArray.length * FACTOR];
            System.arraycopy(coreArray, 0, newArray, 0, coreArray.length);
            coreArray = newArray;

        }
        coreArray[listSize++] = element;
        return element;

    }
    
    ///移除堆栈顶部的对象
    @Override
    public int pop() {
        if (listSize > 0) {
//          int result = coreArray[listSize - 1]; //同下
            int result = this.peek();  
            coreArray[listSize - 1] = 0;
            listSize--; //减少元素个数
            return result;
        } else {
            throw new EmptyStackException(); // 栈为空
        }
    }
    
    //查看栈顶部的对象
    @Override
    public int peek() {
        if (listSize > 0) {
            return coreArray[listSize - 1]; //获取栈顶元素
        } else {
            throw new EmptyStackException(); //栈为空
        }
    }

    @Override
    public boolean isEmpty() {

        return listSize == 0;
    }

    @Override
    public int search() {
        return listSize;
    }
}

public class TestStack {
    public static void main(String[] args) {

        Stack stack = new Stack();
        System.out.println("isEmpty:" + stack.isEmpty()); //true
        for (int i = 0; i < 10; i++) {
            stack.push(i);
        }
        System.out.println("peek:" + stack.peek()); //9
        while (!stack.isEmpty()) {
            System.out.println(stack.pop()); //先进后出 9876543210
        }

    }
}