bonjour je je ne sais pas pourquoi le le programme ne foctionne plus et merci d'avance

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
public class TestConsumer {

	/**
		 * @author aich
		 *
		 */
	public class Personne {

	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<Personne> lPersonne = Arrays.asList(
				new Personne(10, "toto"),
				new Personne(20, "titi"),
				new Personne(30, "tata"),
				new Personne(40, "tutu")
		);
		
		for (int i = 0; i < personneList.size(); i++) {System.out.print(personneList.get(i).getNom() + " " + personneList.get(i).getAge() + ", "); 
    } 
        System.out.println();
	}

}

michelbillaud

15 février 2022 à 15:37:38

Il n'est même pas compilable :

il faudrait un constructeur.
la liste déclarée est lPersonne; celle qui est utilisée est personneList

Boire ou programmer il faut choisir.

---

bon,

on va en profiter pour moderniser un peu

Une Personne a un age et un nom ? La déclaration suivante (depuis java 14)

record Personne(int age, String nom) {
}

remplace celle d'une classe et nous fournit automatiquement un constructeur et des accesseurs pour chaque attribut déclaré.

Du coup on peut écrire

List<Personne> lPersonne = Arrays.asList(
                new Personne(10, "toto"),
                new Personne(20, "titi"),
                new Personne(30, "tata"),
                new Personne(40, "tutu")
        );

ou mieux (var depuis java 11)

         var personnes = List.of(
                new Personne(10, "toto"),
                new Personne(20, "titi"),
                new Personne(30, "tata"),
                new Personne(40, "tutu")
        );

Le compilateur étant assez grand pour induire qu'il s'agit d'une liste de Personne.

La boucle par indices est maladroite (et est par ailleurs très inefficace sur une liste chainée), pourquoi ne pas utiliser la "range based for loop" moderne (depuis java 8). Pour afficher toute personne p :

   for (var p : personnes) {
            System.out.format("%s %s, ", p.nom(), p.age());
   }
   System.out.println();

---

Dans un style plus fonctionnel (streams), on peut aussi

à partir de chaque personne produire sa chaîne nom+age
concaténer l'ensemble en séparant par des virgules
faire afficher le tout

        System.out.println(
                personnes.stream()
                        .map(p -> p.nom() + " " + p.age())
                        .collect(Collectors.joining(", "))
        );

Code complet

package testconcombre;

import java.util.List;
import java.util.stream.Collectors;

public class TestConcombre {

    record Personne(int age, String nom) {

    }

    public static void main(String[] args) {
        var personnes = List.of(
                new Personne(10, "toto"),
                new Personne(20, "titi"),
                new Personne(30, "tata"),
                new Personne(40, "tutu")
        );
// VERSION BOUCLE
        for (var p : personnes) {
            System.out.format("%s %s, ", p.nom(), p.age());
        }
        System.out.println();

// STREAMS
        System.out.println(
                personnes.stream()
                        .map(p -> p.nom() + " " + p.age())
                        .collect(Collectors.joining(", "))
        );
    }

}

---

mais tout ceci ne fait pas apparaitre les interfaces phoque-tionnelles du titre.

-
Edité par michelbillaud 15 février 2022 à 17:08:16

estaleslas

15 février 2022 à 17:48:07

meerci

AbcAbc6

16 février 2022 à 11:17:37

estaleslas a écrit:

meerci

Bonjour,

Sujet résolu

Tu peux passer le sujet à "résolu" (bouton en haut à droite du sujet) et cliquer sur les pouces levés des messages qui t'ont aidé⋅e

michelbillaud

16 février 2022 à 12:08:23

Enfin, il en manque un bout, si on tient à avoir un Consumer là dedans, on peut le faire apparaitre dans une forEach lié à la liste

personnes.forEach(p -> System.out.format("%s %d, ",
                                         p.nom(),
                                         p.age());

On peut aussi employer une référence de méthode statique de l'appli

  personnes.forEach(TestConcombre::afficherPersonne);

static void afficherPersonne(Personne p) {
        System.out.format("%s %s, ", p.nom(), p.age());
}

ou une référence de méthode du record Personne

  personnes.forEach(Personne::afficher);

   record Personne(int age, String nom) {
        void afficher() {
             System.out.format("%s %s, ", nom, age);
        }
    }

estaleslas

16 février 2022 à 13:02:39

merci parfait j'ai essaye avec ce code mais un message qui vient de s'afficher

// class TestConsumer

import java.util.Arrays;

import java.util.List;
import java.util.function.Consumer;


public class TestConsumer {
      
    /**
         * @author aich
         *
         */
   
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<Personne> lPersonne = Arrays.asList(
                new Personne(10, "toto"),
                new Personne(20, "titi"),
                new Personne(30, "tata"),
                new Personne(40, "tutu")
        );
         
        for (int i = 0; i < lPersonne.size(); i++) {System.out.print(lPersonne.get(i).getNom() + " " + lPersonne.get(i).getAge() + ", ");
    }
        System.out.println();
    }
 
}
//Class Pesonne

