Array comparision

[navaneeth-algorithm]

  //Array decalration & initialisation
  int[] arrayNm = [2, 3, 4, 5, 4];

  //equal arrray arrayNm
  int[] arrayPm = [2, 3, 4, 5, 4];

  //shuffle array arrayNm
  int[] arrayCm = [2,4,3,5,4];

  //replace one arrayNm elemnt with new one
  int [] arrayKm = [2,10,4,5,4];

  //assign one array to another
  int[] arrayGm = arrayNm;

  //Accessing array index
  int indexNm = arrayNm[2];


Array content are: 



Are array equal? arrayNm == arrayPm :true

Are array equal?arrayNm==arrayCm :false

Are array equal?arrayNm==arrayKm :false

Are array equal?arrayNm==arrayGm :true

arrayGm[0] = -1

Are array equal after modifying Gm?arrayNm==arrayGm :true ??

how come arrayNm==arrayGm is true??

I changed the index at 0 in arrayGm to -1

[MaryamZi]

With int[] arrayGm = arrayNm; arrayGm refers to the same array value referred to by arrayNm. Therefore, any change done to the array value via arrayGm happens on the same array value that is assigned to arrayNm. So both variables refer to the same array value, which is why even after the change the equality check will result in true anyway.

If what's required is to create a copy of the array value, the lang.value:clone langlib function (int[] arrayGm = arrayNm.clone();) can be used.

We can use the exact equality (===) check to check if the variables refer to the same value.

import ballerina/io;

public function main() {
    int[] a = [2, 3, 4, 5, 4];
    int[] b = a;

    io:println(a == b); // true
    io:println(a === b); // true, since they both refer to the same value

    b[0] = -1;
    io:println(a == b); // true since `a` and `b` refer to the same value

    int[] c = [2, 3, 4, 5, 4];
    int[] d = c.clone(); // Assign a copy of the array value referred to by `c`
    io:println(c == d); // true since the member values are the same
    io:println(c === d); // false now since `d` refers to a clone of the value referred to by `c`

    c[0] = 25;
    io:println(c == d); // now false since `d` was referring to a clone of the value held by `c`
                        // and since `c` was updated, the member values in `c` and `d` are now different
}

[navaneeth-algorithm]

Thank u very much!! understood👍