Tableau int[]

Messages postés
845
Date d'inscription
mardi 25 avril 2006
Statut
Membre
Dernière intervention
1 août 2017
- - Dernière réponse : sheorogath
Messages postés
2465
Date d'inscription
samedi 21 février 2004
Statut
Modérateur
Dernière intervention
29 janvier 2010
- 5 oct. 2006 à 19:45
Bonjour a tous.


j'ai un tres tres gros pb:


je suis entrain de concevoir un prog qui a besoin de stocker dans un tableau de type int[] beaucoup de valeur, mais alors vraiment beacoup (environ 8715 nombre entiers); lors de sa compilation, Jbuilder (mon editeur java), ne veux pas me le compiler car il trouve que le tableau est trop volumineux.


savez vous comment remedier a ce pb?


merci.
Afficher la suite 

18 réponses

Messages postés
5341
Date d'inscription
dimanche 4 mai 2003
Statut
Modérateur
Dernière intervention
10 décembre 2019
89
0
Merci
Salut,

essaye avec un vecteur de int ou un arraylist de int

Vector vec = new Vector
//vec.add(1);

//int n = vec.get(n);

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA
Commenter la réponse de Twinuts
Messages postés
845
Date d'inscription
mardi 25 avril 2006
Statut
Membre
Dernière intervention
1 août 2017
1
0
Merci
D'accord, mais quand vous dites "vec.add(1)" cela veut-il dire qu'il faut que je fasse


"vec.add(1)


vec.add(2)


..." jusqu'a 8715 ?


merci.
Commenter la réponse de didoux95
Messages postés
5341
Date d'inscription
dimanche 4 mai 2003
Statut
Modérateur
Dernière intervention
10 décembre 2019
89
0
Merci
Salut,

oui tu le fais dans une boucle

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA
Commenter la réponse de Twinuts
Messages postés
845
Date d'inscription
mardi 25 avril 2006
Statut
Membre
Dernière intervention
1 août 2017
1
0
Merci
a vrai dire ce son des nombre premiers (que j'ai deja) que je doi y stocker.
donc un boucle ce serais mal approprier je pense.
precedemment, l'aventage de int[] c'etait: int[] A = {3.,5,7,11,13,...};

merci.
Commenter la réponse de didoux95
Messages postés
5341
Date d'inscription
dimanche 4 mai 2003
Statut
Modérateur
Dernière intervention
10 décembre 2019
89
0
Merci
salut,

ba pres calcul les nombres premiers dans ta boucle...

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA
Commenter la réponse de Twinuts
Messages postés
2465
Date d'inscription
samedi 21 février 2004
Statut
Modérateur
Dernière intervention
29 janvier 2010
11
0
Merci
si tu veux une grosse methde de bourrin :

public class premiers {

   public static void main(String[] args)

   {
      int somme = 0;
      for (int i = 1; i < 100; i++) {
         if (isPrimary(i)){
            somme += i;
         System.out.println(i);
         }
      }
      System.out.println("la somme des 100 premiers est = " + somme);
   }

   public static boolean isPrimary(int nb) {       if (nb 2 || nb 3 || nb == 5 || nb == 7)
         return true;       else if ((!((nb & 1) 0 || nb % 3 0 || nb % 5 == 0|| nb % 7 == 0))
            && nb != 1)
         return true;
      else
         return false;
   }
}

sinon il existe d'autre algo qui permette d'aller plus vite mais bon je n'en avais pas besoin donc je ne m'y suis pas penché

"n'est pas mort ce qui semble a jamais dormir et en d'etrange temps meme la mort peut mourrir"
Commenter la réponse de sheorogath
Messages postés
44
Date d'inscription
lundi 23 janvier 2006
Statut
Membre
Dernière intervention
12 août 2007
0
Merci
Tiens, une autre méthode, peut etre un peu moins bourrine qui te renvoie un vecteur contenant tous les nombres premiers jusqu'à n (j'ai testé, le vecteur peut largement contenir assez de valeurs).
C'est surement pas la meilleure solution mais bon (j'utilise le crible d'ératostène ici):

