Discussion :

[JPigKeud]

J'aimerai réinitialiser une portion d'un tableau avec une valeur déterminée.

Existe-t-il une fonction performante pour effectuer cette affectation ? (un peu comme la fonction de copie System.arrayCopy)

A défaut, toute solution me permettant d'éviter la classique boucle for est susceptible de m'intéresser.

Par avance, merci de votre aide.

[waldo2188]

pourais tu être plus claire.
Quel type de tableau utilise tu, vecteur ou arraylist???

[tomca]

Cela dépend le type de tableau...sinon un iterator() ca fonctionne très bien...

[JPigKeud]

En fait il s'agit d'un type tableau ordinaire.
Je pourrais envisager de passer les donnée dans un autre format si cela me fais gagner en performance.

Je cherche une fonctionnalité se rapprochant du memset en C, un peu comme la méthode System.arrayCopy se rapproche du memcpy (ok, je schématise un peu ).

J'aimerai donc éviter si possible toute boucle et itérateur pour affecter une meme valeur à un ensemble d'éléments d'un tableau (une méthode du style setValue(double[] array, double value, int startIndex, int endIndex)).

Voila, voila.

[bigboomshakala]

ce qui concerne les tableaux [] se trouve dans la classe java.util.Arrays.

regarde dans la javadoc, en particulier la fonction fill().


Enjoy yourself !

[c-top]

J'aimerai donc éviter si possible toute boucle et itérateur pour affecter une meme valeur à un ensemble d'éléments d'un tableau (une méthode du style setValue(double[] array, double value, int startIndex, int endIndex)).

Voila, voila.

En fait une telle méthode cacherait surement une boucle sur cette portion de tableau...

[JHelp]

En fait on peut faire un peut plus rapide que le boucle for (Arrays.fill en fait revient à la boucle for) on peut utiliser la dicotomie, il faut savaoir que System.ArrayCopy est plus rapide qu'une boucle for de copie, d'ou mon idée de l'utiliser aussi pour remplir.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
   /**
    * Remplit un tableau d'objets de la même valeur
    * @param objets
    *        Tableau à remplir
    * @param depart
    *        Position de départ
    * @param taille
    *        Nombre de case à remplir
    * @param valeur
    *        Valeur de remplissage
    */
   public static void remplir(Object[] objets, int depart, int taille,
         Object valeur)
   {
      if(objets == null)
      {
         throw new NullPointerException("Le tableau ne doit pas être null");
      }
      //On verifie la taille
      if(depart < 0)
      {
         taille += depart;
         depart = 0;
      }
      if(depart + taille > objets.length)
      {
         taille = objets.length - depart;
      }
      if(taille < 1)
      {
         return;
      }
      //On initialise le remplissage
      objets[depart] = valeur;
      int l = 1;
      int t = taille;
      //On copie, 1, puis 2, puis 4, ... jusqu'a a atteindre 2¨n ou n tel
      // maximun des n tels que 2¨n<=taille
      while(t > 1)
      {
         System.arraycopy(objets, depart, objets, depart + l, l);
         l *= 2;
         t /= 2;
      }
      //On remplit les cases restantes (si il y en a)
      int reste = taille - l;
      if(reste > 0)
      {
         System.arraycopy(objets, depart, objets, depart + taille - reste,
               reste);
      }
   }

On peut ensuite faire la même chose avec les type primitifs

[JPigKeud]

Evidemment, la solution à mon problème de tableau se trouve dans la classe java.util.Arrays, honte sur moi de ne pas y avoir pensé

Je vais également tester la méthode proposée par JHelp qui me semble très intéressante et vérifier les gains en terme de performance.

Merci beaucoup pour votre aide.