创建递归 static 方法来查找数组中素数的乘积

Question

The number 9 keeps returning true from my Prime method despite if(number % j == 0) returning true when 9/3 with no remainders but 0. Would someone like to help me with this? I'm also trying to not use for loops. It's for a homework assignment.

Edit: I've attempted the answer below but I still get the same issue using an if statement.

public class test {
    private static int product = 1;
    private static int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    private static boolean allowmultiply;
    public static void main(String args[]) {
        System.out.println("Product: " + findproduct(array, 0));
        }

    public static int findproduct(int[] list, int i) {
        int[] temp = list;
         if(i <= temp.length-1) {
            allowmultiply = Prime(temp[i], 2);
            if(allowmultiply != false) {
                product = product * temp[i];
            } 
            i++; 
            return findproduct(temp, i);
        }
        return product;
    }
    public static boolean Prime(int number, int j) {
        if(j <= number/j) {
            if(number % j == 0) {
                return false;
            }
            Prime(number, j+1);
        }
        return true;
    }
}

NEW CODE: Thanks to WJS for the help!

public class ProductPrimeNumber {
        private static int product = 1;
        private static boolean allowmultiply;
        private static int checker = 0;
        private static int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    public static void main(String args[]) {
        System.out.println("Product: " + findproduct(array, 0));
        }
    public static int findproduct(int[] list, int i) {
        int[] array = list;
        if(i <= array.length-1) {
            allowmultiply = isPrime(array[i], 2);
            if(allowmultiply != false) {
                product = product * array[i];
            } 
            checker = 0;
            i++;
            return findproduct(array , i);
        }
        return product;
    }
    public static boolean isPrime(int number, int i) {
        if(i < number) {
            if(number % i == 0 && i != number) {
                checker++;
            }
            isPrime(number, i+1);
        }
        if(checker > 0) {
            return false;
        }
        return true;
    }
}

Answer 1

This may help. Forget about primes for the moment as that is an entirely separate issue. Consider the product of even numbers. The method is not as compact as it could be to aid clarity.

static Predicate<Integer> isEven = a -> a != 0 && a % 2 == 0;

int[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int prod = findProduct(data, 0);
System.out.println("prod = " + prod);

prints

prod = 3840

• define a lambda to test for even parity and >.= 0. This isn't required but aids explanation.
• then call the method with the array and 0 to start.
• continue call the method until i == v.length-1 (the last element).
• then "unwind" the recursive calls by first testing the even parity of v[i]
• if true, return prod * v[i] .
• otherwise, just return prod .

public static int findProduct(int[] v, int i) {
    int prod = 1;
    if (i < v.length-1) { 
       prod = findProduct(v, i+1);
    }
    if (isEven.test(v[i])) {
        return prod * v[i];
    }
    return prod;
}

The only difference between this and the prime solution is what your testing for. So replace isEven with isPrime . Then you just need to focus on your isPrime code.

The more compact version of findProduct is here.

• simply test for even parity
• multiply by the return product of either v[i] or 1
• when i == i.length , return 1 to start the unwinding process

public static int prodEven(int[] v, int i) {
    if (i < v.length) { 
        return (isEven.test(v[i]) ? v[i] : 1) * prodEven(v, i+1);
    }
    return 1;
}

Answer 2

To do via recursion, you can start with a index ( say i that points to the starting of the array ).

The base condition: when i reaches the length of the array, then return 1;

work to be done: in case the number is prime, multiply it with product and the return value from the calls of further functions and in case it is not, multiply the product with the return values from the calls of further functions.

public class PrimeProduct {
    static int product = 1;

    public static void main(String[] args) {
        int list[] = { 3, 5, 9, 11 }; // 11*5*3
        int res = findProduct(list, 0);
        System.out.println(res);
    }

    public static int findProduct(int[] list, int i) {
        if (i == list.length) {
            return 1;
        }
        return isPrime(list[i], 2) ? product * list[i] * findProduct(list, i + 1) : product * findProduct(list, i + 1);

    }

    private static boolean isPrime(int num, int i) {
        if (i * i > num) {
            return true;
        }

        return (num % i != 0) ? isPrime(num, i + 1) : false;

    }

}

and the output is

165