Algorithm writing tips?

The first four primes for which any two primes concatenate to produce another prime is 3, 7, 109, 673. For example, if you concatenate 7 and 109, you'll get the prime 7109, and concatenating 109 and 7 yields the prime 1097. The sum of these four primes is 792, and is the lowest sum for the set of four primes with this property.

Find a set of five primes for which any two primes concatenate to produce another prime, and has the lowest sum of such sets of five primes.

--You may use any programming language.
--The script must be written in a fashion that there are no other assumptions made about the nature of the problem without reasonable proof. For example, you may not assume that the highest prime number is below 1,000,000.
--The script execution time preferably produces the answer in under 1 minute for modestly powered computers.
--You may use Google or any other resource to help you. (so long as you don't cheat and look up the answer!)

This is a math problem meant for programming practice. The main problem I'm having is getting the execution time to below 1 minute, but I'm not sure how I can make my algorithm more efficient. Heck, it actually stops when it finds the first set of 5 primes, and it doesn't really check whether it has the lowest sum of all sets of 5 primes. About the only thing I can think of right now is avoiding redundant checks when trying to find larger sets of primes. If anyone has any crazy tips that I don't know about, please feel free to share =)

 Java algorithm

Code:

import java.util.*;

public class Project60 {

    //Find a set of five primes for which any two primes concatenate to produce another
    //prime.
    
    //Hashtable of primes contains keys whose values are determined to be prime.
    private static Hashtable<Long, Boolean> primesTable = new Hashtable<Long, Boolean>();

    //List of primes, whose values are in order.
    private static ArrayList<Long> primesList = new ArrayList<Long>();

    //List of two primes that concatenate to produce primes.
    private static ArrayList<long[]> primesListTwo = new ArrayList<long[]>();

    //List of three primes that concatenate to produce primes.
    private static ArrayList<long[]> primesListThree = new ArrayList<long[]>();

    //List of four primes that concatenate to produce primes.
    private static ArrayList<long[]> primesListFour = new ArrayList<long[]>();
    

    //Algorithm starts by determining the new prime number to compare to existing known sets
    //of primes, if determined.  Each set of primes is checked for compatibility every
    //cycle.  It should be noted that the prime numbers 2 and 5 are excluded since
    //they will NEVER form prime numbers if concatenated last.
    public static void main(String[] args){

        primesList.add(3L);
        long nextPrime = 5;    //the new prime number that gets compared with every cycle
        boolean isCompatible = true;
        double time = System.currentTimeMillis();

        while(true){
            nextPrime += 2;
            while(!isPrime(nextPrime)) nextPrime += 2;
            primesList.add(nextPrime);
            System.out.println(nextPrime);

            //find the next quintuplet(s) of compatible primes.
            for(int i = 0; i < primesListFour.size(); i++){
                long[] list = primesListFour.get(i);
                for(int j = 0; j < list.length && isCompatible; j++){
                    String num1 = "" + list[j] + nextPrime;
                    String num2 = "" + nextPrime + list[j];
                    long n1 = Long.parseLong(num1);
                    long n2 = Long.parseLong(num2);
                    if((primesTable.contains(n1) || isPrime(n1)) &&
                    (primesTable.contains(n2) || isPrime(n2))){
                        primesTable.put(n1, true);
                        primesTable.put(n2, true);
                    }
                    else isCompatible = false;
                }
                if(isCompatible){
                    time = System.currentTimeMillis() - time;
                    time /= 60000;
                    System.out.println("Time: " + time + " minutes.");
                    int sum = 0;
                    for(int j = 0; j < 4; j++){
                        sum += list[j];
                        System.out.println(list[j]);
                    }
                    sum += nextPrime;
                    System.out.println(nextPrime);
                    System.out.println(sum);
                    return;    //end of script
                }
                isCompatible = true;
            }

            //find the next quadruplet(s) of compatible primes.
            for(int i = 0; i < primesListThree.size(); i++){
                long[] list3 = primesListThree.get(i);
                for(int j = 0; j < list3.length && isCompatible; j++){
                    String num1 = "" + list3[j] + nextPrime;
                    String num2 = "" + nextPrime + list3[j];
                    long n1 = Long.parseLong(num1);
                    long n2 = Long.parseLong(num2);
                    if((primesTable.contains(n1) || isPrime(n1)) &&
                    (primesTable.contains(n2) || isPrime(n2))){
                        primesTable.put(n1, true);
                        primesTable.put(n2, true);
                    }
                    else isCompatible = false;
                }
                if(isCompatible){
                    long[] list4 = new long[4];
                    System.arraycopy(list3, 0, list4, 0, 3);
                    list4[3] = nextPrime;
                    primesListFour.add(list4);
                }
                isCompatible = true;
            }

            isCompatible = true;
            //find the next triplet(s) of compatible primes.
            for(int i = 0; i < primesListTwo.size(); i++){
                long[] list2 = primesListTwo.get(i);
                for(int j = 0; j < list2.length && isCompatible; j++){
                    String num1 = "" + list2[j] + nextPrime;
                    String num2 = "" + nextPrime + list2[j];
                    long n1 = Long.parseLong(num1);
                    long n2 = Long.parseLong(num2);
                    if((primesTable.contains(n1) || isPrime(n1)) &&
                    (primesTable.contains(n2) || isPrime(n2))){
                        primesTable.put(n1, true);
                        primesTable.put(n2, true);
                    }
                    else isCompatible = false;
                }
                if(isCompatible){
                    long[] list3 = new long[3];
                    System.arraycopy(list2, 0, list3, 0, 2);
                    list3[2] = nextPrime;
                    primesListThree.add(list3);
                }
                isCompatible = true;
            }

            //find the next pair(s) of compatible primes.
            for(int i = 0; i < primesList.size() - 1; i++){
                String num1 = "" + primesList.get(i) + nextPrime;
                String num2 = "" + nextPrime + primesList.get(i);
                long n1 = Long.parseLong(num1);
                long n2 = Long.parseLong(num2);
                if((primesTable.contains(n1) || isPrime(n1)) &&
                (primesTable.contains(n2) || isPrime(n2))){
                    primesTable.put(n1, true);
                    primesTable.put(n2, true);
                    long[] list = {primesList.get(i), nextPrime};
                    primesListTwo.add(list);
                }
            }
        }// end while(true) loop
    }//end main
    


    //isPrime method utilizes Eratosthenes' Sieve in order to determine prime numbers.
    private static boolean isPrime(long n){
        if(n < 2) return false;
        for(int i = 2; i <= Math.sqrt(n); i++){
            if(n % i == 0) return false;
        }
        return true;
    }
    
}//end class

Btw, I know what the answer is, and it's not as simple as the example made it look. The second number, in ascending order, is 5197 o.O