2.

Write a java program to perform following

A.append the specified element to the end of a hash set

import java.util.HashSet;

public class Exercise1 {

public static void main(String[] args) {
// Create a empty hash set
HashSet<String> h_set = new HashSet<String>();
// use add() method to add values in the hash set
h_set.add("Red");
h_set.add("Green");
h_set.add("Black");
h_set.add("White");
h_set.add("Pink");
h_set.add("Yellow");

// print the hash set

System.out.println("The Hash Set: " + h_set);
}
}

Output:

The Hash Set: [Red, White, Pink, Yellow, Black, Green]

B.iterate through all elements in a hash list

import java.util.*;

import java.util.Iterator;
public class Exercise2 {
public static void main(String[] args) {
// Create a empty hash set
HashSet<String> h_set = new HashSet<String>();
// use add() method to add values in the hash set
h_set.add("Red");
h_set.add("Green");
h_set.add("Black");
h_set.add("White");
h_set.add("Pink");
h_set.add("Yellow");

// set Iterator
Iterator<String> p = h_set.iterator();
// Iterate the hash set
while (p.hasNext()) {
System.out.println(p.next());
 }
}
}

Output

Red
White
Pink
Yellow
Black
Green

C.remove all of the elements from a hash set

import java.util.*;

public class Exercise12 {

public static void main(String[] args) {
// Create a empty hash set
HashSet<String> h_set = new HashSet<String>();
// use add() method to add values in the hash set
h_set.add("Red");
h_set.add("Green");
h_set.add("Black");
h_set.add("White");
System.out.println("Original hash set contains: "+
h_set);
// clear() method removes all the elements from a hash set
// and the set becomes empty.
h_set.clear();

// Display original hash set content again

System.out.println("HashSet content: "+h_set);
}
}

Output:

Original hash set contains: [Red, White, Black, Green]

HashSet content: []

D. get the number of elements in a hash set

import java.util.*;

import java.util.Iterator;
public class Exercise3 {
public static void main(String[] args) {
 // Create a empty hash set
HashSet<String> h_set = new HashSet<String>();
// use add() method to add values in the hash set
h_set.add("Red");
h_set.add("Green");
h_set.add("Black");
h_set.add("White");
h_set.add("Pink");
h_set.add("Yellow");
System.out.println("Original Hash Set: " + h_set);
System.out.println("Size of the Hash Set: " + h_set.size());
}
}

Output:

Original Hash Set: [Red, White, Pink, Yellow, Black, Green]

Size of the Hash Set: 6

E.empty an hash set

import java.util.*;

public class Exercise4 {

public static void main(String[] args) {
// Create a empty hash set
HashSet<String> h_set = new HashSet<String>();
// use add() method to add values in the hash set
h_set.add("Red");
h_set.add("Green");
h_set.add("Black");
h_set.add("White");
h_set.add("Pink");
h_set.add("Yellow");
System.out.println("Original Hash Set: " + h_set);
// Remove all elements
h_set.removeAll(h_set);
System.out.println("Hash Set after removing all the elements
"+h_set);
}
}

Output:

Original Hash Set: [Red, White, Pink, Yellow, Black, Green]

Hash Set after removing all the elements []

F. test a hash set is empty or not

