Answer:

Generic programming means writing data structures and subroutines that can be used for many different types of data. The alternative would be to write a new data structure or subroutine for each different type of data, even when they would all be essentially identical except for the type name. For example, a single generic sort routine can be used for sorting lists that contain data of any type. The alternative is one routine for sorting lists of integers, one for sorting lists of strings, one for storing arrays of real numbers, and so on.

Answer:

LinkedList<int> is an attempt to use a generic class with a type parameter of type int, which is a primitive type. Generic programming in Java works only for objects, and not for the primitive types, so a type parameter of primitive type is not allowed. However, it is possible to use the wrapper class Integer in place of int. An object of type LinkedList<Integer> can be used almost as if it were actually a list of ints.

Answer:

One of the principle features of Java's generic programming framework is Collections. There are several types of collection (including LinkedList, ArrayList, TreeSet, and HashSet). In order to deal with all the different types of collection in a generic way, we need a generic way to access all the elements in a collection. An iterator makes this possible. An iterator is an object associated with a collection that makes it possible to traverse the collection (that is, to visit each of the items in the collection in turn). Code written using iterators will work for any type of collection. (Note, however, that explicit use of an iterator can often be avoided by using a for-each loop.)

Answer:

Using an iterator:

int sum = 0;
Iterator<Integer>  iter = integers.iterator();
while ( iter.hasNext() ) {
   sum += iter.next();
}

The statement "sum += iter.next()" relies on the automatic conversion from type Integer to type int. It could also be written "sum += iter.next().intValue()".

Using a for-each loop:

int sum = 0;
for ( int number : integers ) {   // ( Could also use "Integer number : integers". )
   sum += number;
}

Note that either of these two solutions will fail if integers contains a null value.

Answer:

An abstract data type is defined by the operations that can be performed on it, not by the way the data is actually stored or by the way the operations are implemented. An interface such as List defines operations that can be performed, but says nothing about how they are to be implemented. In fact, there can be many different implementations. For example, both LinkedList and ArrayList implement the List interface. They are different "concrete" data types that implement the same abstract data type.

Answer:

A Set cannot contain duplicate elements. Adding an item to the set has no effect if that item is already in the set. (Note that exactly what it means to say that two items are the same depends on the type of set. For HashSet, two items are tested for equality using the equals() method. For a TreeSet, the test for equality uses the compareTo() method from the Comparable interface or the compare() method from a Comparator.)

Answer:

The key/value pairs in a TreeMap are sorted so that the keys are in ascending order. (For this reason, it must be possible to compare the keys in a TreeMap, using a compareTo() method or compare(). Either the keys must implement the Comparable interface or a Comparator must be provided to do the comparison.)

Answer:

The hash code of an object is an integer that tells where that object should be stored in a hash table. A hash table is an array of linked lists. When an object is stored in a hash table, it is added to one of these linked lists. The object's hash code is the index of the position in the array where the object is stored. All objects with the same hash code go into the same linked list. In Java, every object obj has a method obj.hashCode() that is used to compute hash codes for the object. If the object is to be stored in a hash table of size N, then the hash code that is used for the object is Math.abs(obj.hashCode())%N.

Answer:

The interface Comparable<Date> specifies the method "public int compareTo(Date d)", which will be used to compare two objects of type Date. The compareTo() method must be added to the class, and the class must be declared to implement the interface. To compare two dates, first try comparing the years. If the years are equal, try comparing the months. If the months are also equal, compare the days.

class Date implements Comparable<Date> {
   int month;  // Month number in range 1 to 12.
   int day;    // Day number in range 1 to 31.
   int year;   // Year number.
   Date(int m, int d, int y) {
      month = m;
      day = d;
      year = y;
   }
   public int compareTo( Date otherDate ) {
           // Returns 1, 0, or -1 if this date is greater than, equal to,
           // or less than otherDate, respectively.
      if (year < otherDate.year)
         return -1;
      else if (year > otherDate.year)
         return 1;
      else { // Years are equal; compare months.
         if (month < otherDate.month)
            return -1;
         else if (month > otherDate.month)
            return 1;
         else { // Years and months are equal; compare days.
            if (day < otherDate.day)
               return -1;
            else if (day > otherDate.day)
               return 1;
            else 
               return 0;
         }
      }
   }
}

Answer:

I will give two solutions. One of them simply looks up each date in December, 2018 in the map and prints the corresponding value, if there is one. The other iterates though a submap that contains all the entries for dates in that month.

