title: Stack Overflow error with ArrayLists
body: <p>I'm trying to write some code to look through an image file for groups of pixels that are the same color.</p>
  
  <p>The way I do this is I iterate through the image (in the form of a 1d integer array with the color's hash code) by pixel to find a pixel of the color that I'm searching for. Once one is found, I do a dfs to find adjacent pixels of the same color and add them to a new object I called a Blob. I use a boolean array to keep track of which pixels have already been added so I don't add identical blobs. </p>
  
  <p>I'm using ArrayList for each Blob object to keep track of the pixel numbers. And then I use another ArrayList of Blobs to store the different groups.</p>
  
  <p>When I try to run this on a simple example, a picture with the top half white and the bottom half bottom, I get a stack overflow error when I try to use a picture that's too large. Specifically, when I try to do this with a 320x240 image, I get the stackoverflow once 2752 pixels are added to the blob.</p>
  
  <p>Am I just not using the right data structure for what I want to do? I read that ArrayLists can store Integer.maxValue objects in them.</p>
  
  <p>My code is pasted below. Any help is greatly appreciated.</p>
  
  <pre><code>//blobfind tests code to find similar pixels of a minimum size and groups them together for analysis later  
  //purpose is to identify color coded objects through the webcam  
  
  //util for ArrayList  
  import java.util.*;  
  import java.awt.Color;  
  import java.io.*;  
  
  public class Blobfind2 {  
  
    //width and height of image in pixels  
    private int width;  
    private int height;  
    //hash code for the color being searched for  
    private int colorCode;  
    //minimum blob size to be added  
    private int minPixels;  
    //image in form of array of hashcodes for each pixel  
    private int[] img;  
    //keeping track of which pixels have been added to a blob  
    private boolean[] added;  
    //keeping track of which pixels have been visited when looking for a new blob  
    private boolean[] visited;  
  
    //debugging variable  
    private int count;  
  
    public Blobfind2(int inwidth, int inheight, int inCCode, int inminPixels, int[] inimage)   {
      width = inwidth;  
      height = inheight;  
      colorCode = inCCode;  
      minPixels = inminPixels;  
      img = inimage;  
      count = 0;  
    }    
  
    //takes hashCodeof color, minimum pixel number, and an image in the form of integer array  
    public ArrayList findColor() {  
      //makes an arraylist of "blobs"  
      ArrayList bloblist = new ArrayList();  
      //keep track of which pixels have been added to a blob  
      boolean[] added = new boolean[width * height];  
      //checks through each pixel  
      for (int i = 0; i &lt; img.length; i++) {  
        //if it matches and is not part of a blob, we run dfs to collect all the pixels in   that blob
        if ((img[i] == colorCode) &amp;&amp; (added[i] == false)) {  
          //visited keeps track of which pixels in the blob have been visited  
          //refreshed each time a new blob is made  
          boolean[] visited = new boolean[width*height];  
          Blob currBlob = new Blob();  
          dfs(img, currBlob, i, Color.white.hashCode(), added, visited);  
          //adds the blob to the bloblist if it is of a certain size  
          if (currBlob.mass() &gt;= minPixels) {  
            bloblist.add(currBlob);                          
          }  
        }  
      }  
      return bloblist;  
    }  
  
    //recursive algorithm to find other members of a blob  
    public void dfs (int[] img, Blob blob, int currPixel, int colorCode, boolean[] added,    boolean[] visited) {  
      //System.out.print(currPixel + " - " + count + " ");   
      count++;  
      //check current pixel, this only happens on the first pixel  
      if (visited[currPixel] == false) {  
        blob.add(img[currPixel]);  
        added[currPixel] = true;  
        visited[currPixel] = true;  
      }  
      //checks down pixel  
      if ((currPixel + width &lt; height*width) &amp;&amp; (visited[currPixel + width] == false)) {  
        if (img[currPixel + width] == colorCode) {  
          blob.add(img[currPixel + width]);  
          currPixel = currPixel + width;  
          added[currPixel] = true;  
          visited[currPixel] = true;  
          dfs(img, blob, currPixel, colorCode, added, visited);  
        }  
      }  
      //checks up pixel  
      if ((currPixel - width &gt; 0) &amp;&amp; (visited[currPixel - width] == false)) {  
        if (img[currPixel - width] == colorCode) {  
          blob.add(img[currPixel - width]);  
          currPixel = currPixel - width;  
          added[currPixel] = true;  
          visited[currPixel] = true;  
          dfs (img, blob, currPixel, colorCode, added, visited);  
        }  
      }  
      //checks right pixel  
      if ((currPixel + 1 &lt; width * height) &amp;&amp; (visited[currPixel + 1] == false) &amp;&amp; (((currPixel + 1) % width) != 0)) {  
        if (img[currPixel + 1] == colorCode) {  
          blob.add(img[currPixel + 1]);  
          currPixel = currPixel + 1;  
          added[currPixel] = true;  
          visited[currPixel] = true;  
          dfs(img, blob, currPixel, colorCode, added, visited);  
        }  
      }  
      //checks left pixel  
      if ((currPixel - 1 &gt; 0) &amp;&amp; (visited[currPixel - 1] == false) &amp;&amp; (((currPixel - 1) % width) != width - 1)) {  
        if (img[currPixel - 1] == colorCode) {  
          blob.add(img[currPixel - 1]);  
          currPixel = currPixel - 1;  
          added[currPixel] = true;  
          visited[currPixel] = true;  
          dfs(img, blob, currPixel, colorCode, added, visited);  
        }  
      }  
      return;  
    }  
  
    //test case, makes a new image thats half black and half white  
    //should only return one blob of size width*height/2  
    public static void main(String[] args) {  
     int width = 320;  
     int height = 240;  
     //builds the image  
     int[] img = new int[width * height];  
     for (int i = 0; i &lt; img.length; i++) {  
       if (i &lt; img.length/4) {  
         img[i] = Color.white.hashCode();  
       } else {  
         img[i] = Color.black.hashCode();  
       }  
     }  
  
     //runs blobfind  
     Blobfind2 bf = new Blobfind2(width, height, Color.white.hashCode(), 1, img);  
     ArrayList bloblist = bf.findColor();  
     System.out.println(bloblist.size());  
     //need to typecast things coming out of arraylists  
     Blob firstblob = (Blob)bloblist.get(0);  
     System.out.println(firstblob.mass());  
    }  
  
   private class Blob {  
     private ArrayList pixels = new ArrayList();  
     private Blob() {  
     }  
     private int mass() {  
       return pixels.size();  
     }  
     private void add(int i) {  
       pixels.add(i);  
     }  
     private ArrayList getBlob() {  
       return pixels;  
     }  
   }  
  
  }   
  </code></pre>