在Java語言中 String str=new String("a") 這個語句創(chuàng)建了幾個對象。

答案：兩個，一個是字符串字面量"xyz"所對應(yīng)的、駐留（intern）在一個全局共享的字符串常量池中的實(shí)例，另一個是通過new String(String)創(chuàng)建并初始化的、內(nèi)容與"xyz"相同的實(shí)例

讓客戶滿意是我們工作的目標(biāo)，不斷超越客戶的期望值來自于我們對這個行業(yè)的熱愛。我們立志把好的技術(shù)通過有效、簡單的方式提供給客戶，將通過不懈努力成為客戶在信息化領(lǐng)域值得信任、有價(jià)值的長期合作伙伴，公司提供的服務(wù)項(xiàng)目有：申請域名、雅安服務(wù)器托管、營銷軟件、網(wǎng)站建設(shè)、柳北網(wǎng)站維護(hù)、網(wǎng)站推廣。

這是根據(jù)Java語言規(guī)范相關(guān)規(guī)定可以給出的合理答案。考慮到Java語言規(guī)范中明確指出了：

The Java Language Specification, Third Edition 寫道

The Java programming language is normally compiled to the bytecoded instruction set and binary format defined in The Java Virtual Machine Specification, Second Edition (Addison-Wesley, 1999).

也就是規(guī)定了Java語言一般是編譯為Java虛擬機(jī)規(guī)范所定義的Class文件，但并沒有規(guī)定“一定”（must），留有不使用JVM來實(shí)現(xiàn)Java語言的余地。

考慮上Java虛擬機(jī)規(guī)范，確實(shí)在這段代碼里涉及的常量種類為CONSTANT_String_info的字符串常量也只有"xyz"一個。CONSTANT_String_info是用來表示Java語言中String類型的常量表達(dá)式的值（包括字符串字面量）用的常量種類，只在這個層面上考慮的話，這個解答也沒問題。

所以這種解答可以認(rèn)為是合理的。

值得注意的是問題中“在運(yùn)行時(shí)”既包括類加載階段，也包括這個代碼片段自身執(zhí)行的時(shí)候。下文會再討論這個細(xì)節(jié)與樓主原本給出的問題的關(guān)系。

碰到這種問題首先應(yīng)該想到去查閱相關(guān)的規(guī)范，這里具體是Java語言規(guī)范與Java虛擬機(jī)規(guī)范，以及一些相關(guān)API的JavaDoc。很多人喜歡把“按道理說”當(dāng)作口頭禪，規(guī)范就是用來定義各種“道理”的——“為什么XXX是YYY的意思？”“因?yàn)橐?guī)范里是這樣定義的！”——無敵了。

在Java虛擬機(jī)規(guī)范中相關(guān)的定義有下面一些：

The Java Virtual Machine Specification, Second Edition 寫道

2.3 Literals

A literal is the source code representation of a value of a primitive type (§2.4.1), the String type (§2.4.8), or the null type (§2.4). String literals and, more generally, strings that are the values of constant expressions are "interned" so as to share unique instances, using the method String.intern.

The null type has one value, the null reference, denoted by the literal null. The boolean type has two values, denoted by the literals true and false.

2.4.8 The Class String

Instances of class String represent sequences of Unicode characters (§2.1). A String object has a constant, unchanging value. String literals (§2.3) are references to instances of class String.

2.17.6 Creation of New Class Instances

A new class instance is explicitly created when one of the following situations occurs:

Evaluation of a class instance creation expression creates a new instance of the class whose name appears in the expression.

Invocation of the newInstance method of class Class creates a new instance of the class represented by the Class object for which the method was invoked.

A new class instance may be implicitly created in the following situations:

Loading of a class or interface that contains a String literal may create a new String object (§2.4.8) to represent that literal. This may not occur if the a String object has already been created to represent a previous occurrence of that literal, or if the String.intern method has been invoked on a String object representing the same string as the literal.

Execution of a string concatenation operator that is not part of a constant expression sometimes creates a new String object to represent the result. String concatenation operators may also create temporary wrapper objects for a value of a primitive type (§2.4.1).

