Publicité
+ Répondre à la discussion Actualité déjà publiée
Page 1 sur 2 12 DernièreDernière
Affichage des résultats 1 à 20 sur 39
  1. #1
    Responsable Actualités

    Avatar de Hinault Romaric
    Homme Profil pro Hinault Romaric
    Consultant
    Inscrit en
    janvier 2007
    Messages
    3 859
    Détails du profil
    Informations personnelles :
    Nom : Homme Hinault Romaric
    Localisation : Cameroun

    Informations professionnelles :
    Activité : Consultant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : janvier 2007
    Messages : 3 859
    Points : 56 424
    Points
    56 424

    Par défaut JavaOne 2012 : Oracle renouvelle son engagement à faire évoluer Java et dévoile ses plans

    JavaOne 2012 : Oracle renouvelle son engagement à faire évoluer Java et dévoile ses plans
    les préversions de JDK 8 et JavaFX Scene Builder 1.1 disponibles


    JavaOne 2012, la plus grande conférence annuelle autour de la plateforme Java se déroule actuellement à San Francisco.

    Oracle a profité de l’occasion pour dévoiler sa feuille de route pour Java et renouveler son engagement à faire évoluer le langage afin de rassurer les utilisateurs sceptiques face aux récentes découvertes de failles dans la plateforme.

    Pendant ces prochains mois, Oracle travaillera essentiellement sur Java SE 8. Au menu : l’éditeur prévoit l’intégration des expressions lambda, du moteur JavaScript Nashorn (déjà disponible dans la préversion de NetBeans 7.3), les annotations, la nouvelle API « date and time » et bien plus.

    Oracle a également officialisé le projet Sumatra, qui vise à mettre fin à l’utilisation des bibliothèques externes pour l’accélération GPU des applications Java ainsi qu’au processus de conversion entre Java et OpenCL (librairie multiplateforme qui permet d'utiliser les processeurs graphiques pour réaliser des calculs lourds). Le projet Sumatra sera disponible avec Java SE 8.




    La préversion du JDK 8 peut déjà être testée sur le site java.net. La sortie de la version finale est prévue pour septembre 2013. On va regretter cependant le report à Java 9 du projet Jigsaw, qui devait ajouter au langage un système de module.

    Java EE 7 (l’édition pour entreprise) est annoncé pour avril 2013 et apportera comme nouveautés : une API WebSocket, l’API JCACHE pour une mise en cache temporaire des objets Java, un modèle de programmation pour applications Batch et une API pour la manipulation des données au format JSON. Avec cette version de Java EE, Oracle proposera Glassfish 4.0 comme plateforme de référence.

    En ce qui concerne sa plateforme de développement d’Applications Internet Riches JavaFX, Oracle envisage de passer de JavaFX 2.0 (la version actuelle) à JavaFX 8 lorsque sortira le JDK 8. Cette version de JavaFX disposera par défaut au niveau de l’interface utilisateur d’une boite à outils pour Java SE 8 Embedded. Une nouvelle API sera proposée pour la création d’interfaces utilisateur avec un meilleur support des balises HTML5, WebView et JavaFX Scene Builder 2.0.

    JavaFX Scene Builder, l’outil de mise en page visuelle pour la plateforme JavaFX, qui permet aux utilisateurs de créer des interfaces utilisateur en glissant et en positionnant les composants à partir d'une palette dans une scène est actuellement disponible en version 1.1 développeur avec un support pour Linux 32 et 64 bits.

    Toutes ces annonces montrent l’engagement d’Oracle à vouloir faire évoluer l’écosystème Java.


    Télécharger la préversion de JDK8

    Télécharger la préversion de JavaFX Scene Builder 1.1

    La couverture de JavaOne par Bouye

    Source : JavaOne 2012


    Et vous ?

    Que pensez-vous de ces annonces d'Oracle ?
    Si déboguer est l’art de corriger les bugs, alors programmer est l’art d’en faire
    Mon blog Mes articles
    En posant correctement votre problème, on trouve la moitié de la solution

  2. #2
    Membre Expert
    Avatar de la.lune
    Homme Profil pro Bilal Soidik
    Ingénieur développement logiciels
    Inscrit en
    décembre 2010
    Messages
    513
    Détails du profil
    Informations personnelles :
    Nom : Homme Bilal Soidik
    Localisation : Comores

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2010
    Messages : 513
    Points : 1 946
    Points
    1 946

    Par défaut

    L'importance dans JavaFX8 c'est le support 3D en vrai et le support aussi de l'embarqué. Et vu que presque les syntaxe vont évolué vers Java 8 avec les expressions tous se nouveautés, de plus JavaFX sera une partie intégrant du jdk pas besoin d'installer un jre en plus du jre de java, voilà pourquoi ça va passer à la place de la version 3 à la version 8 pour aller avec java 8

  3. #3
    Modérateur
    Avatar de bouye
    Homme Profil pro Fabrice Bouyé
    Développeur Java
    Inscrit en
    août 2005
    Messages
    4 492
    Détails du profil
    Informations personnelles :
    Nom : Homme Fabrice Bouyé
    Âge : 38
    Localisation : Nouvelle-Calédonie

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : Agroalimentaire - Agriculture

    Informations forums :
    Inscription : août 2005
    Messages : 4 492
    Points : 9 806
    Points
    9 806

    Par défaut

    Note : pour l'API Time & Date, l'équipe a dit hier soir qu'il ne sont pas à 100% sûrs de finir à temps d'ici aux deadlines imposées (j'en ai entendues deux distinctes : novembre et février, sans savoir précisément ce à quoi elles correspondent exactement).
    Merci de penser au tag quand une réponse a été apportée à votre question. Aucune réponse ne sera donnée à des messages privés portant sur des questions d'ordre technique. Les forums sont là pour que vous y postiez publiquement vos problèmes.

    suivez mon blog sur Développez.

    Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the universe trying to produce bigger and better idiots. So far, the universe is winning. ~ Rich Cook

  4. #4
    Membre Expert
    Avatar de Voïvode
    Inscrit en
    mars 2007
    Messages
    288
    Détails du profil
    Informations forums :
    Inscription : mars 2007
    Messages : 288
    Points : 1 738
    Points
    1 738

    Par défaut

    Je suis globalement très emballé par ce que nous réserve le JDK 8, mais suis-je le seul à avoir un avis mitigé sur les expressions lambdas ?

    J'ai cherché après plusieurs exemples sur la toile et en résumant (grossièrement) j'ai remarqué que cela permettait de simplifier le code, notamment en remplaçant les @Override pas beaux. Sauf que des parenthèses sorties de nulle part avec Java, ça ne me plaît pas beaucoup.

    Pourriez-vous partager votre avis et, éventuellement, me rassurer ?

  5. #5
    Modérateur
    Avatar de bouye
    Homme Profil pro Fabrice Bouyé
    Développeur Java
    Inscrit en
    août 2005
    Messages
    4 492
    Détails du profil
    Informations personnelles :
    Nom : Homme Fabrice Bouyé
    Âge : 38
    Localisation : Nouvelle-Calédonie

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : Agroalimentaire - Agriculture

    Informations forums :
    Inscription : août 2005
    Messages : 4 492
    Points : 9 806
    Points
    9 806

    Par défaut

    Grosso-modo là ils utilisent la même syntaxe que C#.
    Perso, je préférais la syntaxe de JavaFXScript/Visage (note : le langage fonctionnel de JavaFX 1.0) où les closures s'écrivaient comme de bêtes pointeurs de fonction à la C, c'était bien plus simple à appréhender.

    Mais bon... Un type de la team langage disait il y a 2 jours que, pour les lambda, ils avaient fait le choix de ne pas exposer les méthodes comme ayant des types à part entière, donc...
    Merci de penser au tag quand une réponse a été apportée à votre question. Aucune réponse ne sera donnée à des messages privés portant sur des questions d'ordre technique. Les forums sont là pour que vous y postiez publiquement vos problèmes.

    suivez mon blog sur Développez.

    Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the universe trying to produce bigger and better idiots. So far, the universe is winning. ~ Rich Cook

  6. #6
    Membre confirmé
    Homme Profil pro
    Développeur Java
    Inscrit en
    juillet 2009
    Messages
    73
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2009
    Messages : 73
    Points : 286
    Points
    286

    Par défaut

    Citation Envoyé par Voïvode Voir le message
    Je suis globalement très emballé par ce que nous réserve le JDK 8, mais suis-je le seul à avoir un avis mitigé sur les expressions lambdas ?

    J'ai cherché après plusieurs exemples sur la toile et en résumant (grossièrement) j'ai remarqué que cela permettait de simplifier le code, notamment en remplaçant les @Override pas beaux. Sauf que des parenthèses sorties de nulle part avec Java, ça ne me plaît pas beaucoup.

    Pourriez-vous partager votre avis et, éventuellement, me rassurer ?
    L'intérêt des expressions lambda va bien au delà; par exemple auparavant quand on voulait ajouter un ActionListener anonyme à un bouton on était obligé d'écrire:
    bouton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
    /* do something */}
    }
    });
    Avec les lambdas on aura plus qu'à déclarer le /* do something /* dans le addActionListener, tout le reste (la déclaration de la classe et de la méthode) sera déduit. Résultat un code plus simple à écrire et à lire.

    Par ailleurs l'API Collection va être revue pour tirer parti de cette nouvelle manière d'écrire du code: il sera alors possible de manipuler des collections de données très facilement sans avoir à écrire de boucles for.
    Par exemple: supprimer tous les objets d'une liste dont l'attribut x sera égal à 1 pourra être réalisé en une petite ligne de code

  7. #7
    Membre Expert
    Avatar de Voïvode
    Inscrit en
    mars 2007
    Messages
    288
    Détails du profil
    Informations forums :
    Inscription : mars 2007
    Messages : 288
    Points : 1 738
    Points
    1 738

    Par défaut

    Citation Envoyé par bouye Voir le message
    Grosso-modo là ils utilisent la même syntaxe que C#.
    Perso, je préférais la syntaxe de JavaFXScript/Visage (note : le langage fonctionnel de JavaFX 1.0) où les closures s'écrivaient comme de bêtes pointeurs de fonction à la C, c'était bien plus simple à appréhender.
    C'est ce que j'ai cru voir, mais je n'ai pas vraiment d'avis là-dessus dans la mesure où Visage m'avait très moyennement emballé (même s'il y avait une certaine élégance dans la syntaxe).

    À ce propos, il me semble avoir lu quelque part que les lambda Java ne seront pas tout à fait des closures…

    Citation Envoyé par ithel Voir le message
    L'intérêt des expressions lambda va bien au delà […] on aura plus qu'à déclarer le /* do something /* dans le addActionListener, tout le reste (la déclaration de la classe et de la méthode) sera déduit. Résultat un code plus simple à écrire et à lire.
    Un truc de ce genre ?
    Code :
    1
    2
    3
    bouton.addActionListener(() -> {
       /* do something */
    });
    Mais… il se passera quoi avec un MouseListener ou un KeyListener qui contiennent plusieurs méthodes à surcharger ?
    Citation Envoyé par ithel Voir le message
    Par ailleurs l'API Collection va être revue pour tirer parti de cette nouvelle manière d'écrire du code: il sera alors possible de manipuler des collections de données très facilement sans avoir à écrire de boucles for.
    Par exemple: supprimer tous les objets d'une liste dont l'attribut x sera égal à 1 pourra être réalisé en une petite ligne de code
    Là je suis entièrement pour ! La verbosité de Java ne me dérange pas trop dans l'ensemble mais devoir se palucher les tris de Collection est effectivement pénible.

  8. #8
    Membre confirmé
    Homme Profil pro
    Développeur Java
    Inscrit en
    juillet 2009
    Messages
    73
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2009
    Messages : 73
    Points : 286
    Points
    286

    Par défaut

    Tout à fait, un truc de ce genre
    Et effectivement pour que cela fonctionne il faut que l'interface utilisée (ici ActionListener) ne contienne qu'une seule méthode. Donc pour un MouseListener ou un KeyListener on fera comme avant: on implémentera ces interfaces à l'ancienne (ou on étendra MouseAdaptor / KeyAdaptor ).

  9. #9
    Modérateur
    Avatar de bouye
    Homme Profil pro Fabrice Bouyé
    Développeur Java
    Inscrit en
    août 2005
    Messages
    4 492
    Détails du profil
    Informations personnelles :
    Nom : Homme Fabrice Bouyé
    Âge : 38
    Localisation : Nouvelle-Calédonie

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : Agroalimentaire - Agriculture

    Informations forums :
    Inscription : août 2005
    Messages : 4 492
    Points : 9 806
    Points
    9 806

    Par défaut

    On peut pas faire
    ?

    C'est con si c'est figé à un seul argument
    Merci de penser au tag quand une réponse a été apportée à votre question. Aucune réponse ne sera donnée à des messages privés portant sur des questions d'ordre technique. Les forums sont là pour que vous y postiez publiquement vos problèmes.

    suivez mon blog sur Développez.

    Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the universe trying to produce bigger and better idiots. So far, the universe is winning. ~ Rich Cook

  10. #10
    Membre confirmé
    Homme Profil pro
    Développeur Java
    Inscrit en
    juillet 2009
    Messages
    73
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2009
    Messages : 73
    Points : 286
    Points
    286

    Par défaut

    Citation Envoyé par bouye Voir le message
    On peut pas faire
    ?

    C'est con si c'est figé à un seul argument
    Si bien sûr on peut avoir autant d'arguments que l'on souhaite. Pour plus d'information vous pouvez aller voir l'article "Java 8 et les Lambda" sur le blog de la société Zenika.

  11. #11
    Modérateur
    Avatar de bouye
    Homme Profil pro Fabrice Bouyé
    Développeur Java
    Inscrit en
    août 2005
    Messages
    4 492
    Détails du profil
    Informations personnelles :
    Nom : Homme Fabrice Bouyé
    Âge : 38
    Localisation : Nouvelle-Calédonie

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : Agroalimentaire - Agriculture

    Informations forums :
    Inscription : août 2005
    Messages : 4 492
    Points : 9 806
    Points
    9 806

    Par défaut

    Ma faute, j'avais lu en diagonale en essayant de comprendre la manière de calculer les impôts sur le revenu américain qui nous était expliquée durant la dernière session

    Oui donc il parlait de plusieurs méthodes et non pas plusieurs arguments.

    Ouaip c'est un peu pour ça que je trouve le truc moins efficace que les closures où il fallait juste transmettre le nom d'une fonction qui correspondait au type attendu. Ici, il faut utiliser une interface avec une seule méthode, c'est pas pratique pour tous les mouse et keyboard listener de AWT/Swing/JavaFX.
    Merci de penser au tag quand une réponse a été apportée à votre question. Aucune réponse ne sera donnée à des messages privés portant sur des questions d'ordre technique. Les forums sont là pour que vous y postiez publiquement vos problèmes.

    suivez mon blog sur Développez.

    Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the universe trying to produce bigger and better idiots. So far, the universe is winning. ~ Rich Cook

  12. #12
    Modérateur
    Avatar de Nemek
    Homme Profil pro Logan
    Architecte technique
    Inscrit en
    août 2005
    Messages
    2 076
    Détails du profil
    Informations personnelles :
    Nom : Homme Logan
    Âge : 29
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Transports

    Informations forums :
    Inscription : août 2005
    Messages : 2 076
    Points : 4 691
    Points
    4 691

    Par défaut

    Concernant les interfaces avec plusieurs méthodes, il est surement probable que de nouvelles interfaces voient le jour comme pour try-with-resource.

    Par exemple :
    Code java :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    interface WindowGainedFocusListener extends EventListener {
      void windowGainedFocus(WindowEvent e);
    }
     
    interface WindowLostFocusListener extends EventListener {
      void windowLostFocus(WindowEvent e);
    }
     
    interface WindowFocusListener extends WindowGainedFocusListener, WindowLostFocusListener {}

    Sinon sur la page du JEP 109: Enhance Core Libraries with Lambda (JDK Enhancement Proposal) :
    Citation Envoyé par JEP 109: Enhance Core Libraries with Lambda
    Candidate Survey
    [...]
    Another approach is to look through existing Java code – both within the library and outside, e.g. from the Qualitas Corpus – and do pattern matching or synthesis to discover candidates. A set of techniques might be as follows:
    [...]
    • Identify abstract classes with one or two abstract methods, and consider adding constructors or factories that takes lambdas. Also consider this for interfaces. The pattern is where implementation is to be “filled in” via overriding; consider how to convert this into passing a Lambda as a parameter.
    Ce qui devrait donner quelquechose comme :
    Code java :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
     
    interface WindowEventListener {
      void windowEventOccured(WindowEvent e);
    }
    class WindowFocusAdapter implements WindowFocusListener {
      public static WindowFocusListener newWindowFocusGainedListener(WindowEventListener listener) {
        return new WindowFocusAdapter() {
          void windowGainedFocus(WindowEvent e) {
            listener.windowEventOccurs(e);
          }
        };
      }
      public static WindowFocusListener newWindowFocusLostListener(WindowEventListener listener) {
        return new WindowFocusAdapter() {
          void windowLostFocus(WindowEvent e) {
            listener.windowEventOccurs(e);
          }
        };
      }
      public static WindowFocusListener newWindowFocusListener(WindowEventListener listener) {
        return new WindowFocusAdapter() {
          void windowGainedFocus(WindowEvent e) {
            listener.windowEventOccurs(e);
          }
          void windowLostFocus(WindowEvent e) {
            listener.windowEventOccurs(e);
          }
        };
      }
     
      void windowGainedFocus(WindowEvent e) {}
      void windowLostFocus(WindowEvent e) {}
    }
    Le plus probable sera certainement la dernière "Factory method". Surtout que la plupart (la totalité ?) des listener AWT/Swing à plusieurs méthodes, il est possible de tout gérer dans la même méthode car l’évènement porte les indications nécessaires.

    En tout cas l'API Java SE 8 ne mentionne rien du genre, il est possible que AWT/Swing n'évolue pas contrairement à JavaFX qui est censé être la relève.
    Java : Forum - FAQ - Java SE 8 API - Java EE 7 API
    Articles sur Ceylon : Présentation et installation - Concepts de base - Typage

    ECM = Exemple(reproduit le problème) Complet (code compilable) Minimal (ne postez pas votre application !)
    Une solution vous convient ? N'oubliez pas le tag
    Signature par pitipoisson

  13. #13
    Responsable Actualités

    Avatar de Hinault Romaric
    Homme Profil pro Hinault Romaric
    Consultant
    Inscrit en
    janvier 2007
    Messages
    3 859
    Détails du profil
    Informations personnelles :
    Nom : Homme Hinault Romaric
    Localisation : Cameroun

    Informations professionnelles :
    Activité : Consultant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : janvier 2007
    Messages : 3 859
    Points : 56 424
    Points
    56 424

    Par défaut Oracle sort la Preview de Java SE 8 pour ARM

    Oracle sort la Preview de Java SE 8 pour ARM
    avec JavaFX, les développeurs peuvent créer des applications pour Raspberry Pi

    Mise à jour du 20/12/2012

    Près de deux mois après la sortie de la préversion de Java SE 8, lors de la conférence JavaOne, Oracle publie une déclinaison de la plateforme de développement pour ARM.

    La préversion de Java SE 8 pour ARM va permettre de développer des applications Java pour les systèmes embarqués et autres dispositifs reposant sur l’architecture ARM à l’instar du Raspberry Pi. Elle embarque une version de JavaFX (sur Linux), le framework de développement d’Applications Internet Riches.

    Pour rappel, Java SE 8 introduira comme nouveautés : les expressions lambda, le moteur JavaScript Nashorn, les annotations, la nouvelle API « date and time » et bien plus.

    La sortie de la version finale de la plateforme est prévue pour septembre 2013.




    Télécharger Java SE 8 pour ARM

    Source : Oracle


    Et vous ?

    Qu'en pensez-vous ?
    Si déboguer est l’art de corriger les bugs, alors programmer est l’art d’en faire
    Mon blog Mes articles
    En posant correctement votre problème, on trouve la moitié de la solution

  14. #14
    Membre Expert Avatar de Gugelhupf
    Homme Profil pro
    Développeur informatique
    Inscrit en
    décembre 2011
    Messages
    595
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : décembre 2011
    Messages : 595
    Points : 1 021
    Points
    1 021

    Par défaut

    J'ai remarqué que les lambdas de Java 8 ressemblaient à celui de C++11.

    Sympa d'inclure un Joda Time dans le standard.
    Par contre j'aurai bien aimé qu'il y est les dates au format relatif.
    Quelque chose du genre :
    Code :
    1
    2
    // Premier Mercredi du moins prochain
    DateTime d = new DateTime("first Wednesday of next month");
    Pourrait-t-on avoir des informations plus précises sur les différentes nouveautés cités ?

  15. #15
    Expert Confirmé Sénior
    Avatar de adiGuba
    Homme Profil pro
    Développeur Java/Web
    Inscrit en
    avril 2002
    Messages
    13 284
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur Java/Web
    Secteur : Transports

    Informations forums :
    Inscription : avril 2002
    Messages : 13 284
    Points : 21 474
    Points
    21 474

    Par défaut

    Citation Envoyé par bouye Voir le message
    Ouaip c'est un peu pour ça que je trouve le truc moins efficace que les closures où il fallait juste transmettre le nom d'une fonction qui correspondait au type attendu. Ici, il faut utiliser une interface avec une seule méthode, c'est pas pratique pour tous les mouse et keyboard listener de AWT/Swing/JavaFX.
    Le problème avec cette solution, c'est qu'elle ne s'applique pas bien à toutes les interfaces, et que cela pourrait engendrer des erreurs "bizarres".

    En effet : que faire avec les méthodes non implémentées ?
    leur attribuer un corps "vide" ?
    remonter une exception (UnsupportedOperationException) ?


    Si cela laisse le corps vide, ca marche bien avec les listeners, mais cela peut aboutir à des cas incohérent pour d'autre type d'interface. Image une méthode "add(E)" qui ne fasse rien. Tu penses stocker ton objet mais il n'en est rien !

    Si cela remonte une exception, cela permet de détecter immédiatement le problème, mais cela empêche l'utilisation dans des listeners...


    De même : que faire lorsqu'elles retournent une valeurs ?
    retourner une valeur "nulle" (null, false, 0, 0.0 selon le cas)
    retourner une exception ?




    Bref dans tous ces cas là il est préférable d'adapter l'API avec une interface "mono-méthode"...



    a++

  16. #16
    Expert Confirmé Sénior
    Avatar de adiGuba
    Homme Profil pro
    Développeur Java/Web
    Inscrit en
    avril 2002
    Messages
    13 284
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur Java/Web
    Secteur : Transports

    Informations forums :
    Inscription : avril 2002
    Messages : 13 284
    Points : 21 474
    Points
    21 474

    Par défaut

    Au passage je viens de découvrir une petit modif anodine mais bien sympathique dans l'API Logger.

    En général on effectue un log de la manière suivante :
    Code :
    	LOG.log(Level.INFO, "Message " + args);
    Toutefois ce code à un défaut, c'est que le message est généré AVANT l'appel de la méthode log(), et qu'il sera donc construit en mémoire même lorsque les logs de ce niveau sont désactivé.


    Pour pallier à cela on utiliser généralement un if pour vérifier le niveau :
    Code :
    1
    2
    3
    	if (LOG.isLoggable(Level.INFO)) {
    		LOG.log(Level.INFO, "Message " + args);
    	}


    Dans la preview du JDK8 on peut désormais utiliser un Supplier<String> pour générer le message.
    Supplier<T> est juste défini comme cela :
    Code :
    1
    2
    3
    public interface Supplier<T> {
        public T get();
    }

    L'intérêt c'est qu'on peut donc utiliser une expression lambda pour la génération du message :
    Code :
    	LOG.log(Level.INFO, () -> "Message " + args );
    Du coup il est inutile de vérifier le niveau avant l'appel, puisque le message ne sera généré que lors de l'appel de la méthode get() du Supplier, et uniquement lorsque le niveau de log correspondant est activé...



    a++

  17. #17
    Modérateur
    Avatar de bouye
    Homme Profil pro Fabrice Bouyé
    Développeur Java
    Inscrit en
    août 2005
    Messages
    4 492
    Détails du profil
    Informations personnelles :
    Nom : Homme Fabrice Bouyé
    Âge : 38
    Localisation : Nouvelle-Calédonie

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : Agroalimentaire - Agriculture

    Informations forums :
    Inscription : août 2005
    Messages : 4 492
    Points : 9 806
    Points
    9 806

    Par défaut

    Heu, j'ai toujours du mal avec leur notation à savoir à quel moment sont faits les allocations des closures/classes anonymes. Encore plus quand c'est sensé produire du bytecode compatible avec la version antérieure. Tu es bien sur de ce que tu avances ?
    Merci de penser au tag quand une réponse a été apportée à votre question. Aucune réponse ne sera donnée à des messages privés portant sur des questions d'ordre technique. Les forums sont là pour que vous y postiez publiquement vos problèmes.

    suivez mon blog sur Développez.

    Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the universe trying to produce bigger and better idiots. So far, the universe is winning. ~ Rich Cook

  18. #18
    Expert Confirmé Sénior
    Avatar de adiGuba
    Homme Profil pro
    Développeur Java/Web
    Inscrit en
    avril 2002
    Messages
    13 284
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur Java/Web
    Secteur : Transports

    Informations forums :
    Inscription : avril 2002
    Messages : 13 284
    Points : 21 474
    Points
    21 474

    Par défaut

    Citation Envoyé par bouye Voir le message
    Heu, j'ai toujours du mal avec leur notation à savoir à quel moment sont faits les allocations des closures/classes anonymes. Encore plus quand c'est sensé produire du bytecode compatible avec la version antérieure. Tu es bien sur de ce que tu avances ?
    Oui j'ai testé cela dans l'early-access JDK8+lambda : http://jdk8.java.net/lambda/

    Sinon cela ne produit pas du bytecode compatible dans le sens où il faudra à tout prix une JVM 1.8 pour faire tourner le code.


    En fait le compilateur va générer une méthode statique qui contiendra le code de la lambda, et va inclure un appel dynamique vers cette méthode via l'invokedynamic et les MethodHandle.

    Grosso modo le code suivant :
    Code :
    1
    2
    3
    public void method(String args) {
    	LOG.log(Level.INFO, () -> "Message " + args );
    }

    Va générer quelque chose de la sorte :
    Code :
    1
    2
    3
    4
    5
    6
    7
    public void method(String args) {
    	LOG.log(Level.INFO, invokedynamic bootstrap[lambda$1]);
    }
     
    static String lambda$1(String args) {
    	return "Message " + args;
    }

    Bien sûr l'instruction "invokedynamic bootstrap[lambda$1]" n'est pas du Java, mais une représentation d'un appel dynamique permettant de créer le lambda.

    Lors de cet appel dynamique, la JVM va retourner un type "lambda proxy" qui "simulera" l'interface fonctionnelle (Supplier<T> dans cet exemple).
    Et apparemment la JVM pourra effectuer là dessus des optimisations très importante en allant carrément jusqu'à remplacer l'appel directement dans le code à l'intérieur de la méthode appelée.

    J'avoue ne pas tout comprendre bien précisément, mais cela a vraiment l'air très prometteur...



    Malheureusement, il y a un "MAIS" ! Apparemment ils sont à la bourre sur l'implémentation de ce proxy lors de l'appel dynamique. Ainsi dans un premier temps l'appel dynamique va se contenter de créer une classe anonyme...

    La version optimisé avec le proxy viendra plus tard...


    Et si j'ai bien compris tout ceci concerne avant tous la JVM, donc il n'y aura pas besoin de recompiler...


    a++

  19. #19
    Modérateur
    Avatar de bouye
    Homme Profil pro Fabrice Bouyé
    Développeur Java
    Inscrit en
    août 2005
    Messages
    4 492
    Détails du profil
    Informations personnelles :
    Nom : Homme Fabrice Bouyé
    Âge : 38
    Localisation : Nouvelle-Calédonie

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : Agroalimentaire - Agriculture

    Informations forums :
    Inscription : août 2005
    Messages : 4 492
    Points : 9 806
    Points
    9 806

    Par défaut

    Merci de la précision
    Merci de penser au tag quand une réponse a été apportée à votre question. Aucune réponse ne sera donnée à des messages privés portant sur des questions d'ordre technique. Les forums sont là pour que vous y postiez publiquement vos problèmes.

    suivez mon blog sur Développez.

    Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the universe trying to produce bigger and better idiots. So far, the universe is winning. ~ Rich Cook

  20. #20
    Expert Confirmé Sénior
    Avatar de adiGuba
    Homme Profil pro
    Développeur Java/Web
    Inscrit en
    avril 2002
    Messages
    13 284
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur Java/Web
    Secteur : Transports

    Informations forums :
    Inscription : avril 2002
    Messages : 13 284
    Points : 21 474
    Points
    21 474

    Par défaut

    Juste pour info, l'early-access Lambda est assez complète : http://jdk8.java.net/lambda/

    Il y a de quoi bien s'amuser même si l'inference des types n'est pas finalisé (du coup il faut parfois caster explicitement, ce qui alourdit la syntaxe).


    Quelques exemples vites fait :


    1 - On peut effectuer des itérations internes sur les éléments Iterable :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
            Iterable<String> iterable = ...
     
           // Ceci :
           for (String s : iterable) {
                System.out.println(s);
            }
           // Peut-être remplacé par cela :
            iterable.forEach((String s) -> {
                System.out.println(s);
            });
    Par defaut cela revient à la même chose (c'est à dire à utiliser un Iterator), mais chaque implémentation peut définir sa propre implémentation de forEach() plus optimisé (c'est le cas par exemple d'ArrayList qui effectuera directement le parcours sur son tableau interne).

    Au passage ce code peut être encore plus compacte, de diverses manières :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
            // Expression Lambda complète, dont l'expression peut prendre plusieurs lignes :
            iterable.forEach((String s) -> {
                System.out.println(s);
            });
            // Lorsque le code de l'expression se résume à une ligne,
            // on peut se passer des crochet et du point-virgule final { ... ;}
            iterable.forEach((String s) -> System.out.println(s));
            // Le type du (ou des) paramètre est déduit du contexte
            // il est donc possible de s'en passer :
            iterable.forEach((s) -> System.out.println(s));
            // Lorsqu'on n'a qu'un seul et unique paramètre,
            // on peut se passer des parenthèses :
            iterable.forEach(s -> System.out.println(s));
    Mieux encore, lorsqu'on se contente d’appeler une méthode, et que sa signature correspond à l'interface fonctionnelle, on peut remplacer l'expression Lambda par un pointeur de méthode (notez bien les doubles deux-points :: )
    Code :
            iterable.forEach(System.out::println);

    Cette méthode forEach() est encore plus intéressante sur les Map :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
            Map<String, Object> map = ...
     
            // Avec un Iterator on se ballade plein de chose inutile :
            for (Map.Entry<String,Object> e : map.entrySet()) {
                String k = e.getKey();
                Object v = e.getValue();
                System.out.println(k + " = " + v);
            }
     
            // Alors qu'on peut aller droit à l'essentiel avec les expr. lambda :
            map.forEach((k,v) -> {
                System.out.println(k + " = " + v);
            });




    L'API de Collections profite des "Default Method" pour se doter de quelques méthodes utiles, exemple :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
            List<String> list = ...
     
            // Passer tous les éléments de la liste en majuscule :
            list.replaceAll(String::toUpperCase);
            // Supprimer tous les éléments de moins de 4 caractères :
            list.removeAll(s -> s.length() < 4);
            // Trier les éléments selon l'ordre naturel (compareTo()) :
            list.sort(Comparators.naturalOrder());
            // Trier les éléments selon leurs tailles :
            list.sort(Comparators.comparing(String::length));
    Note : cette dernière ligne ne fonctionne pas encore à cause de l'inférence des types qui n'est pas finalisé, et pour le moment il faut spécifier explicitement le paramétrage Generics, ce qui ne sera plus le cas dans la version finale :
    Code :
    list.sort(Comparators.<String,Integer>comparing(String::length));



    Mais le plus gros ajout vient des streams : lorsqu'on utilise un stream, on peut filtrer ou modifier les valeurs de la source de données, sans modifier cette source.

    Quelques exemples (loin d'être exhaustif) :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
            Collection<String> coll = ...
     
            // On prend tous les éléments de 6 caractères,
            // en ignorant les doublons,
            // que l'on va trier par taille,
            // puis convertir en majuscule,
            // pour finalement afficher les valeurs :
            coll.stream()
                    .filter(s -> s.length() < 6)
                    .uniqueElements()
                    .sorted(Comparators.<String, Integer>comparing(String::length))
                    .map(String::toUpperCase)
                    .forEach(System.out::println);
     
            // Même chose que ci-dessus, mais en stockant le résultat dans une ArrayList :
            List<String> result = coll.stream()
                    .filter(s -> s.length() < 6)
                    .uniqueElements()
                    .sorted(Comparators.<String, Integer>comparing(String::length))
                    .map(String::toUpperCase)
                    .into(new ArrayList<String>());
     
            // Afficher seulement 5 éléments, après le 10ième
            // (cela permet de mettre en place un système de pagination)
            coll.stream()
                    .slice(10, 5)
                    .forEach(System.out::println);
     
            // Recherche de la valeur minimum, selon l'ordre naturel :
            String min = coll.stream()
                    .min(Comparators.naturalOrder())
                    .get();

    La grosse force des "stream" étant de pouvoir paralléliser les traitements.
    En effet il suffit d'utiliser la méthode parallelStream() à la place de stream() pour que le traitement soit effectuer en parallèle (si cela est possible bien entendu).




    a++

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •