type primitifs : le boolean prendrait autant qu'un byte ?
4 réponses
Kupee
Salut, on m'a dit, et je ne voulais pas le croire qu'un boolean
ne prenait pas 1 bit de mémoire comme prévu mais bien plus en java.
J'ai donc fait un petit test :
public class Tata {
public static void main(String[] args) {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
}
System.out.println("Allocation");
System.gc();
boolean[] b = new boolean[60000000];
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
}
System.out.println(b.length);
System.out.println("fini");
}
}
et j'observe la mémoire occupée par la jvm.
Elle est en gros de 6 Mo au début, puis a l'allocation du tableau
passe a 66 Mo.
Je fais le même test avec un tableau de byte, et obtient exactement
la même occupation mémoire. Ca me parrait un peu louche non?
J'ai merdé quelque part ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Bruno Jouhier
Je fais le même test avec un tableau de byte, et obtient exactement la même occupation mémoire. Ca me parrait un peu louche non? J'ai merdé quelque part ?
Non. C'est probablement une question de compromis vitesse/taille. Si on passe sur 1 bit, on gagne de la mémoire mais on ralentit les opérations de lecture/écriture (car il faut faire des operations de masquage, et de décalage de bit).
Je fais le même test avec un tableau de byte, et obtient exactement
la même occupation mémoire. Ca me parrait un peu louche non?
J'ai merdé quelque part ?
Non. C'est probablement une question de compromis vitesse/taille. Si on
passe sur 1 bit, on gagne de la mémoire mais on ralentit les opérations de
lecture/écriture (car il faut faire des operations de masquage, et de
décalage de bit).
Je fais le même test avec un tableau de byte, et obtient exactement la même occupation mémoire. Ca me parrait un peu louche non? J'ai merdé quelque part ?
Non. C'est probablement une question de compromis vitesse/taille. Si on passe sur 1 bit, on gagne de la mémoire mais on ralentit les opérations de lecture/écriture (car il faut faire des operations de masquage, et de décalage de bit).
Pascal Pizeine
"Kupee" a écrit dans le message de news:4141d1a1$0$32714$
Salut, on m'a dit, et je ne voulais pas le croire qu'un boolean ne prenait pas 1 bit de mémoire comme prévu mais bien plus en java.
Il me semble que c'est le cas dans tous les langages, ce n'est pas lié à Java. Tu ne peux pas allouer moins d'un octet
J'ai donc fait un petit test : public class Tata {
public static void main(String[] args) { try { Thread.sleep(5000); } catch (InterruptedException e) { } System.out.println("Allocation"); System.gc(); boolean[] b = new boolean[60000000]; try { Thread.sleep(10000); } catch (InterruptedException e) { } System.out.println(b.length); System.out.println("fini"); } } et j'observe la mémoire occupée par la jvm. Elle est en gros de 6 Mo au début, puis a l'allocation du tableau passe a 66 Mo. Je fais le même test avec un tableau de byte, et obtient exactement la même occupation mémoire. Ca me parrait un peu louche non? J'ai merdé quelque part ?
"Kupee" <rien@rien.rien> a écrit dans le message de
news:4141d1a1$0$32714$626a14ce@news.free.fr...
Salut, on m'a dit, et je ne voulais pas le croire qu'un boolean
ne prenait pas 1 bit de mémoire comme prévu mais bien plus en java.
Il me semble que c'est le cas dans tous les langages, ce n'est pas lié à
Java.
Tu ne peux pas allouer moins d'un octet
J'ai donc fait un petit test :
public class Tata {
public static void main(String[] args) {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
}
System.out.println("Allocation");
System.gc();
boolean[] b = new boolean[60000000];
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
}
System.out.println(b.length);
System.out.println("fini");
}
}
et j'observe la mémoire occupée par la jvm.
Elle est en gros de 6 Mo au début, puis a l'allocation du tableau
passe a 66 Mo.
Je fais le même test avec un tableau de byte, et obtient exactement
la même occupation mémoire. Ca me parrait un peu louche non?
J'ai merdé quelque part ?
"Kupee" a écrit dans le message de news:4141d1a1$0$32714$
Salut, on m'a dit, et je ne voulais pas le croire qu'un boolean ne prenait pas 1 bit de mémoire comme prévu mais bien plus en java.
Il me semble que c'est le cas dans tous les langages, ce n'est pas lié à Java. Tu ne peux pas allouer moins d'un octet
J'ai donc fait un petit test : public class Tata {
public static void main(String[] args) { try { Thread.sleep(5000); } catch (InterruptedException e) { } System.out.println("Allocation"); System.gc(); boolean[] b = new boolean[60000000]; try { Thread.sleep(10000); } catch (InterruptedException e) { } System.out.println(b.length); System.out.println("fini"); } } et j'observe la mémoire occupée par la jvm. Elle est en gros de 6 Mo au début, puis a l'allocation du tableau passe a 66 Mo. Je fais le même test avec un tableau de byte, et obtient exactement la même occupation mémoire. Ca me parrait un peu louche non? J'ai merdé quelque part ?
Bruno Jouhier
"Pascal Pizeine" a écrit dans le message de news: ci4ijo$a7f$
"Kupee" a écrit dans le message de news:4141d1a1$0$32714$
Salut, on m'a dit, et je ne voulais pas le croire qu'un boolean ne prenait pas 1 bit de mémoire comme prévu mais bien plus en java.
Il me semble que c'est le cas dans tous les langages, ce n'est pas lié à Java.
Mais dans le cas d'un tableau, on peut grouper 8 booléens dans un octet.
Tu ne peux pas allouer moins d'un octet
J'ai donc fait un petit test : public class Tata {
public static void main(String[] args) { try { Thread.sleep(5000); } catch (InterruptedException e) { } System.out.println("Allocation"); System.gc(); boolean[] b = new boolean[60000000]; try { Thread.sleep(10000); } catch (InterruptedException e) { } System.out.println(b.length); System.out.println("fini"); } } et j'observe la mémoire occupée par la jvm. Elle est en gros de 6 Mo au début, puis a l'allocation du tableau passe a 66 Mo. Je fais le même test avec un tableau de byte, et obtient exactement la même occupation mémoire. Ca me parrait un peu louche non? J'ai merdé quelque part ?
"Pascal Pizeine" <pascal.pizeine@milesys.fr> a écrit dans le message de
news: ci4ijo$a7f$1@s5.feed.news.oleane.net...
"Kupee" <rien@rien.rien> a écrit dans le message de
news:4141d1a1$0$32714$626a14ce@news.free.fr...
Salut, on m'a dit, et je ne voulais pas le croire qu'un boolean
ne prenait pas 1 bit de mémoire comme prévu mais bien plus en java.
Il me semble que c'est le cas dans tous les langages, ce n'est pas lié à
Java.
Mais dans le cas d'un tableau, on peut grouper 8 booléens dans un octet.
Tu ne peux pas allouer moins d'un octet
J'ai donc fait un petit test :
public class Tata {
public static void main(String[] args) {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
}
System.out.println("Allocation");
System.gc();
boolean[] b = new boolean[60000000];
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
}
System.out.println(b.length);
System.out.println("fini");
}
}
et j'observe la mémoire occupée par la jvm.
Elle est en gros de 6 Mo au début, puis a l'allocation du tableau
passe a 66 Mo.
Je fais le même test avec un tableau de byte, et obtient exactement
la même occupation mémoire. Ca me parrait un peu louche non?
J'ai merdé quelque part ?
"Pascal Pizeine" a écrit dans le message de news: ci4ijo$a7f$
"Kupee" a écrit dans le message de news:4141d1a1$0$32714$
Salut, on m'a dit, et je ne voulais pas le croire qu'un boolean ne prenait pas 1 bit de mémoire comme prévu mais bien plus en java.
Il me semble que c'est le cas dans tous les langages, ce n'est pas lié à Java.
Mais dans le cas d'un tableau, on peut grouper 8 booléens dans un octet.
Tu ne peux pas allouer moins d'un octet
J'ai donc fait un petit test : public class Tata {
public static void main(String[] args) { try { Thread.sleep(5000); } catch (InterruptedException e) { } System.out.println("Allocation"); System.gc(); boolean[] b = new boolean[60000000]; try { Thread.sleep(10000); } catch (InterruptedException e) { } System.out.println(b.length); System.out.println("fini"); } } et j'observe la mémoire occupée par la jvm. Elle est en gros de 6 Mo au début, puis a l'allocation du tableau passe a 66 Mo. Je fais le même test avec un tableau de byte, et obtient exactement la même occupation mémoire. Ca me parrait un peu louche non? J'ai merdé quelque part ?
Kupee
Pascal Pizeine wrote:
Il me semble que c'est le cas dans tous les langages, ce n'est pas lié à Java. Tu ne peux pas allouer moins d'un octet
C'est ce dont je me suis rendu compte en me renseignant sur les autres langages, ils font pareil. Effectivement la jvm pourrait compacter des paquets de 8 booleans dans un byte, mais ca serait un peu tordu, et on y gagnerait ptet pas grand chose, parce que si c'est pour avoir un pointeur qui va pointer sur le bit en question on a tout perdu :D
Pascal Pizeine wrote:
Il me semble que c'est le cas dans tous les langages, ce n'est pas lié à
Java.
Tu ne peux pas allouer moins d'un octet
C'est ce dont je me suis rendu compte en me renseignant
sur les autres langages, ils font pareil.
Effectivement la jvm pourrait compacter des paquets de 8 booleans
dans un byte, mais ca serait un peu tordu, et on y gagnerait
ptet pas grand chose, parce que si c'est pour avoir un pointeur
qui va pointer sur le bit en question on a tout perdu :D
Il me semble que c'est le cas dans tous les langages, ce n'est pas lié à Java. Tu ne peux pas allouer moins d'un octet
C'est ce dont je me suis rendu compte en me renseignant sur les autres langages, ils font pareil. Effectivement la jvm pourrait compacter des paquets de 8 booleans dans un byte, mais ca serait un peu tordu, et on y gagnerait ptet pas grand chose, parce que si c'est pour avoir un pointeur qui va pointer sur le bit en question on a tout perdu :D
