Forum Programmation.java débutant java : opérations de base sur les listes

Posté par  . Licence CC By‑SA.
Étiquettes : aucune
0
8
juil.
2020

Salut,
Je viens d'apprendre python avec la methode swinnen pendant le confinement et je m'attaque au java.
Les cours que j'ai trouvé sont tous assez théoriques avec peu d'exemples et d'exercices pour se familiariser au code, j'ai donc repris les exercices de swinnen que je recode en java.

Mais pour les listes java semble un peu lourd. Mon exercice est simple, j'ai une liste t1 [1,2,3,4] et une liste t2 ["lundi","mardi","mercredi","jeudi"] et je veux créer une liste t3 [1,"lundi",2,"mardi",3,"mercredi",4,"jeudi"] à partir de t1 et t2.

les cours sont tres théoriques avec beaucoup de notions sur la généricité mais peu d'exemples..
j'ai essayé de déclarer t1=[1,2,3,4] dans eclipse mais ca me dit cannot convert from int to list. je peux déclarer en , mais j'ai lu que les listes peuvent accepter tous les types, d'où ma confusion à vouloir "typer" une liste.
Si je type t1 en et t2 en , je dois créer une classe de liste avec quelle type pour ma liste t3? D'apres mon cours le wildcard <?> n'est utile que pour la lecture de listes composites..
en théorie il s'agit de collections donc ca accepte tous les types d'objets, mais il faut déclarer le type lorsqu'on instancie une liste ou une arraylist ou une linkedliste?
je pensais faire avec la methode .add seulement pour la liste t3 mais pas pour "créer" mes listes t1 et t2, je trouve que cest un peu lourd.

Bref, pourriez vous me conseiller sur les methodes et trucs les plus pratiques pour s'approcher de l'élégance et la légereté de python?

