字元串地址java

⑴ java中兩個字元串的內存地址相同

已經有人回答了，那我就順便貼一點java內存分配的小知識吧：

Java內存分配與管理是Java的核心技術之一，之前我們曾介紹過Java的內存管理與內存泄露以及Java垃圾回收方面的知識，今天我們再次深入Java核心，詳細介紹一下Java在內存分配方面的知識。一般Java在內存分配時會涉及到以下區域：

◆寄存器：我們在程序中無法控制

◆棧：存放基本類型的數據和對象的引用，但對象本身不存放在棧中，而是存放在堆中（new 出來的對象）

◆堆：存放用new產生的數據

◆靜態域：存放在對象中用static定義的靜態成員

◆常量池：存放常量

◆非RAM存儲：硬碟等永久存儲空間

Java內存分配中的棧

在函數中定義的一些基本類型的變數數據和對象的引用變數都在函數的棧內存中分配。

當在一段代碼塊定義一個變數時，Java就在棧中 為這個變數分配內存空間，當該變數退出該作用域後，Java會自動釋放掉為該變數所分配的內存空間，該內存空間可以立即被另作他用。棧中的數據大小和生命周期是可以確定的，當沒有引用指向數據時，這個數據就會消失。

Java內存分配中的堆

堆內存用來存放由new創建的對象和數組。 在堆中分配的內存，由Java虛擬機的自動垃圾回收器來管理。

在堆中產生了一個數組或對象後，還可以 在棧中定義一個特殊的變數，讓棧中這個變數的取值等於數組或對象在堆內存中的首地址，棧中的這個變數就成了數組或對象的引用變數。 引用變數就相當於是 為數組或對象起的一個名稱，以後就可以在程序中使用棧中的引用變數來訪問堆中的數組或對象。引用變數就相當於是為數組或者對象起的一個名稱。

引用變數是普通的變數，定義時在棧中分配，引用變數在程序運行到其作用域之外後被釋放。而數組和對象本身在堆中分配，即使程序 運行到使用 new 產生數組或者對象的語句所在的代碼塊之外，數組和對象本身占據的內存不會被釋放，數組和對象在沒有引用變數指向它的時候，才變為垃圾，不能在被使用，但仍 然占據內存空間不放，在隨後的一個不確定的時間被垃圾回收器收走（釋放掉）。這也是 Java 比較占內存的原因。

實際上，棧中的變數指向堆內存中的變數，這就是Java中的指針！

堆與棧

