Java Interview Programs: Basic to Advanced (With Code)

Prepared collection of Java programs covering syntax, control flow, patterns, arrays & strings, OOP, exception
s & files, collections, algorithms, multithreading, Java 8 features, and mini system design demos. Each sectio
n includes concise, runnable code snippets (single-file examples).

Hello World program

public class Main {
public static void main(String[] args) {
[Link]("Hello, World!");
}
}
Sum of two numbers
import [Link];
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int a = [Link](), b = [Link]();
[Link](a + b);
[Link]();
}
}
Check even or odd
import [Link];
public class Main {
public static void main(String[] args) {
int n = new [Link]([Link]).nextInt();
[Link](n % 2 == 0 ? "Even" : "Odd");
}
}
Largest of two numbers
import [Link];
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int a = [Link](), b = [Link]();
[Link](a > b ? a : b);
[Link]();
}
}
Largest of three numbers
import [Link];
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
int a = [Link](), b = [Link](), c = [Link]();
int max = a;
if(b > max) max = b;
if(c > max) max = c;
[Link](max);
[Link]();
}
}
Positive, Negative, or Zero check
import [Link];
public class Main {
public static void main(String[] args) {
int n = new [Link]([Link]).nextInt();
if(n > 0) [Link]("Positive");
else if(n < 0) [Link]("Negative");
else [Link]("Zero");
}
}
Leap year check
import [Link];
public class Main {
public static void main(String[] args) {
int y = new [Link]([Link]).nextInt();
boolean leap = (y % 400 == 0) || (y % 4 == 0 && y % 100 != 0);
[Link](leap ? "Leap Year" : "Not Leap Year");
}
}
Swap two numbers (with and without third variable)
public class Main {
public static void main(String[] args) {
int a = 10, b = 20;
// With third variable
int temp = a; a = b; b = temp;
[Link](a + " " + b);
// Without third variable (XOR)
a = 10; b = 20;
a ^= b; b ^= a; a ^= b;
[Link](a + " " + b);
}
}
Factorial of a number (iterative)
import [Link];
public class Main {
public static void main(String[] args) {
int n = new [Link]([Link]).nextInt();
long fact = 1;
for(int i=2;i<=n;i++) fact *= i;
[Link](fact);
}
}
Fibonacci series (first N)
import [Link];
public class Main {
public static void main(String[] args) {
int n = new [Link]([Link]).nextInt();
long a=0,b=1;
for(int i=0;i<n;i++){
[Link](a + (i<n-1?" ":""));
long c=a+b; a=b; b=c;
}
}
}
Reverse a number
import [Link];
public class Main {
public static void main(String[] args) {
int n = new [Link]([Link]).nextInt();
int rev = 0;
while(n!=0){ rev = rev*10 + n%10; n/=10; }
[Link](rev);
}
}
Palindrome number check
import [Link];
public class Main {
public static void main(String[] args) {
int n = new [Link]([Link]).nextInt();
int t = n, rev = 0;
while(n!=0){ rev = rev*10 + n%10; n/=10; }
[Link](t==rev ? "Palindrome" : "Not Palindrome");
 }
}
Armstrong number check (3-digit)
import [Link];
public class Main {
public static void main(String[] args) {
int n = new [Link]([Link]).nextInt();
int t = n, sum=0;
while(t!=0){ int d=t%10; sum += d*d*d; t/=10; }
[Link](sum==n ? "Armstrong" : "Not Armstrong");
}
}
Prime number check
import [Link];
public class Main {
public static void main(String[] args) {
int n = new [Link]([Link]).nextInt();
if(n<2){ [Link]("Not Prime"); return; }
for(int i=2;i*i<=n;i++) if(n%i==0){ [Link]("Not Prime"); return; }
[Link]("Prime");
}
}
Print all prime numbers between 1 to N
import [Link];
public class Main {
static boolean isPrime(int n){
if(n<2) return false;
for(int i=2;i*i<=n;i++) if(n%i==0) return false;
return true;
}
public static void main(String[] args) {
int n = new [Link]([Link]).nextInt();
for(int i=2;i<=n;i++) if(isPrime(i)) [Link](i + " ");
}
}
Table of a number (multiplication table)
import [Link];
public class Main {
public static void main(String[] args) {
int n = new [Link]([Link]).nextInt();
for(int i=1;i<=10;i++) [Link](n + " x " + i + " = " + (n*i));
}
}
Sum of digits of a number
import [Link];
public class Main {
public static void main(String[] args) {
int n = new [Link]([Link]).nextInt();
int sum=0; while(n!=0){ sum+=n%10; n/=10; }
[Link](sum);
}
}
Print numbers 1 to 100 without loop (using recursion)
public class Main {
static void print(int i){
if(i>100) return;
[Link](i);
print(i+1);
}
public static void main(String[] args) { print(1); }
}
Square pattern (****)
public class Main {
public static void main(String[] args) {
int n=4;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++) [Link]("*");
[Link]();
}
}
}
Right triangle pattern
public class Main {
public static void main(String[] args) {
int n=5;
for(int i=1;i<=n;i++){
for(int j=1;j<=i;j++) [Link]("*");
[Link]();
}
}
}
Inverted triangle pattern
public class Main {
public static void main(String[] args) {
int n=5;
for(int i=n;i>=1;i--){
for(int j=1;j<=i;j++) [Link]("*");
[Link]();
}
}
}
Pyramid pattern
public class Main {
public static void main(String[] args) {
int n=5;
for(int i=1;i<=n;i++){
for(int s=1;s<=n-i;s++) [Link](" ");
for(int j=1;j<=2*i-1;j++) [Link]("*");
[Link]();
}
}
}
Diamond pattern
public class Main {
public static void main(String[] args) {
int n=5;
for(int i=1;i<=n;i++){
for(int s=1;s<=n-i;s++) [Link](" ");
for(int j=1;j<=2*i-1;j++) [Link]("*");
[Link]();
}
for(int i=n-1;i>=1;i--){
for(int s=1;s<=n-i;s++) [Link](" ");
for(int j=1;j<=2*i-1;j++) [Link]("*");
[Link]();
}
}
}
Number pattern (1, 12, 123, ...)
public class Main {
public static void main(String[] args) {
int n=5;
for(int i=1;i<=n;i++){
 for(int j=1;j<=i;j++) [Link](j);
[Link]();
}
}
}
Alphabet pattern (A, AB, ABC, ...)
public class Main {
public static void main(String[] args) {
int n=5;
for(int i=1;i<=n;i++){
for(char c='A'; c<'A'+i; c++) [Link](c);
[Link]();
}
}
}
Find largest and smallest element in an array
public class Main {
public static void main(String[] args) {
int[] a = {5, 2, 9, -1, 7};
int min=a[0], max=a[0];
for(int v: a){ if(v<min) min=v; if(v>max) max=v; }
[Link]("Min="+min+", Max="+max);
}
}
Reverse an array
import [Link];
public class Main {
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
for(int i=0,j=[Link]-1;i<j;i++,j--){
int t=a[i]; a[i]=a[j]; a[j]=t;
}
[Link]([Link](a));
}
}
Sort an array (ascending/descending)
import [Link].*;
public class Main {
public static void main(String[] args) {
Integer[] a = {5,1,4,2,3};
[Link](a); // ascending
[Link]([Link](a));
[Link](a, [Link]()); // descending
[Link]([Link](a));
}
}
Find duplicate elements in an array
import [Link].*;
public class Main {
public static void main(String[] args) {
int[] a = {1,2,3,1,2,4,5};
[Link]<Integer> seen = new [Link]<>();
[Link]<Integer> dup = new [Link]<>();
for(int v: a) if() [Link](v);
[Link](dup);
}
}
Find missing number in array (1 to N)
public class Main {
public static void main(String[] args) {
int[] a = {1,2,4,5};
int n = 5;
 int sum = n*(n+1)/2;
int s = 0; for(int v: a) s+=v;
[Link](sum - s);
}
}
Find second largest element in an array
public class Main {
public static void main(String[] args) {
int[] a = {5,1,9,2,9,7};
Integer first=null, second=null;
for(int v: a){
if(first==null || v>first){ second=first; first=v; }
else if(v!=first && (second==null || v>second)) second=v;
}
[Link](second);
}
}
Matrix addition, subtraction, multiplication
public class Main {
public static void main(String[] args) {
int[][] A={{1,2},{3,4}};
int[][] B={{5,6},{7,8}};
int n=2;
int[][] add=new int[n][n], sub=new int[n][n], mul=new int[n][n];
for(int i=0;i<n;i++) for(int j=0;j<n;j++){
add[i][j]=A[i][j]+B[i][j];
sub[i][j]=A[i][j]-B[i][j];
}
for(int i=0;i<n;i++) for(int j=0;j<n;j++)
for(int k=0;k<n;k++) mul[i][j]+=A[i][k]*B[k][j];
// Print one result as example
for(int[] r: mul){
for(int v: r) [Link](v + " ");
[Link]();
}
}
}
Transpose of a matrix
public class Main {
public static void main(String[] args) {
int[][] A={{1,2,3},{4,5,6}};
int r=[Link], c=A[0].length;
int[][] T=new int[c][r];
for(int i=0;i<r;i++) for(int j=0;j<c;j++) T[j][i]=A[i][j];
for(int[] row: T){ for(int v: row) [Link](v + " "); [Link](); }
}
}
String reversal
public class Main {
public static void main(String[] args) {
String s = "hello";
StringBuilder sb = new StringBuilder(s);
[Link]([Link]().toString());
}
}
Check if a string is a palindrome
public class Main {
public static void main(String[] args) {
String s="madam";
String r=new StringBuilder(s).reverse().toString();
[Link]([Link](r) ? "Palindrome" : "Not Palindrome");
}
}
Count vowels and consonants in a string
public class Main {
public static void main(String[] args) {
String s="Interview Prep";
s=[Link]();
int v=0,c=0;
for(char ch: [Link]()){
if(ch>='a' && ch<='z'){
if("aeiou".indexOf(ch)>=0) v++; else c++;
}
}
[Link]("Vowels="+v+", Consonants="+c);
}
}
Remove duplicate characters from string
import [Link];
public class Main {
public static void main(String[] args) {
String s="programming";
[Link]<Character> set=new LinkedHashSet<>();
StringBuilder sb=new StringBuilder();
for(char ch: [Link]()) if([Link](ch)) [Link](ch);
[Link]([Link]());
}
}
Find first non-repeated character in string
import [Link].*;
public class Main {
public static void main(String[] args) {
String s="swiss";
Map<Character,Integer> map=new LinkedHashMap<>();
for(char ch: [Link]()) [Link](ch, [Link](ch,0)+1);
for([Link]<Character,Integer> e: [Link]())
if([Link]()==1){ [Link]([Link]()); return; }
[Link]("None");
}
}
Check anagram strings
import [Link];
public class Main {
public static void main(String[] args) {
String a="listen", b="silent";
char[] x=[Link]("\\s","").toLowerCase().toCharArray();
char[] y=[Link]("\\s","").toLowerCase().toCharArray();
[Link](x); [Link](y);
[Link]([Link](x,y) ? "Anagram" : "Not Anagram");
}
}
Find substring in a string (without contains())
public class Main {
static boolean contains(String s, String sub){
for(int i=0;i+[Link]()<=[Link]();i++){
int j=0;
while(j<[Link]() && [Link](i+j)==[Link](j)) j++;
if(j==[Link]()) return true;
}
return false;
}
public static void main(String[] args) {
[Link](contains("helloworld","world"));
}
}
Class and Object demo
class Person {
String name; int age;
void introduce(){ [Link](name + ", " + age); }
}
public class Main {
public static void main(String[] args) {
Person p=new Person(); [Link]="Alice"; [Link]=25; [Link]();
}
}
Constructor demo (default, parameterized, copy)
class Box {
int w,h;
Box(){ this.w=1; this.h=1; }
Box(int w,int h){ this.w=w; this.h=h; }
Box(Box b){ this.w=b.w; this.h=b.h; }
int area(){ return w*h; }
}
public class Main {
public static void main(String[] args) {
Box a=new Box(), b=new Box(2,3), c=new Box(b);
[Link]([Link]()+" "+[Link]()+" "+[Link]());
}
}
Method overloading & overriding
class Calc {
int add(int a,int b){ return a+b; }
int add(int a,int b,int c){ return a+b+c; } // overloading
}
class AdvCalc extends Calc {
@Override int add(int a,int b){ return [Link](a,b)+1; } // overriding
}
public class Main {
public static void main(String[] args) {
Calc c=new Calc(); AdvCalc ac=new AdvCalc();
[Link]([Link](1,2));
[Link]([Link](1,2));
}
}
Inheritance example (single, multilevel, hierarchical)
class A { void f(){ [Link]("A"); } }
class B extends A { void g(){ [Link]("B"); } } // single
class C extends B { void h(){ [Link]("C"); } } // multilevel
class D extends A { void i(){ [Link]("D"); } } // hierarchical
public class Main {
public static void main(String[] args) {
new C().f(); new C().g(); new C().h();
new D().f(); new D().i();
}
}
Abstract class program
abstract class Shape { abstract double area(); }
class Circle extends Shape {
double r; Circle(double r){ this.r=r; }
double area(){ return [Link]*r*r; }
}
public class Main {
public static void main(String[] args) {
Shape s = new Circle(2.0);
[Link]([Link]());
}
}
Interface example
interface Drawable { void draw(); }
class Square implements Drawable {
public void draw(){ [Link]("Drawing square"); }
}
public class Main {
public static void main(String[] args) {
Drawable d = new Square(); [Link]();
}
}
Encapsulation (getters & setters)
class Employee {
private int id; private String name;
public int getId(){ return id; }
public void setId(int id){ [Link] = id; }
public String getName(){ return name; }
public void setName(String name){ [Link] = name; }
}
public class Main {
public static void main(String[] args) {
Employee e=new Employee(); [Link](1); [Link]("Bob");
[Link]([Link]()+": "+[Link]());
}
}
Polymorphism demo
class Animal { void sound(){ [Link]("some sound"); } }
class Dog extends Animal { void sound(){ [Link]("bark"); } }
class Cat extends Animal { void sound(){ [Link]("meow"); } }
public class Main {
public static void main(String[] args) {
Animal a=new Dog(); [Link]();
a=new Cat(); [Link]();
}
}
Static keyword demo
public class Main {
static int count=0;
public Main(){ count++; }
public static void main(String[] args) {
new Main(); new Main();
[Link]([Link]);
}
}
this and super keyword usage
class Base {
int x=10;
Base(int x){ this.x = x; }
}
class Derived extends Base {
int x=20;
Derived(){ super(5); [Link](this.x + ", " + super.x); }
}
public class Main { public static void main(String[] args){ new Derived(); } }
Try–catch–finally example
public class Main {
public static void main(String[] args) {
try{
int x = 10/0;
}catch(ArithmeticException e){
[Link]("Cannot divide by zero");
}finally{
[Link]("Finally always runs");
}
}
}
Throw and throws usage
public class Main {
static int div(int a,int b) throws ArithmeticException {
if(b==0) throw new ArithmeticException("b cannot be zero");
return a/b;
}
public static void main(String[] args) {
[Link](div(10,2));
}
}
Custom exception program
class InvalidAgeException extends Exception {
InvalidAgeException(String msg){ super(msg); }
}
public class Main {
static void vote(int age) throws InvalidAgeException {
if(age<18) throw new InvalidAgeException("Underage");
}
public static void main(String[] args) {
try{ vote(16); }catch(Exception e){ [Link]([Link]()); }
}
}
Read from a file
import [Link].*;
public class Main {
public static void main(String[] args) throws Exception {
try(BufferedReader br = new BufferedReader(new FileReader("[Link]"))){
String line; while((line=[Link]())!=null) [Link](line);
}
}
}
Write to a file
import [Link].*;
public class Main {
public static void main(String[] args) throws Exception {
try(BufferedWriter bw = new BufferedWriter(new FileWriter("[Link]"))){
[Link]("Hello file");
}
}
}
Count words in a file
import [Link].*;
public class Main {
public static void main(String[] args) throws Exception {
int words=0;
try(BufferedReader br = new BufferedReader(new FileReader("[Link]"))){
String line;
while((line=[Link]())!=null){
String[] parts=[Link]().split("\\s+");
if([Link]==1 && parts[0].isEmpty()) continue;
words += [Link];
}
}
[Link](words);
}
}
Copy content of one file to another
import [Link].*;
public class Main {
public static void main(String[] args) throws Exception {
try(BufferedInputStream in = new BufferedInputStream(new FileInputStream("[Link]"));
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("[Link]"))){
 byte[] buf = new byte[4096]; int len;
while((len=[Link](buf))!=-1) [Link](buf,0,len);
}
}
}
ArrayList demo (add, remove, iterate)
import [Link].*;
public class Main {
public static void main(String[] args) {
List<String> list=new ArrayList<>();
[Link]("a"); [Link]("b"); [Link]("a");
for(String s: list) [Link](s);
}
}
LinkedList demo
import [Link].*;
public class Main {
public static void main(String[] args) {
LinkedList<Integer> q=new LinkedList<>();
[Link](1); [Link](0); [Link](2);
[Link](q);
}
}
HashSet & TreeSet demo
import [Link].*;
public class Main {
public static void main(String[] args) {
Set<Integer> hs=new HashSet<>(); [Link](3); [Link](1); [Link](3);
[Link](hs);
Set<Integer> ts=new TreeSet<>(hs);
[Link](ts);
}
}
HashMap & TreeMap demo
import [Link].*;
public class Main {
public static void main(String[] args) {
Map<String,Integer> map=new HashMap<>();
[Link]("a",1); [Link]("b",2);
[Link](map);
Map<String,Integer> tmap=new TreeMap<>(map);
[Link](tmap);
}
}
Iterate through HashMap (entrySet, keySet, values)
import [Link].*;
public class Main {
public static void main(String[] args) {
Map<String,Integer> map=new HashMap<>();
[Link]("x",10); [Link]("y",20);
for([Link]<String,Integer> e: [Link]()) [Link]([Link]()+"="+[Link]()
for(String k: [Link]()) [Link](k);
for(Integer v: [Link]()) [Link](v);
}
}
Sort elements using [Link]()
import [Link].*;
public class Main {
public static void main(String[] args) {
List<Integer> list=[Link](5,3,1,4,2);
[Link](list);
[Link](list);
 [Link](list, [Link]());
[Link](list);
}
}
Convert Array to List and vice versa
import [Link].*;
public class Main {
public static void main(String[] args) {
String[] a = {"a","b","c"};
List<String> list = new ArrayList<>([Link](a));
String[] back = [Link](new String[0]);
[Link](list + " | " + [Link](back));
}
}
Frequency of elements using HashMap
import [Link].*;
public class Main {
public static void main(String[] args) {
int[] a={1,2,2,3,3,3};
Map<Integer,Integer> freq=new HashMap<>();
for(int v: a) [Link](v, [Link](v,0)+1);
[Link](freq);
}
}
Remove duplicates from list using Set
import [Link].*;
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>([Link](1,2,2,3,3,4));
List<Integer> unique = new ArrayList<>(new LinkedHashSet<>(list));
[Link](unique);
}
}
Reverse words in a sentence
public class Main {
public static void main(String[] args) {
String s="Java is fun";
String[] parts=[Link]("\\s+");
StringBuilder sb=new StringBuilder();
for(int i=[Link]-1;i>=0;i--) [Link](parts[i]).append(i==0?"":" ");
[Link]([Link]());
}
}
Check balanced parentheses using Stack
import [Link].*;
public class Main {
static boolean balanced(String s){
Map<Character,Character> m=new HashMap<>();
[Link](')', '('); [Link](']', '['); [Link]('}', '{');
Deque<Character> st=new ArrayDeque<>();
for(char ch: [Link]()){
if([Link](ch)) [Link](ch);
else if([Link](ch)) if([Link]() || [Link]()!=[Link](ch)) return false;
}
return [Link]();
}
public static void main(String[] args) { [Link](balanced("{[()]}")); }
}
Find factorial using recursion
public class Main {
static long fact(int n){ return n<=1 ? 1 : n*fact(n-1); }
public static void main(String[] args) { [Link](fact(5)); }
}
Find nth Fibonacci number using recursion
public class Main {
static long fib(int n){ return n<=1 ? n : fib(n-1)+fib(n-2); }
public static void main(String[] args) { [Link](fib(10)); }
}
Binary search implementation
public class Main {
static int bs(int[] a,int key){
int l=0,r=[Link]-1;
while(l<=r){
int m=l+(r-l)/2;
if(a[m]==key) return m;
if(a[m]<key) l=m+1; else r=m-1;
}
return -1;
}
public static void main(String[] args) {
int[] a={1,3,5,7,9};
[Link](bs(a,7));
}
}
Linear search implementation
public class Main {
static int ls(int[] a,int key){
for(int i=0;i<[Link];i++) if(a[i]==key) return i;
return -1;
}
public static void main(String[] args) {
int[] a={4,2,7,1};
[Link](ls(a,7));
}
}
Bubble sort, Selection sort, Insertion sort
import [Link];
public class Main {
static void bubble(int[] a){
for(int i=0;i<[Link]-1;i++)
for(int j=0;j<[Link]-1-i;j++)
if(a[j]>a[j+1]){ int t=a[j]; a[j]=a[j+1]; a[j+1]=t; }
}
static void selection(int[] a){
for(int i=0;i<[Link]-1;i++){
int min=i;
for(int j=i+1;j<[Link];j++) if(a[j]<a[min]) min=j;
int t=a[i]; a[i]=a[min]; a[min]=t;
}
}
static void insertion(int[] a){
for(int i=1;i<[Link];i++){
int key=a[i], j=i-1;
while(j>=0 && a[j]>key){ a[j+1]=a[j]; j--; }
a[j+1]=key;
}
}
public static void main(String[] args) {
int[] a={5,1,4,2,8};
bubble([Link]()); selection([Link]()); insertion([Link]());
[Link]([Link](a));
}
}
Quick sort, Merge sort
import [Link];
public class Main {
static void quick(int[] a,int l,int r){
if(l>=r) return;
int i=l,j=r,p=a[l+(r-l)/2];
while(i<=j){
while(a[i]<p) i++;
while(a[j]>p) j--;
if(i<=j){ int t=a[i]; a[i]=a[j]; a[j]=t; i++; j--; }
}
if(l<j) quick(a,l,j);
if(i<r) quick(a,i,r);
}
static void mergeSort(int[] a,int l,int r){
if(l>=r) return;
int m=(l+r)/2;
mergeSort(a,l,m); mergeSort(a,m+1,r);
int[] tmp=new int[r-l+1]; int i=l,j=m+1,k=0;
while(i<=m && j<=r) tmp[k++]= a[i]<=a[j]? a[i++]:a[j++];
while(i<=m) tmp[k++]=a[i++];
while(j<=r) tmp[k++]=a[j++];
[Link](tmp,0,a,l,[Link]);
}
public static void main(String[] args) {
int[] a={5,2,9,1,5,6};
quick(a,0,[Link]-1);
mergeSort(a,0,[Link]-1);
[Link]([Link](a));
}
}
Count occurrences of each word in a string
import [Link].*;
public class Main {
public static void main(String[] args) {
String s="to be or not to be";
Map<String,Integer> map=new LinkedHashMap<>();
for(String w: [Link]().toLowerCase().split("\\s+"))
[Link](w, [Link](w,0)+1);
[Link](map);
}
}
Find longest substring without repeating characters
import [Link].*;
public class Main {
public static void main(String[] args) {
String s="abcabcbb";
int l=0, best=0; Map<Character,Integer> pos=new HashMap<>();
for(int r=0;r<[Link]();r++){
char c=[Link](r);
if([Link](c) && [Link](c)>=l) l=[Link](c)+1;
[Link](c,r); best=[Link](best, r-l+1);
}
[Link](best);
}
}
LRU Cache implementation using LinkedHashMap
import [Link].*;
class LRU<K,V> extends LinkedHashMap<K,V>{
private final int cap;
LRU(int cap){ super(cap, 0.75f, true); [Link]=cap; }
protected boolean removeEldestEntry([Link]<K,V> e){ return size()>cap; }
}
public class Main {
public static void main(String[] args) {
LRU<Integer,Integer> cache=new LRU<>(2);
 [Link](1,1); [Link](2,2); [Link](1); [Link](3,3);
[Link]([Link]());
}
}
Producer–Consumer problem using Threads
import [Link];
public class Main {
public static void main(String[] args) throws Exception {
ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<>(2);
Thread producer = new Thread(() -> {
try{
for(int i=1;i<=5;i++){ [Link](i); [Link]("Produced "+i); }
}catch(Exception ignored){}
});
Thread consumer = new Thread(() -> {
try{
for(int i=1;i<=5;i++){ [Link]("Consumed "+[Link]()); }
}catch(Exception ignored){}
});
[Link](); [Link]();
[Link](); [Link]();
}
}
Deadlock example in Java
public class Main {
public static void main(String[] args) throws Exception {
final Object A=new Object(); final Object B=new Object();
Thread t1=new Thread(()->{ synchronized(A){ try{[Link](100);}catch(Exception e){} synchro
){} } });
Thread t2=new Thread(()->{ synchronized(B){ try{[Link](100);}catch(Exception e){} synchro
){} } });
[Link](); [Link](); [Link](); [Link]();
}
}
Singleton design pattern implementation
class Singleton {
private static volatile Singleton instance;
private Singleton(){}
public static Singleton getInstance(){
if(instance==null){
synchronized([Link]){
if(instance==null) instance=new Singleton();
}
}
return instance;
}
}
public class Main { public static void main(String[] args){ [Link]([Link]())
Create thread using Thread class
public class Main extends Thread {
public void run(){ [Link]("Hello from Thread"); }
public static void main(String[] args){ new Main().start(); }
}
Create thread using Runnable interface
public class Main {
public static void main(String[] args){
Runnable r = () -> [Link]("Hello from Runnable");
new Thread(r).start();
}
}
Synchronization example
class Counter {
 int c=0;
synchronized void inc(){ c++; }
}
public class Main {
public static void main(String[] args) throws Exception {
Counter ctr=new Counter();
Thread t1=new Thread(()->{ for(int i=0;i<1000;i++) [Link](); });
Thread t2=new Thread(()->{ for(int i=0;i<1000;i++) [Link](); });
[Link](); [Link](); [Link](); [Link]();
[Link](ctr.c);
}
}
Inter-thread communication (wait(), notify())
class Shared {
private int data; private boolean ready=false;
synchronized void produce(int v) throws InterruptedException {
while(ready) wait();
data=v; ready=true; notify();
}
synchronized int consume() throws InterruptedException {
while(!ready) wait();
ready=false; notify(); return data;
}
}
public class Main {
public static void main(String[] args) throws Exception {
Shared s=new Shared();
Thread p=new Thread(()->{ try{ [Link](42); }catch(Exception e){} });
Thread c=new Thread(()->{ try{ [Link]([Link]()); }catch(Exception e){} });
[Link](); [Link](); [Link](); [Link]();
}
}
Thread pool example (ExecutorService)
import [Link].*;
public class Main {
public static void main(String[] args) throws Exception {
ExecutorService pool=[Link](2);
for(int i=1;i<=4;i++){
final int id=i;
[Link](()-> [Link]("Task "+id+" by "+[Link]().getName()));
}
[Link]();
}
}
Lambda expressions example
interface Op { int run(int a,int b); }
public class Main {
public static void main(String[] args) {
Op add=(a,b)->a+b;
[Link]([Link](2,3));
}
}
Functional interfaces (Predicate, Function, Consumer)
import [Link].*;
public class Main {
public static void main(String[] args) {
Predicate<Integer> isEven = x -> x%2==0;
Function<Integer,Integer> square = x -> x*x;
Consumer<Integer> print = [Link]::println;
if([Link](4)) [Link]([Link](4));
}
}
Streams API (filter, map, reduce, collect)
import [Link].*;
import [Link].*;
public class Main {
public static void main(String[] args) {
List<Integer> nums=[Link](1,2,3,4,5);
int sumSquaresOfEven = [Link]().filter(x->x%2==0).map(x->x*x).reduce(0,Integer::sum);
List<Integer> doubled = [Link]().map(x->x*2).collect([Link]());
[Link](sumSquaresOfEven + " " + doubled);
}
}
Method references
import [Link].*;
public class Main {
static void print(Integer x){ [Link](x); }
public static void main(String[] args) {
List<Integer> list=[Link](1,2,3);
[Link](Main::print);
}
}
Optional class usage
import [Link];
public class Main {
public static void main(String[] args) {
Optional<String> o = [Link](null);
[Link]([Link]("default"));
}
}
Library Management System (mini demo)
import [Link].*;
class Book { String id,title; boolean issued; Book(String id,String t){[Link]=id;[Link]=t;} }
class Library {
Map<String,Book> books=new HashMap<>();
void add(Book b){ [Link]([Link],b); }
boolean issue(String id){ Book b=[Link](id); if(b!=null && ![Link]){ [Link]=true; return tru
turn false; }
void list(){ [Link]().forEach(b->[Link]([Link]+":"+[Link]+":"+[Link])); }
}
public class Main {
public static void main(String[] args) {
Library lib=new Library(); [Link](new Book("1","Java Basics")); [Link](new Book("2","DSA"));
[Link]("1"); [Link]();
}
}
Banking System (deposit, withdraw, balance)
class Account {
private int balance;
Account(int bal){ [Link]=bal; }
synchronized void deposit(int amt){ balance+=amt; }
synchronized boolean withdraw(int amt){ if(amt<=balance){ balance-=amt; return true; } return false
synchronized int balance(){ return balance; }
}
public class Main {
public static void main(String[] args) {
Account acc=new Account(1000);
[Link](500); [Link](200);
[Link]([Link]());
}
}
Employee Management System (mini)
import [Link].*;
class Employee { int id; String name; Employee(int id,String n){[Link]=id;[Link]=n;} }
class EMS {
Map<Integer,Employee> map=new HashMap<>();
 void add(Employee e){ [Link]([Link],e); }
Employee get(int id){ return [Link](id); }
}
public class Main { public static void main(String[] args){ EMS s=new EMS(); [Link](new Employee(1,"Ana"
[Link]([Link](1).name); } }
Student Management System (mini)
import [Link].*;
class Student { int id; String name; Student(int id,String n){[Link]=id;[Link]=n;} }
class SMS {
Map<Integer,Student> map=new HashMap<>();
void add(Student s){ [Link]([Link],s); }
Student get(int id){ return [Link](id); }
}
public class Main { public static void main(String[] args){ SMS s=new SMS(); [Link](new Student(1,"Max")
[Link]([Link](1).name); } }