Add files via upload

Author: pushpadevl

GenPermutations.java

@@ -0,0 +1,30 @@
+import java.util.*;
+import java.util.stream.*;
+public class GenPermutations {
+    public static void main(String[] args){
+    Scanner sc = new Scanner(System.in);
+    String S = sc.next(); 
+    
+    char[] arr = S.toCharArray();
+    findAllPermutations(arr, arr.length, arr.length);
+    }
+    static void findAllPermutations(char[] arr, int size, int n){
+        if(size == 1) {Stream.of(arr).forEach(System.out::print);
+        System.out.println();
+        }
+        for(int i=0;i<size;i++){
+            findAllPermutations(arr, size-1, n);
+
+            if(size % 2 ==1){
+                char temp = arr[0];
+                arr[0] = arr[size-1];
+                arr[size-1] = temp;
+            }else{
+                char temp = arr[i];
+                arr[i] = arr[size-1];
+                arr[size-1] = temp;
+            }
+        }
+    }
+    
+}

Java_Classes.java

@@ -0,0 +1,26 @@
+interface Animals {
+    // (1) Every method in the implementing class should be noted here first
+    //Like this
+    void makeSound();
+}
+class Dog implements Animals{
+    public void makeSound(){
+        System.out.println("woof");
+    }
+}
+class Cat implements Animals{
+    public void makeSound(){
+        System.out.println("meow");
+    }
+}
+class Java_Classes{
+    public static void main(String [] ags){
+        Animals[] anims = new Dogs[2]; // (2) Will not work
+        Animals[] anims = new Animals[2]; //this will
+        anims[0] = new Cat();
+        anims[1] = new Dog();
+        anims[0].makeSound();
+        anims[1].makeSound();
+        
+    }
+}

Java_Hard_Lessons.java

@@ -0,0 +1,70 @@
+/*
+
+Concepts to be learned
+
+1. main args array contains nothing unless some args are provided while running java .class. [args]
+2. Exceptions class throwing exception in try catch and finally, inside a method
+3. inheritance, extends, implements, abstract extension
+4. final static method works
+5. SQL statement query result format
+6. main class name works
+7. If there are two different classes, each with their own main methods, then either one can be run after choosing the class file to run after compilation, but the CLASS with NAME of file should have higher access specifier 
+8. null comaprator
+9. copyOnWrite method
+10. System.console
+*/
+import java.io.Console;
+import java.util.*;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.logging.ConsoleHandler;
+import java.util.stream.*;
+
+class Java_Hard_Lessons{
+    public final static void main(String[] args){
+        System.out.println("inside jhl \n"+args.length);
+        int []arr = {1,5,6,4,6,8,3,2,545,8,8};
+        //Arrays.sort(arr, null); //doesn't work
+        List<Integer> li = new ArrayList();
+        li.add(2);
+        li.add(1);
+        li.add(3);
+        //List<Integer> nli = CopyOnWriteArrayList(li);
+        System.out.println(li);
+        Console iConsole = System.console(); //read more
+        System.out.println(iConsole.toString());
+    }
+}
+ 
+class differentClass{
+    public static void main(String []args){
+        System.out.println("inside dc");
+    }
+}
+class main extends differentClass{
+
+    /*public static void main(String[] args){
+        System.out.println("inside main class");
+    }*/ 
+    /* On commenting the main method after extending differentClass, the main method of diffClass is called. If not commented, then main method is overwritten 
+    */
+}
+
+abstract class Animals{
+    void sound(){
+        System.out.println("Animal sounds");
+    }
+}
+interface Fauna{
+    void makeSound();
+}
+interface Flora{
+    void comm();
+}
+class Dogs extends Animals{}
+
+//class Cats implements Animals{} // Doesn't work, implementation is for interfaces
+
+class Cats implements Fauna, Flora{
+    public void makeSound(){System.out.println("Meow");}
+    public void comm(){System.out.println("comm Meow");}
+}

Java_Synchronized.java

