Distinct permutations of a number

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

class GFG {

    // Utility function to print all distinct permutations
    static void uniquePermutationsUtil(List<String> permute)
    {
        List<String> p = new ArrayList<>();

        // Traverse the list permute[]
        for (String i : permute) {
            // Convert this permutation to list
            p.add(i);
        }

        // Stores unique permutations
        List<String> newList = new ArrayList<>();

        // Traverse list p[]
        for (String i : p) {
            // If permutation is not in newlist
            if (!newList.contains(i)) {
                newList.add(i);
            }
        }

        // Initialize empty list
        List<Integer> permuteList = new ArrayList<>();

        // Traverse the list newList[]
        for (String i : newList) {
            // Convert string to integer
            int s = Integer.parseInt(i);

            // Append the unique permutation to permuteList
            permuteList.add(s);
        }

        // Print all distinct permutations
        for (int i : permuteList) {
            System.out.print(i + " ");
        }
    }

    // Function to print all distinct permutations
    static void uniquePermutations(int N)
    {
        // Stores equivalent string representation of N
        String num = Integer.toString(N);
        List<Character> lis = new ArrayList<>();
        for (char c : num.toCharArray()) {
            lis.add(c);
        }
        Collections.sort(lis);
        List<String> permute = new ArrayList<>();
        do {
            char[] charArray = new char[lis.size()];
            for (int i = 0; i < lis.size(); i++) {
                charArray[i] = lis.get(i);
            }
            permute.add(new String(charArray));
        } while (nextPermutation(lis));

        // Print unique permutations
        uniquePermutationsUtil(permute);
    }

    // Function to find the next permutation
    static boolean nextPermutation(List<Character> array)
    {
        int i = array.size() - 1;
        while (i > 0 && array.get(i - 1) >= array.get(i)) {
            i--;
        }

        if (i <= 0) {
            return false;
        }

        int j = array.size() - 1;
        while (array.get(j) <= array.get(i - 1)) {
            j--;
        }

        // Swap the characters at positions i-1 and j
        char temp = array.get(i - 1);
        array.set(i - 1, array.get(j));
        array.set(j, temp);

        // Reverse the suffix starting at position i
        j = array.size() - 1;
        while (i < j) {
            temp = array.get(i);
            array.set(i, array.get(j));
            array.set(j, temp);
            i++;
            j--;
        }

        return true;
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Given value of N
        int N = 7668;

        // Function call to find all distinct permutations
        // of N
        uniquePermutations(N);
    }
}