Java tricks for Competitive Programming (for Java 8)

In competitive programming it does not only require ability and skill to solve problems but also the ability to solve the problem efficiently. In Java, here are some tips and tricks that can help one to perform better when solving problems under time constraint.

1. Checking if the number is even or odd without using the % operator

In Binary representation, even numbers are those in which the least significant bit (the right most bit) is 0 while odd numbers are those in which the least significant bit is 1, this is the basis of using bitwise technique. Thus, considering the bitwise AND operation between a given number and 1, the least significant bit will be found. If the result is 0, the number is even; else, the number is odd if the result obtained is 1.

Filename: EvenOddChecker.java

public class EvenOddChecker {
    // Method to check if a number is even or odd
    public static void checkEvenOrOdd(int number) {
        // Perform bitwise AND operation with 1
        // If the result is 0, the number is even; otherwise, it's odd
        if ((number & 1) == 0) {
            System.out.println(number + " is even.");
        } else {
            System.out.println(number + " is odd.");
        }
    }
    public static void main(String[] args) {
        // Example numbers to test
        int[] numbers = {10, 15, 24, 37};
        // Test each number
        for (int number : numbers) {
            // Call method to check if the number is even or odd
            checkEvenOrOdd(number);
        }
    }
}

Output:

 
10 is even.
15 is odd.
24 is even.
37 is odd.

Explanation

The checkEvenOrOdd method takes an integer number as input and determines whether it is even or odd using bitwise AND operation. In the main method, an array numbers contains example numbers to test. A loop iterates through each number in the array and calls checkEvenOrOdd method for each number.

2. Fast Multiplication or Division by 2

Fast multiplication or division by 2, also known as bit shifting, is a technique used to multiply or divide an integer by 2 without using the traditional arithmetic operators (* for multiplication and / for division), this technique is particularly useful in scenarios where performance is critical, such as in competitive programming or optimization-focused development.

Filename: FastMultiplicationDivision.java

public class FastMultiplicationDivision {
    // Method for fast multiplication by 2
    public static int fastMultiplyByTwo(int num) {
        return num << 1; // Left shift by one position
    }
    // Method for fast division by 2
    public static int fastDivideByTwo(int num) {
        return num >> 1; // Right shift by one position
    }
    public static void main(String[] args) {
        // Example numbers for testing
        int[] numbers = {10, 15, 30};
        // Test fast multiplication and division for each example number
        for (int num : numbers) {
            System.out.println("Number: " + num);
            System.out.println("Fast Multiply by 2: " + fastMultiplyByTwo(num));
            System.out.println("Fast Divide by 2: " + fastDivideByTwo(num));
            System.out.println();
        }
    }
}

Output:

 
Number: 10
Fast Multiply by 2: 20
Fast Divide by 2: 5
Number: 15
Fast Multiply by 2: 30
Fast Divide by 2: 7
Number: 30
Fast Multiply by 2: 60
Fast Divide by 2: 15

3. Swapping of two numbers using XOR

Swapping two numbers without using a temporary variable is a common problem in programming interviews and competitive programming. One of the most efficient ways to achieve this is by using the bitwise XOR operation. XOR (exclusive OR) is a bitwise operation that results in 1 only if the bits being compared are different; otherwise, it results in 0, this property makes XOR particularly useful for swapping two numbers without using additional memory.

Filename: SwapUsingXOR.java

public class SwapUsingXOR {
    // Method to swap two numbers using XOR
    public static void swap(int a, int b) {
        System.out.println("Before swapping: a = " + a + ", b = " + b);
        // Swapping using XOR
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
        System.out.println("After swapping: a = " + a + ", b = " + b);
    }
    public static void main(String[] args) {
        // Example 1
        int num1 = 10;
        int num2 = 20;
        swap(num1, num2);
        // Example 2
        int num3 = 5;
        int num4 = 15;
        swap(num3, num4);
    }
}

Output:

 
Before swapping: a = 10, b = 20
After swapping: a = 20, b = 10
Before swapping: a = 5, b = 15
After swapping: a = 15, b = 5

4. Using String Buffer for String Manipulations

