关于java中向函数传递数组参数和返回数组的问题

时间：2022-08-30 19:47:24
在java中传递数组参数给函数是传值引用还是传址引用，另外怎样用函数返回数组和动态数组

13 个解决方案

#1

传递的是引用地址，因为数组也是一个对象，所以返回数组与返回对象是一样的，也是返回引用地址。
例如：
int[] array = new int[]{0, 1};
        
        private int[] returnArray(int[] array) {
    return array;
}

#2

只要是对象 就是引用调用  基础类型都是拷贝副本 调用

#3

引用地址！
如果在调用的函数据更新参数数组的值，可以改变你传入的数据的值。

#4

引用 1 楼 chiphuo 的回复:
传递的是引用地址，因为数组也是一个对象，所以返回数组与返回对象是一样的，也是返回引用地址。 
例如： 
int[] array = new int[]{0, 1}; 
        
        private int[] returnArray(int[] array) { 
    return array; 
}

up

#5

今天写了一小段东西检验，主要是向一个函数传递数组，运行以后实参和形参都发生了同步变化，如下

package arrayparametertest;

/**
 *
 * @author Administrator
 */
public class Main 
{

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) 
    {
        // TODO code application logic here
        ParameterTest(i);
    }
    
    public  static int i[]={1,2,3,4,5};
    
    static public void ParameterTest(int j[])
    {
        int k=0;
        while (k<j.length)
        {
            j[k]=0;
            System.out.println("形参数组j["+k+"]="+j[k]);
            System.out.println("实参数组i["+k+"]="+i[k]);
            k=k+1;
        }        
    }
}
运行结果：
形参数组j[0]=0
实参数组i[0]=0
形参数组j[1]=0
实参数组i[1]=0
形参数组j[2]=0
实参数组i[2]=0
形参数组j[3]=0
实参数组i[3]=0
形参数组j[4]=0
实参数组i[4]=0

i数组已经改变，不是{1,2,3,4,5};

#6

不知道你的动态数组是什么意思 


public static String[] getArray(String...strings ){

		return strings;

	}


	public static void main(String[] args) {

		String[] s1 = getArray("aa","bb");

		String[] s2 = getArray("aa","bb","cc");

	}

#7

学习，关注

#8

我指的是函数返回的数组长度不是事先确定长度，而是执行过程中得到一个确定长度

#9

数组：
【1】如果将单个基本类型数组的元素传递给方法，并在方法中对其进行修改，则在被调用方法结束执行时，该元素中存储的并不是修改后的值，因为这种元素是按值传递，如果传递的是数组的引用，则对数组元素的后续修改可以在原始数组中反映出来（因为数组本身就是个对象，int[] a = new int[2];，这里面的int是数组元素的类型，而数组元素的修改是操作对象）。

【2】对于单个非基本类型数组的元素在方法中修改，则在被调用方法结束执行时，该元素中存储的是修改后的值，因为这种元素是按引用传递的，对象的改动将在源数组的数组元素中反映出来。

  可以访问我的博客，http://blog.****.net/niuniu20008/archive/2008/09/19/2953785.aspx   里面有好几个好例子
  O(∩_∩)O 欢迎捧场。

#10

我的那个数据应该是传址的，如果有不同情况，不知有什么例子吗

#11

  许多编程语言都有2种方法将参数传递给方法------按值传递和按引用传递。

 

与其他语言不同，Java不允许程序员选择按值传递还是按引用传递各个参数，基本类型(byte--short--int--long--float--double--boolean--cha)的变量总是按值传递。就对象而言，不是将对象本身传递给方法，而是将对象的的引用或者说对象的首地址传递给方法，引用本身是按值传递的-----------也就是说，讲引用的副本传递给方法（副本就是说明对象此时有两个引用了），通过对象的引用，方法可以直接操作该对象（当操作该对象时才能改变该对象，而操作引用时源对象是没有改变的）。

 

现在说说数组：如果将单个基本类型数组的元素传递给方法，并在方法中对其进行修改，则在被调用方法结束执行时，该元素中存储的并不是修改后的值，因为这种元素是按值传递，如果传递的是数组的引用，则对数组元素的后续修改可以在原始数组中反映出来（因为数组本身就是个对象，int[] a = new int[2];，这里面的int是数组元素的类型，而数组元素的修改是操作对象）。

 

