HMIN215 - Correction des exercices sur les streams (Java 1.

8)

Université de Montpellier - Faculté Des Sciences -

Marianne Huchard - mars 2016

1 Retour sur les exercices avec les itérateurs

Nous reprenons sous forme de streams des équivalents des parcours effectués avec les itérateurs dans le
cours précédent.

1.1 Feu tricolore

L’itérateur de feu tricolore peut être réécrit sous forme de stream, comme vous montre le code suivant. Dans
cette mise en œuvre, un stream d’entiers est créé. Puis on applique à ces entiers (modulo 3) une projection
sur le tableau de couleurs.

package streams_collectors_lambdas;

import java.awt.Color;
import java.util.Arrays;
import java.util.stream.Stream;

public class FeuTricoloreStream {

private Color[] tab = {Color.green, Color.orange, Color.red};

public void brille() {

Stream<Color> feuTricolore
= Stream.iterate(0, n-> n+1).map(curseur -> tab[curseur%3]);
feuTricolore.limit(7).forEach(System.out::println);
}

public static void main(String[] a)

{
FeuTricoloreStream fs = new FeuTricoloreStream();
System.out.println("------ brille --------");
fs.brille();
}
}

1.2 Feuille de salaire

Pour créer un stream sur les attributs de la feuille de salaire, une fonction valeur(int i) retourne l’at-
tribut de rang i. On retrouve la technique utilisée pour le feu tricolore, consistant à créer un stream d’entiers
successifs, à le limiter au nombre d’attributs, puis à projeter ce nombre sur les attributs d’après leur rang
(grâce à valeur(int i)).

import java.util.stream.Stream;

public class FeuilleSalaireAvecStream {

1
 private String employeur, salarie;
private Integer nombreHeures;
private Double montantNet;

public FeuilleSalaireAvecStream(String employeur, String salarie,

Integer nombreHeures, Double montantNet) {
this.employeur = employeur;
this.salarie = salarie;
this.nombreHeures = nombreHeures;
this.montantNet = montantNet;
}

public String getEmployeur() {return employeur;}

public void setEmployeur(String employeur) {this.employeur = employeur;}
public String getSalarie() {return salarie;}
public void setSalarie(String salarie) {this.salarie = salarie;}
public Integer getNombreHeures() {return nombreHeures;}
public void setNombreHeures(Integer nombreHeures) {this.nombreHeures = nombreHeures;}
public Double getMontantNet() {return montantNet;}
public void setMontantNet(Double montantNet) {this.montantNet = montantNet;}

// partie pour la mise en oeuvre de l’iterateur

public Object valeur(int i) {
switch (i) {
case 0: return this.getEmployeur();
case 1: return this.getSalarie();
case 2: return this.getNombreHeures();
case 3: return this.getMontantNet();
default: throw new RuntimeException("pas de champ pour cet indice");
}
}

public Stream<Object> valeurs(){

return Stream.iterate(0, n->n+1).limit(4).map(n -> this.valeur(n));
}

public static void main(String[] arg)

{
FeuilleSalaireAvecStream f = new FeuilleSalaireAvecStream("IBM","Jean",200,2000.3);
f.valeurs().forEach(System.out::println);
}
}

1.3 Suite constante à partir d’un certain rang

L’opérateur generate offre une possibilité de créer un stream sur les valeurs d’une suite constante à partir
d’un certain rang (utilisée dans valeurs2). Cette écriture, on le voit dans le code, n’est pas très élégante car
elle se base sur des attributs et méthodes static. Il faut lui préférer l’écriture de valeurs1, qui crée un stream
d’entiers, puis leur applique la fonction valeur(int n).

import java.util.ArrayList;
import java.util.stream.Stream;

public class SuiteConstanteRang {

 private ArrayList<Double> valeurs = new ArrayList<Double>();
private double constante;

public SuiteConstanteRang(ArrayList<Double> valeurs, double constante) {

this.valeurs = valeurs;
this.constante = constante;
}

public ArrayList<Double> getValeurs() {return valeurs;}

public void setValeurs(ArrayList<Double> valeurs) {this.valeurs = valeurs;}
public int getRang() {return this.valeurs.size();}
public double getConstante() {return constante;}
public void setConstante(double constante) {this.constante = constante;}

public Double valeur(int n)

{
if (n < this.getRang())
{double v=this.getValeurs().get(n); return v;}
else return this.getConstante();
}

// génération de stream par iterate sur des entiers

public Stream<Double> valeurs1() {
return Stream.iterate(0, n-> n+1).map(n->this.valeur(n));
}

// partie pour la generation du stream avec next (demande une méthode statique)

private static int curseur = 0;

private static SuiteConstanteRang s ;
public void initialiseStream(SuiteConstanteRang s) {SuiteConstanteRang.s=s;}
public static Double next(){
double courant = s.valeur(curseur);
curseur++;
return courant;
}
public Stream<Double> valeurs2() {
return Stream.generate(SuiteConstanteRang::next);
}

public static void main(String[] argv){

ArrayList<Double> a = new ArrayList<Double>();
a.add(3.0); a.add(4.0); a.add(5.0); a.add(6.0); a.add(7.0);

SuiteConstanteRang suite = new SuiteConstanteRang(a,8);

suite.initialiseStream(suite);
suite.valeurs2().limit(8).forEach(System.out::println);

suite.valeurs1().limit(8).forEach(System.out::println);
}
}