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:
  1. import java.util.Enumeration;
  2. import java.util.Hashtable;
  3. import java.io.*;
  5. public class ElementCalculation {
  6. static Hashtable hm;
  7. Hashtable[][] reactpro;
  8. Hashtable[] templist;
  9. Hashtable brentry = new Hashtable();
  10. double output, finaloutput;
  11. int newid = 0, roundopen = 0, boxopen = 0, fullLen = 0, indexLen = 0, hmrpos = 0, hmcpos = 0, digitvalue = 0, tempindex = 0, suffix = 0;
  12. String temp = "", args = "";
  13. boolean keyexists = false, yesno = false;
  14. BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  15. public ElementCalculation() {
  16. setInitialValues();
  17. initializeDefaultreactPro();
  18. }
  19. public void dispose() {
  20. temp = "";
  21. roundopen = boxopen = tempindex = hmrpos = hmcpos = digitvalue = fullLen = indexLen = newid = suffix = 0;
  22. brentry.clear();
  23. keyexists = yesno = false;
  24. finaloutput = output = 0;
  25. }
  26. private static void setInitialValues() {
  27. hm = new Hashtable();
  28. hm.put("H", new Double(1.0079));
  29. hm.put("He", new Double(4.0026));
  30. hm.put("Li", new Double(6.941));
  31. hm.put("Be", new Double(9.0122));
  32. hm.put("B", new Double(10.811));
  33. hm.put("C", new Double(12.0107));
  34. hm.put("N", new Double(14.0067));
  35. hm.put("O", new Double(15.9994));
  36. hm.put("F", new Double(18.9984));
  37. hm.put("Ne", new Double(20.1797));
  38. hm.put("Na", new Double(22.9897));
  39. hm.put("Mg", new Double(24.305));
  40. hm.put("Al", new Double(26.9815));
  41. hm.put("Si", new Double(28.0855));
  42. hm.put("P", new Double(30.9738));
  43. hm.put("S", new Double(32.065));
  44. hm.put("Cl", new Double(35.453));
  45. hm.put("K", new Double(39.0983));
  46. hm.put("Ar", new Double(39.948));
  47. hm.put("Ca", new Double(40.078));
  48. hm.put("Sc", new Double(44.9559));
  49. hm.put("Ti", new Double(47.867));
  50. hm.put("V", new Double(50.9415));
  51. hm.put("Cr", new Double(51.9961));
  52. hm.put("Mn", new Double(54.938));
  53. hm.put("Fe", new Double(55.845));
  54. hm.put("Ni", new Double(58.6934));
  55. hm.put("Co", new Double(58.9332));
  56. hm.put("Cu", new Double(63.546));
  57. hm.put("Zn", new Double(65.39));
  58. hm.put("Ga", new Double(69.723));
  59. hm.put("Ge", new Double(72.64));
  60. hm.put("As", new Double(74.9216));
  61. hm.put("Se", new Double(78.96));
  62. hm.put("Br", new Double(79.904));
  63. hm.put("Kr", new Double(83.8));
  64. hm.put("Rb", new Double(85.4678));
  65. hm.put("Sr", new Double(87.62));
  66. hm.put("Y", new Double(88.9059));
  67. hm.put("Zr", new Double(91.224));
  68. hm.put("Nb", new Double(92.9064));
  69. hm.put("Mo", new Double(95.94));
  70. hm.put("Tc", new Double(98));
  71. hm.put("Ru", new Double(101.07));
  72. hm.put("Rh", new Double(102.9055));
  73. hm.put("Pd", new Double(106.42));
  74. hm.put("Ag", new Double(107.8682));
  75. hm.put("Cd", new Double(112.411));
  76. hm.put("In", new Double(114.818));
  77. hm.put("Sn", new Double(118.71));
  78. hm.put("Sb", new Double(121.76));
  79. hm.put("I", new Double(126.9045));
  80. hm.put("Te", new Double(127.6));
  81. hm.put("Xe", new Double(131.293));
  82. hm.put("Cs", new Double(132.9055));
  83. hm.put("Ba", new Double(137.327));
  84. hm.put("La", new Double(138.9055));
  85. hm.put("Ce", new Double(140.116));
  86. hm.put("Pr", new Double(140.9077));
  87. hm.put("Nd", new Double(144.24));
  88. hm.put("Pm", new Double(145));
  89. hm.put("Sm", new Double(150.36));
  90. hm.put("Eu", new Double(151.964));
  91. hm.put("Gd", new Double(157.25));
  92. hm.put("Tb", new Double(158.9253));
  93. hm.put("Dy", new Double(162.5));
  94. hm.put("Ho", new Double(164.9303));
  95. hm.put("Er", new Double(167.259));
  96. hm.put("Tm", new Double(168.9342));
  97. hm.put("Yb", new Double(173.04));
  98. hm.put("Lu", new Double(174.967));
  99. hm.put("Hf", new Double(178.49));
  100. hm.put("Ta", new Double(180.9479));
  101. hm.put("W", new Double(183.84));
  102. hm.put("Re", new Double(186.207));
  103. hm.put("Os", new Double(190.23));
  104. hm.put("Ir", new Double(192.217));
  105. hm.put("Pt", new Double(195.078));
  106. hm.put("Au", new Double(196.9665));
  107. hm.put("Hg", new Double(200.59));
  108. hm.put("Tl", new Double(204.3833));
  109. hm.put("Pb", new Double(207.2));
  110. hm.put("Bi", new Double(208.9804));
  111. hm.put("Po", new Double(209));
  112. hm.put("At", new Double(210));
  113. hm.put("Rn", new Double(222));
  114. hm.put("Fr", new Double(223));
  115. hm.put("Ra", new Double(226));
  116. hm.put("Ac", new Double(227));
  117. hm.put("Pa", new Double(231.0359));
  118. hm.put("Th", new Double(232.0381));
  119. hm.put("Np", new Double(237));
  120. hm.put("U", new Double(238.0289));
  121. hm.put("Am", new Double(243));
  122. hm.put("Pu", new Double(244));
  123. hm.put("Cm", new Double(247));
  124. hm.put("Bk", new Double(247));
  125. hm.put("Cf", new Double(251));
  126. hm.put("Es", new Double(252));
  127. hm.put("Fm", new Double(257));
  128. hm.put("Md", new Double(258));
  129. hm.put("No", new Double(259));
  130. hm.put("Rf", new Double(261));
  131. hm.put("Lr", new Double(262));
  132. hm.put("Db", new Double(262));
  133. hm.put("Bh", new Double(264));
  134. hm.put("Sg", new Double(266));
  135. hm.put("Mt", new Double(268));
  136. hm.put("Rg", new Double(272));
  137. hm.put("Hs", new Double(277));
  138. hm.put("Ds", new Double(280));
  139. }
  141. //This function is created temporary to test the functinality in BBD
  142. private void initializeDefaultreactPro() {
  143. reactpro = new Hashtable[2][];
  144. reactpro[0] = new Hashtable[1];
  145. reactpro[1] = new Hashtable[1];
  146. initializeReactPro();
  147. }
  148. //For initializing the reactPro Hashtable
  149. private void initializeReactPro() {
  150. for (int i = 0; i < reactpro.length; i++)
  152. {
  153. for (int j = 0; j < reactpro[i].length; j++)
  154. reactpro[i][j] = new Hashtable();
  155. }
  156. }
  157. private boolean contains(String args) {
  158. yesno = false;
  159. for (int i = 0; i < args.length(); i++) {
  160. if (args.charAt(i) == '(' || args.charAt(i) == '[') {
  161. yesno = true;
  162. break;
  163. }
  164. }
  165. return yesno;
  166. }
  167. public void accept() {
  168. try {
  169. System.out.println("Enter your expression");
  170. args = br.readLine();
  171. if (contains(args) == true)
  172. getNoOfBrackets(args);
  173. reactpro[hmrpos][hmcpos].clear();
  174. calculateLength(args);
  175. matchElementToUpdate(reactpro[hmrpos][hmcpos], brentry);
  176. calculateMolWeight(hmrpos, hmcpos);
  177. } catch (Exception e1) {}
  178. }
  180. //to calculate the no of Brackets appearing in the string
  181. private void getNoOfBrackets(String args) {
  182. for (int i = 0; i < args.length(); i++) {
  183. if (args.charAt(i) == '(' || args.charAt(i) == '[')
  184. tempindex++;
  185. }
  186. templist = new Hashtable[tempindex];
  188. tempindex = 0;
  189. initializeTempHash();
  190. }
  191. /*intialized the templist hashtable*/
  192. private void initializeTempHash() {
  193. for (int i = 0; i < templist.length; i++)
  194. templist[i] = new Hashtable();
  195. }
  196. private void calculateLength(String args) {
  197. fullLen = args.length();
  198. indexLen = fullLen - 1;
  199. readAtom(args);
  200. }
  201. //for calculating the next position within the String array.
  202. private int calculateNextPosition(int org) {
  203. int id = 0;
  204. if (org == fullLen - 1) {
  205. if (boxopen > 0 || roundopen > 0)
  206. id = org;
  207. else
  208. id = 0;
  209. } else if (org < fullLen - 1)
  210. id = org + 1;
  211. newid = id;
  212. return newid;
  213. }
  214. private void readAtom(String args) {
  215. for (int i = 0, nxtpos = 0; i < args.length(); i++) {
  216. temp = "";
  217. nxtpos = calculateNextPosition(i);
  218. if (Character.isUpperCase(args.charAt(i)) && Character.isUpperCase(args.charAt(indexLen - (indexLen - nxtpos)))) {
  219. temp = String.valueOf(args.charAt(i));
  220. addentry(1);
  221. } else if (Character.isUpperCase(args.charAt(i)) && (args.charAt(indexLen - (indexLen - nxtpos)) == '[' || args.charAt(indexLen - (indexLen - nxtpos)) == '(')) {
  222. temp = String.valueOf(args.charAt(i));
  223. addentry(1);
  225. if (args.charAt(indexLen - (indexLen - nxtpos)) == '(')
  226. roundopen++;
  227. else
  228. boxopen++;
  229. // suffix = 1;
  230. i = readBrackets(args, indexLen - (indexLen - nxtpos));
  231. } else if (Character.isUpperCase(args.charAt(i)) && Character.isDigit(args.charAt(indexLen - (indexLen - nxtpos)))) {
  233. temp = String.valueOf(args.charAt(i));
  234. //keyexists = reactpro[hmrpos][hmcpos].containsKey(temp);
  235. i = IsDigit(args, indexLen - (indexLen - nxtpos));
  236. addentry(digitvalue);
  237. } else if (Character.isUpperCase(args.charAt(i))) {
  238. temp = String.valueOf(args.charAt(i));
  239. i = readLower(args, i);
  240. i = i - 1;
  241. } else if (args.charAt(i) == '[') {
  242. boxopen++;
  243. if (!brentry.isEmpty()) {
  244. addToTempHash();
  245. tempindex++;
  246. }
  247. i = readBrackets(args, i);
  248. } else if (args.charAt(i) == '(') {
  249. roundopen++;
  250. if (!brentry.isEmpty()) {
  251. addToTempHash();
  252. tempindex++;
  253. }
  254. i = readBrackets(args, i);
  255. }
  256. }
  257. }
  258. //This function is used for reading the elements having lower case letters and also for reading the digits
  259. private int readLower(String args, int idx) {
  260. for (int j = idx + 1, nxtpos = 0; j < args.length(); j++) {
  261. nxtpos = calculateNextPosition(j);
  262. if (Character.isLowerCase(args.charAt(j)) && (!(Character.isDigit(args.charAt(indexLen - (indexLen - nxtpos))) || Character.isLowerCase(args.charAt(indexLen - (indexLen -
  263. nxtpos)))))) {
  264. temp += String.valueOf(args.charAt(j));
  265. if (roundopen == 0 && boxopen == 0)
  266. addentry(1);
  267. else {
  268. if (!brentry.isEmpty()) {
  269. addToTempHash();
  270. tempindex++;
  271. }
  272. addentry(1);
  273. }
  274. } else if (Character.isLowerCase(args.charAt(j)) && Character.isDigit(args.charAt(indexLen - (indexLen - nxtpos)))) {
  275. temp += String.valueOf(args.charAt(j));
  276. j = IsDigit(args, indexLen - (indexLen - nxtpos));
  277. addentry(digitvalue);
  278. } else if (Character.isLowerCase(args.charAt(j)) && args.charAt(indexLen - (indexLen - nxtpos)) == '[') {
  279. temp += String.valueOf(args.charAt(j));
  280. addentry(1);
  281. boxopen++;
  282. //suffix=1;
  283. addToTempHash();
  284. tempindex++;
  285. j = readBrackets(args, indexLen - (indexLen - nxtpos));
  286. } else if (Character.isLowerCase(args.charAt(j)) && args.charAt(indexLen - (indexLen - nxtpos)) == '(') {
  287. temp += String.valueOf(args.charAt(j));
  288. addentry(1);
  289. roundopen++;
  290. //suffix=1;
  291. addToTempHash();
  292. tempindex++;
  293. j = readBrackets(args, indexLen - (indexLen - nxtpos));
  294. } else if (Character.isDigit(args.charAt(j)) && args.charAt(indexLen - (indexLen - nxtpos)) == ')') {
  295. j = IsDigit(args, j);
  296. if (roundopen > 1) {
  297. keyexists = brentry.containsKey(temp);
  298. if (keyexists) {
  299. suffix = digitvalue;
  300. j = IsDigit(args, indexLen - (indexLen - nxtpos) + 1);
  301. digitvalue *= suffix;
  302. suffix = 0;
  303. addentry(digitvalue);
  304. roundopen--;
  305. } else
  306. addentry(digitvalue);
  307. } else
  308. addentry(digitvalue);
  309. } else if (Character.isDigit(args.charAt(j)) && args.charAt(indexLen - (indexLen - nxtpos)) == ']') {
  310. j = IsDigit(args, j);
  311. if (boxopen > 1) {
  312. keyexists = brentry.containsKey(temp);
  313. if (keyexists) {
  314. suffix = digitvalue;
  315. j = IsDigit(args, indexLen - (indexLen - nxtpos) + 1);
  316. digitvalue *= suffix;
  317. suffix = 0;
  318. addentry(digitvalue);
  319. boxopen--;
  320. } else
  321. addentry(digitvalue);
  322. } else
  323. addentry(digitvalue);
  324. } else if (Character.isLowerCase(args.charAt(j))) {
  325. temp += String.valueOf(args.charAt(j));
  326. for (int k = j + 1, nxtpos1 = 0; j < args.length(); k++) {
  327. nxtpos1 = calculateNextPosition(k);
  328. if (Character.isLowerCase(args.charAt(k)) && !Character.isDigit(args.charAt(indexLen - (indexLen - nxtpos1)))) {
  329. temp += String.valueOf(args.charAt(k));
  330. addentry(1);
  331. } else if (Character.isLowerCase(args.charAt(k)) && Character.isDigit(args.charAt(indexLen - (indexLen - nxtpos1)))) {
  332. temp += String.valueOf(args.charAt(k));
  333. k = IsDigit(args, k);
  334. addentry(digitvalue);
  335. } else if (Character.isLowerCase(args.charAt(k)) && args.charAt(indexLen - (indexLen - nxtpos1)) == '[') {
  336. temp += String.valueOf(args.charAt(k));
  337. addentry(1);
  338. boxopen++;
  339. k = readBrackets(args, indexLen - (indexLen - nxtpos1));
  340. } else if (Character.isLowerCase(args.charAt(k)) && args.charAt(indexLen - (indexLen - nxtpos1)) == '(') {
  341. temp += String.valueOf(args.charAt(k));
  342. addentry(1);
  343. roundopen++;
  344. k = readBrackets(args, indexLen - (indexLen - nxtpos1));
  345. } else if (Character.isDigit(args.charAt(k))) {
  346. k = IsDigit(args, k);
  347. addentry(digitvalue);
  348. } else if (Character.isUpperCase(args.charAt(k))) {
  349. j = k - 1;
  350. break;
  351. } else {
  352. j = k - 1;
  353. break;
  354. }
  355. }
  356. } else if (Character.isDigit(args.charAt(j)) && args.charAt(indexLen - (indexLen - nxtpos)) != ')') {
  357. j = IsDigit(args, j);
  358. addentry(digitvalue);
  359. } else if (Character.isUpperCase(args.charAt(j))) {
  360. newid = j;
  361. break;
  362. } else if (args.charAt(j) == '[' && args.charAt(indexLen - (indexLen - nxtpos)) == '(') {
  363. boxopen++;
  364. j = readBrackets(args, indexLen - (indexLen - nxtpos));
  365. } else if (args.charAt(j) == '[') {
  366. boxopen++;
  367. if (boxopen > 0) {
  368. if (!brentry.isEmpty()) {
  369. addToTempHash();
  370. tempindex++;
  371. }
  372. }
  373. j = readBrackets(args, j);
  374. } else if (args.charAt(j) == '(') {
  375. roundopen++;
  376. if (roundopen > 0) {
  377. if (!brentry.isEmpty()) {
  378. addToTempHash();
  379. tempindex++;
  380. }
  381. }
  382. j = readBrackets(args, j);
  383. } else if (args.charAt(j) == ')' && Character.isDigit(args.charAt(indexLen - (indexLen - nxtpos)))) {
  384. roundopen--;
  385. j = IsDigit(args, indexLen - (indexLen - nxtpos));
  386. if (boxopen == 0 && roundopen == 0) {
  387. if (!brentry.isEmpty()) {
  388. updateentry(brentry, digitvalue);
  389. tempindex = tempindex > 0 ? tempindex = tempindex - 1 : 0;
  390. if (!templist[tempindex].isEmpty())
  391. matchElementToUpdate(this.brentry, this.templist[tempindex]);
  392. else {
  393. //suffix=0;
  394. addToReactPro();
  395. }
  396. } else
  397. updateentry(reactpro[hmrpos][hmcpos], digitvalue);
  398. } else {
  399. updateentry(brentry, digitvalue);
  400. tempindex = tempindex > 0 ? tempindex = tempindex - 1 : 0;
  401. if (!templist[tempindex].isEmpty())
  402. matchElementToUpdate(brentry, templist[tempindex]);
  403. else {
  404. //suffix=0;
  405. addToReactPro();
  406. }
  407. }
  408. } else if (args.charAt(j) == ']' && Character.isDigit(args.charAt(indexLen - (indexLen - nxtpos)))) {
  409. boxopen--;
  410. j = IsDigit(args, indexLen - (indexLen - nxtpos));
  411. if (boxopen == 0 && roundopen == 0) {
  412. if (!brentry.isEmpty()) {
  413. updateentry(brentry, digitvalue);
  414. tempindex = tempindex > 0 ? tempindex = tempindex - 1 : 0;
  415. if (!templist[tempindex].isEmpty())
  416. matchElementToUpdate(brentry, templist[tempindex]);
  417. else {
  418. //suffix=0;
  419. addToReactPro();
  420. }
  421. } else
  422. updateentry(reactpro[hmrpos][hmcpos], digitvalue);
  423. } else {
  424. updateentry(brentry, digitvalue);
  425. tempindex = tempindex > 0 ? tempindex = tempindex - 1 : 0;
  426. if (!templist[tempindex].isEmpty())
  427. matchElementToUpdate(this.brentry, this.templist[tempindex]);
  428. else {
  429. suffix = 0;
  430. addToReactPro();
  431. }
  432. }
  433. } else if (args.charAt(j) == ')') {
  434. roundopen--;
  435. if (roundopen == 0 && boxopen == 0)
  436. addToReactPro();
  437. else {
  438. tempindex = tempindex > 0 ? tempindex = tempindex - 1 : 0;
  439. if (!templist[tempindex].isEmpty())
  440. matchElementToUpdate(brentry, templist[tempindex]);
  441. else {
  442. suffix = 0;
  443. addToReactPro();
  444. }
  445. }
  446. } else if (args.charAt(j) == ']') {
  447. boxopen--;
  448. if (roundopen == 0 && boxopen == 0)
  449. addToReactPro();
  450. else {
  451. tempindex = tempindex > 0 ? tempindex = tempindex - 1 : 0;
  452. if (!templist[tempindex].isEmpty())
  453. matchElementToUpdate(brentry, templist[tempindex]);
  454. else {
  455. suffix = 0;
  456. addToReactPro();
  457. }
  458. }
  459. }
  460. newid = j;
  461. }
  462. return newid;
  463. }
  464. //For reading the brackets expression
  465. private int readBrackets(String args, int idx) {
  466. for (int i = idx + 1, nxtpos = 0; i < args.length(); i++) {
  467. nxtpos = calculateNextPosition(i);
  468. if (Character.isUpperCase(args.charAt(i)) && Character.isUpperCase(args.charAt(indexLen - (indexLen - nxtpos)))) {
  469. temp = String.valueOf(args.charAt(i));
  470. addentry(1);
  471. } else if (Character.isUpperCase(args.charAt(i)) && args.charAt(indexLen - (indexLen - nxtpos)) == '[') {
  472. temp = String.valueOf(args.charAt(i));
  473. addentry(1);
  474. addToTempHash();
  475. tempindex++;
  476. boxopen++;
  477. //suffix=1;
  478. i = readBrackets(args, indexLen - (indexLen - nxtpos));
  479. } else if (Character.isUpperCase(args.charAt(i)) && args.charAt(indexLen - (indexLen - nxtpos)) == '(') {
  480. temp = String.valueOf(args.charAt(i));
  481. addentry(1);
  482. addToTempHash();
  483. tempindex++;
  484. roundopen++;
  485. //suffix=1;
  486. i = readBrackets(args, indexLen - (indexLen - nxtpos));
  487. } else if (Character.isUpperCase(args.charAt(i)) && args.charAt(indexLen - (indexLen - nxtpos)) == ')') {
  488. temp = String.valueOf(args.charAt(i));
  489. addentry(1);
  490. i = readLower(args, i);
  491. i = i - 1;
  492. } else if (Character.isUpperCase(args.charAt(i)) && args.charAt(indexLen - (indexLen - nxtpos)) == ']') {
  493. temp = String.valueOf(args.charAt(i));
  494. addentry(1);
  495. i = readLower(args, i);
  496. i = i - 1;
  497. } else if (args.charAt(i) == '(') {
  498. roundopen++;
  499. if (!brentry.isEmpty()) {
  500. addToTempHash();
  501. tempindex++;
  502. }
  503. continue;
  504. } else if (args.charAt(i) == '[') {
  505. boxopen++;
  506. if (!brentry.isEmpty()) {
  507. addToTempHash();
  508. tempindex++;
  509. }
  510. continue;
  511. } else if (Character.isUpperCase(args.charAt(i))) {
  512. temp = String.valueOf(args.charAt(i));
  513. i = readLower(args, i);
  514. i = i - 1;
  515. }
  516. newid = i;
  517. }
  518. return newid;
  519. }
  520. //This function is used for adding elements in the respective hashmap considering whether any box brackets or round brackets
  521. //are open if not then add the elements to the reactpro hashmap
  522. private void addentry(int value) {
  523. if (boxopen > 0) {
  524. keyexists = brentry.containsKey(temp);
  525. if (roundopen > 0) {
  526. if (keyexists == false)
  527. brentry.put(temp, new Integer(value));
  528. else
  529. updateKeyValue(temp, value, brentry);
  530. } else {
  531. if (keyexists == false)
  532. brentry.put(temp, new Integer(value));
  533. else
  534. updateKeyValue(temp, value, brentry);
  535. }
  536. } else if (roundopen > 0) {
  537. keyexists = brentry.containsKey(temp);
  538. if (keyexists == false)
  539. brentry.put(temp, new Integer(value));
  540. else
  541. updateKeyValue(temp, value, brentry);
  542. } else {
  543. keyexists = reactpro[hmrpos][hmcpos].containsKey(temp);
  544. if (keyexists == false)
  545. reactpro[hmrpos][hmcpos].put(temp, new Integer(value));
  546. else
  547. updateKeyValue(temp, value, reactpro[hmrpos][hmcpos]);
  548. }
  549. }
  551. //This function are called when the Box or Round brackets opens we are adding it to the templist hashtable
  552. //when anyother round or box bracket gets opened
  553. private void addToTempHash() {
  554. Enumeration keys = brentry.keys();
  555. while (keys.hasMoreElements()) {
  556. Object retrievedKey = keys.nextElement();
  557. templist[tempindex].put(retrievedKey, brentry.get(retrievedKey));
  558. }
  559. brentry.clear();
  560. }
  561. //For calculating the no of digits after the element.
  562. private int IsDigit(String args, int idx) {
  563. String variable = "";
  564. int newid2 = 0;
  565. for (int k = idx; k < fullLen; k++) {
  566. if (Character.isDigit(args.charAt(k))) {
  567. variable += String.valueOf(args.charAt(k));
  568. newid2 = k;
  569. } else {
  570. newid2 = k - 1;
  571. break;
  572. }
  573. }
  574. newid = newid2;
  575. if (variable.equals("") || variable.equals("0"))
  576. digitvalue = 1;
  577. else
  578. digitvalue = Integer.parseInt(variable);
  579. return newid;
  580. }
  581. //For updating the key value stored in the hashtable with that of the value specified after the round or box bracket
  582. protected void updateentry(Hashtable h, int value) {
  583. Enumeration keys = h.keys();
  584. while (keys.hasMoreElements()) {
  585. Object retrievedKey = keys.nextElement();
  586. h.put(retrievedKey, (Object) String.valueOf(Integer.parseInt(String.valueOf(h.get(retrievedKey))) * value));
  587. }
  588. }
  589. //This function is called when any box or round brackets gets closed we are updating the brentry hashtable
  590. //with that of the templist hashtable also checking before adding whether any key exists or not.If exists we are updating the key value
  591. // with that of brentry hashtable and templist hashtable. And also finally adding it to the final hashtable.
  592. public void matchElementToUpdate(Hashtable a, Hashtable b) {
  593. //If a hashmap is empty and the b is not empty then directly copy all the elements from hashmap b to hashmap a
  594. yesno = a.isEmpty() && !b.isEmpty() ? true : false;
  595. if (yesno == true)
  597. {
  598. Enumeration keys = b.keys();
  599. while (keys.hasMoreElements()) {
  600. Object retrievedKey = keys.nextElement();
  601. a.put(retrievedKey, b.get(retrievedKey));
  602. }
  603. } else {
  604. Enumeration keys1 = a.keys();
  605. while (keys1.hasMoreElements()) {
  606. Object retrievedKey1 = keys1.nextElement();
  607. Enumeration keys2 = b.keys();
  608. while (keys2.hasMoreElements()) {
  609. Object retrievedKey2 = keys2.nextElement();
  610. if (a.containsKey(retrievedKey2)) {
  611. if (retrievedKey1.equals(retrievedKey2)) {
  612. int result = Integer.parseInt(String.valueOf(a.get(retrievedKey1))) + Integer.parseInt(String.valueOf(b.get(retrievedKey2)));
  613. a.put(retrievedKey1, (Object) String.valueOf(result));
  614. b.remove(retrievedKey2);
  615. }
  616. } else {
  617. a.put(retrievedKey2, b.get(retrievedKey2));
  618. b.remove(retrievedKey2);
  619. }
  620. }
  621. }
  622. }
  623. b.clear();
  624. }
  625. private void addToReactPro() {
  626. Enumeration keys = brentry.keys();
  627. while (keys.hasMoreElements()) {
  628. Object retrievedKey = keys.nextElement();
  629. keyexists = reactpro[hmrpos][hmcpos].containsKey(retrievedKey);
  630. if (keyexists == false)
  631. reactpro[hmrpos][hmcpos].put(retrievedKey, brentry.get(retrievedKey));
  632. else {
  633. int value = Integer.parseInt(String.valueOf(brentry.get(retrievedKey)));
  634. updateKeyValue(String.valueOf(retrievedKey), value, reactpro[hmrpos][hmcpos]);
  635. }
  636. }
  637. brentry.clear();
  638. }
  639. private void updateKeyValue(String key, int newVal, Hashtable h) {
  640. Enumeration keys = h.keys();
  641. while (keys.hasMoreElements()) {
  642. Object retrievedKey = keys.nextElement();
  643. if (retrievedKey.equals(key)) {
  644. if (suffix != 0) {
  645. h.put(retrievedKey, String.valueOf(Integer.parseInt(String.valueOf(h.get(retrievedKey))) * newVal));
  646. suffix = 0;
  647. } else
  648. h.put(retrievedKey, String.valueOf(Integer.parseInt(String.valueOf(h.get(retrievedKey))) + newVal));
  649. break;
  650. }
  651. }
  652. } //This function will return the atomic weight of that particular element which is stored in the hm hashmap
  653. //which is acting as a database in our case.
  654. private double getMolWeight(String key) {
  655. double value = 0;
  656. Enumeration keys = hm.keys();
  657. while (keys.hasMoreElements()) {
  658. Object retrievedKey = keys.nextElement();
  659. if (retrievedKey.equals(key)) {
  660. value = Double.parseDouble(String.valueOf(hm.get(retrievedKey)));
  661. break;
  662. }
  663. }
  664. return value;
  665. }
  666. //For calculating the molecular weight of the expression and for storing the molecular weight as per the compounds
  667. //in the mol_weight variable at a particular row and at a particular's column
  668. protected void calculateMolWeight(int rindex, int cindex) {
  669. finaloutput = 0;
  670. Enumeration keys = reactpro[rindex][cindex].keys();
  671. while (keys.hasMoreElements()) {
  672. Object retrievedKey = keys.nextElement();
  673. output = getMolWeight(String.valueOf(retrievedKey));
  674. finaloutput += output * Integer.parseInt(String.valueOf(reactpro[rindex][cindex].get(retrievedKey)));
  675. }
  676. System.out.println(finaloutput);
  677. }
  678. public static void main(String args[]) {
  679. ElementCalculation obj = new ElementCalculation();
  680. obj.setInitialValues();
  681. obj.accept();
  682. }
  683. }