Using HashMap object to convert text to integer value

[Sudhir Srinivasan]

Hi,

My program objective is to convert text into its corresponding int form, perform arithmetic operation [in this case add & then multiply] and display the result.
To implement this, the program uses a map object with String, Integer as its key, Value pair.

Please find the program

package testEvenMore.myPrograms;

import java.util.*;

public class TestNaturalLanguageMultiply3 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	
        //To take two user inputs	
	String inp1 = "";	
	String inp2 = "";
	String choice = "";//to run or terminate program

	System.out.println("Enter 'Y' to continue OR 'N' to exit program: ");
	Scanner scan = new Scanner(System.in);
	while(!(choice = scan.nextLine()).equalsIgnoreCase("n")) {//loop till user inputs 'n'
	System.out.println("Enter integer value 1 (as text) between" +
	" 0 to 99: ");
	new Scanner(System.in);
	inp1 = scan.nextLine();//take input & advance scanner to end of current line and set position at next line

	System.out.println("Enter integer value 2 (as text) between" +
	" 0 to 99: ");
	new Scanner(System.in);
	inp2 = scan.nextLine();
	
    //create a new HashMap object at run-time mapping String object to integer value
    Map<String, Integer> map = new HashMap<String, Integer>();
//create a String[] of size 100 containing text from "zero" to "ninety-nine"
	String[] str = 
	{"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
	 "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen",
	 "twenty", "twenty-one", "twenty-two", "twenty-three", "twenty-four", "twenty-five", "twenty-six", "twenty-seven", "twenty-eight", "twenty-nine", 
      "thirty", "thirty-one", "thirty-two", "thirty-three", "thirty-four", "thirty-five", "thirty-six", "thirty-seven", "thirty-eight", "thirty-nine",
  	 "forty", "forty-one", "forty-two", "forty-three", "forty-four", "forty-five", "forty-six", "forty-seven", "forty-eight",	"forty-nine",
	 "fifty", "fifty-one", "fifty-two", "fifty-three", "fifty-four", "fifty-five",	"fifty-six", "fifty-seven", "fifty-eight", "fifty-nine",
	 "sixty", "sixty-one", "sixty-two",	"sixty-three", "sixty-four", "sixty-five",	"sixty-six",	"sixty-seven", "sixty-eight",	"sixty-nine",
	 "seventy",	"seventy-one",	"seventy-two",	"seventy-three", "seventy-four", "seventy-five", "seventy-six", "seventy-seven", "seventy-eight", "seventy-nine",
	 "eighty", "eighty-one", "eighty-two", "eighty-three", "eighty-four", "eighty-five", "eighty-six", "eighty-seven", "eighty-eight", "eighty-nine",
	 "ninety", "ninety-one", "ninety-two", "ninety-three", "ninety-four", "ninety-five", "ninety-six", "ninety-seven", "ninety-eight", "ninety-nine"
	 };
	
        //loop thru the String[] and map each String object to its corresponding value
	for(int i = 0; i < str.length; i++) {
		map.put(str[i], i);
	}
        //Assign user inputs to respective string variables
	String num1 = inp1;
	String num2 = inp2;
	/*int values to store mapped (& added in the case of hyphenated / with space words) values of either single text OR hyphenated words OR 
           words with space inbetween*/
	int addSplitNum = 0;
	int addSplitNum1 = 0;
	//Split String inputs [containing hyphen or space] into String[] of size 2
	String[] splitNum = new String[2];

        /*For condition 1: loop thru the String[] str. On getting String equality [user input with
           specific array element], map the loop incrementor to the user input. Finally, retrieve the mapped value & store
           in int variable*/
        /*For conditions 2 & 3: additionally loop thru String[] splitNum containing the words [post splitting of           
           hyphenated text or text with space] and add the mapped values of each array element of splitNum
           For ex: twenty-two OR twenty two split, assigned values corresponding to twenty & two and then 
           sum of twenty & two*/
        //Checking for condition 1 - single text: 
	if(!num1.contains("-") || !num1.contains(" ")) {
		  for(int i = 0; i < str.length; i++) {
			if(num1.equalsIgnoreCase(str[i])) {
				map.put(num1, i);
				addSplitNum = map.get(num1);
				break;
			}
		}
	   }if(num1.contains("-")) {//Checking for condition 2 - hyphenated words:
		splitNum = num1.split("-");//hyphen as delimiter
		for(int i = 0; i < splitNum.length; i++) {
			for(int j = 0; j < str.length; j++) {
				if(splitNum[i].equalsIgnoreCase(str[j])) {
					map.put(splitNum[i], j);
					addSplitNum = map.get(splitNum[i]) + addSplitNum;
					break;
				}
			}
		}
	   }if(num1.contains(" ")) {//Checking for condition 3 - words with space inbetween:
			splitNum = num1.split(" ");//space as delimiter
			for(int i = 0; i < splitNum.length; i++) {
				for(int j = 0; j < str.length; j++) {
					if(splitNum[i].equalsIgnoreCase(str[j])) {
						map.put(splitNum[i], j);
						addSplitNum = map.get(splitNum[i]) + addSplitNum;
						break;
					}
				}
			}
		}if(!num2.contains("-") || !num2.contains(" ")) {//--ditto-- as num1
			  for(int i = 0; i < str.length; i++) {
				if(num2.equalsIgnoreCase(str[i])) {
					map.put(num2, i);
					addSplitNum1 = map.get(num2);
					break;
				}
			}
		}if(num2.contains("-")) {//--ditto-- as num1
	     splitNum = num2.split("-");
	     for(int i = 0; i < splitNum.length; i++) {
		   for(int j = 0; j < str.length; j++) {
			if(splitNum[i].equalsIgnoreCase(str[j])) {
				map.put(splitNum[i], j);
				addSplitNum1 = map.get(splitNum[i]) + addSplitNum1;
				break;
			    }
		      }
	        }
        }if(num2.contains(" ")) {//--ditto-- as num1
		 splitNum = num2.split(" ");
		 for(int i = 0; i < splitNum.length; i++) {
			for(int j = 0; j < str.length; j++) {
				if(splitNum[i].equalsIgnoreCase(str[j])) {
					map.put(splitNum[i], j);
					addSplitNum1 = map.get(splitNum[i]) + addSplitNum1;
					break;
				 }
			  }
		   }
	     }
	System.out.println(num1+" * "+num2+" = "+addSplitNum * addSplitNum1);
	System.out.println("Enter 'Y' to continue OR 'N' to exit program: ");
	 }
   }		
}

