Sunday 8 March 2020

JAVA notes PDF Download - Handwritten Notes


Core Java

1- Core Java Notes Naresh Tech-      Download

2- Core Java Notes Satya Technology- Download

3- Core Java Notes Ratan Sir-        Download



AdvancedJava

1- JavaEE / J2EE Satya Tech. Notes- Download

2- JavaEE / J2EE Naresh Sir Notes-  Download

3- JavaEE / J2EE Santosh Sir Notes- Download


Spring PDF

1- Spring Notes Naresh Technology- Download

2- Spring Notes Natraj Sir-        Download

3- Spring Notes DurgaSoft- Part-1  Download

4- Spring Notes DurgaSoft- Part-2  Download


Hibernate PDF

1- Hibernate Notes Shekhar Sir- Download

2- Hibernate Notes Santosh Sir- Download

3- Hibernate Notes Natraj Sir-  Download


SCJP/OCJP Notes

1- SCJP/OCJP Notes Durga Sir Part 1- Download

2- SCJP/OCJP Notes Durga Sir Part 2- Download

Deadlock in Java and Solution

Deadlock in Java and Solution

Please find below the program for Deadlock in Java.




Solution: To Avoid Deadlock, replace the sequence of resources


Java 8 - Interface and Class

Please check one of the features of Java 8 related to the Interface and Class 

Program : 


Code Link

Saturday 1 February 2020

Array Program 1 : Find Evenly Repeated number from an Array

Array Program 1: Find the Evenly Repeated number from an Array


Input: int[] a = {1,1,5,4,8,1,5,8,3,9,15,15,16,2,8,7,9,1};

Output : [1, 5, 9, 15]


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package JavaPractice;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ArraysEvenOccurance {

 public static void main(String arg[]){
     int[] input = {1, 1, 5, 4, 8, 1, 5, 8, 3, 9, 15, 15, 16, 2, 8, 7, 9, 1};
     int[] output = new int[input.length];
        // sort input array
        Arrays.sort(input);
        
        int counter = 1, k = 0, j=0;
        for (int i = 1; i < input.length; i++) {
            if (input[k] == input[i]) {
                // check for same number
                counter++;
            } else {
                // check even number of counter
                if (counter % 2 == 0) {
                    output[j] = (input[k]);
                    j++;
                }
                counter = 1;
                k = i;
            }
        }
        // Removing Extra appended element (sub array)
        output = Arrays.copyOfRange(output, 0, j);
        // Print Result array
        System.out.println(Arrays.toString(output));
    }
}

Sunday 26 January 2020

What is Synchronization in Java

What is Synchronization in Java

Synchronization in java is the capability to control the access of multiple threads to any shared resource.


Example :


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
package JavaPractice;

import java.util.Date;

public class TestSynchronization {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Table obj = new Table();
  MyThread1 th1 = new MyThread1(obj, true); // true for Synchronization
  MyThread2 th2 = new MyThread2(obj, true);
  th1.start();
  th2.start();
 }

}

class Table {
 // method not Synchronization
 void printTable(int n) {
  for (int i = 1; i <= 5; i++) {
   System.out.println(n * i);
   try {
    Thread.sleep(400);
   } catch (Exception e) {
    System.out.println(e);
   }
  }

 }

 // method is Synchronization
 synchronized void printTableSynchronization(int n) {
  for (int i = 1; i <= 5; i++) {
   System.out.println(n * i);
   try {
    Thread.sleep(400);
   } catch (Exception e) {
    System.out.println(e);
   }
  }

 }
}

class MyThread1 extends Thread {
 Table t;
 boolean isCallSynchronization;

 MyThread1(Table t, boolean isCallSynchronization) {
  this.t = t;
  this.isCallSynchronization = isCallSynchronization;
 }

 public void run() {
  if (this.isCallSynchronization) {
   System.out.println(new Date());
   t.printTableSynchronization(5);
   System.out.println(new Date());
  } else {
   System.out.println(new Date());
   t.printTable(5);
   System.out.println(new Date());
  }
 }
}

class MyThread2 extends Thread {
 Table t;
 boolean isCallSynchronization;

 MyThread2(Table t, boolean isCallSynchronization) {
  this.t = t;
  this.isCallSynchronization = isCallSynchronization;
 }

 public void run() {
  if (this.isCallSynchronization) {
   System.out.println(new Date());
   t.printTableSynchronization(100);
   System.out.println(new Date());
  } else {
   System.out.println(new Date());
   t.printTable(100);
   System.out.println(new Date());
  }
 }
}

How to find Second Highest element in Array in Java

How to find Second Highest element in Array in Java
  • Three ways to find Second largest element in Array.
    1. using single for loop
    2. using Arrays.
    3. using Collections.
  • Example :
  •  1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    package JavaPractice;
    
    import java.util.*;
    import java.util.stream.Collectors;
    
    public class SecondLargestNumber {
     /**
      * Using Single For loop
      */
     public static void secondLargestNumberUsingSingleForLoop(int arr[],
       int arr_size) {
      int first, second;
      if (arr_size < 2) {
       System.out.print(" Invalid Input ");
       return;
      }
      first = second = Integer.MIN_VALUE;
      for (int i = 0; i < arr_size; i++) {
       if (arr[i] > first) {
        second = first;
        first = arr[i];
       } else if (arr[i] > second && arr[i] != first) {
        second = arr[i];
       }
      }
    
      if (second == Integer.MIN_VALUE)
       System.out.print("There is no second largest" + " element\n");
      else
       System.out.print("The second largest element" + " is " + second + "\n");
     }
    
     /**
      * Using Arrays
      */
     public static void secondLargestNumberUsingArrays(int arr[], int arr_size) {
      Arrays.sort(arr);
      System.out.print("The second largest element" + " is "
        + arr[arr_size - 2] + "\n");
     }
    
     /**
      * Using Collections and Stream
      */
     public static void secondLargestNumberUsingCollections(int arr[],
       int arr_size) {
      List<Integer> list = Arrays.stream(arr).boxed()
        .collect(Collectors.toList());
      Collections.sort(list);
      System.out.print("The second largest element" + " is "
        + list.get(arr_size - 2)+ "\n");
     }
     /**
      * Main Function
      */
     public static void main(String[] args) {
      int arr[] = { 12, 35, 1, 10, 34, 1 };
      int n = arr.length;
      secondLargestNumberUsingSingleForLoop(arr, n);
      secondLargestNumberUsingArrays(arr, n);
      secondLargestNumberUsingCollections(arr, n);
    
     }
    
    }