Each of these situations identifies a particular constructor to be called with specified arguments (possibly none) as part of the class instance creation process.

5.1 The Runtime Constant Pool

...

● A string literal (§2.3) is derived from a CONSTANT_String_info structure (§4.4.3) in the binary representation of a class or interface. The CONSTANT_String_info structure gives the sequence of Unicode characters constituting the string literal.

● The Java programming language requires that identical string literals (that is, literals that contain the same sequence of characters) must refer to the same instance of class String. In addition, if the method String.intern is called on any string, the result is a reference to the same class instance that would be returned if that string appeared as a literal. Thus,

Java代碼

("a" + "b" + "c").intern() == "abc"

must have the value true.

● To derive a string literal, the Java virtual machine examines the sequence of characters given by the CONSTANT_String_info structure.

○ If the method String.intern has previously been called on an instance of class String containing a sequence of Unicode characters identical to that given by the CONSTANT_String_info structure, then the result of string literal derivation is a reference to that same instance of class String.

○ Otherwise, a new instance of class String is created containing the sequence of Unicode characters given by the CONSTANT_String_info structure; that class instance is the result of string literal derivation. Finally, the intern method of the new String instance is invoked.

...

The remaining structures in the constant_pool table of the binary representation of a class or interface, the CONSTANT_NameAndType_info (§4.4.6) and CONSTANT_Utf8_info (§4.4.7) structures are only used indirectly when deriving symbolic references to classes, interfaces, methods, and fields, and when deriving string literals.

把Sun的JDK看作參考實(shí)現(xiàn)（reference implementation, RI），其中String.intern()的JavaDoc為：

JavaDoc 寫道

public String intern()

Returns a canonical representation for the string object.

A pool of strings, initially empty, is maintained privately by the class String.

When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.

It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true.

All literal strings and string-valued constant expressions are interned. String literals are defined in §3.10.5 of the Java Language Specification

Returns:

a string that has the same contents as this string, but is guaranteed to be from a pool of unique strings.

===============================================================

再換一個問題來問：

引用

問題：

Java代碼

String s = new String("xyz");

涉及用戶聲明的幾個String類型的變量？

答案也很簡單：

引用

答案：一個，就是String s。

把問題換成下面這個版本，答案也一樣：

引用

問題：

Java代碼

String s = null;

涉及用戶聲明的幾個String類型的變量？

Java里變量就是變量，引用類型的變量只是對某個對象實(shí)例或者null的引用，不是實(shí)例本身。聲明變量的個數(shù)跟創(chuàng)建實(shí)例的個數(shù)沒有必然關(guān)系，像是說：

Java代碼

String s1 = "a";

String s2 = s1.concat("");

String s3 = null;

new String(s1);

這段代碼會涉及3個String類型的變量，

1、s1，指向下面String實(shí)例的1

2、s2，指向與s1相同

3、s3，值為null，不指向任何實(shí)例

以及3個String實(shí)例，

1、"a"字面量對應(yīng)的駐留的字符串常量的String實(shí)例

2、""字面量對應(yīng)的駐留的字符串常量的String實(shí)例

（String.concat()是個有趣的方法，當(dāng)發(fā)現(xiàn)傳入的參數(shù)是空字符串時(shí)會返回this，所以這里不會額外創(chuàng)建新的String實(shí)例）

3、通過new String(String)創(chuàng)建的新String實(shí)例；沒有任何變量指向它。

===============================================================

回到樓主開頭引用的問題與“標(biāo)準(zhǔn)答案”

引用

問題：

Java代碼

String s = new String("xyz");

創(chuàng)建了幾個String Object？

答案：兩個(一個是“xyz”,一個是指向“xyz”的引用對象s)

用歸謬法論證。假定問題問的是“在執(zhí)行這段代碼片段時(shí)創(chuàng)建了幾個String實(shí)例”。如果“標(biāo)準(zhǔn)答案”是正確的，那么下面的代碼片段在執(zhí)行時(shí)就應(yīng)該創(chuàng)建4個String實(shí)例了：