public Vector nbPremiers(int n){
    // On crée une hashtable que l'on rempli de tous les nombres de 0 à n
    // à ces nombres on associe "oui" si c'est un nb premier, non sinon
    // par defaut ils le sont tous sauf 0 et 1
    Hashtable h = new Hashtable();
    h.put(0,"non");
    h.put(1,"non");
    for(int N=2;N<=n;N++){
        h.put(N,"oui");
    }
   
    // Grace au crible d'Eratostène, on attribue la valeur non à tous les nombres non premiers
    int i=2, j=0;
    while(i<=n){
        j=i*2;
        while(j<=n){
            h.put(j,"non");
            j+=i;
        }
        i++;
        while (i<=n && ((String)h.get(i)).equals("non")){
            i++;
        }
    }
   
    //En se basant sur la hashtable précédemment créée,on crée et retourne
    //un vecteur ne contenant que les nombres premiers
    Vector v = new Vector();
    for(int k=0;k<=n;k++){
        if (((String)h.get(k)).equals("oui")){
            v.addElement(k);
        }
    }
    return v;
}
Commenter la réponse de Ar0z
Messages postés
44
Date d'inscription
lundi 23 janvier 2006
Statut
Membre
Dernière intervention
12 août 2007
0
Merci
Ou plutot, vu que tu n'as peut etre pas besoin de la table complete, petite optimisation :

public Vector nbPremiers(int n){
    Vector v = new Vector();
    for(int N=2;N<=n;N++){
        v.addElement(new Integer(N));
    }
    int i=2, j=0;
    while(i<=n){
        j=i*2;
        while(j<=n){
            v.remove(new Integer(j));
            j+=i;
        }
        i++;
        while (i<=n && !v.contains(new Integer(i))) i++;
    }
    return v;
}

Voilà, c'est plus simple et çà evite des calculs inutiles ^^.
Commenter la réponse de Ar0z
Messages postés
5341
Date d'inscription
dimanche 4 mai 2003
Statut
Modérateur
Dernière intervention
10 décembre 2019
89
0
Merci
Salut,

c'est super bourrin de remplire le vecteur pour supprimer les val apres, pourquoi ne pas le remplire que si c'est un nombre entier, cela t'eviteras de
passer jun temps non negligeable avec les traitements sur ton vecteur.....

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA
Commenter la réponse de Twinuts
Messages postés
44
Date d'inscription
lundi 23 janvier 2006
Statut
Membre
Dernière intervention
12 août 2007
0
Merci
En effet.
Mais pour faire ansi tu es obligé (je pense, pas sur, dites moi si je me trompe) de faire un test par divisions successives (comme dans le post de [auteurdetail.aspx?ID=234347 ]sheorogath) sur chaque nombre, ce qui, pour une valeur de n très élevée, peut s'averrer long.
La méthode du crible d'ératostène que j'ai postée permet d'éviter de traiter énormément de nombres. En effet, on ne traite pas les multiples de X si X n'est lui même pas un nombre premier et ainsi de suite.
D'une certaine façon cette méthode permet donc d'isoler les nombres qui ne sont pas premier et non les nombres premiers.

En revanche, si ta valeur de n ne varie pas trop (ce qui a l'air d'être le cas ici), je pense qu'on peut obtenir de meilleurs résultats en adaptant un algorithme probabiliste. Peut être en faisant un test en deux temps pour écarter les nombres délicats. A tester.
Commenter la réponse de Ar0z
Messages postés
5341
Date d'inscription
dimanche 4 mai 2003
Statut
Modérateur
Dernière intervention
10 décembre 2019
89
0
Merci
Salut,

enfaite ce qui me dérrange le plus dans ton code c'est l'oubli d'un petit detail qui n'est pas négligeable soit tu fais

public class Tmp {
    public static void main(String[] args) {
        new Tmp();

    }
   
    public Tmp(){
        Vector v = nbPremiers(10000);
        System.out.println(v.size()); //affiche 1229
        System.out.println(v.capacity());//affiche 10240 (place mémoire pour rien)
    }
   
    public Vector nbPremiers(int n){
        Vector v = new Vector();
        for(int N=2;N<=n;N++)
            v.add(new Integer(N));
        int i=2, j=0;
        while(i<=n){
            j=i*2;
            while(j<=n){
                v.remove(new Integer(j));
                j+=i;
            }
            i++;
            while (i<=n && !v.contains(new Integer(i))) i++;
        }
        return v;
    }
}

