亚洲色自偷自拍另类小说,亚洲爆乳精品无码一区二区,亚洲1区1区3区4区产品乱码芒果

Fri, 25 Jul 2008 10:07:00 GMT

Java中的字符串也是一�q�串的字�W�。但是与许多其他的计��机语言��字�W�串作�ؓ字符数组处理不同�Q�Java��字�W�串作�ؓString�c�d��对象来处理。将字符串作为内�|�的对象处理允许Java提供十分丰富的功能特性以方便处理字符丌Ӏ�下面是一些��用频率比较高的函数及其相兌��明�?

substring()
它有两种形式�Q�第一�U�是�Q�String substring(int startIndex)
�W�二�U�是�Q�String substring(int startIndex,int endIndex)

concat() �q�接两个字符�?/p>

replace() 替换
它有两种形式�Q�第一�U��Ş式用一个字�W�在调用字符串中所有出现某个字�W�的地方�q�行替换�Q��Ş式如下：
String replace(char original,char replacement)
例如�Q�String s=”Hello”.replace(’l',’w');
�W�二�U��Ş式是用一个字�W�序列替换另一个字�W�序列，形式如下�Q?br /> String replace(CharSequence original,CharSequence replacement)

trim() ��L��起始和结��I�格

valueOf() 转换为字�W�串

toLowerCase() 转换为小�?/p>

toUpperCase() 转换为大�?/p>

length() 取得字符串的长度
例：
char chars[]={’a',’b’.’c'};
String s=new String(chars);
int len=s.length();

charAt() 截取一个字�W?br /> 例：
char ch;
ch=”abc”.charAt(1);
�q�回��gؓ’b’

getChars() 截取多个字符
void getChars(int sourceStart,int sourceEnd,char target[],int targetStart)
sourceStart 指定了子串开始字�W�的下标
sourceEnd 指定了子串结束后的下一个字�W�的下标。因此，子串包含从sourceStart到sourceEnd-1的字�W��?br /> target 指定接收字符的数�l?br /> targetStart target中开始复制子串的下标�?br /> 例：
String s=”this is a demo of the getChars method.”;
char buf[]=new char[20];
s.getChars(10,14,buf,0);

getBytes()
替代getChars()的一�U�方法是��字�W�存储在字节数组中，该方法即getBytes()
例：
String s = “Hello!你好�Q?#8221;;
byte[] bytes = s.getBytes();

toCharArray()
例：
String s = “Hello!你好�Q?#8221;;
char[] ss = s.toCharArray();

equals()和equalsIgnoreCase() 比较两个字符�?/p>

regionMatches() 用于比较一个字�W�串中特定区域与另一特定区域�Q�它有一个重载的形式允许在比较中忽略大小写�?br /> boolean regionMatches(int startIndex,String str2,int
str2StartIndex,int numChars)
boolean regionMatches(boolean ignoreCase,int startIndex,String
str2,int str2StartIndex,int numChars)

startsWith()和endsWith()
startsWith()�Ҏ��军_��是否以特定字�W�串开始，endWith()�Ҏ��军_��是否以特定字�W�串�l�束

equals()�?=
equals()�Ҏ��比较字符串对象中的字�W�，==�q�算�W�比较两个对象是否引用同一实例�?br /> 例：String s1=”Hello”;
String s2=new String(s1);
s1.eauals(s2); //true
s1==s2;//false

compareTo()和compareToIgnoreCase() 比较字符�?/p>

indexOf()和lastIndexOf()
indexOf() 查找字符或者子串第一�ơ出现的地方�?br /> lastIndexOf() 查找字符或者子串是后一�ơ出现的地方�?/p>

StringBuffer构造函�?br /> StringBuffer定义了三个构造函敎ͼ�
StringBuffer()
StringBuffer(int size)
StringBuffer(String str)
StringBuffer(CharSequence chars)