Java代碼

String s1 = new String("xyz");

String s2 = new String("xyz");

馬上就會有人跳出來說上下兩個"xyz"字面量都是引用了同一個String對象，所以不應(yīng)該是創(chuàng)建了4個對象。

那么應(yīng)該是多少個？

運(yùn)行時(shí)的類加載過程與實(shí)際執(zhí)行某個代碼片段，兩者必須分開討論才有那么點(diǎn)意義。

為了執(zhí)行問題中的代碼片段，其所在的類必然要先被加載，而且同一個類最多只會被加載一次（要注意對JVM來說“同一個類”并不是類的全限定名相同就足夠了，而是類全限定名, 定義類加載器一對都相同才行）。

根據(jù)上文引用的規(guī)范的內(nèi)容，符合規(guī)范的JVM實(shí)現(xiàn)應(yīng)該在類加載的過程中創(chuàng)建并駐留一個String實(shí)例作為常量來對應(yīng)"xyz"字面量；具體是在類加載的resolve階段進(jìn)行的。這個常量是全局共享的，只在先前尚未有內(nèi)容相同的字符串駐留過的前提下才需要創(chuàng)建新的String實(shí)例。

我的世界整人指令是什么？

我的世界惡作劇整人指令如下：

1、指令 /nick ID-名稱-給某人改一個名，ID是加白名單的名字。

2、/backup-運(yùn)行備份命令。

3、/fireball-發(fā)射一個火球(會破壞方塊)。

4、/heal name-治療某人。

5、/invsee name-查看某人的包裹。

6、/lingtning name-天譴(不填寫名字會雷擊鼠標(biāo)指向的地方)。

7、/mute name-禁言某人。

8、/ping-讓單位走路發(fā)出乒乓聲。

9、/seen name-查看某人最后退出的時(shí)間。

10、/tp name1 name2-將人物1傳送至人物2身旁。

11、/tp name-將自己傳送至某人身旁。

12、/tphere name-將某人傳送至自己身旁。

13、/tpall-將服務(wù)器內(nèi)的所有人傳送至自己身旁（大傳送陣）。

求我的世界java指令全套

ascend - 把自己提升到上一個平臺

bind 命令 {命令關(guān)鍵字} - 設(shè)置一鍵命令

clear - 清空控制臺

damage - 關(guān)閉或者開啟傷害 即無敵

descend - 把自己移動到下面一個的平臺

destroy [all] - 破壞當(dāng)前的東西（背包）

defuse [all] - 拆彈（拆除已經(jīng)點(diǎn)燃了的TNT炸藥）

diff - X

difficulty - 設(shè)置游戲難度

dropstore - 在身邊創(chuàng)建一個儲物柜

*drops - 開關(guān)物品掉落，關(guān)閉的話采礦打怪不掉東西。

dupe [all] - 復(fù)制東西

duplicate [all] - 復(fù)制手上的東西并丟出來

explode [范圍] - 設(shè)置一個地方爆炸（在自家慎用）

extinguish [all] - 熄滅周圍所有的火

ext [all] - 一樣是熄滅火

falldamage - 開關(guān)高空落下傷害

firedamage - 開關(guān)火的傷害

fly - 飛行模式

*freeze - 凍結(jié)怪物

give 物品 [數(shù)量] - 給一樣物品

goto 名字 - 去一個地方

grow [all] - 讓立即小麥成長

h [COMMAND] - 命令列表/幫助

heal - 補(bǔ)指定的血

health - 設(shè)置生命值

help [COMMAND] - 命令列表/幫助

home 回到出生點(diǎn)

i 物品代碼 [數(shù)量] - 刷東西

instantmine - 開關(guān)即時(shí)采礦（采礦無延遲）

item 物品代碼|物品名稱 [數(shù)量] [費(fèi)用] 給玩家物品, 如果不指定則是最大的數(shù)量

itemname - 顯示當(dāng)前手上的物品名稱

itemstack 物品代碼 [數(shù)量] - 給玩家指定數(shù)量的物品

kill 自殺不解釋

