CSCI 162 - Lecture 4 - Collection Classes

Instructor's Class Notes

 

1. ADT - Abstract Data Type
• ADT definition - A class that uses information hiding to provide an interface for storing and retrieving data.
• Private Instance Variables - An ADT will require at least one private instance variable for storing the data and likely others for holding the state associated with how to access said data.
• Invariant of an ADT - In your ADT class, always make explicit statement of the rules that dictate how the instance variables are used. These rules are called the invariant of the ADT. All of the methods (except the constructors) can count on the invariant being valid when the method is called. Each method also has the responsibility of ensuring that the invariant is valid when the method finishes.

 

2. Java Arrays - Can provide an easy to use and understand private instance variable for data storage within an ADT.
• Length - The length of an array is fixed, making it a bit cumbersome, but that can be overcome with array cloning and copying.
• Arrays Utility Class - The Arrays utility class provides useful methods for manipulating arrays, including the copyOf() method for copying a specific range from one array to another.

 

3. The Bag ADT
• IntArrayBag - The bag of integers class. Think of this as an actual bag in which you can put one or more integers in at a time, take an integer out, etc.
• Programming challenges:
• Integers added to the collection are stored in the data integer array, which is a private instance variable.
• Must ensure that the data array is always large enough to hold all the integers added
• Since integers may be removed from the bag, there must be a way to trim the array to avoid carrying around unnecessary space not needed for holding the fewer integers than stored before.
• Documentation - Documentation for the class is here.
• Methods of Interest:
• add - adds a supplied integer to the bag.
• addMany - Takes one or more integers as parameters and adds them all. Note the syntax for a variable number of parameters.
• ensureCapacity - Given a total number of integers that may be added, grows the internal storage if needed to make sure that number of integers can be accommodated.
• getCapacity - Returns the total number of integers the bag can store.
• size - The current number of integers in the bag (has to be less than or equal to capacity).
• remove - Removes a specified integer value from the bag. Hint: Good test question... how exactly does the remove() method work?
• trimToSize - Removes any access data storage to make the capacity of the bag equal to its size.
• Source Code - Source code for the class is here.
• Bag Demonstration - Sample app here.

 

4. JUnit Testing
• Overview - JUnit provides a unit test validation tool for testing your Java classes.
• Unit Testing is the practice of a developer testing individual components of their code to assure correctness.
• Eclipse has, built-in JUnit4 and JUnit5 libraries.
• The Main book uses a version of JUnit4 for its tests. For alignment with the material and samples in the book, for this course you should also use JUnit4 tests.
• Creating a JUnit Test File
• Steps for creating a JUnit file within Eclipse:
1. Select the Class .java file (ie. IntArrayBag.java) from the Package Explorer
2. Right-mouse-click the .java file then select New > JUnit Test Case
3. In the JUnit Test Case dialog click on the New JUnit 4 test radio button at the top.
4. The Name of the test case .java file should be defaulted to the name of the class file with the word "Test" appended at the end. Change/enter if needed.
5. Click the Finish button to create your test file.
6. When asked if you want to add the JUnit library to your Java Build Path automatically indicate "Yes".
• The empty test file:
  

  
  import static org.junit.Assert.*;
  import org.junit.Test;
  
  public class BagDemonstrationTest {
  
  	@Test
  	public void test() {
  		fail("Not yet implemented");
  	}
  
  }                  
                      

• Fix Method Order - By default, test methods will execute in a seemingly random order (not in the order they appear in the file). This can be fixed by adding the following to the imports statements:
  

  
  import org.junit.runners.MethodSorters;
  import org.junit.FixMethodOrder;
  
  @FixMethodOrder(MethodSorters.NAME_ASCENDING)                    
                      

  
  By adding the above, your test methods will execute in alphabetical order.
• Writing JUnit Test Methods
• Give each method a meaningful name that describes its purpose and make sure each test method name uses an easily sorted naming convention: ie. a_testConstructors().
• The method can have any Java code within, but typically each method will instantiate one or more objects of the Class type being tested, optionally call mutator methods, and then have assertions that include logical expressions that use accessor methods in order to test for correct state.
• Anatomy of an Assertion - There are many assert statements available (see org.junit.Assert.*). One very useful is assertTrue:
  
  Syntax:

  
  assertTrue(<string message>, <boolean condition>);                    
                      

  Example:

  
  assertTrue("Should be empty after default constructor.", b.size()==0);                    
                      

• A good set of test methods will test:
1. All constructors of the class
2. All mutator methods of the class
3. The clone() method of the class, if there is one
4. The equals() method of the class, if there is one
5. All static methods of the class.
• Consider IntArrayBagTest.java (here).
• Running JUnit Tests
• To run your JUnit test file, simply select it in Package Explorer then click the run button within Eclipse.
• The "JUnit" pane will be displayed and it will indicate how many tests were run, errors and failures.
• The test methods will be run, in order, until the first failure, or to completion with all methods passing.
• Clicking on a failed test method in theJUnit window will open the .java file of the test module and highlight the failed assertion line.
• Examing the code of a test method that is failing along with the assertion that is failing should lead you to where to look in your Class file for issues. For example, if failing in the constructor test method with a boolean expression that considers the size() of your Class object after construction should lead you to a possible problem with either the constructor or the size() method.

 

5. The Sequence ADT - Much like the Bag ADT
• Maintains an Index - Unlike Bag, this class maintains a current pointer (or index) into the data stored such that any newly added doubles are added before or after that point in the sequence of doubles with the sequence maintained. Remember, the Bag class provided no structured way to add or retrieve its doubles.
• Documentation - Documentation of the ADT is here.
• Lab 3 assignment (here) is to implement the DoubleArraySeq.java class