private static List<Integer> primes = new ArrayList<>();

    public static int[] sameFactRev(int nMax) {
        primes = getPrimes(nMax-1);
        List<Integer> sameFact = IntStream.range(1089, nMax).
                filter(n -> !isPalindrome(n)).
                filter(App::sameFactors).
                boxed().
                collect(Collectors.toList());
        return sameFact.stream().mapToInt(i -> i).toArray();
    }

    private static boolean sameFactors(int i) {
        Set<Integer> factors = getPrimeFactors(i);
        Set<Integer> reversedFactors = getPrimeFactors(reverseInt(i));
        return factors.equals(reversedFactors);
    }

    private static int reverseInt(int n) {
        StringBuilder number = new StringBuilder(Integer.toString(n));
        number.reverse();
        return Integer.parseInt(number.toString());
    }

    private static Set<Integer> getPrimeFactors(int n) {
        Set<Integer> factors = new TreeSet<>();
        int primeId = 0;
        while (primeId != primes.size() && n >= primes.get(primeId)) {
            if (n % primes.get(primeId) == 0) {
                n = n / primes.get(primeId);
                factors.add(primes.get(primeId));
            } else {
                primeId++;
            }
        }
        return factors;
    }

    private static boolean isPalindrome(int n) {
        StringBuilder number = new StringBuilder(Integer.toString(n));
        return n == Integer.parseInt(number.reverse().toString());
    }

    private static List<Integer> getPrimes(int n) {
        int length = String.valueOf(n).length();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < length; i++) {
            sb.append(9);
        }
        return IntStream.rangeClosed(2, Integer.parseInt(sb.toString()))
                .filter(App::isPrime)
                .boxed()
                .collect(Collectors.toList());
    }

    private static boolean isPrime(int n) {
        OptionalInt s = IntStream.range(3, n)
                .filter(x -> n % x == 0)
                .findFirst();
        return !s.isPresent();
    }