title: Optimising Code an Array of Strings for a History in Java
body: <p>I am seeking guidance in the respect of optimising code. The code I have written is for a text-based game in which you type in commands into a command bar. One feature I wished to incorporate into my interface was the ability to scroll through a history of one's last 100 commands entered using the up and down arrow keys so that it would be more convenient for the user to play the game. </p>
  
  <p>I have designed a class in which uses a <code>String[]</code> that will store each new entry in the second position (<code>Array[1]</code>) and move all entries back one position while the first position of the array (<code>Array[0]</code>) is just a blank, empty string. The code initialises the array to have 101 values to compensate for the first position being a blank line.</p>
  
  <p>When a user inputs 0 - 100 in that order, it should then give me the reverse of the order (almost like a last in, first out kind of situation, but storing the last 100 values as opposed to removing them once they are accessed), and since 0 - 100 is 101 values, the last value will be overwritten. </p>
  
  <p>Thus, scrolling up through the history, it would give me 100, 99, 98, ..., 2, 1. If I were to select 50 from the list, it would then be 50, 100, 99, ..., 3, 2. The code indeed does this.</p>
  
  <p>The code is listed below:</p>
  
  <pre><code>public class CommandHistory {
  private String[] history;
  private final int firstIndex = 1;
  private static int currentIndex = 0;
  
  /**
   * Default constructor, stores last 100 entries of commands plus the blank
   * entry at the first index
   */
  public CommandHistory() {
      history = new String[101];
  }
  
  /**
   * 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 + 1];
  }
  
  /**
   * Returns the size (length) of the history list
   * 
   * @return The size (length) of the history list
   */
  private int size() {
      return history.length;
  }
  
  /**
   * Adds a command to the command history log
   * 
   * @param command
   *            Command to be added to the history log
   */
  public void add(String command) {
      history[0] = "";
      if (!command.equals("")) {
          for (int i = firstIndex; i &lt; size();) {
              if (history[i] == null) {
                  history[i] = command;
                  break;
              } else {
                  for (int j = size() - 1; j &gt; firstIndex; j--) {
                      history[j] = history[j - 1];
                  }
                  history[firstIndex] = command;
                  break;
              }
          }
          currentIndex = 0;
      }
  }
  
  /**
   * Gets the previous command in the history list
   * 
   * @return The previous command from the history list
   */
  public String previous() {
      if (currentIndex &gt; 0) {
          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 &gt;= 0 &amp;&amp; (history[currentIndex + 1] != null)) {
          currentIndex++;
      }
      return history[currentIndex];
  }
  
  /**
   * Clears the command history list
   */
  public void clear() {
      for (int i = firstIndex; i &lt; size(); i++) {
          history[i] = null;
      }
      currentIndex = 0;
  }
  
  /**
   * Returns the entire command history log
   */
  public String toString() {
      String history = "";
      for (int i = 0; i &lt; size(); i++) {
          history += this.history[i];
      }
      return history;
  }
  }
  </code></pre>
  
  <p>In my interface class, once the user types something into the command bar and hits enter, it will get the text currently stored in the bar, uses the add method to add it to the history, parses the command via another class, and then sets the text in the bar to blank.</p>
  
  <p>Pressing the up arrow calls the next method which scrolls up the list, and the down arrow calls the previous method which scrolls down the list.</p>
  
  <p>It seems to work in every way I wish it to, but I was wondering if there was some way to optimise this code or perhaps even code it in a completely different way. I am making this game to keep myself practiced in Java and also to learn new and more advanced things, so I'd love to hear any suggestions on how to do so.</p>