下面是StringBuffer相关的函敎ͼ�
length()和capacity()
一个StringBuffer当前长度可通过length()�Ҏ��得到,而整个可分配�I�间通过capacity()�Ҏ��得到�?/p>

ensureCapacity() 讄��~�冲区的大小
void ensureCapacity(int capacity)

setLength() 讄��~�冲区的长度
void setLength(int len)

charAt()和setCharAt()
char charAt(int where)
void setCharAt(int where,char ch)

getChars()
void getChars(int sourceStart,int sourceEnd,char target[],int targetStart)

append() 可把��M��c�d��数据的字�W�串表示�q�接到调用的StringBuffer对象的末��?br /> 例：int a=42;
StringBuffer sb=new StringBuffer(40);
String s=sb.append(”a=”).append(a).append(”!”).toString();

insert() 插入字符�?br /> StringBuffer insert(int index,String str)
StringBuffer insert(int index,char ch)
StringBuffer insert(int index,Object obj)
index指定��字�W�串插入到StringBuffer对象中的位置的下标�?/p>

reverse() 颠倒StringBuffer对象中的字符
StringBuffer reverse()

delete()和deleteCharAt() 删除字符
StringBuffer delete(int startIndex,int endIndex)
StringBuffer deleteCharAt(int loc)

replace() 替换
StringBuffer replace(int startIndex,int endIndex,String str)

substring() 截取子串
String substring(int startIndex)
String substring(int startIndex,int endIndex)

飞行�?/a> 2008-07-25 18:07 发表评论

Mon, 16 Jun 2008 09:27:00 GMT

String的创�?/font>

String s = "hello";
JVM先根据内�?hello"查找对象�Q�如果没有找刎ͼ�则在heap上创建新对象�Q��ƈ��其赋予s1�Q�否则��用已�l�存在的对象

String s = new String("hello");
JVM直接在heap上创建新的对象，所以在heap中会出现内容相同�Q�地址不同的String对象

String的比�?/font>

"==" 比较地址
"equals" 比较内容

举例:
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");

s1 == s2;               // true        地址相同
s1 == s3;               // false       地址不同
s1.equals(s2);          // true        内容相同
s1.equals(s3);          // true        内容相同

intern() �Ҏ��

查找内容相同(equals())的字�W�串

   String s1 = "hello";                // hello不存在，jvm创徏新对�?(1)
   String s2 = new String("hello");    // 创�D新对�?(2)�Q�这时heap中存在两个内容�ؓhello的对�?br minmax_bound="true" />    s1 == s2;           // false        // 地址不同
   s1.equals(s2);      // true         // 内容相同
   s2 = s2.intern();   // true         // 扑ֈ�对象(1) �q�赋予s2
   s1 == s2;           // true !!      // 注意�Q�此时s1,s2同指�?1)

效率�Q�String �?StringBuffer

情景1�Q?br minmax_bound="true" /> (1) String result = "hello" + " world";
(2) StringBuffer result = new String().append("hello").append(" world");

        (1) 的效率好�?(2)�Q�不要奇怪，�q�是因�ؓJVM会做如下处理
        �~�译�?nbsp; String result = "hello" + " world";
        �~�译�?nbsp; String result = "hello world";

    情景2�Q?br minmax_bound="true" />     (1) public String getString(String s1, String s2) {
            return s1 + s2;
        }
    (2) public String getString(String s1, String s2) {
            return new StringBuffer().append(s1).append(s2);
        }

        (1) 的效率与 (2) 一��P��q�是因�ؓJVM会做如下处理
        �~�译�?nbsp; return s1 + s2;
        �~�译�?nbsp; return new StringBuffer().append(s1).append(s2);

    情景3�Q?br minmax_bound="true" />     (1) String s = "s1";
              s += "s2";
              s += "s3";
    (2) StringBuffer s = new StringBuffer().append("s1").append("s2").append("s3");

