string与参数引用传递

编者语：书上都说string是引用类型，但事实上我所看到的string和所谓的值类型没有什么区别，但通过看以下的文章，明白了：

1、string a="abc";之后，如果a="xy"，则是a并没有改变内存中已经存在的"abc"，而是又创建了另外一个实例。实际上相当于：string a=new String("abc");a=new String("xy");但如果是StringBuffer，则：StringBuffer a=new StringBuffer("abc"); 这是如果再想改变a，则：a.append("xy");值变为"abcxy"，其中并没有new。

2、以上中：string a="abc"; b=a; a="xy"; 则b还是"abc"。
但如果是：StringBuffer a=new StringBuffer("abc"); StringBuffer b=a; a=a.append("xy");  则b变为："abcxy"。

3、虽然string确实是引用类型，但我想我还是基本把他看成是值类型，因为他引用的内存中的值并不会改变，也应该不会说当另外一个应用改变了内存中的值，从而会导致这个值的改变，不会的。但stringBuffer却可以。还有数组等。

4、数据分为2种，一种是值类型，一种是引用类型。但方法的传递方式却是三种，默认的一般书上不写，即值传递（val），另外2种是：ref 和 out。

5、事实上，所有的值类型数据包括所谓的引用类型的string，在值参数时，其方法中都无法不从根本上改变其本质，因为任何常用的赋值都省略了new .....。只有数组、StringBuffer以及其他类在改变其中的部分内容是可以不改变其本质，如stringbuffer.append()、intArray[2]=100等，要改变他们的本质好像只能用new的形式。这也是为何我们经常分不清string是否是引用类型，以及传递参数时的种种疑惑的根源。举个Array的例子：

 

void  aa( int () array, int  x, string  z)
{
  array[2]=array[2]+100;
   array=new int[]{5,6,7}

  x=100;
  z="zz";
}

void  bb(  ref   int [] array , int  x, string  z)
{
  array[2]=array[2]+100;
  array=new int[]{5,6,7}

  x=100;
  z="zz";

}

int [] a = new   int []  {1,2,3} ;
int  xx = 9 ;
string  zy = " zy " ;

 

 那么上面的结论中，如果是第一aa方法，只有数组会改变其值，而且只会执行第一行命令，结果为103，但不会new，而变为{5,6,7}。在ref方法中，数组会变为{5,6,7}，xx和zy也会变的。以上是我的心得。

以下是在Java中的结论，应该也适用于C#吧。

1. 声明是什么?
String s = "Hello world!";

许多人都做过这样的事情，但是，我们到底声明了什么？回答通常是：一个String，内容是“Hello world!”。这样模糊的回答通常是概念不清的根源。如果要准确的回答，一半的人大概会回答错误。
这个语句声明的是一个指向对象的引用，名为“s”，可以指向类型为String的任何对象，目前指向"Hello world!"这个String类型的对象。这就是真正发生的事情。我们并没有声明一个String对象，我们只是声明了一个只能指向String对象的引用变量。所以，如果在刚才那句语句后面，如果再运行一句：

String string = s;

我们是声明了另外一个只能指向String对象的引用，名为string，并没有第二个对象产生，string还是指向原来那个对象，也就是，和s指向同一个对象。
2. String类的特殊性
1) String s1 = “Hello”;  //产生一个String ”Hello”对象,并产生该对象的一个别名s1来引用该对象
String s2 = “Hello”;  //又产生一个别名s2来引用上面的”Hello”对象
s1 == s2 = true;   //由于是同一个对象所以“==”返回为true
s1 = “World”;  //产生一个String ”World”对象, s1的引用不再指向“Hello”而是指向对象”World”
s1 == s2 = false;   //由于不是同一个对象所以“==”返回为false
s1 = “Hello”;  //同上面的String s2 = “Hello”; 现在s1又指向对象”Hello”, 因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。
s1 == s2 = true;   //由于是同一个对象所以“==”又返回为true了
s1 = s1 + “World”;  //这时又产生一个对象”HelloWord”,s1不再指向”Hello”而是指向”HelloWord”
s1 == s2 = false;  //不是一个对象当然是false拉
s1 = s1+ "a"+"b"+"c"+…;  // String不停的创建对象,影响性能，这种易变的String用StringBuffer会得到更好的性能
StringBuffer s3 = new StringBuffer(“Hello”); 
s3.append(“a”); //没有生成新的对象，而是将s3引用的对象内容改为”Helloa”

//说明: String类用来表示那些创建后就不会再改变的字符串，它是immutable的。而StringBuffer类用来表示内容可变的字符串，并提供了修改底层字符串的方法。
StingBuffer是一个可变的字符串，它可以被更改。同时StringBuffer是Thread safe的， 你可以放心的使用.

