Array size limitations... and prime number programs.

Question

What are they? I am an ameteur programmer who wrote an extremely efficient prime finding program, if i do say so myself. The program doesnt find high primes, just prime numbers from 1-1,000,000,000 so far. Thats one version, the next version i use is faster, but because it uses an ArrayList, it can only do the primes 1-10,000,000. I am trying to work the programs up to primes with 50 or more digits, but ArrayList runs out of space, Integer is too small, I dont quite know how to switch all my code to be compatable with BigIntegers, and I cannot find a limit to arrays. I guess that I could find big primes if a) Integer was bigger, b)I tried, but what i wanted to do, because the second program is way more effecient, is to use an array to store primes instead of an ArrayList. The only problem? Arrays cannot be appended, so I need to know the limit in size for an array... So far, from my tests, I have found the limit to be somewhere around, 15,380,277. The only problem with this is that every time i compile, i can use a different number. So I would like it if a) somone could tell me the limit to an array's size, b) ideas for programs that can find primes with 50 or more digits, c) Down below is the code, could someone tell me how to convert it to BigIntegers?
  private void primeFinder1root(int beg, int end){
    int tmp = 0;
    int counter = 0;
    int counter2 = 2;
    boolean flag;
    for(int n = 3; n < end; n+=2){
      if(n%5!=0){
        flag = true;
        for(int d = 3; d <= Math.sqrt(n) && flag; d+=2){
          counter++;
          if(n%d == 0)
            flag = false;
        if(flag){
          System.out.println(n);
          counter2++;
          tmp = n;
          if(counter2%100000 == 0)
            System.out.println(n);
    System.out.println();
    System.out.println("The program looped " + counter + " times. There were " + counter2 + " primes found. "
                         + tmp + " was the last prime found.");
  }That is the first progam that does not use an ArrayList, but is still extremely effecient, it only looped 1,744,118,556 times to find the primes 1-100,000,000 which seems like a lot, but it truely isn't. I realize that by using counters and printing, I am slowing the program down immensly, but i am fine with that.
  public void primeFinder(){
    boolean flag;
    int tmp = 0;
    int tmp2 = 0;
    int counter = 0;
    primes.add(2);
    for(int n = 3; n < end; n+=2){
      if(n%5!=0){
        flag = true;
        for(int i = 0; i < primes.size()/2 && ((Integer)primes.get(i)).intValue() <= Math.sqrt(n) && flag; i++){
          tmp = ((Integer)primes.get(i)).intValue();
          if(n%tmp == 0)
            flag = false;
          counter ++;
        if(flag && n!=1){
          System.out.println(n);
          primes.add(n);
          tmp2 = n;
          if(primes.size() % 100000 == 0)
            System.out.println(n);
    primes.add(0, 1);
    System.out.println(counter + " " + primes.size() + " " + tmp2);
  }This is the code that stores all the primes it finds in an ArrayList, and then compares all numbers to the ArrayList of primes. This is extremely more effecient than the first, looping only 278,097, 308 times to find the primes 1-10,000,000 (the other looped 868,772,491 times). I used 10,000,000 as my example because this program cannot go to 100,000,000 because there are 5,761,455 primes and the ArrayList can only hold ~4,000,000 objects. Because of this ~4,000,000 object limitation on the ArrayList I have set my sites on the Array. This is the reason why I want to know the limitations of an Array if you could please tell me. If you could also, I would like help making my code compatable with BigIntegers as well.
Well, sorry for the very long post, but thank you if you answer it and took the time to read it.
Dumber_Child

Answer 1

I too was in the quest to develop the most efficient prime number code few years ago when I was a student.
Here is a more fine tuned version for your code
   public static long findPrimes(int max, ArrayList out){
      long count=0;
      FastList primes = new FastList((int)Math.sqrt(max));
      primes.add(2);
      for (int i=3; i<=max; i+=2)
         int al_size = primes.size();
         double sqrt = Math.sqrt(i);
         boolean prime_flag =true;
         boolean loop_flag = prime_flag;
         for (int j=0; j<al_size && loop_flag; j++)
            int val = primes.get(j);
            if (i%val == 0)
               loop_flag = prime_flag = false;
            else if (val > sqrt)
               loop_flag = false;
            count++;
         if (prime_flag)
            primes.add(i);
      primes.addToArrayList(out);
      return count;
Following a data structure to store the prime numbers while processing
Since this holds first number of primes in an array instead of in an ArrayList
the get will work much faster and for those elements the casting is not required
   static class FastList
      ArrayList list = new ArrayList();
      int cache[];
      int pointer = 0;
      int fastAreaSize;
      public FastList(int fastAreaSize){
         cache = new int[fastAreaSize];
         this.fastAreaSize = fastAreaSize;
      public void add(int i){
         if (pointer < fastAreaSize)
            cache[pointer] = i;
         list.add(new Integer(i));
         pointer++;
      public int size(){
         return pointer;
      public int get(int i){
         if (i<fastAreaSize)
            return cache;
else
return((Integer)list.get(i)).intValue();
public void addToArrayList(ArrayList al){
for (int i=0; i<pointer; i++)
if (i<fastAreaSize)
al.add(new Integer(cache[i]));
else
al.add(list.get(i));
When running in my pc
above code detected primes within range 0-10000000 in 281809517 iterations within 6.718secs
while your original code did the same in 278097308 iterations within 13.687 secs.
By the way i removed the check for '5' thats why my code does more iterations.
Notice that I have relocated code like Math.sqrt and ((Integer).....).intValue() to reduce the re calculating the same thing. That saved a lot of time.