「java栈接口」java栈的操作
本篇文章给大家谈谈java栈接口，以及java栈的操作对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、java课设报告图形化显示数据进栈出栈过程
- 2、java内部有没有定义好的栈的类？
- 3、java：编写数据访问接口，再分别以堆栈和队列的形式实现
- 4、JAVA 作业 编写固定长度栈和动态栈，完成入栈和出栈。（注：测试接口。）
- 5、都说 java 中的 栈只能在栈顶进行 插入与删除元素，想问能不能遍历整个 栈以查找到某一个特定的元素
java课设报告图形化显示数据进栈出栈过程
pre t="code" l="java"//栈接口
/**
* 2016/10/31 10:19
*
* @author 3306 TODO
*/
public interface StackInterfaceT {
/**
* 压入元素
*
* @param element 元素
*/
void push(T element);
/**
* 弹出栈顶元素
*
* @return T
*/
T pop();
}pre t="code" l="java"//固定长度栈
/**
* 2016/10/31 10:03
*
* @param T 压入元素类型
* @author 3306 TODO 固定长度栈
*/
public class FixedStackT implements StackInterfaceT{
private Object[] objects = new Object[10];
private int index = 0;
/**
* 往固定长度栈压入元素
*
* @param element 元素
* @throws IndexOutOfBoundsException 压缩元素大于栈的容量的时候
*/
public void push(T element) {
if (index objects.length) {
throw new IndexOutOfBoundsException();
}
objects[index++] = element;
}
/**
* 弹出栈顶元素
*
* @return T
*/
public T pop() {
if (index 0) {
throw new IndexOutOfBoundsException();
}
return (T) objects[--index];
}
}pre t="code" l="java"//动态栈
import java.util.ArrayList;
import java.util.List;
/**
* 2016/10/31 10:23
*
* @author 3306 TODO
*/
public class FreeStackT implements StackInterfaceT {
private ListT storage = new ArrayList();
private int index = 0;
@Override
public void push(T element) {
if (null == element) {
throw new IllegalArgumentException();
}
storage.add(element);
index++;
}
@Override
public T pop() {
if (index 0) {
throw new IndexOutOfBoundsException();
}
return storage.get(--index);
}
}pre t="code" l="java"//student类
/**
* 2016/10/31 10:11
*
* @author 3306 TODO
*/
public class Student {
private int studentNo;
private String studentName;
public int getStudentNo() {
return studentNo;
}
public void setStudentNo(int studentNo) {
this.studentNo = studentNo;
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
}
@Override
public String toString() {
return "Student{" +
"studentNo=" + studentNo +
", studentName='" + studentName + '\'' +
'}';
}
}pre t="code" l="java"//测试类
/**
* 2016/10/31 10:12
*
* @author 3306 TODO
*/
public class TestStack {
public static void main(String[] args) {
testStableStack();
testFreeStack();
}
private static void testStableStack() {
System.out.println("\n\n----------- fixed ------------");
StackInterfaceStudent myStack = new FixedStack();
int numOfStudent = 3;
for (int index = 0; index numOfStudent; index++) {
Student stu = new Student();
stu.setStudentNo(index);
stu.setStudentName("stu" + index);
myStack.push(stu);
}
for (int index = 0; index numOfStudent; index++) {
System.out.println(myStack.pop());
}
}
private static void testFreeStack() {
System.out.println("\n\n----------- free ------------");
StackInterfaceStudent freeStack = new FreeStack();
int numOfStudent = 5;
for (int index = 0; index numOfStudent; index++) {
Student stu = new Student();
stu.setStudentNo(index);
stu.setStudentName("stu" + index);
freeStack.push(stu);
}
for (int index = 0; index numOfStudent; index++) {
System.out.println(freeStack.pop());
}
}
}
java内部有没有定义好的栈的类？
有。
数据结构中的栈，在解决很多问题都有用处，比如括号匹配，迷宫求解，表达式求值等等，java中有封装好的类，可以直接调用。
使用链表来实现栈比用数组更加方便，也易于节省空间，因为栈只能在栈顶进行操作，不需要进行随机访问栈元素。首先实现栈接口IStack,提供出栈、入栈、获取栈顶元素、判断是否为空以及清空栈等基本功能：定义一个Node类，用于保存链中点的信息。
栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
java：编写数据访问接口，再分别以堆栈和队列的形式实现
链队列的定义：
队列的链式存储结构简称为链队列。它是限制仅在表头删除和表尾插入的单链表。
链队列的数据存储形式：
链队列基本运算的实现：
[java] view plain copy
package study_02.datastructure.queue;
/**
* 链队列
* @author WWX
*/
public class LinkQueueT {
//链的数据结构
private class Node{
public T data;
public Node next;
//无参构造函数
public Node(){}
public Node(T data,Node next){
this.data=data;
this.next=next;
}
}
//队列头指针
private Node front;
//队列尾指针
private Node rear;
//队列长度
private int size=0;
public LinkQueue(){
Node n=new Node(null,null);
n.next=null;
front=rear=n;
}
/**
* 队列入队算法
* @param data
* @author WWX
*/
public void enqueue(T data){
//创建一个节点
Node s=new Node(data,null);
//将队尾指针指向新加入的节点，将s节点插入队尾
rear.next=s;
rear=s;
size++;
}
/**
* 队列出队算法
* @return
* @author WWX
*/
public T dequeue(){
if(rear==front){
try {
throw new Exception("堆栈为空");
} catch (Exception e) {
e.printStackTrace();
}
return null;
}else{
//暂存队头元素
Node p=front.next;
T x=p.data;
//将队头元素所在节点摘链
front.next=p.next;
//判断出队列长度是否为1
if(p.next==null)
rear=front;
//删除节点
p=null;
size--;
return x;
}
}
/**
* 队列长队
* @return
* @author WWX
*/
public int size(){
return size;
}
/**
* 判断队列是否为空
* @return
* @author WWX
*/
public boolean isEmpty(){
return size==0;
}
public String toString() {
if(isEmpty()){
return "[]";
}else{
StringBuilder sb = new StringBuilder("[");
for(Node current=front.next;current!=null;current=current.next){
sb.append(current.data.toString() + ", ");
}
int len = sb.length();
return sb.delete(len - 2, len).append("]").toString();
}
}
//测试
public static void main(String[] args) {
LinkQueueInteger queue=new LinkQueueInteger();
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);
queue.enqueue(4);
queue.enqueue(5);
queue.enqueue(6);
System.out.println(queue);
System.out.println("出队："+queue.dequeue());
System.out.println("队列长度="+queue.size());
System.out.println(queue);
System.out.println("出队："+queue.dequeue());
System.out.println("队列长度="+queue.size());
System.out.println(queue);
System.out.println("出队："+queue.dequeue());
System.out.println("队列长度="+queue.size());
System.out.println(queue);
}
}
输出结果：
[1, 2, 3, 4, 5, 6]
出队：1
队列长度=5
[2, 3, 4, 5, 6]
出队：2
队列长度=4
[3, 4, 5, 6]
出队：3
队列长度=3
[4, 5, 6]
JAVA 作业 编写固定长度栈和动态栈，完成入栈和出栈。（注：测试接口。）
//栈接口
/**
* 2016/10/31 10:19
*
* @author 3306 TODO
*/
public interface StackInterfaceT {
/**
* 压入元素
*
* @param element 元素
*/
void push(T element);
/**
* 弹出栈顶元素
*
* @return T
*/
T pop();
}
//固定长度栈
/**
* 2016/10/31 10:03
*
* @param T 压入元素类型
* @author 3306 TODO 固定长度栈
*/
public class FixedStackT implements StackInterfaceT{
private Object[] objects = new Object[10];
private int index = 0;
/**
* 往固定长度栈压入元素
*
* @param element 元素
* @throws IndexOutOfBoundsException 压缩元素大于栈的容量的时候
*/
public void push(T element) {
if (index objects.length) {
throw new IndexOutOfBoundsException();
}
objects[index++] = element;
}
/**
* 弹出栈顶元素
*
* @return T
*/
public T pop() {
if (index 0) {
throw new IndexOutOfBoundsException();
}
return (T) objects[--index];
}
}
//动态栈
import java.util.ArrayList;
import java.util.List;
/**
* 2016/10/31 10:23
*
* @author 3306 TODO
*/
public class FreeStackT implements StackInterfaceT {
private ListT storage = new ArrayList();
private int index = 0;
@Override
public void push(T element) {
if (null == element) {
throw new IllegalArgumentException();
}
storage.add(element);
index++;
}
@Override
public T pop() {
if (index 0) {
throw new IndexOutOfBoundsException();
}
return storage.get(--index);
}
}
//student类
/**
* 2016/10/31 10:11
*
* @author 3306 TODO
*/
public class Student {
private int studentNo;
private String studentName;
public int getStudentNo() {
return studentNo;
}
public void setStudentNo(int studentNo) {
this.studentNo = studentNo;
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
}
@Override
public String toString() {
return "Student{" +
"studentNo=" + studentNo +
", studentName='" + studentName + '\'' +
'}';
}
}
//测试类
/**
* 2016/10/31 10:12
*
* @author 3306 TODO
*/
public class TestStack {
public static void main(String[] args) {
testStableStack();
testFreeStack();
}
private static void testStableStack() {
System.out.println("\n\n----------- fixed ------------");
StackInterfaceStudent myStack = new FixedStack();
int numOfStudent = 3;
for (int index = 0; index numOfStudent; index++) {
Student stu = new Student();
stu.setStudentNo(index);
stu.setStudentName("stu" + index);
myStack.push(stu);
}
for (int index = 0; index numOfStudent; index++) {
System.out.println(myStack.pop());
}
}
private static void testFreeStack() {
System.out.println("\n\n----------- free ------------");
StackInterfaceStudent freeStack = new FreeStack();
int numOfStudent = 5;
for (int index = 0; index numOfStudent; index++) {
Student stu = new Student();
stu.setStudentNo(index);
stu.setStudentName("stu" + index);
freeStack.push(stu);
}
for (int index = 0; index numOfStudent; index++) {
System.out.println(freeStack.pop());
}
}
}
都说 java 中的 栈只能在栈顶进行 插入与删除元素，想问能不能遍历整个 栈以查找到某一个特定的元素
当然可以 要看你的栈的实现是否提供改接口
java的stack类提供了以下接口
int search(Object o)
返回对象在堆栈中的位置，以 1 为基数。
关于java栈接口和java栈的操作的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。