Turn Complexity into Code: Learn Permutation in Java with Examples

Permutation in Java is the process of generating all possible ordered arrangements of a set of elements, where the order significantly affects the outcome. Understanding Java permutation techniques helps you tackle challenges in data structure problems, algorithm design, and combinatorial problems that require systematic exploration of sequences.

This blog explains the fundamentals of permutation in Java, practical approaches to creating permutations with examples.

Understanding Permutation in Java: An Overview of Basics

A permutation in Java refers to an arrangement of objects in a specific order. For a particular set, the number of possible permutations is calculated based on how many objects are selected and their order of arrangement. When considering permutations, the order in which the objects appear is important. It is then used to calculate the number of ways to arrange or order items from a set.

To strengthen your skills in Java and other advanced technologies, check these leading programs:

• Professional Certificate Program in Cloud Computing and DevOps
• Master of Design in User Experience
• AI-Driven Full-stack Development

Let’s break down permutation in Java mathematically to understand how it works.

Understanding Permutation in Mathematics

Permutation is a way to find out how many different ways you can arrange a certain number of items when the order matters. It answers questions like: "How many ways can I arrange 3 letters?" or "How many ways can I line up 5 people?"

The formula to calculate permutations is:

Where, 

• n! (n factorial) means multiplying all whole numbers from n down to 1. For example, 3! = 3 × 2 × 1 = 6.
• n is the total number of items you have.
• r is the number of items you want to arrange or select.

Breaking down the formula:

• The numerator, n!n!, counts all the possible ways to arrange all n items.
• The denominator, (n−r)!(n - r)!, removes the arrangements of the leftover items you aren’t arranging.

Example: How many ways can you arrange the letters in “ABD”?

• Total letters, n = 3 (A, B, and D)
• Number of letters to arrange, r = 3 (since you want to arrange all letters)

Using the formula:

P(3,3)=(3−3)!/3!​=0!/3!​

We know:

• 3! = 3 × 2 × 1 = 6
• 0! is defined as 1

This means there are 6 different ways to arrange the letters A, B, and D. This concept helps solve many problems where the order of arrangement matters, such as passwords, seating arrangements, or scheduling tasks.

Also Read: Permutation vs Combination: Difference between Permutation and Combination

Now that you’ve explored the basic concept of permutation in Java, let’s understand how to implement it using Java. 

Implementing Permutation in Java: Key Approaches You Should Know

You can solve permutation problems using three common approaches: recursion with backtracking, iterative methods, and sometimes a combination of both. These approaches help you build a deeper understanding of algorithmic thinking and are often asked in coding interviews. Using Java, you'll write logic that generates all possible arrangements of a given set of elements, whether for characters, numbers, or objects.

Let’s look at the implementations of permutation in Java using different approaches.

1. Recursion with Backtracking

This approach is widely used for its simplicity and clarity. Using recursion and backtracking, you systematically explore all possible arrangements of elements. It’s ideal for solving permutation problems in coding interviews and algorithmic challenges.

Sample Code:

import java.util.*;

public class PermutationRecursive {
    public static void permute(String str, String result) {
        if (str.length() == 0) {
            System.out.println(result);
            return;
        }

        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);
            String remaining = str.substring(0, i) + str.substring(i + 1);
            permute(remaining, result + ch);
        }
    }

    public static void main(String[] args) {
        String input = "ABC";
        permute(input, "");
    }
}

Code Explanation:

• The function calls itself recursively, reducing the string size each time it is invoked.
• Each call selects one character and appends it to the result.
• Backtracking ensures all possible orders are covered.

Output:

ABC
ACB
BAC
BCA
CAB
CBA

Also Read: Permutation vs Combination: Discover the Crucial Differences Now!

2. Iterative Approach using Heap’s Algorithm

This approach is known for its efficiency and structured process. Using Heap’s algorithm, you iteratively generate all possible permutations through smart in-place swaps. It’s a great fit for performance-critical tasks and understanding iterative logic in Java.

Sample Code:

public class PermutationIterative {
    public static void heapPermutation(char[] arr, int size) {
        if (size == 1) {
            System.out.println(String.valueOf(arr));
            return;
        }

        for (int i = 0; i < size; i++) {
            heapPermutation(arr, size - 1);

            if (size % 2 == 1) {
                char temp = arr[0];
                arr[0] = arr[size - 1];
                arr[size - 1] = temp;
            } else {
                char temp = arr[i];
                arr[i] = arr[size - 1];
                arr[size - 1] = temp;
            }
        }
    }

    public static void main(String[] args) {
        char[] input = {'A', 'B', 'C'};
        heapPermutation(input, input.length);
    }
}

Code Explanation:

• Heap’s Algorithm uses swapping to generate permutations.
• It's efficient and avoids a recursion stack overflow for larger inputs.

Output:

ABC
BAC
CBA
BCA
CAB
ACB

3. Iterative Using Next Permutation (Lexicographic Order)

This approach is efficient and systematic, particularly when generating permutations in sorted or dictionary order. By following a well-defined algorithm, you iterate through each possible arrangement without recursion. It's handy in problems that require the next immediate permutation or ordered output.

Sample Code:

import java.util.Arrays;

public class PermutationNext {
    public static void main(String[] args) {
        String input = "ABC";
        char[] chars = input.toCharArray();
        Arrays.sort(chars);

        do {
            System.out.println(String.valueOf(chars));
        } while (nextPermutation(chars));
    }

    private static boolean nextPermutation(char[] arr) {
        int i = arr.length - 2;
        while (i >= 0 && arr[i] >= arr[i + 1]) i--;
        if (i < 0) return false;

        int j = arr.length - 1;
        while (arr[j] <= arr[i]) j--;

        char temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;

        Arrays.sort(arr, i + 1, arr.length);
        return true;
    }
}

Code Explanation:

• This method finds the next lexicographically greater permutation.
• Useful when you want to generate all permutations in sorted order.

Output:

ABC
ACB
BAC
BCA
CAB
CBA

Now that you've learned how permutations work and how to implement them in Java, it's time to apply that knowledge to real-world challenges.

Challenging Permutation Problems to Sharpen Your Java Skills

To truly master the concept, you need to solve problems that introduce complexity, such as handling duplicates, generating permutations for integers, or working with subsets. These problems test your Java skills but also help you think algorithmically and write optimized, interview-ready code.

Here are some classic and advanced permutation problems that you can try implementing in Java to enhance your coding skills.

Example 1: Six people participate in a skit. In how many ways can the first and second prizes be awarded?

In this example, you have to determine how many ways you can award the first and second prizes to six people. You have to find the permutations of 6 people taken 2 at a time. You can use the permutation formula to solve the problem.

Here, n = 6 (number of people) and r = 2 (prizes to be awarded).

Sample Code:

public class PermutationExample1 {

    // Method to calculate permutations (nPr) of n items taken r at a time
    public static int permutation(int n, int r) {
        return factorial(n) / factorial(n - r);  // P(n, r) = n! / (n - r)!
    }

    // Method to calculate factorial of a number
    public static int factorial(int num) {
        int result = 1;
        for (int i = 1; i <= num; i++) {
            result *= i;
        }
        return result;
    }

    public static void main(String[] args) {
        int n = 6;  // Total number of participants
        int r = 2;  // Number of prizes to be awarded

        // Calculate and display the number of permutations (ways to award prizes)
        int result = permutation(n, r);
        System.out.println("Total ways to award first and second prize: " + result);
    }
}

Code Explanation:

The Example class calculates the number of permutations (nPr) of n items taken r at a time, which is often used to determine the number of ways to award prizes in a competition.

• Permutation Method:
  • The permutation(int n, int r) method calculates the number of permutations using the formula P(n, r) = n! / (n - r)!.
  • This formula gives the number of ways to choose r items from n items when the order of selection matters.
