more programs for the beginners

Loops.java

@@ -0,0 +1,35 @@
+public class Loops
+{
+       public static void number(int x)
+       {
+              //using while loop
+              while (x < 10) {
+                     ++x;
+                     System.out.println(x);
+              }
+       }
+       public static void even(int z)
+       {
+              do {
+                     System.out.println (z);
+                     z += 2;
+              } while (z <= 10);
+       }
+       public static void table(int y)
+       {
+              //using for loop
+              int i;
+              for (i = 1; i <= 10; ++i) {
+                     System.out.println(i*y);
+              }
+       }
+       public static void main(String[] args)
+       {
+              System.out.println("Number from 1 to 10");
+              number(0);
+              System.out.println("Even Numbers between 0 to 10");
+              even(0);
+              System.out.println("Table of 8");
+              table(8);
+       }
+}

README.md

@@ -1,2 +1,3 @@
 # Java-Guide-for-Beginners
- This will be an Open Guide for all beginners in Python ! You can read and learn simple Java codes here , and whats more interesting is that you can even Contribute !!! 
+## This will be an Open Guide for all beginners in JAVA!
+You can read and learn simple Java codes here , and whats more interesting is that you can even Contribute !!!

Selection_Statements.java

@@ -0,0 +1,36 @@
+
+package selectionstatements;
+
+
+public class Selection_Statements {
+          public static String IfElse(int x){
+              if(x%2==0){
+                  return "even";
+              }
+              else{
+                  return "odd";
+              }
+          }
+        public static String Switch(int x){
+            switch(x){
+                    case 1 :
+                        return "it's one";
+                    case 2 :
+                        return "it's two";
+                    case 3 :
+                        return "it's three";
+                    default:
+                        return "out of my knowledge";
+            }
+        }    
+
+
+    public static void main(String[] args) {
+       Selection_Statements obj = new Selection_Statements();
+       String y = obj.IfElse(123);
+       System.out.println("The number is "+ y);
+       String x=obj.Switch(2);
+       System.out.println("switch statements result is :"+ x);
+    }
+
+}

class_and_objects/class_object.java

@@ -0,0 +1,27 @@
+public class class_object
+{
+     //class declaration
+     public int square(int x)
+     {
+          return x*2; 
+     }
+     public double square_rt (int x)
+     {
+          return Math.sqrt (x);
+     }
+     public static void main(String[] args)
+     {
+          // using the command line arguements as input
+          int x = Integer.parseInt (args[0]);
+
+          Class object = new Class(); // declaring an object for class Class
+
+          int y = object.square (x); // calling a method of class Class
+          double z = object.square_rt (x); // calling a method of class Class
+
+          System.out.println("Input number = " + x);
+          System.out.println("Square of number = " + y);
+          System.out.println("Square root of number = " + z);
+    }
+
+}

data_structures/infix_to_postfix.java

@@ -0,0 +1,106 @@
+import java.util.Scanner;
+import java.util.StringTokenizer;
+
+/**
+ * Program to convert infix expression to postfix.
+ * Input format :- there have to be spaces in between numbers and mathematical signs
+ * + - * / % ^ ( ) are considered.
+ * example of input :-      a * b - c / d * ( e - f ) ^ g + h
+ * example of output :-     a b * c d / e f - g ^ * - h +
+ */
+public class infix_to_postfix
+{
+    public static int precedence(String sign)
+    {
+        switch (sign) {
+            case "+":
+            case "-":
+                return 0;
+            case "*":
+            case "/":
+                return 1;
+            case "%":
+                return 2;
+            case "^":
+                return 3;
+            case "(":
+            case ")":
+                return 4;
+            default:
+                return 5;
+        }
+    }
+
+    public static void main(String[] args)
+    {
+        String St, i;
+        Scanner Sc = new Scanner (System.in);
+        Stack stack = new Stack();
+        St = Sc.nextLine();
+        StringTokenizer obj = new StringTokenizer(St);
+        for (St = obj.nextToken(); obj.hasMoreTokens(); St = obj.nextToken()) {
+            if (St.equals("(")) {
+                stack.push (St);
+                continue;
+            }
+            if (St.equals(")")) {
+                for (i = stack.top(); !stack.is_empty(); stack.pop(), i = stack.top()) {
+                    if (i.equals("(")) {
+                        stack.pop();
+                        break;
+                    } else {
+                        System.out.print(i + " ");
+                    }
+                }
+                continue;
+            }
+            if (St.equals("+") || St.equals("-") || St.equals("*") || St.equals("/") || St.equals("%") || St.equals("^")) {
+                for ( ; !stack.is_empty(); ) {
+                    i = stack.top();
+                    if (i.equals("(")) {
+                        break;
+                    }
+                    if (precedence (i) >= precedence (St)) {
+                        System.out.print(i + " ");
+                        stack.pop();
+                    } else {
+                        break;
+                    }
+                }
+                stack.push (St);
+            } else {
+                System.out.print(St + " ");
+            }
+        }
+        System.out.print(St + " ");
+        for ( ; !stack.is_empty(); stack.pop()) {
+            System.out.print(stack.top() + " ");
+        }
+    }
+}
+class Stack {
+    private String[] arr;
+    private int size;
+    public Stack()
+    {
+        size = 0;
+        arr = new String[10000];
+    }
+    public String top()
+    {
+        return arr[size - 1];
+    }
+    public void pop()
+    {
+        --size;
+    }
+    public void push (String val)
+    {
+        arr[size] = val;
+        ++size;
+    }
+    public boolean is_empty()
+    {
+        return size == 0;
+    }
+}

