Q1: How to Find the Second Largest Number in an Array in Java?
To find the second largest number efficiently, avoid sorting. Instead, use a single-pass technique with two variables.
Approach:
- Initialize two variables: largest and secondLargest.
- Traverse the array once.
- Update both variables based on the current element.
Java Code:
java
public class SecondLargestFinder {
public static int findSecondLargest(int[] arr) {
int largest = Integer.MIN_VALUE;
int secondLargest = Integer.MIN_VALUE;
for (int num : arr) {
if (num > largest) {
secondLargest = largest;
largest = num;
} else if (num > secondLargest && num != largest) {
secondLargest = num;
}
}
return secondLargest;
}
public static void main(String[] args) {
int[] numbers = {12, 35, 1, 10, 34, 1};
System.out.println(“Second largest number: ” + findSecondLargest(numbers));
}
}
Output:
sql
Second largest number: 34
Q2: How to Find Duplicate Elements in an Array?
Use a HashSet to track already seen elements and detect duplicates during a single array pass.
Java Code:
java
import java.util.*;
public class DuplicateFinder {
public static List<Integer> findDuplicates(int[] arr) {
Set<Integer> seen = new HashSet<>();
List<Integer> duplicates = new ArrayList<>();
for (int num : arr) {
if (!seen.add(num)) {
duplicates.add(num);
}
}
return duplicates;
}
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 2, 7, 8, 8, 3};
System.out.println(“Duplicate elements: ” + findDuplicates(numbers));
}
}
Output:
less
Duplicate elements: [2, 3, 8]
Q3: How to Check if Two Strings are Anagrams?
Two strings are anagrams if they have the same characters with the same frequencies, regardless of order.
Solution:
- Convert strings to lowercase and remove spaces.
- Sort both strings.
- Compare sorted versions.
Java Code:
java
public class AnagramChecker {
public static boolean areAnagrams(String str1, String str2) {
str1 = str1.replaceAll(“\\s”, “”).toLowerCase();
str2 = str2.replaceAll(“\\s”, “”).toLowerCase();
if (str1.length() != str2.length()) return false;
char[] charArray1 = str1.toCharArray();
char[] charArray2 = str2.toCharArray();
java.util.Arrays.sort(charArray1);
java.util.Arrays.sort(charArray2);
return java.util.Arrays.equals(charArray1, charArray2);
}
public static void main(String[] args) {
String s1 = “Listen”;
String s2 = “Silent”;
System.out.println(s1 + ” and ” + s2 + ” are anagrams: ” + areAnagrams(s1, s2));
}
}
Output:
sql
Listen and Silent are anagrams: true
Q4: How to Find the Missing Number in a Sequence?
If you’re given numbers from 1 to N with one missing, you can calculate the expected total and subtract the actual sum.
Java Code:
java
public class MissingNumberFinder {
public static int findMissingNumber(int[] arr, int n) {
int expectedSum = n * (n + 1) / 2;
int actualSum = 0;
for (int num : arr) actualSum += num;
return expectedSum – actualSum;
}
public static void main(String[] args) {
int[] numbers = {1, 2, 4, 6, 3, 7, 8};
System.out.println(“Missing number: ” + findMissingNumber(numbers, 8));
}
}
Output:
yaml
Missing number: 5
Q5: How to Sort an Array Without Using Arrays.sort() in Java?
Manual sorting algorithms like Bubble Sort can be used to sort arrays.
Java Code (Bubble Sort):
java
public class BubbleSort {
public static void bubbleSort(int[] arr) {
int n = arr.length;
boolean swapped;
for (int i = 0; i < n – 1; i++) {
swapped = false;
for (int j = 0; j < n – i – 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = true;
}
}
if (!swapped) break;
}
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
System.out.println(“Original array: ” + java.util.Arrays.toString(arr));
bubbleSort(arr);
System.out.println(“Sorted array: ” + java.util.Arrays.toString(arr));
}
}
Output:
less
Original array: [64, 34, 25, 12, 22, 11, 90]
Sorted array: [11, 12, 22, 25, 34, 64, 90]
Q6: How to Find the First Non-Repeated Character in a String?
Use a HashMap to count occurrences and identify the first character with a count of 1.
Java Code:
java
import java.util.*;
public class FirstNonRepeatedChar {
public static char findFirstNonRepeatedChar(String str) {
Map<Character, Integer> charCounts = new HashMap<>();
for (char c : str.toCharArray()) {
charCounts.put(c, charCounts.getOrDefault(c, 0) + 1);
}
for (char c : str.toCharArray()) {
if (charCounts.get(c) == 1) return c;
}
return ‘\0’;
}
public static void main(String[] args) {
String str = “programming”;
char result = findFirstNonRepeatedChar(str);
System.out.println(“First non-repeated character: ” + (result == ‘\0’ ? “None” : result));
}
}
Output:
sql
First non-repeated character: p
Q7: How to Find Common Elements Between Two Arrays in Java?
Use a HashSet to track elements and find intersection.
Java Code:
java
import java.util.*;
public class CommonElementsFinder {
public static Integer[] findCommonElements(Integer[] arr1, Integer[] arr2) {
Set<Integer> set1 = new HashSet<>(Arrays.asList(arr1));
Set<Integer> commonElements = new HashSet<>();
for (Integer num : arr2) {
if (set1.contains(num)) commonElements.add(num);
}
return commonElements.toArray(new Integer[0]);
}
public static void main(String[] args) {
Integer[] array1 = {1, 2, 3, 4, 5};
Integer[] array2 = {3, 4, 5, 6, 7};
System.out.println(“Common elements: ” + Arrays.toString(findCommonElements(array1, array2)));
}
}
Output:
less
Common elements: [3, 4, 5]
Q8. How do you count the frequency of elements in a String array using HashMap?
Explanation:
Use HashMap to store string elements as keys and their counts as values. This approach is commonly used in string processing and data analytics.
Code Example:
java
import java.util.HashMap;
import java.util.Map;
public class FrequencyCounter {
public static Map<String, Integer> countFrequency(String[] array) {
Map<String, Integer> frequencyMap = new HashMap<>();
for (String item : array) {
frequencyMap.put(item, frequencyMap.getOrDefault(item, 0) + 1);
}
return frequencyMap;
}
public static void main(String[] args) {
String[] fruits = {“Apple”, “Banana”, “Apple”, “Orange”, “Banana”,
“Orange”, “Orange”, “Apple”, “Orange”, “Grape”};
Map<String, Integer> frequency = countFrequency(fruits);
System.out.println(“Frequency of elements:”);
for (Map.Entry<String, Integer> entry : frequency.entrySet()) {
System.out.println(entry.getKey() + “: ” + entry.getValue());
}
}
}
Output:
makefile
Apple: 3
Banana: 2
Orange: 4
Grape: 1
Q9. How do you reverse the words in a sentence using Java?
Explanation:
Use split() to separate the words, then iterate in reverse to construct the sentence in reverse order.
Code Example:
java
public class WordReverser {
public static String reverseWords(String sentence) {
String[] words = sentence.split(“\\s+”);
StringBuilder reversed = new StringBuilder();
for (int i = words.length – 1; i >= 0; i–) {
reversed.append(words[i]).append(i > 0 ? ” ” : “”);
}
return reversed.toString();
}
public static void main(String[] args) {
String sentence = “Java is a programming language”;
System.out.println(“Original: ” + sentence);
System.out.println(“Reversed: ” + reverseWords(sentence));
}
}
Output:
vbnet
Original: Java is a programming language
Reversed: language programming a is Java
Q10. How do you find pairs in an array whose sum equals a target value?
Explanation:
Use a HashSet to store visited values and check if the complement exists.
Code Example:
java
import java.util.*;
public class PairSumFinder {
public static List<int[]> findPairsWithSum(int[] arr, int targetSum) {
List<int[]> pairs = new ArrayList<>();
Set<Integer> visited = new HashSet<>();
for (int num : arr) {
int complement = targetSum – num;
if (visited.contains(complement)) {
pairs.add(new int[]{complement, num});
}
visited.add(num);
}
return pairs;
}
public static void main(String[] args) {
int[] numbers = {2, 4, 3, 5, 6, -2, 8, 7, 1};
int target = 6;
List<int[]> pairs = findPairsWithSum(numbers, target);
for (int[] pair : pairs) {
System.out.println(“(” + pair[0] + “, ” + pair[1] + “)”);
}
}
}
Output:
scss
(2, 4)
(-2, 8)
(5, 1)
👉The Next 10 Questions-II: JAVA STRING
