We Keep Coding

Java, how do you have a user enter their values in one line with no spaces?

I'm new to learning java. My current assignment is to have the user enter the values they want with an operator and come out with a result on one line with no spaces.
I figured out most of the code, but I'm having trouble running it without adding the spaces.
For example:
1 + 1 = 2 (This will work)
1+1 (this causes an error)
Here is my code:
import java.util.Scanner;
public class Mod2 {
Scanner sc = new Scanner(System.in);
static int value1;
static int value2;
static int result;
String input = "";
public static void main(String[] args){
Mod2 m = new Mod2();
System.out.println("Beginning Application");
System.out.println("Enter expression like [value][operator][value2] no spaces");
value1 = m.sc.nextInt();
String input = m.sc.next();
value2 = m.sc.nextInt();
switch (input) {
case "+":
result = (value1 + value2);
System.out.println(result);
break;
case "-":
result = (value1 - value2);
System.out.println(result);
break;
case "*":
result = (value1 * value2);
System.out.println(result);
break;
case "/":
result = (value1 / value2);
System.out.println(result);
break;
case "%":
result = (value1 % value2);
System.out.println(result);
break;
}
System.out.println("Ending application");
System.exit(0);
}
}

You can split the input string by the operator then use the first half of that string as value 1 then second half as value 2.
input.split("-"); // you can use a regex expression here to check for the existence of the operator
...
String input = m.sc.next();
String[] operation = input.split("(?<=\\d)(?=\\D)|(?<=\\D)(?=\\d)");
Integer value1 = Integer.parseInt(operation[0]);
Integer value2 = Integer.parseInt(operation[2]);
switch (operation[1]) {
case "+":
result = (value1 + value2);
break;
case "-":
result = (value1 - value2);
break;
case "*":
result = (value1 * value2);
break;
case "/":
result = (value1 / value2);
break;
case "%":
result = (value1 % value2);
break;
}
System.out.println(result);
That should let you input "2+2" and produce 4 as result

For the nextXXX()-methods (except nextLine()) Scanner uses strings up to some delimiter as its tokens. By default, whitespace is used as delimiter. Since e. g. string "100+50" doesn't contain any whitespace, it's a single token. This token is not an int, therefore a call on nextInt() will fail.
What can you do? Either you read the whole line using nextLine(), then you'll have to parse it on your own.
Or, you use different delimiters. E.g.
m.sc.useDelimiter("[^0-9]"); // delimiter is any non-digit.
int value1 = m.sc.nextInt();
m.sc.useDelimiter("[0-9]"); // delimiter is any digit
String operator = m.sc.next();
m.sc.useDelimiter("[^0-9]"); // delimiter is any non-digit.
int value2 = m.sc.nextInt();
The delimiter is a regular expression. You can find more information on those in the documentation for Pattern.
EDIT: note, the used expressions won't work with negative numbers.