data_structures/maps_I.java

@@ -0,0 +1,63 @@
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
+
+public class maps_I
+{
+    public static void main(String[] args)
+    {
+        Map<Integer, String> my_map = new HashMap<Integer, String>();
+        Scanner Sc = new Scanner(System.in);
+        int choice;
+        String St; int key;
+        do {
+            choice = Sc.nextInt();
+            switch (choice) {
+                case 1:
+                    // check
+                    key = Sc.nextInt();
+                    System.out.println(my_map.containsKey(key));
+                    St = Sc.next();
+                    System.out.println(my_map.containsValue(St));
+                    break;
+                case 2:
+                    // insert
+                    // if key-value pair exists,
+                    // then it replaces the existing pair with the new pair !
+                    key = Sc.nextInt();
+                    St = Sc.next();
+                    my_map.put(key, St);
+                    break;
+                case 3:
+                    // get value
+                    key = Sc.nextInt();
+                    System.out.println(my_map.get(key));
+                    break;
+                case 4:
+                    // size
+                    System.out.println(my_map.size());
+                    break;
+                case 5:
+                    // clear the map
+                    my_map.clear();
+                    break;
+                case 6:
+                    // remove an element
+                    key = Sc.nextInt();
+                    System.out.println("Removed :- " + my_map.get(key));
+                    my_map.remove(key);
+                    break;
+                case 7:
+                    System.out.println(my_map);
+                    System.out.println(my_map.keySet());
+                    System.out.println(my_map.entrySet());
+                    break;
+                case 10:
+                    System.exit(0);
+                    break;
+                default:
+                    System.out.println("Try Again");
+            }
+        } while (true);
+    }
+}

data_structures/maps_ex_1.java

@@ -0,0 +1,34 @@
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Scanner;
+/**
+ * java.util.HashMap is unordered.
+ * This class makes no guarantees as to the order of the map,
+ * in particular, it does not guarantee that the order will remain constant over time.
+ *
+ * java.util.LinkedHashMap uses insertion-order.
+ * This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries.
+ * This linked list defines the iteration ordering,
+ * which is normally the order in which keys were inserted into the map (insertion-order).
+ *
+ * java.util.TreeMap, a SortedMap, uses either natural or custom ordering of the keys.
+ * The map is sorted according to the natural ordering of its keys,
+ * or by a Comparator provided at map creation time, depending on which constructor is used.
+ */
+public class maps_ex_1
+{
+    public static void main(String[] args)
+    {
+        String St; Integer key;
+        int t;
+        Scanner Sc = new Scanner(System.in);
+        Map<String, Integer> my_map = new LinkedHashMap<String, Integer>();
+        for (t = Sc.nextInt(); t > 0; --t) {
+            St = Sc.next();
+            key = my_map.get(St);
+            my_map.put(St, (key == null) ? 1 : key + 1);
+        }
+        System.out.println(my_map.size());
+        System.out.println(my_map);
+    }
+}

input_output/java_io_I.java

@@ -0,0 +1,46 @@
+import java.io.InputStreamReader;
+import java.io.BufferedReader;
+import java.io.IOException;
+public class java_io_I
+{
+  public static void main(String[] args)throws IOException
+    // throw the Exception class object for input-output exceptions ie. IOException
+  {
+    InputStreamReader Isr = new InputStreamReader (System.in);
+    BufferedReader Br = new BufferedReader (Isr);
+
+    // all inputs are taken as Strings
+    // also the entire line is taken as input
+    // Now just parse the String into whichever data type required.
+
+    String input;
+    int input_i;
+    long input_l;
+    float input_f;
+    double input_d;
+    char input_c;
+
+    input = Br.readLine(); // Taking input as a String
+    System.out.println(input); // String Input
+
+    input = Br.readLine(); // Taking input as a String
+    input_i = Integer.parseInt (input); // parsing input
+    System.out.println(input_i);
+
+    input = Br.readLine(); // Taking input as a String
+    input_l = Long.parseLong (input); // parsing input
+    System.out.println(input_l);
+
+    input = Br.readLine(); // Taking input as a String
+    input_f = Float.parseFloat (input); // parsing input
+    System.out.println(input_f);
+
+    input = Br.readLine(); // Taking input as a String
+    input_d = Double.parseDouble (input); // parsing input
+    System.out.println(input_d);
+
+    input_c = (char) Br.read(); // Taking input as a character
+    Br = new BufferedReader (Isr); // flush the junk characters (of newline or carriage return) from the input buffer
+    System.out.println(input_c);
+  }
+}

input_output/java_io_II.java

@@ -0,0 +1,36 @@
+import java.util.Scanner;
+//import this package for input
+
+public class java_io_II
+{
+    public static void main(String[] args) {
+        //for input
+        Scanner Sc = new Scanner(System.in);
+
+        // variable "input_x" takes the input for data type x
+
+        // for integer inputs
+        int input_i = Sc.nextInt();
+        System.out.println("Input = " + input_i);
+
+        // for Long_Integer inputs
+        long input_l = Sc.nextLong();
+        System.out.println("Input = " + input_l);
+
+        // for float inputs
+        float input_f = Sc.nextFloat();
+        System.out.println("Input = " + input_f);
+
+        // for double_float inputs
+        double input_d = Sc.nextDouble();
+        System.out.println("Input = " + input_d);
+
+        // for String inputs WORD by WORD
+        String input_St = Sc.next();
+        System.out.println("Input = " + input_St);
+
+        // for String inputs Entire Line
+        input_St = Sc.nextLine();
+        System.out.println("Input = " + input_St);
+    }
+}