In Java, strings are immutable, meaning once a String object is created, it cannot be changed and this immutability can lead to performance issues when performing multiple string manipulations, as each modification creates a new String object. To address this, Java provides StringBuffer class for efficient string manipulation. StringBuffer is designed for use in scenarios where strings undergo frequent modifications, such as appending, inserting, or deleting characters. Unlike StringBuilder, StringBuffer is synchronized, making it thread-safe but slightly slower in single-threaded environments.

Filename: StringBufferDemo.java

public class StringBufferDemo {
    public static void main(String[] args) {
        // Initializing a StringBuffer
        StringBuffer sb = new StringBuffer("Hello");
        // Append operation
        sb.append(" World");
        System.out.println("After append: " + sb);
        // Insert operation
        sb.insert(5, ",");
        System.out.println("After insert: " + sb);
        // Delete operation
        sb.delete(5, 6);
        System.out.println("After delete: " + sb);
        // Replace operation
        sb.replace(5, 11, " Java");
        System.out.println("After replace: " + sb);
        // Reverse operation
        sb.reverse();
        System.out.println("After reverse: " + sb);
        // Resetting StringBuffer for further operations
        sb.reverse();
        // Demonstrating capacity and length
        System.out.println("Current capacity: " + sb.capacity());
        System.out.println("Current length: " + sb.length());
        // Setting length
        sb.setLength(5);
        System.out.println("After setLength(5): " + sb);
        // Additional examples
        // Example 1: Appending various data types
        sb = new StringBuffer("Value: ");
        sb.append(100).append(" ").append(99.99).append(" ").append(true);
        System.out.println("After appending various data types: " + sb);
        // Example 2: Insert at different positions
        sb = new StringBuffer("12345");
        sb.insert(2, "abc");
        System.out.println("After insert at index 2: " + sb);
        // Example 3: Delete a range of characters
        sb.delete(2, 5);
        System.out.println("After deleting from index 2 to 5: " + sb);
        // Example 4: Replace a substring
        sb.replace(1, 3, "XYZ");
        System.out.println("After replacing from index 1 to 3: " + sb);
        // Example 5: Reversing a StringBuffer
        sb.reverse();
        System.out.println("After reversing: " + sb);
    }
}

Output:

 
After append: Hello World
After insert: Hello, World
After delete: Hello World
After replace: Hello Java
After reverse: avaJ olleH
Current capacity: 21
Current length: 10
After setLength(5): Hello
After appending various data types: Value: 100 99.99 true
After insert at index 2: 12abc345
After deleting from index 2 to 5: 12345
After replacing from index 1 to 3: 1XYZ45
After reversing: 54ZYX1

5. Calculating the Most Significant Digit

The most significant digit (MSD) of a number is the leftmost digit in its decimal representation. For example, the most significant digit of 12345 is 1, this digit can provide valuable information about the scale of the number. Calculating the MSD can be efficiently done using logarithms. Compute the base-10 logarithm of the number. Subtract the floor of the logarithm from the logarithm to get the fractional part. Raise 10 to the power of this fractional part. The integer part of the result is the most significant digit.

Filename: MostSignificantDigit.java

public class MostSignificantDigit {
    // Method to calculate the most significant digit
    public static int getMostSignificantDigit(int number) {
        if (number == 0) {
            return 0; // Special case for zero
        }
        // Compute the base-10 logarithm of the number
        double log10 = Math.log10(Math.abs(number));
        // Subtract the floor of the logarithm from the logarithm to get the fractional part
        double fractionalPart = log10 - Math.floor(log10);
        // Raise 10 to the power of this fractional part
        double msd = Math.pow(10, fractionalPart);
        // The integer part of the result is the most significant digit
        return (int) msd;
    }
    public static void main(String[] args) {
        // Example numbers to test
        int[] numbers = {12345, 2024, 56, 1};
        // Test each number
        for (int number : numbers) {
            System.out.println("The most significant digit of " + number + " is: " + getMostSignificantDigit(number));
        }
    }
}

Output:

 
The most significant digit of 12345 is: 1
The most significant digit of 2024 is: 2
The most significant digit of 56 is: 5
The most significant digit of 1 is: 1

6. Calculating the Number of Digits Using Logarithms