(2) 的效率好�?1)�Q�因为String是不可变对象�Q�每��?+="操作都会造成构造新的String对象

    情景4�Q?br minmax_bound="true" />     (1) StringBuffer s = new StringBuffer();
        for (int i = 0; i < 50000; i ++) {
            s.append("hello");
        }
    (2) StringBuffer s = new StringBuffer(250000);
        for (int i = 0; i < 50000; i ++) {
            s.append("hello");
        }

        (2) 的效率好�?(1)�Q�因为StringBuffer内部实现是char数组�Q�默认初始化长度�?6�Q�每当字�W�串长度大于char
        数组长度的时候，JVM会构造更大的新数�l�，�q�将原先的数�l�内容复制到新数�l�，(2)避免了复制数�l�的开销

关键�?br minmax_bound="true" />     1). ��单的认�ؓ .append() 效率好于 "+" 是错误的�Q?br minmax_bound="true" />     2). 不要使用 new 创徏 String
    3). 注意 .intern() 的��?br minmax_bound="true" />     4). 在编译期能够��定字符串值的情况下，使用"+"效率最�?br minmax_bound="true" />     5). 避免使用 "+=" 来构造字�W�串
    6). 在声明StringBuffer对象的时候，指定合适的capacity�Q�不要��用默认�?18)
    7). 注意以下二者的区别不一�?br minmax_bound="true" />         - String s = "a" + "b";
        - String s = "a";
          s += "b";

String和StringBuffer之概�?br minmax_bound="true" /> 　　创徏字符串的较佳途径
　　滞留字符串带来的优化
　　�q�接字符串时的优化技�?br minmax_bound="true" /> 　　借助StringBuffer的初始化�q�程的优化技�?br minmax_bound="true" /> 　　关键�?/font>

String和StringBuffer之概�?/strong>
　　非可变对象一旦创��Z��后就不能再被改变�Q�可变对象则可以在创��Z��后被改变。String对象是非可变对象�Q�StringBuffer对象则是可变对象。�ؓ获得更佳的性能你需要根据实际情况小心�}慎地选择到底使用�q�两者中的某一个。下面的话题会作详细的阐�q�。（注意�Q�这个章节假设读者已�l�具备Java的String和StringBuffer的相兛_��知识。）

创徏字符串的较佳途径

你可以按照以下方式创建字�W�串对象�Q?br minmax_bound="true" /> 1. String s1 = "hello";
    String s2 = "hello";
2. String s3 = new String("hello");
    String s4 = new String("hello");

上面哪种方式会带来更好的性能呢？下面的代码片断用来测量二者之间的区别�?/font>

StringTest1.java

package com.performance.string;

/** This class shows the time taken for creation of
* String literals and String objects.
*/

public class StringTest1 {

public static void main(String[] args){

    // create String literals
    long startTime = System.currentTimeMillis();
    for(int i=0;i<50000;i++){

    String s1 = "hello";
    String s2 = "hello";
    }

    long endTime = System.currentTimeMillis();
    System.out.println("Time taken for creation of String literals : "
                  + (endTime - startTime) + " milli seconds" );

    // create String objects using 'new' keyword
    long startTime1 = System.currentTimeMillis();
    for(int i=0;i<50000;i++){

    String s3 = new String("hello");
    String s4 = new String("hello");
    }

    long endTime1 = System.currentTimeMillis();
    System.out.println("Time taken for creation of String objects : "
                  + (endTime1 - startTime1)+" milli seconds");
    }
}
�q�段代码的输出：
Time taken for creation of String literals : 0 milli seconds
Time taken for creation of String objects : 170 milli seconds