@@ -0,0 +1,122 @@
+// A Java program to demonstrate working of
+// synchronized.
+import java.io.*;
+import java.util.*;
+
+// A Class used to send a message
+class Sender
+{
+	public void send(String msg)
+	{
+		System.out.println("Sending\t" + msg );
+		try
+		{
+			Thread.sleep(1000);
+		}
+		catch (Exception e)
+		{
+			System.out.println("Thread interrupted.");
+		}
+		System.out.println("\n" + msg + "Sent");
+	}
+}
+
+// Class for send a message using Threads
+class ThreadedSend extends Thread
+{
+	private String msg;
+	Sender sender;
+
+	// Receives a message object and a string
+	// message to be sent
+	ThreadedSend(String m, Sender obj)
+	{
+		msg = m;
+		sender = obj;
+	}
+
+	public void run()
+	{
+		// Only one thread can send a message
+		// at a time.
+		synchronized(sender)
+		{
+			// synchronizing the snd object
+			sender.send(msg);
+		}
+	}
+}
+
+// Driver class
+class Java_Synchronized
+{
+	public static void main(String args[])
+	{
+		Sender snd = new Sender();
+		ThreadedSend S1 =
+			new ThreadedSend( " Hi " , snd );
+		ThreadedSend S2 =
+			new ThreadedSend( " Bye " , snd );
+
+		// Start two threads of ThreadedSend type
+		S1.start();
+		S2.start();
+
+		// wait for threads to end
+		try
+		{
+			S2.join();
+			S1.join();
+		}
+		catch(Exception e)
+		{
+			System.out.println("Interrupted");
+		}
+	}
+}
+
+/* 
+// An alternate implementation to demonstrate
+// that we can use synchronized with method also.
+class Sender
+{
+	public synchronized void send(String msg)
+	{
+		System.out.println("Sending\t" + msg );
+		try
+		{
+			Thread.sleep(1000);
+		}
+		catch (Exception e)
+		{
+			System.out.println("Thread interrupted.");
+		}
+		System.out.println("\n" + msg + "Sent");
+	}
+}
+*/
+
+/* 
+// One more alternate implementation to demonstrate
+// that synchronized can be used with only a part of
+// method
+class Sender
+{
+	public void send(String msg)
+	{
+		synchronized(this)
+		{
+			System.out.println("Sending\t" + msg );
+			try
+			{
+				Thread.sleep(1000);
+			}
+			catch (Exception e)
+			{
+				System.out.println("Thread interrupted.");
+			}
+			System.out.println("\n" + msg + "Sent");
+		}
+	}
+}
+*/

Java_Threads.java

@@ -0,0 +1,32 @@
+import java.util.*;
+class NewRunnableClass implements Runnable{
+    int v=0;
+    NewRunnableClass(int i){
+        v=i;
+    }
+    @Override
+    public synchronized void run() {
+        System.out.println("Thread "+v + " "+System.currentTimeMillis());
+    }
+}
+class Java_Threads{
+    public static void main(String [] ags){
+        
+        Thread[] tarr = new Thread[3];
+        for(int i=1;i<4;i++){
+            NewRunnableClass temp = new NewRunnableClass(i);
+            tarr[i-1] = new Thread(temp);
+            
+        }
+        for(int i=0;i<3;i++){
+            System.out.println((double)System.currentTimeMillis()/1000);
+            tarr[i].start();
+        }
+        
+        
+    }
+}
+// Thread in array format
+// Thread class extension VS Runnable interface impl 
+// return in try catch finally
+// Synchronize method attribute with threads

Java_Try_Catch_Finally.java

@@ -0,0 +1,32 @@
+public class Java_Try_Catch_Finally{
+    public static void main(String []args){
+        int i = Integer.parseInt(args[0]);
+
+        System.out.println(method(i));
+    }
+    static String method(int i){
+        try{
+            System.out.println("Inside the try block");
+            if(i!=0 && i%2==0){
+                i += 10;
+                return "Even";
+              //  System.out.println("Value of i = "+i);
+            }
+                
+            else throw new Exception("Exception occured.");
+        }catch (Exception e){
+            System.out.println("Inside the catch block");
+            if(i!=0){
+                i += 20;
+                return "Not even";
+            }
+                
+            else throw new Exception("Another exception.");
+        }finally{
+            System.out.println("Inside the finally block");
+            return "Zero and value of i = "+i;
+        }
+        //System.out.println("After finally");
+        //return Integer.toBinaryString(55);
+    }
+}

Java_Unchecked_Checked_Exp.java

@@ -0,0 +1,16 @@
+import jdk.tools.jlink.internal.plugins.ExcludePlugin;
+
+public class Java_Unchecked_Checked_Exp {
+    public static void main(String args[]){
+        int i=0;
+        int j=9;/*
+        try{    
+            System.out.println(j/i);
+        //}catch (IOException e){ 
+        //}catch (ArithmeticException e){          
+        }catch (Exception e){
+            System.out.print("Exception occured.");
+        }*/
+        //System.out.println("After the catch block, no finally clause.");
+    }
+}

Lambdas.java

@@ -0,0 +1,43 @@
+import java.util.Collections;
+import java.util.List;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Lambdas {
+    public static void main(String[] args) {
+        
+        List<Integer> list = Arrays.asList(4,3,6,5,7,3,5,8,1);
+/*
+        Collections.sort(list, new Comparator<Integer>(){
+            @Override
+            public int compare(Integer a, Integer b){
+                return a-b;
+            }
+        });
+*/
+        //Since comparator is a functional interface, we can use it as such
+        // Functional interfaces have only one abstract method, but can have multiple default methods
+
+
+        Collections.sort(list, (Integer a, Integer b) -> a-b);
+        System.out.println(list);
+
+        Multiplication mul = (int a, int b)->(a*b);
+        System.out.println(mul.multiply(2,3));
+
+        //() -> System.out.println("asasasas");
+
+    }
+}
+//@FunctionalInterface
+interface Multiplication{
+    int multiply(int a, int b); //abstract is automatically added for interface methods(all non static)
+
+    static int add(int a, int b){ // but not for static methods, but these are perfectly valid
+        return a+b;
+    }
+    //abstract int div (int a, int b); //this would be valid if this interface is not a functional interface (interface with only 1 abstract method), invalid otherwise
+    /*int subtr(int a, int b){ // non static (instance) methods are not allowed
+        return a-b;
+    }*/
+}