Optimisation du code un tableau de chaînes pour un historique en Java

Les commentaires à votre question ont déjà souligné que vous essayez en quelque sorte de réinventer la roue en implémentant les fonctionnalités que la bibliothèque de classes Java standard fournit déjà dans une certaine mesure (voir LinkedList/Queue et Arraylist). Mais puisque vous dites que vous voulez vous maintenir pratiqué en Java, je suppose que c'est parfaitement bien si vous essayez d'implémenter votre propre historique de commandes à partir de zéro.

Voici quelques-unes de mes observations/suggestions:

1) Il n'est pas nécessaire et très contre-intuitif pour déclarer un premier indice final de 1. Il serait facile de commencer avec un index par défaut de 0 et d'ajouter les vérifications correspondantes si nécessaire.

2) Oubliez votre méthode private size () - elle renvoie simplement la longueur du tableau interne de toute façon (c'est-à-dire la capacité initiale+1). Envisagez plutôt d'ajouter une méthode public size () qui renvoie le nombre réel de commandes ajoutées et met à jour en interne la taille réelle lors de l'ajout de nouvelles commandes (voir par exemple java.util.Liste de tableaux pour référence).

3) Pour le moment, chaque appel à add(commande String) définira history[0]="", ce qui n'est pas nécessaire. Si vous souhaitez que le premier indice "", défini dans le constructeur. C'est aussi un signe clair, qu'il serait peut-être préférable de commencer avec un premier indice de 0 au lieu de 1.

4) Un problème mineur: "si (!commande.equals ( "")) " pendant votre méthode add est peut-être OK pour une telle classe spécialisée, mais il devrait certainement être commenté dans la documentation de la méthode. Personnellement, je laisserais toujours la classe appelante décider si une commande "" vide est considérée comme valide ou non. De plus, cette méthode lancera une NullPointerException non documentée, lorsque null est utilisé comme argument. Envisagez de changer cela en " if (!"".equals(command))" ou lancer une exception IllegalArgumentException si null est ajouté.

5) "if (history [i] = = null)" pendant la méthode add est complètement inutile, si vous gardez en interne un pointeur sur la taille réelle des commandes-c'est en fait un cas particulier qui ne sera vrai que lorsque la toute première commande est ajoutée à l'historique des commandes (c'est-à-dire quand sa taille réelle == 0).

6) Avoir deux boucles for imbriquées dans votre implémentation de méthode add est également inutile, si vous gardez un pointeur sur la taille réelle (voir l'exemple ci-dessous)

7) Je reconsidérerais s'il est nécessaire de garder un pointeur sur l'index actuel dans l'historique des commandes. Personnellement j'éviterais de stocker un tel pointeur et laisserais ces détails à la classe appelante - c'est-à-dire supprimer les méthodes précédentes et suivantes et fournir un itérateur avant/arrière et/ou un accès aléatoire à l'index des commandes disponibles. Fait intéressant, lorsque cette fonctionnalité est supprimée de votre classe d'historique de commandes, elle se résume en fait à une implémentation d'une LinkedList ou d'une ArrayList - quelle que soit la façon dont vous allez. Donc, à la fin, l'utilisation de l'une des collections Java intégrées serait en fait la voie à suivre.

8) Enfin et surtout je reconsidérerais si c'est le cas utile pour insérer des commandes ajoutées au début de la liste - je crois qu'il serait plus naturel de les ajouter à la fin comme le fait ArrayList. L'ajout des commandes à la fin rendrait inutile l'échange de toutes les commandes en cours lors de chaque appel à add ()...

Voici quelques-unes des modifications suggérées à votre classe (pas vraiment testées...)

public class CommandHistory {
private String[] history;
private int size;
private static int currentIndex = 0;

/**
 * Default constructor, stores last 100 entries of commands plus the blank
 * entry at the first index
 */
public CommandHistory() {
    this(100);
}

/**
 * Constructor with a capacity, stores the last (capacity) entries of
 * commands plus the blank entry at the first index
 * 
 * @param capacity
 *            Capacity of the commands history list
 */
public CommandHistory(int capacity) {
    history = new String[capacity];
}

/**
 * Returns the size (length) of the history list
 * 
 * @return The size (length) of the history list
 */
public int size() {
    return size;
}

/**
 * Adds a command to the command history log
 * 
 * @param command
 *            Command to be added to the history log
 */
public void add(String command) {
    if (!"".equals(command)) {
        if (this.size < history.length) {
            this.size++;
        }
        for (int i = size-1; i >0; i--) {
            history[i] = history[i-1];
        }
        history[0] = command;
        currentIndex = 0;
    }
}

/**
 * Gets the previous command in the history list
 * 
 * @return The previous command from the history list
 */
public String previous() {
    if (currentIndex >= 0 && currentIndex < size-1) {
        currentIndex++;
    }
    return history[currentIndex];
}

/**
 * Gets the next command in the history list
 * 
 * @return The next command from the history list
 */
public String next() {
    if (currentIndex > 0 && currentIndex < size) {
        currentIndex--;
    }
    return history[currentIndex];
}

/**
 * Clears the command history list
 */
public void clear() {
    for (int i = 0; i < size; i++) {
        history[i] = null;
    }
    currentIndex = 0;
}

/**
 * Returns the entire command history log
 */
public String toString() {
    String history = "";
    for (int i = 0; i < size; i++) {
        history += this.history[i] + ", ";
    }
    return history;
}

}

Eh Bien, je suppose que j'ai investi beaucoup trop de temps pour cela, mais j'ai appris pas mal moi-même à la manière grâce ;-) J'espère que certains de cela est utile pour vous.