JVM是怎样处理字符串的呢？
　　Java虚拟��Z��l�护一个内部的滞留字符串对象的列表�Q�唯一字符串的池）来避免在堆内存中产生重复的String对象。当JVM从class文�g里加载字�W�串字面量�ƈ执行的时候，它会先检查一下当前的字符串是否已�l�存在于滞留字符串列表，如果已经存在�Q�那��׃��会再创徏一个新的String对象而是��引用指向已�l�存在的String对象�Q�JVM会在内部为字�W�串字面量作�q�种��查，但�ƈ不会为通过new关键字创建的String对象作这�U�检查。当然你可以明确��C��用String.intern()�Ҏ��强制JVM为通过new关键字创建的String对象作这��L��查。这样可以强制JVM��查内部列表而��用已有的String对象�?/font>

　　所以结论是�Q�JVM会内在地为字�W�串字面量维护一些唯一的String对象�Q�程序员不需要�ؓ字符串字面量而发愁，但是可能会被一些通过new关键字创建的String对象而困扎ͼ�不过他们可以使用intern()�Ҏ��来避免在堆内存上创徏重复的String对象来改善Java的运行性能。下一��节会向大家展示更多的信息�?/font>

下图展示了未使用intern()�Ҏ��来创建字�W�串的情��c�?br minmax_bound="true" />

　　你可以自�׃��?=操作�W�和String.equals()�Ҏ��来编码测试上面提到的区别�?=操作�W�会�q�回true如果一些引用指向一个相同的对象但不会判断String对象的内�Ҏ��否相同；String.equals()�Ҏ��会返回true如果被操作的String对象的内容相同。对于上面的代码会有s1==s2�Q�因为s1和s2两个引用指向同一个对象，对于上面的代码，s3.equals(s4)会返回true因�ؓ两个对象的内定w��一样�ؓ”hello”。你可以从上囄��U�机制。在�q�里有三个独立的包含了相同的内容�Q?#8221;hello”�Q�的对象�Q�实际上我们不需要这么三个独立的对象――因��q�行它们的话既浪�Ҏ��间又��费内存�?/font>

　　那么怎样才能��保String对象不会重复呢？下一个话题会�늛�对于内徏String机制的兴��?/font>

滞留字符串的优化作用
　　同一个字�W�串对象被重复地创徏是不必要的，String.intern()�Ҏ��可以避免�q�种情况。下图说明了String.intern()�Ҏ��是如何工作的�Q�String.intern()�Ҏ��查字�W�串对象的存在性，如果需要的字符串对象已�l�存在，那么它会��引用指向已�l�存在的字符串对象而不是重新创��Z��个。下图描�l�了使用了intern()�Ҏ��的字�W�串字面量和字符串对象的创徏情况�?br minmax_bound="true" />

下面的例�E�帮助大家了解String.intern()�Ҏ��的重要性�?br minmax_bound="true" /> StringTest2.java

package com.performance.string;

// This class shows the use of intern() method to improve performance
public class StringTest2 {

public static void main(String[] args){

    // create String references like s1,s2,s3...so on..
    String variables[] = new String[50000];
    for( int i=0;i         variables[i] = "s"+i;
    }

    // create String literals
    long startTime0 = System.currentTimeMillis();
    for(int i=0;i         variables[i] = "hello";
    }

    long endTime0 = System.currentTimeMillis();
    System.out.println("Time taken for creation of String literals : "
                         + (endTime0 - startTime0) + " milli seconds" );

    // create String objects using 'new' keyword
    long startTime1 = System.currentTimeMillis();
    for(int i=0;i         variables[i] = new String("hello");
    }

    long endTime1 = System.currentTimeMillis();
    System.out.println("Time taken for creation of String objects with 'new' key word : "
                        + (endTime1 - startTime1)+" milli seconds");

    // intern String objects with intern() method
    long startTime2 = System.currentTimeMillis();
    for(int i=0;i         variables[i] = new String("hello");
        variables[i] = variables[i].intern();
    }

    long endTime2 = System.currentTimeMillis();
    System.out.println("Time taken for creation of String objects with intern(): "
                        + (endTime2 - startTime2)+" milli seconds");
    }
}