and its output
Enter 'Y' to continue OR 'N' to exit program:
y
Enter integer value 1 (as text) between 0 to 99:
ten
Enter integer value 2 (as text) between 0 to 99:
sixteen
ten * sixteen = 160..........correct

Enter 'Y' to continue OR 'N' to exit program:
y
Enter integer value 1 (as text) between 0 to 99:
forty
Enter integer value 2 (as text) between 0 to 99:
five
forty * five = 200..........correct

Enter 'Y' to continue OR 'N' to exit program:
y
Enter integer value 1 (as text) between 0 to 99:
sixty six
Enter integer value 2 (as text) between 0 to 99:
two
sixty six * two = 132..........correct

Enter 'Y' to continue OR 'N' to exit program:
y
Enter integer value 1 (as text) between 0 to 99:
two
Enter integer value 2 (as text) between 0 to 99:
sixty six
two * sixty six = 132..........correct

Enter 'Y' to continue OR 'N' to exit program:
y
Enter integer value 1 (as text) between 0 to 99:
sixty six
Enter integer value 2 (as text) between 0 to 99:
sixty six
sixty six * sixty six = 4356..........correct

Enter 'Y' to continue OR 'N' to exit program:
y
Enter integer value 1 (as text) between 0 to 99:
sixty-six
Enter integer value 2 (as text) between 0 to 99:
two
sixty-six * two = 264..........incorrect

Enter 'Y' to continue OR 'N' to exit program:
y
Enter integer value 1 (as text) between 0 to 99:
two
Enter integer value 2 (as text) between 0 to 99:
sixty-six
two * sixty-six = 264..........incorrect