jump - 瞬移到鼠標(biāo)所指的地方

killnpc [all] - 殺死周圍全部NPC 或者叫 殺了附近所有除自己外的活體生物

*light - 把光永久性關(guān)閉

listwaypoints - 列出所有路徑點(diǎn)

macro 文件名 {參數(shù)} - 允許運(yùn)行宏

maxstack [物品ID|物品名稱|全部] [數(shù)量] - 最大的把某物品堆起來

*mobdamage - 怪物不會給你傷害

msg 消息 - 添加一個消息到控制臺

music [音量] - 播放音樂

noclip - 穿墻

p - 顯示當(dāng)前坐標(biāo)

pos 現(xiàn)在玩家的坐標(biāo)

reach - 玩家到指定地方

return - 傳送到之前傳送的地方

rem - 刪除指定路點(diǎn)

removedrops [all] - 刪掉地上物品

*rename - 修改命令名稱

replenish [all] - X

repair [all] - 修復(fù)當(dāng)前物品耐久

reset - 恢復(fù)默認(rèn)設(shè)置

s 名字 - Same as /set

search 關(guān)鍵詞 - 搜索物品名稱

set 名字 - 在這世界標(biāo)記一個路徑點(diǎn)

setjump [JUMP|reset] - 設(shè)置跳躍的高度 落地傷害和移動 1:1

setspawn [ ] 設(shè)置當(dāng)前位置 X軸 Y軸 Z軸

setspeed [速度|重置] - 設(shè)置移動速度

spawn [QTY] - 產(chǎn)生一個生物

spawnstack {NAME|ID|random} - 產(chǎn)生一個合體的怪物NPC

*superheat [all] - Turns items which are furnace-able into their furnaced form

t - Same as /tele

tele - 傳送到此坐標(biāo)

time [set|get|day|night [minute|hour|day [TIME]]] - 設(shè)置指定時(shí)間得到物品

timeschedule - 設(shè)定一段時(shí)間段，讓世界永遠(yuǎn)保持在這段時(shí)間之間

unbind - 解除一個命令

useportal - 傳送到地獄

waterdamage - 開關(guān)潛水傷害

Java 數(shù)據(jù)結(jié)構(gòu)問題

acm上曾經(jīng)做過一個類似的段子。記不清了，大概想一下。

這里為什么是place=x+y*10000;呢，是你隨便寫的還是與生產(chǎn)實(shí)際相關(guān)。如果是place=x*y;就顯而易見了。

下面鏈接是完全二叉樹的java實(shí)現(xiàn)，網(wǎng)上找的，我也沒細(xì)看。

你這個問題，我說一個“創(chuàng)新”點(diǎn)的想法，哈哈，或許能激發(fā)你的思考。

先說邏輯上：

可以用一個二維數(shù)組，如A[][]，每個元素存放A類的對象，如何定位呢，就根據(jù)x、y的值，正好是一對坐標(biāo)，在二維上標(biāo)定了一個位置，這個位置就放該A類對象。放心，這個數(shù)組不會占用太多的內(nèi)存，幾MB頂多了，這也是我看你說明了x、y的范圍得到的啟發(fā)，這樣，創(chuàng)建數(shù)組時(shí)就可以指定大小。查找時(shí)，直觀些的方法就是掃描，你找x最大的，那就順著x軸從右往左掃，掃到的第一個A類對象就是目標(biāo)。掃4個方向你需要的4個極值就都出來了。

數(shù)據(jù)結(jié)構(gòu)上：

當(dāng)然你就用數(shù)組這種結(jié)構(gòu)就ok的，如果你按照圖去處理，也可以用鄰接矩陣或者鄰接鏈表，從本質(zhì)上說，就是你人為地對二維數(shù)組進(jìn)行了優(yōu)化，強(qiáng)化了“掃描”（查找）過程的效率，或者你自己稍微寫個高效些的針對你這個項(xiàng)目的查找算法。

多說一句，如果place=x*y;的話，明顯就是面積，掃描過之后就會圈出一個區(qū)域來，是一個圖，然后對圖再進(jìn)行操作，會很容易解決后續(xù)的問題（你不可能僅找到4個極值就結(jié)束了吧）。