对于单个非基本类型数组的元素在方法中修改，则在被调用方法结束执行时，该元素中存储的是修改后的值，因为这种元素是按引用传递的，对象的改动将在源数组的数组元素中反映出来。

 

下面看个小程序：

public class Test{ 
     
    String str = new String("good"); 
    char[] ch = {'a','b','c'}; 
    int i = 10; 
    public void change(String str,char[] ch,int i){ 
     
        str = "test ok"; 
        ch[0] = 'g'; 
        i++;     
    } 
     
    public static void main(String[] args){ 
     
        Test tt = new Test(); 
        tt.change(tt.str,tt.ch,tt.i); 
        System.out.println(tt.i); 
        System.out.print(tt.str+" and "); 
        System.out.println(tt.ch);      
    } 
}
str是String类型的引用，i是基本类型变量，ch是数组名，也是数组对象的引用

在chang()方法里，str="test ok"，是一个新的对象把首地址放在引用变量str上；

而ch[0]='g';因为传的是数组的引用，而此时ch[0]='g';是对数组元素的操作，能修改源数组的内容；

i是整型值，只是把值copy了一份给方法，在方法的变化是不改变的源i的。

所以结果是：

10

good and gbc

 

现在咱们把代码变化一下：

public class Test{ 
     
    String str = new String("good"); 
    char[] ch = {'a','b','c'}; 
    int i = 10; 
    public void change(String str,char ch,int i){ 
     
        str = "test ok"; 
        ch = 'g'; 
        this.i = i+1;     
    } 
     
    public static void main(String[] args){ 
     
        Test tt = new Test(); 
        tt.change(tt.str,tt.ch[0],tt.i); 
        System.out.println(tt.i); 
        System.out.print(tt.str+" and "); 
        System.out.println(tt.ch);      
    } 
}
 

仔细观察下实参以及入参有何变化？

change()方法里的入参char[] ch变成--------------char ch;

这次传递的是个char值的单个数组元素，按照上面的解析，此时ch='9';是不影响源数组元素的。

this.i = i+1;这里面等号左边的i是属性i，等号右边的i是局部变量（入参里的i）；

此时i+1后赋值给属性的i，自然会改变属性i的值，同时17行，tt.i又是调用属性的i，这次的结果是：

 

11

good and abc

 

现在是不是有点明白了？

那好再看下面一个小程序

public class Test{ 
     
    public void change(StringBuffer x,StringBuffer y){ 
         
        x.append(y); 
        y=x;     
    } 
    public static void main(String[] args){ 
     
        StringBuffer buffA = new StringBuffer("a"); 
        StringBuffer buffB = new StringBuffer("b"); 
        new Test().change(buffA,buffB); 
        System.out.println(buffA+","+buffB);    
    } 
}
这次传递的是两个对象的引用的值，

在方法change()里 的x.append(y),     其中引用x调用api方法append()修改了new StringBuffer("a");的内容。

 y=x;是一个修改内容的对象把首地址赋值给引用变量y了，此时操作的是引用，而先前y是new StringBuffer("b");的引用变量，所以输出结果是：

ab,b

 

下面是个稍难的小程序，先自己用笔画画过程，写出自己的结果，而后再上机操作下，如果自己的结果和在电脑上的结果一样，那么再碰到这类题就不难了，如果不一样，回头仔细体会下我前面的讲解，找找原因。

public class Test{ 
     
    private String nn = new String("1"); 
    private String[] mm = {"2","5"}; 
     
    void test(String nn,String[] mm){ 
         
        nn = new String("3"); 
        this.nn = "9"; 
         
        mm[0] = "4"; 
        System.out.println("in test(),mm[0]: "+mm[0]); 
        mm = new String[]{"8","7"}; 
        System.out.println("in test(),nn: "+nn); 
        System.out.println("this.nn: "+this.nn); 
        System.out.println("mm[0]: "+mm[0]); 
    } 
     
    public static void main(String[] args){ 
         
        Test s = new Test(); 
        s.test(s.nn,s.mm); 
        System.out.println(s.nn+"  "+s.mm[0]); 
    } 
}
 

 

