List alist = new ArrayList();   alist.add(100); //box this

int x = alist.get(0); System.out.println(x);

What is the result?

Which are acceptable ways to call passIt?

// Method Signature

public static void passIt(Fruit[] fruits){}

satic public void main(String[] args) {

  Apple[] apples = {new Apple()};     /

  passIt(apples); //1

  Banana bananas[] = new Bananas[3];

  passIt(bananas);  //2

  Fruit[] fruits = new Fruit{new Fruit()};

  passIt(fruits); //3

}

Which of the following compile?

1)List<Number> alist= new ArrayList<Integer> ();

2)List<Number> alist= new List<Number>();

3)List<Object> alist= new ArrayList<Object>();

Which are acceptable ways to call passIt?

// Method Signature

public static void passIt(List<Fruit> fruits){}

satic public void main(String[] args) {

  // assume fruit types extend Fruit

  List<Apple> apples = new ArrayList<Apple>();

   passIt(apples);     //1

   passIt(new List <Banana>());  //2

   passIt(new ArrayList<Fruit>()); //3

}

What is the difference between Collections and Collection?

List 4 basic Collections

import java.util.*;
public class LetsNavigate{
public static void main(String[] args) {
  TreeMap<String, String> fruitMap = new TreeMap<String, String>();
  fruitMap.put("b", "bananna");
  fruitMap.put("c", "cherimoya");
  fruitMap.put("d", "durian");
 

  SortedMap<String, String> headFruitMap;
  headFruitMap = fruitMap.headMap("c");
 
  headFruitMap.pollFirstEntry()
  fruitMap.put("a", "apple");
  fruitMap.put("e", "eggfruit");

  System.out.println(headFruitMap);
}

Choose all that will be outputted:

a)a=apple
b)b=bananna
c)c=cherimoya
d)d=durian
e)e=eggplant

What is the result?

1. Compilation Error 
2. Exception
3. Prints "i=42"

public class IDidABadBadThing {
	public static void main(final String... args) {
		final List<Integer> ints = new ArrayList<Integer>();
		insert(ints);
		for (final Object i : ints) {
			System.out.println("i=" + i);
		}
	}

	private static void insert(List ints) {
		ints.add("42");
	}
}

List myIntegers = new ArrayList();

myIntegers.add(42);

Will not compile, primitives must be wrapped prior to adding. True or false?

To implement the Comparable interface a class must implement a single method.

a. compare()

b. compareTo()

c. compareObject()

d. comparable()

When overriding equals() you ____ take an arguement of type Object.

a. should never

b. should always

c. should sometimes

Given the following method signature:

public void addAnimal(List<Animal> animals)

Which of the following may be passed as an argument into the addAnimal method?

a) List<Dog> animals = new ArrayList<Dog>();
b) ArrayList<Dog> animals = new ArrayList<Dog>();
c) List<Animal> animals = new ArrayList<Animal>();
d) ArrayList<Animal> animals = new ArrayList<Animal>();
e) List<Animal> animals = new ArrayList<Dog>();

Given the following method signature:

public void myAnimal(List<? extends Animal> animals)

Answer the following questions:

a) What may be passed as an argument into the myAnimal method? 

b) What limitations, if any, will be enforced within the myAnimal method?

Given the following method signature:

public void myAnimal(List<? super Dog> animals)

Answer the following questions:

a) What may be passed as an argument into the myAnimal method? 

b) What generic specific limitations, if any, will be enforced within the myAnimal method?

What, if anything, is the difference between the following two declarations:

public void foo(List<?> list) //option a

public void foo(List<Object> list) //option b

What, if anything, is the problem with the following code?

import java.util.*;
public class TestWildcards {
  public static void main(String[] args) {
    List<Integer> myList = new ArrayList<Integer>();
    Bar b = new Bar();
    b.doInsert(myList);
  }
}
class Bar {
  void doInsert(List<?> list) {
    list.add(new Dog());
  }
}

What, if anything, is the problem with the following code?

import java.util.*;
public class TestWildcards {
  public static void main(String[] args) {
    List<Integer> myList = new ArrayList<Integer>();
    Bar b = new Bar();
    b.doInsert(myList);
  }
}
class Bar {
  void doInsert(List<Object> list) {
    list.add(new Dog());
  }
}

T/F: The of the following, if any, are identical:

List<? extends Object> //option a

List<?> //option b

List<Object> //option c

Which of the following will compile?

1. List<?> foo = new ArrayList<? extends Animal>();

2. List<?> list = new ArrayList<Dog>();

3. List<? extends Dog> list = new ArrayList<Integer>();

4. List<? extends Animal> aList = new ArrayList<Dog>();

5. List<? super Animal> list = new ArrayList<Dog>();

6. List<? super Dog> list = new ArrayList<Animal>();

What are the parameterized types defined in the class below, and will it compile?

public class UseTwo<T, X> {
  T one;
  X two;
  UseTwo(T one, X two) {
    this.one = one;
    this.two = two;
  }
  T getT() { return one; }
  X getX() { return two; }
}

T/F: The following code, specifying a range (bounds) for the type parameter will compile:

public class AnimalHolder<? extends Animal> { }

F. At the class level, a type must be used, rather than a wildcard (see example below):

public class AnimalHolder <T extends Animal> { }

(p. 627)

Before the return type of the method (see example below):

public <T> void makeArrayList(T t)

(p. 628)

T. The following example is legal:

public <T extends Number> void makeArrayList(T t)

(p. 628)

T. The following is legal:

public class Radio {
  public <T> Radio (T t) { } //legal constructor
}

(p. 628)

Answer the questions below with respect to wildcards and generics

1. When can the '?' wildcard syntax be used?
2. When is something other than the '?' used for wildcard syntax?
3. In those case(s), what is used in its place?

1. When declaring a reference for a variable
2. When creating generic classes or methods
3. Any legal Java identifier

(Exam Watch p. 629)