Filling Array

[Teri Fisher]

I am trying to write the test code in Main and don't understand how to fill my array with the methods we are supposed to use. Thanks in advance.

public class DoubleArraySeq implements Cloneable
{
   // Invariant of the DoubleArraySeq class:
   //   1. The number of elements in the seqeunces is in the instance variable 
   //      manyItems.
   //   2. For an empty sequence (with no elements), we do not care what is 
   //      stored in any of data; for a non-empty sequence, the elements of the
   //      sequence are stored in data[0] through data[manyItems-1], and we
   //      don�t care what�s in the rest of data.
   //   3. If there is a current element, then it lies in data[currentIndex];
   //      if there is no current element, then currentIndex equals manyItems. 
 
   private double[ ] data;
   private int manyItems;
   private int currentIndex; 
   
   /**
   * Initialize an empty sequence with an initial capacity of 10.  Note that
   * the addAfter and addBefore methods work
   * efficiently (without needing more memory) until this capacity is reached.
   * @param - none
   * @postcondition
   *   This sequence is empty and has an initial capacity of 10.
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for: 
   *   new double[10].
   **/   
 
   public DoubleArraySeq( )
   {
     data = new double[10];
      manyItems = 0;
      currentIndex = 5;
   }    
 
   /**
   * Initialize an empty sequence with a specified initial capacity. Note that
   * the addAfter and addBefore methods work
   * efficiently (without needing more memory) until this capacity is reached.
   * @param initialCapacity
   *   the initial capacity of this sequence
   * @precondition
   *   initialCapacity is non-negative.
   * @postcondition
   *   This sequence is empty and has the given initial capacity.
   * @exception IllegalArgumentException
   *   Indicates that initialCapacity is negative.
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for: 
   *   new double[initialCapacity].
   **/   
 
   public DoubleArraySeq(int initialCapacity)
   {
      if (initialCapacity < 0)
      throw new IllegalArgumentException
      ("The initialCapacity is negative: " +initialCapacity);
      data = new double[10];
      manyItems = 0;
      currentIndex = 0;
   }
 
   /**
   * Add a new element to this sequence, after the current element. 
   * If the new element would take this sequence beyond its current capacity,
   * then the capacity is increased before adding the new element.
   * @param element
   *   the new element that is being added
   * @postcondition
   *   A new copy of the element has been added to this sequence. If there was
   *   a current element, then the new element is placed after the current
   *   element. If there was no current element, then the new element is placed
   *   at the end of the sequence. In all cases, the new element becomes the
   *   new current element of this sequence. 
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for increasing the sequence's capacity.
   * @note
   *   An attempt to increase the capacity beyond
   *   Integer.MAX_VALUE will cause the sequence to fail with an
   *   arithmetic overflow.
   **/
 
   public void addAfter(int element)
   {
     int i;
      if (manyItems == data.length)
      {//try to double capacity
      ensureCapacity(manyItems*2 + 1);
      }
      if (!isCurrent())
      data[manyItems] = element;
      currentIndex =  manyItems;
      manyItems++;      
      for      
        (i = manyItems; i > currentIndex; i++)
      data[i] = data[i+1];
      data[currentIndex] = element;
      manyItems++;
      currentIndex++;
   }
   
   /**
   * Add a new element to this sequence, before the current element. 
   * If the new element would take this sequence beyond its current capacity,
   * then the capacity is increased before adding the new element.
   * @param element
   *   the new element that is being added
   * @postcondition
   *   A new copy of the element has been added to this sequence. If there was
   *   a current element, then the new element is placed before the current
   *   element. If there was no current element, then the new element is placed
   *   at the start of the sequence. In all cases, the new element becomes the
   *   new current element of this sequence. 
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for increasing the sequence's capacity.
   * @note
   *   An attempt to increase the capacity beyond
   *   Integer.MAX_VALUE will cause the sequence to fail with an
   *   arithmetic overflow.
   **/
 
   public void addBefore(int element)
   {
      int i;
      if (manyItems == data.length)
      {//try to double capacity
      ensureCapacity(manyItems*2 + 1);
      }
      if (!isCurrent())
      data[manyItems] = element;
      currentIndex =  manyItems;
      manyItems++; 
      for      
        (i = manyItems; i > currentIndex; i--)
      data[i] = data[i-1];
      data[currentIndex] = element;
      manyItems++;
      currentIndex++;
   }   
   
