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 : affectation et comparaison
Loading...
En provenance du cours de École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en Java)
217 notes
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
À partir de la leçon
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.
Rencontrer les enseignants
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
We'll now see what an assignment means
when used with arrays.
To achieve this, it is necessary to come back on our discussion
comparing the basic types and the advanced types in Java.
Let's assume that we have two variables a and b, of
sometimes basic types, for example here a and b are integers,
and sometimes advanced types; there we'll suppose
that a and b are arrays.
What will writing a = b mean in both cases?
Here we imagine, for example, that b initially contains 2,
and that there, b initially contains a reference to an array.
So if I execute an assignment in the case of basic types,
I find myself in the situation where a eventually contains the same value as b.
It's the same in this case there: if I execute this instruction line,
I'll copy in a the same value as b,
that is a reference to the same array, in our case.
For a basic type, doing this assignment
doesn't introduce any particular relation between "a" and "b".
For example, if I decide afterwards to modify "a" with an assignment
such as this one, this obviously doesn't have any incidence on "b".
A different situation arises
for arrays containing the referenced object.
When I achieve this kind of assignment, it becomes possible to modify
the array referenced both by "a" and "b".
Which means that if I write here a[0] = 300,
b[0] will also have the value 300.
So, in the case of basic types, there's a true autonomy
between the two objects, the modification of one of the objects
has absolutely no incidence on the other one.
On the other side, when I do an assignment on objects
such as arrays, there'll be a dependency
relative to the referenced object.
The message here is that, unlike basic types,
to do an assignment between two variables of array type creates
a dependancy between these two objects.
Here, we begin with a situation where we initially have two completely
distinct arrays, which are autonomous in memory, so a first variable "a"
that contains a reference to the 10-cell array,
and a second variable "b" that contains a reference
to a second array with 10 cells, initially completely autonmous.
So we begin by filling the array "a", simply
with a for-loop, by putting in each cell the same values
as the indexes. So we end up with this situation in memory;
and we execute our much vaunted assignment of "a" into "b".
So with this assignment, we'll put in "b" the same address
than the one in "a", which means that now on "b"
will point to this array.
This relation is broken, these memory locations aren't accessible anymore.
And here, if I modify the third entry of the array via "a",
I see that the same array's entry accessed via "b" is also modified.
We therefore see that the assignment of two arrays with =
only makes sense if we want to have
two different names for a same array,
which is relatevly rare.
In the most general case, with an assignment we want
to ensure that each cell of the array "b" is put in corresponding
cells of the array "a", while ensuring that
both array keeps their autonomy.
For such a situationt, it is better to proceed with a loop,
which will allow us to copy each value from the first array's cells
to the corresponding cells of the second array,
paying attention to stay between the licit bounds!
So if, for example, we choose as break condition the size of the
array "a", well, in order for this loop to not commit any error,
it will be necessary for the size of "b" to be at least equal to the size of "a";
otherwise we'd have to formulate the break condition
in a slightly different manner.
You can now easily understand that the fact that arrays in Java
are manipulated through references also has
an impact on the semantic of the '==' comparison operator.
If "a" and "b" are two arrays, comparing them with ==
will, of course, compare the references, and not
the content of the arrays.
So here I'm in the situation where I have "a", which is an array,
so it contains a reference to the array, and same for "b";
so a == b will return true only if the same reference is effectively
contained in the two objects "a" and "b";
when they both point to the same memory address,
which is obviously the case when I've done an assignment of this
kind beforehand.
So the == operator applied to arrays doesn't test the equality
of the content of the arrays pointed by "a" and "b".
If we want to compare the contents, we must, like before
for the assignment, proceed with an iteration.
So if we rather want to compare the content of the two arrays,
we'll have to write a number of instruction lines to test
if it's the case or not.
We can for example begin by testing if the arrays
have the same size; if it's not the case,
we are sure that the content isn't the same.
We'll usually also take the precaution
of comparing the arrays with the special reference,
the reserved word
"null". "null" is a special value that can be assigned
to an array and that indicates that the array doesn't reference anything.
We usually take this precaution too.
So if the arrays don't reference anything, or if they're of different sizes,
then we can immediately say that their content is different.
Otherwise, we can suppose that their content is possibly the same,
but we'll have to test it, and we'll have to iterate over the entire
array and test cell by cell if the content of the two are identic.
If we exit the loop because of the first condition,
it means that we've iterated over the entire array
and that the condition was always true cell by cell,
so we can assert that the contents were the same.
Otherwise, well we're in the situation where the contents are different.
To conclude this presentation about fixed-size arrays in Java,
here are a few simple examples of standard routine manipulations,
like for example printing the content of an array or inputing
the content of an array.
We suppose here that we have initially declared a variable "table" that can
contain a number of double-type values.
We also suppose that, later, the program took care of filling
the array with values that we consider as appropriate, for example
with assignments of this nature, and we want to print
the content of the array.
To achieve that, it is necessary to resort to iterations, for-loops,
which will allow us to iterate over the entire set of values of an array and print them
one by one. The type of for-loop to choose, we saw that there exists two of them,
will in fact depend of the situation: will we need to explicit
the indexes or not. In the case where it is not necessary
to explicit the indexes, we can use a for-loop
of type "iteration on a set of values".
We saw that for this kind of for-loop, we must declare
a variable of the same type as the array's elements.
This variable will alternately take the different values of the array
and we'll be able to print them simply like this.
Contrariwise, if we need to explicit the indexes, then we'll resort to
a standard for-loop, and at that moment we have to declare an index
that will vary from zero to the array's size.
We saw that the array's size is expressed by
this particular notation. Knowing that the array's indexes
go from zero to size-1, we'll have to take the precaution
of stopping just before the array's size, and of course, we'll have
to move the index forward while we progress in the array.
So at that moment, we can print both the index,
as it is explicit, and the corresponding value.
Second example, the input of the array's elements
with a keyboard interaction. We saw that the range for-loop (iteration
on a set of values) doesn't allow us to modify the content of the array.
So for this we don't have a choice,
it is absolutely essential to explicit the indexes in Java.
Here, we'll therefore resort to a standard for-loop,
iterating, like before, from zero to the array's size
and stopping one index before, to avoid overflow,
and at that moment we can input each value of the array separately
with a standard keyboard input, as we have already
done previously.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2019 Coursera Inc. Tous droits réservés.
