Exception in thread "main" java.lang.StackOverflowError

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
 
        ArrayList<Integer> num = new ArrayList<Integer>();
        TaskQueue tq = new TaskQueue();
        MyTask t = new MyTask(1);
 
        long start, end;
        start = System.currentTimeMillis();
        t.findPrime(num, 0, 9);
        tq.push(t);
    }
}

import java.util.*;
 
 
public class MyTask<E> {
 
    private int start;
    private int end;
    private final int size;
    private ArrayList<Integer> answer;
    private ArrayList<Integer> num;
 
    public MyTask(int size) {
        this.size = size;
    }
 
    /*    public int[] findPrime(int[] nums, int start, int end) {
            int[] result = new int[size];
            for (int k = 0; k < size; k++) {
                for (int j = 2; j < nums[start]; j++) {
                    while(start != end + 1) {
                        if (nums[start] % j == 0) {
                            System.out.println("Vse");
                            break;
                        }
                        result[end - start] = nums[k];
                    }
                    start++;
                }
            }
            return result;
        } */
    public ArrayList<Integer> findPrime(ArrayList<Integer> num, int start, int end) {
        int m = 0;
        int a = 0;
        Integer[] nums = new Integer[10];
        Random r = new Random();
        for (int i = 0; i < nums.length; i++) {
            nums[i] = r.nextInt(24);
        }
        Integer[] res = new Integer[nums.length];
        System.arraycopy(nums, 0, res, 0, nums.length);
        if (start == 0 && end == nums.length - 1) {
            for (int k = start; k < end + 1; k++) {
                for (int j = 2; j < (nums[k] / 2) + 1; j++) {
                    if (nums[k] % j == 0) {
                        res[a] = m;
                        break;
                    }
                }
                a++;
            }
        }
        if (start > 0 || end < nums.length) {
            for (int k = start; k < end + 1; k++) {
                for (int j = 2; j < (nums[k] / 2) + 1; j++) {
                    for (int z = 0; z < start; z++) {
                        res[z] = m;
                        if (nums[k] % j == 0) {
                            res[k] = m;
                        }
                    }
                    for (int q = end + 1; q < nums.length; q++) {
                        res[q] = m;
                        if (nums[k] % j == 0) {
                            res[k] = m;
                        }
                    }
                }
                a++;
            }
        }
 
        System.out.println(Arrays.toString(nums));
        ArrayList<Integer> answer = new ArrayList<>(Arrays.asList(res));
        answer.removeIf(nSet -> nSet == 0);
        this.answer = answer;
        System.out.println(this.answer);
        return this.answer;
    }
 
    public ArrayList<Integer> getPrime() {
        return this.answer;
    }
 
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(this.num);
        return sb.toString();
    }
 
}

import java.util.ArrayList;
import java.util.LinkedList;
 
public class TaskQueue extends LinkedList<MyTask> {
    private int index = -1;
 
    public TaskQueue() {
        super();
    }
 
    public MyTask pop() {
        if(index < this.size() && !this.isEmpty()) {
            index++;
            return this.get(index);
        } else {
            return null;
        }
    }
 
    public void push(MyTask t) {
        this.push(t);
    }
 
    public void showResult() {
        while(!this.isEmpty()) {
            this.pollFirst();
        }
    }
 
    public boolean isEmpty() {
        if(this.size() != 0) {
            return true;
        } else {
            return false;
        }
    }
}

public class MyThread implements Runnable {
    private TaskQueue tq;
    private MyTask t;
 
    public MyThread(TaskQueue tq) {
        this.tq = tq;
        t = null;
    }
 
    @Override
    public void run() {
        while(!tq.isEmpty()) {
            synchronized (tq) {
                if(!tq.isEmpty()) {
                    t = tq.pop();
                }
            }
         //   if((t != null) && (t.primeFound())) {
      //          tq.countPrime();
                t = null;
            }
        }
    }
//}

public void push(MyTask t) {
        this.push(t);
    }