   /**
   * Place the contents of another sequence at the end of this sequence.
   * @param addend
   *   a sequence whose contents will be placed at the end of this sequence
   * @precondition
   *   The parameter, addend, is not null. 
   * @postcondition
   *   The elements from addend have been placed at the end of 
   *   this sequence. The current element of this sequence remains where it 
   *   was, and the addend is also unchanged.
   * @exception NullPointerException
   *   Indicates that addend is null. 
   * @exception OutOfMemoryError
   *   Indicates insufficient memory to increase the size of this sequence.
   * @note
   *   An attempt to increase the capacity beyond
   *   Integer.MAX_VALUE will cause an arithmetic overflow
   *   that will cause the sequence to fail.
   **/
 
   public void addAll(DoubleArraySeq addend)
   {
      if (addend == null)
 
         throw new NullPointerException
 
         ("DoubleArraySeq is null");
 
     ensureCapacity(manyItems + addend.manyItems);
 
     System.arraycopy(addend.data, 0, data, manyItems, addend.manyItems); 
 
     manyItems = manyItems + addend.manyItems; 
 
   }  
      
   /**
   * Move forward, so that the current element is now the next element in
   * this sequence.
   * @param - none
   * @precondition
   *   isCurrent() returns true. 
   * @postcondition
   *   If the current element was already the end element of this sequence 
   *   (with nothing after it), then there is no longer any current element. 
   *   Otherwise, the new element is the element immediately after the 
   *   original current element.
   * @exception IllegalStateException
   *   Indicates that there is no current element, so 
   *   advance may not be called.
   **/
 
   public void advance( )
   {
   if (isCurrent())
   {
   currentIndex++; 
   }      
   }   
   
   /**
   * Generate a copy of this sequence.
   * @param - none
   * @return
   *   The return value is a copy of this sequence. Subsequent changes to the
   *   copy will not affect the original, nor vice versa. Note that the return
   *   value must be type cast to a DoubleArraySeq before it can be used.
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for creating the clone.
   **/ 
 
   public Object clone( )
   {  // Clone a DoubleArraySeq object.
      DoubleArraySeq answer;
      
      try
      {
         answer = (DoubleArraySeq) super.clone( );
      }
      catch (CloneNotSupportedException e)
      {  // This exception should not occur. But if it does, it would probably
         // indicate a programming error that made super.clone unavailable.
         // The most common error would be forgetting the "Implements Cloneable"
         // clause at the start of this class.
         throw new RuntimeException
         ("This class does not implement Cloneable");
      }
      
      answer.data = (double [ ]) data.clone( );
      
      return answer;
   }   
 
   /**
   * Create a new sequence that contains all the elements from one sequence
   * followed by another.
   * @param s1
   *   the first of two sequences
   * @param s2
   *   the second of two sequences
   * @precondition
   *   Neither s1 nor s2 is null.
   * @return
   *   a new sequence that has the elements of s1 followed by the
   *   elements of s2 (with no current element)
   * @exception NullPointerException.
   *   Indicates that one of the arguments is null.
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for the new sequence.
   * @note
   *   An attempt to create a sequence with a capacity beyond
   *   Integer.MAX_VALUE will cause an arithmetic overflow
   *   that will cause the sequence to fail.
   **/   
 
   public static DoubleArraySeq catenation(DoubleArraySeq s1, DoubleArraySeq s2)
   {
   if ((s1 == null)&& (s2 == null))
   throw new NullPointerException("s1 or s2 is null");
   
      DoubleArraySeq s3 = new DoubleArraySeq();
//      s3.data[]= s1.data[] + s2.data[];
      s3.manyItems = s1.manyItems + s2.manyItems;
      s3.currentIndex = s1.currentIndex + s2.currentIndex;
      
     
      return s3;
   }
 
   /**
   * Change the current capacity of this sequence.
   * @param minimumCapacity
   *   the new capacity for this sequence
   * @postcondition
   *   This sequence's capacity has been changed to at least minimumCapacity.
   *   If the capacity was already at or greater than minimumCapacity,
   *   then the capacity is left unchanged.
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for: new int[minimumCapacity].
   **/
 
   public void ensureCapacity(int minimumCapacity)
   {
      double[] biggerArray;
      if (data.length < minimumCapacity)
      {
      biggerArray = new double [minimumCapacity];
      System.arraycopy(data, 0, biggerArray, 0, manyItems);
      data = biggerArray;
      }
   }
   
