java函数参数中：用参数值带回结果（类似传址）的方式及各种观点辨析

转自：http://blog.csdn.net/null____/article/details/7893360

用惯了指针 这个问题还挺头疼……

java基本类型都统一传值，所以不行

Integer类new完数值就被写死（Integer中用final定义的成员变量），所以也不行

只剩：用成员变量、用数组、或者传自己定义的类，这些办法了。

成员变量不说了，

可以写了个包装类搞定：

public void change(Num i)
{
    i.number =  XXXX;
}

还试了一种：把数包装在int[] 中传递，操作完再带回，也行

int[] arry = new int[1];

… …

public void change(int[] ay)
{
    ay[0] = XXXX;
}

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

另外找到一篇文章，有空看看：

第一种说法

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(
17dc6
"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 对象。

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

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;

        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 所指示的对象的成员数据，即上述讨论的第二种改变参数值的方法。希望大家能够举一反三，使用类似的方法来解决相关问题。

[b]第二种说法

关于JAVA中参数传递问题有两种，一种是按值传递（如果是基本类型），另一种是按引用传递（如果是對象）. 

首先以两个例子开始：

1）

public class Test2 {

 public static void main (String [] args)  { 

 StringBuffer a = new StringBuffer ("A"); 

 StringBuffer b = new StringBuffer ("B"); 

 operate (a,b); 

 System.out.println(a+","+b); 

 }

static void operate(StringBuffer x, StringBuffer y){ 

     x.append(y); 

     y = x; 

   }

}

输出：AB,B

2）

public class Test2 {

 public static void add3 (Integer i){ 

      int val=i.intValue();

      val += 3; 

      i = new Integer (val); 

  }

 public static void main (String args [ ] )  { 

 Integer  i = new Integer (0); 

  add3 (i); 

  System.out.println (i.intValue ( )); 

 } 

} 

输出：0

首先我们应该明白JAVA中的参数传递全是以值传递的。

是基本类型，就拷贝一个基本类型传进方法；

是引用，就拷贝一个引用变量传进去方法，

理解了这两点就能理解方法操作对象的相关问题了。最好能画出引用指向对象的图出来，就能完全理解了。

第1 题，调用operate方法时，传入了两个引用a,b的拷贝x,y，这两个x,y都指向原a,b引用所指向的对象。x.append(y)对它指向的对象 (即a指向的对象)进行了操作。而x=y，只是两个拷贝变量在赋值，并没有影响到原b所指向的对象。所以b所指向的对象仍然为B。

第2题，i=new Integer(val)只是一个引用的拷贝指向了另外一个对象，而原来的i仍然是指向对象new Integer(0)的。

把握住了JAVA都是传值并且传的都是拷贝的话，类似的题大家都能迎刃而解了。 

Java中的参数传递只有一种方式: by value. 理论说教太麻烦了，直接看些例子吧:

1). 基本类型

    public class A{

   public static void main(String[] args){

       int x = 1;

       System.out.println(x);    //1

       test(x);

       System.out.println(x);    //还是1＝＝>By value

   }

   

   static void test(int a){

      a = 2;

   }

}

2). 引用类型

    public class B{

   public static void main(String[] args){

       Integer x = new Integer(1);

       System.out.println(x);

       test(x);

       System.out.println(x);

       

   }

   

   static void test(Integer a){

      a = new Integer(2);

   }

}

  理解这里的关键是区分对象和引用。 这里声明的x是一个引用，而不是一个对象（只是Java把它设计为看上去好像是对象一样）。这个引用它指向了一个对象，这个对象就是后面用new关键字生成的对象。因此，可以说x指向了一个Integer对象。

  在调用test方法的时候，程序将x作为参数传递给test方法了。这里仍然是值传递，在test调用过程中，会产生一份新的引用(不妨叫做y)。此时，x和y指向了同一个对象。

   x和y指向的是同一个对象， 由于Java的设计，我们可以通过操作引用来达到操作对象的目的。因此，如果我们此时使用y来修改对象的属性 (例如，y.someField++); 你可以看到x指向的对象同时也被修改到了。

   另一方面，如果我们让y指向另外一个对象， y=new Integer(2); 此时x和y就指向了不同的