Enter 'Y' to continue OR 'N' to exit program:
y
Enter integer value 1 (as text) between 0 to 99:
sixty-six
Enter integer value 2 (as text) between 0 to 99:
sixty-six
sixty-six * sixty-six = 17424..........incorrect

Enter 'Y' to continue OR 'N' to exit program:
n

For your better understanding, the program:

takes input from the user two int values in text form

creates a String[] str, of size 100, having String elements "zero","one", "two",............,"ninety-nine"

creates a Map object map whose run-time implementation is HashMap which maps String object to Integer value

loops thru the String[] str and assigns the int value corresponding to each array element [being the key-value pair]

creates another String[] splitNum, of size 2, to split user input [read as String] having hyphenated words

checks [i know too many if statements ]whether user input contains single text OR hyphenated words OR words with
space inbetween [assuming the user forgets to hyphenate two word text]

Post splitting of hyphenated words, within the for loop, assigns values to each string before & after the hyphen, sums
them and then multiplies result [of user input 1] with the result of user input 2

Finally, displays the result on the screen

Issue faced:
The issue arises when checking for either of the user input(s) for hyphen. Somehow, the map object doubles the values mapped to the corresponding text - is
the object duplicating the keys? If so, this contravenes its javadoc - and displays the
same in the output [therefore reason for my writing on this forum as I'm unable to resolve on my own], whereas the if condition checking for space
returns the correct result!

My queries:
a) Is the problem in the lines of code 77 to 87 and 107 to 117 for either of the inputs OR elsewhere in the code that returns incorrect result for hyphenated words??
b) Could anyone suggest alternatives to the many if statements in the code.

Much appreciated if any of the forum experts could help in identifying the error(s) and resolving the same.

Thanks,
Sudhir

[Matthew Brown]

I haven't trawled through the rest of the logic, but this bit looks strange to me:

if(!num1.contains("-") || !num1.contains(" "))

That means "if it doesn't contain a hyphen or it doesn't contain a space". Is that really what you want? That will be true for every input you've shown, and is only false for inputs that contain both.

[Richard Tookey]

Why not just remove all spaces and hyphens from the input supplied by the user and from the keys when generating the map. Keep the hyphens in the arrays though so you can display the result with hyphens. This way you just have to replace all spaces or hyphens with the empty string; a simple one line regular expression.

[Campbell Ritchie]

You have a contradiction in the specification you wrote out. In one place you say “sixty six” and in another “ninety-nine”. Please check that.
You can use the replace methods of the String class, and maybe toLowerCase, too, to convert sIxTy     sIX to sixty‑six.

Why are you trying to put things in the map after using String#split? You have got all things out of order. Start by reducing the main method to its ideal length: 1 statement. Create a class or some classes which will encapsulate your logic. One will have the Map as a field. Create methods to input the two numbers and the operator, and to do the calculation. Don't try to do the whole thing all at once. Do it in bits, and write methods which test each part before the app is complete.

[Sudhir Srinivasan]

Thank you Matthew, Richard and Campbell for your prompt responses.

As you have quite a few suggestions for modifying and improving the program code, will need some time for the same. Will revert with modified code once completed.

Regards,
Sudhir

[Sudhir Srinivasan]

As per Richard's suggestion

Richard Tookey wrote:Why not just remove all spaces and hyphens from the input supplied by the user and from the keys
when generating the map.......... This way you just have to replace all spaces or hyphens with the empty string; a simple
one line regular expression.

this pseudocode (of sorts, if one may call that)

a) for the removal of hyphens / spaces at the time of generating the map

.. create another HashMap object say tempMap that maps String to Integer being <key, value> pair
.. create an empty String key (key being variable name)
.. Iteratively, for each Map Entry (key-value pair) entry in the entrySet of the original HashMap object map
.. (variable) key to be stored with the key object from the key-value pair of each Map entry
.. if variable key does not contain any null value, if true
            replace the key object (stored in variable key) containing hyphen or space with the empty String
.. add the variable key (containing the modified key objects) along with their corresponding values (retrieved from       
   entry) to the new map object mentioned in step 1
.. end of iteration

b) for the calculation part

