Examiner l'utilisation de la mémoire des éléments Java

Primitives et boîte

Tout d'abord, je voudrais créer un tableau de primitives et de type Box et voir combien de mémoire est utilisée.

  private static final int NUM = 100_000;

  public static void main(String[] args) {
    long beforeUse, afterUse, div;
    beforeUse = memoryUsed();
    int[] primitive = new int[NUM];
    afterUse = memoryUsed();
    div = afterUse - beforeUse;

    out.println(" -- int[] -- ");
    out.println(div);
    out.println((double)div / primitive.length);

    beforeUse = memoryUsed();
    Integer[] classes = new Integer[NUM];
    afterUse = memoryUsed();
    div = afterUse - beforeUse;

    out.println(" -- Integer[] unset -- ");
    out.println(div);
    out.println((double)div / classes.length);

    for (int i = 0;i < classes.length;i++) {
      classes[i] = i;
    }

    afterUse = memoryUsed();
    div = afterUse - beforeUse;

    out.println(" -- Integer[] set -- ");
    out.println(div);
    out.println((double)div / classes.length);
  }

Résultat d'exécution

 -- boolean[] -- 
100016
1.00016
 -- Boolean[] unset -- 
400016
4.00016
 -- Boolean[] set -- 
400016
4.00016
 -- byte[] -- 
100016
1.00016
 -- Byte[] unset -- 
400016
4.00016
 -- Byte[] set -- 
448528
4.48528
 -- short[] -- 
200016
2.00016
 -- Short[] unset -- 
400016
4.00016
 -- Short[] set -- 
1923440
19.2344
 -- char[] -- 
200016
2.00016
 -- Character[] unset -- 
400016
4.00016
 -- Character[] set -- 
2402512
24.02512
 -- int[] -- 
400016
4.00016
 -- Integer[] unset -- 
400016
4.00016
 -- Integer[] set -- 
2202512
22.02512
 -- long[] -- 
1048576
10.48576
 -- Long[] unset -- 
400016
4.00016
 -- Long[] set -- 
3105872
31.05872
 -- float[] -- 
400016
4.00016
 -- Float[] unset -- 
400016
4.00016
 -- Float[] set -- 
2706352
27.06352
 -- double[] -- 
1048576
10.48576
 -- Double[] unset -- 
400016
4.00016
 -- Double[] set -- 
3651112
36.51112

Utilisation de la mémoire par élément [octets]

Moule	Primitif	BoxMoule(unset)	BoxMoule(set)
boolean / Boolean	1.00	4.00	4.00
byte / Byte	1.00	4.00	4.48
short / Short	2.00	4.00	19.23
char / Character	2.00	4.00	24.03
int / Integer	4.00	4.00	27.06
long / Long	10.49	4.00	36.51
float / Float	4.00	4.00	27.06
double / Double	10.49	4.00	31.06

Lorsque je crée un tableau, j'utilise toujours 16 octets. Je ne suis pas sûr que les primitives aient utilisé plus de mémoire que prévu long et double. Puisqu'il s'agit d'un type Box (ensemble) et qu'il utilise 20 octets ou plus après Character, est-il strictement interdit de l'utiliser fréquemment?

Classe de chaîne

Jetons un coup d'œil à l'utilisation de la mémoire de la classe String.

// set empty
for (int i = 0;i < NUM;i++) {
    ary[i] = "";
}
// set new String
for (int i = 0;i < NUM;i++) {
    ary[i] = new String();
}

// set 10digit
for (int i = 0;i < NUM;i++) {
    ary[i] = new String("0123456789");
}

 -- String[] unset -- 
400016
4.00016
 -- String[] set empty -- 
400016
4.00016
 -- String[] set new String -- 
3105872
31.05872
 -- String[] set 10digit -- 
3105872
31.05872

New String pour tous les éléments consomme environ 31 octets. Cependant, il est étrange que même new String (" 0123456789 ") soit de 31 octets. Est-ce parce que l'élément interne private final byte [] value; est toujours la même référence?

Je l'ai donc corrigé pour que tous les éléments soient uniques.

for (int i = 0;i < NUM;i++) {
    ary[i] = String.format("%010d", i);
}
System.gc();

 -- String[] set 10digit -- 
4998968
49.98968

Il est devenu 49 octets par élément.

HashMap

Mettez 100 000 éléments dans HashMap.

Map<String, String> map = new HashMap<>();
for (int i = 0;i < NUM;i++) {
    map.put(String.valueOf(i), "A" + i);
}

13632176
136.32176

Il est devenu 136 octets par élément. Il semble que vous ayez besoin de le lire parce que vous ne pouvez pas comprendre la justification à moins de regarder la mise en œuvre.

Code source