Answer:

The base type of an array refers to the type of the items that can be stored in that array. For example, the base type of the array of type Color[] is Color.

Answer:

This function can be called with any number of integer parameters. It tests whether all of the parameter values are equal. The value of same(1,2,3) is false. The function begins by comparing 1 and 2; since they are not equal, it immediately returns false. The value of same(17,17,17,17) is true. The function compares value[0] with value[1], value[1] with value[2], and value[2] with value[3]. All of these values are 17, so the routine goes through the for loop without returning false, and the "return true" statement after the end of the loop is executed. For same(2), value.length is 1, and the body of the loop is never executed; the return value is true.

Answer:

To sort an array means to rearrange the items in the array so that they are in increasing or decreasing order (according to some criterion).

(Note: To be more accurate, we should say "non-decreasing" instead of "increasing" and "non-increasing" instead of "decreasing." An array can contain duplicate values, and in that case, its elements can't be be put into strictly increasing or strictly decreasing order.)

Answer:

The advantage of binary search is that it is much faster. On a list of one million items, linear search would take an average of five hundred thousand steps to find an item, whereas binary search would take only 20 steps. The disadvantage is that binary search only works on a sorted list, so some extra work must be done to sort the list or to keep the list in sorted order as it is created.

Answer:

A dynamic array is like an array in that it is a data structure that stores a sequence of items, all of the same type, in numbered locations. It is different from an array in that there is no preset upper limit on the number of items that it can contain. This is an advantage in situations where a reasonable value for the size of the array is not known at the time it is created.

Answer:

A class name is a type, but as a parameterized type, ArrayList does not define just one type. Instead, for every object type T, there is a type ArrayList<T>. T is a "type parameter." An object of type ArrayList<T> is a list that can only hold objects of type T. We can have ArrayList<String> to represent lists of Strings, ArrayList<Integer> to represent lists of Integers, and so one. The fact that ArrayList is a parameterized type means that we don't have to create a new class for each type of list.

Answer:

Strings can be compared for lexicographic order using the compareTo instance method in the String class. We can find the smallest string as follows:

String smallest = strlst.get(0);
for (int i = 1; i < strlist.size(); i++) {
   String nextString = strlst.get(i);
   if ( nextString.compareTo(smallest) < 0 ) 
       smallest = nextString;
}
System.out.println("The smallest string lexicographically is " + smallest);

Alternatively, a for-each loop could be used:

String smallest = strlst.get(0);
for (String item : strlst) {
   if ( item.compareTo(smallest) < 0 ) 
       smallest = item;
}
System.out.println("The smallest string lexicographically is " + smallest)

Note that in this version, the first item in the list is compared to itself as the first step in the loop. There is no easy way to leave that item out of the for-each loop.

Answer:

The output consists of six lines, with each line containing six characters. In the first line, i is 0, so all the characters are *'s. In the last line, i is 5, so all the characters are *'s. In each of the four lines in the middle, one of the characters is a * and the rest are periods. The output is

******
.*....
..*...
...*..
....*.
******

It might help to look at the array items that are printed on each line. Note that pic[row][col] is '*' if row is 0 or if row is 5 or if row and col are equal. The items with value '*' are shown in red.

pic[0][0] pic[0][1] pic[0][2] pic[0][3] pic[0][4] pic[0][5]
pic[1][0] pic[1][1] pic[1][2] pic[1][3] pic[1][4] pic[1][5] 
pic[2][0] pic[2][1] pic[2][2] pic[2][3] pic[2][4] pic[2][5] 
pic[3][0] pic[3][1] pic[3][2] pic[3][3] pic[3][4] pic[3][5] 
pic[4][0] pic[4][1] pic[4][2] pic[4][3] pic[4][4] pic[4][5] 
pic[5][0] pic[5][1] pic[5][2] pic[5][3] pic[5][4] pic[5][5]

Answer:

One possible answer is:

public static int getMax(int[] list) {
   
   int max = list[0];  // This is the largest item seen so far.
   
   for (int i = 1; i < list.length; i++) {
         // Look at each item in the array.  If the item is
         // bigger than max, then set max equal to the item.
       if (list[i] > max)
          max = list[i];
   }
   
   // At this point, max is the largest item in the whole array.
   
   return max;
   
} // end getMax

(Note that this method throws an exception if the parameter list is null or if it is an array of length 0. The exception is thrown by the line "int max = list[0];". The reference to list[0] causes a NullPointerException if list is null and an ArrayIndexOutOfBoundsException if the array has length zero.)

Answer:

A pseudocode outline of the answer is

For each city {
   Add up all the temperatures for that city
   Divide the total by 365 and print the answer
}

Adding up all the temperatures for a given city itself requires a for loop, so the code segment looks like this:

for (int city = 0; city < 100; city++) {
    int total = 0;  // total of temperatures for this city
    for (int day = 0; day < 365; day++)
       total = total + temps[city][day];
    double avg = total / 365.0;  // average temp for this city
    System.out.println("Average temp for city number " 
             + city + " is " + avg);
}

Answer:

(The data for the i-th employee is stored in an object that can be referred to as employeeData[i]. The four pieces of data about that employee are members of this object and can be referred to as:

• employeeData[i].firstName
• employeeData[i].lastName
• employeeData[i].hourlyWage
• employeeData[i].yearsWithCompany

The code segment uses a for loop to consider each employee in the array.)

for (int i=0; i < 100; i++) {
    if ( employeeData[i].yearsWithCompany >= 20 )
        System.out.println(employeeData[i].firstName + " " +
                      employeeData[i].lastName + ": " +
                      employeeData[i].hourlyWage);
}

Using a for-each loop:

for ( Employee emp : employeeData ) {
    if ( emp.yearsWithCompany >= 20 )
        System.out.println(emp.firstName + " " +
                      emp.lastName + ": " +
                      emp.hourlyWage);
}

Answer:

It is easy to make the conversion, remembering that the instance variables of a record class are listed in parentheses after the class name. The class body will be empty:

record Employee(
   String lastName,
   String firstName,
   double hourlyWage,
   int yearsWithCompany
) { }

(Employee objects would than have to be created using the canonical constructor, and it would not be possible to change the value of any instance variable after the object has been created. However, none of that is relevant to the solution of the previous question.)

Since the fields of a record are private, they are accessed by calling methods instead of directly. For example, emp.firstName would become emp.firstName(). The extra parentheses are the only changes that are relevant to the question. So the two loops from the previous problem would become:

for (int i=0; i < 100; i++) {
    if ( employeeData[i].yearsWithCompany >= 20 )
        System.out.println(employeeData[i].firstName() + " " +
                      employeeData[i].lastName() + ": " +
                      employeeData[i].hourlyWage() );
}

and

for ( Employee emp : employeeData ) {
    if ( emp.yearsWithCompany >= 20 )
        System.out.println(emp.firstName() + " " +
                      emp.lastName() + ": " +
                      emp.hourlyWage() );
}

(Note however that if the Employee class is a nested class in the same class that contains the for loops, then the change is not necessary, since a class has direct access to the private variables in a nested class that it contains.)

Answer:

My solution assumes that months are numbered 1 through 12, and days are numbered 1 through 31. Since different months have different lengths, it's actually non-trivial to check for illegal values, especially taking into account the rule for leap years. But here is my solution:

public record Date( int month, int day, int year ) {

    public Date {  // the canonical constructor
        if ( month < 1 || month > 12 )
            throw new IllegalArgumentException("Illegal month number.");
        int maxday; // last day of the month
        switch (month) {
            case 4, 6, 9, 11 -> maxday = 30;  // April, June, September, October
            case 2 -> {  // February
                boolean isLeapYear = (year % 400 == 0)
                           || ((year % 4 == 0) && (year % 100 != 0));
                maxday = isLeapYear ? 29 : 28;
            }
            default -> maxday = 31;  // All other months
        }
        if ( day < 1 || day > maxday)
            throw new IllegalArgumentException("Illegal day number.");
    }
    
    public String toString() {
        return String.format("%d/%d/%d", month, day, year);
    }

}

Answer:

The purpose of this subroutine is to find the sum of the numbers in each row of the parameter array data. The answer is returned as a one-dimensional array of double. The value of answers[i] is the sum of the numbers in row number i of data.

(In the first two lines of the method, data.length is the number of rows in data. In the nested for loop, data[i].length is the number of values in the i-th row.)