   /**
   * Accessor method to get the current capacity of this sequence. 
   * The add method works efficiently (without needing
   * more memory) until this capacity is reached.
   * @param - none
   * @return
   *   the current capacity of this sequence
   **/
 
   public double getCapacity( )
   {
      return data.length;
   }
 
   /**
   * Accessor method to get the current element of this sequence. 
   * @param - none
   * @precondition
   *   isCurrent() returns true.
   * @return
   *   the current element of this sequence
   * @exception IllegalStateException
   *   Indicates that there is no current element, so 
   *   getCurrent may not be called.
   **/
 
   public double getCurrent( )
   {
      return currentIndex;
   }
 
   /**
   * Accessor method to determine whether this sequence has a specified 
   * current element that can be retrieved with the 
   * getCurrent method. 
   * @param - none
   * @return
   *   true (there is a current element) or false (there is no current element at the moment)
   **/
 
   public boolean isCurrent( )
   {
      if (currentIndex > 0)
      {
      return true;
      }
      else
      {
      return false;
      }
   }
              
   /**
   * Remove the current element from this sequence.
   * @param - none
   * @precondition
   *   isCurrent() returns true.
   * @postcondition
   *   The current element has been removed from this sequence, and the 
   *   following element (if there is one) is now the new current element. 
   *   If there was no following element, then there is now no current 
   *   element.
   * @exception IllegalStateException
   *   Indicates that there is no current element, so 
   *   removeCurrent may not be called. 
   **/
 
      public void removeCurrent( )
   {
       if (isCurrent() == true)
     {
     if (currentIndex == manyItems - 1)
     {
     //On last item, no elements to move and decrementing manyItems below will eliminate this element,
     // do nothing
     }
     else
     {
     //Shuffle elements over
     for (int i = currentIndex; i <manyItems -1; i++ )
     {
     data[i] = data[i+1];
     }
     }
     
         manyItems--;
    }
     else
     {
     throw new IllegalStateException
      ("There is no current element to remove!");
       } 
   }                
   
   /**
   * Determine the number of elements in this sequence.
   * @param - none
   * @return
   *   the number of elements in this sequence
   **/ 
 
   public int size( )
   {
      return manyItems;
   }   
   
   /**
   * Set the current element at the front of this sequence.
   * @param - none
   * @postcondition
   *   The front element of this sequence is now the current element (but 
   *   if this sequence has no elements at all, then there is no current 
   *   element).
   **/ 
   
   public void start( )
   {
    if(this==null)
    
       throw new NullPointerException
       
       ("Current Index is 0");
       
    else
       currentIndex = 0;
   }
      
   /**
   * Reduce the current capacity of this sequence to its actual size (i.e., the
   * number of elements it contains).
   * @param - none
   * @postcondition
   *   This sequence's capacity has been changed to its current size.
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for altering the capacity. 
   **/
 
   public void trimToSize( )
   {
      double[] trimmedArray;
      
      if (data.length != manyItems)
      {
         trimmedArray = new double [manyItems];
         System.arraycopy(data, 0, trimmedArray, 0, manyItems);
         data  = trimmedArray;
      }      
   }      
}
 
Main--------------------------------------------------
 
public class DoubleArraySeqDemo 
{
 
    public static void main(String[]args)
    {
    //testing constructors
    DoubleArraySeq test1 = new DoubleArraySeq();
// int[] copyFrom = {1,2,3,4,5,6,7,8,9};
        
       test1.addAfter(4);
    test1.addAfter(2);
    test1.start();
    test1.addAfter(6);
    System.out.println(test1.size());
//    System.out.println(test1.getCurrent());
//    test1.advance();
//    System.out.println(test1.getCurrent());
//    test1.advance();
//    System.out.println(test1.getCurrent());  
    }   
}

[marc weber]

That's 465 lines of code!

Can you focus on a few lines and tell us where exactly you're having trouble?

[Teri Fisher]

Sorry, I guess I wanted to show what I had to work with, I wanted to put in an add method but we are supposed to use what is in our outline.

public class DoubleArraySeq implements Cloneable
{
 
   private double[ ] data;
   private int manyItems;
   private int currentIndex; 
 
   public DoubleArraySeq( )
   {
     data = new double[10];
      manyItems = 0;
      currentIndex = 5;
   }    
 
   public DoubleArraySeq(int initialCapacity)
   {
      if (initialCapacity < 0)
      throw new IllegalArgumentException
      ("The initialCapacity is negative: " +initialCapacity);
      data = new double[10];
      manyItems = 0;
      currentIndex = 0;
   }
 
