『壹』 java 棧是線程安全嗎
棧只是操作系統為線程分配的一塊內存。是個線程獨有的，保存其運行狀態和局部自動變數的。棧在線程開始的時候初始化，每個線程的棧互相獨立，因此，棧是線程安全的。
『貳』 java中，棧和堆分別是什麼創建的最好詳細點。。
棧與堆都是Java用來在Ram中存放數據的地方。與C++不同，Java自動管理棧和堆，程序員不能直接地設置棧或堆。
Java 的堆是一個運行時數據區,類的(對象從中分配空間。這些對象通過new、newarray、anewarray和multianewarray等指令建立，它們不需要程序代碼來顯式的釋放。堆是由垃圾回收來負責的，堆的優勢是可以動態地分配內存大小，生存期也不必事先告訴編譯器，因為它是在運行時動態分配內存的，Java的垃圾收集器會自動收走這些不再使用的數據。但缺點是，由於要在運行時動態分配內存，存取速度較慢。
棧的優勢是，存取速度比堆要快，僅次於寄存器，棧數據可以共享。但缺點是，存在棧中的數據大小與生存期必須是確定的，缺乏靈活性。棧中主要存放一些基本類型的變數（,int, short, long, byte, float, double, boolean, char）和對象句柄。
棧有一個很重要的特殊性，就是存在棧中的數據可以共享。假設我們同時定義：
int a = 3;
int b = 3；
編譯器先處理int a = 3；首先它會在棧中創建一個變數為a的引用，然後查找棧中是否有3這個值，如果沒找到，就將3存放進來，然後將a指向3。接著處理int b = 3；在創建完b的引用變數後，因為在棧中已經有3這個值，便將b直接指向3。這樣，就出現了a與b同時均指向3的情況。這時，如果再令a=4；那麼編譯器會重新搜索棧中是否有4值，如果沒有，則將4存放進來，並令a指向4；如果已經有了，則直接將a指向這個地址。因此a值的改變不會影響到b的值。要注意這種數據的共享與兩個對象的引用同時指向一個對象的這種共享是不同的，因為這種情況a的修改並不會影響到b, 它是由編譯器完成的，它有利於節省空間。而一個對象引用變數修改了這個對象的內部狀態，會影響到另一個對象引用變數。
String是一個特殊的包裝類數據。可以用：
String str = new String("abc");
String str = "abc";
兩種的形式來創建，第一種是用new()來新建對象的，它會在存放於堆中。每調用一次就會創建一個新的對象。
而第二種是先在棧中創建一個對String類的對象引用變數str，然後查找棧中有沒有存放"abc"，如果沒有，則將"abc"存放進棧，並令str指向」abc」，如果已經有」abc」 則直接令str指向「abc」。
比較類裡面的數值是否相等時，用equals()方法；當測試兩個包裝類的引用是否指向同一個對象時，用==，下面用例子說明上面的理論。
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true
可以看出str1和str2是指向同一個對象的。
String str1 =new String ("abc");
String str2 =new String ("abc");
System.out.println(str1==str2); // false
用new的方式是生成不同的對象。每一次生成一個。
因此用第二種方式創建多個」abc」字元串,在內存中其實只存在一個對象而已. 這種寫法有利與節省內存空間. 同時它可以在一定程度上提高程序的運行速度，因為JVM會自動根據棧中數據的實際情況來決定是否有必要創建新對象。而對於String str = new String("abc")；的代碼，則一概在堆中創建新對象，而不管其字元串值是否相等，是否有必要創建新對象，從而加重了程序的負擔。
另一方面, 要注意: 我們在使用諸如String str = "abc"；的格式定義類時，總是想當然地認為，創建了String類的對象str。擔心陷阱！對象可能並沒有被創建！而可能只是指向一個先前已經創建的對象。只有通過new()方法才能保證每次都創建一個新的對象。由於String類的immutable性質，當String變數需要經常變換其值時，應該考慮使用StringBuffer類，以提高程序效率。
java中內存分配策略及堆和棧的比較
2.1 內存分配策略
按照編譯原理的觀點,程序運行時的內存分配有三種策略,分別是靜態的,棧式的,和堆式的.
靜態存儲分配是指在編譯時就能確定每個數據目標在運行時刻的存儲空間需求,因而在編譯時就可以給他們分配固定的內存空間.這種分配策略要求程序代碼中不允許有可變數據結構(比如可變數組)的存在,也不允許有嵌套或者遞歸的結構出現,因為它們都會導致編譯程序無法計算準確的存儲空間需求.
棧式存儲分配也可稱為動態存儲分配,是由一個類似於堆棧的運行棧來實現的.和靜態存儲分配相反,在棧式存儲方案中,程序對數據區的需求在編譯時是完全未知的,只有到運行的時候才能夠知道,但是規定在運行中進入一個程序模塊時,必須知道該程序模塊所需的數據區大小才能夠為其分配內存.和我們在數據結構所熟知的棧一樣,棧式存儲分配按照先進後出的原則進行分配。
靜態存儲分配要求在編譯時能知道所有變數的存儲要求,棧式存儲分配要求在過程的入口處必須知道所有的存儲要求,而堆式存儲分配則專門負責在編譯時或運行時模塊入口處都無法確定存儲要求的數據結構的內存分配,比如可變長度串和對象實例.堆由大片的可利用塊或空閑塊組成,堆中的內存可以按照任意順序分配和釋放.
2.2 堆和棧的比較
上面的定義從編譯原理的教材中總結而來,除靜態存儲分配之外,都顯得很呆板和難以理解,下面撇開靜態存儲分配,集中比較堆和棧:
從堆和棧的功能和作用來通俗的比較,堆主要用來存放對象的，棧主要是用來執行程序的.而這種不同又主要是由於堆和棧的特點決定的:
在編程中，例如C/C++中，所有的方法調用都是通過棧來進行的,所有的局部變數,形式參數都是從棧中分配內存空間的。實際上也不是什麼分配,只是從棧頂向上用就行,就好像工廠中的傳送帶(conveyor belt)一樣,Stack Pointer會自動指引你到放東西的位置,你所要做的只是把東西放下來就行.退出函數的時候，修改棧指針就可以把棧中的內容銷毀.這樣的模式速度最快, 當然要用來運行程序了.需要注意的是,在分配的時候,比如為一個即將要調用的程序模塊分配數據區時,應事先知道這個數據區的大小,也就說是雖然分配是在程序運行時進行的,但是分配的大小多少是確定的,不變的,而這個"大小多少"是在編譯時確定的,不是在運行時.
堆是應用程序在運行的時候請求操作系統分配給自己內存，由於從操作系統管理的內存分配,所以在分配和銷毀時都要佔用時間，因此用堆的效率非常低.但是堆的優點在於,編譯器不必知道要從堆里分配多少存儲空間，也不必知道存儲的數據要在堆里停留多長的時間,因此,用堆保存數據時會得到更大的靈活性。事實上,面向對象的多態性,堆內存分配是必不可少的,因為多態變數所需的存儲空間只有在運行時創建了對象之後才能確定.在C++中，要求創建一個對象時，只需用 new命令編制相關的代碼即可。執行這些代碼時，會在堆里自動進行數據的保存.當然，為達到這種靈活性，必然會付出一定的代價:在堆里分配存儲空間時會花掉更長的時間！這也正是導致我們剛才所說的效率低的原因,看來列寧同志說的好,人的優點往往也是人的缺點,人的缺點往往也是人的優點(暈~).
2.3 JVM中的堆和棧
JVM是基於堆棧的虛擬機.JVM為每個新創建的線程都分配一個堆棧.也就是說,對於一個Java程序來說，它的運行就是通過對堆棧的操作來完成的。堆棧以幀為單位保存線程的狀態。JVM對堆棧只進行兩種操作:以幀為單位的壓棧和出棧操作。
我們知道,某個線程正在執行的方法稱為此線程的當前方法.我們可能不知道,當前方法使用的幀稱為當前幀。當線程激活一個Java方法,JVM就會在線程的 Java堆棧里新壓入一個幀。這個幀自然成為了當前幀.在此方法執行期間,這個幀將用來保存參數,局部變數,中間計算過程和其他數據.這個幀在這里和編譯原理中的活動紀錄的概念是差不多的.
從Java的這種分配機制來看,堆棧又可以這樣理解:堆棧(Stack)是操作系統在建立某個進程時或者線程(在支持多線程的操作系統中是線程)為這個線程建立的存儲區域，該區域具有先進後出的特性。
每一個Java應用都唯一對應一個JVM實例，每一個實例唯一對應一個堆。應用程序在運行中所創建的所有類實例或數組都放在這個堆中,並由應用所有的線程共享.跟C/C++不同，Java中分配堆內存是自動初始化的。Java中所有對象的存儲空間都是在堆中分配的，但是這個對象的引用卻是在堆棧中分配,也就是說在建立一個對象時從兩個地方都分配內存，在堆中分配的內存實際建立這個對象，而在堆棧中分配的內存只是一個指向這個堆對象的指針(引用)而已。
『叄』 JAVA中棧的問題
棧，其實是一種數據結構！你可以用數組實現，也可以用LinkedList實現！
棧的結構是先進的後出！
就你的問題，如果你用數組解決的話，就判斷數組是不是空，就能知道模擬棧里有沒有東西了！
關於第二個問題！~做一個簡單的程序測試一下就好了·~其實和C++沒有什麼區別！
『肆』 java只用棧判斷字元串是否迴文
importjava.util.ArrayList;
importjava.util.List;
publicclassStackTest{
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
Stringstr="abcba";
System.out.println(str+"迴文數："+isPalindrome(str));
str="abccba";
System.out.println(str+"迴文數："+isPalindrome(str));
str="123321";
System.out.println(str+"迴文數："+isPalindrome(str));
str="1238887321";
System.out.println(str+"迴文數："+isPalindrome(str));
}
/**
*<p>判斷輸入字元串是否為迴文</p>
*@parampValueString輸入待判定的字元串
*@returnboolean是否是迴文
*/
(StringpValue){
//堆棧一
List<Character>stack=newArrayList<Character>();
//堆棧二
List<Character>stack2=newArrayList<Character>();
//字元串長度的一半
inthaflen=pValue.length()/2;
for(inti=0;i<haflen;i++){
//字元進棧
stack.add(pValue.charAt(i));
//倒序進棧
stack2.add(pValue.charAt(pValue.length()-i-1));
}
//標識符
booleanbFlag=true;
//出棧並比較
for(inti=haflen-1;i>=0;i--){
if(stack.remove(i)!=stack2.remove(i)){
bFlag=false;
break;
}
}
//返回比對結果
returnbFlag;
}
}
你這是作業題吧，其實最簡單直接用循環然後charAt()把第一個和最後一個取出來比較就可以了。要用棧的話，我就用List來模擬棧。我們知道棧只有兩個基本的操作進棧和出棧，用ArrayList的add(),remove()來模擬進棧和出棧。上面的代碼和你的思路是一樣的，但是簡化掉奇偶數的判定，因為是奇數的時候，最中間一個我們可以不用管它，是偶數的話就是前半部分和後半部分的比較。
『伍』 JAVA數組模擬棧先進後出怎麼做
用索引來表示數組的容量，就是數組元素添加一個元素，index +=1；
put方法 index +1； arr[index++] = XXX;
push方法 index -1; return arr[index--];
『陸』 java如何用數組來模擬棧的先進後出
import java.util.Arrays;
public class StackTest {
public static void main(String[] args) {
Stack stack = new Stack();
stack.put(1);
stack.put(2);
stack.put(3);
stack.put(4);
stack.show();
System.out.println(stack.push());
System.out.println(stack.push());
System.out.println(stack.push());
System.out.println(stack.push());
}
}
class Stack{
private int index;
private int length = 3;
private int[] stack;
public Stack() {
stack= new int[length];
index = 0;
}
public void put(int i){
if(index <= length -1){
stack[index++] = i;
} else {
System.out.println("Stack 已滿");
}
}
public int push(){
if (index >0){
return stack[--index];
}else {
System.out.print("Stack 已空");
return -1;
}
}
public void show() {
System.out.println(Arrays.toString(stack));
}
}
『柒』 java 數組的題
/**
*2015年6月12日
*
*@authorseasonTODO實現數組簡單操作
*
*/
publicclassExercise4{
/**
*將目標數組元素倒排
*
*@paramarr
*目標數組
*/
publicstaticvoidreverseArray(int[]arr){
for(intindex=0;arr!=null&&index<arr.length/2;index++){
intendIndex=arr.length-index-1;
inttemp=arr[endIndex];
arr[endIndex]=arr[index];
arr[index]=temp;
}
}
/**
*遍歷目標數組元素
*
*@paramarr
*目標數組
*/
publicstaticvoiddisplay(int[]arr){
System.out.println(" ");
if(arr==null)
return;
for(intnumber:arr){
System.out.print(""+number);
}
}
publicstaticvoidmain(String[]args){
int[]arr={1,2,3,4};
display(arr);
reverseArray(arr);
display(arr);
}
}
-------------
classStack{
int[]arr;
staticintindex=0;
publicStack(){
arr=newint[5];
}
/*加入棧頂元素*/
booleanput(intnum){
if(index<arr.length){
arr[index++]=num;
returntrue;
}
returnfalse;
}
/*彈出棧頂元素*/
intpop(){
returnarr[index--];
}
/*顯示棧里所有元素*/
voiddisplay(){
System.out.println(" ");
for(inti=0;i<index;i++)
System.out.print(arr[i]+"");
}
}
/**
*2015年6月12日
*
*@authorseasonTODO實現棧的先進後出
*
*/
publicclassExercise5{
publicstaticvoidmain(String[]args){
Stackstack=newStack();
//添加三個元素
stack.put(1);
stack.put(2);
stack.put(3);
stack.display();
//彈出一個元素
stack.pop();
stack.display();
}
}
-----------
/**
*2015年6月12日
*
*@authorseasonTODO數組的簡單操作
*
*/
publicclassExercise3{
/*顯示數組的所有元素*/
publicstaticvoiddisplay(int[]arr){
if(arr==null)
return;
System.out.println(" ");
for(intnum:arr)
System.out.print(""+num);
}
/*刪除指定下標為:deleteIndex的元素*/
publicstaticint[]delete(int[]arr,intdeleteIndex){
if(arr==null||deleteIndex<0||deleteIndex>=arr.length)
returnnull;
int[]tempArr=newint[arr.length-1];
for(intindex=0;index<arr.length-1;index++){
if(index<deleteIndex){
tempArr[index]=arr[index];
}else{
tempArr[index]=arr[index+1];
}
}
returntempArr;
}
/*增加一個元素*/
publicstaticint[]add(int[]arr,intaddIndex,intnum){
if(arr==null||addIndex>arr.length||addIndex<0)
returnnull;
int[]tempArr=newint[arr.length+1];
for(intindex=0;index<tempArr.length;index++){
if(index<addIndex){
tempArr[index]=arr[index];
}elseif(index==addIndex){
tempArr[index]=num;
}else{
tempArr[index]=arr[index-1];
}
}
returntempArr;
}
publicstaticvoidmain(String[]args){
int[]arr={1,4,6,7,9};
display(arr);
arr=delete(arr,0);
arr=delete(arr,0);
display(arr);
arr=add(arr,1,123);
display(arr);
arr=add(arr,1,-526);
display(arr);
}
}
『捌』 java用數組模擬棧， 重寫了tostring方法，卻沒有調用，輸出的是地址，為什麼
你好！
你的tostring()方法名錯了，toString()才對。
希望對你有幫助！
『玖』 用累和數組方法模擬棧的出入操作 1若棧空則不能出 2若滿則不能入 3所有操作在棧頂執行 4添加能夠
importjava.util.Arrays;
importjava.util.Scanner;
publicclass${
publicstaticvoidmain(String[]args){
Scannerin=newScanner(System.in);
System.out.print("輸入棧的容量:");
intlen=in.nextInt();
Integer[]arr=newInteger[len];
while(true){
System.out.println("----------0:退出;1.出棧;2.入棧;3:顯示----------");
intnum=in.nextInt();
if(num==0){
System.exit(0);
}
//出棧
if(num==1){
if(arr[len-1]!=null){
System.out.println(arr[len-1]);
for(inti=len-1;i>0;i--){
arr[i]=arr[i-1];
}
arr[0]=null;
}else{
System.out.println("棧空則不能出");
}
}
//入棧
if(num==2){
if(arr[0]==null){
for(inti=0;i<len-1;i++){
arr[i]=arr[i+1];
}
System.out.print("輸入要入棧的數字:");
arr[len-1]=in.nextInt();
}else{
System.out.println("滿則不能入");
}
}
//入棧
if(num==3){
System.out.println(Arrays.deepToString(arr));
}
}
}
}
操作步驟:
輸入棧的容量:3
----------0:退出;1.出棧;2.入棧;3:顯示----------
1
棧空則不能出
----------0:退出;1.出棧;2.入棧;3:顯示----------
2
輸入要入棧的數字:11
----------0:退出;1.出棧;2.入棧;3:顯示----------
3
[null,null,11]
----------0:退出;1.出棧;2.入棧;3:顯示----------
2
輸入要入棧的數字:22
----------0:退出;1.出棧;2.入棧;3:顯示----------
3
[null,11,22]
----------0:退出;1.出棧;2.入棧;3:顯示----------
2
輸入要入棧的數字:3
----------0:退出;1.出棧;2.入棧;3:顯示----------
3
[11,22,3]
----------0:退出;1.出棧;2.入棧;3:顯示----------
1
3
----------0:退出;1.出棧;2.入棧;3:顯示----------
3
[null,11,22]
----------0:退出;1.出棧;2.入棧;3:顯示----------
0
『拾』 java 中用雙向鏈表模擬棧
這里只是實現了Stack的部分功能
public class Stack{
private Node top;
public Stack(){
this.top = null;
}
public void push(Node node){
if(node == null)
return;
if(this.top == null){
this.top = node;
node.setNext(null);
node.setPre(null);
}
else{
this.top.setNext(node);
node.setPre(this.top);
node.setNext(null);
this.top = node;
}
}
public Node pop(){
if(this.top == null)
return null;
Node curr = this.top;
Node pre = curr.getPre();
pre.setNext(null);
this.top = pre;
return curr;
}
public Node top(){
return this.top;
}
public boolean isEmpty(){
return this.top == null ? true : false;
}
public void empty(){
this.top = null;
}
public static void main(String[] args){
Stack stack = new Stack();
Node n1 = new Node(1);
Node n2 = new Node(2);
Node n3 = new Node(3);
System.out.println(stack.isEmpty());
stack.push(n1);
System.out.println(stack.top().getValue());
stack.push(n2);
stack.push(n3);
System.out.println(stack.pop().getValue());
stack.empty();
}
}
class Node {
private int value;
private Node next;
private Node pre;
public Node(int value, Node next, Node pre){
this.value = value;
this.next = next;
this.pre = pre;
}
public Node(int value){
this.value = value;
this.next = null;
this.pre = null;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public Node getPre() {
return pre;
}
public void setPre(Node pre) {
this.pre = pre;
}
}