Java的堆是一個運行時數據區,類的(對象從中分配空間。這些對象通過new、newarray、 anewarray和multianewarray等指令建立，它們不需要程序代碼來顯式的釋放。堆是由垃圾回收來負責的，堆的優勢是可以動態地分配內存 大小，生存期也不必事先告訴編譯器，因為它是在運行時動態分配內存的，Java的垃圾收集器會自動收走這些不再使用的數據。但缺點是，由於要在運行時動態 分配內存，存取速度較慢。

棧的優勢是，存取速度比堆要快，僅次於寄存器，棧數據可以共享。但缺點是，存在棧中的數據大小與生存期必須是 確定的，缺乏靈活性。棧中主要存放一些基本類型的變數數據（int, short, long, byte, float, double, boolean, char）和對象句柄(引用)。

棧有一個很重要的特殊性，就是存在棧中的數據可以共享。假設我們同時定義：

Java代碼

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, 它是由編譯器完成的，它有利於節省空間。而一個對象引用變數修改了這個對象的內部狀態，會影響到另一個對象引用變數。

Java代碼
1.int i1 = 9;
2.int i2 = 9;
3.int i3 = 9;
4.public static final int INT1 = 9;
5.public static final int INT2 = 9;
6.public static final int INT3 = 9;

對於成員變數和局部變數：成員變數就是方法外部，類的內部定義的變數；局部變數就是方法或語句塊內部定義的變數。局部變數必須初始化。
形式參數是局部變數，局部變數的數據存在於棧內存中。棧內存中的局部變數隨著方法的消失而消失。
成員變數存儲在堆中的對象裡面，由垃圾回收器負責回收。
如以下代碼：
Java代碼
1.class BirthDate {
2. private int day;
3. private int month;
4. private int year;
5. public BirthDate(int d, int m, int y) {
6. day = d;
7. month = m;
8. year = y;
9. }
10. 省略get,set方法………
11.}
12.
13.public class Test{
14. public static void main(String args[]){
15.int date = 9;
16. Test test = new Test();
17. test.change(date);
18. BirthDate d1= new BirthDate(7,7,1970);
19. }
20.
21. public void change1(int i){
22. i = 1234;
23. }
對於以上這段代碼，date為局部變數，i,d,m,y都是形參為局部變數，day，month，year為成員變數。下面分析一下代碼執行時候的變化：
1. main方法開始執行：int date = 9;
date局部變數，基礎類型，引用和值都存在棧中。
2. Test test = new Test();
test為對象引用，存在棧中，對象(new Test())存在堆中。
3. test.change(date);
i為局部變數，引用和值存在棧中。當方法change執行完成後，i就會從棧中消失。
4. BirthDate d1= new BirthDate(7,7,1970);
d1 為對象引用，存在棧中，對象(new BirthDate())存在堆中，其中d，m，y為局部變數存儲在棧中，且它們的類型為基礎類型，因此它們的數據也存儲在棧中。 day,month,year為成員變數，它們存儲在堆中(new BirthDate()裡面)。當BirthDate構造方法執行完之後，d,m,y將從棧中消失。
5.main方法執行完之後，date變數，test，d1引用將從棧中消失，new Test(),new BirthDate()將等待垃圾回收。

常量池 (constant pool)

常量池指的是在編譯期被確定，並被保存在已編譯的.class文件中的一些數據。

除了包含代碼中所定義的各種基本類型（如int、long等等）和對象型（如String及數組）的常量值(final)還包含一些以文本形式出現的符號引用，比如：

◆類和介面的全限定名；

◆欄位的名稱和描述符；

◆方法和名稱和描述符。

如果是編譯期已經創建好(直接用雙引號定義的)的就存儲在常量池中，如果是運行期（new出來的）才能確定的就存儲在堆中。對於equals相等的字元串，在常量池中永遠只有一份，在堆中有多份。

String是一個特殊的包裝類數據。可以用：

Java代碼

String str = new String("abc");

String str = "abc";

兩種的形式來創建，第一種是用new()來新建對象的，它會在存放於堆中。每調用一次就會創建一個新的對象。而第二種是先在棧中創建一個對 String類的對象引用變數str，然後通過符號引用去字元串常量池 里找有沒有"abc",如果沒有，則將"abc"存放進字元串常量池 ，並令str指向」abc」，如果已經有」abc」 則直接令str指向「abc」。

比較類裡面的數值是否相等時，用equals()方法；當測試兩個包裝類的引用是否指向同一個對象時，用==，下面用例子說明上面的理論。

Java代碼

String str1 = "abc";

String str2 = "abc";

System.out.println(str1==str2); //true

可以看出str1和str2是指向同一個對象的。

Java代碼

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常量池問題的幾個例子

示例1：

Java代碼

String s0="kvill";

String s1="kvill";

String s2="kv" + "ill";

System.out.println( s0==s1 );

System.out.println( s0==s2 );

結果為：

true

true

分析：首先，我們要知結果為道Java 會確保一個字元串常量只有一個拷貝。

因為例子中的 s0和s1中的」kvill」都是字元串常量，它們在編譯期就被確定了，所以s0==s1為true；而」kv」和」ill」也都是字元串常量，當一個字 符串由多個字元串常量連接而成時，它自己肯定也是字元串常量，所以s2也同樣在編譯期就被解析為一個字元串常量，所以s2也是常量池中」 kvill」的一個引用。所以我們得出s0==s1==s2；

示例2：

示例：

Java代碼

String s0="kvill";

String s1=new String("kvill");

String s2="kv" + new String("ill");

System.out.println( s0==s1 );

System.out.println( s0==s2 );

System.out.println( s1==s2 );

結果為：

false

false

false

分析：用new String() 創建的字元串不是常量，不能在編譯期就確定，所以new String() 創建的字元串不放入常量池中，它們有自己的地址空間。

s0還是常量池 中"kvill」的應用，s1因為無法在編譯期確定，所以是運行時創建的新對象」kvill」的引用，s2因為有後半部分 new String(」ill」)所以也無法在編譯期確定，所以也是一個新創建對象」kvill」的應用;明白了這些也就知道為何得出此結果了。

示例3：

Java代碼

String a = "a1";

String b = "a" + 1;

System.out.println((a == b)); //result = true

String a = "atrue";

String b = "a" + "true";

System.out.println((a == b)); //result = true

String a = "a3.4";

String b = "a" + 3.4;

System.out.println((a == b)); //result = true

分析：JVM對於字元串常量的"+"號連接，將程序編譯期，JVM就將常量字元串的"+"連接優化為連接後的值，拿"a" + 1來說，經編譯器優化後在class中就已經是a1。在編譯期其字元串常量的值就確定下來，故上面程序最終的結果都為true。

示例4：

Java代碼

String a = "ab";

String bb = "b";

String b = "a" + bb;

System.out.println((a == b)); //result = false

分析：JVM對於字元串引用，由於在字元串的"+"連接中，有字元串引用存在，而引用的值在程序編譯期是無法確定的，即"a" + bb無法被編譯器優化，只有在程序運行期來動態分配並將連接後的新地址賦給b。所以上面程序的結果也就為false。

示例5：

Java代碼

String a = "ab";

final String bb = "b";

String b = "a" + bb;

System.out.println((a == b)); //result = true

分析：和[4]中唯一不同的是bb字元串加了final修飾，對於final修飾的變數，它在編譯時被解析為常量值的一個本地拷貝存儲到自己的常量 池中或嵌入到它的位元組碼流中。所以此時的"a" + bb和"a" + "b"效果是一樣的。故上面程序的結果為true。

示例6：

Java代碼

String a = "ab";

final String bb = getBB();

String b = "a" + bb;

System.out.println((a == b)); //result = false

private static String getBB() { return "b"; }

分析：JVM對於字元串引用bb，它的值在編譯期無法確定，只有在程序運行期調用方法後，將方法的返回值和"a"來動態連接並分配地址為b，故上面 程序的結果為false。

關於String是不可變的

通過上面例子可以得出得知：

String s = "a" + "b" + "c";

就等價於String s = "abc";

String a = "a";

String b = "b";

String c = "c";

String s = a + b + c;

這個就不一樣了，最終結果等於：

Java代碼

StringBuffer temp = new StringBuffer();

temp.append(a).append(b).append(c);

String s = temp.toString();

由上面的分析結果，可就不難推斷出String 採用連接運算符（+）效率低下原因分析，形如這樣的代碼：

Java代碼

public class Test {

public static void main(String args[]) {

String s = null;

for(int i = 0; i < 100; i++) {

s += "a";

}

}

}

每做一次 + 就產生個StringBuilder對象，然後append後就扔掉。下次循環再到達時重新產生個StringBuilder對象，然後 append 字元串，如此循環直至結束。如果我們直接採用 StringBuilder 對象進行 append 的話，我們可以節省 N - 1 次創建和銷毀對象的時間。所以對於在循環中要進行字元串連接的應用，一般都是用StringBuffer或StringBulider對象來進行 append操作。

由於String類的immutable性質,這一說又要說很多，大家只 要知道String的實例一旦生成就不會再改變了，比如說：String str=」kv」+」ill」+」 「+」ans」; 就是有4個字元串常量，首先」kv」和」ill」生成了」kvill」存在內存中，然後」kvill」又和」 」 生成 「kvill 「存在內存中，最後又和生成了」kvill ans」;並把這個字元串的地址賦給了str,就是因為String的」不可變」產生了很多臨時變數，這也就是為什麼建議用StringBuffer的原 因了，因為StringBuffer是可改變的。

String中的final用法和理解

Java代碼

final StringBuffer a = new StringBuffer("111");

final StringBuffer b = new StringBuffer("222");

a=b;//此句編譯不通過

final StringBuffer a = new StringBuffer("111");

a.append("222");// 編譯通過

可見，final只對引用的"值"(即內存地址)有效，它迫使引用只能指向初始指向的那個對象，改變它的指向會導致編譯期錯誤。至於它所指向的對象 的變化，final是不負責的。

總結

棧中用來存放一些原始數據類型的局部變數數據和對象的引用(String,數組.對象等等)但不存放對象內容

堆中存放使用new關鍵字創建的對象.

字元串是一個特殊包裝類,其引用是存放在棧里的,而對象內容必須根據創建方式不同定(常量池和堆).有的是編譯期就已經創建好，存放在字元串常 量池中，而有的是運行時才被創建.使用new關鍵字，存放在堆中。

⑵ java 怎麼獲得字元串中某一字元的位置

在java中使用indexOf方法即可獲得字元串中某一字元的位置，例如Stringstr="abcdef"，System.out.println(str.indexOf("c"))。

⑶ java字元串位置

提供一下思路，indexof（）取得第一個後數值後a，用substring把字元串拆開，要後半部分，繼續indexof（）取得數值b，位置就是a+b。以此類推遞歸下就可以！

⑷ java中怎麼輸出字元所在位置

java中輸出字元所在位置可以使用indexOf()函數
例子：
System.out.println("abcd".indexOf("b"));
結果輸出1
返回b字元在字元串abcd中第一次出現的位置

⑸ java怎麼列印字元串的地址

toString()列印的不是對象的內存地址。而是類名@hashcode十六進制後的值。
java中的一切類都直接或間接繼承了父類Object，而String重寫了父類Object的toString()方法，返回的是this，是它自己本身。
你看Object中的toString();是怎麼寫的？你用引用名.getClass().getName()+"@"+Integer.toHexString(引用名.hashCode())，因為hashcode不同，對象一定不同。如果hashcode相同，對象不一定相同。
hashcode其實是內存地址對應的數值經過hash演算法得到的值，通過hashcode只能確定對象放在散列結構的某一層，但是這一層有很多個對象，不能確定到具體地址。

⑹ 如何判斷一個字元串在另一個字元串出現的位置，用JAVA實現

字元串有一個方法 indexOf(""),用這個方法就行了，如果不存在就會返回-1的。

⑺ 怎麼查看java中字元串的內存地址

java中不建議直接獲取字元串內存地址，因為java不像c語言，獲取內存地址是C語言的強項，java的弱項。但是java內存地址還是有一個應用場景，就是判斷兩個字元串內存地址是否相等來判斷是否是同一個對象，用雙等號「==」來比較的。參考代碼如下：

publicclassTest01{

	/**
	*@paramargs
	*/
	publicstaticvoidmain(String[]args){
		//TODOAuto-generatedmethodstub
		Stringstr1="abc";
		Stringstr2=newString("abc");
		System.out.println(str1==str2);//輸出false
	}

}

⑻ java怎麼提取下面字元串中的地址

這個可以用正則表達式，給你寫了個簡單的你代碼，我測試過了，希望對你有幫助~！

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ExtractAddress {
public static void main(String[] args) {
String s = "var _url = \"http://www..com/\";";
Pattern pattern = Pattern.compile("\"(.*)\"");
Matcher m = pattern.matcher(s);
if(m.find())
System.out.println(m.group(1));
else
System.out.println("沒找到相關地址");
}

}

⑼ java如何獲取字元位置

Java中String提供的常用操作函數：char charAt(int index)。返回指定索引處的 char 值。

具體操作：

條件是：

(index = str1.indexOf(str2, index + 1)) >= 0 str1.indexOf(str2, index + 1) 查出str2從左到右第一次出現的位置， index = str1.indexOf(str2, index + 1) 將位置賦值給index變數。

下次循環開始時，因為str1.indexOf(str2, index + 1)第二個參數是index+1，所以從str2第一次出現的位置的下一位開始再找出匹配的字元串。