ArrayList<Integer> est-il un objet ?

Version imprimable

05/02/2015, 19h49
Invité

ArrayList<Integer> est-il un objet ?

Bonjour et merci d'avance pour ceux qui répondront

Je vous explique mon souci le plus simplement possible.

Je parcours ma Base de donnée sqlLite dans une AsyncTask jusque la pas de souci.

J'enregistre mes données qui sont des int dans une ArrayList<Integer> lors de l'execution de la méthode doInBackGround()

Puis j'appelle la méthode publishProgess(tableau) dans laquelle je passe mon ArrayList.

Mais le souci vient ici.

Lorsque dans ma méthode publishProgress(ArrayList... values) je fais une chose simple comme: int addition = 1+ values[0].get(0);

il me dit que values[0].get(0) est un objet et qu'il ne peut pas additionner???

Pourtant values[0] devrait correspondre à mon ArrayList et get(0) a la première position.

Pourquoi ne me retourne-t-il pas l'Integer contenu dans mon ArrayList ?? et à quel moment le contenu de mon ArrayList est il devenu un objet??

Merci
05/02/2015, 20h29
wax78

Un bout de code serait utile. En plus tu ne parles pas de tableau et tu sembles vouloir les utiliser.
05/02/2015, 21h56
Hephaistos007

Essayes avec des parenthèses : (values[0]).get(0);
06/02/2015, 03h11
nicroman

Essaye surtout de type ArrayList dans le publishProgress

Sans typage, c'est comme si on avait "<Object>"
ArrayList ... values === ArrayList<Object> ... values

Dit que "values" est une array d'objets "ArrayList<Object>"
values[0] est donc un objet "ArrayList<Object>"
values[0].get(0) est donc un Object

et pas un Integer.

Normalement le compilateur devrait mettre un gros warning là dessus....

D'autre part, même avec des ArrayList<Integer> ... values je recommande de faire en sorte que le compilateur affiche un warning pour "auto-unboxing".

En effet:
int addition = 1+ values[0].get(0);

C'est l'équivalent de:
int addition = 1 + values[0].get(0).intValue();

