Find the maximum number formed by swapping digits of same parity

// Java code to implement the approach
import java.io.*;
import java.util.*;

class GFG {
  static String swap(String str, int i, int j)
  {
    StringBuilder sb = new StringBuilder(str);
    sb.setCharAt(i, str.charAt(j));
    sb.setCharAt(j, str.charAt(i));
    return sb.toString();
  }

  // Function to maximize the number
  public static int maximizedNumber(int num)
  {
    // String will be used to represent the
    // number in string
    String s = Integer.toString(num);

    // Traversing the string
    for (int i = 0; i < s.length(); i++) {
      int maxi = s.charAt(i) - '0';
      int idx = i;

      // Check ith digit with all
      // the remaining unoperated
      // string to maximize the string
      for (int j = i + 1; j < s.length(); j++) {

        // If both the ith and
        // jth digit is odd
        if (maxi % 2 == 0
            && (s.charAt(j) - '0') % 2 == 0) {

          // If the jth digit is
          // greater than the ith digit
          if (s.charAt(j) - '0' > maxi) {
            maxi = s.charAt(j) - '0';
            idx = j;
          }
        }

        // If both ith and
        // jth digit is even
        else if (maxi % 2 == 1
                 && (s.charAt(j) - '0') % 2 == 1) {

          // If the jth digit is
          // greater than ith digit.
          if (s.charAt(j) - '0' > maxi) {
            maxi = s.charAt(j) - '0';
            idx = j;
          }
        }
      }

      // Swap the largest digit to the right
      // of ith digit with ith digit
      s = swap(s, i, idx);
    }

    // Convert string into integer
    return Integer.parseInt(s);
  }

  public static void main(String[] args)
  {
    int N = 6587;

    // Function call
    System.out.print(maximizedNumber(N));
  }
}

// This code is contributed by Rohit Pradhan

// Java code to implement the approach
import java.util.*;

// Helper class implementing Comparator interface
// to compare characters of a string in non
// increasing order
class charSort implements Comparator<Character> {

  @Override public int compare(Character c1, Character c2)
  {
    // Ignoring case
    return Character.compare(Character.toLowerCase(c2),
                             Character.toLowerCase(c1));
  }
};

class GFG {

  // Function to maximize the number
  static int maximizedNumber(int num)
  {
    // Store all even digits
    ArrayList<Character> oddDigit
      = new ArrayList<Character>();

    // Store all odd digits
    ArrayList<Character> evenDigit
      = new ArrayList<Character>();

    // Convert given number into char array
    char[] s = (String.valueOf(num)).toCharArray();

    for (int i = 0; i < s.length; i++) {
      // Check if digit is even or odd
      if ((s[i] - '0') % 2 == 0) {
        evenDigit.add(s[i]);
      }
      else {
        oddDigit.add(s[i]);
      }
    }

    // Sort oddDigit and evenDigit string
    // in non-increasing order.
    oddDigit.sort(new charSort());
    evenDigit.sort(new charSort());

    int i1 = 0, j1 = 0;

    for (int i = 0; i < s.length; i++) {

      // If the current digit is even
      // then replace it with evenDigit[i1]
      if ((s[i] - '0') % 2 == 0) {
        s[i] = evenDigit.get(i1);
        i1++;
      }

      // If the current digit is odd then
      // replace it with the oddDigit[j1]
      else {
        s[i] = oddDigit.get(j1);
        j1++;
      }
    }

    return Integer.parseInt(new String(s));
  }

  // Driver Code
  public static void main(String[] args)
  {
    int N = 6587;

    // Function call
    System.out.println(maximizedNumber(N));
  }
}

// This code is contributed by phasing17