Lesson 2

Greetings, programming enthusiast! In this unit, we're embarking on a thrilling numerical quest, where unidentified bridges connect the islands of data. On these bridges, we'll see hashes and bins, all converging into sets! Throughout our journey, we'll utilize the fundamental concepts of the **Java Collections Framework** to formulate an optimal solution. So, fasten your seatbelt and get ready to solve problems!

The task for this unit is to devise a Java function that accepts two lists containing unique integers and returns another list containing the elements common to both input lists. This task provides an intriguing perspective on deriving similarities between two data sequences, a scenario commonly encountered in data comparisons and analytics.

For illustration, suppose we're given two lists:

Java`1List<Integer> list1 = Arrays.asList(1, 2, 3, 5, 8, 13, 21, 34); 2List<Integer> list2 = Arrays.asList(2, 3, 5, 7, 13, 21, 31);`

The `commonElements(list1, list2)`

function should comb through these arrays of integers and extract the common elements between them.

The expected outcome in this case should be:

Java`1List<Integer> result = Arrays.asList(2, 3, 5, 13, 21);`

Before we delve into the optimized solution, it is instrumental to consider a basic or naïve approach to this problem and analyze its complexity. Often, our first intuitive approach is to iterate over both lists in nested loops and find common elements. This way, for each element in the first list, we check for its presence in the second list. If it's found, it is added to our result list. Let's see how such a solution would look:

Java`1import java.util.ArrayList; 2import java.util.Arrays; 3import java.util.List; 4 5public class CommonElements { 6 public static List<Integer> commonElementsSlow(List<Integer> list1, List<Integer> list2) { 7 List<Integer> common = new ArrayList<>(); // List to store common elements 8 for (Integer num1 : list1) { 9 for (Integer num2 : list2) { 10 if (num1.equals(num2)) { 11 common.add(num1); 12 break; // Break inner loop as we found the number in list2 13 } 14 } 15 } 16 return common; 17 } 18 19 public static void main(String[] args) { 20 List<Integer> list1 = Arrays.asList(1, 2, 3, 5, 8, 13, 21, 34); 21 List<Integer> list2 = Arrays.asList(2, 3, 5, 7, 13, 21, 31); 22 List<Integer> result = commonElementsSlow(list1, list2); 23 System.out.println(result); // Prints: [2, 3, 5, 13, 21] 24 } 25}`

However, the problem with this approach lies in its efficiency. Given that the worst-case scenario has us traversing through every element in both lists, we refer to this as an $O(n \cdot m)$ solution, where `n`

and `m`

represent the number of elements in `list1`

and `list2`

, respectively. For large lists, this iterative approach tends to be inefficient and slow, making it a less desirable solution for this problem.

The solution we aim to implement in the following section utilizes the `HashSet`

data structure to optimize our algorithm and reach a solution in markedly less computational time.

Since efficiency is a concern in our previous approach, we want to reduce the time complexity by minimizing the number of operations we perform to reach a solution. The **Java Collections Framework** `HashSet`

comes to our rescue here.

`HashSet`

internally uses hash tables, which allows operations like *insertion*, *removal*, and *search* to be performed in average constant time, i.e., $O(1)$. This provides a significant performance boost compared to the nested loop approach. Our overall time complexity will be reduced to $O(n + m)$ for traversing both lists and storing their elements into `HashSet`

s.

Let's proceed to build this optimized solution in the next section.

The initial step in crafting our solution is to transform one of these lists into a Java `HashSet`

. The computation of operations, like finding intersections, is highly optimized in `HashSet`

s. We'll leverage this optimization to our advantage.

Java`1import java.util.HashSet; 2import java.util.List; 3import java.util.Set; 4 5public class CommonElements { 6 public static List<Integer> commonElements(List<Integer> list1, List<Integer> list2) { 7 Set<Integer> set1 = new HashSet<>(list1); 8 9 // Implementation continues in the next section 10 } 11}`

Having converted one of our lists to a `HashSet`

, we're now ready to identify the common elements between the two datasets. We'll iterate through the other list and check for each element's presence in the `HashSet`

.

