Tableaux : traitements courants

Loading...

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

Initiation à la programmation (en Java)

205 notes

École Polytechnique Fédérale de Lausanne

Initiation à la programmation (en Java)

205 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 now know how to declare and initialize a fixed-size array.

We'll have a look at the different classical manipulations

that we can do on such arrays.

First manipulation: printing an array.

Let's imagine for example that we have declared and initialized

an array t1 this way.

We'll have the following situation in memory:

In the variable t1, we have a reference, an address to the array.

The array is initialized in this manner.

Now let's suppose that I want to print the array by simply using

an instruction line like this one.

I pass as argument to System.out.println,

the array t1 that I want to print.

Here, I'm going to print the content of t1

which is a reference.

This will translate into printing something a little strange

which will look like this.

Something like fe25235d, which will correspond to something

that is a reference to an array,

something not very understandable.

In reality, what we want to do is printing the content of the array.

To achieve this, we have no other choice than to provide a loop to iterate

over each element of the array, and print them one by one.

Let's suppose that we want to print each element of an array.

Let's imagine that this array has initially been declared this way.

It's an array of integers.

How do we iterate over such an array to print each cell?

Well, we've got two conventional solutions.

The first is what is called "iteration over a set of values"

and which will be written like this.

The reserved word for and the array's values's type in parenthesis,

which obviously has to be of the same type as what we specified here.

We then have to give a variable name

that will allow us to designate an array's cell.

Then, after a colon, we must indicate the array

over which we want to iterate.

After that, to print the current cell, we just have to

write this sort of instruction line.

In fact, val will take each element of the array turn by turn

and we'll print them in sequence one after the other

with this iteration over the set of values.

The even more standard solution is to use a for

as we know it so far.

A for that uses an index, which will go from 0

to the array's size.

Here, this way of specifying the size isn't great

because it is uncorrelated to the array itself.

We have hard coded the value 3.

The question of how to specify this size

in a cleaner way will arise.

We'll see that later.

So we move on with our index to iterate over every cell of the array.

We access the arrays' cells with the indexation mechanism.

To sum up, if we wish to iterate over each value of an array

we dispose of tools such as

the iterations over a set of values.

We have just seen a concrete example of it.

We can also use a standard for iteration.

At that moment, the problem of the computation of

the array's size arises,

which we'll see further.

In reality there exists a third way of iterating over an array,

the one that uses the notion of iterator.

But this notion isn't presented in the context of this course.

Let's come back to the question at hand concerning standard iterations:

how can we specify the size of a fixed-size array?

How can we recover this size?

In Java, it is possible to get get the size of an array

from it's name.

To achieve this it is necessary to resort to a particular notation.

This notation is the following:

I use the array's name, followed by a point,

followed by the reserved word 'length'.

Here's a concrete example:

I declare/initialize an array scores that contains four elements.

If I want to print the array's size,

I just have to resort to the notation I've just described.

So the array's name, followed by a point, followed by 'length'

which will, here, obviously, print 4.

An analogous example here, with an array of booleans with two entries.

It is important to note here that length will always give you

the possible number of elements

and that the effective number of filled cells isn't important.

The fact that you explicitly put values or not

isn't taken into account.

Here's a concrete example:

Here we declare an array without initializing it

with concrete, effective values.

Neither with an assignment of this type,

nor with the assignment of a global array with a certain number of elements.

I haven't put any explicit values in my array.

However, if I print the array's size,

I get 2 indeed. Why?

Because here, when I construct the array,

I allocate a size of 2 to it.

Which means that I'll have this situation in memory.

The variable score is a reference to an array with two entries.

And we know that by default, these entries are initialzed with 0 for integers.

So we are effectively dealing with a fixed-size array,

containing two entries.

length will give us this size.

No matter whether we initialized it with explicit values or not.

We were interested in how to iterate over the entire set of values of an array.

We saw that it is possible to do it with a standard for-loop