 import java.util.*;

public class Exercise5 {

public static void main(String[] args) {
// Create a empty hash set
HashSet<String> h_set = new HashSet();
// use add() method to add values in the hash set
h_set.add("Red");
h_set.add("Green");
h_set.add("Black");
h_set.add("White");
h_set.add("Pink");
h_set.add("Yellow");
System.out.println("Original Hash Set: " + h_set);
System.out.println("Checking the above array list is empty or
not! "+h_set.isEmpty());
System.out.println("Remove all the elements from a Hash Set: ");
h_set.removeAll(h_set);
System.out.println("Hash Set after removing all the elements
"+h_set);
}
}
Output:

Original Hash Set: [Red, White, Pink, Yellow, Black, Green]

Checking the above array list is empty or not! false
Remove all the elements from a Hash Set:
Hash Set after removing all the elements []

G. clone a hash set to another hash set

import java.util.*;

public class Exercise6 {

public static void main(String[] args) {
// Create a empty hash set
HashSet<String> h_set = new HashSet<String>();
// use add() method to add values in the hash set
h_set.add("Red");
h_set.add("Green");
h_set.add("Black");
h_set.add("White");
h_set.add("Pink");
h_set.add("Yellow");
System.out.println("Original Hash Set: " + h_set);
HashSet <String> new_h_set = new HashSet <String> ();
new_h_set = (HashSet)h_set.clone();
System.out.println("Cloned Hash Set: " + new_h_set);
 }
}
Output:

Original Hash Set: [Red, White, Pink, Yellow, Black, Green]

Cloned Hash Set: [Red, White, Pink, Yellow, Black, Green]

H. convert a hash set to an array

import java.util.*;

public class Exercise7 {

public static void main(String[] args) {
// Create a empty hash set
HashSet<String> h_set = new HashSet<String>();
// use add() method to add values in the hash set
h_set.add("Red");
h_set.add("Green");
h_set.add("Black");
h_set.add("White");
h_set.add("Pink");
h_set.add("Yellow");
System.out.println("Original Hash Set: " + h_set);
// Creating an Array
String[] new_array = new String[h_set.size()];
h_set.toArray(new_array);

// Displaying Array elements

System.out.println("Array elements: ");
for(String element : new_array){
System.out.println(element);
}
}
}
Output:

Original Hash Set: [Red, White, Pink, Yellow, Black, Green]

Array elements:
Red
White
Pink
Yellow
Black
Green

I. convert a hash set to a tree set

import java.util.*;

public class Exercise8 {

 public static void main(String[] args) {
// Create a empty hash set
HashSet<String> h_set = new HashSet<String>();
// use add() method to add values in the hash set
h_set.add("Red");
h_set.add("Green");
h_set.add("Black");
h_set.add("White");
h_set.add("Pink");
h_set.add("Yellow");
System.out.println("Original Hash Set: " + h_set);

// Creat a TreeSet of HashSet elements

Set<String> tree_set = new TreeSet<String>(h_set);

// Display TreeSet elements

System.out.println("TreeSet elements: ");
for(String element : tree_set){
System.out.println(element);
}
}
}

Output:

Original Hash Set: [Red, White, Pink, Yellow, Black, Green]

TreeSet elements:
Black
Green
Pink
Red
White
Yellow

J. convert a hash set to a List/ArrayList

import java.util.*;

public class Exercise9 {

public static void main(String[] args) {
// Create a empty hash set
HashSet<String> h_set = new HashSet<String>();
// use add() method to add values in the hash set
h_set.add("Red");
h_set.add("Green");
h_set.add("Black");
h_set.add("White");
 h_set.add("Pink");
h_set.add("Yellow");
System.out.println("Original Hash Set: " + h_set);

// Create a List from HashSet elements

List<String> list = new ArrayList<String>(h_set);

// Display ArrayList elements

System.out.println("ArrayList contains: "+ list);
}
}
Output:

Original Hash Set: [Red, White, Pink, Yellow, Black, Green]

ArrayList contains: [Red, White, Pink, Yellow, Black, Green]

k. compare two hash set

import java.util.*;

public class Exercise10 {

public static void main(String[] args) {
// Create a empty hash set
HashSet<String> h_set = new HashSet<String>();
// use add() method to add values in the hash set
h_set.add("Red");
h_set.add("Green");
h_set.add("Black");
h_set.add("White");

HashSet<String>h_set2 = new HashSet<String>();

h_set2.add("Red");
h_set2.add("Pink");
h_set2.add("Black");
h_set2.add("Orange");
//comparison output in hash set
HashSet<String>result_set = new HashSet<String>();
for (String element : h_set){
System.out.println(h_set2.contains(element) ? "Yes" :
"No");
}
}
}

Output:

Yes
No
Yes
No
L. compare two sets and retain elements which are same on both sets

import java.util.*;

public class Exercise11 {

public static void main(String[] args) {
// Create a empty hash set
HashSet<String> h_set1 = new HashSet<String>();
// use add() method to add values in the hash set
h_set1.add("Red");
h_set1.add("Green");
h_set1.add("Black");
h_set1.add("White");
System.out.println("Frist HashSet content: "+h_set1);
HashSet<String>h_set2 = new HashSet<String>();
h_set2.add("Red");
h_set2.add("Pink");
h_set2.add("Black");
h_set2.add("Orange");
System.out.println("Second HashSet content: "+h_set2);
h_set1.retainAll(h_set2);
System.out.println("HashSet content:");
System.out.println(h_set1);
}
}

Output:

Frist HashSet content: [Red, White, Black, Green]

Second HashSet content: [Red, Pink, Black, Orange]
HashSet content:
[Red, Black]

M. remove all of the elements from a hash set

import java.util.*;

public class Exercise12 {

public static void main(String[] args) {
// Create a empty hash set
HashSet<String> h_set = new HashSet<String>();
// use add() method to add values in the hash set
h_set.add("Red");
h_set.add("Green");
 h_set.add("Black");
h_set.add("White");
System.out.println("Original hash set contains: "+
h_set);
// clear() method removes all the elements from a hash set
// and the set becomes empty.
h_set.clear();

// Display original hash set content again

System.out.println("HashSet content: "+h_set);
}
}

Output:

Original hash set contains: [Red, White, Black, Green]

HashSet content: []

3. Write a java program to perform following

A.associate the specified value with the specified key in a HashMap

import java.util.*;

public class Example1 {

public static void main(String args[]) {
HashMap<Integer,String> hash_map= new HashMap<Integer,String>();
hash_map.put(1, "Red");
hash_map.put(2, "Green");
hash_map.put(3, "Black");
hash_map.put(4, "White");
hash_map.put(5, "Blue");
for(Map.Entry x:hash_map.entrySet()){
System.out.println(x.getKey()+" "+x.getValue());
}
}
}

Output:

1 Red
2 Green
3 Black
4 White
5 Blue
 B. count the number of key-value (size) mappings in a map

import java.util.*;

public class Example2 {

public static void main(String args[]){
HashMap<Integer,String> hash_map= new HashMap<Integer,String>();
hash_map.put(1, "Red");
hash_map.put(2, "Green");
hash_map.put(3, "Black");
hash_map.put(4, "White");
hash_map.put(5, "Blue");
System.out.println("Size of the hash map: "+hash_map.size());
}
}

Output:

Size of the hash map: 5

C. copy all of the mappings from the specified map to another map

import java.util.*;

public class Example3 {

public static void main(String args[]) {
// create two hash maps
HashMap <Integer,String> hash_map1 = new HashMap <Integer,String>
();
HashMap <Integer,String> hash_map2 = new HashMap <Integer,String>
();
// populate hash maps
hash_map1.put(1, "Red");
hash_map1.put(2, "Green");
hash_map1.put(3, "Black");
System.out.println("\nValues in first map: " + hash_map1);
hash_map2.put(4, "White");
hash_map2.put(5, "Blue");
hash_map2.put(6, "Orange");
System.out.println("\nValues in second map: " + hash_map2);

// put all values in secondmap

hash_map2.putAll(hash_map1);
System.out.println("\nNow values in second map: " + hash_map2);
}
}

Output:
Values in first map: {1=Red, 2=Green, 3=Black}

Values in second map: {4=White, 5=Blue, 6=Orange}

Now values in second map: {1=Red, 2=Green, 3=Black, 4=White,

5=Blue, 6=
Orange}

D. remove all of the mappings from a map

import java.util.*;

public class Example4 {

public static void main(String args[]) {
HashMap <Integer,String> hash_map = new HashMap <Integer,String>
();
hash_map.put(1, "Red");
hash_map.put(2, "Green");
hash_map.put(3, "Black");
hash_map.put(4, "White");
hash_map.put(5, "Blue");
// print the map
System.out.println("The Original linked map: " + hash_map);
// Removing all the elements from the linked map
hash_map.clear();
System.out.println("The New map: " + hash_map);
}
}

Output:

The Original linked map: {1=Red, 2=Green, 3=Black, 4=White,

5=Blue}
The New map: {}

E. check whether a map contains key-value mappings (empty) or not

import java.util.*;

public class Example5 {

public static void main(String args[]) {
HashMap <Integer,String> hash_map = new HashMap <Integer,String>
();
hash_map.put(1, "Red");
hash_map.put(2, "Green");
hash_map.put(3, "Black");
hash_map.put(4, "White");
hash_map.put(5, "Blue");
// check if map is empty
 boolean result = hash_map.isEmpty();
// check the result
System.out.println("Is hash map empty: " + result);
// Removing all the elements from the linked map
hash_map.clear();
// check if map is empty
result = hash_map.isEmpty();
// check the result
System.out.println("Is hash map empty: " + result);
}
}

Output:

Is hash map empty: false

Is hash map empty: true

F. get a shallow copy of a HashMap instance.

import java.util.*;

public class Example6 {

public static void main(String args[]){
HashMap<Integer,String> hash_map= new HashMap<Integer,String>();
hash_map.put(1, "Red");
hash_map.put(2, "Green");
hash_map.put(3, "Black");
hash_map.put(4, "White");
hash_map.put(5, "Blue");
// print the map
System.out.println("The Original map: " + hash_map);
HashMap<Integer,String> new_hash_map= new
HashMap<Integer,String>();
new_hash_map = (HashMap)hash_map.clone();
System.out.println("Cloned map: " + new_hash_map);
}
}
Output:

The Original map: {1=Red, 2=Green, 3=Black, 4=White, 5=Blue}

Cloned map: {1=Red, 2=Green, 3=Black, 4=White, 5=Blue}

g. create a set view of the mappings contained in a map

import java.util.*;

public class Example9 {

public static void main(String args[]) {
 HashMap < Integer, String > hash_map = new HashMap < Integer,
String > ();
hash_map.put(1, "Red");
hash_map.put(2, "Green");
hash_map.put(3, "Black");
hash_map.put(4, "White");
hash_map.put(5, "Blue");
// create set view for the map
Set set = hash_map.entrySet();
// check set values
System.out.println("Set values: " + set);
}
}
Output:

Set values: [1=Red, 2=Green, 3=Black, 4=White, 5=Blue]

h. get the value of a specified key in a map

import java.util.*;

public class Example10 {

public static void main(String args[]){
HashMap<Integer,String> hash_map= new HashMap<Integer,String>();
hash_map.put(1,"Red");
hash_map.put(2,"Green");
hash_map.put(3,"Black");
hash_map.put(4,"White");
hash_map.put(5,"Blue");
// get value of key 3
String val=(String)hash_map.get(3);
// check the value
System.out.println("Value for key 3 is: " + val);
}
}
Output:

Value for key 3 is: Black

i. get a set view of the keys contained in this map

import java.util.*;

public class Example11 {

public static void main(String args[]){

HashMap<Integer,String> hash_map= new HashMap<Integer,String>();

hash_map.put(1,"Red");
 hash_map.put(2,"Green");
hash_map.put(3,"Black");
hash_map.put(4,"White");
hash_map.put(5,"Blue");

// get keyset value from map

Set keyset = hash_map.keySet();

// check key set values

System.out.println("Key set values are: " + keyset);
}
}

Output:

Key set values are: [1, 2, 3, 4, 5]

j. get a collection view of the values contained in this map

import java.util.*;

public class Example12 {

public static void main(String args[]){

HashMap<Integer,String> hash_map= new HashMap<Integer,String>();

hash_map.put(1,"Red");
hash_map.put(2,"Green");
hash_map.put(3,"Black");
hash_map.put(4,"White");
hash_map.put(5,"Blue");

// checking collection view of the map

System.out.println("Collection view is: "+ hash_map.values());
}
}
Output

Collection view is: [Red, Green, Black, White, Blue]