#12

lz这部自己很清楚吗？

#13

 还是不太懂！ 学习中、、

#1

传递的是引用地址，因为数组也是一个对象，所以返回数组与返回对象是一样的，也是返回引用地址。
例如：
int[] array = new int[]{0, 1};
        
        private int[] returnArray(int[] array) {
    return array;
}

#2

只要是对象 就是引用调用  基础类型都是拷贝副本 调用

#3

引用地址！
如果在调用的函数据更新参数数组的值，可以改变你传入的数据的值。

#4

引用 1 楼 chiphuo 的回复:
传递的是引用地址，因为数组也是一个对象，所以返回数组与返回对象是一样的，也是返回引用地址。 
例如： 
int[] array = new int[]{0, 1}; 
        
        private int[] returnArray(int[] array) { 
    return array; 
}

up

#5

今天写了一小段东西检验，主要是向一个函数传递数组，运行以后实参和形参都发生了同步变化，如下

package arrayparametertest;

/**
 *
 * @author Administrator
 */
public class Main 
{

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) 
    {
        // TODO code application logic here
        ParameterTest(i);
    }
    
    public  static int i[]={1,2,3,4,5};
    
    static public void ParameterTest(int j[])
    {
        int k=0;
        while (k<j.length)
        {
            j[k]=0;
            System.out.println("形参数组j["+k+"]="+j[k]);
            System.out.println("实参数组i["+k+"]="+i[k]);
            k=k+1;
        }        
    }
}
运行结果：
形参数组j[0]=0
实参数组i[0]=0
形参数组j[1]=0
实参数组i[1]=0
形参数组j[2]=0
实参数组i[2]=0
形参数组j[3]=0
实参数组i[3]=0
形参数组j[4]=0
实参数组i[4]=0

i数组已经改变，不是{1,2,3,4,5};

#6

不知道你的动态数组是什么意思 


public static String[] getArray(String...strings ){

		return strings;

	}


	public static void main(String[] args) {

		String[] s1 = getArray("aa","bb");

		String[] s2 = getArray("aa","bb","cc");

	}

#7

学习，关注

#8

我指的是函数返回的数组长度不是事先确定长度，而是执行过程中得到一个确定长度

#9

数组：
【1】如果将单个基本类型数组的元素传递给方法，并在方法中对其进行修改，则在被调用方法结束执行时，该元素中存储的并不是修改后的值，因为这种元素是按值传递，如果传递的是数组的引用，则对数组元素的后续修改可以在原始数组中反映出来（因为数组本身就是个对象，int[] a = new int[2];，这里面的int是数组元素的类型，而数组元素的修改是操作对象）。

【2】对于单个非基本类型数组的元素在方法中修改，则在被调用方法结束执行时，该元素中存储的是修改后的值，因为这种元素是按引用传递的，对象的改动将在源数组的数组元素中反映出来。

  可以访问我的博客，http://blog.****.net/niuniu20008/archive/2008/09/19/2953785.aspx   里面有好几个好例子
  O(∩_∩)O 欢迎捧场。

#10

我的那个数据应该是传址的，如果有不同情况，不知有什么例子吗

#11

  许多编程语言都有2种方法将参数传递给方法------按值传递和按引用传递。

 

与其他语言不同，Java不允许程序员选择按值传递还是按引用传递各个参数，基本类型(byte--short--int--long--float--double--boolean--cha)的变量总是按值传递。就对象而言，不是将对象本身传递给方法，而是将对象的的引用或者说对象的首地址传递给方法，引用本身是按值传递的-----------也就是说，讲引用的副本传递给方法（副本就是说明对象此时有两个引用了），通过对象的引用，方法可以直接操作该对象（当操作该对象时才能改变该对象，而操作引用时源对象是没有改变的）。

 

现在说说数组：如果将单个基本类型数组的元素传递给方法，并在方法中对其进行修改，则在被调用方法结束执行时，该元素中存储的并不是修改后的值，因为这种元素是按值传递，如果传递的是数组的引用，则对数组元素的后续修改可以在原始数组中反映出来（因为数组本身就是个对象，int[] a = new int[2];，这里面的int是数组元素的类型，而数组元素的修改是操作对象）。

 

