将数组传递给函数javav/scc

我对Java非常陌生，有一个话题让我大吃一惊。 将数组传递给java函数。 代码如下：

private void PassArray(){
String[] arrayw = new String[4]; //populate array
PrintA(arrayw);
}

private void PrintA(String[] a){
//do whatever with array here
}

他们说java中的数组是通过引用传递的。但它看起来非常类似于C中的“按值调用”：

#包括
/*函数声明*/
双getAverage（int arr[]，int size）；
int main（）
{
/*包含5个元素的整数数组*/
整数余额[5]={1000,2,3,17,50}；
双平均值；
/*将指向数组的指针作为参数传递*/
平均值=平均值（余额，5）；
/*输出返回的值*/
printf（“平均值为：%f”，平均值）；
返回0；
}
double getAverage（整数arr[]，整数大小）
{
int i；
双平均值；
双和；
对于（i=0；i

请解释它们在值、引用和内存分配方面的差异。 任何进一步的链接都将不胜感激。

C中的数组是“按引用传递”，而不是“按值传递”。请看以下节目：-

    void print_array (int array[], int len)
    {
        printf("Printing the array: ");
        int i;

        for (i = 0; i < len; ++i) {
            printf("%d ", array[i]);
        }

        printf("\n");
    }

    void populate_array (int array[], int len)
    {
        printf("Populating the array....\n ");
        int i;

        for (i = 0; i < len; ++i) {
            array[i] = i;
        }
    }


    int main() 
    {
        int array[5];
        memset(array, 0, sizeof(int) * 5);  

        print_array(array, 5);  
        populate_array(array, 5);
        print_array(array, 5);  

        return(0);
    }

    Output:-
    GAGUPTA2-M-40UT:Desktop gagupta2$ ./a.out 
    Printing the array: 0 0 0 0 0 
    Populating the array....
    Printing the array: 0 1 2 3 4 

void打印数组（int数组[]，int len）
{
printf（“打印数组：”）；
int i；
对于（i=0；i

因此，一旦将数组作为参数传递给函数，它就不再是C中的“按值传递”机制，而是“按引用传递”。因此，在调用populate_array（）之前，数组的内容都是零，在调用populate_array（）之后，它们有一些值

在Java中，您将看到类似的情况。将类似的Java代码放在下面：-

    public class Test 
    {
        public static void print_array (String[] array)
        {
            System.out.println("Printing the array");

            for (int i = 0; i < array.length; ++i) {
                System.out.print(array[i] + " ");
            }

            System.out.println();
        }

        public static void populate_array (String[] array)
        {
            System.out.println("Populating the array");

            for (int i = 0; i < array.length; ++i) {
                array[i] = new String("init_array");    
            }
        }

        public static void main (String[] args) 
        {
            String[] array = new String[5];

            print_array(array);
            populate_array(array);
            print_array(array);
        }
    }

Output:-
GAGUPTA2-M-40UT:Desktop gagupta2$ java Test
Printing the array
null null null null null 
Populating the array
Printing the array

公共类测试
{
公共静态无效打印数组（字符串[]数组）
{
System.out.println（“打印数组”）；
对于（int i=0；i

---

在java中，int、float、double、boolean等基本数据类型总是按值传递，但当传递数组、字符串和对象等非基本类型时，对象的地址就会传递。有关更多详细信息，请参阅。

数组是在堆上分配的，它们将通过引用传递。与C相比，它们看起来像自动变量，处理也像C中自动变量的处理。只需尝试更改方法（函数）中的数组，看看发生了什么。另一方面，整数在堆栈上分配，并按值传递。下面是一些典型的操作，将数组作为参数传递给函数并从函数返回

public static void main(String[] args) {
  int[] arr = {0, 0, 0, 0};
  print(arr);
  load(arr);
  print(arr);
  print(generate(5));
  long s = 0;
  System.out.println("long is " + s);
}

void willItChange(long param){
  param = 3;
}
static int[] generate(int size){
  int[] arr = new int[size];
  for(int i = 0; i<size; i++)
    arr[i] = i + 1;
  return arr;
}

static void load(int[] arr){
  for(int i = 0; i<arr.length; i++)
    arr[i] = i + 1;
}

static void print(int[] arr){
  for(int i = 0; i<arr.length; i++)
    System.out.print(arr[i] + " ");
  System.out.println();
}

数组通过引用传递，long通过值传递。

在C:

在某种意义上，您不能在C中“传递数组”，因为函数不可能具有数组类型的参数。该标准规定，包含声明为“T数组”类型的参数的函数声明将被“调整”为“指向T的指针”类型的参数。在上面的示例中，参数

arr

的类型为

int*

（指针指向

int

）

那么调用表达式

getAverage（balance，5）

中的

balance

是一个数组（

int[5]

）会发生什么呢？编译器发现函数需要该参数使用指针类型（

int*

），然后在传递该指针（指向需要指针的参数）之前，应用从数组值到指针rvalue（指向数组第一个元素的指针）的隐式转换。正如您所看到的，没有传递“数组”

而且，C中的所有内容都是按值传递的。C中没有pass by引用。您正在传递的指向-

int

的指针是按值传递的，即它的值（它指向的内容）被复制到函数中的本地副本中

public static void main(String[] args) {
  int[] arr = {0, 0, 0, 0};
  print(arr);
  load(arr);
  print(arr);
  print(generate(5));
  long s = 0;
  System.out.println("long is " + s);
}

void willItChange(long param){
  param = 3;
}
static int[] generate(int size){
  int[] arr = new int[size];
  for(int i = 0; i<size; i++)
    arr[i] = i + 1;
  return arr;
}

static void load(int[] arr){
  for(int i = 0; i<arr.length; i++)
    arr[i] = i + 1;
}

static void print(int[] arr){
  for(int i = 0; i<arr.length; i++)
    System.out.print(arr[i] + " ");
  System.out.println();
}

在Java中：

在Java中，数组是对象，Java中的对象不是值，不能“传递”（Java中没有“对象类型”，只有基元类型和引用类型）。与所有对象一样，数组只能通过“引用”（指向对象的指针）进行操作

---

Java中的一切都是按值传递的。Java中没有传递引用。在您的示例中，有一个类型为

String[]

的参数

a

，它是一种引用类型，可以保存指向-

String

对象数组的指针。传递的数组指针是按值传递的，即它的值（它指向的）被复制到函数中的本地副本。

“他们在java数组中按引用传递”＝它们是错误的。考虑并尝试“代码> Prtua< /Co> >实际上修改数组。因为它们是错误的-在Java中没有通过引用传递。@assylas通常这只是一个simplifi

public static void main(String[] args) {
  int[] arr = {0, 0, 0, 0};
  print(arr);
  load(arr);
  print(arr);
  print(generate(5));
  long s = 0;
  System.out.println("long is " + s);
}

void willItChange(long param){
  param = 3;
}
static int[] generate(int size){
  int[] arr = new int[size];
  for(int i = 0; i<size; i++)
    arr[i] = i + 1;
  return arr;
}

static void load(int[] arr){
  for(int i = 0; i<arr.length; i++)
    arr[i] = i + 1;
}

static void print(int[] arr){
  for(int i = 0; i<arr.length; i++)
    System.out.print(arr[i] + " ");
  System.out.println();
}