java入栈_Java如何实现堆栈

Ⅰ java 作业编写固定长度栈和动态栈，完成入栈和出栈。（注：测试接口。）

//栈接口

/**
*2016/10/3110:19
*
*@author3306TODO
*/

publicinterfaceStackInterface<T>{
/**
*压入元素
*
*@paramelement元素
*/
voidpush(Telement);

/**
*弹出栈顶元素
*
*@returnT
*/
Tpop();
}

//固定长度栈
/**
*2016/10/3110:03
*
*@param<T>压入元素类型
*@author3306TODO固定长度栈
*/

publicclassFixedStack<T>implementsStackInterface<T>{

privateObject[]objects=newObject[10];
privateintindex=0;

/**
*往固定长度栈压入元素
*
*@paramelement元素
*@压缩元素大于栈的容量的时候
*/
publicvoidpush(Telement){

if(index>objects.length){
();
}

objects[index++]=element;
}

/**
*弹出栈顶元素
*
*@returnT
*/
publicTpop(){

if(index<0){
();
}

return(T)objects[--index];
}
}

//动态栈

importjava.util.ArrayList;
importjava.util.List;

/**
*2016/10/3110:23
*
*@author3306TODO
*/

publicclassFreeStack<T>implementsStackInterface<T>{

privateList<T>storage=newArrayList<>();
privateintindex=0;

@Override
publicvoidpush(Telement){
if(null==element){
();
}

storage.add(element);
index++;
}

@Override
publicTpop(){


if(index<0){
();
}


returnstorage.get(--index);
}
}

//student类

/**
*2016/10/3110:11
*
*@author3306TODO
*/