对象。y修改了它指向的对象的属性，很显然不会影响到x指向的对象。

 

有人说了数组。数组也是一个引用类型，它的参数传递方式按照引用类型的参数传递一样可以解释得通：

import java.util.Arrays;

public class A{

   public static void main(String[] args){

      int[] aa = {3, 2, 1};

      System.out.println(Arrays.toString(aa));  //[3, 2, 1]

      test(aa);

      System.out.println(Arrays.toString(aa));  //[3, 2, 1]

      test2(aa);

      System.out.println(Arrays.toString(aa));  //[4, 2, 1]

   }

   

   static void test(int[] a){

      a = new int[]{1, 2, 3};   //指向了新对象

   }

   

   static void test2(int[] a){

     if(a != null && a.length > 0)

       a[0]++;              //修改原来的那个对象

   }

}

 

 

对象是传引用，简单类型是传值，不要被网上的一些概念所迷惑！！！你可以自己做个试验。

至于String等类型传的还是引用。如果你用concat方法，String对象的原值就会被改变。

但你如果按如下方法：

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 = "World" 就等同于 String str＝new String("World")。所以结果没有改变！！！

 下列程序在1处是否会有异常，如果没有，输出是什么？是否会运行到2处，如果会，输出是什么？为什么会有这样的结果？

 

　　import java.util.arraylist;

　　 import java.util.list;

　　 

　　 public class testclass {

　　 public static void main(string args[]) {

　　　　 list list = new arraylist();

　　　　 test2(list);

　　　　 system.out.println(list.size()); // 1处

　　　　 test3(list);

　　　　 system.out.println(list.size()); // 2处

　　 }

　　 

　　 public static void test2(list list) {

　　　　 list = null;

　　 }

　　 

　　 public static void test3(list list) {

　　 　　 list.add(“aaaa“);

　　 }

　　 }

plumechen:

不会出错的。结果是0，1。

因 为test2(list)传得是list的引用，我理解成指针置的副本，list=null；只是把那个传入的值设置为null，不改变原来list的指 针和内容。test3(list)传入的一样，但是执行了list.add()由于传入指针值的副本也指向原来的那个list的地址，所以原来的那个 list的内容就改变了，size变成了1了

总结：对于第一种说法，注意理解“引用是一种数据类型”，对于第二种说法，要理解“参数是引用的一个拷贝”

【yasi】这里大致讲了四种情形，总结如下：

1）对于基本数据类型（不包括基本数据类型的数组），通过函数参数带回结果，那是做梦！Java语言不支持，甚至连C语言也不支持。

[java]
view plain
copy

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  

2）对函数传入数组，在函数中对传入的数组的元素做赋值，其结果可以带回。这里，可以将传入的数组，理解成那个数组的“真实肉身”的首元素的地址或引用，在其地址或引用上指定下标（即地址偏移），然后再赋值，实际上就是对偏移地址上的内存做赋值。退出函数后，对偏移地址上的内存做的赋值操作依然有效。

[java]
view plain
copy

public class Test {   
  public static void swap(int[] data, int a, int b) {  
       int t = data[a];  
        data[a] = data;  
        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  

3）对函数传入对象，在函数中，通过调用对象的方法改变对象的成员变量的值，该值可以带回。这里，可以将传入的对象，理解成该对象的“真实肉身”（即new出来的东西）的地址或引用，在其地址或引用上通过调用它自己的成员函数改变其成员变量的值，实际上就是对“真实肉身”在内存中的某一段（对应调用的成员函数修改的成员变量）做赋值。退出函数后，对该段内存的修改依然有效。

[b][java]
view plain
copy

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!  

4）对函数传入对象，在函数中，对传入的对象做“=”操作，让其“等于”另一个对象（的引用），或者对传入的对象做“= new”操作，让其指向新new出来的一个对象。这种情况下，对传入对象的修改不能带回。我们可以将传入的对象理解成该对象的“真实肉身”的地址或引用的一个副本，让该引用的副本“等于”另一个对象的引用，或者让该引用的副本“等于”新new出来的一个对象，都只是改变这个引用的副本自身，即，使得该引用的副本指向了一个新的地址而已，而丝毫不涉及到那个先前指向的“真实肉身”，于是，这里的修改不能带回。

[java]
view plain
copy

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