Java Stack<E> Array
作者&投稿：宗政汪 （若有异议请与网页底部的电邮联系）
1. E是泛型，查阅泛型相关资料吧
2. 用Double对象，计算的时候用doubleValue()得到double值再计算
import java.io.File;import java.io.FileNotFoundException;import java.util.EmptyStackException;import java.util.Scanner;import java.util.Stack;public class TestParenthese {public static void main(String[] args) {long startTime = System.currentTimeMillis();File myFile = new File("test.txt");try {Scanner input = new Scanner(myFile);String aLine;int x = input.nextInt();// 分别创建两个字符串来保存括号对的左括号和右括号String openParentheses = "";String closeParentheses = "";System.out.println("run:
======================================================================");System.out.println("Parentheses:");for (int i = 0; i stack = new Stack();boolean success = true;for (int i = 0; i < aLine.length(); i++) {char ch = aLine.charAt(i);System.out.print(ch);if (openParentheses.indexOf(ch) != -1) {stack.push(ch);} else if (closeParentheses.indexOf(ch) != -1) {char open;try {open = stack.pop();} catch (EmptyStackException e) {System.out.println(" **MISMATCH: Too many parentheses");success = false;break;}if (openParentheses.indexOf(open) != closeParentheses.indexOf(ch)) {System.out.printf(" **MISMATCH: %c should be %c
", ch,closeParentheses.charAt(openParentheses.indexOf(open)));success = false;break;}}}if (success) {if (!stack.isEmpty())System.out.println(" **MISMATCH: Not enough parentheses"); elseSystem.out.println("**GOOD");}}input.close();} catch (FileNotFoundException e) {e.printStackTrace();}System.out.println("======================================================================");long endTime = System.currentTimeMillis();long sec = (endTime - startTime) / 1000;System.out.printf("BUILD SUCCESSFULLY (total time: %d seconds)
", sec);}}
JDK自带的实现了Array接口的数组 LinkedArray和ArrayList都是大小可变的，其中linked底层使用链表实现不必说，ArrayList底层虽然使用数组实现，但是当插入元素已满是，自动扩种默认元素个大小，所以不满足你的需求。Set和List接口继承了Collection的接口。他们的实现类TreeSet和HashSet以及LinkedLis和Listd都和数组实现类一样是自动扩充的。
所以jdk中找不到一个按你要求来的Collection实现类和Array实现类。
那么考虑解决方案：
第一种：使用数组代替 像楼上的两位说的，但是数组时不提供remove方法的，而且频繁操作的时候来其麻烦。使用如下
Stack[] stack=new Stack[3];
创建一个容量为3的数组，里面只能存放Stack.
第二种:实现Collection接口，写一个Colletion接口的实现类，虽然写的时候比较麻烦但是一劳永逸，Collection接口的实现类封装各种强大的方法，这样操作的时候就方便多了。可以将实现类的引用传给接口，面向接口编程使得程序的扩展性上了一个台阶。而且由于封装大大提高了复用性，比如判断是否包含一个元素 子要调用contains方法就ok了而不用每次都自己一个一个比较
我根据楼主的需求写了一个Collection的实现类。都组可以运行一下。
测试的类 Test 只测试了其中的一部分方法 其你可以测一下 有问题联系我
import java.util.*
public class Test{
/**
*测试用的主方法，应该拿到别的类中 此类为一个封装类
*为了给楼主看着方便就不提到别的类中了
*/
public static void main(String args[]) {
/**由于StackArray实现了Collection接口所以可以这么用
*也可以使用 StackArray stackArray = new StackArray(3)
*/
Collection stackArray = new StackArray(3);
Stack<String> stack = new Stack<String>();
stack.push("aaa");
stack.push("bbb");
stackArray.add(stack);
stackArray.add(stack);
stackArray.add(stack);
/*第四个加不进去了 超出了容量*/
stackArray.add(stack);
/*显示StackArray中元素的个数*/
System.out.println(stackArray.size());
/*判断是否为空*/
System.out.println(stackArray.isEmpty());
/**
*因为stackArray实现了Itorator 所以可以使用增强的for *循环遍历
*也可以改成普通的for循环 但是要输出其中的元素首先要*调用stackArray.toArray()方法
*将stackArray转换成数组 再循环遍历数组 比较麻烦
*/
for (Object o : stackArray) {
System.out.println(o);
}
/*清空*/
stackArray.clear();
/*判断是否为空*/
System.out.println(stackArray.isEmpty());
}
}
StackArray类：
import java.util.Collection;
import java.util.Iterator;
import java.util.Stack;
/***
*
* @author Administrator
* 这个类用来顺序的存储栈（Stack类型）的元素
* 数据结构采用数组的形式 这样做的目的是为了删除一个元素的时候保留其位置。
* 成员变量length记录数组的容量
* 成员变量size记录里面已有元素的个数
*/
public class StackArray implements Collection {
private int length;
private int size;
Stack[] stack = null;
/**
* 构造方法 创建一个栈数组 容量为length
*
* @param int类型 表示要创建的容器的容量
* @return 构造方法返回值为空
* */
public StackArray(int length) {
this.length = length;
stack = new Stack[length];
}
/**
* 添加一个栈
* @param Stack 表示类型 为要添加的栈
* @return 如果添加成功返回true 失败(数组已经满了)返回false
* */
public boolean add(Object entry) {
// TODO Auto-generated method stub
for (int i = 0; i <length; i++) {
if(stack[i]==null){
stack[i]=(Stack)entry;
return true;
}
}
return false;
}
/**
* 将指定集合中的所有元素添加到StackArray
* @param 要添加的元素集
* @return 添加成功返回true
*/
public boolean addAll(Collection c) {
for (Object o : c) {
add(o);
}
return true;
}
/**
* 清除StackArray中的所有元素
* @param void
* @return void
*/
public void clear() {
for (int i = 0; i < this.size(); i++) {
stack[i] = null;
}
}
/**
*判断Stack中是否包含指定元素o
*@param 指定元素
*@return包含返回true 不包含返回false
*/
public boolean contains(Object o) {
// TODO Auto-generated method stub
for (Stack s : stack) {
if (s == (Stack) o) {
return true;
}
}
return false;
}
/**
* 判断是否包含制定集合中所有的元素
* @param 想要判断的集合 集合里元素类型应该为Stack
* @return 如果集合中有元素师StackArray中没有的 返回false如果都有返回true
*/
public boolean containsAll(Collection c) {
// TODO Auto-generated method stub
for (Object o : c) {
if (contains(o)) {
} else {
return false;
}
}
return true;
}
/**
* 判断StackArray是否为空
* @param void
* @return 如果为空返回True 不为空返回false
*/
public boolean isEmpty() {
// TODO Auto-generated method stub
if (this.size() == 0) {
return true;
} else {
return false;
}
}
/**
* 删除StackArray中的制定元素 o
* @param 将要删除的元素
* @return 删除后返回ture
*/
public boolean remove(Object o) {
// TODO Auto-generated method stub
for (int i = 0; i < length; i++) {
if (stack[i] == (Stack) o) {
stack[i] = null;
}
}
return true;
}
/**
* 移除StackArray中包含在Collection中的元素
* @param 装有要删除元素的集合
* @param 删除后返回true
*/
public boolean removeAll(Collection c) {
// TODO Auto-generated method stub
for (Object o : c) {
remove(o);
}
return true;
}
/**
* 计算StackArray中元素的个数
* @param void
* @return StackArray中元素的个数
*/
public int size() {
// TODO Auto-generated method stub
size = length;
for (int i = length - 1; i >= 0; i--) {
if (stack[i] == null) {
size--;
} else {
break;
}
}
return size;
}
/**
* 将StackArray转换成数组
* @param void
* @return Object数组
*/
public Object[] toArray() {
// TODO Auto-generated method stub
return (Object[]) stack;
}
/**
* 将一个数组向上造型呈Object数组
* @param 任意类型的数组
* @Object数组
*/
public Object[] toArray(Object[] a) {
// TODO Auto-generated method stub
return (Object[]) a;
}
/**
* 内部类重写迭代器 用来迭代显示加入的栈
*@param void
*@return 自定义的迭代器 能够依次的显示StackArray中的栈
*/
@Override
public Iterator iterator() {
// TODO Auto-generated method stub
/**
* 重写迭代器接口中的方法 返回重写后的迭代器对象给接口的引用
*/
Iterator<Stack> iterator = new Iterator<Stack>() {
int index = 0;
@Override
public boolean hasNext() {
// TODO Auto-generated method stub
if (index >= length) {
return false;
} else {
return true;
}
}
@Override
public Stack next() {
return stack[index++];
}
@Override
public void remove() {
// TODO Auto-generated method stub
StackArray.this.remove(stack[index]);
}
};
return iterator;
}
/**
* 留下StackArray中和Collection的交集
* @param 集合类
* 注意测方法尚未实现
*/
@Override
public boolean retainAll(Collection c) {
// TODO Auto-generated method stub
return false;
}
}
测试结果：
false
[aaa, bbb]
[aaa, bbb]
[aaa, bbb]
true
还有第三种解决方法：就是集成AarryList 然后覆盖父类方法，但是不推荐这个，因为要覆盖分方法太多还不如重写Collection了。
stack就是一个collection啊，其他集合或者数组可以实现你的功能，随便new一个固定长度的Array，把他当成栈用不就行了，只不过没有add或者remove方法而已，你可以用赋值代替啊，入栈就直接 a[0]=1，出栈就是a[0]=null
栈也是个对象呀。那就直接申明一个对象数组呗，数组类型为stack<E>!remove一个stack就是把数组相应位置的值赋为null。
什么意思，Array本来就可以存stack的，你想实现什么样的逻辑啊，说清楚一点啊
樊马悦康： Stack<Double> stack = new Stack<Double>(); stack.push(1); stack.push(1.5); ..... double d = stack.pop(); E这玩意随便给个类型就是那种类型 要不你就强制类型转换
高明区19577715342： 在JAVA中常用的数据结构(容器)有哪些?有什么特点?？
樊马悦康： 问题过于宽泛,简单列举几个接口: 接口 Collection<E>: Collection 层次结构 中的根接口.Collection 表示一组对象,这些对象也称为 collection 的元素.一些 collection 允许有重复的元素,而另一些则不允许.一些 collection 是有序的,而...
高明区19577715342： java栈stack和堆heap的工作原理,用途和区别? - ？
樊马悦康： java堆和栈的区别 Java中内存分成两种:一种是栈stack,一种是堆heap.函数中的一些基本类型的变量(int, float)和对象的引用变量(reference)都在函数的栈中,马克-to-win,(工作于编译阶段, 生成class文件之前)分配.存取速度快,...
高明区19577715342： java 在栈中push数组 - ？
樊马悦康： 直接就写数组啊 float[][]a = new float[10][]; Stack<float[][]> stack = new Stack<float[][]>(); stack.push(a);
高明区19577715342： java里的collection<E>的问题?？
樊马悦康： collection<E>里的E是＂元素＂的意思.但不要忘了object也是一种类型,用object可以达到令容器可以存储任何类型的值 但是它E表示的是任何的类型 不能只局限于object 本身 ,有的时候我们要求我们的元素保留自己的特性 ,一旦他被转...
高明区19577715342： java Stack问题 想把栈中的char类型元素赋值给变量,编译器报错.求解释,求真相.？
樊马悦康： char ch = 是基本类型char类型,而s.peek()返回的是object类型, object类型肯定不能自动转化为基本类型char得,可以改成这样 import java.util.Stack; public class test { public static void main(String args[]) { Stack s = new Stack(); s.push('a'); char ch = s.peek().toString().charAt(0); System.out.println(s.peek()); } }
高明区19577715342： 1. 用C++或Java写一个关于堆栈的类描述,并为堆栈的压栈(push)和出栈(pop)操作编写方法？
樊马悦康： #include<iostream.h>using namespace std;const int MAX=5; //假定栈中最多保存5个数据//定义名为stack的类,其具有栈功能class stack { //数据成员 float num[MAX]; //存放栈数据的数组 int top; //指示栈顶位置的变量 public: //成员函数 ...
高明区19577715342： Java中栈的使用 - ？
樊马悦康： 和C++里面一样,有入栈,弹栈,查找函数import java.util.*;(引入包含栈类的头文件)相关函数介绍 boolean empty() 测试堆栈是否为空. E peek() 查看堆栈顶部的对象,但不从堆栈...
高明区19577715342： java中栈是如何实现的?？
樊马悦康： 这是java.util包下的Stack类,你可以看一下它是如何实现的,至于用法,无非就是push,pop,peek等操作等/*nbsp;*nbsp;@(#)Stack.javanbsp;1.30nbsp;05/11/17nbsp;*nbsp;*nbsp;Copyrightnbsp;2006nbsp;Sunnbsp;Microsystems,nbsp;Inc.nbsp;...
高明区19577715342： 关于数据结构(java)的一个代码 - ？
樊马悦康： 描述栈抽象数据类型的SStack接口的声明 public interfaceSStack<E> //栈接口 { boolean isEmpty(); //判断是否空栈,若空栈返回true boolean push(E element); //元素element入栈,若操作成功返回true E pop(); //出栈,返回当前栈顶元素...
