Stocker des ArrayList dans une ArrayList

Bonjour à Tous :yaisse2:

J'ai un probleme avec le stockage dans une ArrayList. En effet j'essaye de stocker dans une ArrayList d'autre ArrayList, a l'insertion tout fonctionne bien (normal) mais mon probleme survient au moment de l'extraction ! :(

J'utilise une itérator pour parcourir la liste puis je récupere l'objet avec la méthode Iterator.next(), je caste ensuite en ArrayList , mais la nouvelle ArrayList que je récupère est vide !!!.:evilred:

ca donne quelque chose comme ca :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 private void fillTestedCity(ArrayList testedprc) { testedCity.clear(); Iterator i = testedprc.iterator();//testedprc contient uniquement des ArrayList ! while (i.hasNext()) { ArrayList l = (ArrayList) i.next(); //ça, ça ne marche pas ! ArrayList l = new ArrayList((ArrayList) i.next()); // et ça non plus if (l.isEmpty()) // dans les 2 cas l est toujours vide !! System.out.println("WARNING !!"); displaylist(l); if (isSame(l)) { forbiddenValue(l); } } }
Voila, si quelqu'un a une idée ou me donner une indication je lui en serait très reconnaissant.:D

Un conseil qui te sera fort utile si tu cherches à faire ce genre de choses est d'utilisée le typage des collections (java 1.5 et sup.) qui t'évitera de caster
Code:

1 2 3 4 5 6 7 8 9 private void fillTestedCity(ArrayList<ArrayList> testedprc) { for(ArrayList liste : testedprc) { liste.ceQueTuVeux(); } }

euh...
Ce que tu m'as indiquer me permet de faire par exemple :

Code:

ArrayList l = i.next();

sans avoir a caster, c'est bien ça ??

j'ai essayer, mais mon probleme est toujours le meme...,
la liste que je récupère est toujours vide...

Bonjour.
D'abord, mieux vaut passer par les interfaces (List) au lieu des implémentations (ArrayList).
Ensuite, qui te dit que tu as bien remplie tes listes ? :aie:
Veux tu nous montrer comment t'as fait, histoire d'éclaircir ce point ?

Salut,

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
	List<List> temp=new ArrayList<List>();
 
	List<Integer> test=new ArrayList<Integer>();
	List<Integer> test2=new ArrayList<Integer>();
	for(int i=0;i<10;i++)
	    {
		test.add(i);
		test2.add(i*10);
	    }
 
	temp.add(test);
	temp.add(test2);
 
	System.out.println(test.size()+"  "+test2.size());
	//System.out.println(temp.get(0).size()+"  "+temp.get(1).size());
	Iterator<List> it=temp.iterator();
	while(it.hasNext())
	    {
		System.out.println(it.next().size());
	    }

Ce code m'affiche bien mes Listes avec les 10 elements dedans :

Citation:

10 10
10
10

Es-tu sûr que tu remplis bien tes Listes ?

Cordialement

Fred

je vais vérifier le bon remplissage des listes mais théoriquement elle sont bien remplies,

je vous donne ce que j'ai fait, il s'agit de creer un algorithme pour le Trading Salesman Probleme afin d'en mesurer la complexité.
il y a plusieurs classes, et je n'ai pas encore eu le temps de faire la doc...enfin vous verrez...

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
/*
 * ville.java
 *
 * Created on 19 novembre 2007, 12:05
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
 
package tsp;
 
/**
*Cette classe définit une ville par des coordonnées dans un plan et un nom.
*
*@since 18/11/07
*@version 1.0 11/07
* @author LEFEBVRE
*/
public class ville {
 
 
	private int x;
	private int y;
	private String name;
 
   /** Creates a new instance of ville */
	public ville()
	{
		x = 0;
		y = 0;
		name = "automaticname";	
	}
 
	public ville(int xc , int yc )
	{
		x = xc;
		y = yc;
		name = "automaticname";
	}
 
	public ville(int xc , int yc , String nom)
	{
		x = xc;
		y = yc;
		name = nom;		
	}
 
	public int getX()
	{
		return x;
	}
 
	public int getY()
	{
		return y;
	} 
 
	public String getName()
	{
		return name;
	}
 
	public void display()
	{
		System.out.println("Absicce : "+x);
		System.out.println("ordonnée : "+y);
		System.out.println("Nom : "+name);
	}
 
	public void setX(int xc)
	{
		x = xc;
	}
 
	public void setY(int yc)
	{
		y = yc;
	}
 
	public void setName(String nom)
	{
		name = nom;
	}
 
	public void setCoord(int xc , int yc)
	{
		setX(xc);
		setY(yc);
	}
        public void setAll(int xc, int yc, String nom)
        {
            setX(xc);
            setY(yc);
            setName(nom);
        }
 
}

puis,

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
138
139
140
141
142
143
144
145
146
147
148
149
150
/*
 * TSPville.java
 *
 * Created on 19 novembre 2007, 12:07
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
 
package tsp;
 
/**
*Cette classe définit une ville par des coordonnées dans un plan et un nom.
*elle possède également un indicateur de parcours afin d'indiquer si on est déja passer par cette ville
*
*@since 18/11/07
*@version 1.0 11/07
*@author LEFEBVRE Arnaud  
*/
public class TSPville {
 
 
        private ville city;
	private boolean prc;
 
    /** Creates a new instance of TSPville */       
	public TSPville()
	{
		city = new ville();
		prc = false;	
	}
 
	public TSPville(int xc , int yc )
	{
		city = new ville(xc,yc);
		prc = false;
	}
 
	public TSPville(int xc , int yc , String nom)
	{
		city = new ville(xc,yc,nom);
		prc = false;	
	}
 
        public TSPville(int xc, int yc ,String nom, boolean b)
        {
		city = new ville(xc,yc,nom);
		prc = b;            
        }
 
        public TSPville(TSPville v)
        {
            city = new ville(v.getX(),v.getY(),v.getName());
            prc = v.getPrc();
        }
 
	public int getX()
	{
		return city.getX();
	}
 
	public int getY()
	{
		return city.getY();
	} 
 
	public String getName()
	{
		return city.getName();
	}
 
	public boolean getPrc()
	{
		return prc;
	}
 
	public void display()
	{
		System.out.println("Absicce : "+getX());
		System.out.println("ordonnée : "+getY());
		System.out.println("Nom : "+getName());
	}
 
	public void setX(int xc)
	{
		city.setX(xc);
	}
 
	public void setY(int yc)
	{
		city.setY(yc);
	}
 
	public void setName(String nom)
	{
		city.setName(nom);
	}
 
	public void setCoord(int xc , int yc)
	{
		city.setX(xc);
		city.setY(yc);
	}
 
	public void setPrc(boolean b)
	{
		prc = b;
	}
 
        public void setAll(int xc, int yc, String nom)
        {
		city.setX(xc);
		city.setY(yc);
                city.setName(nom);
        }
 
        public TSPville clone()
        {
            return new TSPville(getX(),getY(),getName(),prc);
        }
 
        public boolean equals(Object o)
        {
             if (!(o instanceof TSPville))
             return false;
             else 
             {
                 boolean result=true;
                 TSPville v = (TSPville) o;
                 if (! (v.getX() == this.getX()))
                 {
                     result = false;
                 }
                 else if (!(v.getY() == this.getY()))
                 {
                     result = false;
                 }
                 else if   (!(this.getName().equalsIgnoreCase(v.getName())))
                 {
                     result  = false;
                 }
                 else if  (! (this.prc == v.getPrc() ) )
                 {
                     result = false;
                 }
                 return result;
             }
        }
 
}

...

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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
/*
 * TSPparcours.java
 *
 * Created on 19 novembre 2007, 19:10
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
 
package tsp;
import java.util.*;
/**
 *
 * @author LEFEBVRE
 */
public class TSPparcours {
    private ArrayList tovisit;
    private ArrayList unvisited;
    private ArrayList parcours;
    private ArrayList testedCity;
    /** Creates a new instance of TSPparcours */
    public TSPparcours(ArrayList mp)
    {
        tovisit = new ArrayList(mp);
        unvisited = new ArrayList();
        parcours = new ArrayList();
        testedCity = new ArrayList();
        fillUnVisited();
 
    }
 
    public void setTSP (ArrayList mp)
    {
        tovisit = mp;
        parcours.clear();
        testedCity.clear();
        fillUnVisited();        
    }
 
    private void fillUnVisited()
    {
        unvisited.clear();
        Iterator i = tovisit.iterator();
        while (i.hasNext())
        {
            Object o = i.next();
            TSPville v = (TSPville) o;
            if ( ! v.getPrc())
            {
                unvisited.add(v);
            }
        }
    }
 
    private TSPville getRandomCity()
    {
        if (unvisited.isEmpty())
            return null;
        else 
        {
        Double result = java.lang.Math.random();
        result  = result * (unvisited.size()-1);
 
        TSPville rv = (TSPville) unvisited.get(result.intValue());
        /*récupération de la ville et modification de son statut de visite*/
        TSPville v = (TSPville) tovisit.get(tovisit.indexOf(rv));
        v.setPrc(true);
        tovisit.set(result.intValue(),v);
 
        return rv;
        }
    }
 
    private TSPville getNearRandomCity()//choix d'une ville en fonction des parcours déja fait !!
    {
        if (unvisited.isEmpty())
            return null;
        else 
        {
            Double result;
            TSPville rv;
            do
            {
                result = java.lang.Math.random();
                result  = result * (unvisited.size()-1);
                rv = (TSPville) unvisited.get(result.intValue());
            }
            while (testedCity.contains(rv));
        /*récupération de la ville et modification de son statut de visite*/
        TSPville v = (TSPville) tovisit.get(tovisit.indexOf(rv));
        v.setPrc(true);
        tovisit.set(result.intValue(),v);
 
        return rv;
        }
    }
 
    public double parcours()
    {
        double result = 0;
        fillUnVisited();
        TSPville visiting = getRandomCity();
        System.out.println("VISITING : "+visiting.getName());
        TSPville Firstvisited = visiting.clone();
        TSPville nextCity;
        parcours.add(visiting);
        while ( ! unvisited.isEmpty())
        {
            nextCity = getRandomCity();
            System.out.println("NEXT CITY : "+nextCity.getName());
            if ( ( visiting != null ) && ( nextCity != null ) )
            {
                result = result + Distance(visiting,nextCity);
                visiting = nextCity;
                System.out.println("VISITING : "+visiting.getName());
                parcours.add(visiting);
                fillUnVisited();
            }
        }
        result = result + Distance(visiting,Firstvisited);
        System.out.println("LENGTH OF PARCOURS : "+result);
        return result;
    }
 
    public double parcours(double min, ArrayList alreadyDo)
    {
        double result = 0;
        fillUnVisited();
        fillTestedCity(alreadyDo);
        TSPville visiting = getNearRandomCity();
        System.out.println("VISITING : "+visiting.getName());
        TSPville Firstvisited = visiting.clone();
        TSPville nextCity;
        parcours.add(visiting);
        while ( ( ! unvisited.isEmpty()) && (result <= min) )
        {
            nextCity = getNearRandomCity();
            if ( ( visiting != null ) && ( nextCity != null ) )
            {
                result = result + Distance(visiting,nextCity);
                visiting = nextCity;
                System.out.println("VISITING : "+visiting.getName());
                parcours.add(visiting);
                fillUnVisited();
                fillTestedCity(alreadyDo);
            }
        }
        result = result + Distance(visiting,Firstvisited);
        return result;        
    }
 
     private int sqr(int x)
     {
            return (x*x);
     }
 
     private double Distance(TSPville v1, TSPville v2)
     {
            int XX = sqr( v2.getX() - v1.getX() );
            int YY = sqr( v2.getY() - v1.getY() );
            return java.lang.Math.sqrt( XX+YY );
     }
 
     private double Distance(int i, int j)
    {
            TSPville v1 = new TSPville( (TSPville) tovisit.get(i));
            TSPville v2 = new TSPville( (TSPville) tovisit.get(j));
            int XX = sqr( v2.getX() - v1.getX() );
            int YY = sqr( v2.getY() - v1.getY() );   
            return java.lang.Math.sqrt( XX+YY );            
     }
 
     public void displayParcours()
     {
            Iterator i = parcours.iterator();
            while ( i.hasNext())
            {
                Object o = i.next();
                TSPville v = (TSPville) o;
                v.display();
            }
     }
 
     public ArrayList getParcours()
     {
            return parcours;
     }
 
     private boolean isSame(ArrayList l)
     {
         boolean result = true;
         Iterator i= l.iterator();
         Iterator k = parcours.iterator();
         if (parcours.isEmpty())
             return result;
         else
         {
            while ( (i.hasNext()) && (k.hasNext()))
            {
                TSPville v = (TSPville) i.next();
                TSPville v1 = (TSPville) k.next();
                if ( ! v.equals(v1) )
                {
                   result = false;
                }
            }
             if (k.hasNext())
            {
                result = false;
            }
            return result;
         }
     }
 
     private void forbiddenValue(ArrayList l)
     {
         testedCity.add(l.get(parcours.size()));
     }
 
     private void fillTestedCity(ArrayList<ArrayList> testedprc)
     {
         testedCity.clear();
         for(ArrayList liste : testedprc)
         {
             Iterator i = testedprc.iterator();
         while (i.hasNext())
         {
             ArrayList l = new ArrayList((ArrayList) i.next());
             if (l.isEmpty())
                 System.out.println("WARNING !!");
             displaylist(l);
             if (isSame(l))
             {
                 forbiddenValue(l);
             }
         }
         }
     }
 
     public void displaylist(ArrayList l)
     {
            Iterator i = l.iterator();
            while ( i.hasNext())
            {
                Object o = i.next();
                TSPville v = (TSPville) o;
                v.display();
            }
     }
}

...

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
/*
 * optimalTSP.java
 *
 * Created on 19 novembre 2007, 12:18
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
 
package tsp;
import java.util.*;
 
/**
 *
 * @author LEFEBVRE
 */
public class optimalTSP {
 
    private ArrayList Citymap;
    private ArrayList testedprc;
    private ArrayList BestTSP;
    private double optimalTsp;
 
    /** Creates a new instance of optimalTSP */
    public optimalTSP()
    {
        testedprc = new ArrayList();
        Citymap = new ArrayList();
        BestTSP = new ArrayList();
        optimalTsp = 0;
    }
 
    public optimalTSP(ArrayList p)
    {
        testedprc = new ArrayList();
        Citymap = new ArrayList(p);
        BestTSP = new ArrayList();
        optimalTsp = 0;
    }
 
    private int fact(int k)
    {
        int result =  1;
        for(int i = 0; i < k ; i++)
        {
            result = result * (k-i);
        }
        return result;
    }
 
    public double getoptimalTSP()
    {
        int i = 0;
        int end = fact(Citymap.size());
        System.out.println("NOMBRE DE PARCOURS A TESTER : "+end);
        TSPparcours p = new TSPparcours(Citymap);
        System.out.println("ESSAI DE PARCOURS N°1");
        optimalTsp = p.parcours();
        testedprc.add(p.getParcours());
        BestTSP = p.getParcours();
        TSPville v = (TSPville) BestTSP.get(0);
        v.display();
        //nombre de parcours possible pour n villes ????
        while (i<end)
        {
            p.setTSP(Citymap);
            System.out.println("ESSAI DE PARCOURS N°"+(i+1));
            Double xx = p.parcours(optimalTsp,testedprc);
            if (optimalTsp>xx)
            {
                optimalTsp = xx;
                BestTSP = p.getParcours();
            }
            testedprc.add(p.getParcours());
            i++;
        }
        return optimalTsp;
    }
 
         public void displayParcours()
     {
            Iterator i = BestTSP.iterator();
            while ( i.hasNext())
            {
                Object o = i.next();
                TSPville v = (TSPville) o;
                v.display();
            }
     }
 
}

et enfin le main :

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
/*
 * Main.java
 *
 * Created on 19 novembre 2007, 12:04
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
 
package tsp;
import java.util.*;
/**
 *
 * @author LEFEBVRE
 */
public class Main {
 
    /** Creates a new instance of Main */
    public Main() {
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) 
    {
    		System.out.println("DEBUT");
		ArrayList t = new ArrayList();
		TSPville v1 = new TSPville(0,0,"V1");
                TSPville v2 = new TSPville(0,5,"V2");
                TSPville v3 = new TSPville(5,5,"V3");
                TSPville v4 = new TSPville(5,0,"V4");
 
                System.out.println("REMPLISSAGE");
 
                t.add(v1);
                t.add(v2);
                t.add(v3);
                t.add(v4);
		System.out.println("FIN DU REMPLISSAGE");
 
                optimalTSP p = new optimalTSP(t);
                System.out.println("longeur du parcours : "+p.getoptimalTSP());
                p.displayParcours();
 
		System.out.println("FIN");
    }
 
}

voila il y a tout, dsl pour la mise en page....
Et Merci d'avance pour vos réponses !! :D

ps : je doi aller travailler :(, je me remettrai sur le sujet ce soir