Calculating the number of digits in a number is a common operation in many algorithms and applications. Compute the base-10 logarithm of the absolute value of the number. Take the floor of the logarithm. Add 1 to the result to get the number of digits.

Filename: NumberOfDigits.java

public class NumberOfDigits {
    // Method to calculate the number of digits
    public static int countDigits(int number) {
        if (number == 0) {
            return 1; // Special case for zero
        }
        // Compute the base-10 logarithm of the absolute value of the number
        double log10 = Math.log10(Math.abs(number));
        // Take the floor of the logarithm
        int floorLog10 = (int) Math.floor(log10);
        // Add 1 to the result to get the number of digits
        return floorLog10 + 1;
    }
    public static void main(String[] args) {
        // Example numbers to test
        int[] numbers = {12345, 2024, 987, 56, 1};
        // Test each number
        for (int number : numbers) {
            System.out.println("The number of digits in " + number + " is: " + countDigits(number));
        }
    }
}

Output:

 
The number of digits in 12345 is: 5
The number of digits in 2024 is: 4
The number of digits in 987 is: 3
The number of digits in 56 is: 2
The number of digits in 1 is: 1

7. Inbuilt GCD Method

In Java, you can compute the GCD of two numbers efficiently using the java.math.BigInteger class, which provides an inbuilt method gcd to calculate the GCD of two BigInteger objects. This method simplifies the process, ensuring accurate and efficient computation without the need for manually implementing the algorithm.

Filename: GCDExample.java

import java.math.BigInteger;
public class GCDExample {
    // Method to calculate the GCD of two integers using BigInteger
    public static int calculateGCD(int num1, int num2) {
        // Handle special case where both numbers are zero
        if (num1 == 0 && num2 == 0) {
            throw new IllegalArgumentException("GCD is not defined for both numbers being zero.");
        }
        // Create BigInteger instances for the numbers
        BigInteger bigInt1 = BigInteger.valueOf(num1);
        BigInteger bigInt2 = BigInteger.valueOf(num2);
        // Use the gcd method of BigInteger to compute the GCD
        BigInteger gcd = bigInt1.gcd(bigInt2);
        // Convert the result back to int and return
        return gcd.intValue();
    }
    public static void main(String[] args) {
        // Example numbers to test
        int[][] testPairs = {
            {56, 98},    
            {54, 24},    
            {100, 25},  
            {0, 0},      // Both numbers are zero (handled as a special case)
        };
        // Test each pair of numbers
        for (int[] pair : testPairs) {
            int num1 = pair[0];
            int num2 = pair[1];
            try {
                int gcd = calculateGCD(num1, num2);
                System.out.println("The GCD of " + num1 + " and " + num2 + " is: " + gcd);
            } catch (IllegalArgumentException e) {
                System.out.println("Error: " + e.getMessage() + " (num1: " + num1 + ", num2: " + num2 + ")");
            }
        }
    }
}

Output:

 
The GCD of 56 and 98 is: 14
The GCD of 54 and 24 is: 6
The GCD of 100 and 25 is: 25
Error: GCD is not defined for both numbers being zero. (num1: 0, num2: 0)

8. Checking for a Prime Number

A prime number is a natural number greater than 1 that has no positive divisors other than 1 and itself. Java provides a convenient and efficient method for prime checking in the java.math.BigInteger class, called isProbablePrime(), this method determines if a BigInteger is probably prime with a certain degree of confidence or definitely composite.

Filename: PrimeCheckExample.java

import java.math.BigInteger;
public class PrimeCheckExample {
    // Method to check if a number is probably prime
    public static boolean isPrime(int number, int certainty) {
        // Create BigInteger instance for the number
        BigInteger bigInt = BigInteger.valueOf(number);
        // Use the isProbablePrime method to check for primality
        return bigInt.isProbablePrime(certainty);
    }
    // Method to test various numbers for primality
    public static void testPrimality() {
        // Example numbers to test
        int[] numbers = {2, 4, 17, 18};
        // Certainty level
        int certainty = 10;
        // Test each number
        for (int number : numbers) {
            boolean isPrime = isPrime(number, certainty);
            System.out.println("Is " + number + " a prime number? " + isPrime);
        }
    }
    // Main method to run the program
    public static void main(String[] args) {
        // Call the test method to check primality of various numbers
        testPrimality();
    }
}