.. Iteratively, for each String output (output being variable name) in the keySet of tempMap
            check for String equality of user input 1 with output. If true
            do the calculation
.. for user input 2, ditto as step 1
.. product of the two results is displayed on the screen

provided would display the result without bothering about hyphens / spaces in the text (user input to omit hyphens /
spaces for ex: twentyfive, seventytwo etc..etc..etc). The code derived from this (hope the pseudocode is not complex or
incomprehensible) replaces the lines of code 58 to 130 in my original posting. It certainly shortens the code from 72 lines to approx. 20 lines.

and output from program

Enter 'Y' to continue OR 'N' to exit program: 
y
Enter integer value 1 (as text) between 0 to 99: 
sixtysix
Enter integer value 2 (as text) between 0 to 99: 
two
result = 132........correct

Enter 'Y' to continue OR 'N' to exit program: 
y
Enter integer value 1 (as text) between 0 to 99: 
five
Enter integer value 2 (as text) between 0 to 99: 
seventyseven
result = 385........correct

Enter 'Y' to continue OR 'N' to exit program: 
y
Enter integer value 1 (as text) between 0 to 99: 
eightyone
Enter integer value 2 (as text) between 0 to 99: 
eightyone
result = 6561........correct

Enter 'Y' to continue OR 'N' to exit program: 
n

To further refine the code, will work on Campbell's suggestions

Campbell Ritchie wrote: Start by reducing the main method to its ideal length: 1 statement. Create a class or some classes which will encapsulate your logic. One will have the Map as a field. Create methods to input the two numbers and the operator, and to do the calculation...........

(adhering to java fundamental, OOP) and revert.

[Richard Tookey]

Since you will only ever lookup an integer using the alpha representation of the integer you only need one Map<String,Integer>. That use as key the normalised alpha representation with hyphens and spaces removed (a simple regex will do this) and converted to lower case (or upper if you prefer). The Map can be generated from the arrays of alpha representation without the need to check whether or not a key is already being used since you will make sure the arrays do not contain duplicate values.

When an alpha representation is supplied your just normalise it an look it up in the Map<String,Integer> to get the numeric value.

[Sudhir Srinivasan]

Campbell Ritchie wrote:
Why are you trying................ Don't try to do the whole thing all at once. Do it in bits, and write
methods which test each part before the app is complete.

From Campbell's suggestions,

the Pseudocode [for OOP based application]

Superclass or Parent class:
- Create a java class, say GetValues, for the 2 user inputs
- GetValues to contain two String fields, say input1 and input2. Each field to store and return the user inputs
- Define default and parameterised constructors [will understand soon reason for the constructors]
    ..  fields / variables initialized to their default values within default constructor
    ..  two variables [same as class variables] passed to the parameterised constructor & assigned to the class variables
- setter & getter methods generated from the class variables

Subclass or Child class:
- Create another class, say MapTextToInt, which extends GetValues
- MapTextToInt to contain a single field / variable i.e a map object mapping String to Integer
- define default constructor. Within constructor,
    ..  explicit call to parent constructor//optional. Else, compiler implicitly invokes default parent constructor
    ..  field map to be initialized by a run-time HashMap implementation
- define parameterised constructor. Within constructor,
    ..  explicit call to corresponding parent constructor/*compulsory. Attributes of GetValues inherited in addition to this
        class' map object*/
- generate setter & getter for the map field which take in and return a map object respectively
- setter method
    ..  create local variables that correspond to the map object's key-value pair
    ..  Iteratively, for each Map Entry (key-value pair) entry in the entrySet of the original HashMap object map
    ..  key to be stored with the key object from the key-value pair of each Map entry
    ..  add the variable key (containing the modified key objects) along with their corresponding values (retrieved from         
        entry) to the map object
    ..  end Iteration
    ..  map is set
- getter method
    ..  return the map object set
- attributes inherited from GetValues
   - getter method 1: 
      .. Iteratively, for each String output [output being variable name] in the keySet of tempMap
      .. check for String equality of user input 1[access & get superclass method] with output. If true
      .. do the calculation
      .. end Iteration
      .. return result
   - getter method 2: 
      .. ditto as getter method 1

