⑴ java中什麼叫堆棧
和別的一樣啊，就是後進去的先出來！
⑵ java中什麼是棧啊
存放基本類型的變數數據和對象的引用，但對象本身不存放在棧中，而是存放在堆（new 出來的對象）或者常量池中（字元串常量對象存放在常量池中。）。
棧和常量池中的對象可以共享，對於堆中的對象不可以共享。棧中的數據大小和生命周期是可以確定的，當沒有引用指向數據時，這個數據就會消失。堆中的對象的由垃圾回收器負責回收，因此大小和生命周期不需要確定。
局部變數的數據存在於棧內存中。
棧的優勢是，存取速度比堆要快，僅次於寄存器，棧數據可以共享。但缺點是，存在棧中的數據大小與生存期必須是確定的，缺乏靈活性。棧中主要存放一些基本類型的變數數據（int, short, long, byte, float, double, boolean, char）和對象句柄(引用)。
⑶ java 創建棧問題
import java.util.Stack;
public class Test1 {
public static void main(String[] args){
Stack kk = new Stack();
kk.push(new Integer(11));//只能放入對象,int,double是不行的,只有先作成對象
kk.push(new Integer(12));
kk.push(new Integer(13));
kk.push(new Integer(14));
kk.push(new Integer(15));
System.out.println(kk);
kk.pop();
kk.pop(); //後進先出,不存在優先順序的概念
System.out.println(kk);
kk.push("132343");
System.out.println(kk);
}
}
⑷ java 棧 什麼意思
棧是一種常用的數據結構，棧只允許訪問棧頂的元素，棧就像一個杯子，每次都只能取杯子頂上的東西，而對於棧就只能每次訪問它的棧頂元素，從而可以達到保護棧頂元素以下的其他元素．」先進後出」或」後進先出」就是棧的一大特點，先進棧的元素總是要等到後進棧的元素出棧以後才能出棧．遞歸就是利用到了系統棧，暫時保存臨時結果，對臨時結果進行保護．
對於棧的學習，建議你看一看＜數據結構與演算法＞這本書．
⑸ java 棧、方法棧的區別
棧與堆都是Java用來在Ram中存放數據的地方
String
a="a";這樣的創建形式，在棧中主要存放一些基本類型的和對象的句柄，棧有一個很重要的特殊性，就是存在棧中的數據可以共享
String
b
=
new
String("b");堆中主要存放java對象，同時可以在堆棧中創建一個對String類的對象引用變數，也就是說：Java中所有對象的存儲空間都是在堆中分配的，但是這個對象的引用卻是在堆棧中分配,也
就是說在建立一個對象時從兩個地方都分配內存，在堆中分配的內存實際建立這個對象，而在堆棧中分配的內存只是一個指向這個堆對象的指針(引用)而已。
其中的區別包括：申請空間大小、效率、存儲內容上的差異
⑹ java中棧的應用
棧中存儲的是方法參數變數和方法體中的局部變數還有整形變數。。具體的應用你可以去看thinking in java。。。
⑺ java中棧是如何實現的
這是java.util包下的Stack類，你可以看一下它是如何實現的，至於用法，無非就是push，pop，peek等操作等
/*
* @(#)Stack.java 1.30 05/11/17
*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
package java.util;
/**
* The <code>Stack</code> class represents a last-in-first-out
* (LIFO) stack of objects. It extends class <tt>Vector</tt> with five
* operations that allow a vector to be treated as a stack. The usual
* <tt>push</tt> and <tt>pop</tt> operations are provided, as well as a
* method to <tt>peek</tt> at the top item on the stack, a method to test
* for whether the stack is <tt>empty</tt>, and a method to <tt>search</tt>
* the stack for an item and discover how far it is from the top.
* <p>
* When a stack is first created, it contains no items.
*
* <p>A more complete and consistent set of LIFO stack operations is
* provided by the {@link Deque} interface and its implementations, which
* should be used in preference to this class. For example:
* <pre> {@code
* Deque<Integer> stack = new ArrayDeque<Integer>();}</pre>
*
* @author Jonathan Payne
* @version 1.30, 11/17/05
* @since JDK1.0
*/
public
class Stack<E> extends Vector<E> {
/**
* Creates an empty Stack.
*/
public Stack() {
}
/**
* Pushes an item onto the top of this stack. This has exactly
* the same effect as:
* <blockquote><pre>
* addElement(item)</pre></blockquote>
*
* @param item the item to be pushed onto this stack.
* @return the <code>item</code> argument.
* @see java.util.Vector#addElement
*/
public E push(E item) {
addElement(item);
return item;
}
/**
* Removes the object at the top of this stack and returns that
* object as the value of this function.
*
* @return The object at the top of this stack (the last item
* of the <tt>Vector</tt> object).
* @exception EmptyStackException if this stack is empty.
*/
public synchronized E pop() {
E obj;
int len = size();
obj = peek();
removeElementAt(len - 1);
return obj;
}
/**
* Looks at the object at the top of this stack without removing it
* from the stack.
*
* @return the object at the top of this stack (the last item
* of the <tt>Vector</tt> object).
* @exception EmptyStackException if this stack is empty.
*/
public synchronized E peek() {
int len = size();
if (len == 0)
throw new EmptyStackException();
return elementAt(len - 1);
}
/**
* Tests if this stack is empty.
*
* @return <code>true</code> if and only if this stack contains
* no items; <code>false</code> otherwise.
*/
public boolean empty() {
return size() == 0;
}
/**
* Returns the 1-based position where an object is on this stack.
* If the object <tt>o</tt> occurs as an item in this stack, this
* method returns the distance from the top of the stack of the
* occurrence nearest the top of the stack; the topmost item on the
* stack is considered to be at distance <tt>1</tt>. The <tt>equals</tt>
* method is used to compare <tt>o</tt> to the
* items in this stack.
*
* @param o the desired object.
* @return the 1-based position from the top of the stack where
* the object is located; the return value <code>-1</code>
* indicates that the object is not on the stack.
*/
public synchronized int search(Object o) {
int i = lastIndexOf(o);
if (i >= 0) {
return size() - i;
}
return -1;
}
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = 1224463164541339165L;
}
⑻ Java中為什麼棧運行
ava Virtual Machine Stacks，線程私有，生命周期與線程相同，描述的是Java方法執行的內存模型：每一個方法執行的同時都會創建一個棧幀（Stack Frame），由於存儲局部變數表、操作數棧、動態鏈接、方法出口等信息。每一個方法的執行就對應著棧幀在虛擬機棧中的入棧，出棧過程。
局部變數表：
存放編譯期可知的各種基本數據類型、對象引用類型和returnAddress類型（指向一條位元組碼指令的地址：函數返回地址）。
long、double佔用兩個局部變數控制項Slot。
局部變數表所需的內存空間在編譯期確定，當進入一個方法時，方法在棧幀中所需要分配的局部變數控制項是完全確定的，不可動態改變大小。
異常：線程請求的棧幀深度大於虛擬機所允許的深度---StackOverFlowError，如果虛擬機棧可以動態擴展（大部分虛擬機允許動態擴展，也可以設置固定大小的虛擬機棧），但是無法申請到足夠的內存---OutOfMemorError。
操作數棧：
後進先出LIFO，最大深度由編譯期確定。棧幀剛建立使，操作數棧為空，執行方法操作時，操作數棧用於存放JVM從局部變數表復制的常量或者變數，提供提取，及結果入棧，也用於存放調用方法需要的參數及接受方法返回的結果。
操作數棧可以存放一個jvm中定義的任意數據類型的值。
在任意時刻，操作數棧都一個固定的棧深度，基本類型除了long、double佔用兩個深度，其它佔用一個深度
動態連接：
每個棧幀都包含一個指向運行時常量池中該棧幀所屬方法的引用，持有這個引用是為了支持方法調用過程中的動態連接。Class文件的常量池中存在有大量的符號引用，位元組碼中的方法調用指令就以常量池中指向方法的符號引用為參數。這些符號引用，一部分會在類載入階段或第一次使用的時候轉化為直接引用（如final、static域等），稱為靜態解析，另一部分將在每一次的運行期間轉化為直接引用，這部分稱為動態連接。
方法返回地址：
當一個方法被執行後，有兩種方式退出該方法：執行引擎遇到了任意一個方法返回的位元組碼指令或遇到了異常，並且該異常沒有在方法體內得到處理。無論採用何種退出方式，在方法退出之後，都需要返回到方法被調用的位置，程序才能繼續執行。方法返回時可能需要在棧幀中保存一些信息，用來幫助恢復它的上層方法的執行狀態。一般來說，方法正常退出時，調用者的PC計數器的值就可以作為返回地址，棧幀中很可能保存了這個計數器值，而方法異常退出時，返回地址是要通過異常處理器來確定的，棧幀中一般不會保存這部分信息。
方法退出的過程實際上等同於把當前棧幀出棧，因此退出時可能執行的操作有：恢復上層方法的局部變數表和操作數棧，如果有返回值，則把它壓入調用者棧幀的操作數棧中，調整PC計數器的值以指向方法調用指令後面的一條指令。
⑼ 棧與隊列的實現(java)
import java.util.Stack;
public class Translate {
//程序入口
public static void main(String[]args){
int n = Translate.translate(3467,8);
System.out.println("結果是："+n);
}
public static int translate(int number, int base_num) {
//使用棧
Stack<Integer>stack = new Stack<Integer>();
while(number>0){
//壓棧
stack.push(number % base_num);
number /= base_num;
}
int n = stack.size();
int val=0;
//依次出棧並合成結果（用我們熟悉的十進製表示，所以乘以10）
for(int i=0;i<n;i++){
val=val*10+stack.pop();
}
return val;
}
}
⑽ java中棧與堆的區別
Java棧是與每一個線程關聯的，JVM在創建每一個線程的時候，會分配一定的棧空間給線程。它主要用來存儲線程執行過程中的局部變數，方法的返回值，以及方法調用上下文。棧空間隨著線程的終止而釋放
Java中堆是由所有的線程共享的一塊內存區域，堆用來保存各種JAVA對象，比如數組，線程對象等