Output:

 
Is 2 a prime number? true
Is 4 a prime number? false
Is 17 a prime number? true
Is 18 a prime number? false

9. Efficiently Checking if a Number is a Power of 2

A number is a power of 2 if and only if it has exactly one '1' bit in its binary representation. This property can be used to check if a number is a power of 2 more efficiently than repeatedly dividing by 2. The normal division technique has a time complexity of O(logN), but we can solve it in O(n) where n is the number of digits in the binary representation of the number.

Filename: PowerOfTwoChecker.java

public class PowerOfTwoChecker {
    // Method to check if a number is a power of 2
    public static boolean isPowerOfTwo(int number) {
        // A number is a power of 2 if it is greater than 0 and n & (n - 1) is 0
        return number > 0 && (number & (number - 1)) == 0;
    }
    // Method to test various numbers for being a power of 2
    public static void testPowerOfTwo() {
        // Example numbers to test
        int[] numbers = {16, 100, 512, 2097 };
        // Test each number 
        for (int number : numbers) {
            boolean isPowerOfTwo = isPowerOfTwo(number);
            System.out.println("Is " + number + " a power of 2? " + isPowerOfTwo);
        }
    }
    // Main method to run the program
    public static void main(String[] args) {
        // Call the test method to check if various numbers are powers of 2
        testPowerOfTwo();
    }
}

Output:

 
Is 16 a power of 2? true
Is 100 a power of 2? false
Is 512 a power of 2? true
Is 2097 a power of 2? false

10. Sorting Algorithm

Java provides two primary methods for sorting: Arrays.sort() for arrays and Collections.sort() for collections. Both methods are part of the Java standard library and offer efficient ways to sort elements.

In the following code, we use Arrays.sort() for sorting.

Filename: ArraysSortExample.java

import java.util.Arrays;
public class ArraysSortExample {
    public static void main(String[] args) {
        // Sorting a primitive array
        int[] intArray = {5, 2, 8, 3, 1};
        Arrays.sort(intArray);
        System.out.println("Sorted int array: " + Arrays.toString(intArray));
        // Sorting an array of objects
        String[] stringArray = {"banana", "apple", "cherry", "date"};
        Arrays.sort(stringArray);
        System.out.println("Sorted String array: " + Arrays.toString(stringArray));
    }
}

Output:

 
Sorted int array: [1, 2, 3, 5, 8]
Sorted String array: [apple, banana, cherry, date]

In the following code, we use Collections.sort() for sorting.

Filename: CollectionsSortExample.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class CollectionsSortExample {
    public static void main(String[] args) {
        // Sorting a list of integers
        List<Integer> intList = new ArrayList<>();
        Collections.addAll(intList, 5, 2, 8, 3, 1);
        Collections.sort(intList);
        System.out.println("Sorted Integer list: " + intList);
        // Sorting a list of strings
        List<String> stringList = new ArrayList<>();
        Collections.addAll(stringList, "banana", "apple", "cherry", "date");
        Collections.sort(stringList);
        System.out.println("Sorted String list: " + stringList);
        // Sorting with a custom comparator (reverse order)
        Collections.sort(stringList, Comparator.reverseOrder());
        System.out.println("Sorted String list in reverse order: " + stringList);
    }
}

Output:

 
Sorted Integer list: [1, 2, 3, 5, 8]
Sorted String list: [apple, banana, cherry, date]
Sorted String list in reverse order: [date, cherry, banana, apple]

11. Searching Algorithm

Java provides two primary methods for binary search: Arrays.binarySearch() for arrays and Collections.binarySearch() for collections. Both methods implement the binary search algorithm, which requires the data to be sorted and has a time complexity of O(logn).

In the folllowing code, we use Arrays.binarySearch() for searching.

Filename: ArraysBinarySearchExample.java

