Scores 44% - 100% correctness, 0% performance. Optimisations were done concerning boundaries and time complexity, not sure how to improve now

Codility: semi primes

// you can also use imports, for example:

import java.util.*;
import java.util.stream.Collectors;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    //codility semi primes
    public static void main(String[] args) {
        Solution app = new Solution();
        int[] test = app.solution(26, new int[]{1, 4, 16}, new int[]{26, 10, 20});
        int debug = 1;
    }

    public int[] solution(int N, int[] P, int[] Q) {
        int[] arrayToReturn = new int[P.length];

        //compute all primes below largest number, just once
        Set<Integer> primesBelowLargest = computePrimesBelow(N);
        int absoluteSmallest = computeSmallest(P, Q);

        Set<Integer> semiPrimesBelowLargest = computeSemiPrimesBelow(primesBelowLargest, N, absoluteSmallest);

        for (int i = 0; i < P.length; i++) {
            int largest = Math.max(P[i], Q[i]);
            int smallest = Math.min(P[i], Q[i]);
            arrayToReturn[i] = semiPrimesBelowLargest.stream()
                    .filter(j -> j >= smallest && j <= largest)
                    .collect(Collectors.toSet()).size();
        }

        return arrayToReturn;
    }

    private int computeSmallest(int[] p, int[] q) {
        int smallest = Integer.MAX_VALUE;
        for (int i = 0; i < p.length; i++) {
            if (p[i] < smallest) {
                smallest = p[i];
            }
        }
        for (int i = 0; i < q.length; i++) {
            if (q[i] < smallest) {
                smallest = q[i];
            }
        }
        return smallest;
    }

    private Set<Integer> computeSemiPrimesBelow(Set<Integer> primesBelowNumber, int max, int min) {
        Set<Integer> semiPrimes = new HashSet<>();
        Object[] primesArray = primesBelowNumber.toArray();

        for (int i = 0; i < primesArray.length; i++) {
            for (int j = i; j < primesArray.length; j++) {
                int product = (int) primesArray[i] * (int) primesArray[j];
                if (product <= max && product >= min) {
                    semiPrimes.add(product);
                }
            }
        }
        return semiPrimes;
    }

    private Set<Integer> computePrimesBelow(int number) {
        Set<Integer> sieve = computeSieve(number);
        Set<Integer> sieveCopy = new HashSet<>(sieve);

        for (Integer i : sieveCopy) {
            int temp = i;
            while (i + temp <= number) {
                temp += i;
                sieve.remove(temp);
            }
        }
        return sieve;
    }

    private Set<Integer> computeSieve(int max) {
        Set<Integer> sieve = new HashSet<>();
        for (int i = 2; i <= max; i++) {
            sieve.add(i);
        }
        return sieve;
    }
}