Problem StatementYou are given a function,static String FindMax(int[] arr){}The function accepts an integer array 'arr' of length 'size' as its argument. Implement the function to find and return the maximum number that can be formed by any permutation or arrangement of all the digits obtained from all the numbers present in the array. You have to return the number formed as a string.Note: You may need to rearrange the digits of the numbers to form the maximum number.Example:Input:34 79 58 64Output:98765443Explanation:All digits obtained from all the numbers of array are 3, 4, 7, 9, 5, 8, 6, 4. Maximum number obtained after rearranging all these digit gives 98765443. Thus, output is 98765443.The custom input format for the above case:434 79 58 64(The first line represents the 'size', the second line represents the elements of the array 'arr')Sample input21 90 23Sample Output932210The custom input format for the above case:321 90 23(The first line represents the 'size', the second line represents the elements of the array 'arr')Instructions :This is a template based question, DO NOT write the "main" function.Your code is judged by an automated system, do not write any additional welcome/greeting messages."Save and Test" only checks for basic test cases, more rigorous cases will be used to judge your code while scoring.Additional score will be given for writing optimized code both in terms of memory and execution time.Now let's start coding :Language:Read-only code below . . .1class SolutionClass {2    public static void main(String[] args) throws java.lang.Exception {3        //Input read from STDIN4        String result = FindMax(arr);5        //Value in result printed to STDOUT6   }7}8​Write your code below . . .9static String FindMax(int[] arr) throws java.lang.Exception10{11    /* Write your code here. */12}13​

Here is the Java solution for the problem:

import java.util.*;

class SolutionClass {
    static String FindMax(int[] arr) throws java.lang.Exception {
        // Create a list to store all digits
        List<Integer> digits = new ArrayList<>();

        // Iterate over the array and add all digits to the list
        for (int num : arr) {
            while (num > 0) {
                digits.add(num % 10);
                num /= 10;
            }
        }

        // Sort the list in reverse order
        Collections.sort(digits, Collections.reverseOrder());

        // Convert the list to a string
        StringBuilder sb = new StringBuilder();
        for (int digit : digits) {
            sb.append(digit);
        }

        return sb.toString();
    }

    public static void main(String[] args) throws java.lang.Exception {
        int[] arr = {34, 79, 58, 64};
        String result = FindMax(arr);
        System.out.println(result);
    }
}

This solution works by first extracting all digits from the numbers in the array and storing them in a list. Then it sorts the list in reverse order to get the maximum possible number. Finally, it converts the list to a string and returns it.

The problem is asking to implement a function that takes an array of integers as input and returns the maximum number that can be formed by rearranging all the digits obtained from all the numbers in the array.

Here is a step-by-step solution in Java:

1. First, we need to convert all the integers in the array to a string and concatenate them together. We can do this by iterating over the array and using the Integer.toString() method.

2. Next, we need to convert this concatenated string into a character array so that we can sort the digits. We can do this using the toCharArray() method.

3. We then sort the character array in descending order to get the maximum possible number. We can use the Arrays.sort() method to sort the array and then reverse it using Collections.reverseOrder().

4. Finally, we convert the sorted character array back into a string and return it.

Here is the Java code that implements these steps:

import java.util.Arrays;
import java.util.Collections;

static String FindMax(int[] arr) throws java.lang.Exception {
    // Convert all integers in the array to a string and concatenate them
    StringBuilder sb = new StringBuilder();
    for (int num : arr) {
        sb.append(Integer.toString(num));
    }

    // Convert the concatenated string into a character array
    Character[] chars = sb.toString().chars().mapToObj(c -> (char)c).toArray(Character[]::new);

    // Sort the character array in descending order
    Arrays.sort(chars, Collections.reverseOrder());

    // Convert the sorted character array back into a string
    StringBuilder result = new StringBuilder(chars.length);
    for (Character c : chars) {
        result.append(c.charValue());
    }

    return result.toString();
}

This function will return the maximum number that can be formed by any permutation or arrangement of all the digits obtained from all the numbers present in the array.