import java.util.Arrays;
public class ArraysBinarySearchExample {
    public static void main(String[] args) {
        // Searching in a primitive array
        int[] intArray = {1, 2, 3, 4, 5, 8};
        int index1 = Arrays.binarySearch(intArray, 3);
        System.out.println("Index of 3 in intArray: " + index1);
        // Searching in an array of objects
        String[] stringArray = {"apple", "banana", "cherry", "date"};
        int index2 = Arrays.binarySearch(stringArray, "cherry");
        System.out.println("Index of 'cherry' in stringArray: " + index2);
        // Searching in an array of objects with a custom comparator (case insensitive)
        Arrays.sort(stringArray, String.CASE_INSENSITIVE_ORDER);
        int index3 = Arrays.binarySearch(stringArray, "Banana", String.CASE_INSENSITIVE_ORDER);
        System.out.println("Index of 'Banana' in sorted stringArray (case insensitive): " + index3);
    }
}

Output:

 
Index of 3 in intArray: 2
Index of 'cherry' in stringArray: 2
Index of 'Banana' in sorted stringArray (case insensitive): 1

In the following code, we use Collections.binarySearch() for searching.

Filename: CollectionsBinarySearchExample.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class CollectionsBinarySearchExample {
    public static void main(String[] args) {
        // Searching in a list of integers
        List<Integer> intList = new ArrayList<>();
        Collections.addAll(intList, 1, 2, 3, 4, 5, 8);
        int index1 = Collections.binarySearch(intList, 3);
        System.out.println("Index of 3 in intList: " + index1);
        // Searching in a list of strings
        List<String> stringList = new ArrayList<>();
        Collections.addAll(stringList, "apple", "banana", "cherry", "date");
        int index2 = Collections.binarySearch(stringList, "cherry");
        System.out.println("Index of 'cherry' in stringList: " + index2);
        // Searching in a list of strings with a custom comparator (case insensitive)
        Collections.sort(stringList, String.CASE_INSENSITIVE_ORDER);
        int index3 = Collections.binarySearch(stringList, "Banana", String.CASE_INSENSITIVE_ORDER);
        System.out.println("Index of 'Banana' in sorted stringList (case insensitive): " + index3);
    }
}

Output:

 
Index of 3 in intList: 2
Index of 'cherry' in stringList: 2
Index of 'Banana' in sorted stringList (case insensitive): 1

12. Copy Algorithms

Copying arrays and collections is a common operation in programming, particularly when you need to duplicate data structures without altering the original ones. Java provides built-in methods for this purpose, including Arrays.copyOf(), Arrays.copyOfRange(), and Collections.copy(). These methods offer a straightforward way to create copies of arrays and collections.

The below code shows usage of Arrays.copyOf() method:

Filename: ArraysCopyExample.java

import java.util.Arrays;
public class ArraysCopyExample {
    public static void main(String[] args) {
        // Copying a primitive array
        int[] intArray = {1, 2, 3, 4, 5};
        int[] copiedIntArray = Arrays.copyOf(intArray, 7);
        System.out.println("Original int array: " + Arrays.toString(intArray));
        System.out.println("Copied int array: " + Arrays.toString(copiedIntArray));
        // Copying an array of objects
        String[] stringArray = {"apple", "banana", "cherry"};
        String[] copiedStringArray = Arrays.copyOf(stringArray, 5);
        System.out.println("Original String array: " + Arrays.toString(stringArray));
        System.out.println("Copied String array: " + Arrays.toString(copiedStringArray));
    }
}

Output:

 
Original int array: [1, 2, 3, 4, 5]
Copied int array: [1, 2, 3, 4, 5, 0, 0]
Original String array: [apple, banana, cherry]
Copied String array: [apple, banana, cherry, null, null]

The below code demonstrates the usage of Arrays.copyOfRange() method:

Filename: ArraysCopyOfRangeExample.java

import java.util.Arrays;
public class ArraysCopyOfRangeExample {
    public static void main(String[] args) {
        // Copying a range from a primitive array
        int[] intArray = {1, 2, 3, 4, 5};
        int[] rangeCopiedIntArray = Arrays.copyOfRange(intArray, 1, 4);
        System.out.println("Original int array: " + Arrays.toString(intArray));
        System.out.println("Range copied int array: " + Arrays.toString(rangeCopiedIntArray));
        // Copying a range from an array of objects
        String[] stringArray = {"apple", "banana", "cherry"};
        String[] rangeCopiedStringArray = Arrays.copyOfRange(stringArray, 0, 2);
        System.out.println("Original String array: " + Arrays.toString(stringArray));
        System.out.println("Range copied String array: " + Arrays.toString(rangeCopiedStringArray));
    }
}

