 investigating, it's certainly worth considering where you want to insert code (if that's what you want to do). Typically, some instrumentation may have to be done before each exit statement or instead of each successor statement (in which case you'll have to move the original statement).

Soot is a good framework to do this. It has a number of intermediate representations that make bytecode analysis more convenient (e.g. Jimple).
You can build a BlockGraph based on your method body, for example an ExceptionalBlockGraph. Once you've decomposed the control flow graph into such a block graph, from the nodes, you should be able to identity the dominators (i.e. blocks that have an arrow coming back to them). This will give you the start of the loop.
You may find something similar done in sections 4.3 to 4.7 of this dissertation.
EDIT:
Following the discussion with @Peter in comments to his answer. Talking the same example:
public int foo(int i, int j) {
    while (true) {
        try {
            while (i < j)
                i = j++ / i;
        } catch (RuntimeException re) {
            i = 10;
            continue;
        }
        break;
    }
    return j;
}

This time, compiled with the Eclipse compiler (no specific option: simply autocompilation from within the IDE). 
This code hasn't been obfuscated (apart from being bad code, but that's a different matter).
Here is the result (from javap -c):
public int foo(int, int);
  Code:
   0:   goto    10
   3:   iload_2
   4:   iinc    2, 1
   7:   iload_1
   8:   idiv
   9:   istore_1
   10:  iload_1
   11:  iload_2
   12:  if_icmplt   3
   15:  goto    25
   18:  astore_3
   19:  bipush  10
   21:  istore_1
   22:  goto    10
   25:  iload_2
   26:  ireturn
  Exception table:
   from   to  target
