diff --git a/Java/InfixToPostfix.java b/Java/InfixToPostfix.java
new file mode 100644
index 0000000..1bef270
--- /dev/null
+++ b/Java/InfixToPostfix.java
@@ -0,0 +1,92 @@
+import java.util.Stack; 
+import java.util.Scanner;
+  
+public class InfixToPostfix 
+{ 
+    // A utility function to return precedence of a given operator 
+    // Higher returned value means higher precedence 
+    static int Prec(char ch) 
+    { 
+        switch (ch) 
+        { 
+        case '+': 
+        case '-': 
+            return 1; 
+       
+        case '*': 
+        case '/': 
+            return 2; 
+       
+        case '^': 
+            return 3; 
+            
+        default:
+            return;
+        } 
+        return -1; 
+    } 
+       
+    // The main method that converts given infix expression 
+    // to postfix expression.  
+    static String infixToPostfix(String exp) 
+    { 
+        // initializing empty String for result 
+        String result = new String(""); 
+          
+        // initializing empty stack 
+        Stack<Character> stack = new Stack<>(); 
+          
+        for (int i = 0; i<exp.length(); ++i) 
+        { 
+            char c = exp.charAt(i); 
+              
+             // If the scanned character is an operand, add it to output. 
+            if (Character.isLetterOrDigit(c)) 
+                result += c; 
+               
+            // If the scanned character is an '(', push it to the stack. 
+            else if (c == '(') 
+                stack.push(c); 
+              
+            //  If the scanned character is an ')', pop and output from the stack  
+            // until an '(' is encountered. 
+            else if (c == ')') 
+            { 
+                while (!stack.isEmpty() && stack.peek() != '(') 
+                    result += stack.pop(); 
+                  
+                if (!stack.isEmpty() && stack.peek() != '(') 
+                    return "Invalid Expression"; // invalid expression                 
+                else
+                    stack.pop(); 
+            } 
+            // when an operator is encountered
+            else  
+            { 
+                while (!stack.isEmpty() && Prec(c) <= Prec(stack.peek())){ 
+                    if(stack.peek() == '(') 
+                        return "Invalid Expression"; 
+                    result += stack.pop(); 
+             } 
+                stack.push(c); 
+            } 
+       
+        } 
+       
+        // pop all the operators from the stack 
+        while (!stack.isEmpty()){ 
+            if(stack.peek() == '(') 
+                return "Invalid Expression"; 
+            result += stack.pop(); 
+         } 
+        return result; 
+    } 
+    
+    public static void main(String[] args)  
+    { 
+        Scanner sc = new Scanner(System.in);
+        System.out.println("Enter the infix string to be converted to postfix:");
+        String exp = sc.nextLine(); 
+        System.out.println(infixToPostfix(exp)); 
+    } 
+}