Class with Main method:
- Create class, say TestNaturalLanguageMultiply, being entry point for execution of application
  //Below static fields created as I wanted to access the same from within this class. 
- create static map object [variable], say sendMap, whose type & run-time implementation corresponds to the map object in  
  MapTxtToInt
- create static variable, say str, being a String[] 
    ..  private static String[] str = 
               {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
		 "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", 
                 "nineteen", "twenty", "twentyone", "twentytwo", "twentythree", "twentyfour", "twentyfive", "twentysix", 
                 "twentyseven", "twentyeight", "twentynine", "thirty", "thirtyone", "thirtytwo", "thirtythree", "thirtyfour",	
                 "thirtyfive", "thirtysix", "thirtyseven", "thirtyeight", "thirtynine", "forty",	"fortyone", "fortytwo",	"fortythree",	
                 "fortyfour", "fortyfive", "fortysix", "fortyseven", "fortyeight", "fortynine", "fifty", "fiftyone", "fiftytwo",	
                 "fiftythree", "fiftyfour", "fiftyfive", "fiftysix", "fiftyseven", "fiftyeight", "fiftynine", "sixty", "sixtyone",	
                 "sixtytwo", "sixtythree", "sixtyfour", "sixtyfive", "sixtysix",	"sixtyseven", "sixtyeight", "sixtynine", 
                 "seventy",	"seventyone", "seventytwo", "seventythree", "seventyfour", "seventyfive", "seventysix", 
                 "seventyseven", "seventyeight", "seventynine", "eighty", "eightyone", "eightytwo", "eightythree", 
                 "eightyfour", "eightyfive", "eightysix", "eightyseven", "eightyeight", "eightynine", "ninety", "ninetyone",
                 "ninetytwo","ninetythree", "ninetyfour", "ninetyfive", "ninetysix", "ninetyseven", "ninetyeight", "ninetynine"
		 };
          initialized by array element values shown.
- Within the main method
   .. Declare two string variables
   .. Create a Scanner object to take input from the keyboard
   .. No. of inputs to be 2 and in text form. For ex:
      input 1: ninetynine//input to omit space / hyphen inbetween words
      input 2: eighty
   .. Create instance of subclass[MapTxtToInt], say getMapped
   .. Using this object, set the respective user inputs
   .. Add the key-value pairs of sendMap object by looping thru the String[] str
   .. Again, using the instance getMapped, set this map object sendMap
   .. Use getMapped to get the results thru the getters of MapTxtToInt. Product of these two gives the final result
   .. Print to screen

and its program output

Enter integer value 1 (as text) between 0 to 99: 
ninetynine
Enter integer value 2 (as text) between 0 to 99: 
eighty
ninetynine * eighty = 7920

Enter integer value 1 (as text) between 0 to 99: 
four
Enter integer value 2 (as text) between 0 to 99: 
fortyeight
four * fortyeight = 192

Please Note:

All classes to be within the same package of the project.

Fields / variables within the classes to be private & accessible only thru their respective methods.

I hope the pseudocode is not incomprehensible and complicated. Although a trifle lengthy [in my attempt at ease &
simplicity], I think it can be translated to actual code without too much effort.

I've modified the String[] to contain values without hyphens / spaces corresponding to user inputs. An update to the pseudocode would be
to incorporate hyphens / spaces to be matched to the user inputs

Richard Tookey wrote:Since you will only ever lookup an integer using the alpha representation of the integer you only need one
Map<String,Integer>. That use as key the normalised alpha representation with hyphens and spaces removed (a simple regex will do this)............

by way of a simple regex expression as suggested by Richard. Will post the same on completion.

[Richard Tookey]

Sudhir Srinivasan wrote:

Richard Tookey wrote:Since you will only ever lookup an integer using the alpha representation of the integer you only need one
Map<String,Integer>. That use as key the normalised alpha representation with hyphens and spaces removed (a simple regex will do this)............

by way of a simple regex expression as suggested by Richard. Will post the same on completion.

You don't need to modify the String[] containing the alpha representations! You just need to normalise each one when using it as a key in the Map! You normalise the String[] entry when building the Map and you normalise the user's input when looking up the value in the Map.