A solution using the map's get() method:

      for (int day = 1; day <= 31; day++) {
           // Get the info for one day in December, 2018
         Date date = new Date(12,day,2018); // The key.
         String info = syllabus.get(date);  // Get the value for that key.
                                            // (Can be null if there is no
                                            // entry in the map for this date.)
         if (info != null)
            System.out.println("December " + day + ": " + info);
      }


A solution using a submap (harder, but more efficient):

      Date startDate = new Date(12,1,2018); // Starting date for submap.
      Date endDate = new Date(1,1,2019);    // Ending date for submap.
                                            // (Remember that the end date
                                            // is not included.)
      Map<Date,String> decemberData = syllabus.subMap(startDate, endDate);
      for ( Map.Entry<Date,String> entry : decemberData ) {
         Date date = entry.getKey();
         String info = entry.getValue();
         System.out.println("December " + date.day + ": " + info);
      }

Answer:

public class Stack<T> {
   ArrayList<T> stack = new ArrayList<T>();
   public void push( T newItem ) {
      stack.add(newItem);
   }  
   public T pop() {
      int top = stack.size() - 1;  // location of top item
      return stack.remove(top);    // remove and return top item
   }
   public boolean isEmpty() {
      return stack.size() == 0;
   }
}

Answer:

Since the method operates on ArrayLists, it can use indexed access with the get(i) and set(i,item) methods. These operations are efficient for array lists. I also give a second version of the method that uses a list iterator and is efficient for any type of list.

public static <T> void replaceAll(ArrayList<T> list, T oldItem, T newItem) {
   if (oldItem == null) {
      for (int i = 0; i < list.size(); i++) {
         if ( null == list.get(i) )
            list.set( i, newItem );
      }
   }
   else {
      for (int i = 0; i < list.size(); i++) {
         if ( oldItem.equals(list.get(i)) )
            list.set( i, newItem );
      }
   }
}


public static <T> void replaceAll(List<T> list, T oldItem, T newItem) {
   ListIterator<T> iter = list.listIterator();
   while (iter.hasNext()) {
      T listItem = iter.next();
      if ( oldItem == null ) {
         if ( listItem == null )
            iter.set(newItem);
      }
      else {
         if ( oldItem.equals(listItem) )
            iter.set(newItem);
      }
   }
}

(Note, by the way, that a replaceAll method is already defined as a static method in class Collections.)

Answer:

This code counts the number of different strings in the array, ignoring case. It starts with a stream containing all the strings from the array. The filter() operation only lets non-null values through. This makes sure that there won't be a NullPointerExcetion in the next step, when w.toLowerCase() is evaluated. The map() replaces each string in the stream with a lower case version, so that there will be no difference between upper and lower case versions of the same string. The distinct() eliminates duplicates from the stream. And count() returns the number of strings in the resulting. stream, which now contains just one lower-case copy of every string that occurs in the array.

Answer:

IntStream.range(2,20)
         .filter( n -> (n % 2 == 0) )
         .forEach( n -> System.out.println(n) );

(IntStream.range() can be used to create a stream containing all of the integers 2 to 20. The predicate "n -> (n%2 == 0)" is true just for even integers, so the stream that emerges from the filter operation contains the numbers 2, 4, ... 20. Finally, we can apply an operation to each of the numbers of the stream by using the forEach terminal operator. The operation forEachOrdered would also work, but since the stream is sequential, forEach will print out the numbers in order. If we were using a parallel stream, it is possible that forEach could print the numbers out of order.)

Answer:

The first version uses a for-each loop, and uses the fact that a Predicate contains a boolean-valued function named test() for testing whether the predicate is true:

public static <T> int countIf( Collection<T> items, Predicate<T> pred ) ) {
    int count = 0;
    for ( T x : items ) {
        if ( pred.test(x) )
            count++;
    }
    return count;
}

The second version uses the stream API, with a filter() operation that lets through only the items for which the predicate is true. Note that filter() takes a parameter that is a predicate. Usually, the parameter is given by a lambda expression, but in this case, the predicate is pred, so we need to pass pred as the paramter to filter().

public static <T> int countIf( Collection<T> items, Predicate<T> pred ) {
    long ct = items.parallelStream()
                   .filter(pred)
                   .count();
         // .count() returns a long, but I want countIf to return an int
    return (int)ct; 
}