19/08/2018

jamalgithub · jamalgithub · commit b657619b1d83 · 2018-08-19T20:15:56.000+01:00
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/BiCounter.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/BiCounter.java
@@ -0,0 +1,29 @@
+package com.in28munites.ConcurrencyLocksAtomicityAndCollections;
+
+public class BiCounter {
+	private int i = 0;
+	private int j = 0;
+	
+	synchronized public void incrementI() {
+		i++; 
+		//get i
+		//increment  
+		//set i
+	}
+
+	public int getI() {
+		return i;
+	}
+	
+	synchronized public void incrementJ() {
+		j++; 
+		//get j
+		//increment  
+		//set j
+	}
+
+	public int getJ() {
+		return j;
+	}
+
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/BiCounterWithAtomicInteger.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/BiCounterWithAtomicInteger.java
@@ -0,0 +1,25 @@
+package com.in28munites.ConcurrencyLocksAtomicityAndCollections;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class BiCounterWithAtomicInteger {
+	private AtomicInteger i = new AtomicInteger();
+	private AtomicInteger j = new AtomicInteger();
+		
+	public void incrementI() {		
+		i.incrementAndGet();
+	}
+
+	public int getI() {
+		return i.get();
+	}
+	
+	public void incrementJ() {
+		j.incrementAndGet(); 
+	}
+
+	public int getJ() {
+		return j.get();
+	}
+
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/BiCounterWithLock.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/BiCounterWithLock.java
@@ -0,0 +1,34 @@
+package com.in28munites.ConcurrencyLocksAtomicityAndCollections;
+
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class BiCounterWithLock {
+	private int i = 0;
+	private int j = 0;
+	
+	Lock lockForI = new ReentrantLock();
+	Lock lockForJ = new ReentrantLock();
+	
+	public void incrementI() {		
+		lockForI.lock();//Get Lock For I 
+		i++;
+		lockForI.unlock();
+		//Release Lock For I
+	}
+
+	public int getI() {
+		return i;
+	}
+	
+	public void incrementJ() {
+		lockForJ.lock();//Get Lock For J
+		j++; 
+		lockForJ.unlock();//Release Lock For J
+	}
+
+	public int getJ() {
+		return j;
+	}
+
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/ConcurrencyRunner.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/ConcurrencyRunner.java
@@ -0,0 +1,14 @@
+package com.in28munites.ConcurrencyLocksAtomicityAndCollections;
+
+public class ConcurrencyRunner {
+
+	public static void main(String[] args) {
+		Counter counter = new Counter();
+		counter.increment();
+		counter.increment();
+		counter.increment();
+		System.out.println(counter.getI());
+
+	}
+
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/ConcurrentMapRunner.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/ConcurrentMapRunner.java
@@ -0,0 +1,41 @@
+package com.in28munites.ConcurrencyLocksAtomicityAndCollections;
+
+import java.util.Hashtable;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.LongAdder;
+
+public class ConcurrentMapRunner {
+
+	public static void main(String[] args) {
+		ConcurrentMap<Character, LongAdder> occurances = new ConcurrentHashMap<>();
+		
+		String str = "ABCD ABCD ABCD";
+
+		for(char character:str.toCharArray()) {
+			occurances.computeIfAbsent(character, ch -> new LongAdder()).increment();
+		}
+		
+		System.out.println(occurances);
+				
+
+	}
+
+	/*
+	 	Map<Character, LongAdder> occurances = new Hashtable<>();
+		
+		String str = "ABCD ABCD ABCD";
+		for(char character:str.toCharArray()) {
+			LongAdder longAdder = occurances.get(character);
+			if(longAdder == null) {
+				longAdder = new LongAdder();
+			}
+			longAdder.increment();
+			occurances.put(character, longAdder);
+		}
+		
+		System.out.println(occurances);
+
+	 */
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/CopyOnWriteArrayListRunner.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/CopyOnWriteArrayListRunner.java
@@ -0,0 +1,28 @@
+package com.in28munites.ConcurrencyLocksAtomicityAndCollections;
+
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class CopyOnWriteArrayListRunner {
+	
+	//add - copy
+	//get
+
+	public static void main(String[] args) {
+		List<String> list = new CopyOnWriteArrayList<>();
+		
+		//Threads - 3
+		list.add("Ant");
+		list.add("Bat");
+		list.add("Cat");
+		
+		//Threads - 10000
+		for(String element:list) {
+			System.out.println(element);
+		}
+		
+		// TODO Auto-generated method stub
+
+	}
+
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/Counter.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ConcurrencyLocksAtomicityAndCollections/Counter.java
@@ -0,0 +1,16 @@
+package com.in28munites.ConcurrencyLocksAtomicityAndCollections;
+
+public class Counter {
+	private int i = 0;
+	
+	synchronized public void increment() {
+		i++; 
+		//get i
+		//increment  
+		//set i
+	}
+
+	public int getI() {
+		return i;
+	}
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ExceptionHandling/CheckedExceptionRunner.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ExceptionHandling/CheckedExceptionRunner.java
@@ -0,0 +1,25 @@
+package com.in28munites.ExceptionHandling;
+
+public class CheckedExceptionRunner {
+	
+	public static void main(String[] args) {
+	/*	try {
+			someOtherMethod();
+			Thread.sleep(2000);
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}*/
+		//someOtherMethod1();
+		someOtherMethod2();
+
+	}
+	
+	private static void someOtherMethod2() throws RuntimeException{
+		
+	}
+	
+	private static void someOtherMethod() throws InterruptedException{
+		Thread.sleep(2000);
+	}
+
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ExceptionHandling/ExceptionHandlingRunner.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ExceptionHandling/ExceptionHandlingRunner.java
@@ -0,0 +1,20 @@
+package com.in28munites.ExceptionHandling;
+
+public class ExceptionHandlingRunner {
+
+	public static void main(String[] args) {
+		method1();
+		System.out.println("Main Ended");
+	}
+
+	private static void method1() {
+		method2();
+		System.out.println("Method1 Ended");
+	}
+
+	private static void method2() {
+		String str = null;
+		str.length();
+		System.out.println("Method2 Ended");
+	}
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ExceptionHandling/ExceptionHandlingRunner2.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ExceptionHandling/ExceptionHandlingRunner2.java
@@ -0,0 +1,33 @@
+package com.in28munites.ExceptionHandling;
+
+public class ExceptionHandlingRunner2 {
+
+	public static void main(String[] args) {
+		method1();
+		System.out.println("Main Ended");
+	}
+
+	private static void method1() {
+		method2();
+		System.out.println("Method1 Ended");
+	}
+
+	private static void method2() {
+		try {
+			//String str = null;
+			//str.length();
+			int[] i = {1,2};
+			int number = i[3];
+			System.out.println("Method2 Ended");
+		} catch (NullPointerException ex) {
+			System.out.println("Matched NullPointerException");
+			ex.printStackTrace();
+		} catch (ArrayIndexOutOfBoundsException ex) {
+			System.out.println("Matched ArrayIndexOutOfBoundsException");
+			ex.printStackTrace();
+		} catch (Exception ex) {
+			System.out.println("Matched Exception");
+			ex.printStackTrace();
+		}
+	}
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ExceptionHandling/FinallyRunner.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ExceptionHandling/FinallyRunner.java
@@ -0,0 +1,29 @@
+package com.in28munites.ExceptionHandling;
+
+import java.util.Scanner;
+
+public class FinallyRunner {
+
+	public static void main(String[] args) {
+		
+		Scanner scanner = null;
+
+		try {
+			scanner = new Scanner(System.in);
+			int[] numbers = { 12, 3, 4, 5 };
+
+			int number = numbers[21];
+
+		} catch (Exception e) {
+			e.printStackTrace();
+		} finally {
+			System.out.println("Before Scanner Close");
+			if(scanner!=null) {
+				scanner.close();
+			}
+		}
+		
+		System.out.println("Just before closing out main");
+	}
+
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ExceptionHandling/ThrowingExceptionRunner.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ExceptionHandling/ThrowingExceptionRunner.java
@@ -0,0 +1,48 @@
+package com.in28munites.ExceptionHandling;
+
+class Amount {
+	private String currency;
+	private int amount;
+	
+	public Amount(String currency, int amount) {
+		super();
+		this.currency = currency;
+		this.amount = amount;
+	}
+	
+	public void add(Amount that) throws CurrenciesDoNotMatchException {
+		
+		if(!this.currency.equals(that.currency)) {
+			//throw new Exception("Currencies Don't Match " + this.currency + " & " +that.currency );
+			throw new CurrenciesDoNotMatchException("Currencies Don't Match " + this.currency + " & " +that.currency );
+		}
+		
+		this.amount = this.amount + that.amount;
+	}
+	
+	public String toString() {
+		return amount + " " + currency; 
+	}
+}
+
+class CurrenciesDoNotMatchException extends Exception {
+	public CurrenciesDoNotMatchException(String msg) {
+		super(msg);
+	}
+}
+
+public class ThrowingExceptionRunner {
+
+	public static void main(String[] args) throws CurrenciesDoNotMatchException {
+		Amount amount1 = new Amount("USD", 10);
+		Amount amount2 = new Amount("EUR", 20);
+		try {
+			amount1.add(amount2);
+		} catch (CurrenciesDoNotMatchException e) {
+			System.out.println("Matched CurrenciesDoNotMatchException");
+			e.printStackTrace();
+		}
+		System.out.println(amount1);	
+	}
+
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ExceptionHandling/TryWithResourcesRunner.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/ExceptionHandling/TryWithResourcesRunner.java
@@ -0,0 +1,14 @@
+package com.in28munites.ExceptionHandling;
+
+import java.util.Scanner;
+
+public class TryWithResourcesRunner {
+
+	public static void main(String[] args) {
+		try (Scanner scanner = new Scanner(System.in)) {
+			int[] numbers = { 12, 3, 4, 5 };
+			int number = numbers[21];
+		} 
+	}
+
+}
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/FunctionalProgramming/LambdaBehindTheScreensRunner.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/FunctionalProgramming/LambdaBehindTheScreensRunner.java
diff --git a/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/FunctionalProgramming/MethodReferencesRunner.java b/in28Munites-JavaCourse-ForBeginners/src/com/in28munites/FunctionalProgramming/MethodReferencesRunner.java