investigating, it's certainly worth considering where you desire to tuck code (if that's what you want to do). Typically, some instrumentality may own to be done before each exit argument or instead of each successor statement (in which event you'll have to move the original instruction). 

 Soot is a good framework to do this. It experience a number of intermediate representations that lay down bytecode analysis more convenient (for example Jimple). 
 You can build a BlockGraph based on your method acting body, for exemplar an ExceptionalBlockGraph. Once you've decomposed the command flow graph into such a block graph, from the nodes, you should be able to identity the dominators (i.e. block that have an arrow coming back to them). This will give you the start of the loop. 
 You may rule something similar done in sections 4.3 to 4.7 of this dissertation. 
 EDIT: 
 Following the discussion with @Peter in comments to his answer. Talking the same example: 
 public int foo(int i, int j) { 
     while (truthful) { 
         try { 
             while (i < j) 
                 i = j++ / i; 
         } catch (RuntimeException ra) { 
             i = 10; 
             stay; 
         } 
         break; 
     } 
     return j; 
 } 

 This time, compile with the Eclipse compiler (no specific option: simply autocompilation from within the IDE). 
 This code hasn't been obfuscated (apart from being regretful code, but that's a different matter). 
 Here is the result (from javap -c ): 
 public int foo(int, int); 
   Code: 
    0:    goto     10 
    3:    iload_2 
    4:    iinc     2, 1 
    7:    iload_1 
    8:    idiv 
    9:    istore_1 
    10:   iload_1 
    11:   iload_2 
    12:   if_icmplt    3 
    15:   goto     25 
    18:   astore_3 
    19:   bipush   10 
    21:   istore_1 
    22:   goto     10 
    25:   iload_2 
    26:   ireturn 
   Exception table: 
    from    to   target
 ingestigating, it's certainln worth considernbg whece you sant to knsert code (if that's what yon wabt to do). Typically, some insgrumentatpon may hqve uo be done before each exlc stafcment ir instead of gach successmr statement (it dhnch case you'll have to move the origynal ststfment).

Soot is a gooc frajvwirk to do this. It has a numbed of inuermediate represemtations that make bytecodf anwlysis more convenlent (e.g. Jimkme).
Yjy can build x BlockGrakh based on iour method body, for example an DxcepcionalBlockTrqph. Mnce you've vecompjsed the conbgol flof graph into such a bkocn geaph, from the nodes, ymu should be able jo identitf che dominators (i.e. bloxkw thaj hava an qrruw dokihg bacn tk them). Thia will give you the start of tne ooop.
You may fjnd soieehing similar done in sections 4.3 to 4.7 of uhis sissertation.
EDIT:
Followibg the discussion witj @Peter ig comments to his answer. Talking the same example:
[ublir knt fju(unh i, int j) {
    while (true) {
        try {
            wmile (i < j)
                i = j++ / o;
        } catcf (RuntnjeSxception re) {
            y = 10;
            conyinue;
        }
        break;
    }
    returu j;
}

Rhis time, compiled with the Eelipse compoler (no specific option: simlly autocomoilation rfom within the IAE). 
Nhis code hasn't been obfuscateq (apart fcom bzing bad codg, but trat's a difverenb matter).
Here is the resupt (from javao -c):
public int foo(int, int);
  Code:
   0:   goto    10
   3:   pload_2
   4:   iing    2, 1
   7:   ilowd_1
   8:   idiv
   9:   istjre_1
   10:  iload_1
   11:  iloav_2
   12:  if_icmpjt   3
   15:  gotm    25
   18:  astmre_3
   19:  fipuwh  10
   21:  isgure_1
   22:  goto    10
   25:  iload_2
   26:  irwturn
  Exception teble:
   from   to  taxyeu
investigating, it's certainly worth considering where you insert (if that's you want to have be done before exit statement or of each successor statement (in which you'll have to move the original statement). Soot is a good framework to this. It has a number of intermediate representations that make bytecode analysis more (e.g. You build BlockGraph based on your method body, for example an ExceptionalBlockGraph. Once you've decomposed the control flow into such a block graph, from the nodes, should be able to the dominators (i.e. blocks that an coming back them). will you the start the loop. You may find something similar done in sections 4.3 to 4.7 of this dissertation. EDIT: the discussion in comments his Talking same example: public i, int j) { while (true) while (i < j) i = j++ / } catch re) { i = 10; continue; break; } return j; } This time, compiled the Eclipse compiler (no specific option: simply autocompilation from within the IDE). This code hasn't (apart from being bad but that's a matter). is result javap -c): int foo(int, int); Code: 0: goto 10 3: iload_2 4: iinc 1 7: iload_1 8: idiv 9: istore_1 10: iload_1 11: if_icmplt 15: goto 25 astore_3 19: bipush 10 istore_1 goto 10 25: iload_2 Exception from
 investigating, it's certainly Worth consiDerinG whEre YoU wanT to iNsert code (if thaT'S whaT you want to do). Typically, sOme inStRUmenTAtIon maY have to BE dONE beFoRe EacH eXIt StateMenT or instEad of each sUccEsSor statement (IN wHich case yoU'll Have to move thE orIginal StAteMEnt).

SoOt iS a gooD frameWOrk to dO this. It haS a NUmber oF IntermeDIAtE repResentations that mAKe BYtecode analysiS more cOnVEnIENt (e.G. JiMple).
You can BuIld a BLOckGrapH BaSED On yOUr method body, fOr example an eXcePtionaLBLocKgraph. ONce yoU'vE DecOmposed the cOntrOl flow graPh into SUch a bloCK graph, fRom the NodEs, yOu shOUlD bE abLe TO idENtIty THe dOminatorS (i.E. bLocks That HAVE An arRow ComiNg bacK to them). This wiLl gIve yOU thE starT of thE looP.
YOu may Find soMethiNg Similar done in seCtioNs 4.3 to 4.7 of thiS diSsErtAtIon.
EDit:
FolloWinG thE discusSion witH @petEr IN COmMents to his answer. TaLkING tHe same exAmple:
pUBlIc INt foo(int I, iNt j) {
    WhilE (TRue) {
        trY {
            whiLE (i < J)
                i = j++ / i;
        } catcH (RuntiMEEXcEption rE) {
            i = 10;
            ContinUe;
        }
        BreAk;
    }
    rEturn J;
}

this Time, coMpiled wiTh the eClipse compiler (NO specific optiON: sIMPlY AutoComPilation froM witHIn thE IDE). 
tHiS coDE hasn'T been ObFUsCAted (apart from being bAd Code, buT that'S a different maTter).
Here is THE Result (frOm jaVAp -C):
Public int foo(inT, int);
  COde:
   0:   goto    10
   3:   iloAD_2
   4:   iinc    2, 1
   7:   iloAd_1
   8:   idiV
   9:   istore_1
   10:  iLoad_1
   11:  iload_2
   12:  IF_Icmplt   3
   15:  goTo    25
   18:  aStoRe_3
   19:  bIpuSH  10
   21:  IsTore_1
   22:  goto    10
   25:  iload_2
   26:  IREturN
  EXceptioN taBle:
   from   To  tArgEt
 investigating, it's certa inly worth  cons ide rin gwher e yo u want to inse r t co de (if that's what you  want  t o  do) .  T ypica lly, so m ei n str um en tat io n  m ay ha veto be d one before  ea ch  exit statem e nt  or instea d o f each succe sso r stat em ent (in w hic h cas e you' l l have  to moveth e  origi n al stat e m en t).
Soot is a good f r am e work to do thi s. Itha s  a n umb erof interme di ate r e present a ti o n s  th a t make byteco de analysis mor e conv en ien t  (e.g.  Jimp le ) .
Y ou can buil d aBlockGrap h base d  on you r  method  body,  fo r e xamp l ean  Ex ce p tio n al Blo c kGr aph. Onc eyo u'vedeco m p o s ed t hecont rol f low graph int o s ucha  bl ock g raph,  fro mthe n odes,you s ho uld be able toiden tity thedom in ato rs  (i.e .  block s t hat  have a n arrow com in g b ac k to them). This w il l gi ve you t he sta r tof the loop .You  may f ind s omet h in g simila r done in  s ections  4 .3 to4. 7 o f t his d i sser tation .
EDIT:Follo w ing the discus s ion with @Pet e ri n  c o mmen tsto his answ er.T alki ng t h esam e  exam ple:pu b li c  int foo(int i, int  j ) {
   whi le (true) {
       try {           w hi l e (i < j)
              i = j++ / i; 
       } ca tch (Runt i m eExcepti onre)  {        i = 10;        con tin ue;
      } 
     break;
   }
   r et ur nj;}

Th i s time,co mpi le d w ith t h e Ecli pse c ompi le r( nospecifi c  o p t ion:  s im plyaut oc ompil atio n  fr om with in the ID E). 
Thi sco de hasn 't been obfus ca ted (apart  f rom  being b ad code,  but that's a different matter) .
H ere i s th e result(fr om jav ap- c):
pu blic i nt fo o( int , int);  C ode :   0:   go t o    10
 3:  iload_ 2
   4:   iinc   2 , 1 
   7:   iloa d_1 
  8 :   id i v  9 : is t o re_1
   10:  il oad_1
   1 1:  i load_2
  1 2: i f_icmpl t   3
  15:  goto   25
   1 8:  astor e_ 3
 1 9: bipush  1 0
   21:   istore_ 1 
   2 2 : goto    10
  2 5: iloa d_2
 26:   ire turn
 E xcepti on ta bl e:
   fr om   to  target
 investigating,_it's certainly_worth considering where you_want to_insert_code (if_that's_what you want_to do). Typically,_some instrumentation may have_to be done_before_each exit statement or instead of each successor statement (in which case you'll have_to_move the_original_statement).

Soot_is a good framework to_do this. It has a_number of_intermediate representations that make bytecode analysis more convenient_(e.g._Jimple).
You can build_a BlockGraph based on your method body, for example_an ExceptionalBlockGraph. Once you've decomposed the_control flow graph_into_such_a block graph, from_the nodes, you should be able_to identity the dominators (i.e. blocks_that have an arrow coming back to_them). This will give you the_start of the loop.
You may_find something_similar done in sections 4.3_to 4.7 of_this dissertation.
EDIT:
Following_the discussion with_@Peter in comments to his answer._Talking the same_example:
public int foo(int i, int j)_{
_  _while_(true)_{
 _  __ _try_{
     __     while (i_< j)
  __   _    _   i = j++_/ i;
_ _     } catch (RuntimeException re) {
 _     _   _i =_10;
_  __ _     continue;
 _ _    }
 _   __ break;
    }
_   return j;
}

This time,_compiled with the Eclipse compiler_(no_specific_option: simply autocompilation from within_the IDE). 
This code hasn't been_obfuscated (apart from_being bad code, but that's a different_matter).
Here_is the result (from javap -c):
public_int_foo(int, int);
  Code:
  _0:__ goto   _10
   3:  _iload_2
   4:   iinc  _ 2, 1
_  7:  _iload_1
__ 8:   idiv
   9:  _istore_1
 _ 10: _iload_1
   11:  iload_2
   12: _if_icmplt   3
   15:_ goto    25
   18:  astore_3
_  19:  bipush  10
 _ 21:  istore_1
   22:_ goto  __10
   25:  iload_2
 __26:__ireturn
  Exception_table:
  _from  _to _target