Weird code with Java loop optimization at runtime

Gabriel.java

package com.com.com;

import java.util.HashMap;
import java.util.Map;

import org.apache.log4j.Logger;

public class Gabriel {
    private final static Logger LOG = Logger.getLogger(Gabriel.class);

    public Gabriel() {
        super();
    }

    public int main() {
        int i = 1111;

        for (; rules(i) != true && i < Integer.MAX_VALUE; i++) {
            //LOG.debug("Testing i: " + i);
        }

        System.out.println("The mystery number is: " + i);

        return i;
    }

    // Main function, checks the rules

    protected boolean rules(int nb) {
        String strNum = "" + nb;
        int size = strNum.length();
        int curNb = 9;
        Integer precNum = null;

        Map<Integer, Integer> integerMap = new HashMap<Integer, Integer>();

        int counter = 0;
        int tripleOdd = 0;
        int evenCounter = 0;
        int doubleEven = 0;
        int prodOdd = 1;
        int sum = 0;

        boolean rule1 = true;
        boolean rule3 = true;
        boolean rule4 = true;
        boolean multipleOf5 = false;

        for (int i = 0; i < size; i++) {
            curNb = Integer.valueOf("" + strNum.charAt(i));

            // rule 1 - Check if it is decreasing
            if (precNum != null && curNb > precNum) {
                rule1 = false;
            }

            // rule 3 - Specifies how many times the number is found
            if (integerMap.get(curNb) == null) {
                integerMap.put(curNb, 1);
            } else {
                rule3 = false;
                integerMap.put(curNb, integerMap.get(curNb) + 1);
            }

            if (curNb % 2 != 0) {
                // rule 2 - If odd number, we increase the counter
                counter++;

                // rule 4
                if (i == 3) {
                    rule4 = false;
                }

                // rule 6 - Check how many odd numbers are in a row
                if (tripleOdd > 2) {
                    tripleOdd++;
                } else {
                    tripleOdd = 0;
                }

                // rule 8 - If there are less then 3 even numbers in a row we
                // reset the counter
                if (doubleEven < 3) {
                    doubleEven = 0;
                }

                // rule 9
                prodOdd *= curNb;
            } else {
                // rule 8
                doubleEven++;
                // rule 2
                evenCounter++;
            }

            // rule 5
            if (curNb == 0 || curNb == 5) {
                multipleOf5 = true;
            }

            precNum = curNb;

            sum += curNb;
        }

        // Rules requiring a lower complexity first: 1, 2, 3, 4, 5, 6, 8

        if (!rule123(integerMap, rule1, counter, evenCounter, rule3)
                || !rule4568(integerMap, rule4, multipleOf5, tripleOdd, doubleEven)) {
            LOG.debug("1234568 Returning false");
            return false;
        }

        // Rules: 7, 9, 0

        if (!rule7(integerMap, curNb) || !rule9(integerMap, prodOdd) || !rule0(integerMap, sum)) {
            LOG.debug("790 Returning false");
            return false;
        }

        return true;
    }

    // Rules (1, 2, 3)

    private boolean rule123(Map<Integer, Integer> integerMap, boolean rule1, int counter,
            int evenCounter, boolean rule3) {
        if (integerMap.get(1) != null) {
            if (rule1 == false) {
                return false;
            }
        } else {
            if (rule1) {
                return false;
            }
        }

        if (integerMap.get(2) != null) {
            if (counter < 2) {
                return false;
            }
        } else {
            if (evenCounter >= 2) {
                return false;
            }
        }

        if (integerMap.get(3) != null) {
            if (!rule3) {
                return false;
            }
        } else {
            if (rule3) {
                return false;
            }
        }

        return true;
    }

    // Rules (4, 5, 6, 8)

