Posted in

COLLECTION FRAMEWORK CODING QUESTIONS IN JAVA

by admin••0•Posted inJAVA

1. Write a program to reverse an ArrayList without using built-in reverse method?

import java.util.ArrayList;
      public class ReverseArrayList {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        System.out.println(“Original ArrayList: ” + list);
        for (int i = 0; i < list.size() / 2; i++) {
            int temp = list.get(i);
            list.set(i, list.get(list.size() – 1 – i));
            list.set(list.size() – 1 – i, temp);
        }
        System.out.println(“Reversed ArrayList: ” + list);
    }
}

Output :

Original ArrayList: [10, 20, 30, 40, 50]
Reversed ArrayList: [50, 40, 30, 20, 10]

2. Write a program to remove duplicates from an ArrayList while preserving order?

    import java.util.ArrayList;
     import java.util.LinkedHashSet;
   public class RemoveDuplicates {
    public static void main(String[] args) {
        ArrayList<String> listWithDuplicates = new ArrayList<>();
        listWithDuplicates.add(“apple”);
        listWithDuplicates.add(“banana”);
        listWithDuplicates.add(“apple”);
        listWithDuplicates.add(“orange”);
        listWithDuplicates.add(“banana”);
        listWithDuplicates.add(“grape”);
        System.out.println(“Original List: ” + listWithDuplicates);
        LinkedHashSet<String> set = new LinkedHashSet<>(listWithDuplicates);
        ArrayList<String> listWithoutDuplicates = new ArrayList<>(set);
        System.out.println(“List after removing duplicates: ” + listWithoutDuplicates);
    }
}

Output :

Original List: [apple, banana, apple, orange, banana, grape]
 List after removing duplicates: [apple, banana, orange, grape]

3. Write a program to find the frequency of each element in a list?

import java.util.ArrayList;
    import java.util.HashMap;
   public class FrequencyCounter {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add(“apple”);
        list.add(“banana”);
        list.add(“apple”);
        list.add(“orange”);
        list.add(“banana”);
        list.add(“apple”);
        System.out.println(“Input List: ” + list);
        HashMap<String, Integer> frequencyMap = new HashMap<>();
        for (String item : list) {
            frequencyMap.put(item, frequencyMap.getOrDefault(item, 0) + 1);
        }
        System.out.println(“Element Frequencies:”);
        for (String key : frequencyMap.keySet()) {
            System.out.println(key + “: ” + frequencyMap.get(key));
        }
    }
}

Output :

 Input List: [apple, banana, apple, orange, banana, apple]
  Element Frequencies:
       apple: 3
      banana: 2
      orange: 1

4. Write a program to merge two lists into one without duplicates?

    import java.util.ArrayList;
     import java.util.LinkedHashSet;
     public class MergeLists {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add(“apple”);
        list1.add(“banana”);
        list1.add(“orange”);
        ArrayList<String> list2 = new ArrayList<>();
        list2.add(“banana”);
        list2.add(“grape”);
        list2.add(“apple”);
        System.out.println(“List 1: ” + list1);
        System.out.println(“List 2: ” + list2);
        ArrayList<String> mergedList = new ArrayList<>();
        mergedList.addAll(list1);
        mergedList.addAll(list2);
        LinkedHashSet<String> uniqueSet = new LinkedHashSet<>(mergedList);
        ArrayList<String> finalList = new ArrayList<>(uniqueSet);
        System.out.println(“Merged List without Duplicates: ” + finalList);
    }
}

Output :

List 1: [apple, banana, orange]
List 2: [banana, grape, apple]
Merged List without Duplicates: [apple, banana, orange, grape]

5. Write a program to find duplicates in a list using HashSet?

    import java.util.ArrayList;
     import java.util.HashSet;
public class FindDuplicates {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add(“apple”);
        list.add(“banana”);
        list.add(“orange”);
        list.add(“apple”);
        list.add(“grape”);
        list.add(“banana”);
        System.out.println(“Original List: ” + list);
        HashSet<String> seen = new HashSet<>();
        HashSet<String> duplicates = new HashSet<>();
        for (String item : list) {
            if (!seen.add(item)) {
                duplicates.add(item);
            }
        }
        System.out.println(“Duplicates Found: ” + duplicates);
    }
}

Output :

Original List: [apple, banana, orange, apple, grape, banana]
Duplicates Found: [apple, banana]

