>  believe that this is good code and would like to not have to change what I currently have too greatly because I understand it well, but am open to new methods to accomplish what I am trying to achieve.

While I totally understand that sentiment, it's not a good sentiment to hold, generally, when working with code.  I think that to be a successful programmer, you must always be open to the idea that you may need to scrap what you've got and start over.

Your issue with the food is probably best dealt with in the following manner:

* store the food explicitly within the code.  If you only ever want to have one piece of food, you can just make global "foodX" and "foodY" variables in your program to hold the present location of the food.  Right now your makeFood() function just draws the food and then forgets about it.  Also keep a global "foodPresent" boolean flag that says whether or not the food is on the screen.  You'll set it to true when you create the food, and false when the snake eats it.
* when the snake moves, check to see whether the location of the snake's head is the same as the location of the food.  "if(x[0] == foodX && y[0] == foodY)"
* in your draw() function, you'll draw the snake but also draw the food if the foodPresent variable is true.

As far as making the snake grow, your issue right now is that you're tracking the segments of the snake with a pair of correlated int arrays.  Arrays are great for lots of things, but have some down-sides for applications like this: once the array is full, you can't stuff any more items in there.  Also, you need to explicitly track how many of the items in the array you're actually using.

Much better is the ArrayList type, which can be accessed by numeric index just like an array (although in Java's implementation, you say "list.get(index)" rather than "list[index]"), but which also tracks the length for you and takes care of all the nasty details of making the array longer if you ever need it.  You just use the add() method to add new things to the end of the list.

Other suggestions: don't put the keypress checking in the draw() routine.  Use the keyboard event handlers (keyPressed(), keyReleased(), keyTyped()) instead.  Within those, you'll do whatever processing you need to do to determine what direction the snake is going.  Store that direction in another global variable so your code more clearly expresses what you're trying to do: one part of the code figures out the direction, another part of the code uses that direction to do something with the snake.

As I said:

> Also keep a global "foodPresent" boolean flag that says whether or not the food is on the screen.

When the snake eats the food, you grow the snake and set foodPresent = false.  In your draw() routine, you only draw the food if the foodPresent flag is true:

if(foodPresent)
{
 ellipse(foodX, foodY, 3, 3); // or whatever.
}

The basic idea is this: you want to create simple boolean flags that track important pieces of high-level information about your game.  Such as "is there food on the screen right now, or not?"  Then it becomes very easy, anywhere else, to simply check the flags and do the right thing.  This is a general strategy that works well for any program that has more than one "independent" entity it needs to track.  In your case, the independent entities are the snake and the food.  The behavior of the snake is independent of the food.  The snake does its thing, as directed by the player.  The food's behavior (boring though it is), is independent of the snake.  Food appears, and then just sits there.

The snake has its own pieces of high level information associated with it: how long is it?  Where is the snake's head?  What direction is it going?  In these cases, the data isn't a simple boolean yes/no value, but the concept is the same:  Taken all together, they represent the state of the snake at any point in time.  You should track them with appropriate variables, as such.