public static void print( Set s ) 
    {
        ArrayList copy = new ArrayList( s );  
				// constructor not in AP subset
           for( int i = 0; i < copy.size( ); i++ )
               System.out.println( copy.get( i ) );
    }  
	

public static void print (Set s)
{
   Iterator iter = s.iterator()
   while iter.hasNext()
	System.out.println(iter.next());
}

public static void print( Set s )
{
     for (Object o : s) System.out.println(o);
}

• Use of a generic API class is acceptable.
• Use of boxing/unboxing is acceptable.
• Use of a generalized for loop, if done correctly, is acceptable.

  public interface Fooable
  {
    void foo( ) { }  // Oops... no implementations allowed!
  }

• Most likely to be included: Use of generic API classes is the most likely Java 1.5 construct to be added to the subset. The baggage on this is relatively minimal, and it makes the questions easier to read by removing lots of casting and making it clear which types are being stored in the collections. For instance, in our questions we could declare types such as List<String>, Map<String,Integer>, and even Map<String,List<String>>. Students will probably find it easier to write code using the generic API classes. We would limit the scope of this in the simplest possible way.
  
  
• Least likely to be included: The enhanced for loop, typesafe enum, and static import directives are the least likely Java 1.5 constructs to be added to the subset. We do expect students will use the enhanced for loop on free-response solutions, but the additional syntactic sugar does not seem warranted to simply eliminate a simple line of code. The typesafe enum would seem to have lower priority than char, which is not in the subset now. And the static import directive seems like a very inappropriate construct for an introductory course.
  
  
• Most likely to be difficult to decide: Java 1.5 constructs on the borderline for subset addition, and likely to require the most discussion, are the implementation of generic classes and autoboxing. Unlike using generic classes, implementation of generics is fairly tricky, and it is possible that implementation of generic classes won't be in the subset at all. If implementation of generic classes is in the subset, only an extremely small portion of the fairly complex rules would likely be in the subset. Autoboxing makes some questions read more nicely and makes some code easier to write, but on the other hand, it means more material for teachers to discuss, possibly with obscure rules, with relatively little payoff.