/**
 * 
 */

/**
 * @author hicham
 *
 */
 public class Personne {
private int age=0;
private String name="";
		/**
		 * @param i
		 * @param string
		 */
    	public Personne() {
    	}
		public Personne(int i, String nom) {
			// TODO Auto-generated constructor stub
			this.age=i;
			this.name=nom;
		}

		/**
		 * @return
		 */
		public int getAge() {
			// TODO Auto-generated method stub
			return age;
		}

		/**
		 * @return
		 */
		public String getNom() {
			// TODO Auto-generated method stub
			return this.name;
		}
 
    }

Could not find or load main class TestFunction

reference:https://openclassrooms.com/fr/courses/26832-apprenez-a-programmer-en-java/5012411-creez-des-classes-anonymes-des-interfaces-fonctionnelles-des-lambdas-et-des-references-de-methode

brubru777

16 février 2022 à 13:19:50

Bonjour,

Le nom du fichier doit être identique au nom de la classe (majuscules comprises).

michelbillaud

16 février 2022 à 13:31:51

Et les noms qui commencent ou finissent par Test sont plutôt à conserver pour les tests unitaires.

estaleslas

16 février 2022 à 17:55:49

brubru777 a écrit:

Bonjour,

Le nom du fichier doit être identique au nom de la classe (majuscules comprises).

oui ils sont identiques

michelbillaud

16 février 2022 à 18:03:58

estaleslas a écrit:

brubru777 a écrit:

Bonjour,

Le nom du fichier doit être identique au nom de la classe (majuscules comprises).

oui ils sont identiques

Et alors d'où sort le nom TestFunction qui figure dans le message ?

> Could not find or load main class TestFunction

Ca dépend de l'IDE utilisé mais sous Netbeans, le nom de classe principale est dans les paramètres de Run

-
Edité par michelbillaud 16 février 2022 à 18:05:42

estaleslas

16 février 2022 à 19:25:02

ç'est bon le problème est bien résolu merci a vous

les resultats:

toto 10, titi 20, tata 30, tutu 40,

ekieki

17 février 2022 à 8:55:10

> le problème est bien résolu

C'est dû à un reste de conscience professionnelle : le code avait été testé avant d'avoir été posté.

---

Pendant qu'on y est, quid des interfaces fonctionnelles ?

1. La methode forEach des listes attend, comme paramètre, un objet qui implémente l'interface Consumer. En décomposant :

Consumer<Personne> consommateur = ....;

personnes.forEach(consommateur);

2. Consumer est une interface fonctionnelle, c'est à dire

c'est une interface, qui indique une liste de méthodes à implémenter
elle est fonctionnelle : la liste se réduit à seule méthode (qui s'appelle accept) : un objet qui implémente Consumer représente donc une fonction.

3. Avant Java 8, on aurait pu utiliser une classe anonyme

     Consumer<Personne> consommateur = new Consumer<Personne>() {
            @Override
            public void accept(Personne p) {
                System.out.format("%s %d, ", p.nom(), p.age());
            }
        };

4. Avec l'avancée du progrès, on peut écrire plus léger avec une lambda, pardon, expression fonctionnelle

Consumer<Personne> consommateur = 
     p -> System.out.format("%s %d, ", p.nom(), p.age());
}

qui n'est en fait qu'un raccourci d'écriture :

dans le contexte

Consumer<Personne> consommateur = ...

le compilateur attend un objet qui implémente l'interface Consumer<Personne>.

or c'est une interface fonctionnelle, donc avec une seule méthode accept(Personne ...)
donc, tiens, te la voila la méthode kivabien : p->System.out.format(....)

Un simple raccourci d'écriture, mais un raccourci très pratique.

PS: zut j'ai utilisé le vieux compte.

-
Edité par ekieki 17 février 2022 à 8:56:37

estaleslas

17 février 2022 à 13:10:06

ielle ne retourne rien, elle se contente de "consommer" un objet, donc d'y appliquer un traitement, comme par exemple ajouter 13 ans à l'age d'un objet Pesrsonne

Forums des Zéros

les interface foctionelles

class peronne inconnu

Sujet résolu

les interface foctionelles

class peronne inconnu

Sujet résolu

Supprimer

Modérer

Signaler le message aux modérateurs