merci
A+

  • # Commencer par la base

    Posté par  . Évalué à 1 (+0/-1).

    Salut,

    En tant qu'enseignant, quand c'était ma fonction, j'optais pour des choses encore plus simples lorsque je faisais découvrir un langage.

    D'apres mon cours le wildcard <?>

    En informatique français, c'est ce qu'on appelle un générique. ;)

    Et c'est utile pour bien d'autres choses quand c'est bien utilisé. Mais c'est assez avancé.

    Si tu veux commencer, je peux te donner quelques pistes au delà du "hello world". En général, j'optais pour des notions d'algorithmie combinées au langage, afin de faire maturer tout ça, et c'était juste des tris. Avec un peu cet ordre (je sais plus exactement) :

    • tri bulle,
    • tri insertion,
    • tri rapide.

    Je pense les avoir classés dans le bon ordre de complexité à maîtriser.

    Déjà, en faisant ça, sur une liste d'objets de même nature, tu aura bien avancé dans la compréhension.

    • [^] # Re: Commencer par la base

      Posté par  . Évalué à 1 (+0/-1).

      Salut,

      Petit oubli :

      • tri casier

      Celui-là il est rigolo, car il est en O(n) alors que le rapide approche la limite théorique max de O(n*ln(n)). Mais bon, il marche que sur des entiers :)

  • # Typage

    Posté par  (site Web personnel) . Évalué à 1 (+1/-2).

    En java, tu ferais qqchose comme ça:

    List maListeDeNombres<Int> = new ArrayList<>();
    maListeDeNombres.add(1);
    
    List maListeDeChaines<Str> = new ArrayList<>();
    maListeDeChaines.add("lundi");
    ...
    

    Mais tu ne peux pas mettre 1 et "lundi" dans une même troisième liste. Tes choix sont:
    * convertir les nombres en chaînes de caractères
    * créer une classe NombreOuChaine qui peut contenir un nombre ou une chaîne, et créer List<NombreOuChaine> t3.

    Oui, c'est un peu lourd. Mais ça évite pas mal de bugs que tu pourrais avoir en Python sur des projets plus larges, ou évite que tu regardes le type à l'exécution.

    • [^] # Re: Typage

      Posté par  . Évalué à 1 (+0/-1). Dernière modification le 09/07/20 à 07:35.

      Salut,

      List maListeDeBidules<Object> = new ArrayList<>();

      et tu peux y ranger tout et n'importe quoi…

      Edith : Après c'est pas une bonne pratique…

      • [^] # Re: Typage

        Posté par  (site Web personnel) . Évalué à 2 (+1/-1).

        Nan, mais faut pas abuser. Le langage est typé et objet, donc c'est beaucoup mieux d'utiliser une classe qui peut contenir n'importe lequel des deux type, plutôt qu'Object. Traduire Python en Java, c'est idiot. Autant apprendre à penser en Java : tu veux stocker deux types, tu crées un conteneur, et tu fais du Open/Close au lieu de faire des casts et des IFs…

        • [^] # Re: Typage

          Posté par  . Évalué à 1 (+0/-1).

          Salut,

          Nan, mais faut pas abuser. Le langage est typé et objet

          Oui, et ? Faudrait pas pousser mémé dans les ortilles quand même.

          Tu utilise Int alors que c'est Integer, Str alors que c'est String… Je me demande même si tu sais ce que c'est l'autoboxing en java.

          On en reste là ?

          • [^] # Re: Typage

            Posté par  (site Web personnel) . Évalué à 0 (+0/-2).

            Ah, non, ça c'est parce que le dernier project que j'ai écrit était en Python, où justement les types sont 'str' et 'int', donc je tape ça automatiquement…

            Mais la syntaxe, on s'en cogne. Ton compilateur/IDE s'en charge pour toi. En revanche, utiliser Object au lieu d'un conteneur adéquat (ou d'une conversion vers une chaîne si c'est juste pour faire un affichage), c'est un problème d'un tout autre ordre…

            • [^] # Re: Typage

              Posté par  . Évalué à -1 (+0/-3).

              Salut,

              Mais la syntaxe, on s'en cogne.

              Oui, complètement, c'est pour ça que je n'ai pas répondu immédiatement, parce que ça me semblait complètement inutile de relever ce point.

              En revanche, utiliser Object au lieu d'un conteneur adéquat

              Alors soit tu n'a pas lu le lien sur les generics que j'ai posté, ou pas compris, ou je sais pas; mais c'est vraiment de la fonctionnalité un peu avancée.

              Peut-être que l'OP a envie de commencer avec des choses plus douces.

              • [^] # Re: Typage

                Posté par  (site Web personnel) . Évalué à 4 (+2/-0).

                Comment les generics permettent-ils de mettre deux types qui n'ont pas de relation de sous-typage dans la liste (ce que l'OP cherche à faire), sans passer par Object (qui est objectivement une mauvaise approche en termes de design/architecture Java) ou un nouveau type ? Je ne vois pas le rapport, et mon exemple utilise des génériques (List<Integer> par exemple). Si tu pas un passage précis dans les 20+ pages de ton lien qui indique comment mettre des entiers et des chaînes dans une liste, n'hésite pas à le partager.

                S'il veut commencer par des choses plus douces, alors résoudre des exos Python en Java n'est pas une bonne idée. Python et Java sont très différents, et ce qui est élégant et simple dans l'un ne l'est pas forcément dans l'autre…

                "Comment mélange-t-on des entiers et des chaînes dans une liste en Java ?" -> On ne le fait pas, ou alors on créée une liste d'objets "EntierOuChaîne". C'est à la fois plus dur, et la manière la plus simple.

                • [^] # Re: Typage

                  Posté par  . Évalué à -1 (+0/-3). Dernière modification le 10/07/20 à 15:46.

                  Salut,

                  Je ne sais pas où tu vas chercher toutes ces complications. C'est du boxing (voir là)

                  Et comme tu veux pas faire l'effort de présenter les choses clairement :

                  A generic class is defined with the following format:
                  class name<T1, T2, …, Tn> { /* … */ }
                  The type parameter section, delimited by angle brackets (<>), follows the class name. It specifies the type parameters (also called type variables) T1, T2, …, and Tn.

                  Voilà, donc c'est pas une classe bidouillée en mode débrouille, c'est du boxing.

                  On peut vraiment en rester là ?

                  • [^] # Re: Typage

                    Posté par  (site Web personnel) . Évalué à 4 (+3/-1). Dernière modification le 12/07/20 à 00:09.

                    Je ne comprends absolument pas ce que tu essaies de dire. J'ai plutôt l'impression que tu ne maîtrises pas vraiment les generics en fait.

                    • [^] # Re: Typage

                      Posté par  . Évalué à 0 (+0/-2).

                      Salut,

                      Je préfèrerai qu'on en reste la.

                      Je ne prend pas le problème dans le même sens, c'est tout : Je créerai un wrapper autour de list<Object> qui ne prend que les types autorisés.

                      Parce que de toute façon, ça ne raccourcira pas le code à l'usage.

                      Que va retourner un objet EntierOuChaine si il a une méthode disons getValue ? Bin un Objet.

                      Dans la manière de faire que j'utiliserais, il y a un seul endroit où le contrôle est effectué : à l'entrée du wrapper. C'est, je l'accorde, presque équivalent à l'usage d'un objet EntierOuChaine. Juste peut-être un tout petit peu moins verbeux.

                      • [^] # Re: Typage

                        Posté par  (site Web personnel) . Évalué à 4 (+2/-0).

                        Que va retourner un objet EntierOuChaine si il a une méthode disons getValue ? Bin un Objet.

                        Si tu as besoin de coder Object getValue(), alors tu as un problème de design orienté objet.

                    • [^] # Re: Typage

                      Posté par  . Évalué à 0 (+0/-2).

                      Re-salut.

                      import java.util.ArrayList;
                      
                      public class ClassA {
                      
                          private class ClassB<I, S> extends ArrayList<Object> {
                              public void myAdd(I i,S s) throws Exception {
                                  if(i==null && s==null) 
                                      throw new Exception("Je veux un paramètre !");
                                  if(i!=null && s!=null) 
                                      throw new Exception("Mais juste un seul !");
                                  Object o =null;
                                  if(i!=null)
                                      o=i;
                                  else
                                      o=s;
                                  super.add(o);
                              }
                      
                              public Object get(int i) {
                                  return super.get(i);            
                              }
                      
                          }
                      
                          public static void main(String[] args) throws Exception {
                              ClassA a = new ClassA();
                              a.doThings();
                          }
                      
                          public void doThings() throws Exception {
                              ClassB<Integer, String> maListeDeBidules = new ClassB<>();      
                              maListeDeBidules.myAdd(1, null); // ok
                              maListeDeBidules.myAdd(null, "deux"); // ok
                              System.out.println("mon bidule 1: "+maListeDeBidules.get(0));
                              System.out.println("mon bidule 2: "+maListeDeBidules.get(1));
                              maListeDeBidules.myAdd(3, "quatre"); // pas ok
                      
                          }
                      
                      }

                      Un avis ?

                      • [^] # Re: Typage

                        Posté par  . Évalué à 1 (+0/-1). Dernière modification le 12/07/20 à 10:50.

                        Salut,

                        Le get est complètement inutile :( Mais plus le temps d'éditer ;)

                        Ça fonctionne même si on retire ce bout…

                    • [^] # Re: Typage

                      Posté par  . Évalué à 0 (+0/-2). Dernière modification le 12/07/20 à 11:58.

                      Salut,

                      Donc maintenant, à toi de faire l'effort aussi, vu que j'ai pris un peu de temps pour proposer une solution.

                      Elle n'est peut-être pas optimale, mais elle a deux avantages à mon avis :

                      • vérification du type dès l'entrée,
                      • pas d'objet inutile qui engorge le GC.

                      Le petit désavantage, c'est de devoir utiliser myAdd() et pas juste add(), mais en cherchant, si ça se trouve, ça peut se corriger. J'avais juste pas envie de chercher plus loin.

                    • [^] # Re: Typage

                      Posté par  . Évalué à -1 (+0/-3).

                      Salut,

                      Toujours pas de code de ton côté ?

                      Je sais bien que la je provoque un peu, mais si tu me montre pas ta soluce, c'est gênant.

                      Évidemment, dans la mienne, on peut ajouter des vérifications de type pour ne pas inclure des objets dérivés, mais bon, c'était pas le but.

                      Donc donne toujours, je suis près à me courber si on me montre que je n'ai pas raison.

                      • [^] # Re: Typage

                        Posté par  (site Web personnel) . Évalué à 4 (+3/-1).

                        Toujours pas de code de ton côté ?

                        Désolé, mais j'ai d'autre occupations dans la vie.

                        Je sais bien que la je provoque un peu, mais si tu me montre pas ta soluce, c'est gênant.

                        Franchement, je ne sais pas pour qui tu te prends, mais tu devrais éviter de donner des leçons de Java.

                        Ta solution n'apporte rien, ta liste est toujours une liste d'Objects, on peut d'ailleurs toujours y ajouter n'importe quoi en utilisant la méthode addd'ArrayList. Tout ce que tu as fait, c'est ajouter une méthode peu élégante qui prend deux arguments mais il faut en mettre un à nul. On récupère toujours un Object dont on ne sait quoi faire. Autant directement utiliser ArrayList<Object> en fait.

                        Le problème est bien plus fondamentale que ça. Dans un langage à typage statique fort, ça n'a pas de sens de mélanger des types dans une collection s'ils n'ont pas de super type commun. Le seul type partagé ici est Object, donc c'est ce qu'il faut utiliser. Le plus gros souci n'est pas tant l'insertion dans la liste, mais plutôt de savoir quel type on va récupérer quand on va piocher dedans. Ta proposition ne résout pas ce problème. Dans un langage dynamique comme Python ça pétera à l'exécution si tu utilises mal le type récupéré, mais avec un langage statique comme Java il faut qu'on puisse le vérifier à la compilation.

                        • [^] # Re: Typage

                          Posté par  . Évalué à 0 (+0/-2).

                          Salut,

                          Désolé, mais j'ai d'autre occupations dans la vie.

                          Je peux comprendre, moi aussi. D'ailleurs tu as bien vu que ça fait plusieurs fois que je demande d'arrêter le fil de discution.

                          Ta proposition ne résout pas ce problème.

                          Et bien, dis-moi, alors, j'ai peut-être raté un truc (je sais que var existe). Mais juste en me disant que je ne sais pas pour qui je me prend, ce n'est pas engageant.

                        • [^] # Re: Typage

                          Posté par  . Évalué à 0 (+0/-2).

                          Salut,

                          Désolé d'en rajouter une couche. Peut-être qu'on ne se comprend pas, et que ce n'est rien que ça. Et que ce n'est pas nécessaire d'aller plus loin.

                          Le plus gros souci n'est pas tant l'insertion dans la liste, mais plutôt de savoir quel type on va récupérer quand on va piocher dedans.

                          C'est le soucis de l'OP.

                          Avec vos solutions, on se retrouve à encloisonner dans un objet plusieurs objets.

                          Merci au GC de faire du boulot, mais il va en avoir au moins trois fois plus.

                          Bien sûr je peux chinter le add() dans ClassB pour avoir une exception au runtime. Bien sûr c'est pas optimal balisé avec des contraintes plus fortes en vérification de types mon exemple. Bien sûr, je peux interdire aussi aad(int, object). C'était pas le but.

                          Donc maintenant, deux solutions : on arrête (ma solution préférée), ou tu me montre une solution plus élégante (mais ça peut effectivement demander du temps).

                          • [^] # Re: Typage

                            Posté par  . Évalué à 0 (+0/-2).

                            Salut,

                            Allez, comme c'était pas long…

                            Zou. Une version sans null dans la ClasseA, sans le get() inutile, un peu de type checking de plus…

                            public class ClassA {
                            
                                private class ClassB<I extends Integer, S extends String> extends ArrayList<Object> {
                            
                                    public void myAdd(I i,S s) throws Exception {
                                        if(i==null && s==null) 
                                            throw new Exception("Je veux un paramètre !");
                                        if(i!=null && s!=null) 
                                            throw new Exception("Mais juste un seul !");
                                        Object o =null;
                                        if(i!=null)
                                            o=i;
                                        else
                                            o=s;
                                        super.add(o);
                                    }
                            
                                    public void addInt(I i) throws Exception {
                                        myAdd(i, null);
                                    }
                            
                                    public void addString(S s) throws Exception {
                                        myAdd(null, s);
                                    }
                            
                                }
                            
                                public static void main(String[] args) throws Exception {
                                    ClassA a = new ClassA();
                                    a.doThings();
                                }
                            
                                public void doThings() throws Exception {
                                    ClassB<Integer, String> maListeDeBidules = new ClassB<>();      
                                    maListeDeBidules.addInt(1); // ok
                                    maListeDeBidules.addString("deux"); // ok
                                    System.out.println("mon bidule 1: "+maListeDeBidules.get(0));
                                    System.out.println("mon bidule 2: "+maListeDeBidules.get(1));
                                    maListeDeBidules.myAdd(3, "quatre"); // pas ok
                                }   
                            }
                          • [^] # Re: Typage

                            Posté par  (site Web personnel) . Évalué à 5 (+3/-0).

                            Je peux comprendre, moi aussi. D'ailleurs tu as bien vu que ça fait plusieurs fois que je demande d'arrêter le fil de discution.

                            ce n'est pas engageant.

                            Donc maintenant, deux solutions : on arrête (ma solution préférée), ou tu me montre une solution plus élégante (mais ça peut effectivement demander du temps).

                            C'est l'hôpital qui se fout de la charité :
                            - C'est toi qui a le plus posté dans ce fil et qui remet toujours une pièce dans la machine.
                            - Je me suis permis de réagir parce que tu te fous de la gueule d'Axioplase ıɥs∀ alors que de ce que je lis de tes commentaires, tu ne m'as pas l'air assez compétent en Java pour donner des leçons.
                            - Il n'y a pas de solution élégante en utilisant des generics comme tu le suggères. C'est ce qu'a dit Axioplase ıɥs∀ au début, donc on a pas à se creuser la tête pour trouver une solution élégante. C'est toi qui est allé dans cette voie, c'est une impasse.

                            Quand tu mets des objets dans une collection, c'est que tu t'attends à pouvoir appliquer un traitement commun à tous ces objets. Si c'est juste pour ranger n'importe quoi ou juste appeler toString dessus bah le type Object convient. Si tu veux faire plus ça veut dire que tu vas appeler une autre méthode dessus, cette méthode est rattachée à un type donc il faut bien que tu le définisses quelque part et ça sera le type de ta collection.

                            Si je veux utiliser une collection maison bricolée pour accepter mon mix de type, d'une part je perds les avantages liés à utiliser une collection standard, mais ça ne m'avance pas plus que d'utiliser une collection d'Object parce que je n'aurais pas plus d'info sur le type réel des éléments que je récupère de ma liste.

                            • [^] # Re: Typage

                              Posté par  . Évalué à -1 (+0/-3). Dernière modification le 13/07/20 à 13:32.

                              Salut,

                              C'est l'hôpital qui se fout de la charité

                              Et inversement.

                              Montre-moi où ma solution est moins optimale, et on en reparle. Traquillement.

                              • [^] # Re: Typage

                                Posté par  (site Web personnel) . Évalué à 3 (+1/-0).

                                Elle est pas exensible.

                                • [^] # Re: Typage

                                  Posté par  . Évalué à 1 (+0/-1).

                                  Salut,

                                  C'est extensible à n'importe quel type.

                                  Je pense que je vois cependant ce que tu veux dire par là.

                                  Ce que j'apprécie moins dans ta solution c'est qu'en encapsulant, tu donne deux fois plus de boulot au GC, moi pas.

                                  Mais en tout cas, merci d'avoir fait l'effort de montrer ta solution !

                                  • [^] # Re: Typage

                                    Posté par  . Évalué à 1 (+0/-1).

                                    Hop, comme ça fait du bien de bosser un peu :

                                    import java.util.ArrayList;
                                    
                                    public class ClassA {
                                    
                                        private class ClassB<I extends Integer, S extends String> extends ArrayList<Object> {
                                    
                                            private void myAdd(Object... params) throws Exception {
                                                super.add(checkIn(params));
                                            }
                                    
                                            private Object checkIn(Object... params) throws Exception {
                                                int c=0;
                                                Object o=null;
                                                for(Object p:params)
                                                    if(p!=null) {
                                                        c++;
                                                        o=p;
                                                        }
                                                if(c==0)
                                                    throw new Exception("Je veux un paramètre !");
                                                if(c>1)
                                                    throw new Exception("Mais juste un seul !");
                                                return o;
                                            }
                                    
                                            public void addInt(I i) throws Exception {
                                                myAdd(i);
                                            }
                                    
                                            public void addString(S s) throws Exception {
                                                myAdd(s);
                                            }
                                    
                                        }
                                    
                                        public static void main(String[] args) throws Exception {
                                            ClassA a = new ClassA();
                                            a.doThings();
                                        }
                                    
                                        public void doThings() throws Exception {
                                            ClassB<Integer, String> maListeDeBidules = new ClassB<>();
                                            maListeDeBidules.addInt(1); // ok
                                            maListeDeBidules.addString("deux"); // ok
                                            System.out.println("mon bidule 1: "+maListeDeBidules.get(0));
                                            System.out.println("mon bidule 2: "+maListeDeBidules.get(1));
                                            maListeDeBidules.myAdd(3, "quatre"); // pas ok
                                        }   
                                    }

                                    Peut-être que c'est une solution qui se rapprocherait plus de ce que tu veux ? Pas sûr.

                                    En tout cas, dans cette v3, pas d'encapsulation d'objet, on peut étendre, c'est juste un type et une fonction à rajouter…

                                    On n'a pas le même style, mais encore merci pour ta réponse !

                                  • [^] # Re: Typage

                                    Posté par  (site Web personnel) . Évalué à 4 (+2/-0).

                                    C'est pas ce que je veux dire par « extensible ». Ton code n'est pas utilisable par quelqu'un qui utilise ta librairie et souhaite aussi mettre des caractères, des flottants, des voitures, ou des éléphants dans la liste. Ta liste est restreinte aux entiers et chaînes par définition.

                                    • [^] # Re: Typage

                                      Posté par  . Évalué à 1 (+0/-1).

                                      Salut,

                                      Oui, j'ai compris ça comme ça. Donc je pense qu'on est raccord sur ce point.

                                      C'est un peu quand même ce que demandais l'OP…

                                      Et en général, je gare pas mon éléphant dans le frigo, sinon ça fait des traces sans le beurre ;)

                                      • [^] # Re: Typage

                                        Posté par  . Évalué à 1 (+0/-1).

                                        Salut,

                                        Regarde.

                                        Mon code actuel :

                                        import java.util.ArrayList;
                                        import java.util.Arrays;
                                        import java.util.Collection;
                                        import java.util.List;
                                        
                                        public class ClassA {
                                        
                                            // here, you just say what types are accepted
                                            private class ClassB<I extends Integer, S extends String> {
                                                // it's a bit more wrapping, but for the fun
                                                private List<Object> l;
                                        
                                                public ClassB() {
                                                    l = new ArrayList<Object>();
                                                }
                                        
                                                private void add(Class c, Object... params) throws Exception {
                                                    l.addAll(checkIn(c, params));
                                                }
                                        
                                                // here we can do a bunch of checks. Choose your own. It's just the entry gate
                                                private Collection<? extends Object> checkIn(Class c, Object... params) throws Exception {
                                                    if(params.length==1 && params[0].getClass().equals(c))
                                                        return Arrays.asList(params[0]);
                                                    //a bit ugly here. Something better can be done
                                                    if(params[0].getClass().equals(c)) {
                                                        return Arrays.asList(params);
                                                    }
                                                    throw new Exception("You shall not pass!");
                                                }
                                        
                                                public void addInt(I i) throws Exception {
                                                    add(i.getClass(), i);
                                                }
                                        
                                                public void addManyInts(I... i) throws Exception {
                                                    add(i[0].getClass(), i);
                                                }
                                        
                                                public void addString(S s) throws Exception {
                                                    add(s.getClass(), s);
                                                }
                                        
                                                public void addManyStrings(S... s) throws Exception {
                                                    add(s[0].getClass(), s);
                                                }
                                        
                                                public Object get(int i) {
                                                    return l.get(i);
                                                }
                                        
                                                public int size() {
                                                    return l.size();
                                                }
                                        
                                                private int getNumerOfNumbers() {
                                                    int r=0;
                                                    for(Object o:l) {
                                                        if(o instanceof Number)
                                                            r++;
                                                    }
                                                    return r;
                                                }
                                        
                                                // here we just want to do something more subtle than print
                                                public double getMean() throws Exception {
                                                    int sum = this.getNumerOfNumbers();
                                                    if(sum==0)
                                                        throw new Exception("Maybe you want numbers...");
                                                    double mean=0;
                                                    for(Object o:l) {
                                                        if(o instanceof Number) {
                                                            mean+=((Number)o).doubleValue()/sum;
                                                        }
                                                    }
                                                    return mean;
                                                }
                                        
                                            }
                                        
                                            public static void main(String[] args) throws Exception {
                                                ClassA a = new ClassA();
                                                a.doThings();
                                            }
                                        
                                            public void doThings() throws Exception {
                                                ClassB<Integer, String> maListeDeBidules = new ClassB<>();
                                                maListeDeBidules.addInt(1); // ok
                                                maListeDeBidules.addString("deux"); // ok
                                                maListeDeBidules.addManyInts(3,4,5,6,7,8); // ok
                                                maListeDeBidules.addManyStrings("neuf","dix","onze","douze","treize","quatorze"); // ok
                                                for(int i=0; i< maListeDeBidules.size(); i++)
                                                    System.out.println("mon bidule "+(i+1)+" : "+maListeDeBidules.get(i));      
                                                System.out.println("La moyenne dans ma liste de bidules est de : "+maListeDeBidules.getMean());
                                                // here we go!
                                                ClassB<Integer, String> maListeDeBidules2 = new ClassB<>();
                                                for(int i=0; i<10000000; i++)
                                                    maListeDeBidules2.addInt(i);        
                                            }
                                        }

                                        Et le tien que j'ai modifié un tout petit peu (le moins possible) pour faire un petit tour sur une grosse liste d'entiers.

                                        import java.util.ArrayList;
                                        import java.util.List;
                                        
                                        class ListeExtensible {
                                        
                                            interface MyStuff { 
                                                public void print();
                                            }
                                        
                                            class MyInt implements MyStuff {
                                                final int i;
                                                public MyInt(int i) {
                                                    this.i = i;
                                                }
                                                public void print() {
                                                    System.out.println(this.i);
                                                }
                                            }
                                        
                                            class MyString implements MyStuff {
                                                final String s;
                                                public MyString(String s) {
                                                    this.s = s;
                                                }
                                                public void print() {
                                                    System.out.println(this.s);
                                                }
                                            }
                                        
                                            public void doStuff() {
                                                List<MyStuff> maListe = new ArrayList<>();
                                                maListe.add(new MyInt(1));
                                                maListe.add(new MyString("hello"));
                                                for (MyStuff element : maListe) {
                                                    element.print();
                                                }
                                                List<MyStuff> maListe2 = new ArrayList<>();
                                                for(int i=0; i<10000000; i++)
                                                    maListe2.add(new MyInt(i));     
                                        
                                            }
                                        
                                            public static void main(String[] args) {
                                                ListeExtensible l = new ListeExtensible();
                                                l.doStuff();
                                            }
                                        }

                                        Alors maintenant on peut regarde ce qui se passe en mémoire :
                                        Mon code :

                                        Code_kaos

                                        Ton code :

                                        Code_autre

                                        Je sais pas si tu vois la petite subtile différence d'approche.

                                • [^] # Re: Typage

                                  Posté par  . Évalué à 1 (+0/-1).

                                  Salut,

                                  Comme tu as le courage de répondre, j'ai complété un peu les choses, modifié deux ou trois trucs, pour une nouvelle version.

                                  L'exo se complexifie, on ne fait plus de print (ça, c'est un peu trop facile), mais une moyenne (ça pourrait être du max, du min, peu importe).

                                  import java.util.ArrayList;
                                  import java.util.Arrays;
                                  import java.util.Collection;
                                  import java.util.List;
                                  
                                  public class ClassA {
                                  
                                      // here, you just say what types are accepted
                                      private class ClassB<I extends Integer, S extends String> {
                                          // it's a bit more wrapping, but for the fun
                                          private List<Object> l;
                                  
                                          public ClassB() {
                                              l = new ArrayList<Object>();
                                          }
                                  
                                          private void add(Class c, Object... params) throws Exception {
                                              l.addAll(checkIn(c, params));
                                          }
                                  
                                          // here we can do a bunch of checks. Choose your own. It's just the entry gate
                                          private Collection<? extends Object> checkIn(Class c, Object... params) throws Exception {
                                              if(params.length==1 && params[0].getClass().equals(c))
                                                  return Arrays.asList(params[0]);
                                              //a bit ugly here. Something better can be done
                                              if(params[0].getClass().equals(c)) {
                                                  return Arrays.asList(params);
                                              }
                                              throw new Exception("You shall not pass!");
                                          }
                                  
                                          public void addInt(I i) throws Exception {
                                              add(i.getClass(), i);
                                          }
                                  
                                          public void addManyInts(I... i) throws Exception {
                                              add(i[0].getClass(), i);
                                          }
                                  
                                          public void addString(S s) throws Exception {
                                              add(s.getClass(), s);
                                          }
                                  
                                          public void addManyStrings(S... s) throws Exception {
                                              add(s[0].getClass(), s);
                                          }
                                  
                                          public Object get(int i) {
                                              return l.get(i);
                                          }
                                  
                                          public int size() {
                                              return l.size();
                                          }
                                  
                                          private int getNumerOfNumbers() {
                                              int r=0;
                                              for(Object o:l) {
                                                  if(o instanceof Number)
                                                      r++;
                                              }
                                              return r;
                                          }
                                  
                                          // here we just want to do something more subtle than print
                                          public double getMean() throws Exception {
                                              int sum = this.getNumerOfNumbers();
                                              if(sum==0)
                                                  throw new Exception("Maybe you want numbers...");
                                              double mean=0;
                                              for(Object o:l) {
                                                  if(o instanceof Number) {
                                                      mean+=((Number)o).doubleValue()/sum;
                                                  }
                                              }
                                              return mean;
                                          }
                                  
                                      }
                                  
                                      public static void main(String[] args) throws Exception {
                                          ClassA a = new ClassA();
                                          a.doThings();
                                      }
                                  
                                      public void doThings() throws Exception {
                                          ClassB<Integer, String> maListeDeBidules = new ClassB<>();
                                          maListeDeBidules.addInt(1); // ok
                                          maListeDeBidules.addString("deux"); // ok
                                          maListeDeBidules.addManyInts(3,4,5,6,7,8); // ok
                                          maListeDeBidules.addManyStrings("neuf","dix","onze","douze","treize","quatorze"); // ok
                                          for(int i=0; i< maListeDeBidules.size(); i++)
                                              System.out.println("mon bidule "+(i+1)+" : "+maListeDeBidules.get(i));
                                          System.out.println("La moyenne dans ma liste de bidules est de : "+maListeDeBidules.getMean());
                                      }
                                  }

                                  J'ai suprimmé mon extends, comme ça, il n'y a que ce que j'expose qui est dispo. Dans la version précédente, j'avais commencé à préparer le boulot, tu vois que maintenant j'ai des méthodes avec varargs et du coup c'est assez pratique pour faire de l'ajout en masse.

                                  Voilà, comme tu m'a donné ta version des choses, j'ai pris un peu plus de temps pour t'en donner encore une autre ;)

                                  Pas sûr qu'elle te plaise toujours plus. Et c'est du POC, donc y'a certainement des choses à faire pour que ça marche mieux.

                                  • [^] # Re: Typage

                                    Posté par  (site Web personnel) . Évalué à 4 (+2/-0).

                                    Non seulement tu as des casts et des instanceOf, ce qui rend le code fragile, mais en plus l'utilisateur n'a plus de liste. Et comment tu ferais pour un Set? un ArrayList? un LinkedList? une HashMap? Tu vois pas un problème quelque part avec ta solution ?

                                    • [^] # Re: Typage

                                      Posté par  . Évalué à 1 (+0/-1).

                                      Salut,

                                      Non seulement tu as des casts et des instanceOf, ce qui rend le code fragile

                                      Juste à l'entrée, et dans le traitement si besoin est. Le reste ne bouge pas.

                                      mais en plus l'utilisateur n'a plus de liste.

                                      Ah bin je sais pas, il va falloir vous décider. D'un côté on me reproche d'avoir laissé la porte trop ouverte, de l'autre pas assez.

                                      Revenons-en à nos petite discutions tranquilles :

                                      • Un Set est une interface. Donc faut tout coder.
                                      • Une ArrayList ? T'as vu mes extends dans mes propositions initiales, ou c'est exprès ?
                                      • Une LinkedList ? une HashMap ? Là, pas compris le rapport avec la choucroute.
                                      • [^] # Re: Typage

                                        Posté par  (site Web personnel) . Évalué à 2 (+1/-1).

                                        Ma solution marche pour tous: Set, ArrayList, LinkedList, HashMap, etc. (Interface ou pas, les génériques acceptent mon type).
                                        La tienne a réinventé la roue pour la liste. Si demain il veux utiliser une autre collection, il n'a pas de solution avec ta librairie.

                                        Bref, Object, c'est mal, l'héritage (?) et l'Open-Closed, c'est bien.

                                        • [^] # Re: Typage

                                          Posté par  . Évalué à 2 (+0/-0).

                                          Salut,

                                          Ok. Je vais essayer faire quelque chose sur ce point, si c'est juste celui-là qui coince pour toi.

                                          J'ai déjà une idée, mais probablement pas géniale.

                                        • [^] # Re: Typage

                                          Posté par  . Évalué à 2 (+0/-0). Dernière modification le 15/07/20 à 08:18.

                                          Salut,

                                          Je suppose que tu vas toujours pas être content de ma solution, mais c'est pas grave.

                                          import java.util.ArrayList;
                                          import java.util.Arrays;
                                          import java.util.Collection;
                                          import java.util.Iterator;
                                          import java.util.LinkedList;
                                          import java.util.List;
                                          
                                          public class ClassA {
                                          
                                              // here, you just say what types are accepted
                                              private class ClassB<I extends Integer, S extends String> implements Iterable {
                                                  // it's a bit more wrapping, but for the fun
                                                  private Collection c;
                                          
                                                  public ClassB(Collection c) {
                                                      // we could do better, just a bit of safety here
                                                      if(!c.isEmpty())
                                                          c.clear();
                                                      this.c = c;
                                                  }
                                          
                                                  private void add(Class c, Object... params) throws Exception {
                                                      this.c.addAll(checkIn(c, params));
                                                  }
                                          
                                                  // here we can do a bunch of checks. Choose your own. It's just the entry gate
                                                  private Collection<Object> checkIn(Class c, Object... params) throws Exception {
                                                      if(params.length==1 && params[0].getClass().equals(c))
                                                          return Arrays.asList(params[0]);
                                                      //a bit ugly here. Something better can be done
                                                      if(params[0].getClass().equals(c)) {
                                                          return Arrays.asList(params);
                                                      }
                                                      throw new Exception("You shall not pass!");
                                                  }
                                          
                                                  public void addInt(I i) throws Exception {
                                                      add(i.getClass(), i);
                                                  }
                                          
                                                  public void addManyInts(I... i) throws Exception {
                                                      add(i[0].getClass(), i);
                                                  }
                                          
                                                  public void addString(S s) throws Exception {
                                                      add(s.getClass(), s);
                                                  }
                                          
                                                  public void addManyStrings(S... s) throws Exception {
                                                      add(s[0].getClass(), s);
                                                  }
                                          
                                                  public int size() {
                                                      return c.size();
                                                  }
                                          
                                                  private int getNumerOfBidules(Class c) {
                                                      int r=0;
                                                      for(Object o:this.c) {
                                                          if(c.isInstance(o))
                                                              r++;
                                                      }
                                                      return r;
                                                  }
                                          
                                                  public Collection filter(Class c) {
                                                      List r = new ArrayList();
                                                      for(Object o:this.c) {
                                                          if(c.isInstance(o))
                                                              r.add(o);
                                                      }
                                          
                                                      return r;
                                                  }
                                          
                                                  public Iterator iterator() {
                                                      return c.iterator();
                                                  }
                                              }
                                          
                                              public static void main(String[] args) throws Exception {
                                                  ClassA a = new ClassA();
                                                  a.doThings();
                                              }
                                          
                                              public void doThings() throws Exception {
                                                  ClassB<Integer, String> maListeDeBidules = new ClassB<>(new LinkedList());
                                                  maListeDeBidules.addInt(1); // ok
                                                  maListeDeBidules.addString("deux"); // ok
                                                  maListeDeBidules.addManyInts(3,4,5,6,7,8); // ok
                                                  maListeDeBidules.addManyStrings("neuf","dix","onze","douze","treize","quatorze"); // ok
                                                  int i = 0;
                                                  for(Object o:maListeDeBidules) {
                                                      System.out.println("mon bidule "+(i+1)+" : "+o);
                                                      i++;
                                                  }
                                                  System.out.println("La moyenne dans ma liste de bidules est de : "+this.getMean(maListeDeBidules));
                                                  // here we go!
                                                  ClassB<Integer, String> maListeDeBidules2 = new ClassB<>(new ArrayList());
                                                  for(i=0; i<10000000; i++)
                                                      maListeDeBidules2.addInt(i);
                                              }
                                          
                                              public double getMean(ClassB b) throws Exception {
                                                  Class c = Number.class;
                                                  int n = b.getNumerOfBidules(c);
                                                  if(n==0)
                                                      throw new Exception("Maybe you want numbers...");
                                                  double mean=0;
                                                  for(Object v:b.filter(c)) {
                                                      mean += ((Number)v).doubleValue()/n;
                                                  }
                                                  return mean;
                                              }
                                          
                                          }

                                          Voilà, c'est ok pour tout ce qui est collection.

                                          J'en ai profité pour retirer le calcul de la moyenne de ClassB (rien à faire là dedans).

                                          • [^] # Re: Typage

                                            Posté par  . Évalué à 2 (+0/-0).

                                            Salut,

                                            Ça me plaisait toujours pas trop, vu que le type est vérifié aux entrées de fonctions, donc encore une autre version :(

                                            import java.util.ArrayList;
                                            import java.util.Arrays;
                                            import java.util.Collection;
                                            import java.util.Iterator;
                                            import java.util.LinkedList;
                                            import java.util.List;
                                            
                                            public class ClassA {
                                            
                                                // here, you just say what types are accepted
                                                private class ClassB<I extends Integer, S extends String> implements Iterable {
                                                    // it's a bit more wrapping, but for the fun
                                                    private Collection c;
                                            
                                                    public ClassB(Collection c) {
                                                        // we could do better, just a bit of safety here
                                                        if(!c.isEmpty())
                                                            c.clear();
                                                        this.c = c;
                                                    }
                                            
                                                    private void add(Object... params) throws Exception {
                                                        this.c.addAll(checkIn(params));
                                                    }
                                            
                                                    private Collection<Object> checkIn(Object... params) throws Exception {
                                                        // here we can do a bunch of checks. Choose your own. It's just the entry gate
                                                        if(params.length==0)
                                                            throw new Exception("You shall not pass!");
                                                        return Arrays.asList(params);           
                                                    }
                                            
                                                    public void addInt(I i) throws Exception {
                                                        add(i);
                                                    }
                                            
                                                    public void addManyInts(I... i) throws Exception {
                                                        add(i);
                                                    }
                                            
                                                    public void addString(S s) throws Exception {
                                                        add(s);
                                                    }
                                            
                                                    public void addManyStrings(S... s) throws Exception {
                                                        add(s);
                                                    }
                                            
                                                    private int getNumerOfBidules(Class c) {
                                                        int r=0;
                                                        for(Object o:this.c) {
                                                            if(c.isInstance(o))
                                                                r++;
                                                        }
                                                        return r;
                                                    }
                                            
                                                    public Collection<Object> filter(Class c) {
                                                        List<Object> r = new ArrayList<Object>();
                                                        for(Object o:this.c) {
                                                            if(c.isInstance(o))
                                                                r.add(o);
                                                        }
                                                        return r;
                                                    }
                                            
                                                    public Iterator iterator() {
                                                        return c.iterator();
                                                    }
                                                }
                                            
                                                public static void main(String[] args) throws Exception {
                                                    ClassA a = new ClassA();
                                                    a.doThings();
                                                }
                                            
                                                public void doThings() throws Exception {
                                                    ClassB<Integer, String> maListeDeBidules = new ClassB<>(new LinkedList());
                                                    maListeDeBidules.addInt(1); // ok
                                                    maListeDeBidules.addString("deux"); // ok
                                                    maListeDeBidules.addManyInts(3,4,5,6,7,8); // ok
                                                    maListeDeBidules.addManyStrings("neuf","dix","onze","douze","treize","quatorze"); // ok
                                                    int i = 0;
                                                    for(Object o:maListeDeBidules) {
                                                        System.out.println("mon bidule "+(i+1)+" : "+o);
                                                        i++;
                                                    }
                                                    System.out.println("La moyenne dans ma liste de bidules est de : "+this.getMean(maListeDeBidules));
                                                    // here we go!
                                                    ClassB<Integer, String> maListeDeBidules2 = new ClassB<>(new ArrayList());
                                                    for(i=0; i<10000000; i++)
                                                        maListeDeBidules2.addInt(i);
                                                }
                                            
                                                public double getMean(ClassB<Integer, String> b) throws Exception {
                                                    Class<Number> c = Number.class;
                                                    int n = b.getNumerOfBidules(c);
                                                    if(n==0)
                                                        throw new Exception("Maybe you want numbers...");
                                                    double mean=0;
                                                    for(Object v:b.filter(c)) {
                                                        mean += ((Number)v).doubleValue()/n;
                                                    }
                                                    return mean;
                                                }
                                            }
                                            • [^] # Re: Typage

                                              Posté par  . Évalué à 2 (+0/-0). Dernière modification le 15/07/20 à 12:59.

                                              Salut,

                                              Comme ça me plaisait toujours toujours pas, j'ai fait du golfing (même si je sais que tu as demandé que ça soit pas la règle).

                                              complètement foiré mon truc, donc je vire

                                              On commence à y voir plus clair, même si ce n'est pas parfait.

                                              Merci de m'avoir motivé !

                                              • [^] # Re: Typage

                                                Posté par  . Évalué à 2 (+0/-0).

                                                Re-salut,

                                                Bien désolé pour l'implémentation moisie précédente pas bien vérifiée :( Et peut-être pour mon insistance/lourdeur.

                                                Mais j'aime bien les retours, et t'y vas assez cordialement :) (même si tu prends pas des pincettes, mais moi non plus…)

                                                import java.util.ArrayList;
                                                import java.util.Arrays;
                                                import java.util.Collection;
                                                import java.util.Iterator;
                                                import java.util.LinkedList;
                                                import java.util.List;
                                                
                                                public class ClassA {
                                                
                                                    // here, you just say what types are accepted
                                                    private class ClassB<I extends Integer, S extends String> implements Iterable {
                                                        // it's a bit more wrapping, but for the fun
                                                        private Collection c;
                                                
                                                        public ClassB(Collection c) {
                                                            // we could do better, just a bit of safety here
                                                            if(!c.isEmpty())
                                                                c.clear();
                                                            this.c = c;
                                                        }
                                                
                                                        private void add(Object... params) throws Exception {
                                                            this.c.addAll(checkIn(params));
                                                        }
                                                
                                                        private Collection<Object> checkIn(Object... params) throws Exception {
                                                            // here we can do a bunch of checks. Choose your own. It's just the entry gate
                                                            if(params.length==0)
                                                                throw new Exception("You shall not pass!");
                                                            return Arrays.asList(params);           
                                                        }
                                                
                                                        // do type checking here
                                                        public <T extends I> void addBidules(T... t ) throws Exception {
                                                            this.add(t);
                                                        }
                                                
                                                        public <T extends S> void addBidules(T... t ) throws Exception {
                                                            this.add(t);
                                                        }
                                                
                                                        private int getNumerOfBidules(Class c) {
                                                            int r=0;
                                                            for(Object o:this.c) {
                                                                if(c.isInstance(o))
                                                                    r++;
                                                            }
                                                            return r;
                                                        }
                                                
                                                        public Collection<Object> filter(Class c) {
                                                            List<Object> r = new ArrayList<Object>();
                                                            for(Object o:this.c) {
                                                                if(c.isInstance(o))
                                                                    r.add(o);
                                                            }
                                                            return r;
                                                        }
                                                
                                                        public Iterator iterator() {
                                                            return c.iterator();
                                                        }
                                                    }
                                                
                                                    public static void main(String[] args) throws Exception {
                                                        ClassA a = new ClassA();
                                                        a.doThings();
                                                    }
                                                
                                                    public void doThings() throws Exception {
                                                        ClassB<Integer, String> maListeDeBidules = new ClassB<>(new LinkedList());
                                                        maListeDeBidules.addBidules(1); // ok
                                                        maListeDeBidules.addBidules("deux"); // ok
                                                        maListeDeBidules.addBidules(3,4,5,6,7,8); // ok
                                                        maListeDeBidules.addBidules("neuf","dix","onze","douze","treize","quatorze"); // ok
                                                        int i = 0;
                                                        for(Object o:maListeDeBidules) {
                                                            System.out.println("mon bidule "+(i+1)+" : "+o);
                                                            i++;
                                                        }
                                                        System.out.println("La moyenne dans ma liste de bidules est de : "+this.getMean(maListeDeBidules));
                                                        // here we go!
                                                        ClassB<Integer, String> maListeDeBidules2 = new ClassB<>(new ArrayList());
                                                        for(i=0; i<10000000; i++)
                                                            maListeDeBidules2.addBidules(i);
                                                    }
                                                
                                                    public double getMean(ClassB<Integer, String> b) throws Exception {
                                                        Class<Number> c = Number.class;
                                                        int n = b.getNumerOfBidules(c);
                                                        if(n==0)
                                                            throw new Exception("Maybe you want numbers...");
                                                        double mean=0;
                                                        for(Object v:b.filter(c)) {
                                                            mean += ((Number)v).doubleValue()/n;
                                                        }
                                                        return mean;
                                                    }
                                                }

                                                Donc voilà, que pense-tu de cette solution ?

                                                Il y a probablement plein de trucs à faire pour rendre ça exploitable (les throws Exception et plein d'autres trucs sûrement).

                • [^] # Re: Typage

                  Posté par  . Évalué à 1 (+0/-1).

                  Salut,

                  Même punition ;)

                  "Comment mélange-t-on des entiers et des chaînes dans une liste en Java ?" -> On ne le fait pas, ou alors on créée une liste d'objets "EntierOuChaîne". C'est à la fois plus dur, et la manière la plus simple.

                  Si tu me sors un truc plus concis et simple que ma proposition, je m'incline bien bas.

                  • [^] # Re: Typage

                    Posté par  (site Web personnel) . Évalué à 6 (+4/-0).

                    Alors, "concis", c'est pas la bonne métrique. Si t'as envie de jouer au golfe, tant mieux. Mais je n'ai aucune envie de maintenir du code qui préfère la concision (et les potentiels bugs à l'execution) simplement car c'est concis. Tu veux un containeur qui contient tes objets spécifiques, et rien d'autre, mais qui soit extensible sans aucun changement.

                    import java.util.ArrayList;
                    import java.util.List;
                    
                    class ListeExtensible {
                    
                        interface MyStuff { 
                            public void print();
                        }
                    
                        class MyInt implements MyStuff {
                            final int i;
                            public MyInt(int i) {
                                this.i = i;
                            }
                            public void print() {
                                System.out.println(this.i);
                            }
                        }
                    
                        class MyString implements MyStuff {
                            final String s;
                            public MyString(String s) {
                                this.s = s;
                            }
                            public void print() {
                                System.out.println(this.s);
                            }
                        }
                    
                        public void doStuff() {
                            List<MyStuff> maListe = new ArrayList<>();
                            maListe.add(new MyInt(1));
                            maListe.add(new MyString("hello"));
                            for (MyStuff element : maListe) {
                                element.print();
                            }
                        }
                    
                        public static void main(String[] args) {
                            ListeExtensible l = new ListeExtensible();
                            l.doStuff();
                        }
                    }

                    Pas besoin de casts (vu qu'on ne retourne jamais "Object"), on ne peut pas avoir d'erreur à l'exécution, et on peut ajouter autant de nouveau sous-types qu'on veut sans qu'on doive modifier aucun code existant. C'est, je crois, la manière de s'y prendre en Java. Alors, oui, c'est plus compliqué que Python, mais c'est ainsi. Language différent, paradigme différent.

                    • [^] # Re: Typage

                      Posté par  . Évalué à 2 (+0/-0). Dernière modification le 14/07/20 à 08:02.

                      Salut,

                      Approche plus intéressante que ce que je pensais quand tu parlais d'objet EntierOuChaine.

                      Merci.

                      • [^] # Re: Typage

                        Posté par  (site Web personnel) . Évalué à 3 (+1/-0).

                        Si le contexte est connu et n'est pas exposé par l'API, alors tu peux faire

                        final Class AouB {
                        private Type typ;
                        private final Optional<A> a;
                        private final Optional<B> B;
                        private print() {
                        switch (typ):
                        case Type.A: a.print(); break;
                        case Type.B: b.print(); break;
                        }
                        }

                        Et utiliser des sous classes ou une factory pour créer des objets de type AouB, mais ça n'est pas extensible par un utilisateur.

                        Au final, le truc, c'est qu'en Python, tu peux mettre n'importe quoi dans ta liste, et au final, tu peux avoir des erreurs de type à l'execution. En Java, il faut faire exprès pour se donner se problème, et c'est probablement une bonne idée de ne pas programmer ainsi. Tant pis si Python est plus facile et court à écrire.

                        • [^] # Re: Typage

                          Posté par  . Évalué à 1 (+0/-1).

                          Salut,

                          D'accord, pourquoi pas.

                          Mais j'espère que tu as vu ;)

                          Maintenant, je te demande plus du print() -ça c'est ok pour un hello world- mais une moyenne sur la liste (enfin moyenne, min, max, peu importe).

                          Ça m'intéresse vraiment de savoir comment tu vas t'en tirer, si tu as le temps :)

                          • [^] # Re: Typage

                            Posté par  (site Web personnel) . Évalué à 3 (+1/-0). Dernière modification le 14/07/20 à 22:25.

                            Ca n'a pas de sens. Si je dois calculer la moyenne sur une liste qui ne contient pas que des nombres, alors soit j'ai mal designé mon architecture, soit je fais

                            interface MyStuff {
                              public Optional<Integer> toInt();
                            }

                            Et le reste devient

                            int result = 0;
                            for (MyStuff stuff : mystuff) {
                                result += stuff.toInt().orElse(0);
                              }
                            }

                            C'est propre et facile à comprendre.

                            • [^] # Re: Typage

                              Posté par  . Évalué à 1 (+0/-1).

                              Salut,

                              Ça c'est une somme.

                              Pas une moyenne :)

                            • [^] # Re: Typage

                              Posté par  . Évalué à 1 (+0/-1).

                              Re-salut,

                              Je reviens juste sur ce point. Désolé de t'envoyer autant de messages. :(

                              Mais comme tu prend le temps de répondre (et plutôt agréablement) :

                              Si je dois calculer la moyenne sur une liste qui ne contient pas que des nombres, alors soit j'ai mal designé mon architecture

                              Hey, mais c'est pas moi qui pose cette contrainte à la base, c'est l'OP :(

                              Par ailleurs, dans mon métier, j'en ai vu plein des tableaux faits à la va-vite sous excel qui contiennent du coup dans une seule colonne un peu de types mixés et qu'il faut quand-même traiter.

                              Je ne parle même pas des formules dans des cellules, là, j'abandonne.

                              • [^] # Re: Typage

                                Posté par  (site Web personnel) . Évalué à 2 (+0/-0).

                                C'est toi qui a inventé l'histoire de moyenne. Il a juste écrit :

                                Mais pour les listes java semble un peu lourd. Mon exercice est simple, j'ai une liste t1 [1,2,3,4] et une liste t2 ["lundi","mardi","mercredi","jeudi"] et je veux créer une liste t3 [1,"lundi",2,"mardi",3,"mercredi",4,"jeudi"] à partir de t1 et t2.

                                Bref, pour faire simple: avec tes solutions, tu ne serais pas embauché chez du GAFA. C'est hyper long, hyper complexe, et fragile.

                                Encore une fois. Python, Java, et Excel, c'est pas la même chose. Il a des règles à suivre pour assurer la qualité du code, des règles qui ont été découvertes empiriquement depuis des dizaines d'années. "Je peux le faire" est différent de "c'est une bonne idée".
                                Relis ton code, relis le mien, et demande-toi "si je devais maintenir ce code et corriger un bug à 3h du mat quand des millions d'utilisateurs ne peuvent plus utiliser mon service, lequel choisirai-je ?" C'est mon job, et le choix est vite fait…

                                • [^] # Re: Typage

                                  Posté par  . Évalué à 1 (+0/-1). Dernière modification le 15/07/20 à 16:20.

                                  Salut,

                                  C'est toi qui a inventé l'histoire de moyenne.

                                  En effet. Ce n'était pas dans la question de l'OP.

                                  Avec tes solutions, tu ne serais pas embauché chez du GAFA.

                                  Tant mieux, aucune prétention d'aller sur ce marché.

                                  Relis ton code, relis le mien

                                  Oui, c'est fait, j'ai golfé un peu (même si je sais que tu n'en as pas envie) pour que ça soit plus concis et du coup assez facile à maintenir.

                                  Le problème de ton code (mais je l'ai déjà dit) : t'explose les références objet avec ton encapsulation.

                                  Donc si t'as des millions d'utilisateurs, ça va être gênant.

        • [^] # Re: Typage

          Posté par  . Évalué à 1 (+0/-1).

          Salut,

          Et comme j'ai l'impression que c'est pas fini : generics en java

          Voilà. Pas mal de lecture à faire ;)

  • # arf

    Posté par  . Évalué à 1 (+0/-0).

    salut,
    merci pour le débat entre spécialistes.
    en fait j'ai écrit un programme en python et je veux le traduire en java car je voudrais en faire une appli android qui utilise le java..
    Et créer pleins de classes, je trouve ca lourd, mais visiblement java fonctionne un peu comme ca.
    Ce qui est plus problématique,c'est que lorsque le code de java bugue, il indique pas toujours précisement d'où vient l'erreur, donc je préfere apprendre avec les "bonnes manieres" si possible.
    pour le boxing le cours d'openclassroom en parle un peu.

    Sinon, vous avez une recommendation pour un ouvrage "de référence" pour bien apprendre le java?

    • [^] # Re: arf

      Posté par  . Évalué à 1 (+0/-0).

      parce que bon, java cest vraiment lourd..pour calculer le max dans un array il faut importer des modules ou se taper l'écriture d'une fonction..
      idem si on veut juste afficher le contenu d'une colonne d'un array.
      tres lourd.
      j'aurais besoin d'un bon document pour apprendre les "trucs" qui facilitent la vie dans ce langage

      • [^] # Re: arf

        Posté par  . Évalué à 2 (+0/-0).

        Salut,

        Bien désolé pour les messages qui s’enchaînent plus haut.

        java cest vraiment lourd

        Nope, pas avec un bon IDE et une compréhension du langage.

        Il y a des contraintes, peut-être plus fortes que dans d'autres langages, mais c'est pour le bien.

        Alors oui, parfois ça demande de rajouter un peu de choses, de les enrober. Surtout au début.

        Mais voilà, il faut se dire que c'est pour son bien :)

        • [^] # Re: arf

          Posté par  . Évalué à 1 (+0/-0).

          je suis quand meme un peu inquiet. je fais des trucs ultra basique et java n'arrête pas de bugguer :

          Sur le code suivant que j'ai trouvé en ligne, pour convertir des array en arraylist (afin de faire des tris ou des opérations dessus):

          import java.util.ArrayList;
          import java.util.Arrays;
          import java.util.Collections;
          import java.util.List;
          
          public class Tester {
             public static void main(String args[]) {
                String[] array = {"a", "b", "c", "d", "e"};
          
                //Method 1
                List<String> list = Arrays.asList(array);          
                System.out.println(list);
          
                        list.add("f");
          

          --> bug "at java.base/java.util.AbstractList.add"

                //Method 2
                List<String> list1 = new ArrayList<String>();
                Collections.addAll(list1, array);
                System.out.println(list1);
          

          --> bug "ArrayList cannot be resolved to a type"
          ```

            //Method 3
            List<String> list2 = new ArrayList<String>();
            for(String text:array) {
               list2.add(text);
            }
            System.out.println(list2);
          

          ```--> bug "ArrayList cannot be resolved to a type"

          }

          }

          • [^] # Re: arf

            Posté par  . Évalué à 1 (+0/-0).

            apparemment seulement un oubli de import java.util.ArrayList;

            • [^] # Re: arf

              Posté par  . Évalué à 2 (+0/-0).

              Salut,

              Je ne sais pas quel IDE tu utilise, mais ça, même avant compilation, il devrait le détecter.

  • # comparaison entre object d'une meme liste

    Posté par  . Évalué à 1 (+0/-0). Dernière modification le 13/07/20 à 13:36.

    j'utilise eclipse

    Alors je continue ma découverte du monde merveilleux des collections en java.

    jai une petite erreur apres conversion d'un array en liste.

    Syntax error, insert "Dimensions" to complete ReferenceType
    Apparemment c'est parce que je cherchais à convertir un int[] array en List qu'il faut déclarer en List pour une sombre histoire de wrapper.
    Bon ok. Mais maintenant quand je veux comparer un int d'un tableau de int avec un Integer de ma liste converti, il me sort une autre erreur :
    The type of the expression must be an array type but it resolved to List
    Et c'est pareil si je déclare ma liste en List
    Non mais ca veut dire qu'il faut convertir tous mes array en liste, comparer les liste entre elles, puis reconvertir mes listes en tableaux si nécessaire?

    • [^] # Re: comparaison entre object d'une meme liste

      Posté par  . Évalué à 2 (+0/-0). Dernière modification le 13/07/20 à 14:16.

      Salut,

      j'utilise eclipse

      Ok, c'est celui que j'utilise aussi. Mais il y en a d'autres.

      Je laisse les afficionados de jetbrain te parler leur outil préféré :)

      Bon ok. Mais maintenant quand je veux comparer un int d'un tableau de int avec un Integer de ma liste converti, il me sort une autre erreur

      C'est juste pas possible de faire ça en une instruction en java :)

      • [^] # Re: comparaison entre object d'une meme liste

        Posté par  . Évalué à 1 (+0/-0).

        y a quand meme pas mal de subtilités dans la façon dont java organise ses classes et ses génériques qu'il faudrait que je vois de façon ordonné dans un bon bouquin pour apprendre correctement..
        j'ai fait les 3 premiers niveau de france-ioi, j'ai repris les exercices python de swinnen en java mais je n'ai pas les explications et la façon de faire quand je suis coincé.

        je me rappelle en prépa, les cours de physique, on avait un bouquin deboeck de référence qui était le graal quand on comprenait pas bien quelque chose car cetait bien expliqué avec de bon exos corrigés et il y avait tout.

        Quelqu'un aurait l'équivalent pour apprendre le java (débutant/intermédiaire)?

        • [^] # Re: comparaison entre object d'une meme liste

          Posté par  . Évalué à 2 (+0/-0).

          Salut,

          Oublie les génériques, c'est une fausse piste pour un début d'apprentissage. C'est compliqué de bien les gérer.

          Que ce soit java, R, python, et pour aller plus loin php, perl, lush : une seule référence, la doc.

Envoyer un commentaire

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n’en sommes pas responsables.