Après avoir lu l'article Mécanismes et caractéristiques des classes d'implémentation de collection souvent utilisées en Java, utilisez arrayList pour implémenter le mécanisme que vous essayez de créer. Je me demandais lequel de la LinkedList est le meilleur, donc j'écrirai le résultat de la vérification du temps de calcul.
Ce que j'ai essayé de faire était un "tableau de routes".
Après avoir sécurisé le tableau, recherchez les éléments dans le chemin et extrayez la plus petite valeur de la plage qui remplit les conditions (par exemple, la plage qui ne peut être déterminée que si le tableau entier est déterminé, comme les 10 nombres au milieu du tableau). Je vise.
Sur la base de ce qui précède, considérez la classe à utiliser.
-Vérifiez la vitesse de recherche des éléments de linkedList après avoir créé un tableau.
-Si la vitesse de calcul est lente, comparez-la à la vitesse d'ajout de tableau de l'arraylist.
-Si la vitesse de calcul peut être tolérée, implémentez-la en utilisant la liste chaînée telle quelle.
Par conséquent, le code suivant est utilisé pour la comparaison à l'aide de l'instruction for et de l'instruction for étendue.
test.java
import java.util.LinkedList;
import java.util.Iterator;
public class test {
static final int LIMIT = 100_000;
static LinkedList<Integer> array = new LinkedList<Integer>();
static long sum = 0;
static {
for (int i = 0; i < LIMIT; i++) {
array.addLast(i);
}
}
static void addArrayNumbersWithFor() {
sum = 0L;
for (int i = 0; i < LIMIT; i++) {
sum += array.get(i);
}
}
static void addArrayNumbersWithAppliedFor() {
sum = 0L;
for (int value : array) {
sum += value;
}
}
static double measureCalculationTimeWithFor() {
//Obtenez l'heure de début en millisecondes
long ts1 = System.currentTimeMillis();
//Exécution du traitement
addArrayNumbersWithFor();
//Obtenez l'heure de fin en millisecondes
long te1 = System.currentTimeMillis();
//Temps de traitement milliseconde
long tmsec1 = te1 - ts1;
//Temps de traitement secondes
double tsec1 = (double) tmsec1 / 1000.0;
System.out.println(sum);
return tsec1;
}
static double measureCalculationTimeWithAppliedFor() {
//Obtenez l'heure de début en millisecondes
long ts1 = System.currentTimeMillis();
//Exécution du traitement
addArrayNumbersWithAppliedFor();
//Obtenez l'heure de fin en millisecondes
long te1 = System.currentTimeMillis();
//Temps de traitement milliseconde
long tmsec1 = te1 - ts1;
//Temps de traitement secondes
double tsec1 = (double) tmsec1 / 1000.0;
System.out.println(sum);
return tsec1;
}
public static void main(String[] args) {
System.out.println(test.measureCalculationTimeWithAppliedFor());
System.out.println(test.measureCalculationTimeWithFor());
}
}
A partir de ce résultat, lorsqu'une instruction for simple est utilisée, les éléments sont toujours acquis dans l'ordre à partir du premier élément de la boucle, alors que dans le cas de l'instruction for étendue, les informations de l'élément suivant sont obtenues à partir de l'élément précédent. On peut voir qu'il est acquis et l'élément suivant est acquis.
Si vous souhaitez ajouter des éléments à un tableau les uns après les autres et que vous ne savez pas combien en ajouter, vous voudrez utiliser une liste liée. Le goulot d'étranglement est la vitesse lente de l'accès aléatoire, mais on peut voir qu'il n'y a pas de vitesse lente car les éléments sont acquis dans l'ordre depuis le début en utilisant l'instruction for étendue. Je ne l'ai pas comparé à un tableau normal, mais il est basé sur l'hypothèse que le type de collection sera utilisé.
Recommended Posts