「java清空stack」Java清空文件内容
今天给各位分享java清空stack的知识，其中也会对Java清空文件内容进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、Java Stack Array
- 2、java stack 遍历 清空
- 3、C++中堆栈模块stack的使用中怎么清空堆栈啊？
- 4、java内部有没有定义好的栈的类？
- 5、java中Stack的问题
Java Stack Array
给你分析一下jdk中的集合。
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);
StackString stack = new StackString();
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
/**
* 重写迭代器接口中的方法 返回重写后的迭代器对象给接口的引用
*/
IteratorStack iterator = new IteratorStack() {
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了。
java stack 遍历 清空
for(Integer i:stack)遍历栈时不会清空堆栈的数据，这里用的是Stack的父类Vector的方法。
要想遍历并清空堆栈，可这样写：
while(stack.isEmpty())){
System.out.println(stack.pop());// 将数据弹出堆栈
}
C++中堆栈模块stack的使用中怎么清空堆栈啊？
当用户离开一个task一段时间后，系统就会清理掉task里出了rootActivity以外的Activity，如果用户又回来了，显示的是rootActivity，就像是用户离开又回来，是放弃以前的东西，开始新的东西。上面说的是默认的情况，有一些Activity的属性可以用来控制和修改这些行为。
alwaysRetainTaskState
如果一个task里的root Activity的alwaysRetainTaskState属性设置为true，那么前面描述的默认情况就不会出现了，task即使过了一段时间也会一直保留所有的Activity。
clearTaskOnLaunch
如果一个task里的root Activity的clearTaskOnLaunch属性设置为true，和alwaysRetainTaskState相反，即使是一瞬间的离开，系 统马上就会清理掉task里出rootActivity以外的所有Activity。
扩展资料
堆栈的作用：
在绝大多数的平台上，堆栈主要完成这么四个事情：
1、临时数据存放。
主要通过 push 和 pop 两个指令完成。这就好比，我们在工作的时候，手边临时拿不了的东西，先暂时放在桌子上，等手头空闲下来了，再移动到该存放的地方。
2、存放函数局部变量。
3、存放函数的虚参。
4、记录调用轨迹。
稍大的程序一般是一个函数调用另一个函数，然后再调用其他函数......为了能够让函数执行后按照原先的顺序返回，堆栈就必须记录调用的轨迹。
堆栈要求太高而导致溢出的原因：
1、需要临时存储的信息太多了。这种情况多发生在用内部函数（例如 max 、read、数组整体赋值 ）处理较大量的数组。这种时候，我们可以用循环来代替一些内部函数，或者用循环分批次地处理内部函数。
2、函数局部变量太大。局部变量多数存储在堆栈里，当它很大是，就容易溢出。尤其针对数组大小由虚参给定的情况。
java内部有没有定义好的栈的类？
有。
数据结构中的栈，在解决很多问题都有用处，比如括号匹配，迷宫求解，表达式求值等等，java中有封装好的类，可以直接调用。
使用链表来实现栈比用数组更加方便，也易于节省空间，因为栈只能在栈顶进行操作，不需要进行随机访问栈元素。首先实现栈接口IStack,提供出栈、入栈、获取栈顶元素、判断是否为空以及清空栈等基本功能：定义一个Node类，用于保存链中点的信息。
栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
java中Stack的问题
闲着实在无聊......
写了个简单的双链表实现Stack。未引用任何包。
public class Main {
public static void main(String[] args) {
Stack s = new Stack();
s.put("abc");//压栈
s.put("def");//压栈
s.put("ghi");
System.out.println(s.pop());//出栈
System.out.println(s.isEmpty());//判断栈是否为空
System.out.println(s.pop());
System.out.println(s.isEmpty());
System.out.println(s.pop());
System.out.println(s.isEmpty());
}
}
class Stack {
private Node root = new Node();
private Node top = root;
public Object pop() {
if(top != null) {
Object value = top.getValue();
top = top.getPrevious();
return value;
} else {
return null;
}
}
public void put(Object value) {
Node n = new Node(top, value);
top.setNext(n);
top = n;
}
public boolean isEmpty() {
return top.getPrevious() == null;
}
}
class Node {
private Node next;
private Object value;
private Node previous;
public Node() {
}
public Node(Node previous, Object value) {
this.previous = previous;
this.value = value;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
public Node getPrevious() {
return previous;
}
public void setPrevious(Node previous) {
this.previous = previous;
}
}
java清空stack的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于Java清空文件内容、java清空stack的信息别忘了在本站进行查找喔。
发布于：2022-11-23，除非注明，否则均为原创文章，转载请注明出处。