Decouper un arraylist

Résolu/Fermé
beta - Modifié par beta le 12/04/2015 à 12:35
 beta - 14 avril 2015 à 01:27
Bonjour,

pouvez-vous m' aider avec un petit problème. j'ai le code suivant
List<Double> a = new ArrayList<Double>();
List<Double> b = new ArrayList<Double>();
List<Double> nB = new ArrayList<Double>();
                if (a.size() % size != 0) {
   // cas a traiter
   
  } else {
   for (int j = 0; j < a.size(); j = j + size) {
    b = a.subList(j, j + size);     
    comp++;    
    double m = moyen(b);
                  //moyen est un fonction retourne le moyen de la liste b
    nB.add(m);
   }

ma question est :comment traiter le cas ou la taille de la liste "a" pas un diviseur de "size" exemple si a.size()=11 et size=5.on auras 2 sous listes de taille 5 et reste un sous liste de taille 1
A voir également:

2 réponses

KX Messages postés 16734 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 24 avril 2024 3 015
12 avril 2015 à 14:44
Bonjour,

Quel est l'objectif de ce code ?

Si je comprends bien en prenant
a = [1,2,3,4,5,6,7,8]
et
size = 2
, tu cherches à obtenir
nB = [moyen(1,2), moyen(3,4), moyen(5,6), moyen(7,8)]
?

Du coup, avant même de faire ça en Java, quel résultat est-ce que tu attends pour le dernier groupe si ça dépasse ?
Si
size = 3
par exemple :
nB = [moyen(1,2,3), moyen(4,5,6), moyen(7,8)]
?

Remarques : tu codes avec quelle version de Java ? 6, 7, 8 ?
0
oui vous comprenez .nB = [moyen(1,2), moyen(3,4), moyen(5,6), moyen(7,8)] si a.size()mod taille==0.sinon nB = [moyen(1,2,3), moyen(4,5,6), moyen(7,8)] juste comme vous l'avez dit.j'ai utilisé java 8
0
KX Messages postés 16734 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 24 avril 2024 3 015
13 avril 2015 à 22:28
Bonjour,

Dans un premier temps : un conseil, lorsque tu manipules des données, il faut travailler ton algorithme en partant de ce que tu as, et aller vers ce que tu veux. De la manière dont tu as commencé tu fais l'inverse, c'est à dire que tu as construis ta boucle for sur une itération j+size parce que c'est la structure de ta sortie qui fait que chaque groupe va être découpé en "size" éléments, alors qu'il serait plus simple d'itérer en j+1 en égrainant un à un les différents éléments de ta liste d'entrée.

Ensuite quand tu as des paramètres en entrées, une seule sortie, il faut absolument penser à faire une méthode, ça permet de découper le code, c'est super lisible, et on se concentre mieux sur l'algorithme parce que c'est une partie totalement indépendante du reste.

Enfin, il vaut mieux être le plus général possible. Ici tu manipules des Double en entrée et des Double en sortie avec une méthode moyen(), mais ton code pourrait faire la même avec des int, des String ou n'importe quoi d'autres dès lors qu'on lui passe la bonne fonction de transformation.

Une manière de faire (ce n'est clairement pas la seule).

public static <E, F> List<F> split(List<E> list, int size, Function<List<E>, F> func) {
    List<F> result = new ArrayList<F>(list.size() / size + 1);
    List<E> sublist = null;
    for (int i = 0; i < list.size(); i++) {
        if (i % size == 0) {
            if (sublist != null)
                result.add(func.apply(sublist));
            sublist = new ArrayList<E>(size);
        }
        sublist.add(list.get(i));
    }
    result.add(func.apply(sublist));

    return result;
}

Exemples :

List<Integer> list= Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);

 // [[1, 2], [3, 4], [5, 6], [7, 8]]
System.out.println(split(list, 2, x -> x.toString()));

// [[1, 2, 3], [4, 5, 6], [7, 8]]
System.out.println(split(list, 3, x -> x.toString()));

Et dans ton cas particulier, cela donne ceci :

List<Double> list = Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
List<Double> split = split(list, 3, x -> moyen(x));
System.out.println(split);
0
Merci bq
0