Which package gives you the ability to sort an ArrayList?
Answer:
An ArrayList implements the List interface. An ArrayList does not give you a way to sort its contents but the java.util.Collections class does.
Which interface does the String class implement?
Answer:
The Java String class does implement the `Comparable` interface. Here's what this means:
Natural Ordering: Strings have a natural ordering based on lexicographical comparison (similar to dictionary ordering). When you compare two strings using `compareTo` the result is determined as follows:
Negative integer: If the first string comes before the second string lexicographically.
Zero: If the strings are equal.
Positive integer: If the first string comes after the second string lexicographically.
Example:
String str1 = "hello";
String str2 = "world";
int result = str1.compareTo(str2); // result will be a negative value
// ("hello" comes before "world")
Why is this important?
Sorting: Implementing `Comparable` allows you to easily sort collections of strings using methods like `Collections.sort()` or `Arrays.sort()`.
Search Algorithms: Many search algorithms rely on the ability to compare elements in an ordered manner.
The String class implements the Comparable interface, and that is why we were able to sort a list of Strings using the Collections.sort() method.
Which sorting method makes use of the Comparable interface?
Answer:
The Comparable interface is used by the Collections.sort() method and the java.util.Arrays.sort() method to sort Lists and arrays of objects.
java.util.Collection is an Interface,
java.util.Collections is a class.
Which method belongs to the Comparable interface?
Answer:
A class that implements the Comparable interface uses a method called compareTo.
Comparable: compareTo;
Which method belongs to the Comparator interface?
Answer:
public interface Comparator <T>
A class that implements Comparator has a compare method.
Comparator: compare
Write an example of a class that implements Comparable and makes use of the compareTo method.
Answer:
public class DVDInfo implements Comparable{
private String title="";
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public int compareTo(Object o){
DVDInfo d = null;
return title.compareTo(d.getTitle());
}
}
What type of argument do you have to take when you override equals()?
Answer:
When you override equals() you must take an argument of type Object.
What type of argument should you take when you override compareTo()?
Answer:
When you override compareTo() you should take an argument of the type you are sorting.
How often can you implement compareTo() in a class?
Answer: We can only implement compareTo() once in a class.
What advantage does the Comparator interface offer?
Answer:
The comparator interface gives you the capability to sort a given collection any number of different ways.
Can you put different data types in one container such as an 1) Array or 2) ArrayList in Java?
Answer:
In Java, the data types you can put into an array or an ArrayList depend on whether the container is meant to hold primitive types or objects. Here's how it works for each container type:
Array:
An array in Java can store either primitives (like `int`, `double`, `char`, etc.) or objects (like `Integer`, `String`, `Object`, etc.).
However, an array defined for a specific type can only hold that type. For instance, an `int[]` can only store `int` values, and a `String[]` can only store `String` objects. You cannot mix types in a single array.
If you need to store different types in one array, you can define an array of a common superclass or interface, typically an `Object[]`. This will allow you to store any type of object, but you lose type safety and might need to use type casting when retrieving elements.
ArrayList:
Unlike arrays, an `ArrayList` in Java can only hold objects and not primitive types (e.g., `int`, `double`). If you want to store primitives in an `ArrayList`, you must use their corresponding wrapper classes (`Integer`, `Double`, etc.).
An `ArrayList` can be generic, meaning you can specify the type of objects it can hold, like `ArrayList <String>` or `ArrayList<Integer>`. If you specify a specific type, only that type of object can be stored in the `ArrayList`.
You can also create an `ArrayList` without specifying a type, effectively making it an `ArrayList<Object>`, which can hold any type of object. However, like with `Object[]`, this approach loses type safety and requires casting when retrieving specific types of objects.
In summary, if you want to store different types of data in one container in Java, you can use an `Object[]` array or an `ArrayList