因为String被设计成一种安全的字符串， 避免了C/C++中的尴尬。因此在内部操作的时候会频繁的进行对象的交换， 因此它的效率不如StringBuffer。 如果需要频繁的进行字符串的增删操作的话最好用StringBuffer。 比如拼SQL文， 写共函。 另： 编绎器对String的+操作进行了一定的优化。 
x = "a" + 4 + "c"
会被编绎成
x = new StringBuffer().append("a").append(4).append("c").toString()
但：
x = “a”;
x = x + 4;
x = x + “c”;
则不会被优化。 可以看出如果在一个表达式里面进行String的多次+操作会被优化， 而多个表达式的+操作不会被优化。
摘自：《Java API Using, Tips And Performance Tuning》
2) Integer、Boolean等wrapper类以及BigInteger、BigDecimal是immutable的，所以也有与String类似的地方，不过没有IntegerBuffer之类的东西。不过Float, Double,Boolean比较特殊。如
T a1 = 10; //T代指Byte,Integer,Short,Long
T a2 = 10;
if (f1 == f2)
 System.out.println(true);
else
 System.out.println(false);
这时总是true,和String有点类似

T a1 = (T)10.0; //T代指Float,Double
T a2 = (T)10.0;
if (f1 == f2)
 System.out.println(true);
else
 System.out.println(false);
这时总是false

Boolean a1 =true; 
Boolean a2 =true;
if (f1 == f2)
 System.out.println(true);
else
 System.out.println(false);
这时总是false
总之如果比较两个Wrapper类的值用equals，以免不必要的麻烦
3) 再看
String s1 = new String(“Hello”);
String s2 = new String(“Hello”);
s1 == s2 = false;
//因为new的时候JVM不管heap中有没有”Hello”对象都会产生一个新的”Hello”对象
String s3 = “Hello”; //重新创建对象”Hello”, 并令s3指向对象”Hello”
s3 == s1 = false; //不同对象当然false
String s4 = “Hello”; 
s3 == s4 = true;  //故伎重演，jvm清楚的知道哪些用了new，哪些没用new
//Integer等整型wrapper类也有同样的特性
3. 方法的参数传递中都是以reference传递，而primitive传递的是副本，但如果传递的是Integer、Boolean等wrapper类和String类的Object则是以immutable方式传递。示例：
import java.awt.Point;
class HelloWorld
{
  public static void modifyPoint(Point pt, String j, int k, Integer m, Boolean b)
  {
    pt.setLocation(5,5);                                      
    j = "15";
    k = 25;
    m = 35;
    b = true;
    System.out.println("During modifyPoint " + "pt = " + pt +
                       " and j = " + j+ " and k = "+ k+ 
                       " and m = "+ m+ " and b = "+ b);
  }

  public static void main(String args[])
  {
    Point p = new Point(0,0);                                 
    String i = "10";
    int k = 20;
    Integer m = 30;
    Boolean b = false;
    System.out.println("Before modifyPoint " + "p = " + p +
                       " and i = " + i+ " and k = "+ k+ 
                       " and m = "+ m+ " and b = "+ b);
    modifyPoint(p, i, k, m, b);                                        
    System.out.println("After modifyPoint " + "p = " + p +
                       " and i = " + i+ " and k = "+ k+ 
                       " and m = "+ m+ " and b = "+ b);
  }
}
输出结果：
Before modifyPoint p = java.awt.Point[x=0,y=0] and i = 10 and k = 20 and m = 30 and b = false
During modifyPoint pt = java.awt.Point[x=5,y=5] and j = 15 and k = 25 and m = 35 and b = true
After modifyPoint p = java.awt.Point[x=5,y=5] and i = 10 and k = 20 and m = 30 and b = false

 

 

 

 

Java是传值还是传引用

1. 简单类型是按值传递的

　　Java 方法的参数是简单类型的时候，是按值传递的 (pass by value)。这一点我们可以通过一个简单的例子来说明：

/* 例 1 */
/**
 * @(#) Test.java
 * @author fancy
 */
public class Test {
    public static void test(boolean test) {
        test = ! test;
        System.out.println("In test(boolean) : test = " + test);
    }
    public static void main(String[] args) {
        boolean test = true;
        System.out.println("Before test(boolean) : test = " + test);
        test(test);
        System.out.println("After test(boolean) : test = " + test);
    }
}

　　运行结果：

Before test(boolean) : test = true
In test(boolean) : test = false
After test(boolean) : test = true

　　不难看出，虽然在 test(boolean) 方法中改变了传进来的参数的值，但对这个参数源变量本身并没有影响，即对 main(String[]) 方法里的 test 变量没有影响。那说明，参数类型是简单类型的时候，是按值传递的。以参数形式传递简单类型的变量时，实际上是将参数的值作了一个拷贝传进方法函数的，那么在方法函数里再怎么改变其值，其结果都是只改变了拷贝的值，而不是源值。

