Java Programming - Operators and Assignments - Discussion

Please try this code, then you will come know that all array a1, a2, a3 having same memory reference which is display by,

sys.out.println("a1="+a1);

That's why when we change value of second element (1 index) to array a3 it will reflected to all other array objects a1 and a2.

Because memory address or reference to a1, a2, a3 is same..for me it is,

a3 = [J@1f33675.
a1 = [J@1f33675.
a2 = [J@1f33675.

And as we know all writing operation perform to some memory location.so we write some memory location for a3.

That's why value 7 is updated to all arrays a1, a2, a3 because we write at some memory location and a1, a2, a3 pointing the same memory location.

So key point is "Reference is same".

Now o/p is.

a1 = 3,7,5
a2 = 3,7,5
a3 = 3,7,5

Hence o/p is 15, 15.

class PassA
{
public static void main(String [] args)
{

PassA p = new PassA();
p.start();
}

void start()
{
long [] a1 = {3,4,5};

long [] a3=a1;
System.out.println("a3=" +a3);
System.out.println("a1=" +a1);

long [] a2 = fix(a1);
System.out.println("a2=" +a2);
System.out.print(a1[0] + a1[1] + a1[2] + " ");
System.out.println(a2[0] + a2[1] + a2[2]);
}

long [] fix(long [] a3)
{

a3[1] = 7;
return a3;
}
}

The situation, when working with arrays, is somewhat different. If we were to make copies of arrays to be sent to methods, we could potentially be copying very large amounts of data.
Not very efficient!
Arrays are passed-by-reference. Passing-by-reference means that when an array is passed as an argument, its memory address location is actually passed, referred to as its "reference". In this way, the contents of an array CAN be changed inside of a method, since we are dealing directly with the actual array and not with a copy of the array.

int [ ] num = {1, 2, 3};
testingArray(num); //Method call
System.out.println("num[0] = " + num[0] + "\n num[1] = " + num[1] + "\n num[2] =" + num[2]);
. . .

//Method for testing
public static void testingArray(int[ ] value)
{
value[0] = 4;
value[1] = 5;
value[2] = 6;
}
Output:
num[0] = 4
num[1] = 5
num[2] = 6
(The values in the array have been changed.
Notice that nothing was "returned".)
You will need to be careful when sending an array to a method. Remember that any changes made to the array in the method will change the data in the original array. Be sure that your intention is to change the original data (thus losing the original data).

According to me,

class PassA
{
public static void main(String [] args)
{
PassA p = new PassA();
p.start();
}

void start()
{
long [] a1 = {3,4,5};
long [] a2 = fix(a1);// In this line we are sending the reference variable of a1.
System.out.print(a1[0] + a1[1] + a1[2] + " ");
System.out.println(a2[0] + a2[1] + a2[2]);
}

long [] fix(long [] a3) // Now a3 also starts pointing to the same array as a1 is pointing.
{
a3[1] = 7;// Any modification done now will reflect on both a1..
return a3;//After returning this value array a2 starts will start to point a1 array as well.
}
}

@ALL.

Refer this code.

public class PassA {

public static void main(String[] args) {
PassA p = new PassA();
p.start();
}
void start()
{
long a1[]={3,4,5};
for(long i:a1)
System.out.print(i+"" );
System.out.println(" ");
long a2[]=fix(a1);
System.out.print(a1[0]+a1[1]+a1[2]+" ");
System.out.println(a2[0]+a2[1]+a2[2]);
}
long [] fix(long [] a1)
{
a1[1] = 7;
for(long i:a1)
System.out.print(i);
System.out.println(" ");

return a1;
}
}

Output
345
375
15 15

If we write this:

long [] a2 = a1;

which means the address of a1 is being assigned to a2,therefore a2 also contains same elements as a1.

long [] a2 = fix(a1);

the fix(a1); is only replacing the element at a1[1] which is 4 by 7, and assigning the address of a1 to a2n now both a1 and a2 contains same data elements.

up to this point a1 should contains {3,7,5} not {3,4,5}

so the output should be 375 375

why 15 15..........?

The reason why is because arrays are not primitive types.

Primitive types: pass copy of variable to parameter.

Objects(user defined types): pass by reference variable/objects as parameter.

There are exceptions to arrays(int[],long[], etc).

Formally speaking, an array is a reference type, though you cannot find such a class in the Java APIs.

//**Here when we call fix (a1) method then control will goes to fix method 7 execute it what the result is a1 is passed as a parameter to the fix (long[] a3).

So a3 is replaced by a1 & a3[1] = a1[1] = 7 value will be returned to its calling method. So, finally we will get a1[1] = 7.

I hope my explanation is easy to understand**//.

3 elements should be printed know why only 2 elements are being printed
When I give like this

System.out.print("a1[0]"+a1[0] +"a1[1]"+ a1[1] +"a1[2]"+ a1[2] + " ");

Then it will give the result as
a1[0] = 3
a1[1] = 7
a1[2] = 5 this is why.

In C, we have pointers to get the address of a variable. But in java pointers concept is not there but java has indirectly using pointers such as objects. Objects are nothing but references. So the array is a class of object in java. That's why a1 affected by the method fix().

I didn't understand....the arguement in fix() in the calling function is a1 whose values are copied in a3. So why the hell a1 gonna be updated if a3 is changed! Besides the return keyword returns the updated value to a2 not to a1. .....!!!!!!