    private boolean rule4568(Map<Integer, Integer> integerMap, boolean rule4, boolean multipleOf5,
            int tripleOdd, int doubleEven) {
        if (integerMap.get(4) != null) {
            if (!rule4) {
                return false;
            }
        } else {
            if (rule4) {
                return false;
            }
        }

        if (integerMap.get(5) != null) {
            if (multipleOf5) {
                return false;
            }
        } else {
            if (!multipleOf5) {
                return false;
            }
        }

        if (integerMap.get(6) != null) {
            if (tripleOdd < 3) {
                return false;
            }
        } else {
            if (tripleOdd > 2) {
                return false;
            }
        }

        if (integerMap.get(8) != null) {
            if (doubleEven > 2) {
                return false;
            }
        } else {
            if (doubleEven < 3) {
                return false;
            }
        }

        return true;
    }

    private boolean rule7(Map<Integer, Integer> integerMap, int nb) {
        boolean isNbPrime = isPrime(nb);
        if (integerMap.get(7) != null) {
            if (!isNbPrime) {
                return false;
            }
        } else {
            if (isNbPrime) {
                return false;
            }
        }

        return true;
    }

    private boolean rule9(Map<Integer, Integer> integerMap, int prodOdd) {
        double sqrt = Math.sqrt(prodOdd);
        double sqrtRound = (double) ((int) sqrt);

        if (integerMap.get(9) != null) {
            if (sqrt != sqrtRound) {
                return false;
            }
        } else {
            if (sqrt == sqrtRound) {
                return false;
            }
        }

        return true;
    }

    private boolean rule0(Map<Integer, Integer> integerMap, int sum) {
        boolean isSum = false;
        boolean isNotSum = false;
        for (Integer key : integerMap.keySet()) {
            // Sum of all the numbers - key
            int curSum = sum - key;

            // At least one number is equal to the sum of the others
            if (curSum == key) {
                isSum = true;
            }

            // At least one number is different from the sum of the others
            if (curSum != key) {
                isNotSum = true;
            }
        }

        if (integerMap.get(0) != null) {
            if (!isSum) {
                return false;
            }
        } else {
            if (!isNotSum) {
                return false;
            }
        }

        return true;
    }

    protected boolean isPrime(int n) {
        // check if n is a multiple of 2
        if (n % 2 == 0) {
            return false;
        }
        // if not, then just check the odds
        for (int i = 3; i * i <= n; i += 2) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }
}

GabrielTest.java

package com.com.com;

import java.util.HashSet;
import java.util.Set;

import org.apache.log4j.Logger;

import junit.framework.TestCase;

public class GabrielTest extends TestCase {

    private final static Logger LOG = Logger.getLogger(GabrielTest.class);

    public void testPrime() {
        Gabriel obj = new Gabriel();

        int[] primes = new int[] {
                7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723,
                7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829,
                7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919
        };
        Set<Integer> primeSet = new HashSet<Integer>();
        for (int i = 0; i < primes.length; i++) {
            primeSet.add(Integer.valueOf(primes[i]));
        }
        
        for (int j = 7649; j < 7920; j++) {
            boolean isPrime = obj.isPrime(j);
            LOG.debug("" + j + ": " + (isPrime ? "prime" : "not prime"));
            assertEquals(primeSet.contains(Integer.valueOf(j)), isPrime);
        }
    }
    
    public void testBizarres() {
        Gabriel obj = new Gabriel();
        
        boolean result16698 = obj.rules(16698);
        assertEquals(false, result16698);

        int i = 16698;
        assertTrue(obj.rules(i) != true && i < Integer.MAX_VALUE);
    }

    public void testMain() {
        Gabriel obj = new Gabriel();
        long begin = System.currentTimeMillis();
        int result = obj.main();
        long end = System.currentTimeMillis();

        LOG.debug("Integer.MAX_VALUE :" + Integer.MAX_VALUE);
        LOG.debug("Found result " + result + " in " + (end - begin) + "ms");

        assertEquals(942210, result);
    }
}