Set

In Java, a set is an interface that represents a collection of unique elements. Sets are used when
you want to store a group of objects without duplicates and without any specific order. Java
provides several implementations of the Set interface, including HashSet, TreeSet, and
LinkedHashSet.

Here are some important things to know about sets in Java:

1. Creating a Set: To create a Set in Java, you can use one of the implementations of the Set
interface. For example, to create a HashSet, you can write:

Set<String> set = new HashSet<>();

2. Adding Elements: To add elements to a Set, you can use the add() method. For example,
to add a string to a HashSet, you can write:
set.add("hello");
This adds the string "hello" to the HashSet.

3. Removing Elements: To remove elements from a Set, you can use the remove() method.
For example, to remove the string "hello" from a HashSet, you can write:
set.remove("hello");
This removes the string "hello" from the HashSet.
4. Checking if an Element Exists: To check if an element exists in a Set, you can use the
contains() method. For example, to check if the string "hello" exists in a HashSet, you can
write:
boolean exists = set.contains("hello");

This sets the boolean variable exists to true if "hello" exists in the HashSet, and false
otherwise.

5. Iterating Over a Set: To iterate over the elements in a Set, you can use an iterator or a for-
each loop. For example, to print all the elements in a HashSet, you can write:
for (String s : set) {
System.out.println(s);
}

This prints each element in the HashSet on a separate line.

6. Set Operations: Java provides several methods for performing set operations, such as
union, intersection, and difference. These methods are provided by the Set interface and
can be used by any implementation of the interface. For example, to find the union of two
sets, you can use the addAll() method. For example:
Set<Integer> set1 = new HashSet<Integer>();
set1.add(1);
 set1.add(2);
set1.add(3);

Set<Integer> set2 = new HashSet<Integer>();

set2.add(3);
set2.add(4);
set2.add(5);

Set<Integer> union = new HashSet<Integer>(set1);

union.addAll(set2);

System.out.println(union); // prints [1, 2, 3, 4, 5]

This creates two sets, set1 and set2, and finds their union using the addAll() method.

7. In Java, the retainAll() method is a Set interface method that is used to retain only the
elements in a given collection that are also present in the current set. In other words, it
modifies the current set to only contain elements that are also in another set.
The retainAll() method takes a single parameter, which is a Collection containing the
elements to be retained. The method returns a boolean value indicating whether the current
set was modified as a result of the operation. If the set is modified, the method returns true;
otherwise, it returns false.
Here's an example of how to use the retainAll() method:
Set<Integer> set1 = new HashSet<Integer>();
set1.add(1);
set1.add(2);
set1.add(3);
set1.add(4);

Set<Integer> set2 = new HashSet<Integer>();

set2.add(3);
set2.add(4);
set2.add(5);
set2.add(6);

boolean modified = set1.retainAll(set2);

System.out.println("Modified: " + modified);

System.out.println("Set1: " + set1);
System.out.println("Set2: " + set2);

In this example, we have two sets, set1 and set2. We call the retainAll() method on set1, passing
in set2 as the parameter. After the method call, set1 will only contain the elements that are also
present in set2, which are 3 and 4. The retainAll() method returns true because set1 was modified
as a result of the operation.
The output of the above code will be:

Modified: true
Set1: [3, 4]
Set2: [3, 4, 5, 6]
As you can see, set1 has been modified to only contain the elements 3 and 4, which are
also present in set2. The retainAll() method is a useful tool for manipulating sets in Java,
especially when you need to perform set operations like intersection or subtraction.
8. In Java, the removeAll() method is a Set interface method that is used to remove from a set
all of its elements that are contained in a specified collection. In other words, it modifies
the current set by removing any elements that are also present in another set.
The removeAll() method takes a single parameter, which is a Collection containing the
elements to be removed. The method returns a boolean value indicating whether the current
set was modified as a result of the operation. If the set is modified, the method returns true;
otherwise, it returns false.
Here's an example of how to use the removeAll() method:
Set<Integer> set1 = new HashSet<Integer>();
set1.add(1);
set1.add(2);
set1.add(3);
set1.add(4);

Set<Integer> set2 = new HashSet<Integer>();

set2.add(3);
set2.add(4);
set2.add(5);
set2.add(6);

boolean modified = set1.removeAll(set2);

System.out.println("Modified: " + modified);

System.out.println("Set1: " + set1);
System.out.println("Set2: " + set2);

In this example, we have two sets, set1 and set2. We call the removeAll() method on set1, passing
in set2 as the parameter. After the method call, set1 will only contain the elements that are not
present in set2, which are 1 and 2. The removeAll() method returns true because set1 was modified
as a result of the operation.

The output of the above code will be:

Modified: true
Set1: [1, 2]
Set2: [3, 4, 5, 6]
As you can see, set1 has been modified to only contain the elements 1 and 2, which are not present
in set2. The removeAll() method is a useful tool for manipulating sets in Java, especially when
you need to perform set operations like subtraction.

Overall, Sets in Java are a useful data structure for storing collections of unique elements.
Understanding how to create, add, remove, check, and iterate over Sets is important for any
Java programmer.

Map
In Java, a Map is an interface that represents a collection of key-value pairs. Maps are used to
store and retrieve data based on a key, which is used to identify the associated value. Java
provides several implementations of the Map interface, including HashMap, TreeMap, and
LinkedHashMap.

Here are some important things to know about maps in Java:

1. Creating a Map: To create a Map in Java, you can use one of the implementations of the
Map interface. For example, to create a HashMap, you can write:

Map<String, Integer> map = new HashMap<String, Integer>();

This creates an empty HashMap with keys of type String and values of type Integer.

2. Adding Elements: To add elements to a Map, you can use the put() method. For example, to add
a key-value pair to a HashMap, you can write:
map.put("apple", 3);

This adds the key "apple" with the value 3 to the HashMap.

3. Removing Elements: To remove elements from a Map, you can use the remove() method.
For example, to remove the key "apple" and its associated value from a HashMap, you
can write:
map.remove("apple");
This removes the key "apple" and its associated value from the HashMap.
4. Retrieving Values: To retrieve the value associated with a key in a Map, you can use the get()
method. For example, to retrieve the value associated with the key "apple" in a HashMap, you
can write:
int value = map.get("apple");
This sets the integer variable value to the value associated with the key "apple" in the HashMap.
5. Iterating Over a Map: To iterate over the key-value pairs in a Map, you can use an iterator or a
for-each loop. For example, to print all the key-value pairs in a HashMap, you can write:
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
This prints each key-value pair in the HashMap on a separate line.
 6. Map Operations: Java provides several methods for performing map operations, such as merging,
replacing, and computing values based on keys. These methods are provided by the Map interface
and can be used by any implementation of the interface. For example, to merge two maps, you
can use the merge() method. For example:
Map<String, Integer> map1 = new HashMap<String, Integer>();
map1.put("apple", 3);
map1.put("banana", 2);

Map<String, Integer> map2 = new HashMap<String, Integer>();

map2.put("apple", 5);
map2.put("orange", 4);

map1.merge("apple", 1, Integer::sum);
map1.merge("orange", 1, Integer::sum);
map1.merge("banana", 1, Integer::sum);

System.out.println(map1); // prints {apple=4, banana=3, orange=1}

This creates two maps, map1 and map2, and merges them using the merge() method. The
merge() method takes three arguments: the key, the value to be merged, and a function that
specifies how to merge the values if the key is already present in the map.

Overall, Maps in Java are a powerful data structure for storing and retrieving key-value pairs.
Understanding how to create, add, remove, retrieve, iterate over, and perform operations on
Maps is important for any Java programmer.