• Factorial Method:
  • The factorial(int num) method calculates the factorial of a given number num. The factorial is calculated by multiplying all integers from 1 to num (i.e., num! = num * (num - 1) * ... * 1).
• Main Execution:
  • In the main() method, n is set to 6 (total participants) and r is set to 2 (prizes to be awarded).
  • The permutation(n, r) method is called to calculate the number of ways to award the first and second prizes.
  • The result is printed, representing the total number of ways to award two prizes from six participants.

Output:

Total ways to award first and second prize: 30

Also Read: 50 Java Projects With Source Code in 2025: From Beginner to Advanced

Example 2: Find the permutation of a number n greater than the number itself.

In this example, let's assume you are given a number n (for example, 3), and you want to find the permutations of a number greater than n (for instance, 5). This means you have to calculate the permutations of 5 items taken 3 at a time.

Sample Code:

public class PermutationExample2 {

    // Method to calculate permutations (nPr)
    public static int permutation(int n, int r) {
        return factorial(n) / factorial(n - r);
    }

    // Method to calculate factorial
    public static int factorial(int num) {
        int result = 1;
        for (int i = 1; i <= num; i++) {
            result *= i;
        }
        return result;
    }

    public static void main(String[] args) {
        int n = 5;  // Total number of items
        int r = 3;  // Number of items to choose

        // Calculate and display the number of permutations
        int result = permutation(n, r);
        System.out.println("Total permutations of " + n + " items taken " + r + " at a time: " + result);
    }
}

Code Explanation:

The PermutationExample2 class calculates the number of permutations (nPr) of n items taken r at a time, which is useful for determining how many ways a subset of items can be chosen when the order matters.

• Permutation Method:
  • The permutation(int n, int r) method calculates the number of permutations using the formula P(n, r) = n! / (n - r)!.
  • This formula is used to find the number of ways to choose r items from n items where the order of selection is important.
• Factorial Method:
  • The factorial(int num) method calculates the factorial of a given number num. The factorial is calculated by multiplying all integers from 1 to num (i.e., num! = num * (num - 1) * ... * 1).
• Main Execution:
  • In the main() method, n is set to 5 (total items available) and r is set to 3 (number of items to be chosen).
  • The permutation(n, r) method is called to calculate the number of ways to select 3 items from 5, taking the order into account.
  • The result is printed, representing the total number of permutations for choosing 3 items from 5.

Output:

Total permutations of 5 items taken 3 at a time: 60

Also Read: Top 135+ Java Interview Questions You Should Know in 2025

How Can upGrad Help You Advance Your Career in Java Development?

Permutations in Java help you build logic that handles complex arrangements, whether you're solving algorithmic problems, generating combinations, or designing smarter systems. From recursive methods to iterative logic, understanding how permutations work is key to becoming a stronger Java programmer.

To build confidence, apply these concepts by solving problems and coding challenges. Platforms like LeetCode and CodeChef are great for testing your problem-solving skills in these areas.

Many learners struggle to apply concepts like permutations in real code. upGrad’s software development courses help you build strong Java skills through hands-on projects and expert guidance. Here are some additional courses that will boost your programming language skills.

• Learn Basic Python Programming
• JavaScript Basics from Scratch
• Professional Certificate Program in Data Science and AI
• Executive Diploma in Data Science & AI with IIIT-B

Feeling unsure about where to begin with your programming career? Connect with upGrad’s expert counselors or visit your nearest upGrad offline centre to explore a learning plan tailored to your goals. Transform your programming journey today with upGrad!

Boost your career with our popular Software Engineering courses, offering hands-on training and expert guidance to turn you into a skilled software developer.

Explore our Popular Software Engineering Courses

Master in-demand Software Development skills like coding, system design, DevOps, and agile methodologies to excel in today’s competitive tech industry.

In-Demand Software Development Skills

Stay informed with our widely-read Software Development articles, covering everything from coding techniques to the latest advancements in software engineering.

Read our Popular Articles related to Software

Reference:
https://www.netguru.com/blog/is-java-still-used-in-2025