Enfin... je me demande si c'est bien raisonnable de passer tout ça à publishProgress....
On ne sait pas trop quand le onProgress sera appelé (peut-être jamais ?)
Les objets doivent être clonés (le onProgress peut s'executer pendant que le doInBackground modifie les objets originels).
Bref tout un tas de truc bizarre.

Et si le onProgress fait int addition = 1 + .... ;
Autant le faire dans le doInBackground et passer des "int ... values" en progress non ?

Merci pour vos réponses. Cependant il me semble que l'on peut appeler la méthode onProgressUpdate n'importe quand lorsqu'on utilise la méthode publishProgress();

Voici pour le bout de code, afin de mieux comprendre, j'essaie de faire le traitement des données, qui sont dans la base de données dans une tâche en arrière plan et de retourner deux tableau et ensuite de faire la partie affichage (affichage des données sous forme de graphique)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
class RunDataBase extends AsyncTask<Context,ArrayList,Boolean>{
        
        //référence faible à l'activité
        private WeakReference<Stats> mStats = null;
        Context context;

        public RunDataBase(Stats statsActivity){
            link(statsActivity);
        }

        @Override
        protected void onPreExecute () {
            // Au lancement, on ne fait rien
        }

        //méthode qui effectue les tâches en background, aucune tâche n'est executée dans l'UI Thread dans cette méthode
        @Override
        protected Boolean doInBackground(Context... params) {
            try{
                ArrayList<Integer> tabStatsComplet = new ArrayList<Integer>();

                ArrayList<Integer> tabNbrJours = new ArrayList<Integer>();

                //Utilitaire pour trouver combien de ligne comporte la base de données
                DatabaseUtils dataUtils = new DatabaseUtils();
                nbrRow = dataUtils.queryNumEntries(jourdb.getBDD(),TABLE);

                //On parcourt tout le tableau des niveaux
                for (int i = 0; i < tab.length; i++) {

                    //on définit le niveau en cours
                    float niveau = tab[i];

                    //on récupère le nombre de jour du niveau
                    int nbrOfDays  = jourdb.getAllLevelDays(niveau);

                    //ajout du nombre de jour au tableau
                    tabNbrJours.add(nbrOfDays);

                    //on parcourt tout les jours du niveau pour trouver la somme de traction effectuée
                    for (int j = 1; j < nbrOfDays+1; j++) {
                        
                        //on prend le jour i
                        Jours jour = jourdb.getJoursWithIDAndLevel(j,niveau);

                        //on ajoute la somme de traction dans un tableau
                        tabStatsComplet.add(jour.getTotal());

                    }

                }
                
                //on appelle la méthode onProgress
                publishProgress(tabStatsComplet, tabNbrJours); //On passe ici les deux arrayList à la méthode onProgress

                return true;

            }catch(Exception e){
                Log.w("Erreur", e.getMessage().toString());
                return false;
            }
        }

        @Override
        protected void onProgressUpdate(ArrayList... values) {
            super.onProgressUpdate(values);

            //on doit appeler la méthode pour construire les graphiques
            ArrayList<BarEntry> entries = new ArrayList<BarEntry>();

            int indexOftabAllPullUp = 0;

            //pour chaque niveau nous faisons
            for(int i = 0 ; i < tab.length; i++){

                //pour chaque niveau nous parcourons le nombre de jour dans ce niveau
                int nbrDeJours = values[1].get(0);   //values[1] ici devrait être = au second tableau


                //ArrayList pour l'axe des X
                ArrayList<String> m = new ArrayList<String>();

                //ici la boucle pour parcourir le nombre de jours
                for(int j = 0 ; j < nbrDeJours; j++ ){

                    entries.add(new BarEntry(values[0].get(indexOftabAllPullUp), j)); //ici je souhaite ajouter le int contenu dans le premier tableau, mais j'ai une erreur qui me dit qu'il souhaite un int et non un Objet

                    //on augemente l'index chauque fois que l'on rajoute un jour
                    indexOftabAllPullUp++;

                    //Ajoute les valeurs a l'axe X
                    m.add(""+j+1);
                }//for j


                BarDataSet d = new BarDataSet( entries, "Niveau " + tab[i]);
                d.setBarSpacePercent(20f);

                if(compteur == 1){
                    d.setColor(getResources().getColor(R.color.action_bar));
                    compteur = 0;
                }//if
                else{
                    d.setColor(getResources().getColor(R.color.bg));
                    compteur = 1;
                }//else

                //couleur du fond de la barre
                d.setBarShadowColor(Color.rgb(203, 203, 203));

                ArrayList<BarDataSet> sets = new ArrayList<BarDataSet>();
                sets.add(d);

                BarData cd = new BarData(m, sets);

                //ajoute le graph à la listView
                list.add(cd);
        }

        @Override
        protected void onPostExecute (Boolean result) {
                if(result){
                    jourdb.close();
                }
                else{
                    Toast.makeText(mStats.get(), "Erreur dans l'affichage des statistiques", Toast.LENGTH_SHORT).show();
                }

        }

        public void link(Stats statsActivity){
            mStats = new WeakReference<Stats>(statsActivity);
        }



    }//class statique RunDataBAse

Oui...

Mais c'est ce que je disais... c'est faux dans la manière d'appréhender le publishProgress / onProgressUpdate.

Je m'explique...
Tu passes 2 objets, ces objets sont *statiques* (dans le sens on tu ne passe pas une copie de ces objets).

Imaginons la séquence suivante:
Code:

1 2 3 4 5 6 7 8 9 10 1. Couleur objet1 = new Couleur(blanc); 2. Couleur objet2 = new Couleur(blanc); 3. publishProgress(objet1,objet2); 4. objet1.set(vert); 5. publishProgress(objet1,objet2); 6. objet2.set(bleu); 7. publishProgress(objet1,objet2); 8. objet1.set(rouge); 9. publishProgress(objet1,objet2);
Tu t'attends à recevoir dans le onProgressUpdate:
(blanc,blanc)
(vert,blanc)
(vert,bleu)
(rouge,bleu)

Mais si l'appel à onProgressUpdate est fait entre 4 et 5 par exemple...
Le premier appel à onProgressUpdate recevra (vert,blanc).
Si le second (et ultime parce que le système a décidé que ça ne valait pas le coup d'appeler plus souvent) se produit entre 8 et 9, il recevra (rouge,bleu).

1. C'est dangereux (ArrayList n'est *pas* protégé contre les accès concurrents, et donc il est possible de se retrouver avec un count qui ne match pas l'array, ou une array qui est "ancienne" si une réallocation a été faite).

2. Dans le cas présent, le publishProgress n'est appelé qu'à la fin du traitement, donc complètement inutile... L'interêt de publishProgress est de fournir à l'utilisateur des informations *pendant* le déroulement de l'opération. Donc complètement inutile ici...

Je pense que l'idéal, est de faire l'ensemble des opérations (y compris sur la liste) dans le doInBackground.
et dans le onPostExecute, notifier la list-view que la liste a été modifiée (notifyDataChanged)

11/02/2015, 18h41
Invité

Merci pour ton aide, je n'avais pas compris cela comme ça. Du coup le publishProgress n'est pas forcement appelé quand on lui dit. Dommage!

Ta solution était celle que j'avais adoptée au début. Mon code était dans le doInBackground, mais étant donné qu'il modifiait l'apparence / UI thread, impossible de lancer l'Intent.

C'est pour cela que j'ai séparer, la tâche d'ajout dans l'Array list de la modification/apparence de l'Intent.

Du coup est-ce-que y a-t-il un moyen pour effectuer les tâches de modification d'apparence dans le doInBackground?? Avec un handler peut-être ou dans la méthode onPostExecute??
12/02/2015, 13h35
nicroman

Oui ... le onPostExecute est là pour ça.

Dans le thread UI on a 3 fonctions:
onPreExecute est appelée juste avant que doInBackground ne démarre.
onProgressUpdate est appelée "quand nécessaire" après un appel à publishProgress durant doInBackground.
onPostExecute est appelée juste après que doInBackground soit terminée.