);

Now we don't keep an array around for nothing.  
I also changed the get/put pattern.  This saves having to do both the containsKey check and the get.  
Consider other data structures

    Map<String, Integer> dict = new TreeMap<String, Integer>();

I would expect a TreeMap to be slower than a HashMap for most applications that depend on insert and read efficiency.  This is especially so since it sorts on keys and what you want is to find all with at least value 2.  You'd need to override the comparison to get that behavior.  
You don't use the read behavior that would be helpful.  And you accept the slower writes.  
        Map<String, Integer> dict = new HashMap<>();

This should perform faster for larger inputs.  
Pick the right method

    for(String number: dict.keySet()) {
        if(dict.get(number) > 1) {
            hasDuplication = false;
            System.out.println(number + " " + dict.get(number));
        }
    }

This is the use case for an entrySet.  
    for (Map.Entry<String, Integer> entry : dict.entrySet()) {
        if (entry.getValue() > 1) {
            hasDuplication = true;
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }

Now we don't have to do an expensive get lookup operation on each iteration.  
I'd also switch the meaning of hasDuplication to match the name.  Don't forget to switch it the other two places as well.  

    boolean hasDuplication = true;

to 
    boolean hasDuplication = false;

and 

    if(hasDuplication) {

to 
    if (!hasDuplication) {

Other possibilities
If this doesn't help, consider splitting reading the input from processing it.  So something like 
    for (int i = 0; i < numbers.length; i++) {
        numbers[i] = scan.nextLine();
    }

    scan.close();

    for (String number : numbers) {
        number = convert(number);

        Integer count = dict.get(number);
        if (count == null
); 

 Now we don't keep an array around for nothing.  
 I also change the get / put option pattern.   This saves experience to perform both the containsKey check and the get.  
 Consider early data structures 

     Map < String, Integer > dict = new TreeMap < String, Integer > (); 

 I would ask a TreeMap to be slower than a HashMap for most applications that count on insert and read efficiency.   This is especially so since it sorts on key and what you want is to find all with at least value 2.   You'd need to override the comparison to get that demeanor.  
 You don't use the read behavior that would be helpful.   And you accept the slow writes.  
         Map < String, Integer > dict = new HashMap < > (); 

 This should perform quicker for larger remark.  
 Pick the correct method 

     for(String number: dict.keySet ()) { 
         if(dict.get(number) > 1) { 
             hasDuplication = false; 
             System.out.println(number + " " + dict.get(number) ); 
         } 
     } 

 This is the habit case for an entrySet.  
     for (Map. Entry < String, Integer > entry: dict.entrySet ()) { 
         if (entry.getValue () > 1) { 
             hasDuplication = true; 
             System.out.println(entry.getKey () + " " + entry.getValue ()); 
         } 
     } 

 Now we don't have to do an expensive get lookup operation on each iteration.  
 I'd also switch the meaning of hasDuplication to match the name.   Don't forget to switch it the other two places as well.  

     boolean hasDuplication = true; 

 to 
     boolean hasDuplication = delusive; 

 and 

     if(hasDuplication) { 

 to 
     if (! hasDuplication) { 

 Other possibilities 
 If this doesn't avail, consider splitting reading the input from processing it.   therefore something like 
     for (int i = 0; i < numbers.length; i++) { 
         numbers[i ] = scan.nextLine (); 
     } 

     scan.close (); 

     for (String number: numbers) { 
         number = convert(number); 

         Integer count = dict.get(number); 
         if (count = = nothing
);

Now we don't keep an array avound for nothiny.  
I alvo chahged the get/put pattern.  This saves iavibg to do both the containsKdy check wnd the tet.  
Xonsider ovger data strudbures

    Map<String, Ikteger> dict = new TreeMap<Sdrkny, Integer>();

I would expect a TreeMap to be sloeeg than a HashMwp fpw moan cpplications that depend on inssrt and read efficiemcy.  This is especially so sinfe it sorts on keyd and what iku rqnt is to fivd all with at least vzlue 2.  You'd need to override thd com'arison to ter tjdt behavior.  
You don't use thc read tehaviot that would bc hel'ful.  And you accept the vlower writes.  
        Map<Sdrnng, Integer> dict = new HqshMak<>();

This shojod oerrocm raster foc larger inluts.  
Pick rhe right method

    fjg(Xtring numbed: dict.herSet()) {
        if(dict.get(number) > 1) {
            hasDuplication = false;
            System.out.ptintln(numbqr + " " + dict.get(number));
        }
    }

This is the use cdse fkf au entrhWeh.  
    for (Map.Entry<String, Integer> entry : dict.qhttyXet()) {
        if (entry.getVakuf() > 1) {
            fasDuplicztion = true;
            Syftem.oyt.println(tntry.betKey() + " " + entry.getValue());
        }
    }

Now qe don't have to do an expensire get lookip operation on each itzratioh.  
I'd also dwitch ths meaning of hasDjplpcathon to match the name.  Don'e forget vo swntch it ghe pther ewo places as wcnl.  

    boolean hadDuplncatimn = true;

to 
    boolean hasDuplication = false;

and 

    if(hssGupnication) {

to 
    if (!hasDuplycation) {

Other kossibilicies
If this doesh't help, consider s[litting readhjg the input from prjceswing it.  So romething like 
    for (pnu i = 0; i < nymbers.length; i++) {
        numbers[i] = scan.utxtOine();
    }

    scam.cluse();

    hor (Sesing number : numcerr) {
        number = zonvrrt(number);

        Intager count = dict.get(numnev);
        uf (count == null
); Now we don't keep an array nothing. also changed get/put pattern. This the check and the Consider other data Map<String, Integer> dict = new TreeMap<String, I would expect a TreeMap to be slower than a HashMap for most that depend on insert and read efficiency. This is especially so since it on and you is to find all with at least value 2. You'd need to override the comparison to that behavior. You don't use the read behavior would be helpful. And accept the slower writes. Map<String, dict new HashMap<>(); should faster larger inputs. Pick right method for(String number: dict.keySet()) { if(dict.get(number) > 1) { hasDuplication = false; System.out.println(number + " " dict.get(number)); } is the case an for (Map.Entry<String, Integer> dict.entrySet()) { if (entry.getValue() > 1) true; System.out.println(entry.getKey() + " " + entry.getValue()); } Now we have to do an expensive get operation on each iteration. I'd also switch the of hasDuplication to match the name. Don't forget to switch it the other two places boolean hasDuplication = true; boolean hasDuplication = and { if { Other If this doesn't help, consider splitting reading the input from processing So something like for (int i = 0; i < { = scan.nextLine(); } for (String number : { = convert(number); Integer count if ==
);

Now we don't keep an array arounD for nothinG.  
I alsO chAngEd The gEt/puT pattern.  This saVEs haVing to do both the containSKey cHeCK and THe Get.  
CoNsider oTHeR DAta StRuCtuReS

    maP<StriNg, INteger> dIct = new Treemap<stRing, Integer>();

I WOuLd expect a TReemap to be sloweR thAn a HasHMAp fOR most AppLicatIons thAT depenD on insert AnD Read efFIciency.  tHIs Is esPecially so since it SOrTS on keys and what You wanT iS To FINd aLl wIth at least VaLue 2.  YoU'D need to OVeRRIDe tHE comparison to Get that behaVIor.  
you don'T uSe tHE read bEhaviOr THat Would be helpFul.  ANd you accePt the sLOwer wriTEs.  
        Map<StRing, InTegEr> dIct = nEW HAsHMaP<>();

THIs sHOuLd pERfoRm faster FoR lArger InpuTS.  
pICk thE riGht mEthod

    For(String numbEr: dIct.kEYSeT()) {
        if(diCt.get(NumbEr) > 1) {
            HasDuPlicatIon = faLsE;
            System.out.printLn(nuMber + " " + dict.gEt(nUmBer));
        }
    }

thIs is tHE use caSe fOr aN entrySEt.  
    for (MaP.entRy<sTRInG, Integer> entry : dict.eNtRYseT()) {
        if (entry.GetValUE() > 1) {
            hAsdUplicatiOn = TruE;
            SysTEM.out.pRintLN(eNtry.getKEy() + " " + entrY.GeTVAlue());
        }
    }

Now We Don't haVe To dO an ExpenSIve gEt lookUp operatIon on EAch iteration.  
I'd ALso switch the mEAnING oF HasDUplIcation to maTch tHE namE.  Don'T FoRgeT To swiTch it ThE OtHEr two places as well.  

    boOlEan hasdupliCation = true;

to 
    bOolean hasDUPLIcation = fAlse;

ANd 

    IF(hasDuplicatioN) {

to 
    if (!HasDuplicaTIon) {

Other PossiBilities
if this doeSN'T help, conSidEr sPliTtiNG ReAding the input FROm prOcEssing iT.  So SomethiNg lIke 
    For (Int I = 0; i < Numbers.leNgth; i++) {
        numBeRs[I] = sCaN.neXtLinE();
    }

    Scan.closE();

    fOr (STrIng NumbeR : NumberS) {
        numbEr = coNvErT(NumBer);

        InteGEr COUnt = dIcT.gEt(nuMbeR);
        iF (counT == nulL
);

Now we don't keep an a rray aroun d for  no thi ng .  I al so changed the get/ put pattern.  This sav es ha vi n g to do  both  the co n ta i n sKe ych eck  a n dthe g et.   
Cons ider other  da ta  structures   Map<Stri ng,  Integer> di ct= newTr eeM a p<Str ing , Int eger>( ) ;

I w ould expe ct a Tree M ap to b e sl ower  than a HashMap f o rm ost applicatio ns tha td ep e n d o n i nsert andre ad ef f iciency .  T h i s i s  especially s o since its ort s on k ey s a n d what  youwa n t i s to find a ll w ith at le ast va l ue 2. Y ou'd ne ed toove rri de t h eco mpa ri s ont oget tha t behavi or . 
You  don ' t u se t heread  beha vior that wou ldbe h e lpf ul. And y ou a cc ept t he slo wer w ri tes.  
       Map< String, I nte ge r>di ct =n ew Has hMa p<> ();

Th is shou l d p er f o r mfaster for largerin p u ts .  
Pick  the r i gh tm ethod

  fo r(St r i ng nu mber :  d ict.keyS et()){ 
      if (d ict.ge t( num ber ) > 1 )  {
          has Dupli c ation = false;             S y st e m .o u t.pr int ln(number +  " " + di ct.g e t( num b er)); 
     }     }

This is theus e case  foran entrySet. 
    for( M a p.Entry< Stri n g, Integer> entry  : di ct.entrySe t ()) {
      if (ent ry.getVal u e () > 1){
      ha sDuplication= true ;          Syste m.o ut. pri ntl n( entry.get Key() +""+en try .getV a lue());     }    } 
Now w e don 't h av et o d o an ex p en s i ve g et  l ooku p o pe ratio n on eac h itera tion.  
I 'da lsosw it ch themeaning of ha sD uplication  t o m atch t h e  name. Don't forget to switchi t the o the r two  pla ces as we ll.   

   b o oleanhasDup licat io n = t rue;t o
  boolean ha s D upl icati on  = f alse;
and 

    if(hasDu p lic ation) {

to
   if ( !h asD u pl i cat io n ) { Other possibili ties
If th is do esn't help ,  co ns ider sp litting  read i ng theinput fro m process in g it .  So  something  like 
   for (i n t i = 0;  i <num bers.l en gth ; i++ ) {
     num bers[i ]= scan .next Li ne();
   }

    scan.close();
    f or (S tri ng number  :n umb ers) {
      number =  co nve rt(nu mbe r );

    Int e ger c ount = dict.ge t (n umb e r ); 
        if ( c oun t ==nul l 
);

Now we_don't keep_an array around for_nothing. _
I_also changed_the_get/put pattern. _This saves having_to do both the_containsKey check and_the_get.  
Consider other data structures

    Map<String, Integer> dict = new_TreeMap<String,_Integer>();

I would_expect_a_TreeMap to be slower than_a HashMap for most applications_that depend_on insert and read efficiency.  This is_especially_so since it_sorts on keys and what you want is to_find all with at least value_2.  You'd_need_to_override the comparison to_get that behavior.  
You don't_use the read behavior that would_be helpful.  And you accept the_slower writes.  
  _    _Map<String, Integer>_dict = new HashMap<>();

This should_perform faster for_larger inputs._ 
Pick the_right method

    for(String_number: dict.keySet()) {
_     __if(dict.get(number) > 1)_{
__ _  __ __ hasDuplication = false;
  __      _ System.out.println(number + "_"_+ dict.get(number));
  _    _}
    }

This is_the use_case for_an entrySet.  
    for (Map.Entry<String, Integer> entry_: dict.entrySet()) {
   _   _if (entry.getValue()_>_1) {
 __ _      _hasDuplication =_true;
     _   __ System.out.println(entry.getKey() + " " +_entry.getValue());
     _  }
  __}

Now_we don't have to do_an expensive get lookup operation on_each iteration. _
I'd also switch the meaning of hasDuplication_to_match the name.  Don't forget_to_switch it the other two places_as_well._ 

   _boolean hasDuplication = true;

to 
 _  boolean hasDuplication = false;

and 

  _ if(hasDuplication) {

to_
    if_(!hasDuplication)_{

Other_possibilities
If this doesn't help, consider splitting reading the input from_processing it._ So something_like 
    for (int i = 0;_i < numbers.length; i++) {
  _     numbers[i] = scan.nextLine();
   _}

    scan.close();

   _for (String number : numbers) {
 _   __ number = convert(number);

   ____ Integer count_= dict.get(number);
 _  _ _ if (count_== null