I've tried this in multiple languages (ex. python and js) and I get the same general result everytime:
int[] arr = {1, 2, 3, 4, 5};
int[] other = arr;
other[4] = 2;
System.out.println("other[4]: " + other[4]);
System.out.println("arr[4]: " + arr[4]);
int x = 7;
int y = x;
y = 888;
System.out.println("x: " + x);
System.out.println("y: " + y);
Why does other change arr when modified, but, like it should, y does not change x when modified?
The main reason for your confusion is that you are mistaking Reference Types and Value types. Take a look at the docs
This is a long discussion, but in a nutshell: integers are primitive types (also called value types e.g. here), so there's a specific space in memory for x and y in your example. arrays are reference types, so there is only one array in memory and two objects pointing at it.
Java has three types of variable: Primitive type, Object type and null type. One thing needs to clear that Java is always passed by value. Assigning a primitive on another for example int a = b; value of the primitive variable b is assigned to A. In case of assigning of objects it also follows the same rule: passed by value. But in the later case value is reference to the object. Reference variables are not pointers like in C and C++, they are just a handle to object so that one can access them and make some changes on object's state.This is why the values of the array is changed. Any array in Java is an object. java.lang.Object works as supertype in every Java array and thus it inherits all functions in the Object API.
It's because only references are copied, not contents. To make two arrays independent, you should allocate new memory for the destination, and then copy all of the elements.
In short, arr and other are pointing the same memory, because you copied the reference of the memory pointed by arr to other.
Below is a diagram.
Address 0x1000 : 1
Address 0x1004: 2
Address 0x1008: 3
Address 0x100C: 4
Address 0x1010: 5
Address 0x4000(arr): 0x1000
Address 0x4008(other): 0x1000
So arr and other are pointing to the smae address 0x1000, which was allocated firstly when you allocate arr.
x and y just have their primitive values.
0x4020(x): 7
0x4024(y): none
Becomes:
0x4020(x): 7
0x4024(y): 7
After y=x;. And then it becomes:
0x4020(x): 7
0x4024(y): 888
After y=888;
The difference is that array variables in many languages virtually points to the address of the actual data. The reason is: If we copy all of the data whenever we assign an array to another, it will cost a lot of performance hit.
Basically the data types are different and therefore behave differently.
At least in Javascript, an int value is a primitive data type, while an array is an object.
See this article for better explanation: https://codeburst.io/explaining-value-vs-reference-in-javascript-647a975e12a0
int[] other = arr;doesn't create a second array. It gives you a second variable referring to the same array as the first variable. Any changes you make to the array are naturally visible through both variables, as they both point the same place.