   public void addAfter(int element)
   {
     int i;
      if (manyItems == data.length)
      {//try to double capacity
      ensureCapacity(manyItems*2 + 1);
      }
      if (!isCurrent())
      data[manyItems] = element;
      currentIndex =  manyItems;
      manyItems++;      
      for      
        (i = manyItems; i > currentIndex; i++)
      data[i] = data[i+1];
      data[currentIndex] = element;
      manyItems++;
      currentIndex++;
   }
   
 
   public void addBefore(int element)
   {
      int i;
      if (manyItems == data.length)
      {//try to double capacity
      ensureCapacity(manyItems*2 + 1);
      }
      if (!isCurrent())
      data[manyItems] = element;
      currentIndex =  manyItems;
      manyItems++; 
      for      
        (i = manyItems; i > currentIndex; i--)
      data[i] = data[i-1];
      data[currentIndex] = element;
      manyItems++;
      currentIndex++;
   }     
 
   public void addAll(DoubleArraySeq addend)
   {
      if (addend == null)
 
         throw new NullPointerException
 
         ("DoubleArraySeq is null");
 
     ensureCapacity(manyItems + addend.manyItems);
 
     System.arraycopy(addend.data, 0, data, manyItems, addend.manyItems); 
 
     manyItems = manyItems + addend.manyItems; 
 
   }        
 
   public void advance( )
   {
   if (isCurrent())
   {
   currentIndex++; 
   }      
   }      
 
   public Object clone( )
   {  // Clone a DoubleArraySeq object.
      DoubleArraySeq answer;
      
      try
      {
         answer = (DoubleArraySeq) super.clone( );
      }
      catch (CloneNotSupportedException e)
      {  // This exception should not occur. But if it does, it would probably
         // indicate a programming error that made super.clone unavailable.
         // The most common error would be forgetting the "Implements Cloneable"
         // clause at the start of this class.
         throw new RuntimeException
         ("This class does not implement Cloneable");
      }
      
      answer.data = (double [ ]) data.clone( );
      
      return answer;
   }   
 
   public static DoubleArraySeq catenation(DoubleArraySeq s1, DoubleArraySeq s2)
   {
   if ((s1 == null)&& (s2 == null))
   throw new NullPointerException("s1 or s2 is null");
   
      DoubleArraySeq s3 = new DoubleArraySeq();
//      s3.data[]= s1.data[] + s2.data[];
      s3.manyItems = s1.manyItems + s2.manyItems;
      s3.currentIndex = s1.currentIndex + s2.currentIndex;
      
     
      return s3;
   }
 
   public void ensureCapacity(int minimumCapacity)
   {
      double[] biggerArray;
      if (data.length < minimumCapacity)
      {
      biggerArray = new double [minimumCapacity];
      System.arraycopy(data, 0, biggerArray, 0, manyItems);
      data = biggerArray;
      }
   }   
 
   public double getCapacity( )
   {
      return data.length;
   }
 
   
 
   public double getCurrent( )
   {
      return currentIndex;
   }
 

   public boolean isCurrent( )
   {
      if (currentIndex > 0)
      {
      return true;
      }
      else
      {
      return false;
      }
   }
              
 
      public void removeCurrent( )
   {
       if (isCurrent() == true)
     {
     if (currentIndex == manyItems - 1)
     {
     //On last item, no elements to move and decrementing manyItems below will eliminate this element,
     // do nothing
     }
     else
     {
     //Shuffle elements over
     for (int i = currentIndex; i <manyItems - 1; i++)
     {
     data[i] = data[i+1];
     }
     }
     
         manyItems--;
    }
     else
     {
     throw new IllegalStateException
      ("There is no current element to remove!");
       } 
   } 
 
   public int size( )
   {
      return manyItems;
   }     
   
   public void start( )
   {
    if(this==null)
    
       throw new NullPointerException
       
       ("Current Index is 0");
       
    else
       currentIndex = 0;
   }      
 
   public void trimToSize( )
   {
      double[] trimmedArray;
      
      if (data.length != manyItems)
      {
         trimmedArray = new double [manyItems];
         System.arraycopy(data, 0, trimmedArray, 0, manyItems);
         data  = trimmedArray;
      }      
   }      
}
Main-----------------------
 