I don't know if I understand but the problem occurs when there is space in the right operator?
You can simply remove the operator spaces before entering the switch, like this:
input = input.replaceAll(" ","");
switch (input) {...

Need Help to Understand Some Basic Java concepts about While loop conditional statements and type conversion

I was just trying to code a simple calculator and it works fine...
What I want to do now is include a 'do while' or 'while' loop to repeat a statement till a user enters one of the four basic operator signs. I have achieved it using other methods (if and switch) but I want to simplify it.
Also I faced a lot of problems learning how to parse a character in scanner and JPane methods. I could achieve using various resources on the internet but a simple method that would help me understand the logic more clearly and not just achieve will be highly appreciated...
public class MyCalculator{
public static void main (String [] args){
// Let us code a simple calculator
char OP;
System.out.println("This is a simple calculator that will do basic calculations such as :\nAddition, Multiplication, Substraction and Division.");
// Create a scanner object to Read user Input.
Scanner input = new Scanner(System.in);
System.out.println("Enter Any positive number followed by pressing ENTER.");
int firstNum = input.nextInt();
// Need to Loop the below statement till one of the four (+,-,*,/) operator is entered.
System.out.println("Enter your choice of OPERATOR sign followed by pressing ENTER.");
OP = input.next().charAt(0);
System.out.println("Enter your Second number followed by an ENTER stroke.");
int secNum = input.nextInt();
// Various possible Resolution
int RSum = firstNum+secNum;
int RSubs= firstNum-secNum;
int RPro = firstNum*secNum;
double DPro = firstNum/secNum;
// Conditional statements for Processing
Switch (OP){
case '+': System.out.println("The Resulting sum is "+ RSum);
break;
case '-': System.out.println("The Resulting sum is "+ RSubs);
break;
case '*': System.out.println("The Resulting Product is "+ RPro);
break;
case '/': System.out.println("The Resulting Divisional product is "+ DPro);
break;
default : System.out.println("Try Again");
}
}
}

You can use something like this:
while(scanner.hasNext()) {
//some code
int number = scanner.NextInt();
}
But I would implement a calculator as follow:
int num1 = scanner.NextInt();
String op = scanner.Next();
int num2 = scanner.NextInt();
You can loop through a String as follow and do your checks:
for (char ch : exampleString.toCharArray()){
System.out.println(ch);
}
You can also loop through a String as follow:
for (int i=0; i<examplestring.length(); i++) {
char c = examplestring.charAt(i);
}
You can loop until you get a + or a - as follow:
char operator;
do {
char operator = scanner.next().get(0);
}while(operator != '+' || operator != '-')
You can loop and print error messages as follow:
char operator;
do {
char operator = scanner.next().get(0);
if(!isValidOperator(operator)) {
System.out.println("invalid operator");
}
}while(!isValidOperator(operator))
public boolean isValidOperator(char operator) {
if(operator == '+') {
return true;
} else if (operator == '-') {
return true;
}
return false;
}

Illegal input exception during evaluation of a postfix expression, when my input more than two numbers

I got most of the code out of the text book and every thing seems to be working. For example if I have the postfix 5 2 + it would give me 7, which is correct but if I have 5 2 4 * / 7 - then it throws the illegal input exception. When I got rid of the illegal input exception, it works but doesn't give the right answer.
import java.util.*;
import java.util.regex.Pattern;
//Here is my class and main method
public class postFix {
public static final Pattern UNSIGNED_DOUBLE = Pattern.compile("((\\d+\\.?\\d*)|(\\.\\d+))([Ee][-+]?\\d+)?.*?");
public static final Pattern CHARACTER = Pattern.compile("\\S.*?");
public static Double postfixEvaluate (String expression) {
Stack<Double> numbers = new Stack<Double>( ); //Stack for numbers
Stack<Character> operators = new Stack<Character>( ); //Stack for ops
Scanner input = new Scanner(expression);
String next;
while (input.hasNext()) //Iterator is used (hasNext)
{
if (input.hasNext(UNSIGNED_DOUBLE))
{ // if next input is a number
next = input.findInLine(UNSIGNED_DOUBLE);
numbers.push(new Double(next)); //adding nums to the number stack
}
else
{ //The next input is an operator
next = input.findInLine(CHARACTER);
switch (next.charAt(0))
{
case '+':
case '-':
case '*':
case '/':
operators.push(next.charAt(0)); //adding operators to operator stack
break;
case ')':
evaluateStackTops(numbers, operators);
break;
case '(':
break;
default: //Illegal Character
throw new IllegalArgumentException("Illegal Character");
}
}
}
//This what seems to be throwing the exception but I got this right out of the book
if (numbers.size() != 1)
throw new IllegalArgumentException("Illegal Input");
return numbers.pop( );
}
public static void evaluateStackTops (Stack<Double> numbers, Stack<Character> operators)
{
double operand1 , operand2;
//check that the stacks have enough items, and get the two operands
if ((numbers.size()<2)||(operators.isEmpty())) {
throw new IllegalArgumentException("Illegal Expression");}
operand2 = numbers.pop();
operand1 = numbers.pop();
//carry out an operation based on the operator on top of the stack
for (int i = 0; i < numbers.size(); i++) {
switch (operators.pop()) {
case '+':
numbers.push(operand1 + operand2);
break;
case '-':
numbers.push(operand1 - operand2);
break;
case '*':
numbers.push(operand1 * operand2);
break;
case '/':
numbers.push(operand1 / operand2);
break;
default:
throw new IllegalArgumentException("Illegal Operator");
}
}
public static void main(String[] args) {
//String expression;
//Scanner input = new Scanner(expression);
System.out.println(postFix.postfixEvaluate("(2 3 5 * / )" ));
}
}

Your algorithm is flawed. All it does is build stacks of operators and operands, and then evaluate the expression backwards. That's never going to work.
I don't understand why you're even checking for parentheses. There are no parentheses in postfix expressions, because the conversion from infix to postfix has already removed the parentheses.
Also, there is no need for a stack of operators. The whole idea of postfix is that you can evaluate each operator as you encounter it, and push the result back onto the stack.
The basic algorithm is:
while not end of input
read next token
if token is a number
push on numbers stack
else if token is operator
pop value2 and value1 from stack
result = evaluate value1 <operator> value2
push result to numbers stack
else
invalid input
end while
// at this point, there should be 1 value on numbers stack
So when evaluating 5 2 4 * / 7 -, the sequence is:
push 5
push 2
push 4
// operator * read here
pop 4
pop 2
evaluate 2 * 4
push 8
// operator / read here
pop 8
pop 5
evaluate 5/8
push 0.625
push 7
// operator - read here
pop 7
pop 0.625
evaluate 0.625 - 7
push -6.375
// end of input here
pop final result

Prefix Expression evaluating incorrectly - Java

private class InputListener implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
// Create an integer and character stack
Stack<Integer> operandStack = new Stack<Integer>();
Stack<Character> operatorStack = new Stack<Character>();
// User input in input text field
String input = inputTextField.getText();
// Create string tokenizer containing string input
StringTokenizer strToken = new StringTokenizer(input);
// Loop while there are tokens
while (strToken.hasMoreTokens())
{
String i = strToken.nextToken();
int operand;
char operator;
try
{
operand = Integer.parseInt(i);
operandStack.push(operand);
}
catch (NumberFormatException nfe)
{
operator = i.charAt(0);
operatorStack.push(operator);
}
}
// Loop until there is only one item left in the
// operandStack. This one item left is the result
while(operandStack.size() > 1)
{
// Perform the operations on the stack
// and push the result back onto the operandStack
operandStack.push(operate(operandStack.pop(),
operandStack.pop(), operatorStack.pop()));
}
// Display the result as a string in the result text field
resultTextField.setText(Integer.toString(operandStack.peek()));
}
// Sum and product computed
public int operate(Integer operand1, Integer operand2, char operator)
{
switch(operator)
{
case '*':
return operand2 * operand1;
case '/':
return operand2 / operand1;
case '%':
return operand2 % operand1;
case '+':
return operand2 + operand1;
case '-':
return operand2 - operand1;
default:
throw new IllegalStateException("Unknown operator " + operator + " ");
}
}
}
The prefix expression code provided is incorrectly evaluating expressions with more than one operator. The expression: * + 16 4 + 3 1 should evaluate to 80 = ((16 + 4) * (3 + 1)), but instead it evaluates to 128, which I think is evaluating as: ((16 + 4) * (3 + 1) + (16 * 3)). How do I edit the code to correct this problem? Thank you for your help.

