Array of Primitive Types

We start with empty

symbol table and
memory.

Note that in trace
- u means undefined variable
- - means defined but uninitialized variable
- ? means your turn to answer
At this point all variables are undefined.

You can run the code at any time by clicking "Switch to code" button.

int a;

is a declaration statement. It causes a number of actions:

a new entry in symbol table for variable a
- note that the type is int
a new entry in memory for variable a
- note that a is defined but its content is uninitialized at this point. It is indicated by u.

In order to simplify the picture, we use
- location 0 of the symbol table for declaration of variable a
- location 0 of the memory for the value of variable a
In reality, run time system assigns
- the first available location in the system table for the declaration
- the first available location in the memory for the value

a = 4;

is an assignment statement.

sets the content of memory location of a to 4.

int[] arrInt;

is similar to int a;.

defines variable arrInt of type int[],
- that is, array of int

It causes:

a new entry in symbol table for variable `arrInt`
- note that the type is `int` array,
  that is, `int[]`
a new entry in memory for variable `arrInt`
- note that the content is uninitialized at this point.
  It is indicated by `u`

arrInt = new int[3];

reserves memory location for 3 integers.
the locations are initialized to 0.
- That is, the contents are set to 0

Note that

arrInt refers to these 3 locations all together.
- its content is set to the location of the first item
  - symbolically its value is set to @5, indicating that the array is actually starting at location 5
individual locations are referred by
- arrInt[0] for location 9,
- arrInt[1] for location 10,
- arrInt[2] for location 11

Check the trace.
Now arrInt has a value. The value indicates the memory locations reserved for arrInt.
- In trace, you would see something like [I@33909752, indicating that it is an array of integers ([I) and some number (33909752) for actual location after @

Note that

this value will change at arrInt = new int[2];
- since a new object will be created.

For simplification, we used location 9 for the new array
In reality, the runtime system would use the first available location in the heap
see
- Heap
- What and where are the stack and heap?

Now focus on arrInt[0].

arrInt[0] = 8;

sets its content to 8.

This is not any different than a = 4;
- setting the content of a to 4.

Similarly,

arrInt[2] = 5;

sets the content of arrInt[2] to 5.

Note that

We do not need to go in order in index.
- We skip index 1, that is arrInt[1]

So does this:

arrInt[1] = 7;

So far we use numbers on the right hand side of assignments.

Let's try something new.

Focus to arrInt[0] again.

arrInt[0] = a;

take the content of a,
- assign to that of arrInt[0]
the content of arrInt[0] changes

Do you thing value of a changes?

No. The content of a does not change.

We are not moving the content of a to arrInt[0]
We are copying the content of a to arrInt[0]

a = 9;

When we change the content of a,
- the content of arrInt[0] stays unchanged.

Later, we will see that changing one variable may change the value of another.

It is possible to use two elements of array as any ordinary variables.

arrInt[0] = arrInt[2];

This is actually no different than

b = a;

Now we are about to do something very new.

We will change the size of array to 2 by

arrInt = new int[2];

As a result,

The array will have only 2 items in it,
- That is, it is one shorter.

What would happen to the third item arrInt[2]?
The same question for arrInt[0] and arrInt[1]?
- Do they stay as it is?
- Do they keep their content?

Let's run

arrInt = new int[2];

Did you expect this?

Java does an unexpected thing.

Instead of trying to reorganize the array of 3 into an array of 2
- It does it in a very different way.
Forgets the array of 3 altogether
- Note that the array of 3 becomes grey
Creates a brand new array with 2 items in a new location.

Check the trace.
Note that arrInt has a new value.
This change indicates that arrInt has a new location in the memory.

The previous array is put into destruction list.
When time comes, garbage collector
- destroys it
- recollects the locations for reuse.

How does the system decide on location 7?

In reality, the new operator constructs the new array starting not at location 7.
It uses the first available location in the heap
For simplification we use location 7.

arrInt[0] = 1;

As we previously did, we can assign new values to the items.

Note that arrInt[0] is in the new location of the array.

So does

arrInt[1] = 2;

Do you want to check the trace? Go to step 0 by clicking on 0 in navigation.

That's all.