Why does an increment by positive one return a negative? (Java)

I have a program that lists prime numbers. I started with a positive integer and it returned an array(it's supposed to do this) that contained negative numbers(not supposed to do this). The problem is there's no decrement operator anywhere in the code, only increment operators and modulus functions. Here is the whole code and output for your reference, completely commented for easy understanding:

package calculations;

import java.util.ArrayList;

public class PrimeNumbers {
 public static void main(String[] args) {
 	
 	 //Declaring variables to be used...
 	 ArrayList<Integer> listOfPrimes = new ArrayList<Integer>();
 	 listOfPrimes.add(2);
	 int numOfPrimesToList = 10;
	 int possiblePrimeCounter  = 0;
	 
	 /* We start testing at the number 2 and increment until 
	  * the list of primes we have listed is equal to the
	  * number of primes want to list. 
	  */
	 for(int atNum = 2; listOfPrimes.size() < numOfPrimesToList; atNum++) {
		
		 /* While the index of the number to divide from 
		  * is less than the length of our list, we do 
		  * the following:
		  */
		 for(int intIndexToCheck = 0; intIndexToCheck < listOfPrimes.size(); intIndexToCheck++) {
			
			 /* If the modulus of the number we are testing 
			  * and the one are dividing by is greater than
			  * zero, we increment its possibility of being
			  * a prime by one. 
			  */
			 if(atNum % listOfPrimes.get(intIndexToCheck) < 0) {
				 possiblePrimeCounter++;
				
				 /* If its chance of being a prime is 1 (that is, the
				  * times it has been given a chance is equal to the
				  * total number of possible chances it is given), then
				  * we can consider it to be a prime.
				  */
				 if(possiblePrimeCounter == listOfPrimes.size()) {
					 //We then add this number to the list of primes.
					 listOfPrimes.add(atNum);
					
					 possiblePrimeCounter = 0;
				 }
			 }
		 }
	 }
	 //Finally, we print out the list of primes.
	 System.out.println(listOfPrimes);
 }
}

Returns:

[2, -2147483647, -2147483645, -2147483644, -2147483643, -2147483641, -2147483640, -2147483639, -2147483638, -2147483637]

What is happening is called Integer Overflow.
When int becomes the maximum value (Integer.MAX_VALUE), if you try to increment, it will go back to its smallest value (Integer.MIN_VALUE) which is the number you are getting.

The problem is That your code does not do what your comment says it does. You have

         /* If the modulus of the number we are testing 
          * and the one are dividing by is greater than
          * zero, we increment its possibility of being
          * a prime by one. 
          */
         if(atNum % listOfPrimes.get(intIndexToCheck) < 0) {

Where it says that you check for greater than zero, but in reality it checks for less than zero. Change the line to actually do what the comment says

         if(atNum % listOfPrimes.get(intIndexToCheck) > 0) {

Since you are testing for remainder of less than zero which never happens for positive numbers you keep increasing your number until it overflows and becomes negative at which time the remainder does become less than zero.

For your follow up question, if your number isn't a prime, the possiblePrimeCounter isn't reset, so the possiblePrimeCounter carries on for testing the next number. Also, after adding a prime number you do yet another test and check if it is divisible by it selves (since you just increased the size of the list).

A simple fix would be

     possiblePrimeCounter = 0; // Need to reset before trying each new number
     for(int intIndexToCheck = 0; intIndexToCheck < listOfPrimes.size(); intIndexToCheck++) {

or make the loop somewhat efficient, as soon as we know the number isn't a prime there is no need to continue testing.

     possiblePrimeCounter = 0;

     for(int intIndexToCheck = 0; intIndexToCheck < listOfPrimes.size(); intIndexToCheck++) {
         if(atNum % listOfPrimes.get(intIndexToCheck) !=0) {
             possiblePrimeCounter++;
             if(possiblePrimeCounter == listOfPrimes.size()) {
                 //We then add this number to the list of primes.
                 listOfPrimes.add(atNum);
                
                 possiblePrimeCounter = 0;
             }
         } else {
             break; // Not prime
         }
     }