�q�是上面那段代码的输出结果：
Time taken for creation of String literals : 0 milli seconds
Time taken for creation of String objects with 'new' key word : 160 milli seconds
Time taken for creation of String objects with intern(): 60 milli seconds

�q�接字符串时候的优化技�?br minmax_bound="true" /> 　　你可以��?操作�W�或者String.concat()或者StringBuffer.append()�{�办法来�q�接多个字符�Ԍ��那一�U�办法具有最佳的性能呢？

　　如何作出选择取决于两�U�情景，�W�一�U�情景是需要连接的字符串是在编译期军_��的还是在�q�行期决定的�Q�第二种情景是你使用的是StringBuffer�q�是String。通常�E�序员会认�ؓStringBuffer.append()�Ҏ��会优�?操作�W�或String.concat()�Ҏ��Q�但是在一些特定的情况下这个假��x��不成立的�?/font>

1) �W�一�U�情景：�~�译期决定相对于�q�行期决�?br minmax_bound="true" /> ��L��下面的StringTest3.java代码和输出结果�?/font>

package com.performance.string;

/** This class shows the time taken by string concatenation at compile time and run time.*/
public class StringTest3 {

public static void main(String[] args){
    //Test the String Concatination
    long startTime = System.currentTimeMillis();
    for(int i=0;i<5000;i++){
    String result = "This is"+ "testing the"+ "difference"+ "between"+
            "String"+ "and"+ "StringBuffer";
    }

    long endTime = System.currentTimeMillis();
    System.out.println("Time taken for string concatenation using + operator : "
         + (endTime - startTime)+ " milli seconds");

    //Test the StringBuffer Concatination
    long startTime1 = System.currentTimeMillis();
    for(int i=0;i<5000;i++){
    StringBuffer result = new StringBuffer();
         result.append("This is");
        result.append("testing the");
        result.append("difference");
        result.append("between");
       result.append("String");
       result.append("and");
       result.append("StringBuffer");
     }

    long endTime1 = System.currentTimeMillis();
    System.out.println("Time taken for String concatenation using StringBuffer : "
           + (endTime1 - startTime1)+ " milli seconds");
}
}
�q�是上面的代码的输出�l�果�Q?br minmax_bound="true" /> Time taken for String concatenation using + operator : 0 milli seconds
Time taken for String concatenation using StringBuffer : 50 milli seconds
很有��地�Q?操作�W�居然比StringBuffer.append()�Ҏ��要快�Q��ؓ什么呢�Q?/font>

　　�q�里�~�译器的优化起了关键作用�Q�编译器像下面�D例的那样��单地在编译期�q�接多个字符丌Ӏ�它使用�~�译期决定取代运行期军_��Q�在你��用new关键字来创徏String对象的时候也是如此�?/font>

�~�译前：
String result = "This is"+"testing the"+"difference"+"between"+"String"+"and"+"StringBuffer";
�~�译后：
String result = "This is testing the difference between String and StringBuffer";

�q�里String对象在编译期��决定了而StringBuffer对象是在�q�行期决定的。运行期军_��需要额外的开销当字�W�串的值无法预先知道的时候，�~�译期决定作用于字符串的值可以预先知道的时候，下面是一个例子�?/font>

�~�译前：
public String getString(String str1,String str2) {
    return str1+str2;
}
�~�译后：
return new StringBuffer().append(str1).append(str2).toString();
�q�行期决定需要更多的旉��来运行�?/font>

2) �W�二�U�情景：使用StringBuffer取代String
看看下面的代码你会发��C��情景一相反的结果――连接多个字�W�串的时候StringBuffer要比String快�?br minmax_bound="true" /> StringTest4.java

package com.performance.string;

