int number;
while(true) {
  try {
    number = Integer.parseInt(bufferedReader.readLine());
    break;
  } catch(NumberFormatException e) { }
}

>          if (Integer.isInteger(pageNum)) {
>           sb.append("&com.kashrus.report.pagenum=");
>             sb.append(pageNum);
>         }
> 

    try {
      sb.append("&pagenum="+ String.valueOf(Integer.parseInt(pageNum)));
    } catch(NumberFormatException e) {
        //log problem here
    }

   //Horrible abuse of exceptions. Don't ever do this!
   try {
       int i=0;
       while (true)
           a[i++].f();
   } catch (ArrayIndexOutOfBoundsException e){
   }

if(Integer.isInteger(someObject){
> // do something 
> }

int num;
try{
  num = Integer.parseInt(someString);
}catch(NumberFormatException e){
  num = 0;
}

int num;
if(Integer.isInteger(someString)) num = Integer.parseInt(someString);
else num = 0;

int num = (Integer.isInteger(someString))?Integer.parseInt(someString):0;

    public static int parseInt(String s, int radix)
		throws NumberFormatException
    {
        if (s == null) {
            throw new NumberFormatException("null");
        }

	if (radix < Character.MIN_RADIX) {
	    throw new NumberFormatException("radix " + radix +
					    " less than Character.MIN_RADIX");
	}

	if (radix > Character.MAX_RADIX) {
	    throw new NumberFormatException("radix " + radix +
					    " greater than Character.MAX_RADIX");
	}

	int result = 0;
	boolean negative = false;
	int i = 0, max = s.length();
	int limit;
	int multmin;
	int digit;

	if (max > 0) {
	    if (s.charAt(0) == '-') {
		negative = true;
		limit = Integer.MIN_VALUE;
		i++;
	    } else {
		limit = -Integer.MAX_VALUE;
	    }
	    multmin = limit / radix;
	    if (i < max) {
		digit = Character.digit(s.charAt(i++),radix);
		if (digit < 0) {
		    throw NumberFormatException.forInputString(s);
		} else {
		    result = -digit;
		}
	    }
	    while (i < max) {
		// 1) {
		return result;
	    } else {	/* Only got "-" */
		throw NumberFormatException.forInputString(s);
	    }
	} else {
	    return -result;
	}
    }

public boolean isInteger(String s)
{
  if (s==null) return false;
  int n = s.length(); /* to avoid calling s.length() repeatedly */
  if (n == 0 || n > 11 /* 11 is  "-2147483648".length() */) return false;
  
  boolean positiveNumber = false, negativeNumber = false;
 
  /* to avoid calling matches() twice: */
  if (s.substring(1).matches("\\d+"))
  {
    /* to avoid calling charAt(0) thrice */
    char first = s.charAt(0);
    if (first == '-')
    {
      negativeNumber = true;
    }
    else if ( first == '+' || (Character.isDigit(first) && n <= 10) )
    {
      positiveNumber = true;
    }
  
  if(positiveNumber)
  {
    if (n < 10) return true;
    /* == only do actual parsing in the other cases == */
  }
 
  if (negativeNumber)
  {
    if(n < 11) return true;
    /* == only do actual parsing in the other cases == */
  }
  return false;
}

     String s = "Start";
     for (Iterator i = collection.iterator(); i.hasNext() ; ) {
          s += i.next();
     }

public class PossibleInteger extends Number {
   private PossibleInteger() { } // empty private constructor
  public PossibleInteger(String integer) throws NumberformatException {
    init(integer);
    if(!isInteger())
        throw new NumberFormatException(bla); 
  }
  private void init(String val) {
    // the logic...
  }
  public boolean isInteger() {
    return isAnInteger;
  }
  public int intValue() {
    return intValue;
  }
  public static PossibleInteger fetchInteger(String val) {
    PossibleInteger pi = new PossibleInteger();
    pi.init(val);
    return pi;
  }
}

public class Test{
    public static void main(String args[])    {
        System.out.println("Ignore the first few timings.");
        System.out.println("They may include Hotspot compilation time.");
        System.out.println("I hope you are running me with \"java -server\"!");
        for (int n = 0; n < 10; n++)	    doit();
    }
 
    static void doit()    {
        int loops = 100000;
        long start = System.currentTimeMillis();
        for (int n = 0; n < loops; n++) {
            checkInt("123");
            checkInt("123aa");
        }
        long end = System.currentTimeMillis();
        System.out.println(start);
        System.out.println(end);
        long checks_per_second = loops * 1000 / (end - start) / 2;
        System.out.println("time " + (end - start) + " ms, " +
                checks_per_second + " checks/s");
    }
   
    static boolean checkInt(String num){
        char[] chars = num.toCharArray();
        int size = chars.length;
        for (int x = 0; x < size; x++){
            if ( (chars[x] > 57 || chars[x] < 48) || (x != 1 && chars[x] == '-') ) return false;
        }
        double d = Double.parseDouble(num);
        if(d > Integer.MAX_VALUE || d < Integer.MIN_VALUE) return false;
        return true;
    }
 
   /*
    static boolean checkInt(String num){
        try{Integer.parseInt(num);} catch(Exception e){return false;}
        return true;
    }
     */
}