publicclassStudent{

privateintstudentNo;
privateStringstudentName;

publicintgetStudentNo(){
returnstudentNo;
}

publicvoidsetStudentNo(intstudentNo){
this.studentNo=studentNo;
}

publicStringgetStudentName(){
returnstudentName;
}

publicvoidsetStudentName(StringstudentName){
this.studentName=studentName;
}

@Override
publicStringtoString(){
return"Student{"+
"studentNo="+studentNo+
",studentName='"+studentName+'''+
'}';
}
}

//测试类

/**
*2016/10/3110:12
*
*@author3306TODO
*/

publicclassTestStack{

publicstaticvoidmain(String[]args){

testStableStack();

testFreeStack();
}


(){

System.out.println("

-----------fixed------------");

StackInterface<Student>myStack=newFixedStack<>();
intnumOfStudent=3;

for(intindex=0;index<numOfStudent;index++){
Studentstu=newStudent();

stu.setStudentNo(index);
stu.setStudentName("stu"+index);

myStack.push(stu);
}


for(intindex=0;index<numOfStudent;index++){
System.out.println(myStack.pop());
}


}

(){
System.out.println("

-----------free------------");

StackInterface<Student>freeStack=newFreeStack<>();
intnumOfStudent=5;

for(intindex=0;index<numOfStudent;index++){
Studentstu=newStudent();

stu.setStudentNo(index);
stu.setStudentName("stu"+index);

freeStack.push(stu);
}


for(intindex=0;index<numOfStudent;index++){
System.out.println(freeStack.pop());
}
}


}

Ⅱ Java中栈的使用

和C++里面一样，有入栈，弹栈，查找函数
import java.util.*;(引入包含栈类的头文件)
相关函数介绍
boolean empty()
测试堆栈是否为空。
E peek()
查看堆栈顶部的对象，但不从堆栈中移除它。
E pop()
移除堆栈顶部的对象，并作为此函数的值返回该对象。
E push(E item)
把项压入堆栈顶部。
int search(Object o)
返回对象在堆栈中的位置，以 1 为基数。

Ⅲ JAVA 方法的入栈出栈问题

你得明白栈的定义。代码执行的时候是执行一个方法，执行完，返回方法的上一个代码块继续往下执行后面的内容。这样的话是不是就是一个栈结构了？先进后出。方法一边执行，一边往栈里面存数据，等执行完了就取出数据（取出的是返回值，是最后一个存进去的栈结构是后进先出），然后执行外面的代码。这么说你可能不明白，我给你举个例子。

int sub(int a,int b){
return a+b;

}
int c = sub(2,3);//注意执行这条语句的时候是不是执行了一个方法？
//那么语句执行的时候是要从左往右执行的对吧，但是事实的逻辑却是先算出来sub（2，3）这个方
//法的返回值，然后再把返回值（5）赋值给 c ，那么这个怎么实现，肯定是一个栈的数据结构，编译的时候先把”int c = “入栈，然后再把 sub（2，3），入栈，执行的时候，从栈里面取，取的第一个肯定是sub（2，3）吧？于是就计算出等于5，继续取，取出了int c =，然后就和5对接上了，就把值赋给c了。这只是一个小例子。
道理是这样，但是具体的存取可不是这样的哦。具体的存取应该分的非常细腻，应该是按照java语法的最小单位来往栈里存取的。说白了一句话，程序运行的时候的先后顺序是跟人大脑想问题的顺序一样的，但是代码不是按照这样的顺序写的（从左到右），于是就用栈结构来达到这样的效果。
这么说，明白了吗？

Ⅳ Java如何实现堆栈

//这是JDK提供的栈

import java.util.Stack;

public class UsingStack {
public static void main(String[] args) {
//构造栈对象，使用类型限制，只能存储Integer数据
Stack<Integer> s = new Stack<Integer>();

//1、2、3依次入栈
s.push(1);
s.push(2);
s.push(3);

//3、2、1依次出栈
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
}
}

//这是我写的顺序结构的栈
import java.util.EmptyStackException;
import java.util.Vector;

public class UsingStack{
public static void main(String[] args){
//构造栈对象，使用类型限制，只能存储Integer数据
MyStack<Integer> s = new MyStack<Integer>();

//1、2、3依次入栈
s.push(1);
s.push(2);
s.push(3);

//3、2、1依次出栈
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
}
}

/**
* 栈类
* @author developer_05
* @param <T>
*/
class MyStack<T> extends Vector<T>{
/**
* 构造方法
*/
public MyStack(){
}

/**
* 入栈方法
* @param item 待入栈的元素
* @return 返回入栈的元素
*/
public T push(T item) {
addElement(item);

return item;
}

/**
* 出栈方法(同步处理)
* @return 返回出栈元素
*/
public synchronized T pop() {
T obj;
int len = size();

if (len == 0)
throw new EmptyStackException();
obj = elementAt(len - 1);

removeElementAt(len - 1);

return obj;
}

/**
* 判断栈是否为空的方法
* @return 返回true(栈空)或false(栈非空)
*/
public boolean empty() {
return size() == 0;
}

private static final long serialVersionUID = 1L;
}

Ⅳ java元素入栈

代码贴全下。
你先弄清楚入栈逻辑。
你应该是自己用数组来实现固定大小栈的功能。
top 应该是最后一次元素的位置。
getSize() 应该是数组长度应该是数组当前实际存储的长度
入栈第一步是不是先要判断一下这一次入栈会不会超过当前栈的大小。
我认为if(getSize()>=elements.length) 是这个功能。
然后如果此次入栈没有超过其数组的大小。
那么将其入栈。

Ⅵ java数据结构有关于入栈和入队的问题

这和具体的实现有关，例如top初始值为-1，当然要先加一，然后在放数据。如果top初始值是0那么也可以是data[top++]这样的形式。tail也是一样的道理，放入数据在加一，下一次就可以先放数据。

Ⅶ java 进栈

public StackX(int maxSize){
maxSize=maxSize;
stackarray=new long[maxSize];
top=-1;
}

不好意思，你犯了一个很傻的错误，这里应该是this.maxSize = maxSize,否则的话，你的实例变量maxSize还是没有被初始化为正确值，而只是默认值0

Ⅷ java stack栈的入栈出栈问题

java 里面的对象传入多为址传递，当你传递一个对象的时候，如果是址传递，那么接收者存储的只是被传递对象的地址，所以，当这个地址上的元素发生变化的时候，所有引用该地址的变量都会发生变化。

导航:首页 > 编程语言 > java入栈

java入栈

与java入栈相关的资料