public class DoubleArraySeqDemo 
{
    public static void main(String[]args)
    {
    //testing constructors
    DoubleArraySeq test1 = new DoubleArraySeq();
// int[] copyFrom = {1,2,3,4,5,6,7,8,9};
        
       test1.addAfter(4);
    test1.addAfter(2);
    test1.start();
    test1.addAfter(6);
    System.out.println(test1.size());
//    System.out.println(test1.getCurrent());
//    test1.advance();
//    System.out.println(test1.getCurrent());
//    test1.advance();
//    System.out.println(test1.getCurrent())
   }
 }

[Henry Wong]

I wanted to put in an add method but we are supposed to use what is in our outline.

Basically, you are writing test code. If you modify your class with special methods just for your test code, aren't you just wasting a testing opportunity?

Your class seems to have two add methods that add individual elements -- addBefore and addAfter. Do they work correctly? Have you tested them? If you have tested them, I am assuming that you wrote a loop that load them up? And if you did, can you reuse that testing code here?

Henry

[Teri Fisher]

I guess that's my problem, I was trying to use my addAfter in my test code to get started but was unsuccessful. Once I get going with my array I think I'll be fine, I think that I confuse myself with my variables and I'm stuck.

[Teri Fisher]

I am narrowing it down to my addAfter and addBefore methods now that they are fixed (I think), my question is about the outputs. I know it is still too much code but I am not understanding my output--
1)Why is the addBefore order reversed and why does the list for test 1 not display 9 from the addAfter?
2)Why are there three sets of zeros at the end of the double list?

public void addAfter(double element)
   {    
      if (manyItems == data.length)
      {//try to double capacity
      ensureCapacity(manyItems*2 + 1);
      }
      if (!isCurrent())
      {      
      currentIndex =  manyItems;
      }            
      for (int i = manyItems; i > currentIndex+1; i--)
      {
        data[i] = data[i-1];      
      }
      data[currentIndex+1] = element;
      manyItems++;
      currentIndex++;
   }
   
 public void addBefore(double element)
   {
      if (manyItems == data.length)
      {//try to double capacity
      ensureCapacity(manyItems*2 + 1);
      }
      if (!isCurrent())
      currentIndex = 0; 
      for (int i = manyItems; i > currentIndex; i--)
      {
      data[i] = data[i-1];
      }      
      data[currentIndex] = element;
      manyItems++;
   }  
Main TEST Code-----------------
 
public class DoubleArraySeqDemo {
    public static void main(String[]args)
    {
    //testing constructor
    //using addAfter to fill the array
    DoubleArraySeq test1 = new DoubleArraySeq();
    test1.addAfter(1.0);
    test1.addAfter(2.0);
    test1.addAfter(3.0);
    test1.addAfter(4.0);
    test1.addAfter(5.0);
    test1.addAfter(6.0);
    test1.addAfter(7.0);
    test1.addAfter(8.0);
    test1.addAfter(98.0);
       System.out.println("This is the size of the array: " +test1.size());
       System.out.println("The array list using addAfter to fill it:");
    test1.display();
    System.out.println("---------------");
       test1.addBefore(11.0);
    test1.addBefore(2.0);
    test1.addBefore(3.0);
    test1.addBefore(4.0);
    test1.addBefore(5.0);
    test1.addBefore(6.0);
    test1.addBefore(7.0);
    test1.addBefore(8.0);
    test1.addBefore(99.0);
    
       System.out.println("This is the size of the array: " +test1.size());
       System.out.println("The array list using addBefore to fill it:");
    test1.display();
    System.out.println("---------------");
    
    DoubleArraySeq test2 = new DoubleArraySeq();
    test2.addBefore(11.0);
    test2.addBefore(1.0);
    test2.addBefore(2.0);
    test2.addBefore(3.0);
    test2.addBefore(4.0);
    test2.addBefore(5.0);
    test2.addBefore(6.0);
    test2.addBefore(7.0);
    test2.addBefore(8.0);
    test2.addBefore(999.0);
       System.out.println("This is the size of the array: " +test2.size());
       System.out.println("The array list using addBefore to fill it:");
    test2.display();
    System.out.println("---------------"); 
}
--OUTPUT--
This is the size of the array: 9
The array list using addAfter to fill it:
0.0
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
98.0
---------------
This is the size of the array: 18
The array list using addBefore to fill it:
0.0
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
99.0
8.0
7.0
6.0
5.0
4.0
3.0
2.0
11.0
0.0
0.0
0.0
---------------
This is the size of the array: 10
The array list using addBefore to fill it:
999.0
8.0
7.0
6.0
5.0
4.0
3.0
2.0
1.0
11.0
---------------
Current element is: 0.0