Output:

 
Original int array: [1, 2, 3, 4, 5]
Range copied int array: [2, 3, 4]
Original String array: [apple, banana, cherry]
Range copied String array: [apple, banana]

The following code demonstrates the usage of Collections.copy() method:

Filename: CollectionsCopyExample.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsCopyExample {
    public static void main(String[] args) {
        // Creating source and destination lists
        List<String> sourceList = new ArrayList<>();
        Collections.addAll(sourceList, "apple", "banana", "cherry");
        List<String> destList = new ArrayList<>(Collections.nCopies(sourceList.size(), ""));
        System.out.println("Original source list: " + sourceList);
        System.out.println("Original destination list: " + destList);
        // Copying elements from source list to destination list
        Collections.copy(destList, sourceList);
        System.out.println("Copied destination list: " + destList);
    }
}

Output:

 
Original source list: [apple, banana, cherry]
Original destination list: [, , ]
Copied destination list: [apple, banana, cherry]

13. Frequency and Rotation

Java provides several utility methods in the Collections class to perform common operations on collections. Two of these useful methods are Collections.rotate() and Collections.frequency(). These methods help in manipulating and analyzing collections easily and efficiently.

Filename: CollectionsRotateFrequencyExample.java

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class CollectionsRotateFrequencyExample {
    // Method to demonstrate Collections.rotate()
    public static void demonstrateRotate() {
        List<String> list = Arrays.asList("a", "b", "c", "d", "e");
        System.out.println("Original list: " + list);
        // Rotate the list by 2 positions to the right
        Collections.rotate(list, 2);
        System.out.println("List after rotating by 2: " + list);
        // Rotate the list by -3 positions to the left
        Collections.rotate(list, -3);
        System.out.println("List after rotating by -3: " + list);
    }
    // Method to demonstrate Collections.frequency()
    public static void demonstrateFrequency() {
        List<String> list = Arrays.asList("apple", "banana", "apple", "cherry", "banana", "apple");
        System.out.println("List: " + list);
        // Find the frequency of "apple"
        int frequencyOfApple = Collections.frequency(list, "apple");
        System.out.println("Frequency of 'apple': " + frequencyOfApple);
        // Find the frequency of "banana"
        int frequencyOfBanana = Collections.frequency(list, "banana");
        System.out.println("Frequency of 'banana': " + frequencyOfBanana);
        // Find the frequency of "cherry"
        int frequencyOfCherry = Collections.frequency(list, "cherry");
        System.out.println("Frequency of 'cherry': " + frequencyOfCherry);
    }
    // Main method to run the examples
    public static void main(String[] args) {
        demonstrateRotate();
        demonstrateFrequency();
    }
}

Output:

 
Original list: [a, b, c, d, e]
List after rotating by 2: [d, e, a, b, c]
List after rotating by -3: [b, c, d, e, a]
List: [apple, banana, apple, cherry, banana, apple]
Frequency of 'apple': 3
Frequency of 'banana': 2
Frequency of 'cherry': 1

14. Java Collection Framework

The Java Collection Framework is a unified architecture for representing and manipulating collections of objects. It includes interfaces, implementations, and algorithms to help manage groups of objects effectively, this framework is part of the java.util package and provides a set of well-designed classes and interfaces to handle different types of collections, such as lists, sets, and maps.

An example code using a LinkedList:

Filename: LinkedListExample.java

import java.util.LinkedList;
import java.util.Iterator;
public class LinkedListExample {
    public static void main(String[] args) {
        // Create a LinkedList of Strings
        LinkedList<String> linkedList = new LinkedList<>();
        // Adding elements to the LinkedList
        linkedList.add("Apple");
        linkedList.add("Banana");
        linkedList.add("Cherry");
        linkedList.add("Date");
        // Printing the LinkedList
        System.out.println("LinkedList: " + linkedList);
        // Accessing elements in the LinkedList
        String firstElement = linkedList.get(0);
        String secondElement = linkedList.get(1);
        System.out.println("First element: " + firstElement);
        System.out.println("Second element: " + secondElement);
        // Adding an element at the beginning and end
        linkedList.addFirst("Mango");
        linkedList.addLast("Grapes");
        System.out.println("After adding elements: " + linkedList);
        // Removing elements from the LinkedList
        linkedList.removeFirst();
        linkedList.removeLast();
        System.out.println("After removing elements: " + linkedList);
        }
}