In prefix evaluation,Important thing to remember is
operand 1= pop();
operand 2= pop();
and say the operator is -
The value that is pushed is operand 1 - operand 2 and not operand 2 - operand 1
But something else is causing * + 16 4 + 3 1 to evaluate to 128.
I used the following algo for evaluating in java and it works fine
1.Take the prefix expression as a string in a variable with characters separated by single space.
2.Traverse the string from index length-1 to 0
3.If its a number, perform push ,and if its a multidigit number,first obtain the full number and then push it
4.If its an operator then simply do the thing which i mentioned in beginning of the answer.
It is a simple code.
import java.io.*;
import java.util.*;
class PREFIXEVAL
{
public static void main(String []args)throws IOException
{
String p,n="";StringBuffer b;int i,op1,op2;char c;Stack<Integer> s=new Stack<Integer>();
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.println("enter the prefix expression separated by spaces");
p=br.readLine();
i=p.length()-1;
while(i>=0)
{
c=p.charAt(i);
if(c>=48&&c<=57)
n=n+c;
else if(c==' '&&!n.equals(""))
{/*handles both single and multidigit numbers*/
b=new StringBuffer(n);b.reverse();n=b.toString();
s.push(Integer.parseInt(n));n="";
}
else
{
if(c=='+')
{
op1=s.pop();
op2=s.pop();
s.push(op1+op2);
}
else if(c=='-')
{
op1=s.pop();
op2=s.pop();
s.push(op1-op2);
}
else if(c=='*')
{
op1=s.pop();
op2=s.pop();
s.push(op1*op2);
}
else if(c=='%')
{
op1=s.pop();
op2=s.pop();
s.push(op1%op2);
}
else if(c=='/')
{
op1=s.pop();
op2=s.pop();
s.push(op1/op2);
}
}
i--;
}
System.out.println("the prefix expression evaluates to "+s.peek());
}
}