Donc pour remedier à ce problème mémoire je conseil un petit trim du vecteur avant de le renvoyer, ce qui remettra la capacité au meme niveau que la taille donc plus de perte de mémoire :
public Vector nbPremiers(int n){
        Vector v = new Vector();
        for(int N=2;N<=n;N++)
            v.add(new Integer(N));
        int i=2, j=0;
        while(i<=n){
            j=i*2;
            while(j<=n){
                v.remove(new Integer(j));
                j+=i;
            }
            i++;
            while (i<=n && !v.contains(new Integer(i))) i++;
        }
        v.trimToSize();
        return v;
    }

maintenant concernant l'algo choisi je trouve le Crible d'Eratostène super lourd sur un point de vu application dans un code (ca reste un avis perso).

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA
Commenter la réponse de Twinuts
Messages postés
44
Date d'inscription
lundi 23 janvier 2006
Statut
Membre
Dernière intervention
12 août 2007
0
Merci
ok, je croyais que les vecteurs grandissaient dynamiquement au fur et à mesure qu'on leur ajoutait des éléments. Visiblement c'est pas le cas :).
Sinon pour le crible. L'algo en lui même me parait tres efficace mais c'est vrai qu'appliqué dans un code il peut paraitre un peu lourd.
Commenter la réponse de Ar0z
Messages postés
357
Date d'inscription
jeudi 24 octobre 2002
Statut
Membre
Dernière intervention
30 mars 2011
0
Merci
les vecteurs grandissent dynamiquement au fur et à mesure. mais quand tu crées ton vecteur avec new vector(n), tu lui réserve au démarrage une place de n élèments en mémoire. quand cette taile est dépassée,  java incrémente la taille du vecteur de n élèments. il faut choisir intelligement n de maniere que trop de ressource soit attribué et que java incrémente le vecteur trop fréquement.
Commenter la réponse de kaloway
Messages postés
845
Date d'inscription
mardi 25 avril 2006
Statut
Membre
Dernière intervention
1 août 2017
1
0
Merci
Super, merci a tous.
En revanche (a titre informatif),la generation des nombres premiers avec la methode de "ArOz", met, pour des nombres alan jusaqu'a 90000, un peut plus de 50sec 1min.
MAIS sinon merci.
Commenter la réponse de didoux95
Messages postés
44
Date d'inscription
lundi 23 janvier 2006
Statut
Membre
Dernière intervention
12 août 2007
0
Merci
Je me suis amusé à faire quelques tests sur les vecteurs et
effectivement, le fait de remplir un vecteur comme je fais comme un
bourrin prends non seulement beaucoup de ram mais en plus çà prend
beaucoup de temps !



Sinon question d'algo pur, j'ai testé par le crible d'ératostène et par
divisions successives et effectivement le crible est plus rapide pour
des nombres élevés.


(PS : la méthode postée par sheorogath ne permet évidemment que de calculer les nombres premiers < 121).


Bon, je vais faire un peu plus attention à mes gros vecteurs moi à l'avenir ^^
Commenter la réponse de Ar0z
Messages postés
2465
Date d'inscription
samedi 21 février 2004
Statut
Modérateur
Dernière intervention
29 janvier 2010
11
0
Merci
(PS : la méthode postée par sheorogath ne permet évidemment que de calculer les nombres premiers < 121)

pourquoi cela ? elle permet de tester si un nombre est premier cela dit c'est vrai que c bourrin ... c'est plus adapte pour un test unique pas un crible

"n'est pas mort ce qui semble a jamais dormir et en d'etrange temps meme la mort peut mourrir"
Commenter la réponse de sheorogath
Messages postés
44
Date d'inscription
lundi 23 janvier 2006
Statut
Membre
Dernière intervention
12 août 2007
0
Merci
En fait, à partir de 121, certains résultats seront faux, par exemple 121=11*11, ce n'est pas un nombre premier.
Commenter la réponse de Ar0z
Messages postés
2465
Date d'inscription
samedi 21 février 2004
Statut
Modérateur
Dernière intervention
29 janvier 2010
11
0
Merci
a oui en effet :s il faudrais que je rajoute comme diviseur les nombre premier eux meme ...

"n'est pas mort ce qui semble a jamais dormir et en d'etrange temps meme la mort peut mourrir"
Commenter la réponse de sheorogath