Output:

 
LinkedList: [Apple, Banana, Cherry, Date]
First element: Apple
Second element: Banana
After adding elements: [Mango, Apple, Banana, Cherry, Date, Grapes]
After removing elements: [Apple, Banana, Cherry, Date]

15. Radix Conversion Using Wrapper Classes

Radix conversion involves changing the base of a number from one base to another. Commonly used bases include binary (base 2), octal (base 8), decimal (base 10), and hexadecimal (base 16). Java provides built-in methods in wrapper classes like Integer to facilitate these conversions easily.

Radix: The base of a number system. For example, binary is base 2, decimal is base 10, hexadecimal is base 16.

Wrapper Classes: Classes in Java that provide methods for manipulating primitive data types as objects. The examples include Integer, Double, Character, etc.

Filename: RadixConversionExample.java

public class RadixConversionExample {
    public static void main(String[] args) {
        int number = 255;
        // Convert to binary
        String binaryString = Integer.toBinaryString(number);
        System.out.println("Binary representation of " + number + " is: " + binaryString);
        // Convert to octal
        String octalString = Integer.toOctalString(number);
        System.out.println("Octal representation of " + number + " is: " + octalString);
        // Convert to hexadecimal
        String hexString = Integer.toHexString(number);
        System.out.println("Hexadecimal representation of " + number + " is: " + hexString);
        // Parse the binary string back to integer
        int binaryNumber = Integer.parseInt(binaryString, 2);
        System.out.println("Parsed binary number (" + binaryString + ") is: " + binaryNumber);
        // Parse the octal string back to integer
        int octalNumber = Integer.parseInt(octalString, 8);
        System.out.println("Parsed octal number (" + octalString + ") is: " + octalNumber);
        // Parse the hexadecimal string back to integer
        int hexNumber = Integer.parseInt(hexString, 16);
        System.out.println("Parsed hexadecimal number (" + hexString + ") is: " + hexNumber);
    }
}

Output:

 
Binary representation of 255 is: 11111111
Octal representation of 255 is: 377
Hexadecimal representation of 255 is: ff
Parsed binary number (11111111) is: 255
Parsed octal number (377) is: 255
Parsed hexadecimal number (ff) is: 255

16. NullPointerException

A NullPointerException is a runtime exception in Java that occurs when an application attempts to use an object reference that has not been initialized or points to null, this can happen in various scenarios such as calling a method on a null object, accessing or modifying a field of a null object, or taking the length of a null array.

Filename: NullPointerExceptionExample.java

import java.util.Optional;
public class NullPointerExceptionExample {
    public static void main(String[] args) {
        // Example 1: Calling a method on a null object
        String str = null;
        try {
            System.out.println("Length of string: " + str.length());
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException: str is null");
        }
        // Example 2: Accessing a field of a null object
        Person person = null;
        try {
            System.out.println("Person's name: " + person.name);
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException: person is null");
        }
        // Example 3: Accessing an element of a null array
        int[] numbers = null;
        try {
            System.out.println("First number: " + numbers[0]);
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException: numbers array is null");
        }
        // Example 4: Using Optional to avoid NullPointerException
        String optionalStr = null;
        Optional<String> optional = Optional.ofNullable(optionalStr);
        int length = optional.map(String::length).orElse(0);
        System.out.println("Length using Optional: " + length);
    }
    static class Person {
        String name;
    }
}

Output:

 
Caught NullPointerException: str is null
Caught NullPointerException: person is null
Caught NullPointerException: numbers array is null
Length using Optional: 0

Conclusion

In conclusion, competitive programming often demands efficient, concise, and reliable code. Java 8 offers a rich set of features that, when leveraged properly, can significantly enhance your performance in competitions.

Next TopicLargest-integers-with-sum-of-setbits-at-most-k-in-java

← prev next →