Postfix calculator, how to deal with 3 numbers in a row?

Here is my code so far:
public class PostfixCalculator {
private Stack<Float> stack;
private float result;
private Boolean isOperator (char op){
boolean operator;
switch (op){
case '+':
case '-':
case '*':
case '/':
case '^':
operator = true;
break;
default:
operator = false;
break;}
return operator;
}
private Boolean isFunction (String func){
String[] functions = {"sin", "cos", "max"};
for (int i=0; i<functions.length; i++){
if (func.equals(functions[i]))
return true; }
return false;
}
private void computeOperator (float op1, float op2, char op){
switch (op){
case '+':
result = op1 + op2;
break;
case '-':
result = op1 - op2;
break;
case '/':
result = op1/op2;
break;
case '*':
result = op1 * op2;
break;
case '^':
result = (float) Math.pow(op1, op2);
break;
default:
break;
}
}
public float calculate(String expr) throws IllegalArgumentException {
result = 0;
String token;
Float makeit;
char operator;
float op1, op2, pushFloat;
StringTokenizer calc=new StringTokenizer(expr);
stack = new Stack<Float>();
while (calc.hasNextToken()){
token=calc.getNextToken();
operator=token.charAt(0);
if (!(this.isOperator(operator))){
if (this.isFunction(token)){
if (token.equals("sin")){
op1=stack.pop();
result = (float) Math.sin(op1);
stack.push(result);
}
else if (token.equals("cos")){
op1=stack.pop();
result = (float) Math.cos(op1);
stack.push(result);
}
else if (token.equals("max")){
op1=stack.pop();
op2=stack.pop();
result=Math.max(op1, op2);
stack.push(result);
}
}
else {
makeit = new Float(token);
pushFloat = makeit.floatValue();
stack.push(pushFloat);
}
}
else {
op1 = stack.pop();
op2 = stack.pop();
computeOperator (op1, op2, operator);
stack.push(result);
}
}
return stack.pop();
}
}
I think I have the basics of it down, but how do I deal with postfix calculations with three digits in a row or more, like for example '2 3 4 * -'? Any help would be appreciated. Thanks in advance!

Yep, a stack. And one can implement a simple stack easily with an array and a counter -- no real need to use a fancy class.
The array would be as large as the most deeply nested expression that you can handle (10 elements should be sufficient for virtually all "real" problems).
Push is update A[i] and increment i. Pop is decrement i and reference A[i]. "8 9 +" is push(8), push(9), pop the top two elements, add them, push the result. Note that operators are never pushed, only operands/results.
'2 3 4 * -' would be push(2), push(3), push(4), pop top two, multiply, push result, pop two, subtract, push result.
"7 6 + cos" would be push(7), push(6), pop two, add, push result, pop one, perform "cos", push result.
Error if you need to pop an element and the counter is zero (eg, "7 +" -- you'd want to pop twice but you can only pop once). Also an error if the user expresses "finished" and there is more than one element in the stack.
Always "display" your top element, as that's the last value pushed or the result.

For a calculator like this, you should use a stack. Every number is a push and every operation has a corresponding action.
st = []
while input:
if isanumber(input.next()): st.push(input.consume())
else: #its an operator
#note this may be wrong for operators that have a specific order
if(input.next() == "+"):
stack.push(stack.pop() + stack.pop())
# more operations
input.consume()
print(st)
And that would be the rough python to do it, in this instance I look ahead a single token before making a decision.
edit:
Probably should have read your code before posting, anyway you must always push back the computed number, also attempt to simplify your code into only "functions" and "numbers" making functions that perform both. Regex is also useful for this sort of thing, such as the http://www.cplusplus.com/reference/std/regex/.