How are arrays passed to a function in Java

Question

In C, when we pass an array in a function call, only a pointer to the array is passed to aid memory and time efficiency, and we cannot calculate the size of the array in the called function. We have to pass the size as a parameter to the called function. However, in Java, we can calculate the size of the array in the called function too. So, doesn't it affect memory efficiency as I suppose the whole array is being passed to the called function. Could someone please elaborate on this?

Answer 1

The array in java is an object, that contain the elements and the size of the array.

When you pass an array, only the reference to the array object is passed - the array is NOT duplicated, and any change made to the array in the method will be reflected to the calling environment.

Answer 2

Java and C are completely different languages, and they treat arrays very differently; don't assume the rules for one apply to the other.

In Java, arrays are subclasses of the Object class, and inherit all the attributes and methods of that class. Java arrays set aside a contiguous block of memory for the array elements (at least, I think it's contiguous), but they also set aside memory for array metadata and the base Object methods.

In C, arrays are simply contiguous sequences of elements of type T with no additional metadata.

C was derived from an earlier language known as B; in B, when you declared an N-element array, the compiler would set aside N+1 "cells", one of which would store an offset to the beginning of the array, and that cell would be bound to the identifer; given the declaration

auto arr[2];

you'd see something like this in memory:

        +---+        
   arr: |   |-----+
        +---+     |
         ...      |
        +---+     |
arr[0]: |   |<----+
        +---+
arr[1]: |   |
        +---+

Ritchie initially kept this separate pointer variable, but ran into problems when he added struct types to the language. Eventually, he got rid of it altogether, so when you declare an array, what you get is simply:

        +---+     
arr[0]: |   |
        +---+
arr[1]: |   |
        +---+

There's no separate storage for the pointer to the first element; instead, the pointer is computed when you use the array name in an expression (that is, unless it's the operand of the unary & or sizeof operators, arr will evaluate to the address of the first element of the array, or &arr[0])¹.

In both Java and C, the only thing that gets passed to a function is a reference (Java) or pointer (C) to the array, not a copy of the array itself.

---

^{1. Because there's no separate pointer variable, both arr and &arr will give you the same value (the address of the first element of the array is the same as the address of the array), but the types of the two expressions will be different; the first will be T * and the second will be T (*)[N]. Note that in B, &arr would give you a different result from arr.}

Answer 3

Arrays are passed by value, where the value is a memory address of the array.

Also, read my detailed response here State of an ArrayList in a recursive method

Answer 4

The difference here is that arrays in Java are objects that know their own sizes. We're still passing a reference to the array, it's just that the memory being referred to has the information that's not carried in C.

Answer 5

in Java (almost)everything is a pointer (more specifically a reference), as opposed to C where everything is a value.

a small example to illustrate:

in C:

struct MyStruct {
    int  myInt;
    bool myBool;
};
MyStruct a = { .myInt = 5, .myBool = true};
//following line will cause a CLONE of a to be put in b.
MyStruct b = a;

the above code declares a struct, initializes it and clones that struct to another struct(meaning values are copied not references i.e. changing one will not change the other).

in java stating b = a is copying the reference only (i.e. changing a.myInt will also change b.myInt), to achieve something similar in C we would write have b be a pointer to MyStruct and state b = &a

Therefore, when passing arguments to methods in java we are actually passing the reference to that object (unless we are using primitive types e.g. int, bool, char, etc). Java arrays come conveniently prepacked with their size (in C we could just make a struct of an array and an int as it's length).