/** This class shows the time taken by string concatenation
using + operator and StringBuffer */
public class StringTest4 {

public static void main(String[] args){
    //Test the String Concatenation using + operator
    long startTime = System.currentTimeMillis();
    String result = "hello";
    for(int i=0;i<1500;i++){
        result += "hello";
    }

    long endTime = System.currentTimeMillis();
    System.out.println("Time taken for string concatenation using + operator : "
                  + (endTime - startTime)+ " milli seconds");

    //Test the String Concatenation using StringBuffer
    long startTime1 = System.currentTimeMillis();
    StringBuffer result1 = new StringBuffer("hello");
    for(int i=0;i<1500;i++){
        result1.append("hello");
    }

    long endTime1 = System.currentTimeMillis();
    System.out.println("Time taken for string concatenation using StringBuffer : "
                  + (endTime1 - startTime1)+ " milli seconds");
    }
}
�q�是上面的代码的输出�l�果�Q?br minmax_bound="true" /> Time taken for string concatenation using + operator : 280 milli seconds
Time taken for String concatenation using StringBuffer : 0 milli seconds

看得出StringBuffer.append()�Ҏ��要比+操作�W�要快得多，��Z��么呢�Q?/font>

　　原因是两者都是在�q�行期决定字�W�串对象�Q�但�?操作�W��用不同于StringBuffer.append()的规则通过String和StringBuffer来完成字�W�串�q�接操作。（译注�Q�什么样的规则呢�Q�）

借助StringBuffer的初始化�q�程的优化技�?/strong>
　　你可以通过StringBuffer的构造函数来讑֮�它的初始化容量，�q�样可以明显地提升性能。这里提到的构造函数是StringBuffer(int length)�Q�length参数表示当前的StringBuffer能保持的字符数量。你也可以��用ensureCapacity(int minimumcapacity)�Ҏ��在StringBuffer对象创徏之后讄��它的定w��。首先我们看看StringBuffer的缺省行为，然后再找��Z��条更好的提升性能的途径�?/font>

StringBuffer的缺省行为：
　　StringBuffer在内部维护一个字�W�数�l�，当你使用�~�省的构造函数来创徏StringBuffer对象的时候，因�ؓ没有讄��初始化字�W�长度，StringBuffer的容量被初始化�ؓ16个字�W�，也就是说�~�省定w��是16个字�W�。当StringBuffer辑ֈ�最大容量的时候，它会��自�w�容量增加到当前�?倍再�?�Q�也��是�Q?*旧�?2�Q��?/font>

　　如果你��用缺省��|��初始化之后接着往里面�q�加字符�Q�在你追加到�W?6个字�W�的时候它会将定w��增加�?4�Q?*16+2�Q�，当追加到34个字�W�的时候就会将定w��增加�?0�Q?*34+2�Q�。无��Z��事只要StringBuffer到达它的最大容量它��׃��得不创徏一个新的字�W�数�l�然后重新将旧字�W�和新字�W�都拯��一遍――这也太昂贵了点。所以��L��l�StringBuffer讄��一个合理的初始化容量值是错不了的�Q�这样会带来立竿见媄的性能增益�?/font>

　　我利用两个StringBuffer重新��试了上面的StringTest4.java代码�Q�一个未使用初始化容量��D��另一个��用了。这�ơ我�q�加�?0000�?#8217;hello’对象没有使用+操作�W�。区别是我��用StringBuffer(250000)的构造函数来初始化第二个StringBuffer了�?/font>

输出�l�果如下�Q?br minmax_bound="true" /> Time taken for String concatenation using StringBuffer with out setting size: 280 milli seconds
Time taken for String concatenation using StringBuffer with setting size: 0 milli seconds

StringBuffer初始化过�E�的调整的作用由此可见一斑。所以，使用一个合适的定w��值来初始化StringBuffer永远都是一个最佳的��?/font>