6. Write a program to check if two lists have any elements in common (intersection using Set)?

       import java.util.ArrayList;
      import java.util.HashSet;
     public class ListIntersection {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add(“apple”);
        list1.add(“banana”);
        list1.add(“orange”);
        ArrayList<String> list2 = new ArrayList<>();
        list2.add(“grape”);
        list2.add(“banana”);
        list2.add(“melon”);
        System.out.println(“List 1: ” + list1);
        System.out.println(“List 2: ” + list2);
        HashSet<String> set = new HashSet<>(list1);
        set.retainAll(list2);
        if (set.isEmpty()) {
            System.out.println(“No common elements found.”);
        } else {
            System.out.println(“Common elements: ” + set);
        }
    }
}

Output :

List 1: [apple, banana, orange]
    List 2: [grape, banana, melon]
   Common elements: [banana]

7. Write a program to get all unique characters from a string using Set?

     import java.util.LinkedHashSet;
      import java.util.Set;
    public class UniqueCharacters {
     public static void main(String[] args) {
        String input = “programming”;
        System.out.println(“Input String: ” + input);
        Set<Character> uniqueChars = new LinkedHashSet<>();
        for (char ch : input.toCharArray()) {
            uniqueChars.add(ch);
        }
        System.out.println(“Unique Characters: ” + uniqueChars);
    }
}

Output :

Input String: programming
Unique Characters: [p, r, o, g, a, m, i, n]

8. Write a program to use TreeSet to automatically sort and remove duplicates from an array?

  import java.util.Arrays;
import java.util.Set;
import java.util.TreeSet;
public class TreeSetSort {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 8, 3, 1, 9, 5, 2};
        System.out.println(“Original Array: ” + Arrays.toString(numbers));
        Set<Integer> sortedSet = new TreeSet<>();
        for (int num : numbers) {
            sortedSet.add(num);
        }
        System.out.println(“Sorted & Unique Elements: ” + sortedSet);
    }
}

Output :

Original Array: [5, 3, 8, 3, 1, 9, 5, 2]
Sorted & Unique Elements: [1, 2, 3, 5, 8, 9]

9. Write a program to count character frequency in a string using HashMap?

import java.util.HashMap;
     import java.util.Map;
     public class CharFrequency {
    public static void main(String[] args) {
        String input = “programming”;
        System.out.println(“Input String: ” + input);
        Map<Character, Integer> charCountMap = new HashMap<>();
        for (char ch : input.toCharArray()) {
            charCountMap.put(ch, charCountMap.getOrDefault(ch, 0) + 1);
        }
        System.out.println(“Character Frequencies:”);
        for (Map.Entry<Character, Integer> entry : charCountMap.entrySet()) {
            System.out.println(entry.getKey() + “: ” + entry.getValue());
        }
    }
}

Output :

 Input String: programming
Character Frequencies:
p: 1
r: 2
o: 1
g: 2
a: 1
m: 2
i: 1
n: 1

10. Write a program to find the first non-repeating character in a string using LinkedHashMap?

    import java.util.LinkedHashMap;
    import java.util.Map;
public class FirstNonRepeatingChar {
    public static void main(String[] args) {
        String input = “swiss”;
        System.out.println(“Input String: ” + input);
        LinkedHashMap<Character, Integer> charCountMap = new LinkedHashMap<>();
        for (char ch : input.toCharArray()) {
            charCountMap.put(ch, charCountMap.getOrDefault(ch, 0) + 1);
        }
        for (Map.Entry<Character, Integer> entry : charCountMap.entrySet()) {
            if (entry.getValue() == 1) {
                System.out.println(“First non-repeating character: ” + entry.getKey());
                return;
            }
        }
        System.out.println(“No non-repeating characters found.”);
    }
}

Output :

Input String: swiss
First non-repeating character: w

11. Write a program to implement a word frequency counter from a file using Map?

import java.util.*;
     public class WordFrequencyCounter {
    public static void main(String[] args) {
        String input = “Hello world! Hello everyone. Welcome to the world of programming. Programming is fun. Everyone loves programming.”;
        Map<String, Integer> wordCountMap = new HashMap<>(); 
        for (String word : input.split(“\\W+”)) {
            if (!word.isEmpty()) {
                word = word.toLowerCase();
                wordCountMap.put(word, wordCountMap.getOrDefault(word, 0) + 1);
            }
        }
        wordCountMap.forEach((word, count) -> System.out.println(word + “: ” + count));
    }
}

Output :

 hello: 2
world: 2
everyone: 2
welcome: 1
to: 1
the: 1
of: 1
programming: 3
is: 1
fun: 1
loves: 1

12. Write a Java program that sorts a list of Person objects based on their age using a custom comparator?

    import java.util.*;
   class Person {
    String name;
    int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String toString() {
        return name + ” (” + age + “)”;
    }
}
public class SortByAge {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person(“Alice”, 30),
            new Person(“Bob”, 25),
            new Person(“Charlie”, 35)
        );
        people.sort(Comparator.comparingInt(p -> p.age));
        for (Person p : people) {
            System.out.println(p);
        }
    }
}

