Tableaux : affectation et comparaison

Loading...

En provenance du cours de École Polytechnique Fédérale de Lausanne

Initiation à la programmation (en Java)

189 notes

École Polytechnique Fédérale de Lausanne

Initiation à la programmation (en Java)

189 notes

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.

À 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.

Tableaux : introduction11:31

Tableaux : déclaration11:09

Tableaux : traitements courants11:03

Tableaux : affectation et comparaison9:03

Tableaux à plusieurs dimensions10:33

Rencontrer les enseignants

Jean-Cédric Chappelier
Dr.
School of Computer and Communication Sciences
Jamila Sam
Dr
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.

© 2018 Coursera Inc. Tous droits réservés.

Télécharger dans l'App Store

Disponible sur Google Play