Sorting with the Comparable Interface

Which 2 methods use 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, respectively.
To implement Comparable, a class must implement a single method, compareTo().

Does the String object implement the Comparable interface?

Answer:
To sort the data elements a class needs to implement Comparator or Comparable interface.
Thats why all Wrapper classes like 1) Integer, 2) Double, and 3) String class implement the Comparable interface.

When does a class use the 1) equals and 2) compareTo methods?

Answer:
When a class implements the "Comparable" interface. If a class implements the "Comparable" interface, then these 2 methods must be present.

How do you instantiate an ArrayList polymorphically?

Answer:

List myList = new ArrayList();
List<String> myList = new ArrayList<String>();

What steps need to be taken to sort an ArrayList in Java?

Answer:
Sorting an `ArrayList` in Java can be efficiently accomplished using the `Collections.sort()` method provided by the Java Collections Framework, or by utilizing the `sort()` method of the `ArrayList` itself, which has been available since Java 8. Below are the steps to sort an `ArrayList` in Java, presented in a technical and authoritative tone:
Using `Collections.sort()`
1. Import Collections Framework: Ensure that the `java.util.Collections` package is imported in your Java program to access the `Collections.sort()` method.
```
import java.util.Collections;
```
2. Instantiate and Populate ArrayList: Create an instance of `ArrayList` and populate it with elements. The `ArrayList` can store objects such as `Integer`, `String`, or custom objects.
```
ArrayList numbers = new ArrayList();
numbers.add(5);
numbers.add(1);
numbers.add(3);
```
3. Sort the ArrayList: Use the `Collections.sort()` method to sort the `ArrayList`. By default, this method sorts the elements in ascending order.
```
Collections.sort(numbers);
```
  For custom objects, you may need to implement the `Comparable` interface or provide a `Comparator` to define the sort order.
Using `ArrayList.sort()`
1. Ensure Java 8 or Later: The `ArrayList.sort()` method is available from Java 8 onwards. Ensure your environment is set up with Java 8 or a later version.
2. Instantiate and Populate ArrayList: Similar to the previous method, create and populate your `ArrayList`.
```
ArrayList names = new ArrayList();
names.add("John");
names.add("Alice");
names.add("Bob");
```
3. Sort the ArrayList: Use the `sort()` method of the `ArrayList` class. This method accepts a `Comparator`, which can be provided using a lambda expression for simple cases, or by implementing the `Comparator` interface for more complex sorting logic.
```
names.sort(Comparator.naturalOrder()); // For ascending order
```
  Or, for descending order:
```
names.sort(Comparator.reverseOrder());
```
For sorting custom objects, define your own `Comparator` or make your custom class implement `Comparable` and override the `compareTo()` method to establish the natural order of the objects.
Considerations
- Natural Ordering: Both methods sort elements based on their natural ordering, such as numerical order for numbers and lexicographical order for strings.
- Custom Ordering: For custom sorting logic, especially with custom objects, implement the `Comparable` interface or provide a custom `Comparator`.
- Stability: The sort algorithms used by these methods are stable, meaning equal elements will not be reordered as a result of the sort.
- Performance: The performance of the sort operation can vary based on the size of the `ArrayList` and the complexity of the comparison logic.
By following these steps, you can effectively sort `ArrayLists` in Java, tailoring the approach to the specific requirements of your data and use case.
ArrayList does not give you any way to sort its contents, but the java.util.Collections class does.

What is a checked exception?

Answer:
When an object of a subtype of Exception is thrown, it must be handled or declared.
These objects are called checked exceptions, and include all exceptions except those that are subtypes of RuntimeException.

Which Superclass do a) Error and b) Exception objects share?

Answer:
They share the Superclass "Throwable".

What is an unchecked Exception?

Answer:
When an Error or a subclass of Error is thrown, it is unchecked.

Does the compiler care about Error?

Answer:
Since Error is not a subtype of Exception, it does not need to be declared.
You can declare it if you like, but the compiler does not care one way or another when or how the Error was thrown.

What is a thread?

Answer:
In "Java", the word "thread" means 2 different things.
1. An instance of class java.lang.Thread
2. A thread of execution