　　2. 什么是引用

　　Java 是传值还是传引用，问题主要出在对象的传递上，因为 Java 中简单类型没有引用。既然争论中提到了引用这个东西，为了搞清楚这个问题，我们必须要知道引用是什么。

　　简单的说，引用其实就像是一个对象的名字或者别名 (alias)，一个对象在内存中会请求一块空间来保存数据，根据对象的大小，它可能需要占用的空间大小也不等。访问对象的时候，我们不会直接是访问对象在内存中的数据，而是通过引用去访问。引用也是一种数据类型，我们可以把它想象为类似 C 语言中指针的东西，它指示了对象在内存中的地址——只不过我们不能够观察到这个地址究竟是什么。

　　如果我们定义了不止一个引用指向同一个对象，那么这些引用是不相同的，因为引用也是一种数据类型，需要一定的内存空间来保存。但是它们的值是相同的，都指示同一个对象在内存的中位置。比如

String a = "Hello";
String b = a;

　　这里，a 和 b 是不同的两个引用，我们使用了两个定义语句来定义它们。但它们的值是一样的，都指向同一个对象 "Hello"。也许你还觉得不够直观，因为 String 对象的值本身是不可更改的 (像 b = "World"; b = a; 这种情况不是改变了 "World" 这一对象的值，而是改变了它的引用 b 的值使之指向了另一个 String 对象 a)。那么我们用 StringBuffer 来举一个例子：

/* 例 2 */
/**
 * @(#) Test.java
 * @author fancy
 */
public class Test {
    public static void main(String[] args) {
        StringBuffer a = new StringBuffer("Hello");
        StringBuffer b = a;
        b.append(", World");
        System.out.println("a is " + a);
    }
}

　　运行结果：

a is Hello, World

　　这个例子中 a 和 b 都是引用，当改变了 b 指示的对象的值的时候，从输出结果来看，a 所指示的对象的值也改变了。所以，a 和 b 都指向同一个对象即包含 "Hello" 的一个 StringBuffer 对象。

　　这里我描述了两个要点：

1. 引用是一种数据类型，保存了对象在内存中的地址，这种类型即不是我们平时所说的简单数据类型也不是类实例(对象)；
2. 不同的引用可能指向同一个对象，换句话说，一个对象可以有多个引用，即该类类型的变量。

　　3. 对象是如何传递的呢

　　关于对象的传递，有两种说法，即“它是按值传递的”和“它是按引用传递的”。这两种说法各有各的道理，但是它们都没有从本质上去分析，即致于产生了争论。

　　既然现在我们已经知道了引用是什么东西，那么现在不妨来分析一下对象作是参数是如何传递的。还是先以一个程序为例：

/* 例 3 */
/**
 * @(#) Test.java
 * @author fancy
 */
public class Test {
    public static void test(StringBuffer str) {
        str.append(", World!");
    }
    public static void main(String[] args) {
        StringBuffer string = new StringBuffer("Hello");
        test(string);
        System.out.println(string);
    }
}

　　运行结果：

　　Hello, World!

　　test(string) 调用了 test(StringBuffer) 方法，并将 string 作为参数传递了进去。这里 string 是一个引用，这一点是勿庸置疑的。前面提到，引用是一种数据类型，而且不是对象，所以它不可能按引用传递，所以它是按值传递的，它么它的值究竟是什么呢？是对象的地址。

　　由此可见，对象作为参数的时候是按值传递的，对吗？错！为什么错，让我们看另一个例子：

/* 例 4 */
/**
 * @(#) Test.java
 * @author fancy
 */
public class Test {
    public static void test(String str) {
        str = "World";
    }
    public static void main(String[] args) {
        String string = "Hello";
        test(string);
        System.out.println(string);
    }
}

　　运行结果：

Hello

　　为什么会这样呢？因为参数 str 是一个引用，而且它与 string 是不同的引用，虽然它们都是同一个对象的引用。str = "World" 则改变了 str 的值，使之指向了另一个对象，然而 str 指向的对象改变了，但它并没有对 "Hello" 造成任何影响，而且由于 string 和 str 是不同的引用，str 的改变也没有对 string 造成任何影响，结果就如例中所示。

　　其结果是推翻了参数按值传递的说法。那么，对象作为参数的时候是按引用传递的了？也错！因为上一个例子的确能够说明它是按值传递的。

　　结果，就像光到底是波还是粒子的问题一样，Java 方法的参数是按什么传递的问题，其答案就只能是：即是按值传递也是按引用传递，只是参照物不同，结果也就不同。

