Java实现Stack类

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Scanner;

public class Stack<Item> implements Iterable<Item> {
    private int N;
    private Node<Item> first;
    private static class Node<Item> {
        private Item item;
        private Node<Item> next;
    }
    public Stack() {
        first = null;
        N = 0;
    }
    public boolean isEmpty() {
        return first == null;
    }
    public int size() {
        return N;
    }
    public void push(Item item) {
        Node<Item> oldfirst = first;
        first = new Node<Item>();
        first.item = item;
        first.next = oldfirst;
        N ++;
    }
    public Item pop() {
        if(isEmpty()) throw new NoSuchElementException("Stack underflow");
        Item item = first.item;
        first = first.next;
        N --;
        return item;
    }
    public Item peek() {
        if(isEmpty()) throw new NoSuchElementException("Stack underflow");
        return first.item;
    }
    public String toString() {
        StringBuilder s = new StringBuilder();
        for(Item item : this)
            s.append(item + " ");
        return s.toString();
    }
    public Iterator<Item> iterator() {
        return new ListIterator<Item>(first);
    }
    private class ListIterator<Item> implements Iterator<Item> {
        private Node<Item> current;
        public ListIterator(Node<Item> first) {
            current = first;
        }
        public boolean hasNext() { return current != null; }
        public void remove() { throw new UnsupportedOperationException(); }
        public Item next() {
            if(!hasNext()) throw new NoSuchElementException();
            Item item = current.item;
            current = current.next;
            return item;
        }
    }
    public static void main(String[] args) {
        Stack<String> s = new Stack<String>();
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {
            String item = in.next();
            if(!item.equals("-")) s.push(item);
            else if(!s.isEmpty()) System.out.println(s.pop() + " ");
            System.out.println("(" + s.size() + " left on stack)");
        }
    }
}
时间: 2024-10-08 21:12:54

Java实现Stack类的相关文章

java.util.Stack类中的peek()方法

java.util.stack类中常用的几个方法:isEmpty(),add(),remove(),contains()等各种方法都不难,但需要注意的是peek()这个方法. peek()查看栈顶的对象而不移除它. import java.util.Stack; public class MyStack1 { private Stack<Integer> stackData; private Stack<Integer> stackMin; public MyStack1(){ t

恶补java(十一)-------Stack类的使用

package com.gc.Stack; /** * java中stack的使用方法,堆栈是一种"后进先出"(LIFO)的数据结构,只能在一端进行插入(称为"压栈")或删除(称为"出栈")数据的操作. * Java中,使用java.util.Stack类的构造方法创建对象 * public class Stack extends vector * 构造方法:public Stack()创建一个空Stack * 1.public push(ite

Java的Stack类实现List接口真的是个笑话吗

今天在网上闲逛时看到了这样一个言论,说“Java的Stack类实现List接口的设计是个笑话”. 当然作者这篇文章的重点不是这个,原本我也只是一笑置之,然而看评论里居然还有人附和,说“Java那种Stack的设计作为笑话,差不多可以算公案了”,我就有点不淡定了,为什么.什么时候“作为笑话”的并且“差不多可以算公案”了呢? 因此我决定写一篇文章来谈谈这个问题. 接口是什么 狭义地讲,接口就是一个类所定义的方法(方法名.参数.返回值).一个类提供了Foo方法,其他类就可以调用它.广义上讲,接口可以理

java.util.Stack类简介

Stack是一个后进先出(last in first out,LIFO)的堆栈,在Vector类的基础上扩展5个方法而来 Deque(双端队列)比起Stack具有更好的完整性和一致性,应该被优先使用 E push(E item)      把项压入堆栈顶部. E pop()        移除堆栈顶部的对象,并作为此函数的值返回该对象. E peek()          查看堆栈顶部的对象,但不从堆栈中移除它. boolean empty()         测试堆栈是否为空. int sea

Java中的栈:java.util.Stack类

public class Stack<E>extends Vector<E>Stack 类表示后进先出(LIFO)的对象堆栈.它通过五个操作对类 Vector 进行了扩展 ,允许将向量视为堆栈.它提供了通常的 push 和 pop 操作,以及取堆栈顶点的 peek 方法.测试堆栈是否为空的 empty 方法.在堆栈中查找项并确定到堆栈顶距离的 search 方法.  方法 使用说明 boolean empty() 测试堆栈是否为空 E peek() 查看堆栈顶部的对象,但不从堆栈移

基于数组实现Java 自定义Stack栈类及应用

栈是存放对象的一种特殊容器,在插入与删除对象时,这种结构遵循后进先出( Last-in-first-out,LIFO)的原则.java本身是有自带Stack类包,为了达到学习目的已经更好深入了解stack栈,自己动手自建java stack类是个很好的学习开始: 自建Java Stack 类 Stack 类: 1 package com.stack; 2 3 import java.util.ArrayList; 4 import java.util.Arrays; 5 6 /** 7 * St

Java 自定义Stack栈类及应用

栈是存放对象的一种特殊容器,在插入与删除对象时,这种结构遵循后进先出( Last-in-first-out,LIFO)的原则.java本身是有自带Stack类包,为了达到学习目的已经更好深入了解stack栈,自己动手自建java stack类是个很好的学习开始: 自建Java Stack 类 Stack 类: package com.stack; import java.util.ArrayList; import java.util.Arrays; /** * Stack Class * @a

[Java]Stack类

Java Stack类顾名思义,实现堆栈.具体方法如下: import java.util.Stack; public class StackTest { public static void main(String[] args) { Stack<String> stack = new Stack<String>(); System.out.println("now the stack is " + isEmpty(stack)); stack.push(&q

java集合类——Stack栈类

今日走读代码时,遇到stack栈类,特查看java的API文档,总结如下: Stack继承Vector类. 栈的特点是后进先出. API中Stack自身的方法不多,基本跟栈的特点有关. 现附上例子,后续继续总结 /** * @作者 whs * @创建日期 2015年2月4日 * @版本 V 1.0 */ package thread.pool; import java.util.Stack; public class StackExam { public static void main(Str