_kaos_ a écrit 2344 commentaires

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.

Matricule 23415

Salut,

Ça c'est une somme.

Pas une moyenne :)

Matricule 23415

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).

Matricule 23415

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.

Matricule 23415

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 :

Ton code :

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

Matricule 23415

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 :)

Matricule 23415

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.

Matricule 23415

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 ;)

Matricule 23415

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.

Matricule 23415

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 !

Matricule 23415

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 !

Matricule 23415

Salut,

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

Merci.

Matricule 23415

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.

Matricule 23415

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 :)

Matricule 23415

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.

Matricule 23415

Salut,

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

Matricule 23415

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
    }   
}

Matricule 23415

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).

Matricule 23415

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.

Matricule 23415

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.

Matricule 23415

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 :)

Matricule 23415

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.

Matricule 23415

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.

Matricule 23415

Salut,

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

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

Matricule 23415

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 ?

Matricule 23415