　　4. 正确看待传值还是传引用的问题

　　要正确的看待这个问题必须要搞清楚为什么会有这样一个问题。

　　实际上，问题来源于 C，而不是 Java。

　　C 语言中有一种数据类型叫做指针，于是将一个数据作为参数传递给某个函数的时候，就有两种方式：传值，或是传指针，它们的区别，可以用一个简单的例子说明：

/* 例 5 */
/**
 * @(#) test.c
 * @author fancy
 */
void SwapValue(int a, int b) {
    int t = a;
    a = b;
    b = t;
}
void SwapPointer(int * a, int * b) {
    int t = * a;
    * a = * b;
    * b = t;
}
void main() {
    int a = 0, b = 1;
    printf("1 : a = %d, b = %d/n", a, b);
    SwapValue(a, b);
    printf("2 : a = %d, b = %d/n", a, b);
    SwapPointer(&a, &b);
    printf("3 : a = %d, b = %d/n", a, b);
}

　　运行结果：

1 : a = 0, b = 1
2 : a = 0, b = 1
3 : a = 1, b = 0

　　大家可以明显的看到，按指针传递参数可以方便的修改通过参数传递进来的值，而按值传递就不行。

　　当 Java 成长起来的时候，许多的 C 程序员开始转向学习 Java，他们发现，使用类似 SwapValue 的方法仍然不能改变通过参数传递进来的简单数据类型的值，但是如果是一个对象，则可能将其成员随意更改。于是他们觉得这很像是 C 语言中传值/传指针的问题。但是 Java 中没有指针，那么这个问题就演变成了传值/传引用的问题。可惜将这个问题放在 Java 中进行讨论并不恰当。

　　讨论这样一个问题的最终目的只是为了搞清楚何种情况才能在方法函数中方便的更改参数的值并使之长期有效。

　　Java 中，改变参数的值有两种情况，第一种，使用赋值号“=”直接进行赋值使其改变，如例 1 和例 4；第二种，对于某些对象的引用，通过一定途径对其成员数据进行改变，如例 3。对于第一种情况，其改变不会影响到方法该方法以外的数据，或者直接说源数据。而第二种方法，则相反，会影响到源数据——因为引用指示的对象没有变，对其成员数据进行改变则实质上是改变的该对象。

　　5. 如何实现类似 swap 的方法

　　传值还是传引用的问题，到此已经算是解决了，但是我们仍然不能解决这样一个问题：如果我有两个 int 型的变量 a 和 b，我想写一个方法来交换它们的值，应该怎么办？

　　结论很让人失望——没有办法！因此，我们只能具体情况具体讨论，以经常使用交换方法的排序为例：

/** 例 6 */
/**
 * @(#) Test.java
 * @author fancy
 */
public class Test {
    public static void swap(int[] data, int a, int b) {
        int t = data[a];
        data[a] = data[b];
        data[b] = t;
    }
    public static void main(String[] args) {
        int[] data = new int[10];
        for (int i = 0; i < 10; i++) {
            data[i] = (int) (Math.random() * 100);
            System.out.print(" " + data[i]);
        }
        System.out.println();
        for (int i = 0; i < 9; i++) {
            for (int j = i; j < 10; j++) {
                if (data[i] > data[j]) {
                    swap(data, i, j);
                }
            }
        }
        for (int i = 0; i < 10; i++) {
            System.out.print(" " + data[i]);
        }
        System.out.println();
    }
}

　　运行结果(情况之一)：

78 69 94 38 95 31 50 97 84 1
1 31 38 50 69 78 84 94 95 97

　　swap(int[] data, int a, int b) 方法在内部实际上是改变了 data 所指示的对象的成员数据，即上述讨论的第二种改变参数值的方法。希望大家能够举一反三，使用类似的方法来解决相关问题。

这里增加其他的比较类型

public static void main(String[] args) {
float f= 100.0f;
int x=100;
Integer t=new Integer(100);
Integer t1=new Integer(100);
String s=new String("100");
String s1=new String("100");
String s3="100";
System.out.println(s3==s);
if(f==x){
System.out.println("浮点数和整数比较的结果是true");
}else{
System.out.println("浮点数和整数比较的结果是false");


}
if(x==t){
System.out.println("int型和Integer比较的结果是true");
}else{
System.out.println("int型和Integer比较的结果是false");


}
if(x==t1){
System.out.println("int型和Integer比较的结果是true");
}else{
System.out.println("int型和Integer比较的结果是false");


}
if(t==t1){
System.out.println("Integer和Integer比较的结果是true");
}else{
System.out.println("Integer和Integer比较的结果是false");


}
if(s!=s1){
System.out.println("String 和String比较的结果是true");
}else{
System.out.println("String 和String比较的结果是false");


}