[Sudhir Srinivasan]

Okay. I think I've got it. Modifying the Pseudocode in my previous post

Richard Tookey wrote:You don't need to modify the String[] containing the alpha representations!

the String[] str containing the original values (with hyphens / space).

private static String[] str = 
		{"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
		 "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen",
		 "twenty", "twenty-one", "twenty-two", "twenty-three", "twenty-four", "twenty-five", "twenty-six", "twenty-seven", "twenty-eight", "twenty-nine",
		 "thirty", "thirty-one",	"thirty-two", "thirty-three",	"thirty-four", "thirty-five", "thirty-six", "thirty-seven", "thirty-eight",	 "thirty-nine",
		 "forty", "forty-one", "forty-two", "forty-three", "forty-four", "forty-five", "forty-six",	"forty-seven", "forty-eight",	"forty-nine",
		 "fifty", "fifty-one", "fifty-two", "fifty-three", "fifty-four",	"fifty-five",	"fifty-six",	"fifty-seven", "fifty-eight", "fifty-nine",
		 "sixty", "sixty one", "sixty two", "sixty three", "sixty four", "sixty five", "sixty six", "sixty seven", "sixty eight", "sixty nine",
		 "seventy", "seventy one",	"seventy two", "seventy three", "seventy four", "seventy five", "seventy six",	"seventy seven", "seventy eight", "seventy nine",
		 "eighty", "eighty one", "eighty two", "eighty three", "eighty four",	"eighty five", "eighty six", "eighty seven", "eighty eight", "eighty nine",
		 "ninety", "ninety one", "ninety two", "ninety three", "ninety four", "ninety five", "ninety six", "ninety seven", "ninety eight", "ninety nine"
		 };

Richard Tookey wrote:You just need to normalise each one when using it as a key in the Map! You normalise the String[]
entry when building the Map

At the time of building the map object sendMap, by looping thru the String[] str & adding the key-value pairs to this object, replace each
array element - containing hyphen / space - with empty string. Converts all the text, within the map, into a common form with the
corresponding values.

Richard Tookey wrote:
and you normalise the user's input when looking up the value in the Map.

In the GetValues class, when setting the respective field within the setter method, replace the hyphen / space with empty
string. Converts the user input to a common form.

In the MapTxtToInt class,

just set (& return) the (normalized) map object sendMap passed from TestNaturalLanguageMultiply

within the getter methods,

Sudhir Srinivasan wrote:
- attributes inherited from GetValues
- getter method 1:
.. Iteratively, for each String output [output being variable name] in the keySet of tempMap
.. check for String equality of user input 1[access & get superclass method] with output. If true..........

check for String equality of normalized user input with that of the keySet of the normalized map object. If true,
get the values corresponding to the same & do the calculation.

This obviates the need

for creating a separate map object and also

for lines of pseudocode [12-17] of MapTxtToInt in my previous post

[sidebar]
If I've still not got it right (*sigh*), could you please provide the sample code (Richard, a big thank you for your time
and patience) that simplifies my program as suggested.[/sidebar]

Program output:

Enter integer value 1 (as text) between 0 to 99: 
ninety nine
Enter integer value 2 (as text) between 0 to 99: 
ninety-nine
ninety nine * ninety-nine = 9801

Enter integer value 1 (as text) between 0 to 99: 
thirty-three
Enter integer value 2 (as text) between 0 to 99: 
thirty three
thirty-three * thirty three = 1089

[Richard Tookey]

Sudhir Srinivasan wrote:Okay. I think I've got it.

Well done. Though I can't see your latest code so I can't be certain it does seem you have got it right now..

[Sudhir Srinivasan]

Richard Tookey wrote:Though I can't see your latest code so I can't be certain....

The updated code snippets based on my understanding of your suggestions.

Sudhir Srinivasan wrote:At the time of building the map object sendMap, by looping thru
the String[] str & adding the key-value pairs to this object,...

Richard Tookey wrote:You
just need to normalise each one when using it as a key in the Map! You normalise the String[]
entry when building the Map...