对于单个非基本类型数组的元素在方法中修改，则在被调用方法结束执行时，该元素中存储的是修改后的值，因为这种元素是按引用传递的，对象的改动将在源数组的数组元素中反映出来。

 

下面看个小程序：

public class Test{ 
     
    String str = new String("good"); 
    char[] ch = {'a','b','c'}; 
    int i = 10; 
    public void change(String str,char[] ch,int i){ 
     
        str = "test ok"; 
        ch[0] = 'g'; 
        i++;     
    } 
     
    public static void main(String[] args){ 
     
        Test tt = new Test(); 
        tt.change(tt.str,tt.ch,tt.i); 
        System.out.println(tt.i); 
        System.out.print(tt.str+" and "); 
        System.out.println(tt.ch);      
    } 
}
str是String类型的引用，i是基本类型变量，ch是数组名，也是数组对象的引用

在chang()方法里，str="test ok"，是一个新的对象把首地址放在引用变量str上；

而ch[0]='g';因为传的是数组的引用，而此时ch[0]='g';是对数组元素的操作，能修改源数组的内容；

i是整型值，只是把值copy了一份给方法，在方法的变化是不改变的源i的。

所以结果是：

10

good and gbc

 

现在咱们把代码变化一下：

public class Test{ 
     
    String str = new String("good"); 
    char[] ch = {'a','b','c'}; 
    int i = 10; 
    public void change(String str,char ch,int i){ 
     
        str = "test ok"; 
        ch = 'g'; 
        this.i = i+1;     
    } 
     
    public static void main(String[] args){ 
     
        Test tt = new Test(); 
        tt.change(tt.str,tt.ch[0],tt.i); 
        System.out.println(tt.i); 
        System.out.print(tt.str+" and "); 
        System.out.println(tt.ch);      
    } 
}
 

仔细观察下实参以及入参有何变化？

change()方法里的入参char[] ch变成--------------char ch;

这次传递的是个char值的单个数组元素，按照上面的解析，此时ch='9';是不影响源数组元素的。

this.i = i+1;这里面等号左边的i是属性i，等号右边的i是局部变量（入参里的i）；

此时i+1后赋值给属性的i，自然会改变属性i的值，同时17行，tt.i又是调用属性的i，这次的结果是：

 

11

good and abc

 

现在是不是有点明白了？

那好再看下面一个小程序

public class Test{ 
     
    public void change(StringBuffer x,StringBuffer y){ 
         
        x.append(y); 
        y=x;     
    } 
    public static void main(String[] args){ 
     
        StringBuffer buffA = new StringBuffer("a"); 
        StringBuffer buffB = new StringBuffer("b"); 
        new Test().change(buffA,buffB); 
        System.out.println(buffA+","+buffB);    
    } 
}
这次传递的是两个对象的引用的值，

在方法change()里 的x.append(y),     其中引用x调用api方法append()修改了new StringBuffer("a");的内容。

 y=x;是一个修改内容的对象把首地址赋值给引用变量y了，此时操作的是引用，而先前y是new StringBuffer("b");的引用变量，所以输出结果是：

ab,b

 

下面是个稍难的小程序，先自己用笔画画过程，写出自己的结果，而后再上机操作下，如果自己的结果和在电脑上的结果一样，那么再碰到这类题就不难了，如果不一样，回头仔细体会下我前面的讲解，找找原因。

public class Test{ 
     
    private String nn = new String("1"); 
    private String[] mm = {"2","5"}; 
     
    void test(String nn,String[] mm){ 
         
        nn = new String("3"); 
        this.nn = "9"; 
         
        mm[0] = "4"; 
        System.out.println("in test(),mm[0]: "+mm[0]); 
        mm = new String[]{"8","7"}; 
        System.out.println("in test(),nn: "+nn); 
        System.out.println("this.nn: "+this.nn); 
        System.out.println("mm[0]: "+mm[0]); 
    } 
     
    public static void main(String[] args){ 
         
        Test s = new Test(); 
        s.test(s.nn,s.mm); 
        System.out.println(s.nn+"  "+s.mm[0]); 
    } 
}
 

 

#12

lz这部自己很清楚吗？

#13

 还是不太懂！ 学习中、、
标签：

相关文章