Reader Level:
ARTICLE

Finding Molecular Weight in Java

Posted by Vishal Gilbile Articles | Java June 17, 2012
This article is basically not for everyone, it is for those who deal with all chemistry related subjects or students who are have a need to find an element's molecular weight.
  • 1
  • 0
  • 3865
Download Files:
 

This article is basically not for everyone, it is for those who deal with all chemistry related subjects or students who are have a need to find an element's molecular weight. Molecular weight basically is the element's weight and the finding the expression full molecular weight.
For Eg: H2O; in this case we can say that there are two Hydrogen atoms and 1 Oxygen atom so for the molecular weight calculation the expression would be say Hydrogen's atomic weight times 2 + Oxygen's atomic weight. Say for example the element Hydrogen has the atomic weight of 1 and oxygen has the atomic weight of 16. Then the expression result would be 1X2+16=18.

The following is the code for finding the molecular weight in Java:

import java.util.Enumeration;
import java.util.Hashtable;
import java.io.*;
 

public
class ElementCalculation {
       static Hashtable hm;
       Hashtable[][]reactpro;
       Hashtable[] templist;
       Hashtable brentry=new Hashtable();
       double output,finaloutput;
       int newid=0,roundopen=0,boxopen=0,fullLen=0,indexLen=0,hmrpos=0,hmcpos=0,digitvalue=0,tempindex=0,suffix=0;
       String temp="",args="";
       boolean keyexists=false,yesno=false;
       BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
       public ElementCalculation()
       {
             setInitialValues();
             initializeDefaultreactPro();
       }
    public void dispose()
    {
       temp = "";
       roundopen = boxopen = tempindex = hmrpos = hmcpos = digitvalue = fullLen = indexLen = newid = suffix = 0;
       brentry.clear();
       keyexists=yesno=false;
       finaloutput = output = 0;
    }
       private static void setInitialValues()
       {
             hm=new Hashtable();
             hm.put("H", new Double(1.0079));
        hm.put("He", new Double(4.0026));
        hm.put("Li", new Double(6.941));
        hm.put("Be", new Double(9.0122));
        hm.put("B", new Double(10.811));
        hm.put("C", new Double(12.0107));
        hm.put("N", new Double(14.0067));
        hm.put("O", new Double(15.9994));
        hm.put("F", new Double(18.9984));
        hm.put("Ne", new Double(20.1797));
        hm.put("Na", new Double(22.9897));
        hm.put("Mg", new Double(24.305));
        hm.put("Al", new Double(26.9815));
        hm.put("Si", new Double(28.0855));
        hm.put("P", new Double(30.9738));
        hm.put("S", new Double(32.065));
        hm.put("Cl", new Double(35.453));
        hm.put("K", new Double(39.0983));
        hm.put("Ar", new Double(39.948));
        hm.put("Ca", new Double(40.078));
        hm.put("Sc", new Double(44.9559));
        hm.put("Ti", new Double(47.867));
        hm.put("V", new Double(50.9415));
        hm.put("Cr", new Double(51.9961));
        hm.put("Mn", new Double(54.938));
        hm.put("Fe", new Double(55.845));
        hm.put("Ni", new Double(58.6934));
        hm.put("Co", new Double(58.9332));
        hm.put("Cu", new Double(63.546));
        hm.put("Zn", new Double(65.39));
        hm.put("Ga", new Double(69.723));
        hm.put("Ge", new Double(72.64));
        hm.put("As", new Double(74.9216));
        hm.put("Se", new Double(78.96));
        hm.put("Br", new Double(79.904));
        hm.put("Kr", new Double(83.8));
        hm.put("Rb", new Double(85.4678));
        hm.put("Sr", new Double(87.62));
        hm.put("Y", new Double(88.9059));
        hm.put("Zr", new Double(91.224));
        hm.put("Nb", new Double(92.9064));
        hm.put("Mo", new Double(95.94));
        hm.put("Tc", new Double(98));
        hm.put("Ru", new Double(101.07));
        hm.put("Rh", new Double(102.9055));
        hm.put("Pd", new Double(106.42));
        hm.put("Ag", new Double(107.8682));
        hm.put("Cd", new Double(112.411));
        hm.put("In", new Double(114.818));
        hm.put("Sn", new Double(118.71));
        hm.put("Sb", new Double(121.76));
        hm.put("I", new Double(126.9045));
        hm.put("Te", new Double(127.6));
        hm.put("Xe", new Double(131.293));
        hm.put("Cs", new Double(132.9055));
        hm.put("Ba", new Double(137.327));
        hm.put("La", new Double(138.9055));
        hm.put("Ce",new Double(140.116));
        hm.put("Pr", new Double(140.9077));
        hm.put("Nd", new Double(144.24));
        hm.put("Pm", new Double(145));
        hm.put("Sm", new Double(150.36));
        hm.put("Eu", new Double(151.964));
        hm.put("Gd", new Double(157.25));
        hm.put("Tb", new Double(158.9253));

        hm.put("Dy",new Double(162.5));
        hm.put("Ho", new Double(164.9303));       
        hm.put("Er", new Double(167.259));
        hm.put("Tm", new Double(168.9342));
        hm.put("Yb", new Double(173.04));
        hm.put("Lu", new Double(174.967));
        hm.put("Hf", new Double(178.49));
        hm.put("Ta", new Double(180.9479));
        hm.put("W", new Double(183.84));
        hm.put("Re", new Double(186.207));
        hm.put("Os", new Double(190.23));
        hm.put("Ir", new Double(192.217));
        hm.put("Pt", new Double(195.078));
        hm.put("Au", new Double(196.9665));
        hm.put("Hg", new Double(200.59));
        hm.put("Tl", new Double(204.3833));
        hm.put("Pb", new Double(207.2));
        hm.put("Bi", new Double(208.9804));
        hm.put("Po", new Double(209));
        hm.put("At", new Double(210));
        hm.put("Rn", new Double(222));
        hm.put("Fr", new Double(223));
        hm.put("Ra", new Double(226));
        hm.put("Ac", new Double(227));
        hm.put("Pa", new Double(231.0359));
        hm.put("Th", new Double(232.0381));
        hm.put("Np", new Double(237));
        hm.put("U", new Double(238.0289));
        hm.put("Am", new Double(243));
        hm.put("Pu", new Double(244));
        hm.put("Cm", new Double(247));
        hm.put("Bk", new Double(247));
        hm.put("Cf", new Double(251));
        hm.put("Es", new Double(252));
        hm.put("Fm",new Double(257));
        hm.put("Md", new Double(258));
        hm.put("No", new Double(259));
        hm.put("Rf", new Double(261));
        hm.put("Lr", new Double(262));
        hm.put("Db", new Double(262));
        hm.put("Bh", new Double(264));
        hm.put("Sg", new Double(266));
        hm.put("Mt", new Double(268));
        hm.put("Rg", new Double(272));
        hm.put("Hs", new Double(277));
        hm.put("Ds", new Double(280));
       }
     
      
//This function is created temporary to test the functinality in BBD
       private void initializeDefaultreactPro()
       {
             reactpro=new Hashtable[2][];
             reactpro[0]=new Hashtable[1];
             reactpro[1]=new Hashtable[1];
             initializeReactPro();
       }
      
//For initializing the reactPro Hashtable
       private void initializeReactPro()
       {
             for(int i=0;i<reactpro.length;i++)

            {
                    for(int j=0;j<reactpro[i].length;j++)
                           reactpro[i][j]=new Hashtable();
             }
       }
       private boolean contains(String args){
             yesno=false;
             for(int i=0;i<args.length();i++)
             {
                    if(args.charAt(i)=='(' || args.charAt(i)=='[')
                    {
                           yesno=true;
                           break;
                    }
             }
             return yesno;
       }
       public void accept()
       {
            
try
             {
                    System.out.println("Enter your expression");
                    args=br.readLine();
                    if(contains(args)==true)
                           getNoOfBrackets(args);
                    reactpro[hmrpos][hmcpos].clear();
                    calculateLength(args);
                    matchElementToUpdate(reactpro[hmrpos][hmcpos],brentry);
                    calculateMolWeight(hmrpos,hmcpos);
             }
             catch(Exception e1){}
       }
      
      
//to calculate the no of Brackets appearing in the string
       private void getNoOfBrackets(String args)
       {
             for(int i=0;i<args.length();i++)
             {
                    if(args.charAt(i)=='(' || args.charAt(i)=='[')
                           tempindex++;
             }
             templist=new Hashtable[tempindex];

             tempindex=0;
             initializeTempHash();
       }
        
/*intialized the templist hashtable*/
       private void initializeTempHash()
       {
             for (int i = 0; i < templist.length; i++)
              templist[i] = new Hashtable();
       }
       private void calculateLength(String args)
       {
             fullLen=args.length();
             indexLen=fullLen-1;
             readAtom(args);
       }
      
//for calculating the next position within the String array.
       private int calculateNextPosition(int org)
       {
              int id = 0;
            if (org == fullLen - 1)
            {
               if (boxopen > 0 || roundopen > 0)
                    id = org;
               
else
                   id = 0;
            }
            else if (org < fullLen - 1)
              id = org + 1;
           newid = id;
         return newid;
       }
        private void readAtom(String args) {
               for(int i=0,nxtpos=0;i<args.length();i++)
               {
                   temp="";
                   nxtpos=calculateNextPosition(i);
                  if(Character.isUpperCase(args.charAt(i))&& Character.isUpperCase(args.charAt(indexLen-(indexLen-nxtpos))))
                   {
                       temp=String.valueOf(args.charAt(i));
                       addentry(1);
                   }
                   else if(Character.isUpperCase(args.charAt(i)) && (args.charAt(indexLen-(indexLen-nxtpos))=='[' || args.charAt(indexLen-(indexLen-nxtpos))=='('))
                   {
                       temp = String.valueOf(args.charAt(i));
                       addentry(1);

                       if(args.charAt(indexLen - (indexLen - nxtpos))=='(')
                           roundopen++;
                      
else
                         boxopen++;
                       
// suffix = 1;
                       i=readBrackets(args, indexLen - (indexLen - nxtpos));
                   }
                   else if(Character.isUpperCase(args.charAt(i)) && Character.isDigit(args.charAt(indexLen-(indexLen-nxtpos))))
                   {

                       temp =String.valueOf(args.charAt(i));
                      
//keyexists = reactpro[hmrpos][hmcpos].containsKey(temp);
                       i=IsDigit(args, indexLen - (indexLen - nxtpos));
                       addentry(digitvalue);
                   }
                   else if(Character.isUpperCase(args.charAt(i)))
                   {
                       temp=String.valueOf(args.charAt(i));
                       i=readLower(args,i);
                       i=i-1;
                   }
                   else if(args.charAt(i)=='[')
                   {
                       boxopen++;
                       if(!brentry.isEmpty())
                       {
                           addToTempHash();
                           tempindex++;
                       }
                       i=readBrackets(args, i);
                   }
                   else if(args.charAt(i)=='(')
                   {
                       roundopen++;
                       if(!brentry.isEmpty())
                       {
                           addToTempHash();
                           tempindex++;
                       }
                       i=readBrackets(args, i);
                   }
               }
           }
          
//This function is used for reading the elements having lower case letters and also for reading the digits
           private int readLower(String args, int idx) {
               for(int j=idx+1,nxtpos=0;j<args.length();j++)
               {
                   nxtpos=calculateNextPosition(j);
                    if(Character.isLowerCase(args.charAt(j))&& (!(Character.isDigit(args.charAt(indexLen-(indexLen-nxtpos))) || Character.isLowerCase(args.charAt(indexLen-(indexLen-
nxtpos))))))
                    {
                       temp+=String.valueOf(args.charAt(j));
                       if (roundopen == 0 && boxopen == 0)
                               addentry(1);
                      
else
                       {
                           if (!brentry.isEmpty())
                           {
                              addToTempHash();
                              tempindex++;
                           }
                           addentry(1);
                       } 
                    }
                    else if(Character.isLowerCase(args.charAt(j)) && Character.isDigit(args.charAt(indexLen-(indexLen-nxtpos))))
                    {
                       temp+=String.valueOf(args.charAt(j));
                       j=IsDigit(args,indexLen-(indexLen-nxtpos));
                       addentry(digitvalue);
                    }
                    else if(Character.isLowerCase(args.charAt(j))&& args.charAt(indexLen-(indexLen-nxtpos))=='[')
                    {
                        temp+=String.valueOf(args.charAt(j));
                        addentry(1);
                        boxopen++;
                       
//suffix=1;
                        addToTempHash();
                        tempindex++;
                        j=readBrackets(args, indexLen-(indexLen-nxtpos));
                    }
                    else if(Character.isLowerCase(args.charAt(j))&& args.charAt(indexLen-(indexLen-nxtpos))=='(')
                    {
                        temp+=String.valueOf(args.charAt(j));
                        addentry(1);
                        roundopen++;
                       
//suffix=1;
                        addToTempHash();
                        tempindex++;
                        j=readBrackets(args, indexLen-(indexLen-nxtpos));
                    }
                    else if(Character.isDigit(args.charAt(j))&& args.charAt(indexLen-(indexLen-nxtpos))==')')
                    {
                          j=IsDigit(args, j);
                       if(roundopen>1)
                       {
                           keyexists=brentry.containsKey(temp);
                           if(keyexists)
                           {
                               suffix=digitvalue;
                               j=IsDigit(args, indexLen-(indexLen-nxtpos)+1);
                               digitvalue*=suffix;
                               suffix=0;
                               addentry(digitvalue);
                               roundopen--;
                           }
                          
else
                               addentry(digitvalue);
                       }
                      
else
                           addentry(digitvalue);
                    }
                    else if(Character.isDigit(args.charAt(j)) && args.charAt(indexLen-(indexLen-nxtpos))==']')
                    {
                         j=IsDigit(args, j);
                       if(boxopen>1)
                       {
                           keyexists=brentry.containsKey(temp);
                           if(keyexists)
                           {
                               suffix=digitvalue;
                               j=IsDigit(args, indexLen-(indexLen-nxtpos)+1);
                               digitvalue*=suffix;
                               suffix=0;
                               addentry(digitvalue);
                               boxopen--;
                           }
                          
else
                               addentry(digitvalue);
                       }
                      
else
                           addentry(digitvalue);
                    }
                    else if(Character.isLowerCase(args.charAt(j)))
                    {
                        temp+=String.valueOf(args.charAt(j));
                        for(int k=j+1,nxtpos1=0;j<args.length();k++)
                        {
                            nxtpos1=calculateNextPosition(k);
                            if(Character.isLowerCase(args.charAt(k))&& !Character.isDigit(args.charAt(indexLen-(indexLen-nxtpos1))))
                            {
                               temp+=String.valueOf(args.charAt(k));
                               addentry(1);
                            }
                            else if(Character.isLowerCase(args.charAt(k)) && Character.isDigit(args.charAt(indexLen-(indexLen-nxtpos1))))
                            {
                               temp+=String.valueOf(args.charAt(k));
                               k=IsDigit(args, k);
                               addentry(digitvalue);
                            }
                           else if(Character.isLowerCase(args.charAt(k))&& args.charAt(indexLen-(indexLen-nxtpos1))=='[')
                           {
                               temp+=String.valueOf(args.charAt(k));
                               addentry(1);
                               boxopen++;
                               k=readBrackets(args, indexLen-(indexLen-nxtpos1));
                           }
                           else if(Character.isLowerCase(args.charAt(k))&& args.charAt(indexLen-(indexLen-nxtpos1))=='(')
                           {
                               temp+=String.valueOf(args.charAt(k));
                               addentry(1);
                               roundopen++;
                               k=readBrackets(args, indexLen-(indexLen-nxtpos1));
                           }
                           else if(Character.isDigit(args.charAt(k)))
                           {
                               k=IsDigit(args, k);
                               addentry(digitvalue);
                           }
                           else if(Character.isUpperCase(args.charAt(k)))
                           {
                               j=k-1;
                               break;
                           }
                          
else
                           {
                               j=k-1;
                               break;
                           }
                        }
                    }
                    else if(Character.isDigit(args.charAt(j))&& args.charAt(indexLen-(indexLen-nxtpos))!=')')
                    {
                        j=IsDigit(args, j);
                        addentry(digitvalue);
                    }
                    else if(Character.isUpperCase(args.charAt(j)))
                    {
                        newid=j;
                        break;
                    }
                    else if(args.charAt(j)=='[' && args.charAt(indexLen-(indexLen-nxtpos))=='(')
                    {
                        boxopen++;
                        j=readBrackets(args, indexLen-(indexLen-nxtpos));
                    }
                    else if(args.charAt(j)=='[')
                    {
                        boxopen++;
                        if(boxopen>0)
                        {
                            if(!brentry.isEmpty())
                            {
                                addToTempHash();
                                tempindex++;
                            }
                        }
                        j=readBrackets(args, j);
                    }
                    else if(args.charAt(j)=='(')
                    {
                        roundopen++;
                        if(roundopen>0)
                        {
                            if(!brentry.isEmpty())
                            {
                                addToTempHash();
                                tempindex++;
                            }
                        }
                        j=readBrackets(args, j);
                    }
                    else if(args.charAt(j)==')' && Character.isDigit(args.charAt(indexLen-(indexLen-nxtpos))))
                    {
                        roundopen--;
                        j=IsDigit(args, indexLen-(indexLen-nxtpos));
                        if(boxopen==0 && roundopen==0)
                        {
                            if(!brentry.isEmpty())
                            {
                                updateentry(brentry,digitvalue);
                                tempindex=tempindex>0?tempindex=tempindex-1:0;
                                if(!templist[tempindex].isEmpty())
                                    matchElementToUpdate(this.brentry,this.templist[tempindex]);
                               
else
                                {
                                   
//suffix=0;
                                    addToReactPro();
                                }
                            }
                           
else
                                updateentry(reactpro[hmrpos][hmcpos],digitvalue);
                       }
                      
else
                       {
                           updateentry(brentry,digitvalue);
                           tempindex=tempindex>0?tempindex=tempindex-1:0;
                           if(!templist[tempindex].isEmpty())
                               matchElementToUpdate(brentry, templist[tempindex]);
                          
else                           {
                              
//suffix=0;
                               addToReactPro();
                           }
                       }
                    }
                    else if(args.charAt(j)==']' && Character.isDigit(args.charAt(indexLen-(indexLen-nxtpos))))
                    {
                        boxopen--;
                        j=IsDigit(args, indexLen-(indexLen-nxtpos));
                        if(boxopen==0 && roundopen==0)
                        {
                            if(!brentry.isEmpty())
                            {
                                updateentry(brentry,digitvalue);
                                tempindex=tempindex>0?tempindex=tempindex-1:0;
                                if(!templist[tempindex].isEmpty())
                                    matchElementToUpdate(brentry,templist[tempindex]);
                               
else
                                {
                                    
//suffix=0;
                                    addToReactPro();
                                }
                            }
                           
else
                                updateentry(reactpro[hmrpos][hmcpos], digitvalue);
                        }
                       
else
                        {
                            updateentry(brentry,digitvalue);
                            tempindex=tempindex>0?tempindex=tempindex-1:0;
                            if(!templist[tempindex].isEmpty())
                                matchElementToUpdate(this.brentry,this.templist[tempindex]);
                           
else
                            {
                                suffix=0;
                                addToReactPro();
                            }
                        }
                    }
                    else if(args.charAt(j)==')')
                    {
                        roundopen--;
                        if(roundopen==0 && boxopen==0)
                            addToReactPro();
                       
else
                        {
                            tempindex=tempindex>0?tempindex=tempindex-1:0;
                            if(!templist[tempindex].isEmpty())
                                matchElementToUpdate(brentry,templist[tempindex]);
                           
else
                            {
                                suffix=0;
                                addToReactPro();
                            }
                        }
                    }
                    else if(args.charAt(j)==']')
                    {
                        boxopen--;
                        if(roundopen==0 && boxopen==0)
                            addToReactPro();
                       
else
                        {
                            tempindex=tempindex>0?tempindex=tempindex-1:0;
                            if(!templist[tempindex].isEmpty())
                                matchElementToUpdate(brentry,templist[tempindex]);
                           
else
                            {
                                suffix=0;
                                addToReactPro();
                            }
                        }
                    }
                    newid=j;
               }
               return newid;
           }
          
//For reading the brackets expression
           private int readBrackets(String args, int idx) {
               for(int i=idx+1,nxtpos=0;i<args.length();i++)
               {
                   nxtpos=calculateNextPosition(i);
                   if(Character.isUpperCase(args.charAt(i)) && Character.isUpperCase(args.charAt(indexLen-(indexLen-nxtpos))))
                   {
                       temp=String.valueOf(args.charAt(i));
                       addentry(1);
                   }
                   else if(Character.isUpperCase(args.charAt(i)) && args.charAt(indexLen-(indexLen-nxtpos))=='[')
                   {
                       temp=String.valueOf(args.charAt(i));
                       addentry(1);
                       addToTempHash();
                       tempindex++;
                       boxopen++;
                      
//suffix=1;
                       i=readBrackets(args, indexLen-(indexLen-nxtpos));
                   }
                   else if(Character.isUpperCase(args.charAt(i))&& args.charAt(indexLen-(indexLen-nxtpos))=='(')
                   {
                       temp=String.valueOf(args.charAt(i));
                       addentry(1);
                       addToTempHash();
                       tempindex++;
                       roundopen++;
                      
//suffix=1;
                       i=readBrackets(args, indexLen-(indexLen-nxtpos));
                   }
                   else if(Character.isUpperCase(args.charAt(i))&& args.charAt(indexLen-(indexLen-nxtpos))==')')
                   {
                         temp=String.valueOf(args.charAt(i));
                         addentry(1);
                         i=readLower(args, i);
                         i=i-1;
                  }
                   else if(Character.isUpperCase(args.charAt(i)) && args.charAt(indexLen-(indexLen-nxtpos))==']')
                   {
                         temp=String.valueOf(args.charAt(i));
                         addentry(1);
                         i=readLower(args, i);
                         i=i-1;
                   }
                   else if(args.charAt(i)=='(')
                   {
                       roundopen++;
                       if(!brentry.isEmpty())
                       {
                           addToTempHash();
                           tempindex++;
                       }
                       continue;
                   }
                   else if(args.charAt(i)=='[')
                   {
                       boxopen++;
                       if(!brentry.isEmpty())
                       {
                           addToTempHash();
                           tempindex++;
                       }
                       continue;
                   }
                   else if(Character.isUpperCase(args.charAt(i)))
                   {
                       temp=String.valueOf(args.charAt(i));
                       i=readLower(args, i);
                       i=i-1;
                   }
                   newid=i;
               }
               return newid;
           }
          
//This function is used for adding elements in the respective hashmap considering whether any box brackets or round brackets
          
//are open if not then add the elements to the reactpro hashmap
           private void addentry(int value) {
                    if (boxopen > 0)
                   {
                       keyexists = brentry.containsKey(temp);
                       if (roundopen > 0)
                       {
                           if (keyexists == false)
                               brentry.put(temp, new Integer(value));
                           
else
                               updateKeyValue(temp, value, brentry);
                       }
                      
else
                       {
                           if (keyexists == false)
                               brentry.put(temp, new Integer(value));
                          
else
                               updateKeyValue(temp, value, brentry);
                       }
                   }
                   else if (roundopen > 0)
                   {
                       keyexists = brentry.containsKey(temp);
                       if (keyexists == false)
                           brentry.put(temp, new Integer(value));
                      
else
                           updateKeyValue(temp, value, brentry);
                   }
                  
else
                   {
                       keyexists = reactpro[hmrpos][hmcpos].containsKey(temp);
                       if (keyexists == false)
                           reactpro[hmrpos][hmcpos].put(temp, new Integer(value));
                      
else
                           updateKeyValue(temp, value, reactpro[hmrpos][hmcpos]);
                   }
           }
 
          
//This function are called when the Box or Round brackets opens we are adding it to the templist hashtable
          
//when anyother round or box bracket gets opened
           private void addToTempHash() {
              Enumeration keys=brentry.keys();
              while(keys.hasMoreElements())
              {
                    Object retrievedKey=keys.nextElement();
                     templist[tempindex].put(retrievedKey,brentry.get(retrievedKey));
              }
              brentry.clear();
           }
        
//For calculating the no of digits after the element.
           private int IsDigit(String args, int idx) {
               String variable = "";
               int newid2 = 0;
               for (int k = idx; k < fullLen; k++)
               {
                  if (Character.isDigit(args.charAt(k)))
                  {
                     variable += String.valueOf(args.charAt(k));
                     newid2 = k;
                  }
                 
else
                  {
                      newid2 = k - 1;
                      break;
                  }
                }
                newid = newid2;
                if (variable.equals("") || variable.equals("0"))
                   digitvalue = 1;
               
else
                  digitvalue=Integer.parseInt(variable);
              return newid;
           }
          
//For updating the key value stored in the hashtable with that of the value specified after the round or box bracket
           protected void updateentry(Hashtable h, int value) {
              Enumeration keys=h.keys();
              while(keys.hasMoreElements())
              {
                    Object retrievedKey=keys.nextElement();
                     h.put(retrievedKey,(Object)String.valueOf(Integer.parseInt(String.valueOf(h.get(retrievedKey))) * value));
              }
           }
          
//This function is called when any box or round brackets gets closed we are updating the brentry hashtable
          
//with that of the templist hashtable also checking before adding whether any key exists or not.If exists we are updating the key value
          
// with that of brentry hashtable and templist hashtable. And also finally adding it to the final hashtable.
            public void matchElementToUpdate(Hashtable a, Hashtable b) {
               
//If a hashmap is empty and the b is not empty then directly copy all the elements from hashmap b to hashmap a
                yesno=a.isEmpty() && !b.isEmpty()?true:false;
                if(yesno==true)

                {
                     Enumeration keys=b.keys();
                     while(keys.hasMoreElements())
                     {
                            Object retrievedKey=keys.nextElement();
                            a.put(retrievedKey, b.get(retrievedKey));
                     }
                }
               
else
                {
                     Enumeration keys1=a.keys();
                     while(keys1.hasMoreElements())
                     {
                            Object retrievedKey1=keys1.nextElement();
                            Enumeration keys2=b.keys();
                            while(keys2.hasMoreElements())
                            {
                                   Object retrievedKey2=keys2.nextElement();
                                   if(a.containsKey(retrievedKey2))
                                   {
                                         if(retrievedKey1.equals(retrievedKey2))
                                         {
                                                int result=Integer.parseInt(String.valueOf(a.get(retrievedKey1)))+ Integer.parseInt(String.valueOf(b.get(retrievedKey2)));
                                                       a.put(retrievedKey1,(Object)String.valueOf(result));
                                                       b.remove(retrievedKey2);
                                         }
                                   }
                                   
else
                                   {
                                         a.put(retrievedKey2, b.get(retrievedKey2));
                                         b.remove(retrievedKey2);
                                   }
                            }
                     }
                }
                b.clear();
            }
            private void addToReactPro() {
               Enumeration keys=brentry.keys();
               while(keys.hasMoreElements())
               {
                     Object retrievedKey=keys.nextElement();
                     keyexists=reactpro[hmrpos][hmcpos].containsKey(retrievedKey);
                     if(keyexists==false)
                            reactpro[hmrpos][hmcpos].put(retrievedKey, brentry.get(retrievedKey));
                     
else
                      {
                            int value=Integer.parseInt(String.valueOf(brentry.get(retrievedKey)));
                            updateKeyValue(String.valueOf(retrievedKey),value,reactpro[hmrpos][hmcpos]);
                     }
               }
               brentry.clear();
            }
             private void updateKeyValue(String key, int newVal, Hashtable h)
             {
                    Enumeration keys=h.keys();
                    while(keys.hasMoreElements())
                    {
                           Object retrievedKey=keys.nextElement();
                           if(retrievedKey.equals(key))
                           {
                                 if(suffix!=0)
                                 {
                                        h.put(retrievedKey,String.valueOf(Integer.parseInt(String.valueOf(h.get(retrievedKey)))* newVal));
                                        suffix=0;
                                 }
                                
else
                                        h.put(retrievedKey,String.valueOf(Integer.parseInt(String.valueOf(h.get(retrievedKey)))+newVal));
                                 break;
                          }
                    }
             }              
//This function will return the atomic weight of that particular element which is stored in the hm hashmap
          
//which is acting as a database in our case.
           private double getMolWeight(String key)
           {
              double value=0;
              Enumeration keys=hm.keys();
              while(keys.hasMoreElements())
              {
                    Object retrievedKey=keys.nextElement();
                    if(retrievedKey.equals(key))
                    {
                           value=Double.parseDouble(String.valueOf(hm.get(retrievedKey)));
                           break;
                    }
              }
              return value;
           }
          
//For calculating the molecular weight of the expression and for storing the molecular weight as per the compounds
          
//in the mol_weight variable at a particular row and at a particular's column
           protected void calculateMolWeight(int rindex,int cindex)
           {
              finaloutput=0;
               Enumeration keys=reactpro[rindex][cindex].keys();
               while(keys.hasMoreElements())
               {
                    Object retrievedKey=keys.nextElement();
                    output=getMolWeight(String.valueOf(retrievedKey));
                    finaloutput+=output * Integer.parseInt(String.valueOf(reactpro[rindex][cindex].get(retrievedKey)));
               }
                    System.out.println(finaloutput);
           }
             public static void main(String args[])
             {
                    ElementCalculation obj=new ElementCalculation();
                    obj.setInitialValues();
                    obj.accept();
             }
}

 

COMMENT USING

Trending up