//from the main class TestNaturalLanguageMultiply
/*create an instance of MapTxtToInt class. 
  MapTxtToInt subclass of GetValues (superclass).
  Use the object getMapped to pass & set both user inputs
  within setter methods of GetValues inherited by MapTxtToInt.*/
MapTxtToInt getMapped = new MapTxtToInt();
getMapped.setInp1(inp1);
getMapped.setInp2(inp2);
for(int i = 0; i < str.length; i++) {
/*map object sendMap built by replacing each key (containing hyphen / space) with
empty string. Brings all keys within sendMap into common form*/
	sendMap.put(str[i].replace("-", "").replace(" ", ""), i);
   }
	getMapped.setMap(sendMap);//normalized map object sendMap passed to
MapTxtToInt class

Sudhir Srinivasan wrote:In the GetValues class, when setting the respective field
within the setter method,....

Richard Tookey wrote:and you normalise the user's input
when looking up the value in the Map.

/*replacing hyphens and spaces with empty string, within the setter methods,
at the time of setting user inputs*/
public void setInp1(String inp1) {
       this.inp1 = inp1.replace("-", "").replace(" ", "");
}

public void setInp2(String inp2) {
       this.inp2 = inp2.replace("-", "").replace(" ", "");
}

Sudhir Srinivasan wrote:In the MapTxtToInt class,

just set (& return) the (normalized) map object sendMap passed from
TestNaturalLanguageMultiply....

......check for String equality of normalized user input with that of the keySet
of the normalized map object.

Richard Tookey wrote:and you normalise the user's input when looking up
the value in the Map.

/*setter method of MapTxtToInt class set  with the normalized 
map object sendMap passed from main class TestNaturalLanguageMultiply.
field map, of this class, is an object whose type and 
run-time implementation is same as sendMap.*/
public void setMap(Map<String, Integer> sendMap) {
	map = sendMap;	
}

public Map<String, Integer> getMap() {
	return map;//normalized map object returned
}
/*getter method, for user input 1, of GetValues (superclass) inherited by subclass 
MapTxtToInt. Ditto for user input 2*/
public String getInp1() {
	int addSplitNum = 0;
	String result = "";
	for(String output:map.keySet()) {//deriving the normalized keys from the map object map
/*check for String equality of user input and that of the keys from KeySet of map,
post removal of hyphens and spaces*/
	       if(super.getInp1().equalsIgnoreCase(output)) {
                //retrieve the value corresponding to the key and calculate
		addSplitNum = map.get(output) + addSplitNum;
		  }
	}
	result = String.valueOf(addSplitNum);
	return result;
}

[Winston Gutkowski]

Sudhir Srinivasan wrote:The updated code snippets based on my understanding of your suggestions.

Sudhir,

It's too late for this thread, I suspect, but for future reference: Please DontWriteLongLines.
It makes your thread very hard to read, and it's actually bad coding practice. Please remember in future:
80 characters max.
(the SSCCE page actually recommends 62)
And that includes string literals AND comments AND long method calls.

Thanks.

Winston

[Sudhir Srinivasan]

Winston Gutkowski wrote:

Sudhir Srinivasan wrote:The updated code snippets based on my understanding of your suggestions.

Sudhir,

It's too late for this thread, I suspect, but for future reference: Please DontWriteLongLines.

Hi Winston,
I've edited my last post and shortened the lines as suggested.

I shall certainly keep your suggestions in mind when posting in the future. Any inconvenience caused to the moderators / responder(s)
is regretted.

Regards,
Sudhir

[Winston Gutkowski]

Sudhir Srinivasan wrote:Hi Winston,
I've edited my last post and shortened the lines as suggested.
I shall certainly keep your suggestions in mind when posting in the future. Any inconvenience caused to the moderators / responder(s)
is regretted.

No probs. It's as much for you as it is for us; and I'm afraid that it's not just your last post.

Do you find looking at that first post of yours restful? I don't.

You might want to have a look at this page; except change the 120
in section 1.4 to 80.

Back in the dark ages, coding sheets were 80 characters long; and I reckon it's still a good rule of thumb to stick to.

HIH

Winston