boolean[] vs BitSet: Qui est plus efficace?

• Boolean[] utilise environ 4-20 octets par valeur booléenne.
• boolean[] utilise environ 1 octet par valeur booléenne.
• BitSet utilise environ 1 bit par valeur booléenne.

La taille de la mémoire peut ne pas être un problème pour vous, auquel cas boolean[] peut-être plus simple de code.

Comme pour la mémoire, la documentation pour un BitSet a assez clair implications. En particulier:

Chaque bit a une taille actuelle, qui est le nombre de bits de l'espace
actuellement en cours d'utilisation par l'ensemble de bits. Notez que la taille est liée à la
la mise en œuvre d'un ensemble de bits, de sorte qu'il peut changer avec la mise en œuvre. L'
la longueur d'un ensemble de bits se rapporte à la logique de la longueur d'un ensemble de bits et est
définie indépendamment de la mise en œuvre.

La source pour Java bibliothèque de classes est publiquement disponible et on peut facilement vérifier par eux-mêmes. En particulier:

The internal field corresponding to the serialField "bits".
89 
90     private long[] words;

Comme pour la vitesse; il dépend de ce que l'on est en train de faire. En général, ne pense pas à la vitesse de l'avance; utiliser n'importe quel outil qui fait le plus de sens du point de vue sémantique et conduit à la plus claire code. Optimiser seulement après avoir fait observer que les exigences de rendement ne sont pas remplies et identifier les goulots d'étranglement.

Venir ALORS et vous demande si Un est plus rapide que B est ridicule pour de nombreuses raisons, y compris, mais certainement pas limité à:

1. Il dépend de l'application, dont personne ne répond a généralement accès. D'analyser et de profil dans le contexte, il est utilisé dans. Assurez-vous que c'est un goulot d'étranglement qui vaut de l'optimisation.
2. À ce genre de Questions que de demander à propos de la vitesse montrent généralement que les OP pense qu'ils se soucier de l'efficacité, mais n'était pas disposé à profil et n'a pas de définir des exigences de performance. Sous la surface, qui est habituellement un drapeau rouge que l'OP est dirigé dans la mauvaise voie.

Je sais que c'est une vieille question, mais il est venu jusqu'à récemment; et je crois que cela vaut la peine d'ajouter.

Ici vous pouvez voir un Mémoire/Temps de référence en comparant une valeur de type boolean[][] trianguar matrice versus BitSet[] matrice triangulaire.

Que j'ai créer, définir et de lire le (taille * (taille-1) /2) valeurs et de comparer l'utilisation de la mémoire et de temps...

Espérons que cette aide...

Ici le code... (juste un quikly sale code de test, désolé 😉

import java.util.BitSet;
import java.util.Date;
public class BooleanBitSetProfiler {
Runtime runtime;
int sum = 0;
public void doIt() {
runtime = Runtime.getRuntime();
long[][] bitsetMatrix = new long[30][2];
long[][] booleanMatrix = new long[30][2];
int size = 1000;
for (int i = 0; i < booleanMatrix.length; i++) {
booleanMatrix[i] = testBooleanMatrix(size);
bitsetMatrix[i] = testBitSet(size);
size += 2000;
}
int debug = 1;
for (int j = 0; j < booleanMatrix.length; j++){
System.out.print(booleanMatrix[j][0] + ";");
}
System.out.println();
for (int j = 0; j < booleanMatrix.length; j++){
System.out.print(booleanMatrix[j][1] + ";");
}
System.out.println();
for (int j = 0; j < bitsetMatrix.length; j++){
System.out.print(bitsetMatrix[j][0] + ";");
}
System.out.println();
for (int j = 0; j < bitsetMatrix.length; j++){
System.out.print(bitsetMatrix[j][1] + ";");
}
System.out.println();
}
private long memory () {
return runtime.totalMemory() - runtime.freeMemory();
}
private long[] testBooleanMatrix(int size) {
runtime.gc();
long startTime = new Date().getTime();
long startMemory = memory();
boolean[][] matrix = new boolean[size][];
for (int i = 0; i < size; i++) {
matrix[i] = new boolean[size - i - 1];
}
long creationMemory = memory();
long creationTime = new Date().getTime();
for (int i = 0; i < size; i++)  {
for (int j = 0; j < matrix[i].length; j++) {
matrix[i][j] = i % 2 == 0;
}
}
long setMemory = memory();
long setTime = new Date().getTime();
for (int i = 0; i < size; i++)  {
for (int j = 0; j < matrix[i].length; j++) {
if (matrix[i][j]) sum++;
}
}
long readTime = new Date().getTime();
System.out.println("Boolean[][] (size " + size + ")");
System.out.println("Creation memory " + printMem(creationMemory-startMemory) + ", set memory " + printMem(setMemory-startMemory));
System.out.println("Creation time " + printTime(creationTime-startTime) + ", set time " + printTime(setTime - creationTime) + " read time " + printTime(readTime - setTime) + "\n");
runtime.gc();
return new long[]{(setMemory-startMemory)/(1024*1024), (readTime-startTime)};
}
private long[] testBitSet(int size) {
runtime.gc();
long startTime = new Date().getTime();
long startMemory = memory();
BitSet[] matrix = new BitSet[size];
for (int i = 0; i < size; i++) {
matrix[i] = new BitSet(size - i - 1);
}
long creationMemory = memory();
long creationTime = new Date().getTime();
for (int i = 0; i < size; i++)  {
for (int j = 0; j < matrix[i].size(); j++) {
matrix[i].set(j, (i % 2 == 0));
}
}
long setMemory = memory();
long setTime = new Date().getTime();
for (int i = 0; i < size; i++)  {
for (int j = 0; j < matrix[i].size(); j++) {
if (matrix[i].get(j)) sum++;
}
}
long readTime = new Date().getTime();
System.out.println("BitSet[] (size " + size + ")");
System.out.println("Creation memory " + printMem(creationMemory-startMemory) + ", set memory " + printMem(setMemory-startMemory));
System.out.println("Creation time " + printTime(creationTime-startTime) + ", set time " + printTime(setTime - creationTime) + " read time " + printTime(readTime - setTime) + "\n");
runtime.gc();
return new long[]{(setMemory-startMemory)/(1024*1024), (readTime-startTime)};
}
private String printMem(long mem) {
mem = mem / (1024*1024);
return mem + "MB";
}
private String printTime(long milis) {
int seconds = (int) (milis / 1000);
milis = milis % 1000;
return seconds > 0 ? seconds + "s " + milis + "ms" : milis + "ms";
}
}

Je crois qu'un BitSet de mémoire et de CPU-efficace, c'est qu'elle peut à l'interne pack les bits en int, aspire, ou les types de données natifs, tandis qu'une valeur de type boolean[] nécessite un octet pour chaque bit de données. En outre, si vous étiez à utiliser les autres méthodes (et, ou, etc), vous constaterez que le BitSet est plus efficace, car il n'est pas nécessaire pour parcourir chaque élément d'un tableau; bit-à-bit de mathématiques est utilisé à la place.