普通数组进实现栈

用封装数组进实现栈

准备好自己封装的数组(有对封装数组进行讲解)

package Array;

public class MyArray <E>{
    private E []data; //1新键一个数组
    private int size;  //2 新键计数数组个数
	public MyArray(int size) {
		data=(E[])new Object[size];
		size=0;
	}
	public MyArray() {  //3 初始化完成
	        this(10);
	}
	
	// 4添加方法>任意位置
	public void add(int index,E e) {
		//判断index 是否越界
		if(index>size||index<0) {
			throw new IllegalArgumentException("下标越界");
		}
		//判断是否需要阔容  >>等于最后一个元素
		if(size==data.length) {
			resize(data.length*2);
		}
		//腾出位置
		for(int i=size-1;i>=index;i--) {
			data[i+1]=data[i];
		}
		//在index的位置添加e，并维护size;
		data[index]=e;
		size++;  //size是先行的
	}

	// 5增加方法>尾部添加 
	public void addLast(E e) {
		//如果数组存放满了，无法继续添加
		add(size,e);

	} 
	//6 增加方法>在头部添加
	public void addFirst(E e) {
		add(0,e);
	}
	//6 删除方法 > 删除指定元素
	//7 删除 >>指定索引值
	public E removeIndex(int index) {
		// TODO Auto-generated method stub
		if(index>=size||index<0) {
		throw new IllegalArgumentException("remove faile,index is illegal");
		}
		//找出待删除元素并存储起来
		E res =data[index];
		for(int i=index;i<size;i++) {
			data[i]=data[i+1]; //往前挪一位进行 覆盖
		}
		//维护size ,因为元素数目减少一位
		size--;
		//懒得算法 缩容>>具有一定弹跳性
		if(size==data.length/4&&data.length!=1) {
			resize(data.length/2);
		}
		return res;
	}
	//8删> 尾部
	public  E removeLast() {
		return removeIndex(size-1);
	}
	//9 删 >头部
	public E removFirst() {
		return removeIndex(0);
	}
	//10查> 指定索引
	public int findIndex(int e) {
		// TODO Auto-generated method stub
		for(int i=0;i<size;i++) {
			if(data[i].equals(e)) {
				return i;
			}
		}
		return -1;
	}
	//11改> 
	public void set(int index ,E e) {
		//改元素之前先判断
		if(index>size||index<0) {
			throw new IllegalArgumentException("set fail,index is Illgal");
		}
		data[index]=e;
	}
	//12 查> 是否含有该元素
	public boolean contain(E e) {
		for(int i=0;i<size;i++) {
		 //值的比较
			if(data[i].equals(e)) {
				return true;
			}
		}
		return false;
	}
	//12 查 > 索引查元素
	public E getElement(int index) {
		//判断索引是否越界
		if(index>=size||index<0) {
		throw new IllegalArgumentException("get index fail,index is illegal");
		}
	return data[index];
	}
	//13 查 >元素查索引
	public int getIndex(int i) {
		return findIndex(i);
	}
	//20 阔容 > 新键一个原先大小两倍数组空间，将原先数组元素一存放到新的数组里面取
	public void resize(int newcapacity) {
		// TODO Auto-generated method stub
		E []newdata=(E[])new Object[newcapacity];
		for(int i=0;i<size;i++) {
			newdata[i]=data[i];
		}
		data=newdata;
	}
	//21 实现栈 新增加的方法
	public E getLast() {  //拿到最后一个元素
		return getElement(size-1);
	}
	//22 拿到元素的个数
	public int getSize() {
		return size;
	}
	//23 判断队列是否为空
	public boolean isEmpty() {
		return size==0;
	}
	
	
    //重写toStriing
	@Override
	public String toString() {
		// TODO Auto-generated method stub
    StringBuffer res=new StringBuffer();
    res.append(String.format("Array:size=%d,capacity=%d\n", size,data.length));
     res.append("[");
     //遍历数组
     for(int i=0;i<size;i++) {
    	 if(i==size-1) {
    		 res.append(data[i]);
    	 }else {
    		 res.append(data[i]+",");
    	 }
     }
     res.append("]");
    return res.toString();
	}
    
}

栈接口

package Stack;

public interface Stack<E> {//1 建立泛型
	void push(E e); //2 入栈
	E pop(); //出栈
	E peek();//查询栈顶的元素
	int getSize(); //查询栈里存放的元素的个数
	boolean isEmpty(); //判断栈是否为空

}

实现栈方法

package Stack;

import Array.MyArray;

public class myStack<E>implements Stack<E> {
    private MyArray<E> array;
   //
	public myStack(int aarray) { //1、第一步初始化数组
		array = new MyArray<>(aarray);
	}
	public myStack() { 
		array=new MyArray<>(10);
	}
	@Override  
	public void push(E e) { //2、增加方法
		// TODO Auto-generated method stub
		array.addLast(e);
	}

	@Override
	public E pop() {  //3删除最后一个元素
		// TODO Auto-generated method stub
		return array.removeLast();
	}

	@Override
	public E peek() { //4、返回栈顶元素也技术最后一个元素怒
		// TODO Auto-generated method stub
		return array.getLast();
	}

	@Override
	public int getSize() { //5、返回栈的元素个数
		// TODO Auto-generated method stub
		return array.getSize();
	}

	@Override
	public boolean isEmpty() { //6、判断栈是否为空
		// TODO Auto-generated method stub
		return array.isEmpty();
	}
	@Override
	public String toString() {
		StringBuilder res=new StringBuilder();
		res.append(String.format("Stack:size=%d",array.getSize() ));
		res.append("\n");
		res.append("[");
		for(int i=0;i<array.getSize();i++) {
			res.append(array.getElement(i));
			if(i!=array.getSize()-1) {
				res.append(",");
			}
		}
		res.append("]");
		return res.toString();
	}

}

测试

package Stack;

public class StackTest {
public static void main(String[] args) {
	myStack<Integer> stack=new myStack();
	stack.push(9);
	stack.push(8);
	stack.push(7);
	stack.push(6);
	stack.push(5);
	stack.push(4);

	int i=stack.getSize();
	System.out.println("栈中的元素为:"+i); 
	System.out.println("判断栈是否为空："+stack.isEmpty());
    int last=stack.peek();
    System.out.println("返回栈中最后的那个元素："+last);
    int a=stack.pop();
    System.out.println("删除最后一个元素："+a);
	System.out.println(stack);
 }
}

实现效果