Java`1import java.util.ArrayList; 2import java.util.HashSet; 3import java.util.List; 4import java.util.Set; 5import java.util.Arrays; 6 7public class CommonElements { 8 public static List<Integer> commonElements(List<Integer> list1, List<Integer> list2) { 9 Set<Integer> set1 = new HashSet<>(list1); 10 11 List<Integer> common = new ArrayList<>(); 12 for (Integer num : list2) { 13 if (set1.contains(num)) { 14 common.add(num); 15 } 16 } 17 return common; 18 } 19 20 public static void main(String[] args) { 21 List<Integer> list1 = Arrays.asList(1, 2, 3, 5, 8, 13, 21, 34); 22 List<Integer> list2 = Arrays.asList(2, 3, 5, 7, 13, 21, 31); 23 List<Integer> result = commonElements(list1, list2); 24 System.out.println(result); // Prints: [2, 3, 5, 13, 21] 25 } 26}`

The `HashSet`

in **Java** is not only efficient but also provides a plethora of useful methods for performing various operations. Let's explore some of these practical methods:

The `add`

method allows you to add elements to a `HashSet`

. If the element already exists, the insertion does nothing. The average time complexity for insertion is $O(1)$.

Java`1import java.util.Arrays; 2import java.util.HashSet; 3import java.util.Set; 4 5public class HashSetInsertExample { 6 public static void main(String[] args) { 7 Set<Integer> mySet = new HashSet<>(Arrays.asList(1, 2, 3)); 8 mySet.add(4); // O(1) 9 mySet.add(2); // O(1) but this will have no effect since 2 is already in the set 10 11 System.out.println(mySet); // Prints: [1, 2, 3, 4] (order may vary) 12 } 13}`

The `remove`

method removes elements from a `HashSet`

. If the element does not exist, the remove operation does nothing. The average time complexity for removal is $O(1)$.

Java`1import java.util.Arrays; 2import java.util.HashSet; 3import java.util.Set; 4 5public class HashSetRemoveExample { 6 public static void main(String[] args) { 7 Set<Integer> mySet = new HashSet<>(Arrays.asList(1, 2, 3, 4)); 8 mySet.remove(3); // O(1) 9 mySet.remove(5); // O(1) but this will have no effect since 5 is not in the set 10 11 System.out.println(mySet); // Prints: [1, 2, 4] (order may vary) 12 } 13}`

The `contains`

method checks for the existence of an element in a `HashSet`

. It returns `true`

if the element is found, otherwise, it returns `false`

. The average time complexity for this operation is $O(1)$.

Java`1import java.util.Arrays; 2import java.util.HashSet; 3import java.util.Set; 4 5public class HashSetContainsExample { 6 public static void main(String[] args) { 7 Set<Integer> mySet = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5)); 8 System.out.println(mySet.contains(3)); // O(1), prints: true 9 System.out.println(mySet.contains(6)); // O(1), prints: false 10 } 11}`

The `size`

method returns the number of elements in a `HashSet`

. The time complexity for this operation is $O(1)$.

Java`1import java.util.Arrays; 2import java.util.HashSet; 3import java.util.Set; 4 5public class HashSetSizeExample { 6 public static void main(String[] args) { 7 Set<Integer> mySet = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5)); 8 System.out.println(mySet.size()); // O(1), prints: 5 9 } 10}`

The `clear`

method removes all elements from a `HashSet`

. The average time complexity for this operation is $O(n)$, where `n`

is the number of elements in the set.

Java`1import java.util.Arrays; 2import java.util.HashSet; 3import java.util.Set; 4 5public class HashSetClearExample { 6 public static void main(String[] args) { 7 Set<Integer> mySet = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5)); 8 mySet.clear(); // O(n) 9 System.out.println(mySet.size()); // O(1), prints: 0 10 } 11}`

Knowing these operations will allow you to use Java `HashSet`

s to their full potential and help you devise efficient solutions for a variety of problems.

Well done! You've demonstrated a commendable understanding of lists and `HashSet`

s, along with their operations in **Java**. It is rare to come across solutions that marry elegance with performance efficiency, but today's task offered us precisely that opportunity, and you've seized it superbly.

Of course, the journey doesn't end here. Now, it's time for you to explore similar challenges in the following practice session. Don't be afraid to experiment with various data sequences and maximize your learning venture. Happy coding!

By following these detailed instructions, you should now have a solid basis for understanding how to operate with `HashSet`

in Java and how to develop efficient algorithms using them.