Ce cours initie aux bases de la programmation en utilisant le langage Java : variables, boucles, fonctions, ... Il ne présuppose pas de connaissance préalable. Les aspects plus avancés (programmation orientée objet) sont donnés dans un cours suivant, «Introduction à la programmation orientée objet (en Java)». Il s'appuie sur de nombreux éléments pédagogiques : vidéos sous-titrées, quizz dans et hors vidéos, exercices, devoirs notés automatiquement, notes de cours.
Tableaux : déclaration
Loading...
Del curso dictado por École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en Java)
217 calificaciones
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
De la lección
Tableaux
Cette semaine et les suivantes nous présentons des types de données plus avancés que les types de base. Cette semaine : les tableaux qui permettent de regrouper plusieurs données de même type.
Conoce a los instructores
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
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.
Explora nuestro catálogo
Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.
Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.
© 2019 Coursera Inc. Todos los derechos reservados.