关键�?/strong>
1. 无论何时只要可能的话使用字符串字面量来常见字�W�串而不是��用new关键字来创徏字符丌Ӏ?br minmax_bound="true" /> 2. 无论何时当你要��用new关键字来创徏很多内容重复的字�W�串的话�Q�请使用String.intern()�Ҏ��?br minmax_bound="true" /> 3. +操作�W�会为字�W�串�q�接提供最佳的性能――当字符串是在编译期军_��的时候�?br minmax_bound="true" /> 4. 如果字符串在�q�行期决定，使用一个合适的初期定w��值初始化的StringBuffer会�ؓ字符串连接提供最佳的性能�?/font>

String与StringBuffer的比�?/strong>
String�c�L��供了一些方法，用来�q�行字符串的比较。这个类实现了Object父类的equals()�Ҏ��Q�用来比较两�U�字�W�串的值是否相�{�。同时还增加了equalsIgnoreCase()�Ҏ��可以忽略两个字符串大��写的区别。下面是�q�两�U�方法的例子�?br minmax_bound="true" /> 【例6-6�?br minmax_bound="true" /> public class E6_6{
public static void main(String args[]) {
  String s1="a";
  String s2=new String("a");
  String s3="A";
  System.out.println(s1.equals(s2));
  System.out.println(s1.equals(s3));
  System.out.println(s1.equalsIgnoreCase(s3));
}
}
上例的输出是
true
flase
true
但是StringBuffer�c�dƈ没有实现Objcet�cȝ��Equals�Ҏ��Q�所以不能用�q�个�Ҏ��来比较两个StringBuffer�cȝ��字符串是否相�{�，如下例所�C��?br minmax_bound="true" /> 【例6-7�?br minmax_bound="true" /> public class E6_7{
public static void main(String args[]) {
  StringBuffer s1=new StringBuffer("a");
  StringBuffer s2=new StringBuffer("a");
  System.out.println(s1.equals(s2));

}
}
�E�序输出�Q�false

除了用equalse�Ҏ��来比较两个字�W�串外，�q�可以用==来比较字�W�串。与equalse�Ҏ��不同的是�Q?=不是比较两个字符串的值是否相�{�，而是比较几个字符串的引用是否指向同一个实例。如�?-8所�C��?br minmax_bound="true" /> 【例6-8�?br minmax_bound="true" /> public class E6_8{
public static void main(String args[]) {
  String s1="a";
  String s2="a";
  String s3=new String("a");
  String s4=new String("a");
  System.out.println(s1==s2);
  System.out.println(s3==s4);
  System.out.println(s1==s3);

}

}
上面的程序段输出�Q?br minmax_bound="true" /> true
false
false
与上例进行比较，不仅可以看出�?=与equals的区别，�q�可以看到字面量的String的特�D�之外�?br minmax_bound="true" /> 对于字面量的String�Q�只要字�W�串的值是相等的，不论有多��个引用都是指向同一块内存，不再另外分配�I�间。而用new关键字生成的实例则不同，每当用new实例化一�ơ，分配该实例自��q��内存�I�间。上例的存储方式如图所�C�：

�?-1 s1、s2、s3、s4的区�?br minmax_bound="true" /> 下面再通过另一个例子来看String和StringBuffer的区别�?br minmax_bound="true" /> 【例6-9�?br minmax_bound="true" /> public class E6_9{
public static void main(String args[]) {
  String s1="a";
  StringBuffer sb1=new StringBuffer("a");

  StringBuffer sb2=sb1;
  String s2="a"+"b";
  sb1.append("b");

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

}
}
上例输出的是�Q?br minmax_bound="true" /> flase
true
上例可以证明�q�样的结论：String是不可变长的字符�Ԍ��对String做�Q何的修改��生成新的字�W�串�Q�而StringBuffer是可变长的字�W�串�Q�不论怎么更动�q�是同一个字�W�串�?br minmax_bound="true" />

飞行�?/a> 2008-06-16 17:27 发表评论

Tue, 03 Jun 2008 09:56:00 GMT

对于java初学者来��_��往往不懂区分jdk和jre的区别，实际上这两个东西差别很大的，有必要了解一下：

��单的说JDK是面向开发�h员��用的SDK�Q�它提供了Java的开发环境和�q�行环境。SDK是Software Development Kit 一般指软�g开发包�Q�可以包括函数库、编译程序等�?br />    JDK��是Java Development Kit
JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java�E�序的��用者，而不是开发者�?/p>
如果安装了JDK�Q�会发同你的电脑有两套JRE�Q�一套位�?\jre 另外一套位�?C:\Program Files\Java\j2re1.4.1_01 目录下，后面�q�套比前面那套少了Server端的Java虚拟机，不过直接��前面那套的Server端Java虚拟机复制过来就行了。而且在安装JDK可以选择是否安装�q�个位于 C:\Program Files\Jav a 目录下的JRE。如果你只安装JRE�Q�而不是JDK�Q�那么只会在 C:\Program Files\Java 目录下安装唯一的一套JRE�?

     JRE的地位就象一台PC��Z��P��我们写好的Win32应用�E�序需要操作系�l�帮我们�q�行�Q�同��L��Q�我们编写的Java�E�序也必��要JRE才能�q�行。所以当你装完JDK后，如果分别在硬盘上的两个不同地方安装了两套JRE�Q�那么你可以惌��你的电脑有两台虚拟的Java PC机，都具有运行Java�E�序的功能。所以我们可以说�Q�只要你的电脑安装了JRE�Q�就可以正确�q�行Jav a应用�E�序�?br />
       1、�ؓ什么Sun要让JDK安装两套相同的JRE�Q�这是因为JDK里面有很多用Java所�~�写的开发工��P��如javac.exe、jar.exe�{�）�Q�而且都放�|�在 \lib\tools.jar 里。从下面例子可以看出�Q�先��tools.jar改名为tools1.jar�Q�然后运行javac.exe�Q�显�C�如下结果： Exception in thread "main" java.lang.NoClassDefFoundError: com/sun/tools/javac /Main �q�个意思是��_��你输入javac.exe与输�?java -cp c:\jdk\lib\tools.jar com.sun.tools.javac.Main 是一��L��Q�会得到相同的结果。从�q�里我们可以证明javac.exe只是一个包装器�Q�Wrapper�Q�，而制作的目的是�ؓ了让开发者免于输入太长的指命。而且可以发现\lib目录下的�E�序都很��，不大�? 9K�Q�从�q�里我们可以得出一个结论。就是JDK里的工具几乎是用Java所�~�写�Q�所以也是Java应用�E�序�Q�因此要使用JDK所附的工具来开发Java�E�序�Q�也必须要自行附一套JRE才行�Q�所以位于C:\Program Files\Java目录下的那套JRE��是用来�q�行一般Java�E�序用的�?

      2、如果一台电脑安装两套以上的JRE�Q�谁来决定呢�Q�这个重大�Q务就落在java.exe�w�上。Java.exe的工作就是找到合适的JRE来运行Java�E�序�?Java.exe依照底下的顺序来查找JRE�Q�自��q��目录下有没有JRE�Q�父目录有没有JRE�Q�查询注册表�Q?[HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment] 所以java.exe的运行结果与你的电脑里面哪个JRE被执行有很大的关�p�R�?

     3、介�l�JVM JRE目录下的Bin目录有两个目录：server与client。这��是真正的jvm.dll所在�?jvm.dll无法单独工作�Q�当jvm.dll启动后，会��用explicit的方法（��是使用Win32 API之中的LoadLibrary()与GetProcAddress()来蝲入辅助用的动态链接库�Q�，而这些辅助用的动态链接库�Q?dll�Q�都必须位于jvm.dll所在目录的父目录之中。因此想使用哪个JVM�Q�只需要设�|�PATH�Q�指向JRE所在目录底下的jvm.dll

飞行�?/a> 2008-06-03 17:56 发表评论