which lead us to discuss about the problem

of the computation of the array's size.

But before concluding the chapter on iterations

let's come back to the other type of iteration,

the for-loops allow us to iterate over a set of values.

We saw that this kind of for-loops are written like this.

We can easily see that it's a very simple and elegant

way of iterating.

We don't even have to worry about the array's size.

However, there exists a certain number of limitations

to this for-loop that we don't encounter with the standard iteration

and which are the following.

First limitation:

an iteration on a set of values won't allow us to modify

the content of the array.

So here, if I have declared/initialized an array this way

and that I want to iterate over this array

with an iteration over a set of values.

The fact of writing something like this,

won't allow us to modify the content of the array.

I can't modify the array

by using a notation of this kind.

Second limitation: I can iterate over one array at a time.

So I can iterate over only one array.

Here, a notation of this kind doesn't exist.

If we want, for example, to

iterate over two arrays at the same time,

with such a notation.

To compare the values of the first array

with the values of the second array, this doesn't exist.

We won't be able, with an iteration over a set of values

to proceed to the simultaneous iteration of the two arrays.

Third limitation:

With the variable val, with the iteration over a set of values, I can

only access one element at a time.

For example, it won't be possible to compare

an element of the array with the one following it.

With val, I can access one element at a time.

Finally, last limitation:

I can iterate one step at a time only.

For example, if I want to jump two by two in the array,

this isn't possible with an iteration over a set of values.

Note that the standard iterations don't have any of these limitations.

It is possible to do everything with a standard for iteration.

Manipulating arrays requires taking a number of precautions.

You should pay attention to a number of aspects

to not cause any errors.

Errors either during the compilation, or during the program's execution.

Errors we'll encounter while learning about arrays,

are errors on indexes or access errors

before the array's construction.

There exists other types of errors which are related

to the object-oriented programming aspect

which will be presented in an upcoming course on object-oriented Java.

Concerning the index problems, there are two things to be observed.

The first is that the index of an array must imperatively be of int type.

That's an integer.

You must absolutely respect the array's bounds, which are between

0 and T-1, where T is the array's size.

Here, I declare and construct an array of size 250.

I commit a first error here, by trying to use an index

that isn't of int type.

So it's an error on the index type.

Here I commit a second error by trying to use an index

that is outside the array's bounds.

So it's an error on the bounds.

Likewise, an error on the bounds, here.

We know that an array of 250 element has indexes going from 0 to 249.

If I use the index 250, I overflow.

I am not in the array's bounds.

In this case, I also have a error on the bounds.

Note that the first type of error is an error that will be detectable

by the compiler, so when I compile the program.

Contrariwise, the other errors are errors that will only be

detected during the program's execution.

Of course in practice, we won't commit

this kind of error in such explicit ways.

Often, it's if we get the indexes through a computation,

and that our computation is wrong, that we'll end up with this kind of error.

In general, we won't commit them in such explicit ways.

Another classical error: the access before construction.

In Java, if we want to access an array's element through indexation,

it is imperative that the array has been constructed beforehand.

An array's construction can be done, for example,

by directly indicating the values when declaring the array.

What can be seen here, with this instruction line.

When I declare my array, I put a number of values into it,

explicitly, with an assignment of this nature.

So obviously, here, the element of index 0 really exists.

It is possible to access it, it is entirely licit to proceed to this kind of access

with the array's cell of index 0.

Contrariwise, here, I have a slightly different situation.

I declare the array but I don't construct the array,

I don't assign initial values with an assignment of this nature to it,

no more than I construct the array with this second type of instruction lines,

which allows me to give an initial size to it and allocate

a number of cells to this array.

As I don't resort to this possibility, nor this possibility, nor this one,

the access to a cell of the array is impossible.

So here I would have an error.

So what's missing with this instruction line

is having built the array beforehand, which I can do

with a trick of this nature.

At that moment, the problem is resolved

and I don't have problems of access before construction anymore.

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