We saw what the notion of array conceptually was in computer programming.

We also saw that there exists different types of arrays, depending

on whether the array's size is initially known, or whether the size can evolve

or not during the program's execution.

It is now time to move to practical things and see how

we can manipulate a fixed-size array in Java.

When I want to manipulate data in a program, we know that I must

do it through a variable. For example, if my program must

use data of double type, I'll declare a variable of double

type and I'll give it a name. It's exactly the same with an array,

I must declare a variable of array type. Here I must indicate the type

of the elements contained in the array and the fact that it's an array is

indicated by this pair of brackets that precedes the variable's declaration.

So here we once again have a variable name and a type that corresponds

to the fixed-size array of integers type. In Java, there exists an alternative syntax.

So the instruction line we just saw can also be written in this manner

in Java. Just like this instruction line corresponds to the declaration of

a variable of double type, the instruction lines you saw here correspond

to the declaration of a variable "score" of fixed-size array of integers type.

We'll naturally ask ourselves how we can initialize

an array declared this way.

Two methods are usually used to put values

in an array. I can put the values in an array when

I declare it, that's the first possible solution. In the same manner as

when I declare a variable of double type, I can affect it an

initial value, so that corresponds to a declaration-initialization. I can do

the same for an array, assuming

that I initially know what elements I'm putting into it, and I use a particular syntax:

these curly braces that we'll see in more detail

later. So this corresponds to a declaration-initializazion

of an array that corresponds to the situation 1. Second situation,

exactly the same thing as for a double, when I declare it

and then assign it a value. I can do the same for an array.

So I can simply declare it, and fill it element by element

in the instruction lines that follow.

So, as we just saw, if I initially know what elements

I'll put in my array, when I declare it: I can simply write a

unique declaration-initialization instruction line to

declare an array and put values in it. Concretely, here

are the steps to observe. I must declare an array, which I do

like this. Then, I must indicate the elements

to put in the array, between curly braces. And then I must put elements

in this array, and every element will be separated

by a comma. So here are the different syntactic rules that I

must follow to declare-initialize a fixed-size array in Java.

Let's see what memory situation this corresponds to.

Before studying in detail the notion of fixed-size arrays in Java,

and as we are beginning to manipulate advanced types of data, it is

important to understand that in Java, the basic types of data and the

composed, advanced types of data, aren't stored the same way

in memory. For example, if I declare a variable "x" of elementary

type, you must know that when I manipulate a variable of a basic type,

well, that variable will directly store that value. What we can observe

in this little diagram, the variable "x" directly stores the value associated

with it. This isn't the case when I begin manipulating data

of advanced types.

Data of advanced types, like arrays or strings of

characters, which we'll see in future episodes, are in fact

stored by using references, indirections, addresses.

For example, if I declare a variable of type "string of characters", we'll

see that there exists a type for that, called String, so the memory

situation is the following: the variable "v" doesn't directly store the associated

sequence of characters value, but it stores a reference, an address, to the

sequence of characters in question. And this has a strong incidence on

the semantic of assignments in Java. Imagine, for example, that I assign

a variable "v2" to a variable "v1", what does this concretely

mean? Am I modifying the stored reference in "v1"?

Or am I modifying the object referenced by "v1"?

In the same way, the "==" operator's semantic is also

impacted. What does comparing "v1" and "v2" mean? Am I comparing

references? Am I comparing the pointed sequences of characters?

We'll see that there also exists an incidence on the printing.

For example, if I print an object of composed type. What am I trying

to print? An address? Or the [content of the] referenced object? So all these questions

will arise when I manipulate composed type objects in a

Java program.

In Java, an array is an advanced type data, it is therefore manipulated

through an indirection, a reference. So if I declare-initialize

for example a variable "score" of fixed-size array of

integers type in this manner here, the memory situation will be the following:

the variable "score" doesn't directly contain the array's values,

it contains an indirection, a reference, an address to the array.

We suppose that the array's address is here. In the variable "score"

I only store the reference to this array. In jargon terms,

we'll say that the variable "score" "references" or "points to" an array of int.

We just saw how it is possible to declare-initialize a fixed-size

array in a single instruction line, in Java. This presupposes that we initially

know what values to put in the array. In the most general case,

we don't know these values and therefore we must separate the declaration

instruction from the effective fill of the array. That's how we proceed

in that case. So we begin by declaring our variable of array type,

here a fixed-size array of integers. Then, we must allocate the memory

locations, reserve memory locations for our array. This is done in the

following manner: we use the reserved word "new"; we then indicate

the type of the values that we want to store in the array, then in

brackets, the size of the array when it was constructed.

So what you must know is that once the size is allocated,

this size can't change during the program's execution, that's why

we call these arrays, fixed-size arrays.

So second step, we must allocate the reserved memory locations

for the array. At this stage, I'm in the following situation:

I have a variable "score" that contains a reference, an indirection, to an

array. This array contains four elements. What will these elements' values

be at this stage?

What you should know is that in Java there exists default

values that are put in arrays when they are constructed.

So for the previous situation we end up with an array

that contains zeroes. The default values are 0 for int and double types,

False for boolean, and there exists other dedicated values for other types

of data.

So concretely, when an instruction line of this nature is executed,

we have a situation in memory where the array looks like this.

The default values for each cell is zero because I am

working with an array of integers for which the default value

is indeed zero. Of course, these default values won't satisfy us in

most cases, so the third step will consist in

filling the array element by element, which implies taking interest in how

to access every cell of the array to put a dedicated value into it.

The mechanism by which I can access the i-th cell of an array is the

indexation mechanism. I use the following syntax: I indicate the

index, the number of the cell I want to access. What you must

know is that in Java, the index, the cells' number, varies between 0

and T - 1, where T is the size of the array. For example, if I declare an array of

integers "tab" in a program, and that I allocate an initial size of 10 to it,

as it is done here, then the first element

of the array corresponds to the index 0 and the last element of the array will

correspond to the index 9. With this notation, I can alter, modify

the content of a given cell, for example by writing this. It is

important to note that if you overflow the index of the intitially

allocated size, "an exception will be thrown", as we say.

At this stage of your learning, this will probably result in an

abrupt stop of your program. So here for example,

if I try and access a cell that is outside the licit indexes, given

that the last licit index is 9 for an array of size 10, we'll get an

error during the program's execution.

To come back to the initialization of arrays, here's a small example showing

how to fill an array element by element using the indexation

mechanism. This presupposes that we have declared the array, that we

constructed, beforehand. During the construction, we indicate the array's

size and that size can't change during the program's

execution, that's why we talk about fixed-size arrays.

Then, using indexation, it is possible to fill the array cell

by cell, like we do in this sequence of instruction lines.

Here, we'll finally reach this memory situation: the variable

"score" contains a reference to an array that looks like this.

The array is such that at the cell of index 0, there's the value 1000. It's what

we initialized with this instruction line, and at the cell of index 3,

the last cell, we have the value 6450, it's what we

obtained through this instruction line.

Tableaux : déclaration

Initiation à la programmation (en Java)

Conoce a los instructores