Output :

 Bob (25)
Alice (30)
Charlie (35)

13. Write a Java program to check if a given ArrayList contains a sublist?

import java.util.*;
public class SublistCheck {
    public static void main(String[] args) {
        List<Integer> mainList = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> subList = Arrays.asList(3, 4, 5);
        boolean contains = Collections.indexOfSubList(mainList, subList) != -1;
        System.out.println(“Main List: ” + mainList);
        System.out.println(“Sublist: ” + subList);
        System.out.println(“Contains Sublist? ” + contains);
    }
}

Output :

Main List: [1, 2, 3, 4, 5, 6]
 Sublist: [3, 4, 5]
 Contains Sublist? True

14. Write a Java program to remove all even numbers from a list of integers?

import java.util.*;
     public class RemoveEven {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8));
        System.out.println(“Original List: ” + numbers);
        numbers.removeIf(n -> n % 2 == 0); 
        System.out.println(“After Removing Even Numbers: ” + numbers);
    }
}

Output :

Original List: [1, 2, 3, 4, 5, 6, 7, 8]
 After Removing Even Numbers: [1, 3, 5, 7]

15. Write a Java program that creates a PriorityQueue of integers and demonstrates the behavior of the queue (insert elements, peek, poll)?

   import java.util.PriorityQueue;
     public class PriorityQueueExample {
    public static void main(String[] args) {
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        pq.add(30);
        pq.add(10);
        pq.add(20);
        pq.add(5);
        System.out.println(“PriorityQueue: ” + pq);
        System.out.println(“Peek (head): ” + pq.peek());
        System.out.println(“Poll (remove head): ” + pq.poll());
        System.out.println(“PriorityQueue after poll: ” + pq);
    }
}

Output :

 PriorityQueue: [5, 10, 20, 30]
Peek (head): 5
Poll (remove head): 5
PriorityQueue after poll: [10, 30, 20]

16. Write a Java program to find the union of two lists of integers?

import java.util.*;
public class ListUnion {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
        List<Integer> list2 = Arrays.asList(3, 4, 5, 6);
        Set<Integer> unionSet = new LinkedHashSet<>();
        unionSet.addAll(list1);
        unionSet.addAll(list2);
        List<Integer> unionList = new ArrayList<>(unionSet);
        System.out.println(“List 1: ” + list1);
        System.out.println(“List 2: ” + list2);
        System.out.println(“Union: ” + unionList);
    }
}

Output :

   List 1: [1, 2, 3, 4]
   List 2: [3, 4, 5, 6]
   Union: [1, 2, 3, 4, 5, 6]

17. Write a Java program to demonstrate the use of LinkedHashMap where you insert some elements and print the map to show the order of insertion?

    import java.util.LinkedHashMap;
   import java.util.Map;
public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
        map.put(101, “Apple”);
        map.put(102, “Banana”);
        map.put(103, “Cherry”);
        map.put(104, “Date”);
        System.out.println(“LinkedHashMap (Insertion Order):”);
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ” => ” + entry.getValue());
        }
    }
}

Output :

LinkedHashMap (Insertion Order):
101 => Apple
102 => Banana
103 => Cherry
104 => Date

18. Write a Java program that sorts a TreeSet in reverse order?

   import java.util.*;
public class TreeSetReverseOrder {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>(Collections.reverseOrder());
        numbers.add(10);
        numbers.add(5);
        numbers.add(20);
        numbers.add(15);
        System.out.println(“TreeSet in Reverse Order: ” + numbers);
    }
}

Output :

TreeSet in Reverse Order: [20, 15, 10, 5]

19. Write a Java program that checks if a list is empty and returns a boolean result?

import java.util.*; 
    public class ListEmptyCheck {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>();
        boolean isEmpty = items.isEmpty();
        System.out.println(“List: ” + items);
        System.out.println(“Is the list empty? ” + isEmpty);
    }
}

Output :

List: []
Is the list empty? True

20. Write a Java program to convert an ArrayList to a LinkedList?

     import java.util.*;
  public class ConvertList {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add(“Apple”);
        arrayList.add(“Banana”);
        arrayList.add(“Cherry”);
        LinkedList<String> linkedList = new LinkedList<>(arrayList);
        System.out.println(“ArrayList: ” + arrayList);
        System.out.println(“Converted LinkedList: ” + linkedList);
    }
}

Output :

ArrayList: [Apple, Banana, Cherry]
Converted LinkedList: [Apple, Banana, Cherry]

Leave a Reply

Your email address will not be published. Required fields are marked *