增刪節(jié)點(diǎn)的話，就把該位置上的A對象賦空就可以了，相當(dāng)于刪除，新增則相反。然后重新啟動掃描算法。

用java編寫個程序并注釋

import java.util.Date;

/**

* 名字：XX你是帥哥！

* 作用：突出版主很帥

* @author Administrator

*

*/

public class ShuaiG {

//姓名

private String name;

//拍馬匹用的華麗語言

private String sName;

//拍馬匹的時(shí)間

private Date date;

//獲得拍馬匹的人的姓名

public String getName() {

return name;

}

//設(shè)置拍馬匹的人的姓名

public void setName(String name) {

this.name = name;

}

//設(shè)置拍馬匹用的華麗語言

public String getSName() {

return sName;

}

//獲得拍馬匹用的華麗語言

public void setSName(String name) {

sName = name;

}

//獲得拍馬匹的時(shí)間

public Date getDate() {

return date;

}

//設(shè)置拍馬匹的時(shí)間

public void setDate(Date date) {

this.date = date;

}

/**

* 程序主方法，用來設(shè)置和獲得你的操作并輸出結(jié)果

* @param args

*/

public static void main(String[] args) {

//創(chuàng)建一個帥哥去給老板拍馬匹

ShuaiG shuaiG=new ShuaiG();

//拍馬屁對象的名字叫：版主

shuaiG.setName("版主");

//設(shè)置你要對版主說的話：你帥呆了簡直天下無敵：

shuaiG.setSName("你帥呆了簡直天下無敵");

//指定什么時(shí)候?qū)Π嬷髡f這些話

shuaiG.setDate(new Date());

//現(xiàn)在開始對版主說：版主你帥呆了簡直天下無敵

System.out.println(shuaiG.getName()+shuaiG.getSName());

//你說出這句話的準(zhǔn)確時(shí)間

System.out.println(shuaiG.getDate());

}

}

java自學(xué)一周基本無敵了

首先可以看譚浩強(qiáng)的書，掌握基本的數(shù)據(jù)類型，類，對象，判斷循環(huán)什么的，這個過程如果是自學(xué)，短則一周，長則一個月。并且要不斷練習(xí)編寫小程序，比如什么輸出九九表啊，圖形啊什么的。這個過程相當(dāng)于學(xué)語文的學(xué)語法一樣。

然后是看《Java核心技術(shù)》，學(xué)習(xí)常用的系統(tǒng)提供的方法，這個過程中你掌握的方法越多，往后學(xué)習(xí)起來越容易，并且要不斷練習(xí)編寫中、小程序，Java核心技術(shù)里的源代碼特別多，比別的教材要好很多，而且工作中甚至都能用到那些源代碼。還要大量閱讀Java API文檔，相當(dāng)于學(xué)語文的時(shí)候翻字典一樣。大概要半年時(shí)間。

然后是看《設(shè)計(jì)模式》，這個時(shí)候已經(jīng)可以寫一些稍稍大一點(diǎn)的程序了，比如俄羅斯方塊啊，象棋五子棋啊之類的。這個過程相當(dāng)于學(xué)語文的時(shí)候了解起承轉(zhuǎn)合，了解各種修辭。大概要幾個月吧。

然后是使用各種常用工具，Eclipse是最常用的Java開發(fā)工具，當(dāng)然還有數(shù)據(jù)庫，Java是用來編程的，但是一般的項(xiàng)目中，數(shù)據(jù)需要數(shù)據(jù)庫來存儲。好的Java程序結(jié)構(gòu)需要使用struts，hibernate等工具，這些工具實(shí)際項(xiàng)目中使用，邊用邊學(xué)，不消耗多少時(shí)間。

當(dāng)然，有人帶會快些，沒人帶會慢些。前三個階段，寫代碼多，則半年左右，甚至幾個月。寫代碼少，則一年多甚至兩年。

如果對您有幫助，請記得采納為滿意答案，謝謝！祝您生活愉快！

vaela