diff --git a/132Pattern.java b/132Pattern.java
new file mode 100644
index 0000000..c2ea662
--- /dev/null
+++ b/132Pattern.java
@@ -0,0 +1,38 @@
+class 132Pattern
+{
+static boolean pattern(int a[])
+{
+int n=a.length;
+int min[]=new int[n];
+min[0]=a[0];
+for(int i=1;i<n;i++)
+{
+min[i]=Math.min(min[i-1],a[i]);
+}
+
+Stack<Integer> st=new Stack<>();
+for(int i=n-1;i>=0;i--)
+{
+if(nums[i]>min[i])
+{
+while(!st.isEmpty() && st.peek()<=min[i])
+{
+st.pop();
+}
+
+if(!st.isEmpty() && st.peek()<a[i])
+{
+return true;
+}
+st.push(a[i]);
+}
+}
+
+return false;
+}
+public static void main(String args[])
+{
+int []={3,1,4,2};
+pattern(a);
+}
+}
\ No newline at end of file
diff --git a/A.class b/A.class
new file mode 100644
index 0000000..c1e0110
Binary files /dev/null and b/A.class differ
diff --git a/Abstract2.class b/Abstract2.class
new file mode 100644
index 0000000..5dab1fb
Binary files /dev/null and b/Abstract2.class differ
diff --git a/Abstract2.java b/Abstract2.java
new file mode 100644
index 0000000..76a7f87
--- /dev/null
+++ b/Abstract2.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class Abstract2
+{
+public static void main(String args[])
+{
+AbstractSet<Integer> set=new TreeSet<>();
+set.add(10);
+set.add(11);
+set.add(12);
+set.add(8);
+System.out.println(set);
+if(set.contains(12))
+{
+System.out.println("Yes");
+}
+else
+System.out.println("No");
+}
+}
\ No newline at end of file
diff --git a/Abstract4.class b/Abstract4.class
new file mode 100644
index 0000000..36ab850
Binary files /dev/null and b/Abstract4.class differ
diff --git a/AbstractList1.class b/AbstractList1.class
new file mode 100644
index 0000000..4d73432
Binary files /dev/null and b/AbstractList1.class differ
diff --git a/AbstractList1.java b/AbstractList1.java
new file mode 100644
index 0000000..33cbabf
--- /dev/null
+++ b/AbstractList1.java
@@ -0,0 +1,15 @@
+import java.util.*;
+class AbstractList1
+{
+public static void main(String args[])
+{
+AbstractList<String> str=new ArrayList<>();
+str.add("sujit");
+str.add("kumar");
+str.add("gaurav");
+str.add("kushal");
+System.out.println(str);
+str.remove(2);
+System.out.println(str);
+}
+}
\ No newline at end of file
diff --git a/AbstractList2.java b/AbstractList2.java
new file mode 100644
index 0000000..367e3f2
--- /dev/null
+++ b/AbstractList2.java
@@ -0,0 +1,15 @@
+import java.util.*;
+class AbstractList2
+{
+public static void main(String args[])
+{
+AbstractList<String> ab=new LinkedList<>();
+ab.add("kumar");
+ab.add("sujit");
+ab.add("kushal");
+ab.add("vikash");
+System.out.println(ab);
+int index=ab.lastIndexOf("vikash");
+System.out.println(index);
+}
+}
\ No newline at end of file
diff --git a/AddLink$Node.class b/AddLink$Node.class
new file mode 100644
index 0000000..523d828
Binary files /dev/null and b/AddLink$Node.class differ
diff --git a/AddLink.class b/AddLink.class
new file mode 100644
index 0000000..47c5eaa
Binary files /dev/null and b/AddLink.class differ
diff --git a/AddLink.java b/AddLink.java
new file mode 100644
index 0000000..afd8b4d
--- /dev/null
+++ b/AddLink.java
@@ -0,0 +1,108 @@
+class AddLink
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void push(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+AddLink AddTwoLink(Node head1,Node head2)
+{
+Node temp1=head1;
+Node temp2=head2;
+int x=0;
+int y=0;
+int sum=0;
+int carry=0;
+AddLink l=new AddLink();
+while(temp1!=null|| temp2!=null)
+{
+if(temp1!=null)
+{
+x=temp1.data;
+}else{
+x=0;
+}
+
+if(temp2!=null)
+{
+y=temp2.data;
+}else
+{
+y=0;
+}
+
+sum=carry+x+y;
+carry=sum/10;
+l.push(sum%10);
+
+if(temp1!=null)
+temp1=temp1.next;
+
+if(temp2!=null)
+temp2=temp2.next;
+
+}
+if(carry!=0)
+{
+l.push(carry);
+}
+return l;
+}
+
+public static void main(String args[])
+{
+AddLink a=new AddLink();
+a.push(9);
+a.push(9);
+a.push(9);
+a.push(9);
+a.push(9);
+a.push(9);
+a.push(9);
+a.print();
+
+AddLink a1=new AddLink();
+a1.push(9);
+a1.push(9);
+a1.push(9);
+a1.push(9);
+a1.print();
+AddLink a2=new AddLink();
+a2=a2.AddTwoLink(a.head,a1.head);
+a2.print();
+}
+}
\ No newline at end of file
diff --git a/AddLinked1$Node.class b/AddLinked1$Node.class
new file mode 100644
index 0000000..a4896e3
Binary files /dev/null and b/AddLinked1$Node.class differ
diff --git a/AddLinked1.class b/AddLinked1.class
new file mode 100644
index 0000000..1c4ee39
Binary files /dev/null and b/AddLinked1.class differ
diff --git a/AddLinked1.java b/AddLinked1.java
new file mode 100644
index 0000000..d8c58b7
--- /dev/null
+++ b/AddLinked1.java
@@ -0,0 +1,112 @@
+class AddLinked1
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+AddLinked1 AddLinked(Node head1,Node head2)
+{
+Node temp1=head1;
+Node temp2=head2;
+int x=0;
+int y=0;
+int carry=0;
+int sum=0;
+AddLinked1 l1=new AddLinked1();
+while(temp1!=null || temp2!=null)
+{
+if(temp1!=null)
+{
+x=temp1.data;
+}
+else
+{
+x=0;
+}
+if(temp2!=null)
+{
+y=temp2.data;
+}
+else
+{
+y=0;
+}
+sum=carry+x+y;
+carry=sum/10;
+l1.append(sum%10);
+if(temp1!=null)
+{
+temp1=temp1.next;
+}
+
+if(temp2!=null)
+{
+temp2=temp2.next;
+}
+}
+if(carry!=0)
+{
+l1.append(carry);
+}
+return l1;
+}
+
+public static void main(String args[])
+{
+AddLinked1 l1=new AddLinked1();
+l1.append(9);
+l1.append(9);
+l1.append(9);
+l1.append(9);
+l1.append(9);
+l1.append(9);
+l1.append(9);
+l1.print();
+
+AddLinked1 l2=new AddLinked1();
+l2.append(9);
+l2.append(9);
+l2.append(9);
+l2.append(9);
+l2.print();
+AddLinked1 l3=new AddLinked1();
+System.out.println("Addtion of two linkedList");
+l3=l3.AddLinked(l1.head,l2.head);
+l3.print();
+}
+}
\ No newline at end of file
diff --git a/Adjacent.class b/Adjacent.class
new file mode 100644
index 0000000..52b6d15
Binary files /dev/null and b/Adjacent.class differ
diff --git a/Adjacent.java b/Adjacent.java
new file mode 100644
index 0000000..91e4e10
--- /dev/null
+++ b/Adjacent.java
@@ -0,0 +1,38 @@
+import java.util.*;
+class Adjacent
+{
+static List<String> l=new ArrayList<>();
+static void push(String k)
+{
+int i=0;
+if(l.isEmpty())
+{
+l.add(i,k);
+i++;
+}
+else
+{
+if(l.get(i).equals(l.get(i-1)))
+{
+l.remove(l.size()-1);
+i++;
+}
+}
+}
+
+static void print()
+{
+System.out.println(l);
+}
+public static void main(String args[])
+{
+String s="abbaca";
+char c[]=s.toCharArray();
+for(int i=0;i<c.length;i++)
+{
+push(Character.toString(c[i]));
+}
+
+print();
+}
+}
\ No newline at end of file
diff --git a/Agression.class b/Agression.class
new file mode 100644
index 0000000..8c7efa5
Binary files /dev/null and b/Agression.class differ
diff --git a/Agression.java b/Agression.java
new file mode 100644
index 0000000..2f662a4
--- /dev/null
+++ b/Agression.java
@@ -0,0 +1,86 @@
+import java.util.*;
+class Student
+{
+String name;
+int id;
+String dept;
+Student(String name,int id,String dept)
+{
+this.name=name;
+this.id=id;
+this.dept=dept;
+}
+}
+
+class Department
+{
+List<Student> student;
+String name;
+Department(String name,List<Student> student)
+{
+this.name=name;
+this.student=student;
+}
+
+List<Student> getStudent()
+{
+return student;
+}
+}
+
+class Institute
+{
+List<Department> dept;
+String name;
+Institute(String name,List<Department> dept)
+{
+this.name=name;
+this.dept=dept;
+}
+
+int getTotalStudentInInstitute()
+{
+int noOfStudent=0;
+List<Student> student;
+for(Department d:dept)
+{
+student=d.getStudent();
+for(Student s:student)
+{
+noOfStudent++;
+}
+}
+return noOfStudent;
+}
+}
+
+
+
+class Agression
+{
+public static void main(String args[])
+{
+Student s1=new Student("gaurav",153,"CSE");
+Student s2=new Student("Kushal",156,"CSE");
+Student s3=new Student("vikash",253,"MECH");
+Student s4=new Student("Ankit",254,"MECH");
+
+List<Student> cse=new ArrayList<>();
+cse.add(s1);
+cse.add(s2);
+
+List<Student> mech=new ArrayList<>();
+mech.add(s2);
+mech.add(s3);
+
+Department d1=new Department("CSE",cse);
+Department d2=new Department("MECH",mech);
+
+List<Department> dept=new ArrayList<>();
+dept.add(d1);
+dept.add(d2);
+
+Institute ins=new Institute("NIT",dept);
+System.out.println("Total Studnet in institute="+ins.getTotalStudentInInstitute());
+}
+}
\ No newline at end of file
diff --git a/AllOf.class b/AllOf.class
new file mode 100644
index 0000000..ba9c970
Binary files /dev/null and b/AllOf.class differ
diff --git a/AllOf.java b/AllOf.java
new file mode 100644
index 0000000..12d48fc
--- /dev/null
+++ b/AllOf.java
@@ -0,0 +1,23 @@
+import java.util.*;
+enum gfg
+{
+PYTHON,JAVA,CSS,HTML,PHP;
+}
+
+class AllOf
+{
+public static void main(String args[])
+{
+Set<gfg> g=EnumSet.allOf(gfg.class);
+System.out.println(g);
+
+Set<gfg> k1=EnumSet.allOf(gfg.class);
+System.out.println("the value is:"+k1);
+
+Set<gfg> k2=EnumSet.allOf(gfg.class);
+System.out.println("the value is:"+k2);
+
+Set<gfg> k3=EnumSet.allOf(gfg.class);
+System.out.println(k3);
+}
+}
\ No newline at end of file
diff --git a/Angram12.class b/Angram12.class
new file mode 100644
index 0000000..bc25b35
Binary files /dev/null and b/Angram12.class differ
diff --git a/Angram12.java b/Angram12.java
new file mode 100644
index 0000000..d8f9d03
--- /dev/null
+++ b/Angram12.java
@@ -0,0 +1,39 @@
+class Angram12
+{
+public static void main(String args[])
+{
+String a="gat";
+String b="akb";
+boolean visited[]=new boolean[a.length()];
+boolean isAnagram=false;
+if(a.length()==b.length())
+{
+for(int i=0;i<a.length();i++)
+{
+int c=a.charAt(i);
+for(int j=0;j<b.length();j++)
+{
+if(b.charAt(j)==c && !visited[j])
+{
+visited[j]=true;
+isAnagram=true;
+break;
+}
+}
+if(!isAnagram)
+break;
+}
+}
+if(isAnagram)
+{
+System.out.println("The String is Anagram");
+}
+else
+{
+System.out.println("Not Anagram");
+}
+
+
+
+}
+}
diff --git a/Array.class b/Array.class
new file mode 100644
index 0000000..d61ef00
Binary files /dev/null and b/Array.class differ
diff --git a/Array.java b/Array.java
new file mode 100644
index 0000000..b76cda6
--- /dev/null
+++ b/Array.java
@@ -0,0 +1,27 @@
+class Student
+{
+int roll;
+String name;
+Student(int roll,String name)
+{
+this.roll=roll;
+this.name=name;
+}
+}
+
+class Array
+{
+public static void main(String args[])
+{
+Student a[]=new Student[3];
+a[0]=new Student(1,"gaurav");
+a[1]=new Student(2,"sujit");
+a[2]=new Student(3,"kumar");
+
+for(int i=0;i<a.length;i++)
+{
+System.out.println(a[i].roll+ " : "+a[i].name); 
+}
+
+}
+}
\ No newline at end of file
diff --git a/Array1.class b/Array1.class
new file mode 100644
index 0000000..3e8aeff
Binary files /dev/null and b/Array1.class differ
diff --git a/Array1.java b/Array1.java
new file mode 100644
index 0000000..251ded7
--- /dev/null
+++ b/Array1.java
@@ -0,0 +1,12 @@
+import java.util.*;
+class Array1
+{
+public static void main(String args[])
+{
+Number a[]=new Number[3];
+a[0]=new Integer(10);
+a[1]=23.5f;
+a[2]=23.9;
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/ArrayBinary.class b/ArrayBinary.class
new file mode 100644
index 0000000..4d23a11
Binary files /dev/null and b/ArrayBinary.class differ
diff --git a/ArrayBinary.java b/ArrayBinary.java
new file mode 100644
index 0000000..b56a1ce
--- /dev/null
+++ b/ArrayBinary.java
@@ -0,0 +1,10 @@
+import java.util.*;
+class ArrayBinary
+{
+public static void main(String args[])
+{
+int a[]={1,2,3,4,10};
+int key=5;
+System.out.println(Arrays.binarySearch(a,key));
+}
+}
\ No newline at end of file
diff --git a/ArrayBlock.class b/ArrayBlock.class
new file mode 100644
index 0000000..c1e4d0c
Binary files /dev/null and b/ArrayBlock.class differ
diff --git a/ArrayBlock.java b/ArrayBlock.java
new file mode 100644
index 0000000..2bc3545
--- /dev/null
+++ b/ArrayBlock.java
@@ -0,0 +1,25 @@
+import java.util.concurrent.*;
+import java.util.*;
+class ArrayBlock
+{
+public static void main(String args[])
+{
+ArrayBlockingQueue<Integer> ab=new ArrayBlockingQueue<>(4);
+ab.add(10);
+ab.add(20);
+ab.add(30);
+ab.add(40);
+System.out.println("ArrayBlocking is:"+ab);
+int data=ab.peek();
+System.out.println("Head element is:"+data);
+ab.remove(30);
+System.out.println(ab);
+//System.out.println(ab.poll());
+
+Iterator i=ab.iterator();
+while(i.hasNext())
+{
+System.out.println(i.next());
+}
+}
+}
\ No newline at end of file
diff --git a/ArrayCopy.class b/ArrayCopy.class
new file mode 100644
index 0000000..241f5cd
Binary files /dev/null and b/ArrayCopy.class differ
diff --git a/ArrayCopy.java b/ArrayCopy.java
new file mode 100644
index 0000000..4e1b1ea
--- /dev/null
+++ b/ArrayCopy.java
@@ -0,0 +1,12 @@
+import java.util.*;
+class ArrayCopy
+{
+public static void main(String args[])
+{
+int a[]={11,2,4,4,12,10,8,7};
+int b[]={1,2,4,5};
+System.out.println(Arrays.mismatch(a,b));
+Arrays.sort(a,3,8);
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/ArrayList2.class b/ArrayList2.class
new file mode 100644
index 0000000..0a109cb
Binary files /dev/null and b/ArrayList2.class differ
diff --git a/ArrayList2.java b/ArrayList2.java
new file mode 100644
index 0000000..6d36ac4
--- /dev/null
+++ b/ArrayList2.java
@@ -0,0 +1,27 @@
+import java.util.*;
+class ArrayList2
+{
+public static void main(String args[])
+{
+ArrayList<Integer> l=new ArrayList<>();
+l.add(0,120);
+l.add(1,100);
+l.add(2,400);
+l.add(3,500);
+System.out.println(l);
+l.remove(2);
+System.out.println(l);
+l.set(0,12);
+System.out.println(l);
+
+ArrayList<Integer> l1=new ArrayList<>();
+l1.addAll(l);
+System.out.println("L1="+l1);
+
+Iterator i=l.iterator();
+while(i.hasNext())
+{
+System.out.println(i.next());
+}
+}
+}
\ No newline at end of file
diff --git a/ArrayString.class b/ArrayString.class
new file mode 100644
index 0000000..d0d4e66
Binary files /dev/null and b/ArrayString.class differ
diff --git a/ArrayString.java b/ArrayString.java
new file mode 100644
index 0000000..4306841
--- /dev/null
+++ b/ArrayString.java
@@ -0,0 +1,15 @@
+import java.util.*;
+class ArrayString
+{
+static String[] convertArrayString(Set<String> s)
+{
+String k[]=s.toArray(new String[s.size()]);
+return k;
+}
+public static void main(String args[])
+{
+Set<String> s=new HashSet<>(Arrays.asList("kumar","gaurav","sujit","kushal"));
+String m[]=convertArrayString(s);
+System.out.println(Arrays.toString(m));
+}
+}
\ No newline at end of file
diff --git a/ArrayToMap.class b/ArrayToMap.class
new file mode 100644
index 0000000..e487e18
Binary files /dev/null and b/ArrayToMap.class differ
diff --git a/ArrayToMap.java b/ArrayToMap.java
new file mode 100644
index 0000000..ce1477f
--- /dev/null
+++ b/ArrayToMap.java
@@ -0,0 +1,41 @@
+import java.util.*;
+class Student
+{
+private int id;
+private String name;
+Student(int id,String name)
+{
+this.id=id;
+this.name=name;
+}
+
+int getId()
+{
+return id;
+}
+
+String getName()
+{
+return name;
+}
+}
+
+class ArrayToMap
+{
+public static void main(String args[])
+{
+ArrayList<Student> l=new ArrayList<>();
+
+l.add(new Student(1,"gaurav"));
+l.add(new Student(2,"sujit"));
+l.add(new Student(3,"ankit"));
+
+HashMap<Integer,String> map=new HashMap<>();
+for(Student s:l)
+{
+map.put(s.getId(),s.getName());
+}
+
+System.out.println("Map is:"+map);
+}
+}
\ No newline at end of file
diff --git a/Assign.class b/Assign.class
new file mode 100644
index 0000000..1b5f7a9
Binary files /dev/null and b/Assign.class differ
diff --git a/Assign.java b/Assign.java
new file mode 100644
index 0000000..4e770f7
--- /dev/null
+++ b/Assign.java
@@ -0,0 +1,17 @@
+class Sujit
+{
+final String name;
+Sujit()
+{
+name="gaurav";
+}
+}
+
+class Assign
+{
+public static void main(String args[])
+{
+Sujit s=new Sujit();
+System.out.println("Name is:"+s.name);
+}
+}
\ No newline at end of file
diff --git a/Assign1.class b/Assign1.class
new file mode 100644
index 0000000..84b28c3
Binary files /dev/null and b/Assign1.class differ
diff --git a/Assign1.java b/Assign1.java
new file mode 100644
index 0000000..b46bbc3
--- /dev/null
+++ b/Assign1.java
@@ -0,0 +1,26 @@
+class Gaurav
+{
+static final String branch;
+static 
+{
+branch="CSE";
+System.out.println(branch);
+}
+
+static 
+{
+System.out.println("This will run first before the main");
+}
+}
+
+class Assign1
+{
+public static void main(String args[])
+{
+Gaurav g=new Gaurav();
+g.branch="MECH";
+System.out.println(g.branch);
+System.out.println("Hello");
+
+}
+}
\ No newline at end of file
diff --git a/Assign3.class b/Assign3.class
new file mode 100644
index 0000000..02108a8
Binary files /dev/null and b/Assign3.class differ
diff --git a/Assign3.java b/Assign3.java
new file mode 100644
index 0000000..2147a01
--- /dev/null
+++ b/Assign3.java
@@ -0,0 +1,33 @@
+class A{}
+class B extends A{}
+
+class Base
+{
+A run()
+{
+System.out.println("Hello how are you...");
+return new A();
+}
+}
+
+
+class Child extends Base
+{
+B run()
+{
+System.out.println("This is my child class");
+return new B();
+}
+}
+
+class Assign3
+{
+public static void main(String args[])
+{
+Child c=new Child();
+c.run();
+
+Base b=new Base();
+b.run();
+}
+}
diff --git a/Assign4.class b/Assign4.class
new file mode 100644
index 0000000..b6e138e
Binary files /dev/null and b/Assign4.class differ
diff --git a/Assign4.java b/Assign4.java
new file mode 100644
index 0000000..f643b67
--- /dev/null
+++ b/Assign4.java
@@ -0,0 +1,33 @@
+class Outer
+{
+static String msg="gaurav";
+static class  NestedClass
+{
+public void show()
+{
+System.out.println("I gonna so you something "+msg);
+}
+}
+
+
+class InnerClass
+{
+public void display()
+{
+System.out.println("I am displaying:"+msg);
+}
+}
+
+}
+
+class Assign4
+{
+public static void main(String args[])
+{
+Outer.NestedClass out=new Outer.NestedClass();
+out.show();
+
+Outer.InnerClass in=new Outer().new InnerClass();
+in.display();
+}
+}
\ No newline at end of file
diff --git a/Assign5.class b/Assign5.class
new file mode 100644
index 0000000..55f44cd
Binary files /dev/null and b/Assign5.class differ
diff --git a/Assign5.java b/Assign5.java
new file mode 100644
index 0000000..a3c900e
--- /dev/null
+++ b/Assign5.java
@@ -0,0 +1,34 @@
+class Collage
+{
+static String branch="CSE";
+String name="gaurav";
+static class Kumar
+{
+public void display()
+{
+System.out.println("the branch is:"+branch);
+}
+}
+
+class Sujit
+{
+public void show()
+{
+System.out.print("Haii my name is:"+name);
+System.out.println(" Branch is:"+branch);
+}
+}
+
+}
+
+class Assign5
+{
+public static void main(String args[])
+{
+Collage.Kumar out=new Collage.Kumar();
+out.display();
+
+Collage.Sujit s=new Collage().new Sujit();
+s.show();
+}
+}
\ No newline at end of file
diff --git a/Assign7.class b/Assign7.class
new file mode 100644
index 0000000..b758252
Binary files /dev/null and b/Assign7.class differ
diff --git a/Assign7.java b/Assign7.java
new file mode 100644
index 0000000..3de287d
--- /dev/null
+++ b/Assign7.java
@@ -0,0 +1,32 @@
+class Outer
+{
+static String name="gaurav";
+static class Parent
+{
+public void eat()
+{
+System.out.println("hello parent inside outer:"+name);
+}
+}
+
+class Inner
+{
+public void run()
+{
+System.out.println("The name is:"+name);
+}
+
+}
+}
+
+class Assign7
+{
+public static void main(String args[])
+{
+Outer.Parent out=new Outer.Parent();
+out.eat();
+
+Outer.Inner in=new Outer().new Inner();
+in.run();
+}
+}
\ No newline at end of file
diff --git a/Assign8.class b/Assign8.class
new file mode 100644
index 0000000..53a3473
Binary files /dev/null and b/Assign8.class differ
diff --git a/Assign8.java b/Assign8.java
new file mode 100644
index 0000000..bed68d3
--- /dev/null
+++ b/Assign8.java
@@ -0,0 +1,24 @@
+class Student
+{
+int a;
+int b;
+Student(int a,int b)
+{
+this.a=a;
+this.b=b;
+}
+
+public String toString()
+{
+return("a="+a+" and b="+b);
+}
+}
+
+class Assign8
+{
+public static void main(String args[])
+{
+Student s1=new Student(10,20);
+System.out.println(s1);
+}
+}
\ No newline at end of file
diff --git a/Assign9.class b/Assign9.class
new file mode 100644
index 0000000..8e7eb55
Binary files /dev/null and b/Assign9.class differ
diff --git a/Assign9.java b/Assign9.java
new file mode 100644
index 0000000..f8af646
--- /dev/null
+++ b/Assign9.java
@@ -0,0 +1,26 @@
+class Collage
+{
+String name;
+int roll;
+Collage(String name,int roll)
+{
+this.name=name;
+this.roll=roll;
+}
+
+public String toString()
+{
+return("name="+name+" and Roll="+roll);
+}
+
+}
+
+class Assign9
+{
+public static void main(String args[])
+{
+Collage c=new Collage("gaurav",153);
+System.out.println(c);
+}
+}
+
diff --git a/Associa.class b/Associa.class
new file mode 100644
index 0000000..a59e0fd
Binary files /dev/null and b/Associa.class differ
diff --git a/Associa.java b/Associa.java
new file mode 100644
index 0000000..f34bf2b
--- /dev/null
+++ b/Associa.java
@@ -0,0 +1,37 @@
+class Collage
+{
+String name;
+Collage(String name)
+{
+this.name=name;
+}
+String getName()
+{
+return name;
+}
+}
+
+class Student
+{
+String sName;
+Student(String sName)
+{
+this.sName=sName;
+}
+
+String getStudentName()
+{
+return sName;
+}
+}
+
+class Associa
+{
+public static void main(String args[])
+{
+Student s=new Student("kumar");
+Collage c=new Collage("NIT");
+
+System.out.println(s.getStudentName()+" is the Student of "+c.getName());
+}
+}
diff --git a/Association.class b/Association.class
new file mode 100644
index 0000000..82ec8e6
Binary files /dev/null and b/Association.class differ
diff --git a/Association.java b/Association.java
new file mode 100644
index 0000000..4df6355
--- /dev/null
+++ b/Association.java
@@ -0,0 +1,37 @@
+class Bank
+{
+private String name;
+Bank(String name)
+{
+this.name=name;
+}
+
+String getName()
+{
+return name;
+}
+}
+
+class Emp
+{
+private String EmpName;
+Emp(String EmpName)
+{
+this.EmpName=EmpName;
+}
+
+String getEmpName()
+{
+return EmpName;
+}
+}
+
+class Association
+{
+public static void main(String args[])
+{
+Emp e=new Emp("gaurav");
+Bank b=new Bank("BOI");
+System.out.println(e.getEmpName()+" is the employee of "+b.getName());
+}
+}
\ No newline at end of file
diff --git a/B.class b/B.class
new file mode 100644
index 0000000..31c0efd
Binary files /dev/null and b/B.class differ
diff --git a/Bank.class b/Bank.class
new file mode 100644
index 0000000..c8307ed
Binary files /dev/null and b/Bank.class differ
diff --git a/Base.class b/Base.class
new file mode 100644
index 0000000..a24a6e2
Binary files /dev/null and b/Base.class differ
diff --git a/Bicycle.class b/Bicycle.class
new file mode 100644
index 0000000..0c1fd5f
Binary files /dev/null and b/Bicycle.class differ
diff --git a/Bike.class b/Bike.class
new file mode 100644
index 0000000..e643c06
Binary files /dev/null and b/Bike.class differ
diff --git a/BinaryNumber$Node.class b/BinaryNumber$Node.class
new file mode 100644
index 0000000..9a7f4bd
Binary files /dev/null and b/BinaryNumber$Node.class differ
diff --git a/BinaryNumber.class b/BinaryNumber.class
new file mode 100644
index 0000000..91ace86
Binary files /dev/null and b/BinaryNumber.class differ
diff --git a/BinaryNumber.java b/BinaryNumber.java
new file mode 100644
index 0000000..c2a1b27
--- /dev/null
+++ b/BinaryNumber.java
@@ -0,0 +1,58 @@
+class BinaryNumber
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void parts()
+{
+List[]=new Int
+Node temp=head;
+while
+}
+
+public static void main(String args[])
+{
+BinaryNumber b=new BinaryNumber();
+b.append(1);
+b.append(2);
+b.append(3);
+b.print();
+b.parts();
+}
+}
\ No newline at end of file
diff --git a/BinarySearch1.class b/BinarySearch1.class
new file mode 100644
index 0000000..5c277ad
Binary files /dev/null and b/BinarySearch1.class differ
diff --git a/BinarySearch1.java b/BinarySearch1.java
new file mode 100644
index 0000000..ad33665
--- /dev/null
+++ b/BinarySearch1.java
@@ -0,0 +1,40 @@
+//find the missing number using BinarySerach java
+class BinarySearch1
+{
+static int findMissing(int a[],int n)
+{
+int i=0;
+int j=n-1;
+int mid=0;
+boolean k=true;
+while((j-i)>1)
+{
+mid=(i+j)/2;
+
+if((a[i]-i)!=(a[mid]-mid))
+j=mid;
+
+else if((a[j]-j)!=(a[mid]-mid))
+i=mid;
+
+else
+{
+i++;
+j--;
+k=false;
+}
+}
+
+if(k==false)
+{
+return -1;
+}
+return a[mid]+1;
+}
+public static void main(String args[])
+{
+int a[]={1,2,3,4,5,10};
+int n=a.length;
+System.out.println(findMissing(a,n));
+}
+}
\ No newline at end of file
diff --git a/BinarySearch2.class b/BinarySearch2.class
new file mode 100644
index 0000000..d905efd
Binary files /dev/null and b/BinarySearch2.class differ
diff --git a/BinarySearch2.java b/BinarySearch2.java
new file mode 100644
index 0000000..dec3bba
--- /dev/null
+++ b/BinarySearch2.java
@@ -0,0 +1,37 @@
+import java.util.*;
+class BinarySearch2
+{
+static int binarySearch(int a[],int low,int search,int high)
+{
+int mid=low+(high-low)/2;
+
+while(low<=high)
+{
+if(a[mid]==search)
+{
+return mid;
+}
+
+else if(a[mid]<search)
+low=mid+1;
+
+else if(a[mid]>search)
+high=mid-1;
+}
+return -1;
+}
+public static void main(String args[])
+{
+Scanner sc=new Scanner(System.in);
+System.out.println("Enter the number of elements");
+int n=sc.nextInt();
+int a[]=new int[n];
+System.out.println("Enter the number");
+for(int i=0;i<n;i++)
+{
+a[i]=sc.nextInt();
+}
+int k=binarySearch(a,0,30,n-1);
+System.out.println("The searching element is:"+k);
+}
+}
diff --git a/Binding2.class b/Binding2.class
new file mode 100644
index 0000000..b4c0c21
Binary files /dev/null and b/Binding2.class differ
diff --git a/Binding2.java b/Binding2.java
new file mode 100644
index 0000000..7ec8c05
--- /dev/null
+++ b/Binding2.java
@@ -0,0 +1,30 @@
+class Student
+{
+public static class Parent
+{
+static void show()
+{
+System.out.println("Hello parent Class");
+}
+}
+
+public static class Child extends Parent
+{
+static void show()
+{
+System.out.println("Hello Child class");
+}
+}
+}
+
+class Binding2
+{
+public static void main(String args[])
+{
+Student.Parent p=new Student.Parent();
+p.show();
+
+Student.Parent p1=new Student.Child();
+p1.show();
+}
+}
\ No newline at end of file
diff --git a/Binding3$Child.class b/Binding3$Child.class
new file mode 100644
index 0000000..2e8802a
Binary files /dev/null and b/Binding3$Child.class differ
diff --git a/Binding3$Parent.class b/Binding3$Parent.class
new file mode 100644
index 0000000..defac51
Binary files /dev/null and b/Binding3$Parent.class differ
diff --git a/Binding3.class b/Binding3.class
new file mode 100644
index 0000000..f76b4a4
Binary files /dev/null and b/Binding3.class differ
diff --git a/Binding3.java b/Binding3.java
new file mode 100644
index 0000000..8e6cd33
--- /dev/null
+++ b/Binding3.java
@@ -0,0 +1,27 @@
+class Binding3
+{
+static class Parent
+{
+static void eat()
+{
+System.out.println("I am hungry now");
+}
+}
+
+static class Child extends Parent
+{
+static void eat()
+{
+System.out.println("I am eating in child");
+}
+}
+
+public static void main(String args[])
+{
+Parent p=new Parent();
+p.eat();
+
+Child c=new Child();
+c.eat();
+}
+}
\ No newline at end of file
diff --git a/Binding4$Teacher.class b/Binding4$Teacher.class
new file mode 100644
index 0000000..86f4df0
Binary files /dev/null and b/Binding4$Teacher.class differ
diff --git a/Binding4$student.class b/Binding4$student.class
new file mode 100644
index 0000000..9369ed3
Binary files /dev/null and b/Binding4$student.class differ
diff --git a/Binding4.class b/Binding4.class
new file mode 100644
index 0000000..36a33c2
Binary files /dev/null and b/Binding4.class differ
diff --git a/Binding4.java b/Binding4.java
new file mode 100644
index 0000000..38425ab
--- /dev/null
+++ b/Binding4.java
@@ -0,0 +1,27 @@
+class Binding4
+{
+static class student
+{
+void show()
+{
+System.out.println("I gonna show you something");
+}
+}
+
+static class teacher extends student
+{
+void show()
+{
+System.out.println("Hello Teacher");
+}
+}
+
+public static void main(String args[])
+{
+student s=new student();
+s.show();
+student s2=new teacher();
+s2.show();
+
+}
+}
\ No newline at end of file
diff --git a/Block3.class b/Block3.class
new file mode 100644
index 0000000..a29c575
Binary files /dev/null and b/Block3.class differ
diff --git a/Block3.java b/Block3.java
new file mode 100644
index 0000000..48c63b6
--- /dev/null
+++ b/Block3.java
@@ -0,0 +1,20 @@
+class Block3
+{
+static 
+{
+System.out.println("This  will execute first");
+}
+
+static 
+{
+System.out.println("This will execute after the first static block");
+}
+public static void main(String args[])
+{
+System.out.println("This will execute after the static block");
+}
+
+static{
+System.out.println("Hello How are you");
+}
+}
\ No newline at end of file
diff --git a/Book.class b/Book.class
new file mode 100644
index 0000000..b80a711
Binary files /dev/null and b/Book.class differ
diff --git a/Branch.class b/Branch.class
new file mode 100644
index 0000000..7270e72
Binary files /dev/null and b/Branch.class differ
diff --git a/Bubble1.class b/Bubble1.class
new file mode 100644
index 0000000..9ef57e9
Binary files /dev/null and b/Bubble1.class differ
diff --git a/Bubble1.java b/Bubble1.java
new file mode 100644
index 0000000..52bbaec
--- /dev/null
+++ b/Bubble1.java
@@ -0,0 +1,22 @@
+import java.util.*;
+class Bubble1
+{
+public static void main(String args[])
+{
+int a[]={10,1,2,6,7,3,5};
+int n=a.length;
+for(int i=0;i<n;i++)
+{
+for(int j=i+1;j<n;j++)
+{
+if(a[j]<a[i])
+{
+int temp=a[i];
+a[i]=a[j];
+a[j]=temp;
+}
+}
+}
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/Bubble2.class b/Bubble2.class
new file mode 100644
index 0000000..ae15bde
Binary files /dev/null and b/Bubble2.class differ
diff --git a/Bubble2.java b/Bubble2.java
new file mode 100644
index 0000000..6d43183
--- /dev/null
+++ b/Bubble2.java
@@ -0,0 +1,22 @@
+import java.util.*;
+class Bubble2
+{
+public static void main(String args[])
+{
+int a[]={12,3,2,1,3,4,6};
+int n=a.length;
+for(int i=0;i<n-1;i++)
+{
+for(int j=0;j<n-1;j++)
+{
+if(a[j+1]<a[j])
+{
+int temp=a[j];
+a[j]=a[j+1];
+a[j+1]=temp;
+}
+}
+}
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/Bubble8.class b/Bubble8.class
new file mode 100644
index 0000000..3fb1cc5
Binary files /dev/null and b/Bubble8.class differ
diff --git a/Bubble8.java b/Bubble8.java
new file mode 100644
index 0000000..38ec9ef
--- /dev/null
+++ b/Bubble8.java
@@ -0,0 +1,23 @@
+import java.util.*;
+class Bubble8
+{
+public static void main(String args[])
+{
+int a[]={12,1,4,3,2,5,6};
+int n=a.length;
+for(int i=0;i<n-1;i++)
+{
+for(int j=0;j<n-1;j++)
+{
+if(a[j]>a[j+1])
+{
+int temp=a[j];
+a[j]=a[j+1];
+a[j+1]=temp;
+}
+}
+}
+
+System.out.println(Arrays.toString(a));
+} 
+}
\ No newline at end of file
diff --git a/BubbleSort2.class b/BubbleSort2.class
new file mode 100644
index 0000000..7c6bda0
Binary files /dev/null and b/BubbleSort2.class differ
diff --git a/BubbleSort2.java b/BubbleSort2.java
new file mode 100644
index 0000000..73aa2b6
--- /dev/null
+++ b/BubbleSort2.java
@@ -0,0 +1,23 @@
+import java.util.*;
+class BubbleSort2
+{
+public static void main(String args[])
+{
+int a[]={5,4,3,1,2};
+int n=a.length;
+for(int i=0;i<n-1;i++)
+{
+for(int j=0;j<n-1;j++)
+{
+if(a[j+1]<a[j])
+{
+int temp=a[j];
+a[j]=a[j+1];
+a[j+1]=temp;
+}
+}
+}
+
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/Buffer12.class b/Buffer12.class
new file mode 100644
index 0000000..1a906bb
Binary files /dev/null and b/Buffer12.class differ
diff --git a/Buffer12.java b/Buffer12.java
new file mode 100644
index 0000000..8cda679
--- /dev/null
+++ b/Buffer12.java
@@ -0,0 +1,20 @@
+class Buffer12
+{
+public static void main(String args[])
+{
+StringBuffer s=new StringBuffer("kumar gaurav");
+s.delete(0,4);
+System.out.println(s);
+
+StringBuffer s1=new StringBuffer("sujit");
+s1.deleteCharAt(2);
+s1.deleteCharAt(3);
+s1.deleteCharAt(0);
+System.out.println(s1);
+
+StringBuffer s3=new StringBuffer("kushal");
+s3.deleteCharAt(3);
+s3.deleteCharAt(2);
+System.out.println(s3);
+}
+}
\ No newline at end of file
diff --git a/Buffer4.class b/Buffer4.class
new file mode 100644
index 0000000..67fb876
Binary files /dev/null and b/Buffer4.class differ
diff --git a/Buffer4.java b/Buffer4.java
new file mode 100644
index 0000000..b8eb321
--- /dev/null
+++ b/Buffer4.java
@@ -0,0 +1,10 @@
+class Buffer4
+{
+public static void main(String args[])
+{
+StringBuffer s=new StringBuffer("kushal");
+s.replace(0,2,"sujit");
+s.replace(5,7
+System.out.println(s);
+}
+}
\ No newline at end of file
diff --git a/Builder2.class b/Builder2.class
new file mode 100644
index 0000000..cf2e843
Binary files /dev/null and b/Builder2.class differ
diff --git a/Builder2.java b/Builder2.java
new file mode 100644
index 0000000..a56b15b
--- /dev/null
+++ b/Builder2.java
@@ -0,0 +1,20 @@
+class Builder2
+{
+public static void main(String args[])
+{
+StringBuilder str=new StringBuilder();
+str.append("kumar");
+str.append("gaurav");
+str.append(" sujit");
+System.out.println(str.toString());
+
+
+StringBuilder str2=new StringBuilder(20);
+System.out.println(str2.capacity());
+
+StringBuilder str3=new StringBuilder("kushal");
+System.out.println(str3.toString());
+str3.reverse();
+System.out.println(str3.toString());
+}
+}
\ No newline at end of file
diff --git a/Builder3.class b/Builder3.class
new file mode 100644
index 0000000..e114d1e
Binary files /dev/null and b/Builder3.class differ
diff --git a/Builder3.java b/Builder3.java
new file mode 100644
index 0000000..1d9d379
--- /dev/null
+++ b/Builder3.java
@@ -0,0 +1,11 @@
+class Builder3
+{
+public static void main(String args[])
+{
+StringBuilder str=new StringBuilder("kumar");
+str.appendCodePoint(65);
+System.out.println(str);
+str.setCharAt(1,'G');
+System.out.println(str);
+}
+}
\ No newline at end of file
diff --git a/Car.class b/Car.class
new file mode 100644
index 0000000..a30c9c5
Binary files /dev/null and b/Car.class differ
diff --git a/Car.java b/Car.java
new file mode 100644
index 0000000..eaee70b
--- /dev/null
+++ b/Car.java
@@ -0,0 +1,24 @@
+class Car
+{
+int no;
+Car(int no)
+{
+this.no=no;
+}
+
+static void swap(Car c1,Car c2)
+{
+int temp=c1.no;
+c1.no=c2.no;
+c2.no=temp;
+}
+
+public static void main(String args[])
+{
+Car c1=new Car(10);
+Car c2=new Car(20);
+swap(c1,c2);
+
+System.out.println("C1.no="+c1.no+" and C2.no="+c2.no);
+}
+}
\ No newline at end of file
diff --git a/CharDup.class b/CharDup.class
new file mode 100644
index 0000000..6d7bbff
Binary files /dev/null and b/CharDup.class differ
diff --git a/CharDup.java b/CharDup.java
new file mode 100644
index 0000000..94f50b8
--- /dev/null
+++ b/CharDup.java
@@ -0,0 +1,27 @@
+import java.util.*;
+class CharDup
+{
+static void FindChar(String s)
+{
+List<Character> l=new ArrayList<>();
+List<Character> l1=new ArrayList<>();
+char c[]=s.toCharArray();
+for(int i=0;i<c.length;i++)
+{
+if(!l.contains(c[i]))
+{
+l.add(c[i]);
+}
+else
+{
+l1.add(c[i]);
+}
+}
+System.out.println("Duplicate Character is:"+l1 );
+}
+public static void main(String args[])
+{
+String s="gauravvg";
+FindChar(s);
+}
+}
\ No newline at end of file
diff --git a/CheckPalin$Node.class b/CheckPalin$Node.class
new file mode 100644
index 0000000..a3c89d7
Binary files /dev/null and b/CheckPalin$Node.class differ
diff --git a/CheckPalin.class b/CheckPalin.class
new file mode 100644
index 0000000..e02de2e
Binary files /dev/null and b/CheckPalin.class differ
diff --git a/CheckPalin.java b/CheckPalin.java
new file mode 100644
index 0000000..f2c339c
--- /dev/null
+++ b/CheckPalin.java
@@ -0,0 +1,42 @@
+class CheckPalin
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void push(int data)
+{
+Node x=new Node(data);
+x.next=head;
+head=x;
+}
+
+
+void print()
+{
+Node temp=head;
+Stack<Integer> s=new Stack<>();
+while(temp!=null)
+{
+s.push(temp.data);
+temp=temp.next;
+}
+}
+
+public static void main(String args[])
+{
+CheckPalin p=new CheckPalin();
+p.push(10);
+p.push(20);
+p.push(30);
+p.print();
+}
+}
\ No newline at end of file
diff --git a/Child.class b/Child.class
new file mode 100644
index 0000000..e8d6a4c
Binary files /dev/null and b/Child.class differ
diff --git a/ChildThread.class b/ChildThread.class
new file mode 100644
index 0000000..850384c
Binary files /dev/null and b/ChildThread.class differ
diff --git a/Circle.class b/Circle.class
new file mode 100644
index 0000000..f19ff8a
Binary files /dev/null and b/Circle.class differ
diff --git a/Clone1.class b/Clone1.class
new file mode 100644
index 0000000..54a33ee
Binary files /dev/null and b/Clone1.class differ
diff --git a/Clone1.java b/Clone1.java
new file mode 100644
index 0000000..c3138eb
--- /dev/null
+++ b/Clone1.java
@@ -0,0 +1,22 @@
+class Clone1 implements Cloneable
+{
+protected Object clone() throws CloneNotSupportedException
+{
+return super.clone();
+}
+String name="gaurav";
+public static void main(String args[])
+{
+Clone1 x=new Clone1();
+try
+{
+Clone1 y=(Clone1)x.clone();
+System.out.println(y.name);
+}
+catch(CloneNotSupportedException e)
+{
+e.printStackTrace();
+}
+
+}
+}
\ No newline at end of file
diff --git a/Clone12.class b/Clone12.class
new file mode 100644
index 0000000..11f89fc
Binary files /dev/null and b/Clone12.class differ
diff --git a/Clone12.java b/Clone12.java
new file mode 100644
index 0000000..f70aadc
--- /dev/null
+++ b/Clone12.java
@@ -0,0 +1,24 @@
+class Clone12 implements Cloneable
+{
+protected Object clone() throws CloneNotSupportedException
+{
+return super.clone();
+}
+
+String name="gaurav";
+public static void main(String args[])
+{
+Clone12 c=new Clone12();
+try
+{
+Clone12 c2=(Clone12)c.clone();
+System.out.println(c2.name);
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+
+
+}
+}
\ No newline at end of file
diff --git a/Collage$Kumar.class b/Collage$Kumar.class
new file mode 100644
index 0000000..7b20bf0
Binary files /dev/null and b/Collage$Kumar.class differ
diff --git a/Collage$Sujit.class b/Collage$Sujit.class
new file mode 100644
index 0000000..f68ff89
Binary files /dev/null and b/Collage$Sujit.class differ
diff --git a/Collage.class b/Collage.class
new file mode 100644
index 0000000..3d46a60
Binary files /dev/null and b/Collage.class differ
diff --git a/Collect.class b/Collect.class
new file mode 100644
index 0000000..54a9e51
Binary files /dev/null and b/Collect.class differ
diff --git a/Collect.java b/Collect.java
new file mode 100644
index 0000000..ae64edf
--- /dev/null
+++ b/Collect.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class Collect
+{
+public static void main(String args[])
+{
+int a[]=new int[]{1,2,3,4,5};
+Vector<Integer> v=new Vector<>();
+Hashtable<Integer,String> ht=new Hashtable<>();
+v.addElement(2);
+v.addElement(4);
+v.addElement(5);
+System.out.println("Vector is:"+v);
+System.out.println(v.elementAt(2));
+
+ht.put(1,"gaurav");
+ht.put(2,"sujit");
+System.out.println(ht.get(2));
+}
+}
\ No newline at end of file
diff --git a/CollectArray.java b/CollectArray.java
new file mode 100644
index 0000000..6e465f7
--- /dev/null
+++ b/CollectArray.java
@@ -0,0 +1,13 @@
+import java.util.*;
+class CollectArray
+{
+public static void main(String args[])
+{
+Collection<Integer> list=new ArrayList<>();
+list.add(20);
+list.add(10);
+list.add(22);
+list.add(30);
+System.out.println(list);
+}
+}
\ No newline at end of file
diff --git a/Collection.java b/Collection.java
new file mode 100644
index 0000000..07ac81b
--- /dev/null
+++ b/Collection.java
@@ -0,0 +1,13 @@
+import java.util.*;
+class Collection
+{
+public static void main(String args[])
+{
+Collection<String> c1=new LinkedList<String>();
+c1.add("sujit");
+c1.add("kumar");
+c1.add("kushal");
+c1.add("payal");
+System.out.println("Hello collection:"+c1);
+}
+}
\ No newline at end of file
diff --git a/Collection1.java b/Collection1.java
new file mode 100644
index 0000000..9f44aab
--- /dev/null
+++ b/Collection1.java
@@ -0,0 +1,13 @@
+import java.util.*;
+class Collection1	
+{
+public static void main(String args[])
+{
+Collection<String> c1=new LinkedList<String>();
+c1.add("sujit");
+c1.add("kumar");
+c1.add("kushal");
+c1.add("payal");
+System.out.println("Hello collection:"+c1);
+}
+}
\ No newline at end of file
diff --git a/Collection2.java b/Collection2.java
new file mode 100644
index 0000000..f1f491c
--- /dev/null
+++ b/Collection2.java
@@ -0,0 +1,12 @@
+import java.util.*;
+class Collection2
+{
+public static void main(String args[])
+{
+Collection<Integer> c=new LinkedList<Integer>();
+c.add(1);
+c.add(2);
+c.add(3);
+System.out.println(c);
+}
+}
\ No newline at end of file
diff --git a/Common1.class b/Common1.class
new file mode 100644
index 0000000..19246ca
Binary files /dev/null and b/Common1.class differ
diff --git a/Common1.java b/Common1.java
new file mode 100644
index 0000000..f220ab6
--- /dev/null
+++ b/Common1.java
@@ -0,0 +1,36 @@
+class Common1
+{
+public static void main(String args[])
+{
+int a[]={1,2,3,4,5,6};
+int b[]={5,6,7,8,9,10};
+int c[]={4,5,6,10,11,12,13};
+int n1=a.length;
+int n2=b.length;
+int n3=c.length;
+int i=0;
+int j=0;
+int k=0;
+while(i<n1 && j<n2 && k<n3)
+{
+if(a[i]==b[j] && b[j]==c[k])
+{
+System.out.print(a[i]+" ");
+i++;
+j++;
+k++;
+}
+
+else if(a[i]<b[j])
+i++;
+
+
+else if(b[j]<c[k])
+j++;
+
+else 
+k++;
+}
+
+}
+}
\ No newline at end of file
diff --git a/Composite.class b/Composite.class
new file mode 100644
index 0000000..dadef5f
Binary files /dev/null and b/Composite.class differ
diff --git a/Composite.java b/Composite.java
new file mode 100644
index 0000000..715b76b
--- /dev/null
+++ b/Composite.java
@@ -0,0 +1,47 @@
+import java.util.*;
+class Book
+{
+String title;
+String author;
+Book(String title,String author)
+{
+this.title=title;
+this.author=author;
+}
+}
+
+class Library
+{
+List<Book> book;
+Library(List<Book> book)
+{
+this.book=book;
+}
+
+List<Book> getAllBooks()
+{
+return book;
+}
+}
+
+class Composite
+{
+public static void main(String args[])
+{
+Book b1=new Book("Love","Gaurav");
+Book b2=new Book("Hate","vikash");
+Book b3=new Book("PremKatha","Arjun");
+
+List<Book> book=new ArrayList<>();
+book.add(b1);
+book.add(b2);
+book.add(b3);
+
+Library l=new Library(book);
+List<Book> s=l.getAllBooks();
+for(Book b:s)
+{
+System.out.println("Title="+b.title+" Author="+b.author);
+}
+}
+}
\ No newline at end of file
diff --git a/ConvertCollect.class b/ConvertCollect.class
new file mode 100644
index 0000000..2bba260
Binary files /dev/null and b/ConvertCollect.class differ
diff --git a/ConvertCollect.java b/ConvertCollect.java
new file mode 100644
index 0000000..33f6098
--- /dev/null
+++ b/ConvertCollect.java
@@ -0,0 +1,17 @@
+import java.util.*;
+class ConvertCollect
+{
+public static <T> Collection<T> convert(Iterable<T> i)
+{
+Collection<T> c=new ArrayList<T>();
+i.forEach(c::add);
+return c;
+}
+public static void main(String args[])
+{
+Iterable<Integer> i=Arrays.asList(1,2,3,4,5);
+System.out.println(i);
+Collection<Integer> c=convert(i);
+System.out.println(c);
+}
+}
diff --git a/ConvertList.class b/ConvertList.class
new file mode 100644
index 0000000..1e74656
Binary files /dev/null and b/ConvertList.class differ
diff --git a/ConvertList.java b/ConvertList.java
new file mode 100644
index 0000000..66b6d3d
--- /dev/null
+++ b/ConvertList.java
@@ -0,0 +1,10 @@
+import java.util.*;
+class ConvertList
+{
+public static void main(String args[])
+{
+int n=5;
+List<Integer> l=new ArrayList<>(Arrays.asList(n));
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/CopyArrayList1$Data.class b/CopyArrayList1$Data.class
new file mode 100644
index 0000000..0d7a834
Binary files /dev/null and b/CopyArrayList1$Data.class differ
diff --git a/CopyArrayList1.class b/CopyArrayList1.class
new file mode 100644
index 0000000..c73e0e2
Binary files /dev/null and b/CopyArrayList1.class differ
diff --git a/CopyArrayList1.java b/CopyArrayList1.java
new file mode 100644
index 0000000..a06139a
--- /dev/null
+++ b/CopyArrayList1.java
@@ -0,0 +1,49 @@
+import java.util.*;
+class CopyArrayList1
+{
+int n=4;
+class Data
+{
+int roll;
+String name;
+int marks;
+long phone;
+Data(int roll,String name,int marks,long phone)
+{
+this.roll=roll;
+this.name=name;
+this.marks=marks;
+this.phone=phone;
+}
+}
+
+public static void main(String args[])
+{
+int roll[]={1,2,3,4};
+String name[]={"gaurav","sujit","kushal","kumar"};
+int marks[]={100,200,300,400};
+long phone[]={123445,78797,6299164,78704971};
+
+CopyArrayList1 l=new CopyArrayList1();
+l.addValues(roll,name,marks,phone);
+}
+
+void addValues(int roll[],String name[],int marks[],long phone[])
+{
+ArrayList<Data> l=new ArrayList<>();
+for(int i=0;i<n;i++)
+{
+l.add(new Data(roll[i],name[i],marks[i],phone[i]));
+}
+print(l);
+}
+
+void print(ArrayList<Data> l)
+{
+for(int i=0;i<n;i++)
+{
+Data d=l.get(i);
+System.out.println(d.roll+" "+d.name+" "+d.marks+" "+d.phone);
+}
+}
+}
\ No newline at end of file
diff --git a/CopyArrayList2$Data.class b/CopyArrayList2$Data.class
new file mode 100644
index 0000000..a8f0bcc
Binary files /dev/null and b/CopyArrayList2$Data.class differ
diff --git a/CopyArrayList2.class b/CopyArrayList2.class
new file mode 100644
index 0000000..e34df4f
Binary files /dev/null and b/CopyArrayList2.class differ
diff --git a/CopyArrayList2.java b/CopyArrayList2.java
new file mode 100644
index 0000000..369ee91
--- /dev/null
+++ b/CopyArrayList2.java
@@ -0,0 +1,40 @@
+import java.util.*;
+class CopyArrayList2
+{
+int n=3;
+class Data
+{
+int roll;
+String name;
+int marks;
+Data(int roll,String name,int marks)
+{
+this.roll=roll;
+this.name=name;
+this.marks=marks;
+}
+
+public String toString()
+{
+return ("Roll="+this.roll+ " Name="+this.name+" marks="+this.marks);
+}
+}
+public static void main(String args[])
+{
+int roll[]={1,2,3};
+String name[]={"sujit","gaurav","kushal"};
+int marks[]={100,200,300};
+
+CopyArrayList2 l=new CopyArrayList2();
+l.addValues(roll,name,marks);
+}
+
+void addValues(int roll[],String name[],int marks[])
+{
+for(int i=0;i<n;i++)
+{
+Data d=new Data(roll[i],name[i],marks[i]);
+System.out.println(d);
+}
+}
+}
\ No newline at end of file
diff --git a/CountConso.class b/CountConso.class
new file mode 100644
index 0000000..e77fcc8
Binary files /dev/null and b/CountConso.class differ
diff --git a/CountConso.java b/CountConso.java
new file mode 100644
index 0000000..178f1b8
--- /dev/null
+++ b/CountConso.java
@@ -0,0 +1,23 @@
+class CountConso
+{
+public static void main(String args[])
+{
+String s="kushal";
+s=s.toLowerCase();
+int v=0;
+int c=0;
+for(int i=0;i<s.length();i++)
+{
+if(s.charAt(i)=='a' || s.charAt(i)=='e' || s.charAt(i)=='i' || s.charAt(i)=='o' || s.charAt(i)=='u')
+{
+v++;
+}
+else
+{
+c++;
+}
+}
+
+System.out.println("Vowels="+v+ " and consonants="+c);
+}
+}
diff --git a/CountOccurrence$Node.class b/CountOccurrence$Node.class
new file mode 100644
index 0000000..f7a782c
Binary files /dev/null and b/CountOccurrence$Node.class differ
diff --git a/CountOccurrence.class b/CountOccurrence.class
new file mode 100644
index 0000000..6518e0a
Binary files /dev/null and b/CountOccurrence.class differ
diff --git a/CountOccurrence.java b/CountOccurrence.java
new file mode 100644
index 0000000..084e000
--- /dev/null
+++ b/CountOccurrence.java
@@ -0,0 +1,70 @@
+class CountOccurrence
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void Occurrence(int key)
+{
+int count=0;
+Node temp=head;
+while(temp!=null)
+{
+if(temp.data==key)
+{
+count+=1;
+}
+temp=temp.next;
+}
+System.out.println("Number of occurrences is:"+count);
+}
+
+public static void main(String args[])
+{
+CountOccurrence l=new CountOccurrence();
+l.append(1);
+l.append(2);
+l.append(1);
+l.append(2);
+l.append(1);
+l.append(3);
+l.append(1);
+l.print();
+l.Occurrence(1);
+}
+}
\ No newline at end of file
diff --git a/CountVowels1.class b/CountVowels1.class
new file mode 100644
index 0000000..4d5840b
Binary files /dev/null and b/CountVowels1.class differ
diff --git a/CurrentInstance.class b/CurrentInstance.class
new file mode 100644
index 0000000..f582917
Binary files /dev/null and b/CurrentInstance.class differ
diff --git a/CurrentInstance.java b/CurrentInstance.java
new file mode 100644
index 0000000..9552242
--- /dev/null
+++ b/CurrentInstance.java
@@ -0,0 +1,30 @@
+class Student
+{
+int a;
+int b;
+Student()
+{
+a=10;
+b=20;
+}
+
+Student run()
+{
+return this;
+}
+
+void display()
+{
+System.out.println("The a="+a+ " and b="+b);
+}
+}
+
+class CurrentInstance
+{
+public static void main(String args[])
+{
+Student s=new Student();
+s.run().display();
+
+}
+}
\ No newline at end of file
diff --git a/CurrentMethod.class b/CurrentMethod.class
new file mode 100644
index 0000000..d745355
Binary files /dev/null and b/CurrentMethod.class differ
diff --git a/CurrentMethod.java b/CurrentMethod.java
new file mode 100644
index 0000000..9e99c81
--- /dev/null
+++ b/CurrentMethod.java
@@ -0,0 +1,30 @@
+class Student
+{
+String name;
+String branch;
+Student(String name,String branch)
+{
+this.name=name;
+this.branch=branch;
+}
+
+void eat()
+{
+System.out.println("Call to another mathod");
+this.display();
+}
+
+void display()
+{
+System.out.println("Name="+this.name+" and branch="+branch);
+}
+}
+
+class CurrentMethod
+{
+public static void main(String args[])
+{
+Student s=new Student("kumar","cse");
+s.eat();
+}
+}
\ No newline at end of file
diff --git a/Date1.class b/Date1.class
new file mode 100644
index 0000000..9cdf868
Binary files /dev/null and b/Date1.class differ
diff --git a/Date1.java b/Date1.java
new file mode 100644
index 0000000..c481f22
--- /dev/null
+++ b/Date1.java
@@ -0,0 +1,17 @@
+import java.util.*;
+import java.text.*;
+class Date1
+{
+static void convertDateToString(String s)
+{
+DateFormat df=new SimpleDateFormat(s);
+Date today=Calendar.getInstance().getTime();
+System.out.println(today);
+//return str;
+}
+public static void main(String args[])
+{
+String s="2020-02-21";
+convertDateToString(s);
+}
+}
\ No newline at end of file
diff --git a/Date12.java b/Date12.java
new file mode 100644
index 0000000..b5a26b0
--- /dev/null
+++ b/Date12.java
@@ -0,0 +1,12 @@
+import java.time.*;
+import java.time.temporal.*;
+class Date12
+{
+public static void main(String args[])
+{
+LocalDate d=LocalDate.of(2020,2,23);
+LocalTime t=LocalTime.of(6,30);
+LocalDateTime dt=LocalDateTime.of(d,t);
+System.out.println(dt);
+}
+}
\ No newline at end of file
diff --git a/Date3.class b/Date3.class
new file mode 100644
index 0000000..7a8b774
Binary files /dev/null and b/Date3.class differ
diff --git a/Date3.java b/Date3.java
new file mode 100644
index 0000000..0833e99
--- /dev/null
+++ b/Date3.java
@@ -0,0 +1,22 @@
+import java.util.*;
+import java.text.*;
+import java.time.*;
+class Date3
+{
+static void ConvertToString(String s)
+{
+LocalDate l=LocalDate.parse(s);
+System.out.println(l);
+int day=l.getDayOfMonth();
+System.out.println("Day is:"+day);
+Month m=l.getMonth();
+System.out.println("Month="+m);
+int year=l.getYear();
+System.out.println("Year="+year);
+}
+public static void main(String args[])
+{
+String s="2021-02-21";
+ConvertToString(s);
+}
+}
\ No newline at end of file
diff --git a/Date4.class b/Date4.class
new file mode 100644
index 0000000..9f266c4
Binary files /dev/null and b/Date4.class differ
diff --git a/Date4.java b/Date4.java
new file mode 100644
index 0000000..bd5872f
--- /dev/null
+++ b/Date4.java
@@ -0,0 +1,41 @@
+import java.util.*;
+import java.text.*;
+class Date4
+{
+static void findDifference(String sDate,String eDate)
+{
+SimpleDateFormat df=new SimpleDateFormat("dd-mm-yyyy HH-mm-ss");
+try
+{
+Date d1=df.parse(sDate);
+Date d2=df.parse(eDate);
+
+long timeDiff=d2.getTime()-d1.getTime();
+System.out.println(timeDiff);
+
+long diffInSec=(timeDiff/1000)%60;
+long diffInMin=(timeDiff/(1000*60))%60;
+long diffInHour=(timeDiff/(1000*60*60))%24;
+long diffInYear=(timeDiff/(1000l*60*60*24*365));
+long diffInDay=(timeDiff/(1000*60*60*24))%365;
+
+System.out.println("Year="+diffInYear);
+System.out.println("Hours="+diffInHour);
+System.out.println("Minutes="+diffInMin);
+System.out.println("Sec="+diffInSec);
+System.out.println("Days="+diffInDay);
+
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+
+}
+public static void main(String args[])
+{
+String sDate="2019-02-21 01-10-30";
+String eDate="2021-02-21 02-15-20";
+findDifference(sDate,eDate);
+}
+}
\ No newline at end of file
diff --git a/Date5.class b/Date5.class
new file mode 100644
index 0000000..b78a702
Binary files /dev/null and b/Date5.class differ
diff --git a/Date5.java b/Date5.java
new file mode 100644
index 0000000..4a165d0
--- /dev/null
+++ b/Date5.java
@@ -0,0 +1,13 @@
+import java.util.*;
+import java.time.*;
+class Date5
+{
+public static void main(String args[])
+{
+LocalDate l=LocalDate.of(2021,03,26);
+System.out.println(l);
+System.out.println(l.getDayOfMonth());
+System.out.println(l.getMonth());
+System.out.println(l.getYear());
+}
+}
\ No newline at end of file
diff --git a/Date6.class b/Date6.class
new file mode 100644
index 0000000..f6c73fe
Binary files /dev/null and b/Date6.class differ
diff --git a/Date6.java b/Date6.java
new file mode 100644
index 0000000..7c8edfd
--- /dev/null
+++ b/Date6.java
@@ -0,0 +1,10 @@
+import java.util.*;
+import java.time.*;
+class Date6
+{
+public static void main(String args[])
+{
+LocalDate l=LocalDate.of(2021,Month.MARCH,20);
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/DeleteAll$Node.class b/DeleteAll$Node.class
new file mode 100644
index 0000000..8c70660
Binary files /dev/null and b/DeleteAll$Node.class differ
diff --git a/DeleteAll.class b/DeleteAll.class
new file mode 100644
index 0000000..da7d42c
Binary files /dev/null and b/DeleteAll.class differ
diff --git a/DeleteAll.java b/DeleteAll.java
new file mode 100644
index 0000000..848fa31
--- /dev/null
+++ b/DeleteAll.java
@@ -0,0 +1,79 @@
+class DeleteAll
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()    
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Node Delete()
+{
+Node temp=head;
+Node head1=new Node(-1);
+Node prev=head1;
+while(temp!=null)
+{
+Node start=temp;
+int count=0;
+while(temp!=null && start.data==temp.data)
+{
+temp=temp.next;
+count++;
+}
+if(count>1)
+start=temp;
+else
+{
+prev.next=start;
+prev=prev.next;
+}
+}
+prev.next=null;
+return prev.next; 
+}
+
+public static void main(String args[])
+{
+DeleteAll s=new DeleteAll();
+s.append(1);
+s.append(2);
+s.append(2);
+s.append(3);
+s.append(4);
+s.print();
+Node k=s.Delete();
+s.print();
+}
+}
\ No newline at end of file
diff --git a/DeleteAll1$Node.class b/DeleteAll1$Node.class
new file mode 100644
index 0000000..d577e76
Binary files /dev/null and b/DeleteAll1$Node.class differ
diff --git a/DeleteAll1.class b/DeleteAll1.class
new file mode 100644
index 0000000..dfe5cc7
Binary files /dev/null and b/DeleteAll1.class differ
diff --git a/DeleteAll1.java b/DeleteAll1.java
new file mode 100644
index 0000000..7be215f
--- /dev/null
+++ b/DeleteAll1.java
@@ -0,0 +1,78 @@
+class DeleteAll1
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Node Delete()
+{
+Node temp=head;
+Node head1=new Node(-1);
+Node prev=head1;
+while(temp!=null)
+{
+Node start=temp;
+int count=0;
+while(temp!=null && start.data==temp.data)
+{
+temp=temp.next;
+count++;
+}
+if(count>1)
+start=temp;
+else
+{
+prev.next=start;
+prev=prev.next;
+}
+}
+prev.next=null;
+return head1.next;
+}
+
+public static void main(String args[])
+{
+DeleteAll1 s=new DeleteAll1();
+s.append(1);
+s.append(2);
+s.append(2);
+s.append(3);
+s.print();
+Node k=s.Delete();
+s.print();
+}
+}
\ No newline at end of file
diff --git a/DeleteAll2$Node.class b/DeleteAll2$Node.class
new file mode 100644
index 0000000..8d24203
Binary files /dev/null and b/DeleteAll2$Node.class differ
diff --git a/DeleteAll2.class b/DeleteAll2.class
new file mode 100644
index 0000000..13f291b
Binary files /dev/null and b/DeleteAll2.class differ
diff --git a/DeleteAll2.java b/DeleteAll2.java
new file mode 100644
index 0000000..97a570c
--- /dev/null
+++ b/DeleteAll2.java
@@ -0,0 +1,81 @@
+class DeleteAll2
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Node Delete()
+{
+Node temp=head;
+Node head1=new Node(-1);
+Node prev=head1;
+while(temp!=null)
+{
+Node start=temp;
+int count=0;
+while(temp!=null && start.data==temp.data)
+{
+temp=temp.next;
+count++;
+}
+if(count>1)
+{
+start=temp;
+}
+else
+{
+prev.next=start;
+prev=prev.next;
+}
+}
+prev.next=null;
+return head1.next;
+}
+
+public static void main(String args[])
+{
+DeleteAll2 s=new DeleteAll2();
+s.append(1);
+s.append(2);
+s.append(2);
+s.append(3);
+s.append(4);
+s.print();
+Node x=s.Delete();
+s.print();
+}
+}
\ No newline at end of file
diff --git a/DeleteNode$Node.class b/DeleteNode$Node.class
new file mode 100644
index 0000000..59f0618
Binary files /dev/null and b/DeleteNode$Node.class differ
diff --git a/DeleteNode.class b/DeleteNode.class
new file mode 100644
index 0000000..59b513f
Binary files /dev/null and b/DeleteNode.class differ
diff --git a/DeleteNode.java b/DeleteNode.java
new file mode 100644
index 0000000..6993005
--- /dev/null
+++ b/DeleteNode.java
@@ -0,0 +1,79 @@
+class DeleteNode
+{
+Node head;
+static class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+boolean isPalindrome()
+{
+Node temp=head;
+boolean isPalin=false;
+Stack<Integer> s=new Stack<>();
+while(temp!=null)
+{
+s.push(temp.data);
+temp=temp.next;
+}
+temp=head;
+
+while(temp!=null)
+{
+if(temp.data==s.pop())
+{
+isPalin=true;
+}
+else
+{
+isPalin=false;
+break;
+}
+temp=temp.next;
+}
+return isPalin;
+}
+
+public static void main(String args[])
+{
+DeleteNode s=new DeleteNode();
+s.append(10);
+s.append(11);
+s.append(10);
+s.print();
+System.out.println(s.isPalindrome());
+}
+}
\ No newline at end of file
diff --git a/Department.class b/Department.class
new file mode 100644
index 0000000..6ebe9bd
Binary files /dev/null and b/Department.class differ
diff --git a/Deque1.class b/Deque1.class
new file mode 100644
index 0000000..a56a54d
Binary files /dev/null and b/Deque1.class differ
diff --git a/Deque1.java b/Deque1.java
new file mode 100644
index 0000000..eddd15a
--- /dev/null
+++ b/Deque1.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class Deque1
+{
+public static void main(String args[])
+{
+Deque<Integer> s=new ArrayDeque<>();
+s.add(10);
+s.add(20);
+s.add(30);
+s.add(40);
+System.out.println(s);
+Iterator i=s.iterator();
+while(i.hasNext())
+{
+System.out.println(i.next());
+}
+
+}
+}
\ No newline at end of file
diff --git a/Deserial.class b/Deserial.class
new file mode 100644
index 0000000..a649cc2
Binary files /dev/null and b/Deserial.class differ
diff --git a/Deserial.java b/Deserial.java
new file mode 100644
index 0000000..4e40c95
--- /dev/null
+++ b/Deserial.java
@@ -0,0 +1,31 @@
+import java.io.*;
+class Deserial implements Serializable
+{
+String name;
+Deserial(String name)
+{
+this.name=name;
+}
+public static void main(String  args[])
+{
+Deserial d1=new Deserial("gaurav");
+try
+{
+FileOutputStream out=new FileOutputStream("dog.txt");
+ObjectOutputStream obj=new ObjectOutputStream(out);
+obj.writeObject(d1);
+
+FileInputStream f1=new FileInputStream("dog.txt");
+ObjectInputStream ob=new ObjectInputStream(f1);
+d1=(Deserial)ob.readObject();
+
+obj.close();
+out.close();
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+System.out.println(d1.name);
+}
+}
\ No newline at end of file
diff --git a/Deserial1.class b/Deserial1.class
new file mode 100644
index 0000000..7e1f51d
Binary files /dev/null and b/Deserial1.class differ
diff --git a/Deserial1.java b/Deserial1.java
new file mode 100644
index 0000000..75424c6
--- /dev/null
+++ b/Deserial1.java
@@ -0,0 +1,43 @@
+import java.io.*;
+class Student implements Serializable
+{
+String name;
+Student(String name)
+{
+this.name=name;
+}
+}
+
+class Deserial1
+{
+public static void main(String args[])
+{
+Student s=new Student("kumar");
+try
+{
+FileOutputStream f=new FileOutputStream("cat.txt");
+ObjectOutputStream ob=new ObjectOutputStream(f);
+ob.writeObject(s);
+ob.close();
+f.close();
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+
+try
+{
+FileInputStream f1=new FileInputStream("cat.txt");
+ObjectInputStream ob1=new ObjectInputStream(f1);
+s=(Student)ob1.readObject();
+ob1.close();
+f1.close();
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+System.out.println(s.name);
+}
+}
diff --git a/Details.class b/Details.class
new file mode 100644
index 0000000..3e22961
Binary files /dev/null and b/Details.class differ
diff --git a/Details.java b/Details.java
new file mode 100644
index 0000000..8021aa6
--- /dev/null
+++ b/Details.java
@@ -0,0 +1,26 @@
+class Collage
+{
+String branch;
+int age;
+Collage(String branch,int age)
+{
+this.branch=branch;
+this.age=age;
+}
+}
+
+class Details
+{
+public static void main(String args[])
+{
+Collage s[]=new Collage[3];
+s[0]=new Collage("CSE",20);
+s[1]=new Collage("MECH",21);
+s[2]=new Collage("ECE",32);
+for(int i=0;i<s.length;i++)
+{
+System.out.println(s[i].branch+":"+s[i].age);
+}
+
+}
+}
\ No newline at end of file
diff --git a/DisJoint.class b/DisJoint.class
new file mode 100644
index 0000000..7e6aec5
Binary files /dev/null and b/DisJoint.class differ
diff --git a/DisJoint.java b/DisJoint.java
new file mode 100644
index 0000000..4d1f639
--- /dev/null
+++ b/DisJoint.java
@@ -0,0 +1,26 @@
+import java.util.*;
+class DisJoint
+{
+public static void main(String args[])
+{
+List<String> l=new ArrayList<>();
+l.add("sujit");
+l.add("kushal");
+l.add("kumar");
+
+List<String> l1=new Vector<>();
+l1.add("vikash");
+l1.add("mukesh");
+l1.add("babu");
+l1.add("sujit");
+
+System.out.println(Collections.disjoint(l,l1));
+
+Set<String> set=new HashSet<>();
+set.add("gaurav");
+set.add("kushal");
+set.add("payal");
+
+System.out.println(Collections.disjoint(l,set));
+}
+}
\ No newline at end of file
diff --git a/DisJoint2.class b/DisJoint2.class
new file mode 100644
index 0000000..b783591
Binary files /dev/null and b/DisJoint2.class differ
diff --git a/DisJoint2.java b/DisJoint2.java
new file mode 100644
index 0000000..cc60049
--- /dev/null
+++ b/DisJoint2.java
@@ -0,0 +1,10 @@
+import java.util.*;
+class DisJoint2
+{
+public static void main(String args[])
+{
+Integer a[]={12,1,2,3,4,5};
+Integer b[]={21,23,34,56};
+System.out.println(Collections.disjoint(Arrays.asList(a),Arrays.asList(b)));
+}
+}
\ No newline at end of file
diff --git a/Dog.class b/Dog.class
new file mode 100644
index 0000000..8f0302e
Binary files /dev/null and b/Dog.class differ
diff --git a/Dog.java b/Dog.java
new file mode 100644
index 0000000..fea5bb3
--- /dev/null
+++ b/Dog.java
@@ -0,0 +1,17 @@
+class Dog
+{
+int age;
+String name;
+Dog(int age,String name)
+{
+this.age=age;
+this.name=name;
+}
+public static void main(String args[])
+{
+Dog d=new Dog(2,"Seru");
+Dog d1=new Dog(3,"Rocky");
+System.out.println("Age of Dog1="+d.age+ " Name of Dog="+d.name);
+System.out.println("Age of Dog2="+d1.age+" Name of Dog2="+d1.name);
+}
+} 
diff --git a/Dogi.class b/Dogi.class
new file mode 100644
index 0000000..92840a9
Binary files /dev/null and b/Dogi.class differ
diff --git a/Dogi.java b/Dogi.java
new file mode 100644
index 0000000..abe1fcc
--- /dev/null
+++ b/Dogi.java
@@ -0,0 +1,26 @@
+class hello
+{
+int age;
+String name;
+void run()
+{
+age=10;
+System.out.println("hello i am gaurav and age is:"+age);
+}
+
+void play()
+{
+name="sujit";
+System.out.println("Can you tell me your name:"+name);
+}
+}
+
+class Dogi
+{
+public static void main(String args[])
+{
+hello h=new hello();
+h.run();
+h.play();
+}
+}
\ No newline at end of file
diff --git a/Duration6.class b/Duration6.class
new file mode 100644
index 0000000..610e36c
Binary files /dev/null and b/Duration6.class differ
diff --git a/Duration6.java b/Duration6.java
new file mode 100644
index 0000000..adc10b5
--- /dev/null
+++ b/Duration6.java
@@ -0,0 +1,14 @@
+import java.time.*;
+class Duration6
+{
+public static void main(String args[])
+{
+Duration d=Duration.parse("P2DT3H4M");
+System.out.println(d);
+System.out.println(d.toHours());
+
+Duration d2=Duration.parse("P3DT4H2M");
+System.out.println(d2);
+System.out.println(d2.toHours());
+}
+}
\ No newline at end of file
diff --git a/DurationHour.class b/DurationHour.class
new file mode 100644
index 0000000..c6974fa
Binary files /dev/null and b/DurationHour.class differ
diff --git a/DurationHour.java b/DurationHour.java
new file mode 100644
index 0000000..b830466
--- /dev/null
+++ b/DurationHour.java
@@ -0,0 +1,21 @@
+import java.time.*;
+class DurationHour
+{
+public static void main(String args[])
+{
+Duration d=Duration.parse("P2DT4H20M");
+System.out.println(d);
+System.out.println(d.toHoursPart());
+Duration d2=Duration.parse("P3DT5H6M");
+System.out.println(d2.toHoursPart());
+
+Duration d3=Duration.ofHours(10);
+System.out.println(d3.toHoursPart());
+Duration d4=Duration.parse("P2DT45H30M");
+System.out.println(d4.toHoursPart());
+
+Duration d5=Duration.parse("P4DT55H60M");
+System.out.println(d5.toHoursPart());
+
+}
+}
\ No newline at end of file
diff --git a/Emp.class b/Emp.class
new file mode 100644
index 0000000..6bd8e61
Binary files /dev/null and b/Emp.class differ
diff --git a/Encap.class b/Encap.class
new file mode 100644
index 0000000..bd5ca68
Binary files /dev/null and b/Encap.class differ
diff --git a/Encap.java b/Encap.java
new file mode 100644
index 0000000..03baf7a
--- /dev/null
+++ b/Encap.java
@@ -0,0 +1,46 @@
+class Encap
+{
+private String name;
+private int roll;
+private int age;
+
+public void setName(String name)
+{
+this.name=name;
+} 
+
+public void setRoll(int roll)
+{
+this.roll=roll;
+}
+
+public void setAge(int age)
+{
+this.age=age;
+}
+
+public String getName()
+{
+return name;
+}
+
+public int getRoll()
+{
+return roll;
+}
+
+public int getAge()
+{
+return age;
+}
+
+public static void main(String args[])
+{
+Encap e=new Encap();
+e.setName("gaurav");
+e.setRoll(10);
+e.setAge(20);
+
+System.out.println("Name="+e.getName()+" Roll="+e.getRoll()+" Age="+e.getAge());
+}
+}
\ No newline at end of file
diff --git a/Encap1.class b/Encap1.class
new file mode 100644
index 0000000..31e7960
Binary files /dev/null and b/Encap1.class differ
diff --git a/Encap1.java b/Encap1.java
new file mode 100644
index 0000000..6afbe54
--- /dev/null
+++ b/Encap1.java
@@ -0,0 +1,36 @@
+class Student
+{
+private String name;
+private int roll;
+
+public void setName(String name)
+{
+this.name=name;
+}
+
+public void setRoll(int roll)
+{
+this.roll=roll;
+}
+
+public String getName()
+{
+return name;
+}
+
+public int getRoll()
+{
+return roll;
+}
+}
+
+class Encap1
+{
+public static void main(String args[])
+{
+Student s=new Student();
+s.setName("gaurav");
+s.setRoll(10);
+System.out.println("Name="+s.getName()+"Roll="+s.getRoll());
+}
+}
\ No newline at end of file
diff --git a/Encapsu.class b/Encapsu.class
new file mode 100644
index 0000000..cdc3f9b
Binary files /dev/null and b/Encapsu.class differ
diff --git a/Encapsu.java b/Encapsu.java
new file mode 100644
index 0000000..0f92df1
--- /dev/null
+++ b/Encapsu.java
@@ -0,0 +1,52 @@
+class Encapsulate
+{
+private String name;
+private int roll;
+private int age;
+
+public void setName(String name)
+{
+this.name=name;
+}
+
+public void setRoll(int roll)
+{
+this.roll=roll;
+}
+
+public void setAge(int age)
+{
+this.age=age;
+}
+
+public String getName()
+{
+return name;
+}
+
+public int getRoll()
+{
+return roll;
+}
+
+public int getAge()
+{
+return age;
+}
+}
+
+
+class Encapsu
+{
+public static void main(String args[])
+{
+Encapsulate e=new Encapsulate();
+e.setName("gaurav");
+e.setRoll(120);
+e.setAge(20);
+
+System.out.println("Name="+e.getName());
+System.out.println("Age="+e.getAge());
+System.out.println("Roll="+e.getRoll());
+}
+}
\ No newline at end of file
diff --git a/Encapsu1.class b/Encapsu1.class
new file mode 100644
index 0000000..4fa843d
Binary files /dev/null and b/Encapsu1.class differ
diff --git a/Encapsu1.java b/Encapsu1.java
new file mode 100644
index 0000000..dfd6b08
--- /dev/null
+++ b/Encapsu1.java
@@ -0,0 +1,52 @@
+class Encapsulate
+{
+private String branch;
+private int roll;
+private int age;
+
+public void setBranch(String branch)
+{
+this.branch=branch;
+}
+
+public void setRoll(int roll)
+{
+this.roll=roll;
+}
+
+public void setAge(int age)
+{
+this.age=age;
+}
+
+public String getBranch()
+{
+return branch;
+}
+
+public int getRoll()
+{
+return roll;
+}
+
+public int getAge()
+{
+return age;
+}
+}
+
+
+class Encapsu1
+{
+public static void main(String args[])
+{
+Encapsulate e=new Encapsulate();
+e.setBranch("CSE");
+e.setRoll(120);
+e.setAge(23);
+
+System.out.println("Name="+e.getBranch());
+System.out.println("Roll="+e.getRoll());
+System.out.println("Age="+e.getAge());
+}
+}
\ No newline at end of file
diff --git a/Encapsu2.class b/Encapsu2.class
new file mode 100644
index 0000000..2897650
Binary files /dev/null and b/Encapsu2.class differ
diff --git a/Encapsu2.java b/Encapsu2.java
new file mode 100644
index 0000000..cbe9e66
--- /dev/null
+++ b/Encapsu2.java
@@ -0,0 +1,39 @@
+class Encapsulate
+{
+private String collage;
+private int roll;
+
+public void setCollage(String collage)
+{
+this.collage=collage;
+}
+
+public void setRoll(int roll)
+{
+this.roll=roll;
+}
+
+public String getCollage()
+{
+return collage;
+}
+
+public int getRoll()
+{
+return roll;
+}
+
+}
+
+class Encapsu2
+{
+public static void main(String args[])
+{
+Encapsulate e=new Encapsulate();
+e.setCollage("NIT");
+e.setRoll(153);
+
+System.out.println("Collage="+e.getCollage());
+System.out.println("Roll="+e.getRoll());
+}
+}
\ No newline at end of file
diff --git a/Encapsulate.class b/Encapsulate.class
new file mode 100644
index 0000000..bb7f3bc
Binary files /dev/null and b/Encapsulate.class differ
diff --git a/Enum1$student.class b/Enum1$student.class
new file mode 100644
index 0000000..311b8d4
Binary files /dev/null and b/Enum1$student.class differ
diff --git a/Enum1.class b/Enum1.class
new file mode 100644
index 0000000..56ec064
Binary files /dev/null and b/Enum1.class differ
diff --git a/Enum1.java b/Enum1.java
new file mode 100644
index 0000000..001cf26
--- /dev/null
+++ b/Enum1.java
@@ -0,0 +1,22 @@
+import java.util.*;
+class Enum1
+{
+enum student
+{
+CODE,CONTRIBUTING,JAVA,PYTHON;
+}
+
+public static void main(String args[])
+{
+EnumMap<student,String> map=new EnumMap<>(student.class);
+map.put(student.CODE,"Hello");
+map.put(student.CONTRIBUTING,"We are contributing something");
+map.put(student.JAVA,"I am learning java");
+map.put(student.PYTHON,"I am also learning java");
+System.out.println("the map is:"+map);
+System.out.println("\nSize of Enum map is:"+map.size());
+System.out.println("\nThe Retrieving data:"+map.get(student.JAVA));
+System.out.println("\nAnother data is:"+map.get(student.CONTRIBUTING));
+System.out.println("Is it present:"+map.containsKey(student.CODE));
+}
+}
\ No newline at end of file
diff --git a/Enum3.class b/Enum3.class
new file mode 100644
index 0000000..c330c28
Binary files /dev/null and b/Enum3.class differ
diff --git a/Enum3.java b/Enum3.java
new file mode 100644
index 0000000..3009094
--- /dev/null
+++ b/Enum3.java
@@ -0,0 +1,14 @@
+import java.util.*;
+enum gaurav
+{
+JAVA,PYTHON,PHP,CSS,HTML;
+}
+
+class Enum3
+{
+public static void main(String args[])
+{
+Set<gaurav> s=EnumSet.of(gaurav.JAVA,gaurav.PYTHON,gaurav.PHP);
+System.out.println("the set is:"+s);
+}
+}
\ No newline at end of file
diff --git a/Enum4.class b/Enum4.class
new file mode 100644
index 0000000..c57266a
Binary files /dev/null and b/Enum4.class differ
diff --git a/Enum4.java b/Enum4.java
new file mode 100644
index 0000000..f3cbb86
--- /dev/null
+++ b/Enum4.java
@@ -0,0 +1,14 @@
+import java.util.*;
+enum baba
+{
+KUMAR,ANKIT,GAURAV,SUJIT;
+}
+
+class Enum4
+{
+public static void main(String args[])
+{
+Set<baba> set=EnumSet.of(baba.KUMAR,baba.ANKIT,baba.GAURAV,baba.SUJIT);
+System.out.println("The set is:"+set);
+}
+}
\ No newline at end of file
diff --git a/Enum5.class b/Enum5.class
new file mode 100644
index 0000000..cfc84c9
Binary files /dev/null and b/Enum5.class differ
diff --git a/Enum5.java b/Enum5.java
new file mode 100644
index 0000000..0036f9e
--- /dev/null
+++ b/Enum5.java
@@ -0,0 +1,23 @@
+import java.util.*;
+enum gfg
+{
+KUMAR,SUJIT,KUSHAL,ANKIT;
+}
+
+class Enum5
+{
+public static void main(String args[])
+{
+Set<gfg> s=EnumSet.allOf(gfg.class);
+System.out.println("the set is:"+s);
+
+Set<gfg> s1=EnumSet.noneOf(gfg.class);
+System.out.println("the value is:"+s1);
+
+Set<gfg> s3=EnumSet.allOf(gfg.class);
+System.out.println("the value is:"+s3);
+
+Set<gfg> s4=EnumSet.allOf(gfg.class);
+System.out.println(s4);
+}
+}
\ No newline at end of file
diff --git a/Enumeration1.class b/Enumeration1.class
new file mode 100644
index 0000000..336637f
Binary files /dev/null and b/Enumeration1.class differ
diff --git a/Enumeration1.java b/Enumeration1.java
new file mode 100644
index 0000000..56be1bc
--- /dev/null
+++ b/Enumeration1.java
@@ -0,0 +1,21 @@
+import java.util.*;
+class Enumeration1
+{
+public static void main(String args[])
+{
+Vector v=new Vector();
+v.addElement("sujit");
+v.addElement("kumar");
+v.addElement("kushal");
+v.addElement("gaurav");
+System.out.println(v);
+
+Enumeration e=v.elements();
+while(e.hasMoreElements())
+{
+
+String k=(String)e.nextElement();
+System.out.println(k);
+}
+}
+}
diff --git a/EvenNumber$Node.class b/EvenNumber$Node.class
new file mode 100644
index 0000000..9a6db55
Binary files /dev/null and b/EvenNumber$Node.class differ
diff --git a/EvenNumber.class b/EvenNumber.class
new file mode 100644
index 0000000..fcf76c1
Binary files /dev/null and b/EvenNumber.class differ
diff --git a/EvenNumber.java b/EvenNumber.java
new file mode 100644
index 0000000..461ec1b
--- /dev/null
+++ b/EvenNumber.java
@@ -0,0 +1,101 @@
+class EvenNumber
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Node arrange()
+{
+Node temp=head;
+Node head1=null;
+Node head2=null;
+Node even=head1;
+Node odd=head2;
+while(temp!=null)
+{
+if(temp.data%2==0)
+{
+if(head1==null)
+{
+head1=temp;
+even=head1;
+}
+else
+{
+even.next=temp;
+even=even.next;
+}
+}
+
+else
+{
+if(head2==null)
+{
+head2=temp;
+odd=head2;
+}
+else
+{
+odd.next=temp;
+odd=odd.next;
+}
+}
+temp=temp.next;
+}
+
+even.next=head2;
+odd.next=null;
+head=head1;
+return head;
+}
+
+public static void main(String args[])
+{
+EvenNumber a=new EvenNumber();
+a.append(1);
+a.append(2);
+a.append(3);
+a.append(4);
+a.append(5);
+a.append(6);
+a.print();
+Node k=a.arrange();
+a.print();
+}
+}
\ No newline at end of file
diff --git a/Exception1.class b/Exception1.class
new file mode 100644
index 0000000..eb5f168
Binary files /dev/null and b/Exception1.class differ
diff --git a/Exception1.java b/Exception1.java
new file mode 100644
index 0000000..e0e308e
--- /dev/null
+++ b/Exception1.java
@@ -0,0 +1,24 @@
+class  Parent
+{
+void eat() throws RuntimeException
+{
+System.out.println("I am doing the same things");
+}
+}
+
+class child1 extends Parent
+{
+void eat() throws ArithmeticException
+{
+System.out.println("It will throws an child class Exception");
+}
+}
+
+class Exception1
+{
+public static void main(String args[])
+{
+child1 c=new child1();
+c.eat();
+}
+}
\ No newline at end of file
diff --git a/Fibonacci1.class b/Fibonacci1.class
new file mode 100644
index 0000000..df3cba6
Binary files /dev/null and b/Fibonacci1.class differ
diff --git a/Fibonacci1.java b/Fibonacci1.java
new file mode 100644
index 0000000..ca76b42
--- /dev/null
+++ b/Fibonacci1.java
@@ -0,0 +1,21 @@
+import java.util.*;
+class Fibonacci1
+{
+public static void main(String args[])
+{
+Scanner sc=new Scanner(System.in);
+System.out.println("Enter the number");
+int n=sc.nextInt();
+int a=0;
+int b=1;
+System.out.print(a+" ");
+System.out.print(b+" ");
+for(int i=0;i<n-2;i++)
+{
+int c=a+b;
+System.out.print(c+" ");
+a=b;
+b=c;
+}
+}
+}
\ No newline at end of file
diff --git a/FinalStudent.class b/FinalStudent.class
new file mode 100644
index 0000000..d6ff7ba
Binary files /dev/null and b/FinalStudent.class differ
diff --git a/FinalStudent.java b/FinalStudent.java
new file mode 100644
index 0000000..20671dd
--- /dev/null
+++ b/FinalStudent.java
@@ -0,0 +1,14 @@
+class FinalStudent
+{
+static final int x;
+static
+{
+x=10;
+System.out.println("X="+x);
+}
+public static void main(String args[])
+{
+FinalStudent s=new FinalStudent();
+System.out.println("Hello kumar");
+}
+}
\ No newline at end of file
diff --git a/FinalValue.class b/FinalValue.class
new file mode 100644
index 0000000..2e4c182
Binary files /dev/null and b/FinalValue.class differ
diff --git a/FinalValue.java b/FinalValue.java
new file mode 100644
index 0000000..e847be1
--- /dev/null
+++ b/FinalValue.java
@@ -0,0 +1,13 @@
+class FinalValue
+{
+final int i;
+FinalValue()
+{
+i=10;
+}
+public static void main(String args[])
+{
+FinalValue f=new FinalValue();
+System.out.println("The value is:"+f.i);
+}
+}
\ No newline at end of file
diff --git a/FinalValue1.class b/FinalValue1.class
new file mode 100644
index 0000000..a5c0fbf
Binary files /dev/null and b/FinalValue1.class differ
diff --git a/FinalValue1.java b/FinalValue1.java
new file mode 100644
index 0000000..778bded
--- /dev/null
+++ b/FinalValue1.java
@@ -0,0 +1,22 @@
+class FinalValue1
+{
+static final int i;
+static
+{
+i=20;
+}
+
+static 
+{
+System.out.println("Hello how are you");
+}
+public static void main(String args[])
+{
+FinalValue1 f=new FinalValue1();
+System.out.println("The value is:"+f.i);
+}
+static 
+{
+System.out.println("hello");
+}
+}
\ No newline at end of file
diff --git a/FindDate1.class b/FindDate1.class
new file mode 100644
index 0000000..7b41371
Binary files /dev/null and b/FindDate1.class differ
diff --git a/FindDate1.java b/FindDate1.java
new file mode 100644
index 0000000..6720fa0
--- /dev/null
+++ b/FindDate1.java
@@ -0,0 +1,19 @@
+import java.util.*;
+import java.time.*;
+class FindDate1
+{
+static void Day(String s)
+{
+LocalDate l=LocalDate.parse(s);
+int day=l.getDayOfMonth();
+System.out.println(day);
+
+Month month=l.getMonth();
+System.out.println(month);
+}
+public static void main(String args[])
+{
+String s="2020-02-21";
+Day(s);
+}
+}
\ No newline at end of file
diff --git a/FindDay.class b/FindDay.class
new file mode 100644
index 0000000..6aa7798
Binary files /dev/null and b/FindDay.class differ
diff --git a/FindDay.java b/FindDay.java
new file mode 100644
index 0000000..3d3ed96
--- /dev/null
+++ b/FindDay.java
@@ -0,0 +1,19 @@
+import java.time.*;
+class FindDay
+{
+static void Day(String date)
+{
+LocalDate l=LocalDate.parse(date);
+int day=l.getDayOfMonth();
+System.out.println("Day is:"+day);
+Month month = l.getMonth();
+System.out.println("Month is:"+month);
+int year=l.getYear();
+System.out.println("Year is:"+year);
+}
+public static void main(String args[])
+{
+String date="2021-02-20";
+Day(date);
+}
+}
\ No newline at end of file
diff --git a/FindDuplicate.class b/FindDuplicate.class
new file mode 100644
index 0000000..220490b
Binary files /dev/null and b/FindDuplicate.class differ
diff --git a/FindDuplicate.java b/FindDuplicate.java
new file mode 100644
index 0000000..4e3c6b8
--- /dev/null
+++ b/FindDuplicate.java
@@ -0,0 +1,23 @@
+import java.util.*;
+class FindDuplicate
+{
+static List<Integer> duplicate(int a[])
+{
+List<Integer> l=new ArrayList<>();
+Arrays.sort(a);
+for(int i=0;i<a.length-1;i++)
+{
+if(a[i]==a[i+1])
+{
+l.add(a[i]);
+}
+}
+return l;
+}
+public static void main(String args[])
+{
+int a[]={1,2,1,3,2,3,4};
+List<Integer> k=duplicate(a);
+System.out.println("The value is:"+k);
+}
+}
\ No newline at end of file
diff --git a/FindMiddle$Node.class b/FindMiddle$Node.class
new file mode 100644
index 0000000..5b3cfc0
Binary files /dev/null and b/FindMiddle$Node.class differ
diff --git a/FindMiddle.class b/FindMiddle.class
new file mode 100644
index 0000000..072ca54
Binary files /dev/null and b/FindMiddle.class differ
diff --git a/FindMiddle.java b/FindMiddle.java
new file mode 100644
index 0000000..4b58499
--- /dev/null
+++ b/FindMiddle.java
@@ -0,0 +1,59 @@
+class FindMiddle
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+int count=0;
+Node temp=head;
+while(temp!=null)
+{
+count+=1;
+temp=temp.next;
+}
+temp=head;
+for(int i=0;i<count/2 && temp!=null;i++)
+{
+temp=temp.next;
+}
+System.out.println(temp.data);
+}
+
+public static void main(String args[])
+{
+FindMiddle f=new FindMiddle();
+f.append(10);
+f.append(20);
+f.append(30);
+f.append(40);
+f.append(60);
+f.append(90);
+f.print();
+}
+}
\ No newline at end of file
diff --git a/FindMiddle1$Node.class b/FindMiddle1$Node.class
new file mode 100644
index 0000000..d71659c
Binary files /dev/null and b/FindMiddle1$Node.class differ
diff --git a/FindMiddle1.class b/FindMiddle1.class
new file mode 100644
index 0000000..3c17960
Binary files /dev/null and b/FindMiddle1.class differ
diff --git a/FindMiddle1.java b/FindMiddle1.java
new file mode 100644
index 0000000..bd52f90
--- /dev/null
+++ b/FindMiddle1.java
@@ -0,0 +1,60 @@
+//Find the middle element using two pointer?
+class FindMiddle1
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void printMiddle()
+{
+Node fast=head;
+Node slow=head;
+if(head!=null)
+{
+while(fast!=null && fast.next!=null)
+{
+fast=fast.next.next;
+slow=slow.next;
+}
+}
+System.out.println("Middle Node is:"+slow.data);
+}
+
+void push(int data)
+{
+Node x=new Node(data);
+x.next=head;
+head=x;
+}
+public static void main(String args[])
+{
+FindMiddle1 f=new FindMiddle1();
+f.push(10);
+f.push(20);
+f.push(30);
+f.push(40);
+f.print();
+System.out.println("Print the middle elemnt");
+f.printMiddle();
+
+}
+}
\ No newline at end of file
diff --git a/FindNodeLast$Node.class b/FindNodeLast$Node.class
new file mode 100644
index 0000000..093b923
Binary files /dev/null and b/FindNodeLast$Node.class differ
diff --git a/FindNodeLast.class b/FindNodeLast.class
new file mode 100644
index 0000000..2aea902
Binary files /dev/null and b/FindNodeLast.class differ
diff --git a/FindNodeLast.java b/FindNodeLast.java
new file mode 100644
index 0000000..43e5404
--- /dev/null
+++ b/FindNodeLast.java
@@ -0,0 +1,65 @@
+class FindNodeLast
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void push(int data)
+{
+Node x=new Node(data);
+x.next=head;
+head=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.println(temp.data);
+temp=temp.next;
+}
+}
+
+int findValue(int pos)
+{
+Node temp=head;
+int len=0;
+while(temp!=null)
+{
+len+=1;
+temp=temp.next;
+}
+
+if(pos>len)
+{
+return -1;
+}
+temp=head;
+for(int i=1;i<len-pos+1;i++)
+{
+temp=temp.next;
+}
+return temp.data;
+}
+
+public static void main(String args[])
+{
+FindNodeLast l=new FindNodeLast();
+l.push(10);
+l.push(20);
+l.push(30);
+l.push(40);
+l.print();
+System.out.println("Find the value at the given index:"+l.findValue(3));
+
+}
+}
\ No newline at end of file
diff --git a/FindPrime1.class b/FindPrime1.class
new file mode 100644
index 0000000..2e83cf6
Binary files /dev/null and b/FindPrime1.class differ
diff --git a/FindPrime1.java b/FindPrime1.java
new file mode 100644
index 0000000..3086077
--- /dev/null
+++ b/FindPrime1.java
@@ -0,0 +1,49 @@
+import java.util.*;
+class FindPrime1
+{
+static ArrayList<Integer> l=new ArrayList<>();
+static void findPrime(int a,int b)
+{
+if(a==1)
+{
+a++;
+}
+if(b>=2)
+{
+l.add(a);
+a++;
+}
+
+if(a==2)
+l.add(a);
+
+if(a%2==0)
+a++;
+
+for(int i=a;i<=b;i+=2)
+{
+int flag=1;
+for(int j=2;j*j<=i;j++)
+{
+if(i%j==0)
+{
+flag=0;
+break;
+}
+}
+
+if(flag==1)
+{
+l.add(i);
+}
+}
+System.out.println(l);
+}
+public static void main(String args[])
+{
+Scanner sc=new Scanner(System.in);
+int a=sc.nextInt();
+int b=sc.nextInt();
+findPrime(a,b);
+}
+}
\ No newline at end of file
diff --git a/FindSecond$Node.class b/FindSecond$Node.class
new file mode 100644
index 0000000..8147d14
Binary files /dev/null and b/FindSecond$Node.class differ
diff --git a/FindSecond.class b/FindSecond.class
new file mode 100644
index 0000000..2db156c
Binary files /dev/null and b/FindSecond.class differ
diff --git a/FindSecond.java b/FindSecond.java
new file mode 100644
index 0000000..dbcdb32
--- /dev/null
+++ b/FindSecond.java
@@ -0,0 +1,72 @@
+class FindSecond
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void findKth(int k)
+{
+Node fast=head;
+Node slow=head;
+
+for(int i=0;i<k;i++)
+{
+fast=fast.next;
+}
+
+while(fast!=null)
+{
+
+slow=slow.next;
+fast=fast.next;
+}
+System.out.println("Second Element is:"+slow.data);
+}
+
+public static void main(String args[])
+{
+FindSecond f=new FindSecond();
+f.append(10);
+f.append(20);
+f.append(30);
+f.append(40);
+f.append(50);
+f.print();
+f.findKth(2);
+}
+}
diff --git a/FindSubsequence.class b/FindSubsequence.class
new file mode 100644
index 0000000..343b1e3
Binary files /dev/null and b/FindSubsequence.class differ
diff --git a/FindSubsequence.java b/FindSubsequence.java
new file mode 100644
index 0000000..f6f5404
--- /dev/null
+++ b/FindSubsequence.java
@@ -0,0 +1,22 @@
+import java.util.*;
+class FindSubsequence
+{
+static ArrayList<String> l=new ArrayList<>();
+static void find(String s,String ans)
+{
+if(s.length()==0)
+{
+l.add(ans);
+return;
+}
+
+find(s.substring(1),ans+s.charAt(0));
+find(s.substring(1),ans);
+}
+public static void main(String args[])
+{
+String s="ram";
+find(s,"");
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/Freq.class b/Freq.class
new file mode 100644
index 0000000..99bf960
Binary files /dev/null and b/Freq.class differ
diff --git a/Freq.java b/Freq.java
new file mode 100644
index 0000000..4131d01
--- /dev/null
+++ b/Freq.java
@@ -0,0 +1,14 @@
+import java.util.*;
+class Freq
+{
+public static void main(String args[])
+{
+List<String> l=new ArrayList<>();
+l.add("sujit");
+l.add("gaurav");
+l.add("kumar");
+l.add("kumar");
+
+System.out.println(Collections.frequency(l,"kumar"));
+}
+}
\ No newline at end of file
diff --git a/Gaurav1.class b/Gaurav1.class
new file mode 100644
index 0000000..c891dd6
Binary files /dev/null and b/Gaurav1.class differ
diff --git a/Gaurav1.java b/Gaurav1.java
new file mode 100644
index 0000000..eeea46b
--- /dev/null
+++ b/Gaurav1.java
@@ -0,0 +1,33 @@
+class Vikash
+{
+void eat()
+{
+System.out.println("I am eating something");
+}
+
+void dance()
+{
+System.out.println("I am doing dance");
+}
+}
+
+class Gaurav1 extends Vikash
+{
+void eat()
+{
+System.out.println("I am not eating anything");
+}
+
+void sleep()
+{
+System.out.println("I gonna sleep");
+}
+public static void main(String args[])
+{
+Vikash v=new Gaurav1();
+v.eat();
+
+Gaurav1 g1=new Gaurav1();
+g1.sleep();
+}
+}
\ No newline at end of file
diff --git a/HashMap1.class b/HashMap1.class
new file mode 100644
index 0000000..dfb9d8a
Binary files /dev/null and b/HashMap1.class differ
diff --git a/HashMap1.java b/HashMap1.java
new file mode 100644
index 0000000..f493ffb
--- /dev/null
+++ b/HashMap1.java
@@ -0,0 +1,23 @@
+import java.util.*;
+class HashMap1
+{
+public static void main(String args[])
+{
+System.out.println("First HashMap is:");
+HashMap<Integer,String> map=new HashMap<>(5);
+map.put(1,"gaurav");
+map.put(2,"sujit");
+map.put(3,"kumar");
+map.put(4,"Ankit");
+map.put(5,"kushal");
+map.put(6,"kunal");
+System.out.println(map);
+System.out.println("\nAnother map is:");
+HashMap<Integer,String> map1=new HashMap<>(map);
+System.out.println(map1);
+
+HashMap<Integer,String> map2=new HashMap<>();
+map2.putAll(map1);
+System.out.println("\nThird HashMap is:"+map2);
+}
+}
\ No newline at end of file
diff --git a/HashTable.class b/HashTable.class
new file mode 100644
index 0000000..268bff6
Binary files /dev/null and b/HashTable.class differ
diff --git a/HashTable.java b/HashTable.java
new file mode 100644
index 0000000..de08bb0
--- /dev/null
+++ b/HashTable.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class HashTable
+{
+public static void main(String args[])
+{
+Hashtable<String,Integer> h=new Hashtable<>();
+h.put("gaurav",153);
+h.put("kushal",156);
+h.put("ankit",245);
+h.put("vikash",78);
+System.out.println("HashTable is:"+h);
+
+Hashtable<Integer,String> hs=new Hashtable<>();
+hs.put(1,"cse");
+hs.put(2,"mech");
+hs.put(3,"ece");
+System.out.println("Hashtable is:"+hs);
+hs.forEach((k,v)->System.out.println(k+":"+v));
+}
+}
\ No newline at end of file
diff --git a/HashTable1.class b/HashTable1.class
new file mode 100644
index 0000000..fbd2950
Binary files /dev/null and b/HashTable1.class differ
diff --git a/HashTable1.java b/HashTable1.java
new file mode 100644
index 0000000..dc21aab
--- /dev/null
+++ b/HashTable1.java
@@ -0,0 +1,16 @@
+import java.util.*;
+class HashTable1
+{
+public static void main(String args[])
+{
+Hashtable<Integer,String> ht=new Hashtable<>(3);
+ht.put(1,"kumar");
+ht.put(2,"gaurav");
+ht.put(3,"sujit");
+ht.put(4,"kushal");
+System.out.println(ht);
+Hashtable<Integer,String>hs=new Hashtable<>(ht);
+System.out.println("Another" + "\"hashtable\" is:"+hs);
+System.out.println(" \"gaurav\" ");
+}
+}
diff --git a/Hiding1.class b/Hiding1.class
new file mode 100644
index 0000000..b1a3b63
Binary files /dev/null and b/Hiding1.class differ
diff --git a/Hiding1.java b/Hiding1.java
new file mode 100644
index 0000000..128ea97
--- /dev/null
+++ b/Hiding1.java
@@ -0,0 +1,46 @@
+class Student 
+{
+static void run()
+{
+System.out.println("This is method hiding");
+}
+
+void eat()
+{
+System.out.println("Hello method overriding");
+}
+
+void play()
+{
+System.out.println("hello i am doing");
+}
+}
+
+class Collage extends Student
+{
+static void run()
+{
+System.out.println("Hello child hiding");
+}
+
+void eat()
+{
+System.out.println("Hello method riding");
+}
+
+void play()
+{
+System.out.println("Hello, I am playing in collage");
+}
+}
+
+class Hiding1
+{
+public static void main(String args[])
+{
+Student c=new Collage();
+c.eat();
+c.run();
+c.play();
+}
+}
\ No newline at end of file
diff --git a/HourGlass.class b/HourGlass.class
new file mode 100644
index 0000000..7265228
Binary files /dev/null and b/HourGlass.class differ
diff --git a/HourGlass.java b/HourGlass.java
new file mode 100644
index 0000000..a79d10c
--- /dev/null
+++ b/HourGlass.java
@@ -0,0 +1,59 @@
+import java.util.*;
+class HourGlass
+{
+static void maxSum(int a[])
+{
+int max=Integer.MIN_VALUE;
+int sum=0;
+int n=a.length;
+for(int i=0;i<n;i++)
+{
+sum+=a[i];
+if(sum>max)
+max=sum;
+
+if(sum<0)
+sum=0;
+}
+int curSum=0;
+int left=0;
+int right=0;
+int i=0;
+int j=0;
+List<Integer> l=new ArrayList<>();
+while(left<a.length && right<a.length)
+{
+curSum+=a[right];
+if(curSum<0)
+{
+curSum=0;
+left++;
+right++;
+}
+else if(curSum==max)
+{
+i=left;
+j=right;
+break;
+}
+
+else if(curSum<max)
+right++;
+else
+left++;
+}
+
+for(int k=i;k<=j;k++)
+{
+l.add(a[k]);
+}
+System.out.println(l);
+}
+public static void main(String args[])
+{
+int a[]={2,1,3,-1,-3};
+maxSum(a);
+
+}
+}
+
diff --git a/Initializer1.class b/Initializer1.class
new file mode 100644
index 0000000..ad54529
Binary files /dev/null and b/Initializer1.class differ
diff --git a/Initializer1.java b/Initializer1.java
new file mode 100644
index 0000000..ab21e14
--- /dev/null
+++ b/Initializer1.java
@@ -0,0 +1,27 @@
+class collage
+{
+{
+System.out.println("This will execute first before the every constructor");
+
+}
+
+collage()
+{
+System.out.println("Hello Default Constructor");
+}
+
+collage(int a)
+{
+System.out.println("helo parameter");
+}
+}
+
+class Initializer1
+{
+public static void main(String args[])
+{
+collage c1=new collage();
+collage c2=new collage(10);
+
+}
+}
\ No newline at end of file
diff --git a/Initializer2.class b/Initializer2.class
new file mode 100644
index 0000000..bd73569
Binary files /dev/null and b/Initializer2.class differ
diff --git a/Initializer2.java b/Initializer2.java
new file mode 100644
index 0000000..2ed8286
--- /dev/null
+++ b/Initializer2.java
@@ -0,0 +1,37 @@
+class Collage
+{
+Collage()
+{
+System.out.println("Hello Collage");
+}
+
+{
+System.out.println("Hello Instance Initializer block");
+}
+}
+
+class Sujit extends Collage
+{
+
+{
+System.out.println("Intance Initializer Block");
+}
+
+Sujit()
+{
+super();
+System.out.println("Called Sujit");
+}
+
+
+}
+
+
+class Initializer2
+{
+public static void main(String args[])
+{
+//Collage c=new Collage();
+Sujit s=new Sujit();
+}
+}
\ No newline at end of file
diff --git a/Insertion1.class b/Insertion1.class
new file mode 100644
index 0000000..a03fc8e
Binary files /dev/null and b/Insertion1.class differ
diff --git a/Insertion1.java b/Insertion1.java
new file mode 100644
index 0000000..0e22724
--- /dev/null
+++ b/Insertion1.java
@@ -0,0 +1,22 @@
+import java.util.*;
+class Insertion1
+{
+public static void main(String args[])
+{
+int a[]={6,5,4,3,2,1};
+int n=a.length;
+for(int i=1;i<n;i++)
+{
+int temp=a[i];
+int j=i-1;
+while(j>=0 && a[j]>temp)
+{
+a[j+1]=a[j];
+j--;
+}
+a[j+1]=temp;
+}
+
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/Instance1.class b/Instance1.class
new file mode 100644
index 0000000..c44e748
Binary files /dev/null and b/Instance1.class differ
diff --git a/Instance1.java b/Instance1.java
new file mode 100644
index 0000000..7075498
--- /dev/null
+++ b/Instance1.java
@@ -0,0 +1,29 @@
+class Student
+{
+int roll;
+int regd;
+Student()
+{
+roll=153;
+regd=1;
+}
+
+Student Test()
+{
+return this;
+}
+
+void display()
+{
+System.out.println("Roll="+roll+ " and Regd="+regd);
+}
+}
+
+class Instance1
+{
+public static void main(String args[])
+{
+Student s=new Student();
+s.Test().display();
+}
+}
\ No newline at end of file
diff --git a/Instant1.class b/Instant1.class
new file mode 100644
index 0000000..7aca64c
Binary files /dev/null and b/Instant1.class differ
diff --git a/Instant1.java b/Instant1.java
new file mode 100644
index 0000000..0b123d3
--- /dev/null
+++ b/Instant1.java
@@ -0,0 +1,9 @@
+import java.time.*;
+class Instant1
+{
+public static void main(String args[])
+{
+Instant i=Instant.now();
+System.out.println(i);
+}
+}
\ No newline at end of file
diff --git a/Instant2.class b/Instant2.class
new file mode 100644
index 0000000..09a2070
Binary files /dev/null and b/Instant2.class differ
diff --git a/Instant2.java b/Instant2.java
new file mode 100644
index 0000000..d14e18b
--- /dev/null
+++ b/Instant2.java
@@ -0,0 +1,18 @@
+import java.time.*;
+class Instant2
+{
+public static void main(String args[])
+{
+Clock c=Clock.systemUTC();
+Instant i=Instant.now(c);
+System.out.println(i);
+
+Clock c1=Clock.systemUTC();
+Instant i1=Instant.now(c1);
+System.out.println(i1);
+
+Clock c2=Clock.systemUTC();
+Instant i2=Instant.now(c2);
+System.out.println(i2);
+}
+}
diff --git a/Institute.class b/Institute.class
new file mode 100644
index 0000000..2fce7ba
Binary files /dev/null and b/Institute.class differ
diff --git a/Instnace1.class b/Instnace1.class
new file mode 100644
index 0000000..cf8267f
Binary files /dev/null and b/Instnace1.class differ
diff --git a/Instnace1.java b/Instnace1.java
new file mode 100644
index 0000000..4774bf6
--- /dev/null
+++ b/Instnace1.java
@@ -0,0 +1,19 @@
+class Instnace1
+{
+void run()
+{
+System.out.println("I am running");
+play();
+}
+
+static void play()
+{
+System.out.println("I am playing now");
+}
+
+public static void main(String args[])
+{
+Instnace1 s=new Instnace1();
+s.run();
+}
+}
\ No newline at end of file
diff --git a/Intersect$Node.class b/Intersect$Node.class
new file mode 100644
index 0000000..13124e8
Binary files /dev/null and b/Intersect$Node.class differ
diff --git a/Intersect.class b/Intersect.class
new file mode 100644
index 0000000..9ad2950
Binary files /dev/null and b/Intersect.class differ
diff --git a/Intersect.java b/Intersect.java
new file mode 100644
index 0000000..d90b381
--- /dev/null
+++ b/Intersect.java
@@ -0,0 +1,91 @@
+import java.util.*;
+class Intersect
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Intersect intersection(Node head1,Node head2)
+{
+Node temp1=head1;
+Node temp2=head2;
+HashSet<Integer> set=new HashSet();
+Intersect s=new Intersect();
+while(temp1!=null)
+{
+set.add(temp1.data);
+temp1=temp1.next;
+}
+
+while(temp2!=null)
+{
+if(set.contains(temp2.data))
+{
+s.append(temp2.data);
+}
+temp2=temp2.next;
+}
+
+return s;
+}
+
+public static void main(String args[])
+{
+Intersect s1=new Intersect();
+Intersect s2=new Intersect();
+Intersect s3=new Intersect();
+
+
+s1.append(10);
+s1.append(20);
+s1.append(30);
+s1.append(33);
+System.out.println("First List is");
+s1.print();
+
+s2.append(20);
+s2.append(30);
+s2.append(34);
+System.out.println("Second List is:");
+s2.print();
+
+Intersect k=s3.intersection(s1.head,s2.head);
+System.out.println("Intersection of two list");
+k.print();
+}
+}
\ No newline at end of file
diff --git a/Intersection1$Node.class b/Intersection1$Node.class
new file mode 100644
index 0000000..8320725
Binary files /dev/null and b/Intersection1$Node.class differ
diff --git a/Intersection1.class b/Intersection1.class
new file mode 100644
index 0000000..2711c55
Binary files /dev/null and b/Intersection1.class differ
diff --git a/Intersection1.java b/Intersection1.java
new file mode 100644
index 0000000..f670892
--- /dev/null
+++ b/Intersection1.java
@@ -0,0 +1,117 @@
+class Intersection1
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+int getNode(Node head1,Node head2)
+{
+int c1=getCount(head1);
+int c2=getCount(head2);
+int d;
+if(c1>c2)
+{
+d=c1-c2;
+return point(d,head1,head2);
+}
+else
+{
+d=c2-c1;
+return point(d,head1,head2);
+}
+}
+
+int getCount(Node node)
+{
+int count=0;
+Node temp=node;
+while(temp!=null)
+{
+count+=1;
+temp=temp.next;
+}
+return count;
+}
+
+int point(int d,Node head1,Node head2)
+{
+Node temp1=head1;
+Node temp2=head2;
+for(int i=0;i<d;i++)
+{
+if(temp1==null)
+{
+return -1;
+}
+temp1=temp1.next;
+}
+
+while(temp1!=null && temp2!=null)
+{
+if(temp1.data==temp2.data)
+{
+return temp1.data;
+}
+temp1=temp1.next;
+temp2=temp2.next;
+}
+return -1;
+}
+
+public static void main(String args[])
+{
+Intersection1 i=new Intersection1();
+i.append(3);
+i.append(6);
+i.append(9);
+i.append(15);
+i.append(30);
+i.print();
+
+Intersection1 i1=new Intersection1();
+i1.append(10);
+i1.append(15);
+i1.append(30);
+System.out.println("Second LinkedList is:");
+i1.print();
+
+Intersection1 i3=new Intersection1();
+System.out.println("The intersection point is:"+i3.getNode(i.head,i1.head));
+}
+}
\ No newline at end of file
diff --git a/IntersectionPoint.java b/IntersectionPoint.java
new file mode 100644
index 0000000..5c2579a
--- /dev/null
+++ b/IntersectionPoint.java
@@ -0,0 +1,53 @@
+class IntersecionPoint
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+public static void main(String args[])
+{
+IntersectionPoint i=new IntersectionPoint();
+i.append(3);
+i.append(6);
+i.append(9);
+i.append(15);
+i.append(30);
+i.print();
+}
+}
\ No newline at end of file
diff --git a/Iterable1.class b/Iterable1.class
new file mode 100644
index 0000000..1b0cdb2
Binary files /dev/null and b/Iterable1.class differ
diff --git a/Iterable1.java b/Iterable1.java
new file mode 100644
index 0000000..db88483
--- /dev/null
+++ b/Iterable1.java
@@ -0,0 +1,17 @@
+import java.util.*;
+class Iterable1
+{
+public static void main(String args[])
+{
+Iterable<Integer> i=Arrays.asList(1,2,3,4);
+System.out.println(i);
+
+Collection<Integer>  c=new ArrayList<>();
+for(Integer x:i)
+{
+c.add(x);
+}
+
+System.out.println(c);
+}
+}
\ No newline at end of file
diff --git a/Iterator1.class b/Iterator1.class
new file mode 100644
index 0000000..6e9ae15
Binary files /dev/null and b/Iterator1.class differ
diff --git a/Iterator1.java b/Iterator1.java
new file mode 100644
index 0000000..190d370
--- /dev/null
+++ b/Iterator1.java
@@ -0,0 +1,26 @@
+import java.util.*;
+class Iterator1
+{
+public static void main(String args[])
+{
+ArrayList<Integer> l=new ArrayList<>();
+for(int i=1;i<=7;i++)
+{
+l.add(i);
+}
+
+System.out.println(l);
+Iterator it=l.iterator();
+while(it.hasNext())
+{
+int x=(Integer)it.next();
+
+if(x%2==0)
+{
+it.remove();
+}
+}
+
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/Iterator2.class b/Iterator2.class
new file mode 100644
index 0000000..1fc9702
Binary files /dev/null and b/Iterator2.class differ
diff --git a/Iterator2.java b/Iterator2.java
new file mode 100644
index 0000000..b95811a
--- /dev/null
+++ b/Iterator2.java
@@ -0,0 +1,25 @@
+import java.util.*;
+class Iterator2
+{
+public static void main(String args[])
+{
+ArrayList<Integer> l=new ArrayList<>();
+l.add(10);
+l.add(20);
+l.add(30);
+l.add(40);
+System.out.println(l);
+Iterator i=l.iterator();
+while(i.hasNext())
+{
+System.out.print(i.next()+" ");
+}
+System.out.println();
+
+ListIterator li=l.listIterator();
+while(li.hasPrevious())
+{
+System.out.println(li.previous());
+}
+}
+}
\ No newline at end of file
diff --git a/KthElement1$Node.class b/KthElement1$Node.class
new file mode 100644
index 0000000..95230ec
Binary files /dev/null and b/KthElement1$Node.class differ
diff --git a/KthElement1.class b/KthElement1.class
new file mode 100644
index 0000000..5773041
Binary files /dev/null and b/KthElement1.class differ
diff --git a/KthElement1.java b/KthElement1.java
new file mode 100644
index 0000000..8a10aa5
--- /dev/null
+++ b/KthElement1.java
@@ -0,0 +1,73 @@
+class KthElement1
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+int findKth(int k)
+{
+Node slow=head;
+Node fast=head;
+for(int i=0;i<k;i++)
+{
+fast=fast.next;
+}
+
+while(fast!=null)
+{
+slow=slow.next;
+fast=fast.next;
+}
+return slow.data;
+}
+
+public static void main(String args[])
+{
+KthElement1 k=new KthElement1();
+k.append(10);
+k.append(20);
+k.append(30);
+k.append(40);
+k.print();
+int l=2;
+int x=k.findKth(l);
+System.out.println(x);
+}
+
+}
diff --git a/KthElementFirst$Node.class b/KthElementFirst$Node.class
new file mode 100644
index 0000000..3512bd5
Binary files /dev/null and b/KthElementFirst$Node.class differ
diff --git a/KthElementFirst.class b/KthElementFirst.class
new file mode 100644
index 0000000..f67bb24
Binary files /dev/null and b/KthElementFirst.class differ
diff --git a/KthElementFirst.java b/KthElementFirst.java
new file mode 100644
index 0000000..3b98e62
--- /dev/null
+++ b/KthElementFirst.java
@@ -0,0 +1,62 @@
+class KthElementFirst
+{
+Node head;
+class Node
+{
+Node next;
+int data;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+
+void findKth(int k)
+{
+Node temp=head;
+for(int i=1;i<k;i++)
+{
+temp=temp.next;
+}
+System.out.println(temp.data);
+}
+
+public static void main(String args[])
+{
+KthElementFirst k=new KthElementFirst();
+k.append(10);
+k.append(20);
+k.append(30);
+k.print();
+k.findKth(3);
+}
+}
\ No newline at end of file
diff --git a/LIstSwap1.java b/LIstSwap1.java
new file mode 100644
index 0000000..fa48a6c
--- /dev/null
+++ b/LIstSwap1.java
@@ -0,0 +1,21 @@
+import java.util.*;
+class ListSwap1
+{
+public static void main(String args[])
+{
+ArrayList<String> l=new ArrayList<>();
+l.add("sujit");
+l.add("kumar");
+l.add("kushal");
+l.add("gaurav");
+System.out.println(l);
+Collections.swap(l,1,3);
+System.out.println(l);
+Collections.swap(l,0,2);
+System.out.println(l);
+
+Collections.swap(l,0,3);
+
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/Library.class b/Library.class
new file mode 100644
index 0000000..5259756
Binary files /dev/null and b/Library.class differ
diff --git a/LinkData$Node.class b/LinkData$Node.class
new file mode 100644
index 0000000..3f9d02c
Binary files /dev/null and b/LinkData$Node.class differ
diff --git a/LinkData.class b/LinkData.class
new file mode 100644
index 0000000..2ebf5f3
Binary files /dev/null and b/LinkData.class differ
diff --git a/LinkData.java b/LinkData.java
new file mode 100644
index 0000000..92fb22e
--- /dev/null
+++ b/LinkData.java
@@ -0,0 +1,53 @@
+class LinkData
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+public static void main(String args[])
+{
+LinkData l=new LinkData();
+l.append(10);
+l.append(20);
+l.append(30);
+l.append(40);
+
+l.print();
+}
+}
\ No newline at end of file
diff --git a/LinkedArray.class b/LinkedArray.class
new file mode 100644
index 0000000..4b115fc
Binary files /dev/null and b/LinkedArray.class differ
diff --git a/LinkedArray.java b/LinkedArray.java
new file mode 100644
index 0000000..c59e3b9
--- /dev/null
+++ b/LinkedArray.java
@@ -0,0 +1,10 @@
+import java.util.*;
+class LinkedArray
+{
+public static void main(String args[])
+{
+String s[]={"gaurav","ankit","sujit","kumar","gaurav"};
+LinkedHashSet<String> s1=new LinkedHashSet<>(Arrays.asList(s));
+System.out.println("Linked Hash Set is:"+s1);
+}
+}
\ No newline at end of file
diff --git a/LinkedHash.class b/LinkedHash.class
new file mode 100644
index 0000000..3d3587d
Binary files /dev/null and b/LinkedHash.class differ
diff --git a/LinkedHash.java b/LinkedHash.java
new file mode 100644
index 0000000..10bdc6b
--- /dev/null
+++ b/LinkedHash.java
@@ -0,0 +1,13 @@
+import java.util.*;
+class LinkedHash
+{
+public static void main(String args[])
+{
+Map<Integer,String> map=new LinkedHashMap<>();
+map.put(1,"gaurav");
+map.put(2,"sujit");
+map.put(3,"kumar");
+map.put(4,"kushal");
+System.out.println("Map is:"+map);
+}
+}
\ No newline at end of file
diff --git a/LinkedList$Node.class b/LinkedList$Node.class
new file mode 100644
index 0000000..422a8f9
Binary files /dev/null and b/LinkedList$Node.class differ
diff --git a/LinkedList.class b/LinkedList.class
new file mode 100644
index 0000000..4a64f5e
Binary files /dev/null and b/LinkedList.class differ
diff --git a/LinkedList.java b/LinkedList.java
new file mode 100644
index 0000000..02e4735
--- /dev/null
+++ b/LinkedList.java
@@ -0,0 +1,35 @@
+class LinkedList
+{
+Node head;
+
+static class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+static void printList()
+{
+Node n=head;
+while(n!=null)
+{
+System.out.println(n.data);
+n=n.next;
+}
+}
+public static void main(String args[])
+{
+LinkedList l=new LinkedList();
+l.head=new Node(20);
+Node second=new Node(30);
+Node third=new Node(40);
+
+l.head.next=second;
+second.next=third;
+l.printList();
+}
+}
diff --git a/LinkedList1$Node.class b/LinkedList1$Node.class
new file mode 100644
index 0000000..4589322
Binary files /dev/null and b/LinkedList1$Node.class differ
diff --git a/LinkedList1.class b/LinkedList1.class
new file mode 100644
index 0000000..ac8600e
Binary files /dev/null and b/LinkedList1.class differ
diff --git a/LinkedList1.java b/LinkedList1.java
new file mode 100644
index 0000000..d87f522
--- /dev/null
+++ b/LinkedList1.java
@@ -0,0 +1,36 @@
+class LinkedList1
+{
+static Node head;
+static class Node
+{
+int data;
+Node next=null;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+static void printList()
+{
+Node n=head;
+while(n!=null)
+{
+System.out.println(n.data);
+n=n.next;
+}
+}
+public static void main(String args[])
+{
+LinkedList1 l=new LinkedList1();
+l.head=new Node(30);
+Node x=new Node(40);
+Node y=new Node(90);
+Node z=new Node(100);
+l.head.next=x;;
+x.next=y;
+y.next=z;
+l.printList();
+
+}
+}
\ No newline at end of file
diff --git a/LinkedRever$Node.class b/LinkedRever$Node.class
new file mode 100644
index 0000000..ae9a020
Binary files /dev/null and b/LinkedRever$Node.class differ
diff --git a/LinkedRever.class b/LinkedRever.class
new file mode 100644
index 0000000..e09dd3d
Binary files /dev/null and b/LinkedRever.class differ
diff --git a/LinkedRever.java b/LinkedRever.java
new file mode 100644
index 0000000..55706ce
--- /dev/null
+++ b/LinkedRever.java
@@ -0,0 +1,76 @@
+class LinkedRever
+{
+Node head;
+class Node
+{
+Node next;
+int data;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+
+void reverse()
+{
+Node temp=head;
+Node prev=null;
+Node next=null;
+while(temp!=null)
+{
+next=temp.next;
+temp.next=prev;
+prev=temp;
+temp=next;
+}
+
+temp=prev;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+public static void main(String args[])
+{
+LinkedRever l=new LinkedRever();
+l.append(10);
+l.append(20);
+l.append(30);
+l.append(40);
+l.print();
+l.reverse();
+}
+}
\ No newline at end of file
diff --git a/LinkedReverse$Node.class b/LinkedReverse$Node.class
new file mode 100644
index 0000000..75556b1
Binary files /dev/null and b/LinkedReverse$Node.class differ
diff --git a/LinkedReverse.class b/LinkedReverse.class
new file mode 100644
index 0000000..fbabaa9
Binary files /dev/null and b/LinkedReverse.class differ
diff --git a/LinkedReverse.java b/LinkedReverse.java
new file mode 100644
index 0000000..aaf243c
--- /dev/null
+++ b/LinkedReverse.java
@@ -0,0 +1,73 @@
+class LinkedReverse
+{
+static Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.println(temp.data);
+temp=temp.next;
+}
+}
+
+void reverse(Node head)
+{
+if(head==null)
+{
+return ;
+}
+Node temp=head;
+Node prev=null;
+Node next=null;
+while(temp!=null)
+{
+next=temp.next;
+temp.next=prev;
+prev=temp;
+temp=next;
+}
+head=prev;
+while(head!=null)
+{
+System.out.println("In Reverse Order:"+head.data);
+head=head.next;
+}
+}
+
+public static void main(String args[])
+{
+LinkedReverse l=new LinkedReverse();
+l.append(10);
+l.append(30);
+l.append(40);
+l.print();
+l.reverse(head);
+}
+}
\ No newline at end of file
diff --git a/ListInter.class b/ListInter.class
new file mode 100644
index 0000000..ae7a50f
Binary files /dev/null and b/ListInter.class differ
diff --git a/ListInter.java b/ListInter.java
new file mode 100644
index 0000000..9e36df3
--- /dev/null
+++ b/ListInter.java
@@ -0,0 +1,31 @@
+import java.util.*;
+class ListInter
+{
+public static void main(String args[])
+{
+List<Integer> l=new ArrayList<>();
+l.add(1);
+l.add(20);
+l.add(30);
+l.add(40);
+System.out.println(l);
+
+List<Integer> l1=new ArrayList<>();
+l1.add(0,40);
+l1.add(1,50);
+l1.add(2,60);
+System.out.println(l1);
+l.addAll(0,l1);
+System.out.println(l);
+l.set(0,90);
+System.out.println(l);
+l.set(2,100);
+System.out.println(l);
+l.remove(2);
+System.out.println(l);
+l.remove(3);
+System.out.println(l);
+l.remove(2);
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/ListIterate3.class b/ListIterate3.class
new file mode 100644
index 0000000..58002d3
Binary files /dev/null and b/ListIterate3.class differ
diff --git a/ListIterator1.class b/ListIterator1.class
new file mode 100644
index 0000000..3e4d7a1
Binary files /dev/null and b/ListIterator1.class differ
diff --git a/ListIterator1.java b/ListIterator1.java
new file mode 100644
index 0000000..24829fd
--- /dev/null
+++ b/ListIterator1.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class ListIterator1
+{
+public static void main(String args[])
+{
+ArrayList<Integer> l=new ArrayList<>();
+for(int i=1;i<=6;i++)
+{
+l.add(i);
+}
+ListIterator li=l.listIterator();
+while(li.hasNext())
+{
+int y=(Integer)li.next();
+System.out.println(y);
+System.out.println("Index="+li.nextIndex());
+}
+}
+}
\ No newline at end of file
diff --git a/ListIterator2.class b/ListIterator2.class
new file mode 100644
index 0000000..c28a94c
Binary files /dev/null and b/ListIterator2.class differ
diff --git a/ListIterator2.java b/ListIterator2.java
new file mode 100644
index 0000000..0e2e609
--- /dev/null
+++ b/ListIterator2.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class ListIterator2
+{
+public static void main(String args[])
+{
+ArrayList<String> l=new ArrayList<>();
+l.add("kumar");
+l.add("sujit");
+l.add("kushal");
+l.add("vikash");
+System.out.println(l);
+
+ListIterator li=l.listIterator();
+while(li.hasNext())
+{
+String s=(String)li.next();
+System.out.println(s);
+}
+}
+}
\ No newline at end of file
diff --git a/ListIterator3.class b/ListIterator3.class
new file mode 100644
index 0000000..1479435
Binary files /dev/null and b/ListIterator3.class differ
diff --git a/ListIterator3.java b/ListIterator3.java
new file mode 100644
index 0000000..a999b79
--- /dev/null
+++ b/ListIterator3.java
@@ -0,0 +1,26 @@
+import java.util.*;
+class ListIterator3
+{
+public static void main(String args[])
+{
+ArrayList<Integer> l=new ArrayList<>();
+for(int i=1;i<=5;i++)
+{
+l.add(i);
+}
+System.out.println(l);
+ListIterator li=l.listIterator();
+while(li.hasNext())
+{
+int k=(Integer)li.next();
+
+while(k%2==0)
+{
+k++;
+li.set(k);
+li.add(k);
+}
+}
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/ListItr.class b/ListItr.class
new file mode 100644
index 0000000..f0d7911
Binary files /dev/null and b/ListItr.class differ
diff --git a/ListItr.java b/ListItr.java
new file mode 100644
index 0000000..2c4ca69
--- /dev/null
+++ b/ListItr.java
@@ -0,0 +1,22 @@
+import java.util.*;
+class ListItr
+{
+public static void main(String args[])
+{
+ArrayList<Integer> l=new ArrayList<>();
+for(int i=1;i<=6;i++)
+{
+l.add(i);
+}
+
+System.out.println(l);
+
+Iterator i=l.iterator();
+while(i.hasNext())
+{
+int x=(Integer)i.next();
+System.out.println(x);
+}
+
+}
+}
\ No newline at end of file
diff --git a/ListLink.java b/ListLink.java
new file mode 100644
index 0000000..ca14557
--- /dev/null
+++ b/ListLink.java
@@ -0,0 +1,12 @@
+import java.util.*;
+class ListLink
+{
+public static void main(String args[])
+{
+List<Integer> l=new LinkedList<Integer>();
+l.add(10);
+l.add(20);
+l.add(30);
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/ListStack.java b/ListStack.java
new file mode 100644
index 0000000..e87330c
--- /dev/null
+++ b/ListStack.java
@@ -0,0 +1,12 @@
+import java.util.*;
+class ListStck
+{
+public static void main(String args[])
+{
+List<Integer> l=new Stack();
+l.add(10);
+l.add(20);
+l.add(30);
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/ListStr.class b/ListStr.class
new file mode 100644
index 0000000..0f67c82
Binary files /dev/null and b/ListStr.class differ
diff --git a/ListStr.java b/ListStr.java
new file mode 100644
index 0000000..0c252d6
--- /dev/null
+++ b/ListStr.java
@@ -0,0 +1,23 @@
+import java.util.*;
+class ListStr
+{
+public static void main(String args[])
+{
+List<String> l=new ArrayList<>();
+l.add("kushaml");
+l.add("kumar");
+l.add("sujit");
+l.add("gaurav");
+
+Iterator i=l.iterator();
+while(i.hasNext())
+{
+System.out.println(i.next());
+}
+
+for(String s:l)
+{
+System.out.print(s+" ");
+}
+}
+}
\ No newline at end of file
diff --git a/ListSwap1.class b/ListSwap1.class
new file mode 100644
index 0000000..784a779
Binary files /dev/null and b/ListSwap1.class differ
diff --git a/ListToArray.class b/ListToArray.class
new file mode 100644
index 0000000..b98dae9
Binary files /dev/null and b/ListToArray.class differ
diff --git a/ListToArray.java b/ListToArray.java
new file mode 100644
index 0000000..01f05ea
--- /dev/null
+++ b/ListToArray.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class ListToArray
+{
+static String[] convertArray(ArrayList<String> l)
+{
+String s[]=l.toArray(new String[0]);
+return s;
+}
+public static void main(String args[])
+{
+ArrayList<String> l=new ArrayList<>();
+l.add("hello");
+l.add("gaurav");
+l.add("kumar");
+l.add("sujit");
+String h[]=convertArray(l);
+System.out.println(Arrays.toString(h));
+}
+}
\ No newline at end of file
diff --git a/ListVec.class b/ListVec.class
new file mode 100644
index 0000000..5d28654
Binary files /dev/null and b/ListVec.class differ
diff --git a/ListVec.java b/ListVec.java
new file mode 100644
index 0000000..8c254d8
--- /dev/null
+++ b/ListVec.java
@@ -0,0 +1,15 @@
+import java.util.*;
+class ListVec
+{
+public static void main(String args[])
+{
+int n=3;
+List<Integer> v=new Vector<Integer>(n);
+v.add(10);
+v.add(20);
+v.add(30);
+v.add(40);
+
+System.out.println(v);
+}
+}
\ No newline at end of file
diff --git a/Loading.class b/Loading.class
new file mode 100644
index 0000000..56403e3
Binary files /dev/null and b/Loading.class differ
diff --git a/Loading.java b/Loading.java
new file mode 100644
index 0000000..4c1d955
--- /dev/null
+++ b/Loading.java
@@ -0,0 +1,27 @@
+class Collage
+{
+int sum()
+{
+return 8+9;
+}
+
+int sum(int x,int y)
+{
+return x+y;
+}
+
+double sum(int x,double y)
+{
+return x+y;
+}
+}
+
+class Loading
+{
+public static void main(String args[])
+{
+Collage c=new Collage();
+System.out.println(c.sum());
+System.out.println(c.sum(2,3.4));
+}
+}
\ No newline at end of file
diff --git a/Local12.class b/Local12.class
new file mode 100644
index 0000000..f666e97
Binary files /dev/null and b/Local12.class differ
diff --git a/Local12.java b/Local12.java
new file mode 100644
index 0000000..98bbd11
--- /dev/null
+++ b/Local12.java
@@ -0,0 +1,23 @@
+class Student
+{
+int a=10;
+
+String name="gaurav";
+Student()
+{
+int a=20;
+String name="sujit";
+System.out.println("The local value is:"+a);
+System.out.println("the value is:"+this.a);
+System.out.println("the name is:"+name);
+System.out.println("the name instance is:"+this.name);
+}
+}
+
+class Local12
+{
+public static void main(String args[])
+{
+Student s=new Student();
+}
+}
\ No newline at end of file
diff --git a/LocalDate.java b/LocalDate.java
new file mode 100644
index 0000000..5bcc6a6
--- /dev/null
+++ b/LocalDate.java
@@ -0,0 +1,12 @@
+import java.time.*;
+import java.time.temporal.*;
+class LocalDate
+{
+public static void main(String arg[])
+{
+LocalDate d=LocalDate.of(2020,02,23);
+LocalTime t=LocalTime.of(7,45);
+LocalDateTime dt=LocalDateTime.of(d,t);
+System.out.println("LocalDateTime is:"+dt);
+}
+}
\ No newline at end of file
diff --git a/LocalDate1.java b/LocalDate1.java
new file mode 100644
index 0000000..f1a5392
--- /dev/null
+++ b/LocalDate1.java
@@ -0,0 +1,12 @@
+import java.time.*;
+import java.time.temporal.*;
+class LocalDate1
+{
+public static void main(String arg[])
+{
+LocalDate d=LocalDate.of(2020,2,23);
+LocalTime t=LocalTime.of(7,45);
+LocalDateTime dt=LocalDateTime.of(d,t);
+System.out.println("LocalDateTime is:"+dt);
+}
+}
\ No newline at end of file
diff --git a/MLH.txt b/MLH.txt
new file mode 100644
index 0000000..fcf2e66
--- /dev/null
+++ b/MLH.txt
@@ -0,0 +1 @@
+https://www.tfaforms.com/4844143
\ No newline at end of file
diff --git a/Main.class b/Main.class
new file mode 100644
index 0000000..134a2dc
Binary files /dev/null and b/Main.class differ
diff --git a/Main.java b/Main.java
new file mode 100644
index 0000000..48399f5
--- /dev/null
+++ b/Main.java
@@ -0,0 +1,27 @@
+class human extends Thread
+{
+public void run()
+{
+System.out.println("Hello,"+Thread.currentThread().getName());
+}
+}
+
+class Main
+{
+public static void main(String args[])
+{
+human h=new human();
+h.start();
+try
+{
+h.join(1000);
+System.out.println("Hello whatever  is present");
+}
+catch(Exception e)
+{
+System.out.println("EXception");
+}
+
+
+}
+}
\ No newline at end of file
diff --git a/MainThread.class b/MainThread.class
new file mode 100644
index 0000000..5eebd25
Binary files /dev/null and b/MainThread.class differ
diff --git a/MainThread.java b/MainThread.java
new file mode 100644
index 0000000..be088cd
--- /dev/null
+++ b/MainThread.java
@@ -0,0 +1,26 @@
+class gaurav extends Thread
+{
+public void run()
+{
+try
+{
+System.out.println("Hello "+Thread.currentThread().getId());
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+}
+}
+
+class MainThread
+{
+public static void main(String args[])
+{
+gaurav g=new gaurav();
+for(int i=0;i<3;i++)
+{
+g.run();
+}
+}
+}
\ No newline at end of file
diff --git a/MainThread1.class b/MainThread1.class
new file mode 100644
index 0000000..6cb634f
Binary files /dev/null and b/MainThread1.class differ
diff --git a/MainThread1.java b/MainThread1.java
new file mode 100644
index 0000000..b58c8f6
--- /dev/null
+++ b/MainThread1.java
@@ -0,0 +1,23 @@
+class gaurav implements Runnable
+{
+public void run()
+{
+try
+{
+System.out.println("Good morning "+Thread.currentThread().getId());
+}
+catch(Exception e)
+{
+System.out.println(e);
+}
+}
+}
+
+class MainThread1
+{
+public static void main(String args[])
+{
+gaurav g=new gaurav();
+g.run();
+}
+}
\ No newline at end of file
diff --git a/Map1.class b/Map1.class
new file mode 100644
index 0000000..8ba7d3c
Binary files /dev/null and b/Map1.class differ
diff --git a/Map1.java b/Map1.java
new file mode 100644
index 0000000..fcb17fa
--- /dev/null
+++ b/Map1.java
@@ -0,0 +1,23 @@
+import java.util.*;
+class Map1
+{
+public static void main(String args[])
+{
+Map<String,Integer> map=new HashMap<>();
+map.put("gaurav",153);
+map.put("sujit",123);
+map.put("kushal",153);
+map.put("vikash",78);
+map.put("vikash",270);
+
+System.out.println("Map is:"+map);
+for(Map.Entry<String,Integer> m:map.entrySet())
+{
+System.out.println(m.getKey()+":"+ m.getValue());
+}
+
+map.remove("gaurav");
+map.remove("sujit");
+System.out.println("After deletion map is:"+map);
+}
+}
\ No newline at end of file
diff --git a/Map12.class b/Map12.class
new file mode 100644
index 0000000..51e4a48
Binary files /dev/null and b/Map12.class differ
diff --git a/Map12.java b/Map12.java
new file mode 100644
index 0000000..7f91b6d
--- /dev/null
+++ b/Map12.java
@@ -0,0 +1,25 @@
+import java.util.*;
+class Map12
+{
+public static void main(String args[])
+{
+Map<Integer,String> map=new HashMap<>();
+map.put(1,"gaurav");
+map.put(2,"kushal");
+map.put(3,"kumar");
+map.put(4,"vikash");
+
+System.out.println(map);
+for(Map.Entry<Integer,String> m:map.entrySet())
+{
+System.out.println(m.getKey()+" "+m.getValue());
+}
+Map<Integer,String> m1=new HashMap<>();
+
+for(Map.Entry<Integer,String> m2:map.entrySet())
+{
+m1.put(m2.getKey(),m2.getValue());
+}
+System.out.println(m1);
+}
+}
\ No newline at end of file
diff --git a/Map13.class b/Map13.class
new file mode 100644
index 0000000..0eaeb59
Binary files /dev/null and b/Map13.class differ
diff --git a/Map13.java b/Map13.java
new file mode 100644
index 0000000..6d76d30
--- /dev/null
+++ b/Map13.java
@@ -0,0 +1,22 @@
+import java.util.*;
+class Map13
+{
+public static void main(String args[])
+{
+String s="kumarr";
+char c[]=s.toCharArray();
+Map<Character,Integer> m=new HashMap<>();
+for(int i=0;i<c.length;i++)
+{
+m.put(c[i], m.getOrDefault(c[i],0)+1);
+}
+System.out.println(m);
+for(Character i:m.keySet())
+{
+if(m.get(i)==1)
+{
+System.out.println(i);
+}
+}
+}
+}
\ No newline at end of file
diff --git a/Map14.class b/Map14.class
new file mode 100644
index 0000000..cf8c981
Binary files /dev/null and b/Map14.class differ
diff --git a/Map14.java b/Map14.java
new file mode 100644
index 0000000..7eaf954
--- /dev/null
+++ b/Map14.java
@@ -0,0 +1,25 @@
+import java.util.*;
+class Map14
+{
+public static void main(String args[])
+{
+Map<String,Integer> m=new HashMap<>();
+m.put("gaurav",1);
+m.put("kushal",2);
+m.put("kumar",3);
+m.put("vishal",4);
+System.out.println(m);
+
+for(String s:m.keySet())
+{
+if(m.get(s)==1)
+{
+System.out.println(s);
+}
+}
+for(Map.Entry<String,Integer> m1:m.entrySet())
+{
+System.out.println(m1.getKey()+" "+m1.getValue());
+}
+}
+}
\ No newline at end of file
diff --git a/Map15.class b/Map15.class
new file mode 100644
index 0000000..f257b3e
Binary files /dev/null and b/Map15.class differ
diff --git a/Map15.java b/Map15.java
new file mode 100644
index 0000000..be0170a
--- /dev/null
+++ b/Map15.java
@@ -0,0 +1,26 @@
+import java.util.*;
+class Map15
+{
+public static void main(String args[])
+{
+Map<Integer,String> map=new HashMap<>();
+map.put(1,"gaurav");
+map.put(2,"kushal");
+map.put(3,"vikash");
+map.put(4,"yellow");
+System.out.println(map);
+
+for(Map.Entry<Integer,String> m:map.entrySet())
+{
+System.out.println(m.getKey()+" "+m.getValue());
+}
+
+for(Integer i:map.keySet())
+{
+if(map.get(i)=="gaurav")
+{
+System.out.println(i);
+}
+}
+}
+}
\ No newline at end of file
diff --git a/MapClone.class b/MapClone.class
new file mode 100644
index 0000000..0e29904
Binary files /dev/null and b/MapClone.class differ
diff --git a/MapClone.java b/MapClone.java
new file mode 100644
index 0000000..216e191
--- /dev/null
+++ b/MapClone.java
@@ -0,0 +1,21 @@
+import java.util.*;
+class MapClone
+{
+public static void main(String args[])
+{
+HashMap<Integer,Integer> map=new HashMap<>();
+map.put(1,2);
+map.put(2,3);
+map.put(3,5);
+map.put(4,10);
+
+HashMap<Integer,Integer> map1=new HashMap<>();
+for(Map.Entry<Integer,Integer>m:map.entrySet())
+{
+map1.put(m.getKey(),m.getValue());
+}
+
+System.out.println(map);
+System.out.println(map1);
+}
+}
\ No newline at end of file
diff --git a/MapManner.class b/MapManner.class
new file mode 100644
index 0000000..3065c27
Binary files /dev/null and b/MapManner.class differ
diff --git a/MapManner.java b/MapManner.java
new file mode 100644
index 0000000..9adbaf9
--- /dev/null
+++ b/MapManner.java
@@ -0,0 +1,22 @@
+import java.util.*;
+class MapManner
+{
+public static void main(String args[])
+{
+Map<Integer,String>m=new HashMap<>();
+m.put(1,"gaurav");
+m.put(2,"kumar");
+m.put(3,"kushal");
+m.put(4,"vikash");
+System.out.println(m);
+
+for(Map.Entry<Integer,String> e:m.entrySet())
+{
+System.out.println(e.getKey()+" "+e.getValue());
+}
+for(Integer i:m.keySet())
+{
+System.out.println(i);
+}
+}
+}
\ No newline at end of file
diff --git a/MaximumSum.class b/MaximumSum.class
new file mode 100644
index 0000000..643e3ac
Binary files /dev/null and b/MaximumSum.class differ
diff --git a/MaximumSum.java b/MaximumSum.java
new file mode 100644
index 0000000..26959ea
--- /dev/null
+++ b/MaximumSum.java
@@ -0,0 +1,64 @@
+import java.util.*;
+class MaximumSum
+{
+static void subArray(int a[])
+{
+int max=Integer.MIN_VALUE;
+int sum=0;
+for(int i=0;i<a.length;i++)
+{
+sum+=a[i];
+if(sum>max)
+{
+max=sum;
+}
+
+if(sum<0)
+sum=0;
+}
+
+int curSum=0;
+int left=0;
+int right=0;
+int i=0;
+int j=0;
+List<Integer> l=new ArrayList<>();
+while(left<a.length && right<a.length)
+{
+curSum+=a[right];
+if(curSum<0)
+{
+curSum=0;
+left++;
+right++;
+}
+
+else if(curSum==max)
+{
+i=left;
+j=right;
+break;
+}
+
+else if(curSum<max)
+{
+right+=1;
+
+}
+else
+left+=1;
+}
+
+for(int k=i;k<=j;k++)
+{
+l.add(a[k]);
+}
+System.out.println(l);
+
+}
+public static void main(String args[])
+{
+int a[]={-2,-3,4,-1,-2,1,5,-3};
+subArray(a);
+}
+}
\ No newline at end of file
diff --git a/Merge5.class b/Merge5.class
new file mode 100644
index 0000000..9dad7c8
Binary files /dev/null and b/Merge5.class differ
diff --git a/Merge5.java b/Merge5.java
new file mode 100644
index 0000000..2b85c0d
--- /dev/null
+++ b/Merge5.java
@@ -0,0 +1,67 @@
+class Merge5
+{
+int array[];
+int length;
+int temp[];
+public static void main(String args[])
+{
+int a[]={4,5,2,1,9};
+Merge5 m=new Merge5();
+m.ArraySort(a);
+
+for(int i=0;i<a.length;i++)
+{
+System.out.print(a[i]+" ");
+}
+}
+
+void ArraySort(int a[])
+{
+this.array=a;	
+this.length=a.length;
+this.temp=new int[length];
+divide(0,length-1);
+}
+
+void divide(int lower,int higher)
+{
+if(lower<higher)
+{
+int middle=lower+(higher-lower)/2;
+divide(lower,middle);
+divide(middle+1,higher);
+merge(lower,middle,higher);
+}
+}
+
+void merge(int lower,int middle,int higher)
+{
+for(int i=lower;i<=higher;i++)
+{
+temp[i]=array[i];
+}
+int i=lower;
+int j=middle+1;
+int k=lower;
+while(i<=middle && j<=higher)
+{
+if(temp[i]<=temp[j])
+{
+array[k]=temp[i];
+i++;
+}
+else
+{
+array[k]=temp[j];
+j++;
+}
+k++;
+}
+while(i<=middle)
+{
+array[k]=temp[i];
+i++;
+k++;
+}
+}
+}
diff --git a/MergeLink$Node.class b/MergeLink$Node.class
new file mode 100644
index 0000000..5073733
Binary files /dev/null and b/MergeLink$Node.class differ
diff --git a/MergeLink.class b/MergeLink.class
new file mode 100644
index 0000000..cd2987c
Binary files /dev/null and b/MergeLink.class differ
diff --git a/MergeLink.java b/MergeLink.java
new file mode 100644
index 0000000..c234427
--- /dev/null
+++ b/MergeLink.java
@@ -0,0 +1,104 @@
+class MergeLink
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+
+void merge(Node head1,Node head2)
+{
+Node temp1=head1;
+Node temp2=head2;
+Node head3=null;
+if(temp1.data<temp2.data)
+{
+head3=temp1;
+temp1=temp1.next;
+}
+else
+{
+head3=temp2;
+temp2=temp2.next;
+}
+
+Node temp3=head3;
+
+while(temp1!=null && temp2!=null)
+{
+if(temp1.data<temp2.data)
+{
+temp3.next=temp1;
+temp1=temp1.next;
+}
+else
+{
+temp3.next=temp2;
+temp2=temp2.next;
+}
+temp3=temp3.next;
+}
+temp3=head3;
+while(temp3!=null)
+{
+System.out.print(temp3.data+"->");
+temp3=temp3.next;
+}
+System.out.println("null");
+}
+
+
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+public static void main(String args[])
+{
+MergeLink m1=new MergeLink();
+m1.append(10);
+m1.append(20);
+m1.append(30);
+
+MergeLink m2=new MergeLink();
+m2.append(12);
+m2.append(24);
+m2.append(23);
+//m2.print();
+
+MergeLink m3=new MergeLink();
+m3.merge(m1.head,m2.head);
+
+}
+}
\ No newline at end of file
diff --git a/MergeLinked$Node.class b/MergeLinked$Node.class
new file mode 100644
index 0000000..6dd6366
Binary files /dev/null and b/MergeLinked$Node.class differ
diff --git a/MergeLinked.class b/MergeLinked.class
new file mode 100644
index 0000000..5c76783
Binary files /dev/null and b/MergeLinked.class differ
diff --git a/MergeLinked.java b/MergeLinked.java
new file mode 100644
index 0000000..1230163
--- /dev/null
+++ b/MergeLinked.java
@@ -0,0 +1,108 @@
+class MergeLinked
+{
+Node head;
+class Node
+{
+Node next;
+int data;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void mergeNode(Node head1,Node head2)
+{
+Node head3=null;
+Node fast=head1;
+Node slow=head2;
+
+if(fast.data<slow.data)
+{
+head3=fast;
+fast=fast.next;
+}
+else
+{
+head3=slow;
+slow=slow.next;
+}
+Node temp=head3;
+while(fast!=null && slow!=null)
+{
+if(fast.data<slow.data)
+{
+temp.next=fast;
+fast=fast.next;
+}
+else
+{
+temp.next=slow;
+slow=slow.next;
+}
+temp=temp.next;
+}
+if(fast!=null)
+{
+temp.next=fast;
+}
+if(slow!=null)
+{
+temp.next=slow;
+}
+temp=head3;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+public static void main(String args[])
+{
+MergeLinked l1=new MergeLinked();
+l1.append(4);
+l1.append(5);
+l1.append(7);
+l1.append(9);
+l1.print();
+
+MergeLinked l2=new MergeLinked();
+l2.append(1);
+l2.append(2);
+l2.append(3);
+l2.append(6);
+l2.print();
+
+MergeLinked l3=new MergeLinked();
+l3.mergeNode(l1.head,l2.head);
+}
+}
\ No newline at end of file
diff --git a/MergeSort1.class b/MergeSort1.class
new file mode 100644
index 0000000..fc846ea
Binary files /dev/null and b/MergeSort1.class differ
diff --git a/MergeSort1.java b/MergeSort1.java
new file mode 100644
index 0000000..de672de
--- /dev/null
+++ b/MergeSort1.java
@@ -0,0 +1,47 @@
+import java.util.*;
+class MergeSort1
+{
+static void merge(int a[],int b[])
+{
+int c[]=new int[a.length+b.length];
+int i=0;
+int j=0;
+int k=0;
+while(i<a.length && j<b.length)
+{
+if(a[i]<b[j])
+{
+c[k]=a[i];
+k++;
+i++;
+}
+else
+{
+c[k]=b[j];
+k++;
+j++;
+}
+}
+while(i<a.length)
+{
+c[k]=a[i];
+i++;
+k++;
+}
+
+while(j<b.length)
+{
+c[k]=b[j];
+k++;
+j++;
+}
+
+System.out.println(Arrays.toString(c));
+}
+public static void main(String args[])
+{
+int a[]={2,4,5,6,7};
+int b[]={1,3,8,9};
+merge(a,b);
+}
+}
\ No newline at end of file
diff --git a/MergeSort2.class b/MergeSort2.class
new file mode 100644
index 0000000..eb721f1
Binary files /dev/null and b/MergeSort2.class differ
diff --git a/MergeSort2.java b/MergeSort2.java
new file mode 100644
index 0000000..b62d5df
--- /dev/null
+++ b/MergeSort2.java
@@ -0,0 +1,66 @@
+import java.util.*;
+class MergeSort2
+{
+static void mergeSort(int a[],int l,int h)
+{
+if(l<h)
+{
+int mid=(l+h)/2;
+mergeSort(a,l,mid);
+mergeSort(a,mid+1,h);
+merge(a,l,mid,h);
+}
+}
+
+static void merge(int a[],int l,int mid,int h)
+{
+int i=l;
+int j=mid+1;
+int k=l;
+int b[]=new int[a.length];
+while(i<=mid && j<=h)
+{
+if(a[j]<a[i])
+{
+b[k]=a[j];
+j++;
+}
+else
+{
+b[k]=a[i];
+i++;
+}
+k++;
+}
+
+if(i>mid)
+{
+while(j<=h)
+{
+b[k]=a[j];
+k++;
+j++;
+}
+}
+else{
+while(i<=mid)
+{
+b[k]=a[i];
+k++;
+i++;
+}
+}
+
+for(int t=l;t<=h;t++)
+{
+a[t]=b[t];
+}
+}
+public static void main(String args[])
+{
+int a[]={6,5,4,3,2,1};
+int n=a.length;
+mergeSort(a,0,n-1);
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/MergeTwoLink$Node.class b/MergeTwoLink$Node.class
new file mode 100644
index 0000000..194fd3a
Binary files /dev/null and b/MergeTwoLink$Node.class differ
diff --git a/MergeTwoLink.class b/MergeTwoLink.class
new file mode 100644
index 0000000..37d8d54
Binary files /dev/null and b/MergeTwoLink.class differ
diff --git a/MergeTwoLink.java b/MergeTwoLink.java
new file mode 100644
index 0000000..5301f12
--- /dev/null
+++ b/MergeTwoLink.java
@@ -0,0 +1,112 @@
+class MergeTwoLink
+{
+Node head;
+class Node
+{
+Node next;
+int data;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+
+void merge(Node head1,Node head2)
+{
+Node slow=head1;
+Node fast=head2;
+Node temp=null;
+if(slow.data<fast.data)
+{
+temp=slow;
+slow=slow.next;
+}
+else
+{
+temp=fast;
+fast=fast.next;
+}
+
+Node prev=temp;
+while(slow!=null && fast!=null)
+{
+if(slow.data<fast.data)
+{
+prev.next=slow;
+prev=prev.next;
+slow=slow.next;
+}
+else
+{
+prev.next=fast;
+prev=prev.next;
+fast=fast.next;
+}
+}
+
+if(slow!=null)
+{
+prev.next=slow;
+}
+if(fast!=null)
+{
+prev.next=fast;
+}
+Node head3=temp;
+while(head3!=null)
+{
+System.out.print(head3.data+"->");
+head3=head3.next;
+}
+System.out.println("null");
+}
+public static void main(String args[])
+{
+MergeTwoLink l=new MergeTwoLink();
+l.append(1);
+l.append(3);
+l.append(5);
+l.append(6);
+
+l.print();
+MergeTwoLink l1=new MergeTwoLink();
+l1.append(2);
+l1.append(4);
+l1.append(7);
+l1.append(8);
+l1.print();
+
+MergeTwoLink l2=new MergeTwoLink();
+l1.merge(l.head,l1.head);
+}
+}
\ No newline at end of file
diff --git a/MiddleElement1$Node.class b/MiddleElement1$Node.class
new file mode 100644
index 0000000..497e093
Binary files /dev/null and b/MiddleElement1$Node.class differ
diff --git a/MiddleElement1.class b/MiddleElement1.class
new file mode 100644
index 0000000..33aa98d
Binary files /dev/null and b/MiddleElement1.class differ
diff --git a/MiddleElement1.java b/MiddleElement1.java
new file mode 100644
index 0000000..1deff79
--- /dev/null
+++ b/MiddleElement1.java
@@ -0,0 +1,65 @@
+class MiddleElement1
+{
+Node head;
+class Node
+{
+Node next;
+int data;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void middle()
+{
+Node low=head;
+Node fast=head;
+while(fast!=null && fast.next!=null)
+{
+low=low.next;
+fast=fast.next.next;
+}
+System.out.println("Middle Element is:"+low.data);
+}
+
+public static void main(String args[])
+{
+MiddleElement1 l=new MiddleElement1();
+l.append(10);
+l.append(20);
+l.append(30);
+l.append(40);
+l.print();
+l.middle();
+}
+}
diff --git a/Missing12.class b/Missing12.class
new file mode 100644
index 0000000..0876ad0
Binary files /dev/null and b/Missing12.class differ
diff --git a/Missing2.java b/Missing2.java
new file mode 100644
index 0000000..9b2c728
--- /dev/null
+++ b/Missing2.java
@@ -0,0 +1,29 @@
+class Missing12
+{
+static int findMissing(int a[])
+{
+int l=0;
+int h=a.length-1;
+while(l<=h)
+{
+int mid=(l+h)/2;
+if(a[mid]!=mid+1 && a[mid-1]==mid)
+{
+return mid+1;
+}
+
+else if(a[mid]!=mid+1)
+h=mid-1;
+
+else
+l=mid+1;
+}
+
+return -1;
+}
+public static void main(String args[])
+{
+int a[]={1,2,4,5,6};
+System.out.println(findMissing(a));
+}
+}
\ No newline at end of file
diff --git a/Missing3.class b/Missing3.class
new file mode 100644
index 0000000..cea13f0
Binary files /dev/null and b/Missing3.class differ
diff --git a/Missing3.java b/Missing3.java
new file mode 100644
index 0000000..c25a270
--- /dev/null
+++ b/Missing3.java
@@ -0,0 +1,20 @@
+class Missing3
+{
+static int findMissing(int a[],int n)
+{
+int sum=0;
+for(int i=0;i<a.length;i++)
+{
+sum+=a[i];
+}
+int res=n*(n+1)/2;
+
+return res-sum;
+}
+public static void main(String args[])
+{
+int a[]={1,3,4,2,6,7,9,8,10};
+int n=10;
+System.out.println(findMissing(a,n));
+}
+}
\ No newline at end of file
diff --git a/MissingElement.class b/MissingElement.class
new file mode 100644
index 0000000..6ddf694
Binary files /dev/null and b/MissingElement.class differ
diff --git a/MissingElement.java b/MissingElement.java
new file mode 100644
index 0000000..b36e5d2
--- /dev/null
+++ b/MissingElement.java
@@ -0,0 +1,28 @@
+class MissingElement
+{
+static int missing(int a[],int n)
+{
+int low=0;
+int high=n-1;
+while(low<=high)
+{
+int mid=(low+high)/2;
+if(a[mid]!=mid+1 && a[mid-1]==mid)
+{
+return mid+1;
+}
+if(a[mid]!=mid+1)
+high=mid-1;
+
+else
+low=mid+1;
+}
+return -1;
+}
+public static void main(String args[])
+{
+int a[]={1,2,3,4,6};
+int n=a.length;
+System.out.println(missing(a,n));
+}
+}
\ No newline at end of file
diff --git a/MissingNum.class b/MissingNum.class
new file mode 100644
index 0000000..d3ebea3
Binary files /dev/null and b/MissingNum.class differ
diff --git a/MissingNum.java b/MissingNum.java
new file mode 100644
index 0000000..6dbf141
--- /dev/null
+++ b/MissingNum.java
@@ -0,0 +1,28 @@
+import java.util.*;
+class MissingNum
+{
+static void findMissing(int a[],int l,int h)
+{
+List<Integer> l1=new ArrayList<>();
+while(l<=h)
+{
+int mid=(l+h)/2;
+if(a[mid]!=mid+1 && a[mid-1]==mid)
+{
+l1.add(mid+1);
+l++;
+}
+else if(a[mid]!=mid+1)
+h=mid-1;
+
+else
+l=mid+1;
+}
+System.out.println(l1);
+}
+public static void main(String args[])
+{
+int a[]={1,2,3,5,7};
+findMissing(a,0,a.length-1);
+}
+}
\ No newline at end of file
diff --git a/MultiThread.class b/MultiThread.class
new file mode 100644
index 0000000..2bbf13c
Binary files /dev/null and b/MultiThread.class differ
diff --git a/MultiThread.java b/MultiThread.java
new file mode 100644
index 0000000..867b166
--- /dev/null
+++ b/MultiThread.java
@@ -0,0 +1,29 @@
+class gaurav extends Thread
+{
+public void run()
+{
+try
+{
+System.out.println("Thread :"+Thread.currentThread().getId()+ " is running");
+}
+catch(Exception e)
+{
+System.out.println(e);
+}
+
+}
+}
+
+class MultiThread
+{
+public static void main(String args[])
+{
+int n=4;
+for(int i=0;i<n;i++)
+{
+gaurav g=new gaurav();
+g.start();
+}
+
+}
+}
\ No newline at end of file
diff --git a/MultipleMissing.class b/MultipleMissing.class
new file mode 100644
index 0000000..068ca8d
Binary files /dev/null and b/MultipleMissing.class differ
diff --git a/MultipleMissing.java b/MultipleMissing.java
new file mode 100644
index 0000000..090a2f8
--- /dev/null
+++ b/MultipleMissing.java
@@ -0,0 +1,33 @@
+//find the missing element in a  unsorted array? and also the elemnt is present twice
+import java.util.*;
+class MultipleMissing
+{
+static List<Integer> missing(int a[],int n)
+{
+List<Integer> l=new ArrayList<>();
+for(int b:a)
+{
+int index=Math.abs(b)-1;
+if(a[index]>0)
+{
+a[index]=-a[index];
+}
+
+}
+for(int i=0;i<n;i++)
+{
+if(a[i]>0)
+{
+l.add(i+1);
+}
+}
+return l;
+}
+public static void main(String args[])
+{
+int a[]={1,2,2,3,5};
+int n=a.length;
+List<Integer> k=missing(a,n);
+System.out.println("Missing elemnt is :"+k);
+}
+}
\ No newline at end of file
diff --git a/MyThread.class b/MyThread.class
new file mode 100644
index 0000000..3a693c9
Binary files /dev/null and b/MyThread.class differ
diff --git a/MyThread.java b/MyThread.java
new file mode 100644
index 0000000..867e30d
--- /dev/null
+++ b/MyThread.java
@@ -0,0 +1,19 @@
+class MyThread extends Thread
+{
+public void run()
+{
+try
+{
+System.out.println("Hello");
+}
+catch(Exception e)
+{
+System.out.println(e);
+}
+}
+public static void main(String args[])
+{
+MyThread t=new MyThread();
+t.start();
+}
+}
diff --git a/Naming.class b/Naming.class
new file mode 100644
index 0000000..4909847
Binary files /dev/null and b/Naming.class differ
diff --git a/Naming.java b/Naming.java
new file mode 100644
index 0000000..aa49df1
--- /dev/null
+++ b/Naming.java
@@ -0,0 +1,23 @@
+class kumar extends Thread
+{
+kumar(String name)
+{
+super(name);
+}
+public void run()
+{
+System.out.println("Hello run! what can i do for you");
+}
+}
+
+class Naming
+{
+public static void main(String args[])
+{
+kumar k=new kumar("gaurav");
+kumar k1=new kumar("sujit");
+System.out.println("New Thread name is :"+k1.getName());
+System.out.println("Thread name is:"+k.getName());
+k.start();
+}
+}
\ No newline at end of file
diff --git a/Naming1.class b/Naming1.class
new file mode 100644
index 0000000..7eb2d93
Binary files /dev/null and b/Naming1.class differ
diff --git a/Naming1.java b/Naming1.java
new file mode 100644
index 0000000..d326e98
--- /dev/null
+++ b/Naming1.java
@@ -0,0 +1,26 @@
+class sujit extends Thread
+{
+public void run()
+{
+System.out.println("Hello sujit! what can i do for u");
+System.out.println(Thread.currentThread().getName());
+}
+}
+
+class Naming1
+{
+public static void main (String args[])
+{
+sujit s=new sujit();
+s.start();
+System.out.println("Thread name is:"+s.getName());
+s.setName("geeks");
+s.setName("gaurav");
+System.out.println("After change, the new Thread is:"+s.getName());
+sujit s1=new sujit();
+s1.setName("kushal");
+System.out.println("My new Thread name is:"+s1.getName());
+System.out.println(Thread.currentThread().getName());
+System.out.println(Thread.currentThread().getId());
+}
+}
\ No newline at end of file
diff --git a/NamingThread.class b/NamingThread.class
new file mode 100644
index 0000000..f3ed9ee
Binary files /dev/null and b/NamingThread.class differ
diff --git a/NamingThread.java b/NamingThread.java
new file mode 100644
index 0000000..006b1da
--- /dev/null
+++ b/NamingThread.java
@@ -0,0 +1,26 @@
+class kushal extends Thread
+{
+kushal(String name)
+{
+super(name);
+}
+
+public void run()
+{
+System.out.println("I run very Fast");
+}
+}
+
+class NamingThread 
+{
+public static void main(String args[])
+{
+kushal k=new kushal("gaurav");
+kushal k1=new kushal("kushal");
+kushal k2=new kushal("sujit");
+System.out.println("Thread name is:"+k.getName());
+System.out.println("New Name is:"+k1.getName());
+System.out.println("Hello kumar:"+k2.getName());
+k.start();
+}
+}
\ No newline at end of file
diff --git a/NestedTwo.class b/NestedTwo.class
new file mode 100644
index 0000000..b2217d5
Binary files /dev/null and b/NestedTwo.class differ
diff --git a/NestedTwo.java b/NestedTwo.java
new file mode 100644
index 0000000..7ab66e8
--- /dev/null
+++ b/NestedTwo.java
@@ -0,0 +1,32 @@
+class outer
+{
+static String s="gaurav";
+
+static class nested
+{
+public void run()
+{
+System.out.println(s+" is run very fast");
+}
+}
+
+class inner
+{
+public void dance()
+{
+System.out.println(s+" is doing dance very well");
+}
+}
+}
+
+class NestedTwo
+{
+public static void main(String args[])
+{
+outer.nested s=new outer.nested();
+s.run();
+
+outer.inner s1=new outer().new inner();
+s1.dance();
+}
+}
\ No newline at end of file
diff --git a/NextGreater.class b/NextGreater.class
new file mode 100644
index 0000000..270233b
Binary files /dev/null and b/NextGreater.class differ
diff --git a/NextGreater.java b/NextGreater.java
new file mode 100644
index 0000000..52440dc
--- /dev/null
+++ b/NextGreater.java
@@ -0,0 +1,37 @@
+import java.util.*;
+class NextGreater
+{
+static int[] greater(int a[],int b[])
+{
+int j=0;
+int i=0;
+for(i=0;i<a.length;i++)
+{
+int x=a[i];
+for(j=0;j<b.length-1;j++)
+{
+if(x==b[j] && b[j+1]>x)
+{
+a[i]=b[j+1];
+break;
+}
+else{
+a[i]=-1;
+break;
+}
+}
+if(b[j]>x)
+{
+a[i]=b[j];
+}
+}
+return a;
+}
+public static void main(String args[])
+{
+int a[]={4,1,2};
+int b[]={1,3,4,2};
+int c[]=greater(a,b);
+System.out.println(Arrays.toString(c));
+}
+}
\ No newline at end of file
diff --git a/NextGreater1.class b/NextGreater1.class
new file mode 100644
index 0000000..658a39a
Binary files /dev/null and b/NextGreater1.class differ
diff --git a/NextGreater1.java b/NextGreater1.java
new file mode 100644
index 0000000..6075a20
--- /dev/null
+++ b/NextGreater1.java
@@ -0,0 +1,44 @@
+import java.util.*;
+class NextGreater1
+{
+static void next(int a[])
+{
+int max=0;
+int n=a.length;
+int b[]=new int[n];
+for(int k=0;k<a.length;k++)
+{
+max=Math.max(max,a[k]);
+}
+int i=0;
+int j=1;
+while(i<=j)
+        {
+            if(a[i]==max)
+            {
+                b[i]=-1;
+            }
+          else if(a[i]<a[i+1])
+            {
+             b[i]=a[i+1];
+             i++;
+              j++;
+            }
+            else if(a[i]<a[j])
+            {
+		b[i]=a[j];
+                i++;
+                j++;
+            }
+            else
+                j++;
+        }
+
+System.out.println(Arrays.toString(b));
+}
+public static void main(String args[])
+{
+int a[]={1,2,1};
+next(a);
+}
+}
\ No newline at end of file
diff --git a/NextGreater2.class b/NextGreater2.class
new file mode 100644
index 0000000..1f06371
Binary files /dev/null and b/NextGreater2.class differ
diff --git a/NextGreater2.java b/NextGreater2.java
new file mode 100644
index 0000000..60b1cad
--- /dev/null
+++ b/NextGreater2.java
@@ -0,0 +1,54 @@
+import java.util.*;
+class NextGreater2
+{
+static int next(int n)
+{
+char c[]=(""+n).toCharArray();
+int i=c.length-2;
+while(i>=0 && c[i]>=c[i+1])
+i--;
+
+if(i==-1)
+return -1;
+
+int j=c.length-1;
+while(j>i && c[j]<=c[i])
+{
+j--;
+}
+
+swap(c,i,j);
+reverse(c,i+1);
+
+try
+{
+return Integer.parseInt(new String(c));
+}catch(Exception e)
+{
+return -1;
+}
+}
+
+static void swap(char c[],int i,int j)
+{
+char temp=c[i];
+c[i]=c[j];
+c[j]=temp;
+}
+
+static void reverse(char c[],int l)
+{
+int r=c.length-1;
+while(l<r)
+{
+swap(c,l,r);
+l++;
+r--;
+}
+}
+public static void main(String args[])
+{
+int n=123;
+System.out.println(next(n));
+}
+}
\ No newline at end of file
diff --git a/NoRepeating.class b/NoRepeating.class
new file mode 100644
index 0000000..c7c2650
Binary files /dev/null and b/NoRepeating.class differ
diff --git a/NoRepeating.java b/NoRepeating.java
new file mode 100644
index 0000000..a7086f8
--- /dev/null
+++ b/NoRepeating.java
@@ -0,0 +1,24 @@
+import java.util.*;
+class NoRepeating
+{
+public static void main(String args[])
+{
+int a[]={19,2,1,10,11,13,14,2};
+Map<Integer,Integer> map=new LinkedHashMap<>();
+for(int i=0;i<a.length;i++)
+{
+map.put(a[i],map.getOrDefault(a[i],0)+1);
+}
+System.out.println(map);
+
+for(int s:map.keySet())
+{
+if(map.get(s)==1)
+{
+System.out.print(s);
+break;
+}
+}
+
+}
+}
diff --git a/NotRepeated.class b/NotRepeated.class
new file mode 100644
index 0000000..4d66aac
Binary files /dev/null and b/NotRepeated.class differ
diff --git a/NotRepeated.java b/NotRepeated.java
new file mode 100644
index 0000000..1615134
--- /dev/null
+++ b/NotRepeated.java
@@ -0,0 +1,16 @@
+import java.util.*;
+class NotRepeated
+{
+public static void main(String args[])
+{
+String s="gaurav";
+char c[]=s.toCharArray();
+Map<Character,Integer> map=new HashMap<>();
+for(int i=0;i<c.length;i++)
+{
+map.put(c[i],map.getOrDefault(c[i],0)+1);
+}
+
+System.out.println("Map is:"+map);
+}
+}
diff --git a/NumberOfSegment.class b/NumberOfSegment.class
new file mode 100644
index 0000000..02306e8
Binary files /dev/null and b/NumberOfSegment.class differ
diff --git a/NumberOfSegment.java b/NumberOfSegment.java
new file mode 100644
index 0000000..681992c
--- /dev/null
+++ b/NumberOfSegment.java
@@ -0,0 +1,19 @@
+//count the number of segment in a string;
+import java.util.*;
+class NumberOfSegment
+{
+static int countSegment(String s)
+{
+if(s==null || s.trim().length()==0)
+return 0;
+
+String str[]=s.trim().split("\\s+");
+System.out.println(Arrays.toString(str));
+return str.length;
+}
+public static void main(String args[])
+{
+String s="  hello kumar, how are you";
+System.out.println(countSegment(s));
+}
+}
diff --git a/Object2.class b/Object2.class
new file mode 100644
index 0000000..de0fb55
Binary files /dev/null and b/Object2.class differ
diff --git a/Object2.java b/Object2.java
new file mode 100644
index 0000000..773712c
--- /dev/null
+++ b/Object2.java
@@ -0,0 +1,21 @@
+class Object2
+{
+public static void main(String args[])
+{
+Object o=new String("kumar gaurav"); 
+Class c=o.getClass();
+System.out.println(c.getName());
+
+Object y=new String("123");
+System.out.println(y);
+
+y=123;
+Class c1=y.getClass();
+System.out.println(c1.getName());
+
+y="i love you";
+Class c2=y.getClass();
+System.out.println(c2);
+System.out.println(c2.getName());
+}
+}
\ No newline at end of file
diff --git a/ObjectClass1.class b/ObjectClass1.class
new file mode 100644
index 0000000..9efae97
Binary files /dev/null and b/ObjectClass1.class differ
diff --git a/ObjectClass1.java b/ObjectClass1.java
new file mode 100644
index 0000000..7ef4896
--- /dev/null
+++ b/ObjectClass1.java
@@ -0,0 +1,18 @@
+class ObjectClass1
+{
+public static void main(String args[])
+{
+Object y;
+y="gaurav";
+System.out.println(y);
+
+y=123;
+System.out.println(y);
+
+y=98.95;
+System.out.println(y);
+
+y="kumar";
+System.out.println(y);
+}
+}
\ No newline at end of file
diff --git a/Occurrence.class b/Occurrence.class
new file mode 100644
index 0000000..652c057
Binary files /dev/null and b/Occurrence.class differ
diff --git a/Occurrence.java b/Occurrence.java
new file mode 100644
index 0000000..46dee18
--- /dev/null
+++ b/Occurrence.java
@@ -0,0 +1,18 @@
+//count the number of occurrence of a given character in a string
+class Occurrence
+{
+public static void main(String args[])
+{
+String s="gaurav";
+char c='a';
+int count=0;
+for(int i=0;i<s.length();i++)
+{
+if(s.charAt(i)==c)
+{
+count++;
+}
+}
+System.out.println("Number of occurrence of given character:"+count);
+}
+}
\ No newline at end of file
diff --git a/OddEven$Node.class b/OddEven$Node.class
new file mode 100644
index 0000000..d1ebf82
Binary files /dev/null and b/OddEven$Node.class differ
diff --git a/OddEven.class b/OddEven.class
new file mode 100644
index 0000000..856d13b
Binary files /dev/null and b/OddEven.class differ
diff --git a/OddEven.java b/OddEven.java
new file mode 100644
index 0000000..2ddbe19
--- /dev/null
+++ b/OddEven.java
@@ -0,0 +1,100 @@
+class OddEven
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next= null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head =x;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Node findOddEven()
+{
+Node temp=head;
+Node head1=null;
+Node head2=null;
+Node odd=null;
+Node even=null;
+while(temp!=null)
+{
+if(temp.data%2==0)
+{
+if(head1==null)
+{
+head1=temp;
+even=head1;
+}
+else
+{
+even.next=temp;
+even=even.next;
+}
+
+}
+else
+{
+if(head2==null)
+{
+head2=temp;
+odd=head2;
+}
+else
+{
+odd.next=temp;
+odd=odd.next;
+}
+}
+
+temp=temp.next;
+}
+even.next=head2;
+odd.next=null;
+head=head1;
+return head;
+}
+
+public static void main(String args[])
+{
+OddEven o=new OddEven();
+o.append(1);
+o.append(2);
+o.append(3);
+o.append(4);
+o.append(5);
+o.print();
+Node s=o.findOddEven();
+o.print();
+}
+}
\ No newline at end of file
diff --git a/OddEven1$Node.class b/OddEven1$Node.class
new file mode 100644
index 0000000..ca22c9a
Binary files /dev/null and b/OddEven1$Node.class differ
diff --git a/OddEven1.class b/OddEven1.class
new file mode 100644
index 0000000..231d0a0
Binary files /dev/null and b/OddEven1.class differ
diff --git a/OddEven1.java b/OddEven1.java
new file mode 100644
index 0000000..e98e3b9
--- /dev/null
+++ b/OddEven1.java
@@ -0,0 +1,98 @@
+class OddEven1
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next= null;
+
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void findOddEven()
+{
+Node temp=head;
+Node head1=null;
+Node head2=null;
+Node even=head1;
+Node odd=head2;
+while(temp!=null)
+{
+if(temp.data%2==0)
+{
+if(head1==null)
+{
+head1=temp;
+even=head1;
+}else
+{
+even.next=temp;
+even=even.next;
+}
+}
+
+else
+{
+if(head2==null)
+{
+head2=temp;
+odd=head2;
+}
+else
+{
+odd.next=temp;
+odd=odd.next;
+}
+
+}
+
+temp=temp.next;
+}
+even.next=head2;
+odd.next=null;
+head=head1;
+}
+
+public static void main(String args[])
+{
+OddEven1 s=new OddEven1();
+s.append(1);
+s.append(2);
+s.append(3);
+s.append(4);
+s.append(5);
+s.print();
+s.findOddEven();
+s.print();
+}
+}
\ No newline at end of file
diff --git a/Outer$InnerClass.class b/Outer$InnerClass.class
new file mode 100644
index 0000000..c66a5b6
Binary files /dev/null and b/Outer$InnerClass.class differ
diff --git a/Outer$InstanceClass.class b/Outer$InstanceClass.class
new file mode 100644
index 0000000..f9eb0d0
Binary files /dev/null and b/Outer$InstanceClass.class differ
diff --git a/Outer$Parent.class b/Outer$Parent.class
new file mode 100644
index 0000000..c0ed236
Binary files /dev/null and b/Outer$Parent.class differ
diff --git a/Outer$nestedClass.class b/Outer$nestedClass.class
new file mode 100644
index 0000000..90e2171
Binary files /dev/null and b/Outer$nestedClass.class differ
diff --git a/Outer.class b/Outer.class
new file mode 100644
index 0000000..f17cc0c
Binary files /dev/null and b/Outer.class differ
diff --git a/Over5.class b/Over5.class
new file mode 100644
index 0000000..1fac473
Binary files /dev/null and b/Over5.class differ
diff --git a/Over5.java b/Over5.java
new file mode 100644
index 0000000..8b5c6be
--- /dev/null
+++ b/Over5.java
@@ -0,0 +1,37 @@
+class Student
+{
+protected void run()
+{
+System.out.println("Hello i am parent");
+}
+
+void show()
+{
+System.out.println("I am child");
+}
+}
+
+class Collage extends Student
+{
+protected void run()
+{
+System.out.println("hello chutiya child");
+}
+
+void show()
+{
+System.out.println("I want to display something");    
+}
+}
+
+class Over5
+{
+public static void main(String args[])
+{
+Student s=new Student();
+s.run();
+
+Student s2=new Collage();
+s2.show();
+}
+}
\ No newline at end of file
diff --git a/OverLoad.class b/OverLoad.class
new file mode 100644
index 0000000..d5b9040
Binary files /dev/null and b/OverLoad.class differ
diff --git a/OverLoad.java b/OverLoad.java
new file mode 100644
index 0000000..87c97da
--- /dev/null
+++ b/OverLoad.java
@@ -0,0 +1,36 @@
+class OverLoad
+{
+int a;
+int b;
+int c;
+void eat(int a)
+{
+this.a=a;
+System.out.println("the value of a="+a);
+}
+
+void eat(int a,int b)
+{
+this.b=b;
+System.out.println("the value a=" +a+ " and b="+b);
+}
+
+int eat(int a,int b,int c)
+{
+this.c=c;
+return (a+b+c);
+}
+
+void eat(String s,int a)
+{
+System.out.println(s+" "+a);
+}
+public static void main(String args[])
+{
+OverLoad o=new OverLoad();
+o.eat(10);
+o.eat(20,30);
+System.out.println(o.eat(12,22,34));
+o.eat("gaurav",10);
+}  
+}
\ No newline at end of file
diff --git a/OverLoadMain.class b/OverLoadMain.class
new file mode 100644
index 0000000..108d8f7
Binary files /dev/null and b/OverLoadMain.class differ
diff --git a/OverLoadMain.java b/OverLoadMain.java
new file mode 100644
index 0000000..778b780
--- /dev/null
+++ b/OverLoadMain.java
@@ -0,0 +1,27 @@
+class OverLoadMain
+{
+public static void main(String args[])
+{
+System.out.println("Hello i am main");
+OverLoadMain.main("hello, My love");
+}
+
+public static void main(String a)
+{
+System.out.println(a+ " Payal");
+OverLoadMain.main("kumar","Gaurav");
+}
+
+public static void main(String s1,String s2)
+{
+System.out.println("Hello "+s1+" and "+s2 );
+OverLoadMain.main(12);
+}
+
+public static void main(int a)
+{
+System.out.println("Value is:"+a);
+}
+}
+
+
diff --git a/OverrRide.class b/OverrRide.class
new file mode 100644
index 0000000..a42c966
Binary files /dev/null and b/OverrRide.class differ
diff --git a/OverrRide.java b/OverrRide.java
new file mode 100644
index 0000000..f1d16b3
--- /dev/null
+++ b/OverrRide.java
@@ -0,0 +1,38 @@
+class Student
+{
+void eat()
+{
+System.out.println(" i am eating in parent");
+}
+
+void happy()
+{
+System.out.println("Hello how are you");
+}
+}
+
+class teacher extends Student
+{
+void eat()
+{
+System.out.println("Hello child");
+}
+
+void happy()
+{
+System.out.println("Hello i am happy");
+}
+}
+
+class OverrRide
+{
+public static void main(String args[])
+{
+teacher t=new teacher();
+t.eat();
+
+Student s=new Student();
+s.happy();
+s.eat();
+}
+}
\ No newline at end of file
diff --git a/Override.class b/Override.class
new file mode 100644
index 0000000..50e9a59
Binary files /dev/null and b/Override.class differ
diff --git a/Override.java b/Override.java
new file mode 100644
index 0000000..2935a55
--- /dev/null
+++ b/Override.java
@@ -0,0 +1,36 @@
+class sujit
+{
+void eat()
+{
+System.out.println("Hello I am sorry");
+}
+void play()
+{
+System.out.println("Hello i am playing");
+}
+}
+
+class gaurav extends sujit
+{
+void eat()
+{
+System.out.println("Helllo i am subclass");
+}
+
+void play()
+{
+System.out.println("I am call to everything");
+}
+}
+
+class Override
+{
+public static void main(String args[])
+{
+gaurav g=new gaurav();
+g.eat();
+
+sujit s=new sujit();
+s.play();
+}
+}
\ No newline at end of file
diff --git a/Override1.class b/Override1.class
new file mode 100644
index 0000000..ea2d531
Binary files /dev/null and b/Override1.class differ
diff --git a/Override1.java b/Override1.java
new file mode 100644
index 0000000..566e071
--- /dev/null
+++ b/Override1.java
@@ -0,0 +1,37 @@
+class sujit
+{
+private void play()
+{
+System.out.println("I gonna play");
+}
+
+protected void dance()
+{
+System.out.println("I am doing dance");
+}
+}
+
+class kumar extends sujit
+{
+private void play()
+{
+System.out.println("I can do this things very fast");
+}
+
+public void dance()
+{
+super.dance();
+System.out.println("I can do dance better rather than you");
+}
+}
+
+class Override1
+{
+public static void main(String args[])
+{
+sujit s=new kumar();
+s.dance();
+kumar k=new kumar();
+//k.play();
+}
+}
\ No newline at end of file
diff --git a/Override12.class b/Override12.class
new file mode 100644
index 0000000..9580427
Binary files /dev/null and b/Override12.class differ
diff --git a/Override12.java b/Override12.java
new file mode 100644
index 0000000..4e424b4
--- /dev/null
+++ b/Override12.java
@@ -0,0 +1,46 @@
+class vikash
+{
+void eat()
+{
+System.out.println("Vikash is eating something");
+}
+
+void play()
+{
+System.out.println("He is going to play");
+}
+}
+
+class gaurav extends vikash
+{
+void eat()
+{
+System.out.println("I am eating in child");
+}
+
+void play()
+{
+System.out.println("I am going to play somewhere");
+}
+
+void sleep()
+{
+System.out.println("I am gonna to sleep");
+}
+
+}
+
+class Override12
+{
+public static void main(String args[])
+{
+vikash v=new gaurav();
+v.eat();
+v.play();
+
+gaurav a=new gaurav();
+a.sleep();
+
+
+}
+}
diff --git a/Pair.class b/Pair.class
new file mode 100644
index 0000000..345dcc9
Binary files /dev/null and b/Pair.class differ
diff --git a/Pair.java b/Pair.java
new file mode 100644
index 0000000..9dec323
--- /dev/null
+++ b/Pair.java
@@ -0,0 +1,31 @@
+import java.util.*;
+class Pair
+{
+static void pairSum(int a[],int n)
+{
+Arrays.sort(a);
+int left=0;
+int right=a.length-1;
+while(left<right)
+{
+if(a[left]+a[right]<n)
+left=left+1;
+
+else if(a[left]+a[right]>n)
+right=right-1;
+
+else if(a[left]+a[right]==n)
+{
+System.out.println("the pair is:"+"(" +a[left]+","+a[right]+")");
+right=right-1;
+left=left+1;
+}
+}
+}
+public static void main(String args[])
+{
+int a[]={1,2,3,4,5};
+int n=5;
+pairSum(a,n);
+}
+}
\ No newline at end of file
diff --git a/Palin$Node.class b/Palin$Node.class
new file mode 100644
index 0000000..66bafb2
Binary files /dev/null and b/Palin$Node.class differ
diff --git a/Palin.class b/Palin.class
new file mode 100644
index 0000000..398c648
Binary files /dev/null and b/Palin.class differ
diff --git a/Palin.java b/Palin.java
new file mode 100644
index 0000000..2a48f0a
--- /dev/null
+++ b/Palin.java
@@ -0,0 +1,37 @@
+class Palin
+{
+Node head;
+static class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.println(temp.data);
+temp=temp.next;
+}
+}
+public static void main(String args[])
+{
+Palin p=new Palin();
+p.head=new Node(5);
+
+Node x=new Node(10);
+Node y=new Node(20);
+Node z=new Node(30);
+p.head.next=x;
+x.next=y;
+y.next=z;
+
+p.print();
+}
+}
\ No newline at end of file
diff --git a/Parameter.class b/Parameter.class
new file mode 100644
index 0000000..8bd4ed4
Binary files /dev/null and b/Parameter.class differ
diff --git a/Parameter.java b/Parameter.java
new file mode 100644
index 0000000..be07370
--- /dev/null
+++ b/Parameter.java
@@ -0,0 +1,29 @@
+class teacher
+{
+String name;
+int a;
+teacher(String name,int a)
+{
+this.name=name;
+this.a=a;
+}
+
+void get()
+{
+print(this);
+}
+
+void print(teacher ob)
+{
+System.out.println("Name="+ob.name+" and a="+ob.a);
+}
+}
+
+class Parameter
+{
+public static void main(String args[])
+{
+teacher t=new teacher("gaurav",153);
+t.get();
+}
+}
\ No newline at end of file
diff --git a/Parent.class b/Parent.class
new file mode 100644
index 0000000..5594c08
Binary files /dev/null and b/Parent.class differ
diff --git a/Permutation1.class b/Permutation1.class
new file mode 100644
index 0000000..b95219f
Binary files /dev/null and b/Permutation1.class differ
diff --git a/Point$Node.class b/Point$Node.class
new file mode 100644
index 0000000..a5414e4
Binary files /dev/null and b/Point$Node.class differ
diff --git a/Point.class b/Point.class
new file mode 100644
index 0000000..8878f5c
Binary files /dev/null and b/Point.class differ
diff --git a/Point.java b/Point.java
new file mode 100644
index 0000000..0a143ce
--- /dev/null
+++ b/Point.java
@@ -0,0 +1,113 @@
+class Point
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+
+int getNode(Node head1,Node head2)
+{
+int l1=getCount(head1);
+int l2=getCount(head2);
+int d;
+if(l1>l2)
+{
+d=l1-l2;
+return Intersection(d,head1,head2);
+}
+else
+{
+d=l2-l1;
+return Intersection(d,head1,head2);
+}
+}
+
+int Intersection(int d,Node head1,Node head2)
+{
+Node temp1=head1;
+Node temp2=head2;
+for(int i=0;i<d;i++)
+{
+if(temp1==null)
+{
+return -1;
+}
+temp1=temp1.next;
+}
+
+while(temp1!=null && temp2!=null)
+{
+if(temp1.data==temp2.data)
+{
+return temp1.data;
+}
+temp1=temp1.next;
+temp2=temp2.next;
+}
+return -1;
+}
+
+int getCount(Node x)
+{
+int count=0;
+Node temp=x;
+while(temp!=null)
+{
+count+=1;
+temp=temp.next;
+}
+return count;
+}
+public static void main(String args[])
+{
+Point p1=new Point();
+p1.append(10);
+p1.append(20);
+p1.append(30);
+p1.append(40);
+p1.print();
+
+Point p2=new Point();
+p2.append(2);
+p2.append(30);
+p2.append(40);
+p2.print();
+Point p3=new Point();
+System.out.println("The intersection point-->"+p3.getNode(p1.head,p2.head));
+}
+}
\ No newline at end of file
diff --git a/Point1$Node.class b/Point1$Node.class
new file mode 100644
index 0000000..ab2c789
Binary files /dev/null and b/Point1$Node.class differ
diff --git a/Point1.class b/Point1.class
new file mode 100644
index 0000000..b33ba90
Binary files /dev/null and b/Point1.class differ
diff --git a/Point1.java b/Point1.java
new file mode 100644
index 0000000..8f9b4bf
--- /dev/null
+++ b/Point1.java
@@ -0,0 +1,89 @@
+import java.util.*;
+class Point1
+{
+static Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+static void intersection(Node head1,Node head2)
+{
+Node temp1=head1;
+Node temp2=head2;
+Set<Node> set=new HashSet<>();
+
+while(temp1!=null)
+{
+set.add(temp1);
+temp1=temp1.next;
+}
+
+while(temp2!=null)
+{
+if(set.contains(temp2))
+{
+System.out.println(temp2.data);
+break;
+}
+temp2=temp2.next;
+}
+
+}
+
+public static void main(String args[])
+{
+Point1 p1=new Point1();
+p1.append(4);
+p1.append(1);
+p1.append(8);
+p1.append(4);
+p1.append(5);
+p1.print();
+
+Point1 p2=new Point1();
+p2.append(5);
+p2.append(6);
+p2.append(1);
+p2.append(8);
+p2.append(4);
+p2.append(5);
+p2.print();
+
+Point1 p3=new Point1();
+intersection(p1.head,p2.head);
+}
+}
\ No newline at end of file
diff --git a/Power.class b/Power.class
new file mode 100644
index 0000000..ae279a7
Binary files /dev/null and b/Power.class differ
diff --git a/Power.java b/Power.java
new file mode 100644
index 0000000..b1efe63
--- /dev/null
+++ b/Power.java
@@ -0,0 +1,17 @@
+//Power of a number
+import java.util.*;
+class Power
+{
+public static void main(String args[])
+{
+int a=2;
+int b=3;
+int res=1;
+for(int i=0;i<b;i++)
+{
+res=res*a;
+}
+
+System.out.println("The power of a number is:"+res);
+} 
+}
\ No newline at end of file
diff --git a/PrimeNumber.class b/PrimeNumber.class
new file mode 100644
index 0000000..a0ae96b
Binary files /dev/null and b/PrimeNumber.class differ
diff --git a/PrimeNumber.java b/PrimeNumber.java
new file mode 100644
index 0000000..5a8a512
--- /dev/null
+++ b/PrimeNumber.java
@@ -0,0 +1,18 @@
+class PrimeNumber
+{
+public static void main(String args[])
+{
+int n=4;
+boolean isPrime=true;
+for(int i=2;i<n;i++)
+{
+if(n%2==0)
+{
+isPrime=false;
+break;
+}
+}
+if(n<2) isPrime=false;
+System.out.println("IsPrime="+isPrime);
+}
+}
diff --git a/Priority1.class b/Priority1.class
new file mode 100644
index 0000000..30a6679
Binary files /dev/null and b/Priority1.class differ
diff --git a/Priority1.java b/Priority1.java
new file mode 100644
index 0000000..9d48c6d
--- /dev/null
+++ b/Priority1.java
@@ -0,0 +1,14 @@
+import java.util.*;
+class Priority1
+{
+public static void main(String args[])
+{
+PriorityQueue<Integer> p=new PriorityQueue<>();
+p.add(10);
+p.add(2);
+p.add(1);
+p.add(3);
+p.add(12);
+System.out.println(p);
+}
+}
\ No newline at end of file
diff --git a/QuickSort1.class b/QuickSort1.class
new file mode 100644
index 0000000..8533b51
Binary files /dev/null and b/QuickSort1.class differ
diff --git a/QuickSort1.java b/QuickSort1.java
new file mode 100644
index 0000000..d12061b
--- /dev/null
+++ b/QuickSort1.java
@@ -0,0 +1,52 @@
+import java.util.*;
+class QuickSort1
+{
+static void quickSort(int a[],int l,int h)
+{
+if(l<h)
+{
+int pivot=partition(a,l,h);
+quickSort(a,l,pivot-1);
+quickSort(a,pivot+1,h);
+}
+}
+
+static int partition(int a[],int l,int h)
+{
+int pivot=a[l];
+int i=l;
+int j=h;
+while(i<j)
+{
+while(a[i]<=pivot)
+{
+i++;
+}
+
+while(a[j]>pivot)
+{
+j--;
+}
+
+if(i<j)
+{
+int temp=a[i];
+a[i]=a[j];
+a[j]=temp;
+}
+
+}
+
+int k=a[l];
+a[l]=a[j];
+a[j]=k;
+return j;
+}
+public static void main(String args[])
+{
+int a[]={2,1,4,5,7,6,9,8};
+int n=a.length;
+quickSort(a,0,n-1);
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/RandomData1.class b/RandomData1.class
new file mode 100644
index 0000000..67c3ac9
Binary files /dev/null and b/RandomData1.class differ
diff --git a/RandomData1.java b/RandomData1.java
new file mode 100644
index 0000000..23ee1f4
--- /dev/null
+++ b/RandomData1.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class RandomData1
+{
+static String random(List<String> l)
+{
+Random r=new Random();
+return l.get(r.nextInt(l.size()));
+}
+public static void main(String args[])
+{
+List<String> l=new ArrayList<>();
+l.add("gaurav");
+l.add("sujit");
+l.add("kumar");
+l.add("payal");
+System.out.println(l);
+System.out.println(random(l));
+
+}
+}
\ No newline at end of file
diff --git a/RandomList.class b/RandomList.class
new file mode 100644
index 0000000..990373d
Binary files /dev/null and b/RandomList.class differ
diff --git a/RandomList.java b/RandomList.java
new file mode 100644
index 0000000..0ebe9a4
--- /dev/null
+++ b/RandomList.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class RandomList
+{
+static int randomElement(List<Integer> l)
+{
+Random r=new Random();
+return l.get(r.nextInt(l.size()));
+}
+public static void main(String args[])
+{
+List<Integer> l=new ArrayList<>();
+l.add(1);
+l.add(2);
+l.add(3);
+l.add(4);
+l.add(5);
+System.out.println(l);
+System.out.println(randomElement(l));
+}
+}
\ No newline at end of file
diff --git a/Rearrange.class b/Rearrange.class
new file mode 100644
index 0000000..866b2e8
Binary files /dev/null and b/Rearrange.class differ
diff --git a/Rearrange.java b/Rearrange.java
new file mode 100644
index 0000000..b54375a
--- /dev/null
+++ b/Rearrange.java
@@ -0,0 +1,46 @@
+import java.util.*;
+class Rearrange
+{
+public static  void main(String args[])
+{
+int a[]={1,2,3,-2,-3,5};
+int n=a.length;
+int i=0;
+int j=n-1;
+while(i<=j)
+{
+if(a[i]<0 && a[j]>0)
+{
+int temp=a[i];
+a[i]=a[j];
+a[j]=temp;
+i++;
+j--;
+}
+
+else if(a[i]>0 && a[j]<0)
+{
+i++;
+j--;
+}
+
+else if(a[i]>0)
+i++;
+
+else if(a[j]<0)
+j--;
+}
+
+int k=0;
+while(k<a.length && i<a.length)
+{
+int temp=a[k];
+a[k]=a[i];
+a[i]=temp;
+k+=2;
+i++;
+}
+
+System.out.println(Arrays.toString(a));
+}
+}
diff --git a/Rearrange1.class b/Rearrange1.class
new file mode 100644
index 0000000..bf109ed
Binary files /dev/null and b/Rearrange1.class differ
diff --git a/Rearrange1.java b/Rearrange1.java
new file mode 100644
index 0000000..e93551f
--- /dev/null
+++ b/Rearrange1.java
@@ -0,0 +1,43 @@
+import java.util.*;
+class Rearrange1
+{
+public static void main(String args[])
+{
+int a[]={1,2,3,-3,-4,5};
+int n=a.length;
+int i=0;
+int j=n-1;
+while(i<=j)
+{
+if(a[i]>0 && a[j]<0)
+{
+int temp=a[i];
+a[i]=a[j];
+a[j]=temp;
+i++;
+j--;
+}
+else if(a[i]<0 && a[j]>0)
+{
+i++;
+j--;
+}
+
+else if(a[i]<0)
+i++;
+else if(a[j]>0)
+j--;
+}
+int k=0;
+while(k<n && i<n)
+{
+int temp=a[k];
+a[k]=a[i];
+a[i]=temp;
+k+=2;
+i++;
+}
+
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/Rectangle.class b/Rectangle.class
new file mode 100644
index 0000000..b79c30b
Binary files /dev/null and b/Rectangle.class differ
diff --git a/RemoveAll1$Node.class b/RemoveAll1$Node.class
new file mode 100644
index 0000000..a15eeae
Binary files /dev/null and b/RemoveAll1$Node.class differ
diff --git a/RemoveAll1.class b/RemoveAll1.class
new file mode 100644
index 0000000..0f2c875
Binary files /dev/null and b/RemoveAll1.class differ
diff --git a/RemoveAll1.java b/RemoveAll1.java
new file mode 100644
index 0000000..ef59a45
--- /dev/null
+++ b/RemoveAll1.java
@@ -0,0 +1,50 @@
+class RemoveAll1
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+public static void main(String args[])
+{
+RemoveAll1 r=new RemoveAll1();
+r.append(1);
+r.append(2);
+r.append(3);
+r.append(3);
+r.append(4);
+r.print();
+}
+}
\ No newline at end of file
diff --git a/RemoveChar.class b/RemoveChar.class
new file mode 100644
index 0000000..6751253
Binary files /dev/null and b/RemoveChar.class differ
diff --git a/RemoveChar.java b/RemoveChar.java
new file mode 100644
index 0000000..e5e3d22
--- /dev/null
+++ b/RemoveChar.java
@@ -0,0 +1,28 @@
+import java.util.*;
+class RemoveChar
+{
+static String remove(String s)
+{
+Set<Character> set=new HashSet<>();
+char a[]=s.toCharArray();
+String k="";
+for(int i=0;i<a.length;i++)
+{
+if(!(set.contains(a[i])))
+{
+set.add(i,a[i]);
+}
+}
+System.out.println(set);
+for(char l:set)
+{
+k+=l;
+}
+return k;
+}
+public static void main(String args[])
+{
+String s="Gaurav";
+System.out.println(remove(s));
+}
+}
\ No newline at end of file
diff --git a/RemoveChar1.class b/RemoveChar1.class
new file mode 100644
index 0000000..2af1335
Binary files /dev/null and b/RemoveChar1.class differ
diff --git a/RemoveChar1.java b/RemoveChar1.java
new file mode 100644
index 0000000..802a080
--- /dev/null
+++ b/RemoveChar1.java
@@ -0,0 +1,22 @@
+import java.util.*;
+class RemoveChar1
+{
+public static void main(String args[])
+{
+Set<Character> set=new LinkedHashSet<>();
+String s="Gaurav";
+String k="";
+char c[]=s.toCharArray();
+System.out.println(Arrays.toString(c));
+for(int i=0;i<c.length;i++)
+{
+set.add(c[i]);
+}
+for(char c1:set)
+{
+k+=c1;
+}
+System.out.println(k);
+}
+
+}
\ No newline at end of file
diff --git a/RemoveData.class b/RemoveData.class
new file mode 100644
index 0000000..0f1b301
Binary files /dev/null and b/RemoveData.class differ
diff --git a/RemoveData.java b/RemoveData.java
new file mode 100644
index 0000000..26c6644
--- /dev/null
+++ b/RemoveData.java
@@ -0,0 +1,17 @@
+import java.util.*;
+class RemoveData
+{
+public static void main(String args[])
+{
+List<Integer> l=new ArrayList<>();
+l.add(10);
+l.add(1);
+l.add(2);
+l.add(3);
+l.add(4);
+l.add(5);
+System.out.println(l);
+l.subList(1,3).clear();
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/RemoveData1.class b/RemoveData1.class
new file mode 100644
index 0000000..13bd647
Binary files /dev/null and b/RemoveData1.class differ
diff --git a/RemoveData1.java b/RemoveData1.java
new file mode 100644
index 0000000..28f2c4e
--- /dev/null
+++ b/RemoveData1.java
@@ -0,0 +1,15 @@
+import java.util.*;
+class RemoveData1
+{
+public static void main(String args[])
+{
+ArrayList<String> l=new ArrayList<>();
+l.add("Sujit");
+l.add("gaurav");
+l.add("kumar");
+l.add("vikash");
+System.out.println(l);
+l.subList(0,3).clear();
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/RemoveData3.class b/RemoveData3.class
new file mode 100644
index 0000000..cc19e82
Binary files /dev/null and b/RemoveData3.class differ
diff --git a/RemoveData3.java b/RemoveData3.java
new file mode 100644
index 0000000..76fce56
--- /dev/null
+++ b/RemoveData3.java
@@ -0,0 +1,16 @@
+import java.util.*;
+class RemoveData3 extends ArrayList<Integer>
+{
+public static void main(String args[])
+{
+RemoveData3 l=new RemoveData3();
+l.add(1);
+l.add(2);
+l.add(3);
+l.add(4);
+System.out.println(l);
+l.removeRange(2,4);
+System.out.println(l);
+
+}
+}
\ No newline at end of file
diff --git a/RemoveDup1$Node.class b/RemoveDup1$Node.class
new file mode 100644
index 0000000..ae4d74f
Binary files /dev/null and b/RemoveDup1$Node.class differ
diff --git a/RemoveDup1.class b/RemoveDup1.class
new file mode 100644
index 0000000..1e30540
Binary files /dev/null and b/RemoveDup1.class differ
diff --git a/RemoveDup1.java b/RemoveDup1.java
new file mode 100644
index 0000000..94c3c74
--- /dev/null
+++ b/RemoveDup1.java
@@ -0,0 +1,76 @@
+class RemoveDup1
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void remove()
+{
+Node temp=head;
+Node prev=head;
+
+while(temp!=null && prev!=null)
+{
+if(temp.data==prev.data)
+{
+prev=prev.next;
+}
+else
+{
+temp.next=prev;
+temp=temp.next;
+prev=prev.next;
+}
+if(temp!=null)
+{
+temp.next=prev;
+}
+}
+}
+
+public static void main(String args[])
+{
+RemoveDup1 r=new RemoveDup1();
+r.append(10);
+r.append(20);
+r.append(20);
+r.append(30);
+r.print();
+r.remove();
+r.print();
+}
+}
\ No newline at end of file
diff --git a/RemoveDup12.class b/RemoveDup12.class
new file mode 100644
index 0000000..43d910a
Binary files /dev/null and b/RemoveDup12.class differ
diff --git a/RemoveDup12.java b/RemoveDup12.java
new file mode 100644
index 0000000..965dd92
--- /dev/null
+++ b/RemoveDup12.java
@@ -0,0 +1,22 @@
+import java.util.*;
+class RemoveDup12
+{
+static List<Integer> duplicates(int a[])
+{
+Arrays.sort(a);
+List<Integer> l=new ArrayList<>();
+for(int i=0;i<a.length-1;i++)
+{
+if(a[i]==a[i+1])
+{
+l.add(a[i]);
+}
+}
+return l;
+}
+public static void main(String args[])
+{
+int a[]={4,3,2,7,8,2,3,1};
+System.out.println(duplicates(a));
+}
+}
\ No newline at end of file
diff --git a/RemoveDup2$Node.class b/RemoveDup2$Node.class
new file mode 100644
index 0000000..ccd61d7
Binary files /dev/null and b/RemoveDup2$Node.class differ
diff --git a/RemoveDup2.class b/RemoveDup2.class
new file mode 100644
index 0000000..723258c
Binary files /dev/null and b/RemoveDup2.class differ
diff --git a/RemoveDup2.java b/RemoveDup2.java
new file mode 100644
index 0000000..7fccc34
--- /dev/null
+++ b/RemoveDup2.java
@@ -0,0 +1,71 @@
+class RemoveDup2
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void removeDup()
+{
+Node temp=head;
+while(temp!=null)
+{
+Node prev=temp;
+while(prev!=null && temp.data==prev.data)
+{
+prev=prev.next;
+}
+temp.next=prev;
+temp=temp.next;
+}
+}
+
+public static void main(String args[])
+{
+RemoveDup2 r=new RemoveDup2();
+r.append(10);
+r.append(20);
+r.append(30);
+r.append(30);
+r.append(40);
+r.print();
+
+r.removeDup();
+System.out.println("After removeing...");
+r.print();
+}
+}
\ No newline at end of file
diff --git a/RemoveDup3.class b/RemoveDup3.class
new file mode 100644
index 0000000..054af0c
Binary files /dev/null and b/RemoveDup3.class differ
diff --git a/RemoveDup3.java b/RemoveDup3.java
new file mode 100644
index 0000000..5839a8c
--- /dev/null
+++ b/RemoveDup3.java
@@ -0,0 +1,25 @@
+class RemoveDup3
+{
+static int remove(int a[])
+{
+int i=0;
+int j=1;
+while(i<a.length && j<a.length)
+{
+if(a[i]==a[j])
+j++;
+else
+{
+i++;
+a[i]=a[j];
+}
+
+}
+return i+1;
+}
+public static void main(String args[])
+{
+int a[]={1,2,2,3,4,4};
+System.out.println(remove(a));
+}
+}
\ No newline at end of file
diff --git a/RemoveDup4$Node.class b/RemoveDup4$Node.class
new file mode 100644
index 0000000..445baee
Binary files /dev/null and b/RemoveDup4$Node.class differ
diff --git a/RemoveDup4.class b/RemoveDup4.class
new file mode 100644
index 0000000..7f88b96
Binary files /dev/null and b/RemoveDup4.class differ
diff --git a/RemoveDup4.java b/RemoveDup4.java
new file mode 100644
index 0000000..b739662
--- /dev/null
+++ b/RemoveDup4.java
@@ -0,0 +1,76 @@
+class RemoveDup4
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void remove()
+{
+Node temp=head;
+Node prev=null;
+ArrayList<Integer> l=new ArrayList<>();
+while(temp!=null)
+{
+if(l.contains(temp.data))
+{
+prev.next=temp.next;
+temp=temp.next;
+}
+else
+{
+l.add(temp.data);
+prev=temp;
+temp=temp.next;
+}
+}
+}
+
+public static void main(String args[])
+{
+RemoveDup4 r=new RemoveDup4();
+r.append(5);
+r.append(3);
+r.append(3);
+r.append(4);
+r.append(10);
+
+r.print();
+r.remove();
+}
+}
\ No newline at end of file
diff --git a/RemoveDuplicate1.class b/RemoveDuplicate1.class
new file mode 100644
index 0000000..7019790
Binary files /dev/null and b/RemoveDuplicate1.class differ
diff --git a/RemoveDuplicate1.java b/RemoveDuplicate1.java
new file mode 100644
index 0000000..d016f4e
--- /dev/null
+++ b/RemoveDuplicate1.java
@@ -0,0 +1,29 @@
+import java.util.*;
+class RemoveDuplicate1
+{
+static int remove(int a[])
+{
+int i=0;
+int j=1;
+while(i<a.length && j<a.length)
+{
+if(a[i]==a[j])
+{
+j++;
+}
+else
+{
+i++;
+a[i]=a[j];
+}
+}
+return i+1;
+}
+
+public static void main(String args[])
+{
+int a[]={1,2,2,3,4,5,5};
+int k=remove(a);
+System.out.println(k);
+}
+}
\ No newline at end of file
diff --git a/RemoveInPlace.java b/RemoveInPlace.java
new file mode 100644
index 0000000..d3615ab
--- /dev/null
+++ b/RemoveInPlace.java
@@ -0,0 +1,8 @@
+class RemoveInPalce
+{
+public static void main(String args[])
+{
+String s="gaurav";
+
+}
+}
\ No newline at end of file
diff --git a/RemoveNth$Node.class b/RemoveNth$Node.class
new file mode 100644
index 0000000..7835518
Binary files /dev/null and b/RemoveNth$Node.class differ
diff --git a/RemoveNth.class b/RemoveNth.class
new file mode 100644
index 0000000..328971a
Binary files /dev/null and b/RemoveNth.class differ
diff --git a/RemoveNth.java b/RemoveNth.java
new file mode 100644
index 0000000..4249561
--- /dev/null
+++ b/RemoveNth.java
@@ -0,0 +1,66 @@
+class RemoveNth
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void push(int data)
+{
+Node x=new Node(data);
+x.next=head;
+head=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Node remove(int n)
+{
+Node prev=head;
+Node temp=head;
+for(int i=1;i<=n;i++)
+{
+temp=temp.next;
+}
+if(temp==null)
+{
+head=head.next;
+return head;
+}
+
+while(temp.next!=null)
+{
+temp=temp.next;
+prev=prev.next;
+}
+prev.next=prev.next.next;
+return head;
+
+}
+
+public static void main(String args[])
+{
+RemoveNth r=new RemoveNth();
+r.push(10);
+r.push(20);
+r.print();
+Node k=r.remove(2);
+r.print();
+}
+}
\ No newline at end of file
diff --git a/Reorder$Node.class b/Reorder$Node.class
new file mode 100644
index 0000000..3729150
Binary files /dev/null and b/Reorder$Node.class differ
diff --git a/Reorder.class b/Reorder.class
new file mode 100644
index 0000000..e9e8a6e
Binary files /dev/null and b/Reorder.class differ
diff --git a/Reorder.java b/Reorder.java
new file mode 100644
index 0000000..37d37d8
--- /dev/null
+++ b/Reorder.java
@@ -0,0 +1,77 @@
+class Reorder
+{
+Node head;
+class Node{
+Node next;
+int data;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+
+void order()
+{
+Node temp=head;
+int len=0;
+while(temp!=null)
+{
+len+=1;
+temp=temp.next;
+}
+temp=head;
+Node k=len;
+Node prev=head.next;
+while(temp!=null)
+{
+temp.next=k;
+temp=temp.next;
+temp.next=prev;
+prev=prev.next;
+k--;
+}
+             
+}
+
+public static void main(String args[])
+{
+Reorder r=new Reorder();
+r.append(1);
+r.append(2);
+r.append(3);
+r.append(4);
+r.print();
+r.order();
+r.print();
+}
+}
\ No newline at end of file
diff --git a/Replace2.class b/Replace2.class
new file mode 100644
index 0000000..9d66a52
Binary files /dev/null and b/Replace2.class differ
diff --git a/Replace2.java b/Replace2.java
new file mode 100644
index 0000000..540da59
--- /dev/null
+++ b/Replace2.java
@@ -0,0 +1,9 @@
+class Replace2
+{
+public static void main(String args[])
+{
+StringBuffer s1=new StringBuffer("KAmar");
+String s=s1.toString();
+System.out.println(s);
+}
+}
\ No newline at end of file
diff --git a/ReturnType.class b/ReturnType.class
new file mode 100644
index 0000000..ab127ee
Binary files /dev/null and b/ReturnType.class differ
diff --git a/ReturnType.java b/ReturnType.java
new file mode 100644
index 0000000..2d03a6d
--- /dev/null
+++ b/ReturnType.java
@@ -0,0 +1,32 @@
+class A{}
+class B extends A{}
+
+class Gaurav
+{
+A eat()
+{
+System.out.println("Hello how are you");
+return new A();
+}
+}
+
+
+class Sujit extends Gaurav
+{
+B eat()
+{
+System.out.println("hello Child how are you");
+return new B();
+}
+}
+
+class ReturnType
+{
+public static void main(String args[])
+{
+Gaurav g=new Sujit();
+g.eat();
+Gaurav g1=new Gaurav();
+g1.eat();
+}
+}
\ No newline at end of file
diff --git a/Reverse1.class b/Reverse1.class
new file mode 100644
index 0000000..abd81cf
Binary files /dev/null and b/Reverse1.class differ
diff --git a/Reverse1.java b/Reverse1.java
new file mode 100644
index 0000000..1171de9
--- /dev/null
+++ b/Reverse1.java
@@ -0,0 +1,27 @@
+import java.util.*;
+class Reverse1
+{
+static int[] reverse(int a[],int n)
+{
+int b[]=new int[n];
+int j=0;
+for(int i=n-1;i>=0;i--)
+{
+b[j]=a[i];
+j++;
+}
+return b;
+}
+public static void main(String args[])
+{
+Scanner sc=new Scanner(System.in);
+int n=sc.nextInt();
+int a[]=new int[n];
+for(int i=0;i<n;i++)
+{
+a[i]=sc.nextInt();
+}
+int res[]=reverse(a,n);
+System.out.println(Arrays.toString(res));
+}
+}
\ No newline at end of file
diff --git a/Reverse2.class b/Reverse2.class
new file mode 100644
index 0000000..01c08cc
Binary files /dev/null and b/Reverse2.class differ
diff --git a/Reverse2.java b/Reverse2.java
new file mode 100644
index 0000000..173d7c9
--- /dev/null
+++ b/Reverse2.java
@@ -0,0 +1,10 @@
+import java.util.*;
+class Reverse2
+{
+public static void main(String args[])
+{
+Integer a[]={10,2,20,15,11,12};
+Arrays.sort(a,Collections.reverseOrder());
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/ReverseLink12$Node.class b/ReverseLink12$Node.class
new file mode 100644
index 0000000..d4f186d
Binary files /dev/null and b/ReverseLink12$Node.class differ
diff --git a/ReverseLink12.class b/ReverseLink12.class
new file mode 100644
index 0000000..67e8ad6
Binary files /dev/null and b/ReverseLink12.class differ
diff --git a/ReverseLink12.java b/ReverseLink12.java
new file mode 100644
index 0000000..cef9b2e
--- /dev/null
+++ b/ReverseLink12.java
@@ -0,0 +1,51 @@
+class ReverseLink12
+{
+Node head;
+class Node
+{
+Node next;
+int data;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node n=new Node(data);
+if(head==null)
+{
+head=n;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=n;
+}
+
+void print(){
+
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+public static void main(String args[])
+{
+ReverseLink12 r=new ReverseLink12();
+r.append(10);
+r.append(11);
+r.append(12);
+r.append(13);
+r.print();
+}
+}
\ No newline at end of file
diff --git a/ReverseLinked1$Node.class b/ReverseLinked1$Node.class
new file mode 100644
index 0000000..88154b4
Binary files /dev/null and b/ReverseLinked1$Node.class differ
diff --git a/ReverseLinked1.class b/ReverseLinked1.class
new file mode 100644
index 0000000..5bc56b6
Binary files /dev/null and b/ReverseLinked1.class differ
diff --git a/ReverseLinked1.java b/ReverseLinked1.java
new file mode 100644
index 0000000..ee90a20
--- /dev/null
+++ b/ReverseLinked1.java
@@ -0,0 +1,74 @@
+class ReverseLinked1
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void reverse()
+{
+Node temp=head;
+Node next=null;
+Node prev=null;
+while(temp!=null)
+{
+next=temp.next;
+temp.next=prev;
+prev=temp;
+temp=next;
+}
+temp=prev;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+public static void main(String args[])
+{
+ReverseLinked1 r=new ReverseLinked1();
+r.append(1);
+r.append(2);
+r.append(3);
+r.append(4);
+r.print();
+r.reverse();
+}
+}
\ No newline at end of file
diff --git a/ReverseLinked12$Node.class b/ReverseLinked12$Node.class
new file mode 100644
index 0000000..de655da
Binary files /dev/null and b/ReverseLinked12$Node.class differ
diff --git a/ReverseLinked12.class b/ReverseLinked12.class
new file mode 100644
index 0000000..64f1e4c
Binary files /dev/null and b/ReverseLinked12.class differ
diff --git a/ReverseLinked12.java b/ReverseLinked12.java
new file mode 100644
index 0000000..1944c48
--- /dev/null
+++ b/ReverseLinked12.java
@@ -0,0 +1,75 @@
+class ReverseLinked12
+{
+Node head;
+class Node
+{
+Node next;
+int data;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+
+void reverse()
+{
+Node temp=head;
+Node next=null;
+Node prev=null;
+while(temp!=null)
+{
+next=temp.next;
+temp.next=prev;
+prev=temp;
+temp=next;
+}
+
+temp=prev;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+public static void main(String args[])
+{
+ReverseLinked12 l=new ReverseLinked12();
+l.append(10);
+l.append(11);
+l.append(12);
+l.append(13);
+l.print();
+l.reverse();
+}
+}
\ No newline at end of file
diff --git a/ReverseOrder.class b/ReverseOrder.class
new file mode 100644
index 0000000..e583ef5
Binary files /dev/null and b/ReverseOrder.class differ
diff --git a/ReverseOrder.java b/ReverseOrder.java
new file mode 100644
index 0000000..a87fbb8
--- /dev/null
+++ b/ReverseOrder.java
@@ -0,0 +1,16 @@
+import java.util.*;
+class ReverseOrder
+{
+public static void main(String args[])
+{
+List<Integer> l=new ArrayList<>();
+l.add(10);
+l.add(5);
+l.add(20);
+l.add(15);
+l.add(25);
+System.out.println(l);
+Collections.sort(l,Collections.reverseOrder());
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/ReverseStr.class b/ReverseStr.class
new file mode 100644
index 0000000..5e55aa5
Binary files /dev/null and b/ReverseStr.class differ
diff --git a/ReverseStr.java b/ReverseStr.java
new file mode 100644
index 0000000..ddab7fa
--- /dev/null
+++ b/ReverseStr.java
@@ -0,0 +1,13 @@
+class ReverseStr
+{
+public static void main(String args[])
+{
+String s="gaurav";
+char a[]=s.toCharArray();
+
+for(int i=s.length()-1;i>=0;i--)
+{
+System.out.print(a[i]);
+}
+}
+}
\ No newline at end of file
diff --git a/ReverseString2.class b/ReverseString2.class
new file mode 100644
index 0000000..21f3529
Binary files /dev/null and b/ReverseString2.class differ
diff --git a/ReverseString2.java b/ReverseString2.java
new file mode 100644
index 0000000..87f7928
--- /dev/null
+++ b/ReverseString2.java
@@ -0,0 +1,9 @@
+class ReverseString2
+{
+public static void main(String args[])
+{
+String s1="kumar";
+s1=s1.replace('k','g');
+System.out.println(s1);
+}
+}
\ No newline at end of file
diff --git a/Reversse.class b/Reversse.class
new file mode 100644
index 0000000..59db219
Binary files /dev/null and b/Reversse.class differ
diff --git a/Reversse.java b/Reversse.java
new file mode 100644
index 0000000..4163778
--- /dev/null
+++ b/Reversse.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class Reversse
+{
+public static void main(String args[])
+{
+List<String> l=new ArrayList();
+l.add("sujit");
+l.add("kumar");
+l.add("kushal");
+l.add("water");
+System.out.println(l);
+Collections.reverse(l);
+System.out.println(l);
+
+Integer a[]={10,20,30,40,50};
+System.out.println(Arrays.toString(a));
+Collections.reverse(Arrays.asList(a));
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/Riding1.class b/Riding1.class
new file mode 100644
index 0000000..4bc3d91
Binary files /dev/null and b/Riding1.class differ
diff --git a/Riding1.java b/Riding1.java
new file mode 100644
index 0000000..cf15d28
--- /dev/null
+++ b/Riding1.java
@@ -0,0 +1,27 @@
+class Student
+{
+void eat()
+{
+System.out.println("I am eating now");
+}
+
+}
+
+class teacher extends Student
+{
+void eat()
+{
+super.eat();
+System.out.println("Hello child");
+}
+}
+
+class Riding1
+{
+public static void main(String args[])
+{
+teacher t=new teacher();
+t.eat();
+}
+}
+
diff --git a/Riding2.class b/Riding2.class
new file mode 100644
index 0000000..49c8749
Binary files /dev/null and b/Riding2.class differ
diff --git a/Riding2.java b/Riding2.java
new file mode 100644
index 0000000..101b093
--- /dev/null
+++ b/Riding2.java
@@ -0,0 +1,25 @@
+class Collage
+{
+void play()
+{
+System.out.println("Hello child i am playing there");
+}
+}
+
+class Branch extends Collage
+{
+void play()
+{
+super.play();
+System.out.println("Helllo branch! i can deserve in my life");
+}
+}
+
+class Riding2
+{
+public static void main(String args[])
+{
+Branch b=new Branch();
+b.play();
+}
+}
\ No newline at end of file
diff --git a/Rotate1.class b/Rotate1.class
new file mode 100644
index 0000000..bc7cb60
Binary files /dev/null and b/Rotate1.class differ
diff --git a/Rotate1.java b/Rotate1.java
new file mode 100644
index 0000000..d0c2850
--- /dev/null
+++ b/Rotate1.java
@@ -0,0 +1,14 @@
+import java.util.*;
+class Rotate1
+{
+public static void main(String args[])
+{
+List<String> l=new ArrayList<>();
+l.add("kumar");
+l.add("sujit");
+l.add("gaurav");
+System.out.println(l);
+Collections.rotate(l,1);
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/Rotate2.class b/Rotate2.class
new file mode 100644
index 0000000..120a513
Binary files /dev/null and b/Rotate2.class differ
diff --git a/Rotate2.java b/Rotate2.java
new file mode 100644
index 0000000..d9dd6a7
--- /dev/null
+++ b/Rotate2.java
@@ -0,0 +1,11 @@
+import java.util.*;
+class Rotate2
+{
+public static void main(String args[])
+{
+Integer a[]={10,20,30,70};
+System.out.println(Arrays.toString(a));
+Collections.rotate(Arrays.asList(a),2);
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/RotateArray.class b/RotateArray.class
new file mode 100644
index 0000000..698d469
Binary files /dev/null and b/RotateArray.class differ
diff --git a/RotateArray.java b/RotateArray.java
new file mode 100644
index 0000000..c4f6b27
--- /dev/null
+++ b/RotateArray.java
@@ -0,0 +1,33 @@
+import java.util.*;
+class RotateArray
+{
+static void leftRotate(int a[],int d,int n)
+{
+for(int i=0;i<d;i++)
+{
+rotate(a,n);
+}
+}
+
+static void rotate(int a[],int n)
+{
+int temp=a[0];
+int i;
+for(i=0;i<n-1;i++)
+{
+a[i]=a[i+1];
+}
+a[i]=temp;
+}
+
+public static void main(String args[])
+{
+Scanner sc=new Scanner(System.in);
+int a[]={1,2,3,4,5};
+System.out.println("Enter the number");
+int k=sc.nextInt();
+int n=a.length;
+leftRotate(a,k,n);
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/RunTime.class b/RunTime.class
new file mode 100644
index 0000000..b5d7e8f
Binary files /dev/null and b/RunTime.class differ
diff --git a/RunTime.java b/RunTime.java
new file mode 100644
index 0000000..c121fbd
--- /dev/null
+++ b/RunTime.java
@@ -0,0 +1,36 @@
+class sujit
+{
+void eat()
+{
+System.out.println("I am eating");
+}
+
+void dance()
+{
+System.out.println("hello i gonna dance");
+}
+}
+
+class  gaurav extends sujit
+{
+void eat()
+{
+System.out.println("i am eating in child");
+}
+
+void dance()
+{
+System.out.println("i am doing dance");
+}
+}
+
+class RunTime
+{
+public static void main(String args[])
+{
+gaurav g=new gaurav();
+g.dance();
+sujit s=new sujit();
+s.dance();
+}
+}
\ No newline at end of file
diff --git a/Search3.class b/Search3.class
new file mode 100644
index 0000000..a344acb
Binary files /dev/null and b/Search3.class differ
diff --git a/Search3.java b/Search3.java
new file mode 100644
index 0000000..ebda23f
--- /dev/null
+++ b/Search3.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class Search3
+{
+public static void main(String args[])
+{
+ArrayList<Integer> l=new ArrayList<>();
+l.add(10);
+l.add(20);
+l.add(24);
+l.add(30);
+l.add(40);
+l.add(20);
+l.add(24);
+System.out.println(l);
+
+int index=Collections.binarySearch(l,24,Collections.reverseOrder());
+System.out.println(index);
+}
+}
\ No newline at end of file
diff --git a/SearchData.class b/SearchData.class
new file mode 100644
index 0000000..44164f7
Binary files /dev/null and b/SearchData.class differ
diff --git a/SearchData.java b/SearchData.java
new file mode 100644
index 0000000..8bc399b
--- /dev/null
+++ b/SearchData.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class SearchData
+{
+public static void main(String args[])
+{
+ArrayList<Integer> l=new ArrayList<>();
+l.add(10);
+l.add(20);
+l.add(30);
+l.add(40);
+System.out.println(l);
+int index=Collections.binarySearch(l,35);
+System.out.println(index);
+int x=Collections.binarySearch(l,40);
+System.out.println(x);
+
+Integer a[]={12,13,22,11,15};
+int k=Collections.binarySearch(Arrays.asList(a),11);
+}
+}
\ No newline at end of file
diff --git a/Second.class b/Second.class
new file mode 100644
index 0000000..ff70841
Binary files /dev/null and b/Second.class differ
diff --git a/Second.java b/Second.java
new file mode 100644
index 0000000..d9455c6
--- /dev/null
+++ b/Second.java
@@ -0,0 +1,10 @@
+import java.time.*;
+class Second
+{
+public static void main(String args[])
+{
+Duration d=Duration.ofSeconds(2123);
+System.out.println(d);
+System.out.println(d.getSeconds());
+}
+}
\ No newline at end of file
diff --git a/Second1.class b/Second1.class
new file mode 100644
index 0000000..feef23c
Binary files /dev/null and b/Second1.class differ
diff --git a/Second1.java b/Second1.java
new file mode 100644
index 0000000..79924ed
--- /dev/null
+++ b/Second1.java
@@ -0,0 +1,10 @@
+import java.time.*;
+class Second1
+{
+public static void main(String args[])
+{
+Duration d=Duration.ofSeconds(2345);
+System.out.println(d);
+System.out.println(d.getSeconds());
+}
+}
\ No newline at end of file
diff --git a/Segment.class b/Segment.class
new file mode 100644
index 0000000..3019f0d
Binary files /dev/null and b/Segment.class differ
diff --git a/Segment.java b/Segment.java
new file mode 100644
index 0000000..cd155c2
--- /dev/null
+++ b/Segment.java
@@ -0,0 +1,16 @@
+class Segment
+{
+static int countNumber(String s)
+{
+if(s==null || s.trim().length()==0)
+return 0;
+
+String str[]=s.trim().split("\\s+[,&]");
+return str.length;
+}
+public static void main(String args[])
+{
+String s="Haii,dud how are you";
+System.out.println(countNumber(s));
+}
+}
\ No newline at end of file
diff --git a/Selection1.class b/Selection1.class
new file mode 100644
index 0000000..dba2ddf
Binary files /dev/null and b/Selection1.class differ
diff --git a/Selection1.java b/Selection1.java
new file mode 100644
index 0000000..b5e0b41
--- /dev/null
+++ b/Selection1.java
@@ -0,0 +1,24 @@
+import java.util.*;
+class Selection1
+{
+public static void main(String args[])
+{
+int a[]={10,2,1,3,5,4,6};
+int n=a.length;
+for(int i=0;i<n;i++)
+{
+int min=i;
+for(int j=i;j<n;j++)
+{
+if(a[j]<a[min])
+{
+min=j;
+}
+}
+int temp=a[i];
+a[i]=a[min];
+a[min]=temp;
+}
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/Selection2.class b/Selection2.class
new file mode 100644
index 0000000..dd4396d
Binary files /dev/null and b/Selection2.class differ
diff --git a/Selection2.java b/Selection2.java
new file mode 100644
index 0000000..5da5987
--- /dev/null
+++ b/Selection2.java
@@ -0,0 +1,24 @@
+import java.util.*;
+class Selection2
+{
+public static void main(String args[])
+{
+int a[]={2,1,3,4,5,3,6};
+int n=a.length;
+for(int i=0;i<a.length;i++)
+{
+int min=i;
+for(int j=i;j<n;j++)
+{
+if(a[j]<a[min])
+{
+min=j;
+}
+}
+int temp=a[i];
+a[i]=a[min];
+a[min]=temp;
+}
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/SelectionSort1.class b/SelectionSort1.class
new file mode 100644
index 0000000..e9e8633
Binary files /dev/null and b/SelectionSort1.class differ
diff --git a/SelectionSort1.java b/SelectionSort1.java
new file mode 100644
index 0000000..b3745c1
--- /dev/null
+++ b/SelectionSort1.java
@@ -0,0 +1,24 @@
+import java.util.*;
+class SelectionSort1
+{
+public static void main(String args[])
+{
+int a[]={5,4,3,1,2};
+int n=a.length;
+for(int i=0;i<n-1;i++)
+{
+int min=i;
+for(int j=i;j<n;j++)
+{
+if(a[j]<a[min])
+{
+min=j;
+}
+}
+int temp=a[min];
+a[min]=a[i];
+a[i]=temp;
+}
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/Sender.class b/Sender.class
new file mode 100644
index 0000000..4c99047
Binary files /dev/null and b/Sender.class differ
diff --git a/Serial.class b/Serial.class
new file mode 100644
index 0000000..5444e97
Binary files /dev/null and b/Serial.class differ
diff --git a/Serial.java b/Serial.java
new file mode 100644
index 0000000..c277817
--- /dev/null
+++ b/Serial.java
@@ -0,0 +1,32 @@
+import java.io.*;
+class Serial implements Serializable
+{
+String name;
+Serial(String name)
+{
+this.name=name;
+}
+public static void main(String args[])
+{
+try
+{
+Serial s=new Serial("kumar");
+FileOutputStream file=new FileOutputStream("gaurav.txt");
+ObjectOutputStream obj=new ObjectOutputStream(file);
+obj.writeObject(s);
+
+FileInputStream f=new FileInputStream("gaurav.txt");
+ObjectInputStream ob=new ObjectInputStream(f);
+Serial k=(Serial)ob.readObject();
+System.out.println(k.name);
+
+file.close();
+obj.close();
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+
+}
+}
\ No newline at end of file
diff --git a/Serial1.class b/Serial1.class
new file mode 100644
index 0000000..ed81264
Binary files /dev/null and b/Serial1.class differ
diff --git a/Serial1.java b/Serial1.java
new file mode 100644
index 0000000..720eeca
--- /dev/null
+++ b/Serial1.java
@@ -0,0 +1,32 @@
+import java.io.*;
+class Serial1 implements Serializable
+{
+String Collage;
+Serial1(String Collage)
+{
+this.Collage=Collage;
+}
+public static void main(String args[])
+{
+try
+{
+Serial1 s=new Serial1("Nalanda");
+FileOutputStream f=new FileOutputStream("nit.txt");
+ObjectOutputStream o=new ObjectOutputStream(f);
+o.writeObject(s);
+
+FileInputStream file=new FileInputStream("nit.txt");
+ObjectInputStream ob=new ObjectInputStream(file);
+Serial1 k=(Serial1)ob.readObject();
+System.out.println(k.Collage);
+
+f.close();
+o.close();
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+
+}
+}
\ No newline at end of file
diff --git a/Serialize1.class b/Serialize1.class
new file mode 100644
index 0000000..4f6486f
Binary files /dev/null and b/Serialize1.class differ
diff --git a/Serialize1.java b/Serialize1.java
new file mode 100644
index 0000000..c06ba00
--- /dev/null
+++ b/Serialize1.java
@@ -0,0 +1,32 @@
+import java.io.*;
+class Serialize1 implements Serializable
+{
+String name;
+Serialize1(String name)
+{
+this.name=name;
+}
+
+public static void main(String args[])
+{
+try
+{
+Serialize1 s=new Serialize1("kushal");
+FileOutputStream file=new FileOutputStream("viko.txt");
+ObjectOutputStream ob=new ObjectOutputStream(file);
+ob.writeObject(s);
+
+FileInputStream f=new FileInputStream("viko.txt");
+ObjectInputStream o=new ObjectInputStream(f);
+s=(Serialize1)o.readObject();
+System.out.println(s.name);
+ob.close();
+file.close(); 
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+
+}
+}
\ No newline at end of file
diff --git a/Serialize5.class b/Serialize5.class
new file mode 100644
index 0000000..5f84a07
Binary files /dev/null and b/Serialize5.class differ
diff --git a/Serialize5.java b/Serialize5.java
new file mode 100644
index 0000000..6f9508c
--- /dev/null
+++ b/Serialize5.java
@@ -0,0 +1,35 @@
+import java.io.*;
+class Serialize5 implements Serializable
+{
+String name;
+Serialize5(String name)
+{
+this.name=name;
+}
+public static void main(String args[])
+{
+try
+{
+Serialize5 s=new Serialize5("gaurav");
+FileOutputStream file=new FileOutputStream("prem.txt");
+ObjectOutputStream obj=new ObjectOutputStream(file);
+obj.writeObject(s);
+
+FileInputStream f=new FileInputStream("prem.txt");
+ObjectInputStream ob=new ObjectInputStream(f);
+s=(Serialize5)ob.readObject();
+System.out.println(s.name);
+obj.close();
+file.close();
+
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+
+}
+}
+
+
+
diff --git a/SetClass.class b/SetClass.class
new file mode 100644
index 0000000..f6f6d4a
Binary files /dev/null and b/SetClass.class differ
diff --git a/SetClass.java b/SetClass.java
new file mode 100644
index 0000000..52b4faf
--- /dev/null
+++ b/SetClass.java
@@ -0,0 +1,23 @@
+import java.util.*;
+class SetClass
+{
+public static void main(String args[])
+{
+Set<Integer> set=new HashSet<>();
+set.add(10);
+set.add(12);
+set.add(13);
+set.add(14);
+System.out.println("Set1 is :"+set);
+
+Set<Integer> set1=new HashSet<>();
+set1.add(12);
+set1.add(10);
+set1.add(11);
+set1.add(1);
+System.out.println("Set2 is :"+set1);
+
+set.addAll(set1);
+System.out.println("The value is:"+set);
+}
+}
\ No newline at end of file
diff --git a/SetInter.class b/SetInter.class
new file mode 100644
index 0000000..f4f25ca
Binary files /dev/null and b/SetInter.class differ
diff --git a/SetInter.java b/SetInter.java
new file mode 100644
index 0000000..f415f57
--- /dev/null
+++ b/SetInter.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class SetInter
+{
+public static void main(String args[])
+{
+Set<Integer> set=new HashSet<>();
+set.add(10);
+set.add(11);
+set.add(12);
+set.add(13);
+Set<Integer> set1=new HashSet<>();
+set1.add(10);
+set1.add(11);
+set1.add(12);
+set1.add(1);
+set.retainAll(set1);
+System.out.println("the intersection is:"+set);
+
+}
+}
\ No newline at end of file
diff --git a/SetIntern.class b/SetIntern.class
new file mode 100644
index 0000000..aab7357
Binary files /dev/null and b/SetIntern.class differ
diff --git a/SetIntern.java b/SetIntern.java
new file mode 100644
index 0000000..90ea49e
--- /dev/null
+++ b/SetIntern.java
@@ -0,0 +1,14 @@
+import java.util.*;
+enum gfg
+{
+JAVA,PYTHON,CSS,HTML,JAVASCRIPT;
+}
+
+class SetIntern
+{
+public static void main(String args[])
+{
+Set<gfg> s=EnumSet.of(gfg.JAVA,gfg.PYTHON,gfg.CSS,gfg.HTML);
+System.out.println("The set is:"+s);
+}
+}
\ No newline at end of file
diff --git a/SetOfArray.class b/SetOfArray.class
new file mode 100644
index 0000000..5a21b94
Binary files /dev/null and b/SetOfArray.class differ
diff --git a/SetOfArray.java b/SetOfArray.java
new file mode 100644
index 0000000..ec99f81
--- /dev/null
+++ b/SetOfArray.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class SetOfArray
+{
+public static void main(String args[])
+{
+HashSet<Integer> set=new HashSet<>();
+set.add(1);
+set.add(3);
+set.add(4);
+set.add(5);
+System.out.println("HashSet is:"+set);
+
+HashMap<String,String> hs=new HashMap<>();
+hs.put(null,null);
+hs.put("1","gaurav");
+hs.put("2","ankit");
+hs.put("3","sujit");
+System.out.println("Map is:"+hs);
+}
+}
\ No newline at end of file
diff --git a/Shuffle2.class b/Shuffle2.class
new file mode 100644
index 0000000..800f66b
Binary files /dev/null and b/Shuffle2.class differ
diff --git a/Shuffle2.java b/Shuffle2.java
new file mode 100644
index 0000000..47a5656
--- /dev/null
+++ b/Shuffle2.java
@@ -0,0 +1,16 @@
+import java.util.*;
+class Shuffle2
+{
+public static void main(String args[])
+{
+List<String> l=new ArrayList<>();
+l.add("garav");
+l.add("kumar");
+l.add("sujit");
+l.add("kushal");
+System.out.println(l);
+Collections.shuffle(l);
+System.out.println(l);
+
+}
+}
\ No newline at end of file
diff --git a/SimpleDate.class b/SimpleDate.class
new file mode 100644
index 0000000..5d14bec
Binary files /dev/null and b/SimpleDate.class differ
diff --git a/SimpleDate.java b/SimpleDate.java
new file mode 100644
index 0000000..ef9ed8c
--- /dev/null
+++ b/SimpleDate.java
@@ -0,0 +1,19 @@
+import java.util.*;
+import java.text.*;
+class SimpleDate
+{
+
+static String convertDateToString(String date)
+{
+DateFormat df=new SimpleDateFormat(date);
+Date today=Calendar.getInstance().getTime();
+String s= df.format(today);
+return s;
+}
+
+public static void main(String args[])
+{
+String date="2021-02-20";
+System.out.println(convertDateToString(date));
+}
+}
\ No newline at end of file
diff --git a/Single3.class b/Single3.class
new file mode 100644
index 0000000..858ccec
Binary files /dev/null and b/Single3.class differ
diff --git a/Single3.java b/Single3.java
new file mode 100644
index 0000000..5c45b09
--- /dev/null
+++ b/Single3.java
@@ -0,0 +1,16 @@
+import java.util.*;
+class Single3
+{
+public static void main(String args[])
+{
+List<String> l=new ArrayList<>();
+l.add("sujit");
+l.add("kumar");
+l.add("kushal");
+l.add("kushal");
+l.add("kushal");
+System.out.println(l);
+l.removeAll(Collections.singleton("kushal"));
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/Singleton.class b/Singleton.class
new file mode 100644
index 0000000..11502ac
Binary files /dev/null and b/Singleton.class differ
diff --git a/Singleton.java b/Singleton.java
new file mode 100644
index 0000000..6ea8175
--- /dev/null
+++ b/Singleton.java
@@ -0,0 +1,14 @@
+import java.util.*;
+class Singleton
+{
+public static void main(String args[])
+{
+List<String> l=new ArrayList<>();
+l.add("sujit");
+l.add("kumar");
+l.add("sujit");
+l.add("gaurav");
+l.removeAll(Collections.singleton("sujit"));
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/SmallestAndBiggest.class b/SmallestAndBiggest.class
new file mode 100644
index 0000000..f80d6fa
Binary files /dev/null and b/SmallestAndBiggest.class differ
diff --git a/SmallestAndBiggest.java b/SmallestAndBiggest.java
new file mode 100644
index 0000000..a9e5efb
--- /dev/null
+++ b/SmallestAndBiggest.java
@@ -0,0 +1,63 @@
+class SmallestAndBiggest
+{
+static void palindrome(String word[])
+{
+int n=word.length;
+int count=0;
+String small="",biggest="";
+
+for(int i=0;i<n;i++)
+{
+if(checkPalin(word[i]))
+{
+count++;
+if(count==1)
+{
+small=biggest=word[i];
+}
+else
+{
+if(word[i].length()<small.length())
+{
+small=word[i];
+}
+
+if(word[i].length()>biggest.length())
+{
+biggest=word[i];
+}
+}
+}
+}
+if(count==0)
+{
+System.out.println("Not palindrome");
+}
+else
+{
+System.out.println("Smallest="+small);
+System.out.println("Biggest="+biggest);
+}
+}
+
+static boolean checkPalin(String s)
+{
+int n=s.length();
+s=s.toLowerCase();
+for(int i=0;i<n;i++,n--)
+{
+if(s.charAt(i)!=s.charAt(n-1))
+{
+return false;
+}
+}
+return true;
+}
+public static void main(String args[])
+{
+String s="hello wow what i ahve to do madam";
+String word[]=s.split(" ");
+System.out.println("Inputed String is:"+s);
+palindrome(word);
+}
+}
\ No newline at end of file
diff --git a/SmallestPositive.class b/SmallestPositive.class
new file mode 100644
index 0000000..eb5a7be
Binary files /dev/null and b/SmallestPositive.class differ
diff --git a/SmallestPositive.java b/SmallestPositive.java
new file mode 100644
index 0000000..6edc55f
--- /dev/null
+++ b/SmallestPositive.java
@@ -0,0 +1,23 @@
+class SmallestPositive
+{
+public static void main(String args[])
+{
+int a[]={2,3,4};
+int t=1;
+int sum=0;
+for(int i=0;i<a.length;i++)
+{
+if(a[i]<=t)
+{
+sum+=a[i];
+t=sum+1;
+}
+else
+{
+System.out.println(t);
+System.exit(0);
+}
+}
+System.out.println("the value is:"+t);
+}
+}
\ No newline at end of file
diff --git a/Sort$Node.class b/Sort$Node.class
new file mode 100644
index 0000000..cc22b4a
Binary files /dev/null and b/Sort$Node.class differ
diff --git a/Sort.class b/Sort.class
new file mode 100644
index 0000000..b52f374
Binary files /dev/null and b/Sort.class differ
diff --git a/Sort.java b/Sort.java
new file mode 100644
index 0000000..ccec580
--- /dev/null
+++ b/Sort.java
@@ -0,0 +1,76 @@
+class Sort
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void sortList()
+{
+Node temp=head;
+while(temp!=null)
+{
+Node prev=temp;
+while(prev!=null)
+{
+if(temp.data>prev.data)
+{
+int x=temp.data;
+temp.data=prev.data;
+prev.data=x;
+prev=prev.next;
+}
+else
+{
+prev=prev.next;
+}
+}
+temp=temp.next;
+}
+}
+
+public static void main(String args[])
+{
+Sort s=new Sort();
+s.append(4);
+s.append(2);
+s.append(1);
+s.append(3);
+s.print();
+s.sortList();
+s.print();
+}
+}
\ No newline at end of file
diff --git a/SortArray.class b/SortArray.class
new file mode 100644
index 0000000..63c019f
Binary files /dev/null and b/SortArray.class differ
diff --git a/SortArray.java b/SortArray.java
new file mode 100644
index 0000000..e14730f
--- /dev/null
+++ b/SortArray.java
@@ -0,0 +1,11 @@
+import java.util.*;
+class SortArray
+{
+public static void main(String args[])
+{
+String a[]={"sujit","kumar","gaurav","aman"};
+Arrays.sort(a);
+
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/SortByBranch.class b/SortByBranch.class
new file mode 100644
index 0000000..42fa8d8
Binary files /dev/null and b/SortByBranch.class differ
diff --git a/SortedArray.class b/SortedArray.class
new file mode 100644
index 0000000..f979e8e
Binary files /dev/null and b/SortedArray.class differ
diff --git a/SortedArray.java b/SortedArray.java
new file mode 100644
index 0000000..a17847d
--- /dev/null
+++ b/SortedArray.java
@@ -0,0 +1,37 @@
+import java.util.*;
+class SortedArray
+{
+static void merge(int a[],int b[])
+{
+int j=0;
+int i=0;
+while(i<a.length)
+{
+Arrays.sort(b);
+if(a[i]<b[j])
+i++;
+
+else
+{
+int temp=a[i];
+a[i]=b[j];
+b[j]=temp;
+i++;
+}
+}
+
+Arrays.sort(a);
+for(int k=0;k<b.length;k++)
+{
+a[i]=b[k];
+i++;
+}
+System.out.println(Arrays.toString(a));
+}
+public static void main(String args[])
+{
+int a[]={1,4,7,8,9};
+int b[]={2,5,6,7};
+merge(a,b);
+}
+}
diff --git a/SortedMap1.class b/SortedMap1.class
new file mode 100644
index 0000000..befac3d
Binary files /dev/null and b/SortedMap1.class differ
diff --git a/SortedMap1.java b/SortedMap1.java
new file mode 100644
index 0000000..14a1bf3
--- /dev/null
+++ b/SortedMap1.java
@@ -0,0 +1,18 @@
+import java.util.*;
+class SortedMap1
+{
+public static void main(String args[])
+{
+SortedMap<Integer,String> sm=new TreeMap<>();
+sm.put(3,"Gaurav");
+sm.put(4,"Ankit");
+sm.put(1,"vikash");
+sm.put(2,"kushal");
+System.out.println("SortedMap is:"+sm);
+for(Map.Entry<Integer,String> map:sm.entrySet())
+{
+System.out.print(map.getKey()+":");
+System.out.println(map.getValue());
+}
+}
+}
\ No newline at end of file
diff --git a/SortedMap3.class b/SortedMap3.class
new file mode 100644
index 0000000..fd3db34
Binary files /dev/null and b/SortedMap3.class differ
diff --git a/SortedMap3.java b/SortedMap3.java
new file mode 100644
index 0000000..da83045
--- /dev/null
+++ b/SortedMap3.java
@@ -0,0 +1,18 @@
+import java.util.*;
+class SortedMap3
+{
+public static void main(String args[])
+{
+SortedMap<String,String> map=new TreeMap<String,String>();
+map.put("gaurav","1");
+map.put("kumar","2");
+map.put("sujit","4");
+map.put("kushal","3");
+System.out.println("Map is:"+map);
+map.remove("gaurav");
+System.out.println(map);
+System.out.println(map.firstKey());
+System.out.println(map.lastKey());
+System.out.println(map.containsKey("kumar"));
+}
+}
\ No newline at end of file
diff --git a/Square.class b/Square.class
new file mode 100644
index 0000000..045c640
Binary files /dev/null and b/Square.class differ
diff --git a/Stack.java b/Stack.java
new file mode 100644
index 0000000..1d9e427
--- /dev/null
+++ b/Stack.java
@@ -0,0 +1,9 @@
+import java.util.*;
+class Stack 
+{
+public static void main(String args[])
+{
+Stack<Integer> stack=new Stack<>();
+stack.push(10);
+}
+}
\ No newline at end of file
diff --git a/Stack1.java b/Stack1.java
new file mode 100644
index 0000000..38c1390
--- /dev/null
+++ b/Stack1.java
@@ -0,0 +1,9 @@
+import java.util.*;
+class Stack1
+{
+public static void main(String args[])
+{
+Stack stack=new Stack();
+stack.push(10);
+}
+}
\ No newline at end of file
diff --git a/Star.class b/Star.class
new file mode 100644
index 0000000..9430bbd
Binary files /dev/null and b/Star.class differ
diff --git a/Star.java b/Star.java
new file mode 100644
index 0000000..1766412
--- /dev/null
+++ b/Star.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class Star
+{
+public static void main(String args[])
+{
+Scanner sc=new Scanner(System.in);
+System.out.println("Enter the number");
+int n=sc.nextInt();
+
+for(int i=1;i<=n;i++)
+{
+for(int j=1;j<=i;j++)
+{
+System.out.print("*");
+}
+System.out.println(" ");
+System.out.println();
+}
+}
+}
\ No newline at end of file
diff --git a/Star1.class b/Star1.class
new file mode 100644
index 0000000..062a60a
Binary files /dev/null and b/Star1.class differ
diff --git a/Star1.java b/Star1.java
new file mode 100644
index 0000000..4940f3d
--- /dev/null
+++ b/Star1.java
@@ -0,0 +1,27 @@
+class Star1
+{
+public static void main(String args[])
+{
+int n=5;
+int row=2*n-1;
+for(int i=1;i<=row;i++)
+{
+if(i<=n)
+{
+for(int j=1;j<=i;j++)
+{
+System.out.print("*");
+}
+}
+else
+{
+for(int k=1;k<=row-i+1;k++)
+{
+System.out.print("*");
+}
+}
+System.out.println(" ");
+System.out.println();
+}
+}
+}
\ No newline at end of file
diff --git a/StaticAndNOn.class b/StaticAndNOn.class
new file mode 100644
index 0000000..0a1cc83
Binary files /dev/null and b/StaticAndNOn.class differ
diff --git a/StaticAndNon.java b/StaticAndNon.java
new file mode 100644
index 0000000..f6d9501
--- /dev/null
+++ b/StaticAndNon.java
@@ -0,0 +1,32 @@
+class Outer
+{
+static String s="kumar";
+static class nestedClass
+{
+public void message()
+{
+System.out.println("The value is:"+s);
+}
+}
+
+class InstanceClass
+{
+public void display()
+{
+System.out.println("My name is:"+s);
+}
+}
+
+}
+
+class StaticAndNon
+{
+public static void main(String args[])
+{
+Outer.nestedClass s=new Outer.nestedClass();
+s.message();
+
+Outer.InstanceClass s2=new Outer().new InstanceClass();
+s2.display();
+}
+}
\ No newline at end of file
diff --git a/StreamArray.class b/StreamArray.class
new file mode 100644
index 0000000..d79cbc4
Binary files /dev/null and b/StreamArray.class differ
diff --git a/StreamArray.java b/StreamArray.java
new file mode 100644
index 0000000..cdc9de8
--- /dev/null
+++ b/StreamArray.java
@@ -0,0 +1,16 @@
+import java.util.stream.*;
+import java.util.*;
+class StreamArray
+{
+static Set<Integer> findDuplicate(Stream<Integer> s)
+{
+Set<Integer> set=new HashSet<>();
+
+return s.filter(n->!set.add(n)).collect(Collectors.toSet());
+}
+public static void main(String args[])
+{
+Stream<Integer> s=Stream.of(12,1,2,12,10,10);
+System.out.println(findDuplicate(s));
+}
+}
\ No newline at end of file
diff --git a/StringJoin1.class b/StringJoin1.class
new file mode 100644
index 0000000..9fb7146
Binary files /dev/null and b/StringJoin1.class differ
diff --git a/StringJoin1.java b/StringJoin1.java
new file mode 100644
index 0000000..5289e19
--- /dev/null
+++ b/StringJoin1.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class StringJoin1
+{
+public static void main(String args[])
+{
+ArrayList<String> a=new ArrayList<>();
+a.add("gaurav");
+a.add("kumar");
+a.add("sujit");
+a.add("kushal");
+StringJoiner st=new StringJoiner(",");
+st.add(a.get(0)).add(a.get(1));
+System.out.println(st);
+System.out.println(st.length());
+
+StringJoiner st1=new StringJoiner(":");
+st1.add(a.get(2)).add(a.get(3));
+System.out.println(st1);
+}
+}
\ No newline at end of file
diff --git a/StringJoiner1.class b/StringJoiner1.class
new file mode 100644
index 0000000..2134f62
Binary files /dev/null and b/StringJoiner1.class differ
diff --git a/StringJoiner1.java b/StringJoiner1.java
new file mode 100644
index 0000000..c06c439
--- /dev/null
+++ b/StringJoiner1.java
@@ -0,0 +1,23 @@
+import java.util.*;
+class StringJoiner1
+{
+public static void main(String args[])
+{
+ArrayList<String> a=new ArrayList<>();
+a.add("gaurav");
+a.add("kumar");
+a.add("sujit");
+a.add("kushal");
+
+StringJoiner st=new StringJoiner(",");
+st.add(a.get(0)).add(a.get(1));
+System.out.println("The first StringJoiner is:"+st);
+System.out.println("Lenght is:"+st.length());
+
+StringJoiner st1=new StringJoiner(":");
+st1.add(a.get(2)).add(a.get(3));
+
+System.out.println("StringJoiner is:"+st1);
+System.out.println("Length is:"+st1.length());
+}
+}
diff --git a/StringPalin.class b/StringPalin.class
new file mode 100644
index 0000000..fb95031
Binary files /dev/null and b/StringPalin.class differ
diff --git a/StringPalin.java b/StringPalin.java
new file mode 100644
index 0000000..75d6262
--- /dev/null
+++ b/StringPalin.java
@@ -0,0 +1,36 @@
+class StringPalin
+{
+static boolean checkPalin(String s)
+{
+s=s.toLowerCase();
+boolean f=false;
+int i=0;
+int j=s.length()-1;
+while(i<=j)
+{
+if(s.charAt(i)==s.charAt(j))
+{
+i++;
+j--;
+f=true;
+}
+else
+{
+return f;
+}
+}
+return f;
+}
+public static void main(String args[])
+{
+String s="MaDam";
+if(checkPalin(s))
+{
+System.out.println("The String is palindrome:");
+}
+else
+{
+System.out.println("Not palindrome:");
+}
+}
+}
\ No newline at end of file
diff --git a/StringPool.class b/StringPool.class
new file mode 100644
index 0000000..c483873
Binary files /dev/null and b/StringPool.class differ
diff --git a/StringPool.java b/StringPool.java
new file mode 100644
index 0000000..51ab123
--- /dev/null
+++ b/StringPool.java
@@ -0,0 +1,17 @@
+class StringPool
+{
+public static void main(String args[])
+{
+String s1="gaurav";
+String s2="gaurav";
+System.out.println(s1.equals(s2));
+System.out.println(s1==s2);
+
+String s3=new String("kushal");
+String s4=new String("kushal"); 
+System.out.println(s3.equals(s4));
+System.out.println(s3==s4);
+
+System.out.println(s3.compareTo(s2));
+}
+}
\ No newline at end of file
diff --git a/StringToken.class b/StringToken.class
new file mode 100644
index 0000000..28f9a1a
Binary files /dev/null and b/StringToken.class differ
diff --git a/StringToken.java b/StringToken.java
new file mode 100644
index 0000000..d3eb958
--- /dev/null
+++ b/StringToken.java
@@ -0,0 +1,28 @@
+import java.util.*;
+class StringToken
+{
+public static void main(String args[])
+{
+StringTokenizer st=new StringTokenizer("hello how are you"," ");
+while(st.hasMoreTokens())
+{
+System.out.println(st.nextToken());
+}
+
+StringTokenizer st1=new StringTokenizer("Hello:kumar:how:are:you",":");
+System.out.println("Second token is:");
+while(st1.hasMoreTokens())
+{
+System.out.println(st1.nextToken());
+}
+
+StringTokenizer st2=new StringTokenizer("java:python:javascript:",":",true);
+System.out.println("the third StringTokenizer is:");
+System.out.println(st2.countTokens());
+while(st2.hasMoreTokens())
+{
+System.out.println(st2.nextToken());
+}
+
+}
+}
\ No newline at end of file
diff --git a/StringToken1.class b/StringToken1.class
new file mode 100644
index 0000000..a7f1df3
Binary files /dev/null and b/StringToken1.class differ
diff --git a/StringToken1.java b/StringToken1.java
new file mode 100644
index 0000000..1a941a2
--- /dev/null
+++ b/StringToken1.java
@@ -0,0 +1,14 @@
+import java.util.*;
+class StringToken1
+{
+public static void main(String args[])
+{
+StringTokenizer st1=new StringTokenizer("gaurav:sujit:kumar:vikash",":");
+int k=st1.countTokens();
+System.out.println("Number of token is:"+k);
+for(int i=0;i<k;i++)
+{
+System.out.println("tokens at ["+i+"] is " +st1.nextToken());
+}
+}
+}
\ No newline at end of file
diff --git a/StringToken2.class b/StringToken2.class
new file mode 100644
index 0000000..e847ad5
Binary files /dev/null and b/StringToken2.class differ
diff --git a/StringToken2.java b/StringToken2.java
new file mode 100644
index 0000000..a554490
--- /dev/null
+++ b/StringToken2.java
@@ -0,0 +1,13 @@
+import java.util.*;
+class StringToken2
+{
+public static void main(String args[])
+{
+StringTokenizer st=new StringTokenizer("My name is kumar gaurav"," ");
+while(st.hasMoreElements())
+{
+System.out.println(st.nextElement());
+}
+
+}
+}
\ No newline at end of file
diff --git a/String_Buffer.class b/String_Buffer.class
new file mode 100644
index 0000000..91ffc63
Binary files /dev/null and b/String_Buffer.class differ
diff --git a/String_Buffer.java b/String_Buffer.java
new file mode 100644
index 0000000..f663564
--- /dev/null
+++ b/String_Buffer.java
@@ -0,0 +1,16 @@
+class String_Buffer
+{
+public static void main(String args[])
+{
+StringBuffer s=new StringBuffer("kumar");
+int k=s.length();
+System.out.println(s);
+System.out.println(k);
+s.append(" gaurav");
+System.out.println(s);
+s.append(" and sujit kumar");
+s.append(1);
+s.append(2.5);
+System.out.println(s+" Length="+s.length());
+}
+}
\ No newline at end of file
diff --git a/Student$Child.class b/Student$Child.class
new file mode 100644
index 0000000..4554646
Binary files /dev/null and b/Student$Child.class differ
diff --git a/Student$Parent.class b/Student$Parent.class
new file mode 100644
index 0000000..cc66c6e
Binary files /dev/null and b/Student$Parent.class differ
diff --git a/Student.class b/Student.class
new file mode 100644
index 0000000..1fd955d
Binary files /dev/null and b/Student.class differ
diff --git a/Student1.class b/Student1.class
new file mode 100644
index 0000000..3f3a29f
Binary files /dev/null and b/Student1.class differ
diff --git a/Student1.java b/Student1.java
new file mode 100644
index 0000000..e02ae1d
--- /dev/null
+++ b/Student1.java
@@ -0,0 +1,21 @@
+class Student1
+{
+int age;
+String name;
+Student1(int age,String name)
+{
+this.name=name;
+this.age=age;
+}
+
+public String toString()
+{
+return("Name="+this.name+" Age="+this.age);
+}
+
+public static void main(String args[])
+{
+Student1 s=new Student1(12,"Gaurav");
+System.out.println(s.toString());
+}
+}
\ No newline at end of file
diff --git a/Student2.class b/Student2.class
new file mode 100644
index 0000000..d244efc
Binary files /dev/null and b/Student2.class differ
diff --git a/Student2.java b/Student2.java
new file mode 100644
index 0000000..d1b482d
--- /dev/null
+++ b/Student2.java
@@ -0,0 +1,23 @@
+class Student2
+{
+String name;
+Student2(String name)
+{
+this.name=name;
+}
+
+static void swap(Student2 s1,Student2 s2)
+{
+String temp=s1.name;
+s1.name=s2.name;
+s2.name=temp;
+}
+
+public static void main(String args[])
+{
+Student2 s1=new Student2("gaurav");
+Student2 s2=new Student2("sujit");
+swap(s1,s2);
+System.out.println("S1.name="+s1.name+" S2.name="+s2.name);
+}
+}
diff --git a/Student3.class b/Student3.class
new file mode 100644
index 0000000..b07fab1
Binary files /dev/null and b/Student3.class differ
diff --git a/Student3.java b/Student3.java
new file mode 100644
index 0000000..5f27cdf
--- /dev/null
+++ b/Student3.java
@@ -0,0 +1,45 @@
+class Student
+{
+int roll;
+int age;
+Student(int roll,int age)
+{
+this.roll=roll;
+this.age=age;
+}
+
+void print()
+{
+System.out.println("Roll="+roll+" Age="+age);
+}
+}
+
+class Wrapper
+{
+Student s;
+Wrapper(Student s)
+{
+this.s=s;
+}
+}
+
+class Student3
+{
+static void swap(Wrapper w1,Wrapper w2)
+{
+Student temp=w1.s;
+w1.s=w2.s;
+w2.s=temp;
+}
+
+public static void main(String args[])
+{
+Student s1=new Student(10,20);
+Student s2=new Student(7,8);
+Wrapper w1=new Wrapper(s1);
+Wrapper w2=new Wrapper(s2);
+swap(w1,w2);
+w1.s.print();
+w2.s.print();
+}
+}
\ No newline at end of file
diff --git a/Student4.class b/Student4.class
new file mode 100644
index 0000000..749215d
Binary files /dev/null and b/Student4.class differ
diff --git a/Student4.java b/Student4.java
new file mode 100644
index 0000000..91f9542
--- /dev/null
+++ b/Student4.java
@@ -0,0 +1,44 @@
+class Student
+{
+int roll;
+int age;
+Student(int roll,int age)
+{
+this.roll=roll;
+this.age=age;
+}
+
+void print()
+{
+System.out.println("Roll="+roll+"Age="+age);
+}
+}
+
+class wrapper
+{
+Student s;
+wrapper(Student s)
+{
+this.s=s;
+}
+}
+
+class Student4
+{
+static void swap(wrapper w1,wrapper w2)
+{
+Student temp=w1.s;
+w1.s=w2.s;
+w2.s=temp;
+}
+public static void main(String args[])
+{
+Student s1=new Student(20,30);
+Student s2=new Student(100,200);
+wrapper w1=new wrapper(s1);
+wrapper w2=new wrapper(s2);
+swap(w1,w2);
+w1.s.print();
+w2.s.print();
+}
+}
\ No newline at end of file
diff --git a/StudentSort.class b/StudentSort.class
new file mode 100644
index 0000000..dd705f3
Binary files /dev/null and b/StudentSort.class differ
diff --git a/StudentSort.java b/StudentSort.java
new file mode 100644
index 0000000..74e0a9a
--- /dev/null
+++ b/StudentSort.java
@@ -0,0 +1,50 @@
+import java.util.*;
+class Student
+{
+String name;
+int roll;
+Student(String name,int roll)
+{
+this.name=name;
+this.roll=roll;
+}
+
+public String toString()
+{
+return ("name="+this.name+ " and roll="+this.roll);
+}
+}
+
+
+class SortByRoll implements Comparator<Student>
+{
+public int compare(Student a,Student b)
+{
+return a.roll-b.roll;
+}
+}
+class StudentSort
+{
+public static void main(String args[])
+{
+ArrayList<Student> l=new ArrayList<>();
+l.add(new Student("gaurav",153));
+l.add(new Student("aman",121));
+l.add(new Student("kushal",120));
+
+System.out.println(l);
+System.out.println("Unsorted data===============");
+for(int i=0;i<l.size();i++)
+{
+System.out.println(l.get(i));
+}
+
+Comparator c=Collections.reverseOrder(new SortByRoll());
+Collections.sort(l,c);
+System.out.println("Sorted order========");
+for(int i=0;i<l.size();i++)
+{
+System.out.println(l.get(i));
+}
+}
+}
\ No newline at end of file
diff --git a/StudentSort1.class b/StudentSort1.class
new file mode 100644
index 0000000..c099fc2
Binary files /dev/null and b/StudentSort1.class differ
diff --git a/StudentSort1.java b/StudentSort1.java
new file mode 100644
index 0000000..920e298
--- /dev/null
+++ b/StudentSort1.java
@@ -0,0 +1,49 @@
+import java.util.*;
+class Teacher
+{
+String name;
+String branch;
+Teacher(String name,String branch)
+{
+this.name=name;
+this.branch=branch;
+}
+
+public String toString()
+{
+return ("name="+this.name+ " and branch="+this.branch);
+}
+}
+
+
+class SortByBranch implements Comparator<Teacher>
+{
+public int compare(Teacher a,Teacher b)
+{
+return a.branch.compareTo(b.branch);
+}
+}
+
+class StudentSort1
+{
+public static void main(String args[])
+{
+ArrayList<Teacher> l=new ArrayList<>();
+l.add(new Teacher("gaurav","CSE"));
+l.add(new Teacher("sujit","MECH"));
+l.add(new Teacher("kushal","ECE"));
+
+System.out.println("Before Sorted");
+for(int i=0;i<l.size();i++)
+{
+System.out.println(l.get(i));
+}
+
+Collections.sort(l,new SortByBranch());
+System.out.println("Sort By Branch");
+for(int i=0;i<l.size();i++)
+{
+System.out.println(l.get(i));
+}
+}
+}
\ No newline at end of file
diff --git a/Studentt.class b/Studentt.class
new file mode 100644
index 0000000..6e51796
Binary files /dev/null and b/Studentt.class differ
diff --git a/Studentt.java b/Studentt.java
new file mode 100644
index 0000000..49d5163
--- /dev/null
+++ b/Studentt.java
@@ -0,0 +1,14 @@
+class Studentt
+{
+String name="gaurav";
+String lname;
+Studentt()
+{
+lname=name;
+}
+public static void main(String args[])
+{
+Studentt s=new Studentt();
+System.out.println(s.toString());
+}
+}
\ No newline at end of file
diff --git a/Studun.class b/Studun.class
new file mode 100644
index 0000000..904beef
Binary files /dev/null and b/Studun.class differ
diff --git a/Studun.java b/Studun.java
new file mode 100644
index 0000000..0b9168e
--- /dev/null
+++ b/Studun.java
@@ -0,0 +1,43 @@
+class Student
+{
+String name;
+int age;
+String branch;
+Student(String name,int age,String branch)
+{
+this.name=name;
+this.age=age;
+this.branch=branch;
+}
+
+String getName()
+{
+return name;
+}
+
+int getAge()
+{
+return age;
+}
+
+String getBranch()
+{
+return branch;
+}
+
+public String toString()
+{
+return ("Name="+this.getName()+" Age="+this.getAge()+" Branch="+this.getBranch());
+}
+
+
+}
+
+class Studun
+{
+public static void main(String args[])
+{
+Student s=new Student("gaurav",153,"CSE");
+System.out.println(s.toString());
+}
+}
\ No newline at end of file
diff --git a/SubArraySum.class b/SubArraySum.class
new file mode 100644
index 0000000..7767854
Binary files /dev/null and b/SubArraySum.class differ
diff --git a/SubList.class b/SubList.class
new file mode 100644
index 0000000..b9dcd22
Binary files /dev/null and b/SubList.class differ
diff --git a/SubList.java b/SubList.java
new file mode 100644
index 0000000..df98a1b
--- /dev/null
+++ b/SubList.java
@@ -0,0 +1,29 @@
+import java.util.*;
+class SubList
+{
+public static void main(String args[])
+{
+try
+{
+ArrayList<Integer> l=new ArrayList<>();
+l.add(1);
+l.add(2);
+l.add(3);
+l.add(4);
+l.add(5);
+System.out.println(l);
+List<Integer> l1=l.subList(1,3);
+System.out.println(l1);
+}
+catch(IndexOutOfBoundsException e)
+{
+System.out.println(e);
+}
+
+catch(IllegalArgumentException e)
+{
+System.out.println(e);
+}
+
+}
+}
\ No newline at end of file
diff --git a/SubList1.class b/SubList1.class
new file mode 100644
index 0000000..08f00f1
Binary files /dev/null and b/SubList1.class differ
diff --git a/SubList1.java b/SubList1.java
new file mode 100644
index 0000000..35a2a78
--- /dev/null
+++ b/SubList1.java
@@ -0,0 +1,29 @@
+import java.util.*;
+class SubList1
+{
+public static void main(String args[])
+{
+try
+{
+ArrayList<String> l=new ArrayList<>();
+l.add("sujit");
+l.add("kumar");
+l.add("kushal");
+l.add("gaurav");
+System.out.println(l);
+List<String> l1=l.subList(1,3);
+System.out.println(l1);
+}
+
+catch(IndexOutOfBoundsException e)
+{
+System.out.println(e);
+}
+
+catch(IllegalArgumentException e)
+{
+System.out.println(e);
+}
+
+}
+}
\ No newline at end of file
diff --git a/SumToN.class b/SumToN.class
new file mode 100644
index 0000000..58ad790
Binary files /dev/null and b/SumToN.class differ
diff --git a/SumToN.java b/SumToN.java
new file mode 100644
index 0000000..317766e
--- /dev/null
+++ b/SumToN.java
@@ -0,0 +1,13 @@
+class SumToN
+{
+public static void main(String args[])
+{
+int n=5;
+double sum=0;
+for(float i=1;i<=n;i++)
+{
+sum+=1/i;
+}
+System.out.println("The sum of number is:"+sum);
+}
+}
\ No newline at end of file
diff --git a/SumToN1.class b/SumToN1.class
new file mode 100644
index 0000000..4efccaf
Binary files /dev/null and b/SumToN1.class differ
diff --git a/SumToN1.java b/SumToN1.java
new file mode 100644
index 0000000..a0e85da
--- /dev/null
+++ b/SumToN1.java
@@ -0,0 +1,20 @@
+class SumToN1
+{
+public static void main(String args[])
+{
+int n=6;
+float res=0;
+for(float i=1;i<=n;i++)
+{
+if(i%2==0)
+{
+res-=1/i;
+}
+else
+{
+res+=1/i;
+}
+}
+System.out.println("The sum number is:"+res);
+}
+}
\ No newline at end of file
diff --git a/Swap12.class b/Swap12.class
new file mode 100644
index 0000000..e339e51
Binary files /dev/null and b/Swap12.class differ
diff --git a/Swap12.java b/Swap12.java
new file mode 100644
index 0000000..2fc9f98
--- /dev/null
+++ b/Swap12.java
@@ -0,0 +1,28 @@
+class Car
+{
+int no;
+Car(int no)
+{
+this.no=no;
+}
+}
+
+class Swap12
+{
+static void swap(Car c1,Car c2)
+{
+int temp=c1.no;
+c1.no=c2.no;
+c2.no=temp;
+} 
+
+public static void main(String args[])
+{
+Car c1=new Car(2);
+Car c2=new Car(4);
+swap(c1,c2);
+System.out.println("First Car is:"+c1.no);
+System.out.println("Second car is:"+c2.no); 
+}
+
+}
\ No newline at end of file
diff --git a/Swap13.class b/Swap13.class
new file mode 100644
index 0000000..ff4b400
Binary files /dev/null and b/Swap13.class differ
diff --git a/Swap13.java b/Swap13.java
new file mode 100644
index 0000000..044ecf1
--- /dev/null
+++ b/Swap13.java
@@ -0,0 +1,43 @@
+class Car
+{
+int no;
+int brake;
+Car(int no,int brake)
+{
+this.no=no;
+this.brake=brake;
+}
+void print()
+{
+System.out.println("No="+no+" Brake="+brake);
+}
+}
+
+class SwapCar
+{
+Car c1;
+SwapCar(Car c1)
+{
+this.c1=c1;
+}
+
+}
+class Swap13
+{
+static void swap(SwapCar c3,SwapCar c4)
+{
+Car temp=c3.c1;
+c3.c1=c4.c1;
+c4.c1=temp;
+}
+public static void main(String args[])
+{
+Car c1=new Car(2,10);
+Car c2=new Car(10,20);
+SwapCar c3=new SwapCar(c1);
+SwapCar c4=new SwapCar(c2);
+swap(c3,c4);
+c3.c1.print();
+c4.c1.print();
+}
+}
\ No newline at end of file
diff --git a/Swap14.java b/Swap14.java
new file mode 100644
index 0000000..de3051a
--- /dev/null
+++ b/Swap14.java
@@ -0,0 +1,45 @@
+class Car
+{
+int no;
+String name;
+Car(int no,String name)
+{
+this.no=no;
+this.name=name;
+}
+
+void print()
+{
+System.out.println("No="+no+" Name "+name);
+}
+}
+
+class Wrapper
+{
+Car c;
+Wrapper(Car c)
+{
+this.c=c;
+}
+
+}
+
+class Swap14
+{
+static void swap(Wrapper w1,Wrapper w2)
+{
+Car temp=w1.c;
+w1.c=w2.c;
+w2.c=temp;
+}
+public static void main(String args[])
+{
+Car c1=new Car(10,"BMW");
+Car c2=new Car(20,"Swift");
+
+Wrapper w1=new Wrapper(c1);
+Wrapper w2=new Wrapper(c2);
+swap(w1,w2);
+w1.c.print();
+w2.c.print();
+}
\ No newline at end of file
diff --git a/SwapCar.class b/SwapCar.class
new file mode 100644
index 0000000..9498192
Binary files /dev/null and b/SwapCar.class differ
diff --git a/SwapObj.class b/SwapObj.class
new file mode 100644
index 0000000..816b2b3
Binary files /dev/null and b/SwapObj.class differ
diff --git a/SwapObj.java b/SwapObj.java
new file mode 100644
index 0000000..efc2d34
--- /dev/null
+++ b/SwapObj.java
@@ -0,0 +1,42 @@
+class Car
+{
+int model,no;
+Car(int model,int no)
+{
+this.model=model;
+this.no=no;
+}
+void print()
+{
+System.out.println("Models="+model+" No="+no);
+}
+}
+
+class wrapper
+{
+Car c;
+wrapper(Car c)
+{
+this.c=c;
+}
+}
+
+class SwapObj
+{
+static void swap(wrapper w1,wrapper w2)
+{
+Car temp=w1.c;
+w1.c=w2.c;
+w2.c=temp;
+}
+public static void main(String args[])
+{
+Car c1=new Car(12,20);
+Car c2=new Car(22,21);
+wrapper w1=new wrapper(c1);
+wrapper w2=new wrapper(c2);
+swap(w1,w2);
+w1.c.print();
+w2.c.print();
+}
+}
\ No newline at end of file
diff --git a/SwapPair1$Node.class b/SwapPair1$Node.class
new file mode 100644
index 0000000..8ddcbae
Binary files /dev/null and b/SwapPair1$Node.class differ
diff --git a/SwapPair1.class b/SwapPair1.class
new file mode 100644
index 0000000..bb0189f
Binary files /dev/null and b/SwapPair1.class differ
diff --git a/SynValue.class b/SynValue.class
new file mode 100644
index 0000000..21044de
Binary files /dev/null and b/SynValue.class differ
diff --git a/SynValue.java b/SynValue.java
new file mode 100644
index 0000000..ae98f92
--- /dev/null
+++ b/SynValue.java
@@ -0,0 +1,43 @@
+class thread
+{
+void getValue()
+{
+for(int i=0;i<3;i++)
+{
+System.out.println(i);
+try
+{
+Thread.sleep(500);
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+}
+}
+}
+
+class ThreadSyn extends Thread
+{
+thread t;
+ThreadSyn(thread t)
+{
+this.t=t;
+}
+public void run()
+{
+t.getValue();
+}
+}
+
+class SynValue
+{
+public static void main(String args[])
+{
+thread t=new thread();
+ThreadSyn t1=new ThreadSyn(t);
+ThreadSyn t2=new ThreadSyn(t);
+t1.start();
+t2.start();
+}
+}
\ No newline at end of file
diff --git a/SynValue1.class b/SynValue1.class
new file mode 100644
index 0000000..31b6d57
Binary files /dev/null and b/SynValue1.class differ
diff --git a/SynValue1.java b/SynValue1.java
new file mode 100644
index 0000000..4a71dd4
--- /dev/null
+++ b/SynValue1.java
@@ -0,0 +1,44 @@
+class first
+{
+synchronized void getValue()
+{
+for(int i=0;i<5;i++)
+{
+System.out.println(i);
+try
+{
+Thread.sleep(500);
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+}
+}
+}
+
+class ThreadSyn extends Thread
+{
+first f;
+ThreadSyn(first f)
+{
+this.f=f;
+}
+public void run()
+{
+f.getValue();
+}
+}
+
+
+class SynValue1
+{
+public static void main(String args[])
+{
+first f=new first();
+ThreadSyn t=new ThreadSyn(f);
+ThreadSyn t1=new ThreadSyn(f);
+t.start();
+t1.start();
+}
+}
diff --git a/Task.class b/Task.class
new file mode 100644
index 0000000..9ac3804
Binary files /dev/null and b/Task.class differ
diff --git a/Teacher12.class b/Teacher12.class
new file mode 100644
index 0000000..af20a73
Binary files /dev/null and b/Teacher12.class differ
diff --git a/Teacher12.java b/Teacher12.java
new file mode 100644
index 0000000..ed373df
--- /dev/null
+++ b/Teacher12.java
@@ -0,0 +1,27 @@
+class Student
+{
+Teacher12 t;
+Student(Teacher12 t)
+{
+this.t=t;
+t.display();
+}
+}
+
+class Teacher12
+{
+Teacher12()
+{
+Student s=new Student(this);
+}
+
+void display()
+{
+System.out.println("hello how are you");
+}
+
+public static void main(String args[])
+{
+Teacher12 t=new Teacher12();
+}
+}
\ No newline at end of file
diff --git a/Test.class b/Test.class
new file mode 100644
index 0000000..8cf016d
Binary files /dev/null and b/Test.class differ
diff --git a/Test.java b/Test.java
new file mode 100644
index 0000000..ede30d3
--- /dev/null
+++ b/Test.java
@@ -0,0 +1,31 @@
+class Test extends Thread
+{
+public static void main(String args[])
+{
+Thread t=Thread.currentThread();
+System.out.println("Current thread is:"+t.getName());
+t.setName("gaurav");
+System.out.println("After chnage the name:"+t.getName());
+System.out.println("Priority is:"+t.getPriority());
+t.setPriority(MAX_PRIORITY);
+System.out.println("After change priority:"+t.getPriority());
+
+ChildThread t1=new ChildThread();
+System.out.println("Child thread is:"+t1.getName());
+System.out.println("Child priority is:"+t1.getPriority());
+t1.setPriority(MIN_PRIORITY);
+System.out.println("Min priority is:"+t1.getPriority());
+t1.start();
+}
+}
+
+class ChildThread extends Thread
+{
+public void run()
+{
+for(int i=0;i<3;i++)
+{
+System.out.println("Main thread");
+}
+}
+}
\ No newline at end of file
diff --git a/ThreadMain1$1.class b/ThreadMain1$1.class
new file mode 100644
index 0000000..0275025
Binary files /dev/null and b/ThreadMain1$1.class differ
diff --git a/ThreadMain1$2.class b/ThreadMain1$2.class
new file mode 100644
index 0000000..5f53604
Binary files /dev/null and b/ThreadMain1$2.class differ
diff --git a/ThreadMain1.class b/ThreadMain1.class
new file mode 100644
index 0000000..44690e2
Binary files /dev/null and b/ThreadMain1.class differ
diff --git a/ThreadMain1.java b/ThreadMain1.java
new file mode 100644
index 0000000..3b5a169
--- /dev/null
+++ b/ThreadMain1.java
@@ -0,0 +1,93 @@
+import java.util.*;
+class ThreadMain1
+{
+public static void main(String arg[])
+{
+System.out.println("\n========================Here I am  handle two Thread communication, Producer and Consumer are Communicate with each About their Product==================="); 
+company c=new company();
+Thread t1=new Thread(new Runnable()
+{
+int i=1;
+public void run()
+{
+while(i<5)
+{
+try
+{
+c.producer();
+i++;
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+}
+}
+});
+
+Thread t2=new Thread(new Runnable()
+{
+int i=1;
+public void run()
+{
+while(i<5)
+{
+try
+{
+c.consumer();
+i++;
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+}
+}
+});
+
+t1.start();
+t2.start();
+}
+}
+
+class company
+{
+Scanner sc=new Scanner(System.in);
+String s;
+public void producer()throws Exception
+{
+synchronized(this)
+{
+System.out.println("\nProducer is started.....");
+Thread.sleep(600);
+System.out.println("What you want to produce");
+s=sc.nextLine();
+System.out.println("You are produced...."+s);
+wait();
+}
+}
+void consumer() throws Exception
+{
+Thread.sleep(1000);
+synchronized(this)
+{
+System.out.println("Consumer is started....");
+Thread.sleep(600);
+System.out.println("Do you want to consumed, press... YES/NO");
+String k=sc.nextLine();
+if(k.toLowerCase().equals("yes"))
+{
+System.out.println("You are consumed.."+s);
+notify();
+Thread.sleep(2000);
+}
+else
+{
+System.out.println("You are not producing anything");
+notify();
+Thread.sleep(2000);
+}
+}
+
+}
+}
diff --git a/ThreadMe$1.class b/ThreadMe$1.class
new file mode 100644
index 0000000..b8bf216
Binary files /dev/null and b/ThreadMe$1.class differ
diff --git a/ThreadMe$2.class b/ThreadMe$2.class
new file mode 100644
index 0000000..2dc5c6b
Binary files /dev/null and b/ThreadMe$2.class differ
diff --git a/ThreadMe$PC.class b/ThreadMe$PC.class
new file mode 100644
index 0000000..4b5397d
Binary files /dev/null and b/ThreadMe$PC.class differ
diff --git a/ThreadMe.class b/ThreadMe.class
new file mode 100644
index 0000000..66fe0e5
Binary files /dev/null and b/ThreadMe.class differ
diff --git a/ThreadMe.java b/ThreadMe.java
new file mode 100644
index 0000000..58db3d8
--- /dev/null
+++ b/ThreadMe.java
@@ -0,0 +1,70 @@
+import java.util.*;
+class ThreadMe
+{
+public static void main(String args[]) throws Exception
+{
+PC pc=new PC();
+Thread t1=new Thread(new Runnable()
+{
+public void run()
+{
+try
+{
+pc.produce();
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+}
+});
+
+Thread t2=new Thread(new Runnable()
+{
+public void run()
+{
+try
+{
+pc.consumer();
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+}
+});
+
+t1.start();
+t2.start();
+
+
+}
+
+static class PC
+{
+void produce() throws Exception
+{
+synchronized(this)
+{
+System.out.println("Producer thread is running...");
+wait();
+System.out.println("Resumed..");
+
+}
+}
+
+void consumer()throws Exception
+{
+Thread.sleep(1000);
+Scanner sc=new Scanner(System.in);
+synchronized(this)
+{
+System.out.println("Waiting for return key...");
+sc.nextLine();
+System.out.println("Return key...");
+notify();
+Thread.sleep(2000);
+}
+}
+}
+}
\ No newline at end of file
diff --git a/ThreadOp.class b/ThreadOp.class
new file mode 100644
index 0000000..a3f153e
Binary files /dev/null and b/ThreadOp.class differ
diff --git a/ThreadOp.java b/ThreadOp.java
new file mode 100644
index 0000000..af566ee
--- /dev/null
+++ b/ThreadOp.java
@@ -0,0 +1,24 @@
+class thread extends Thread
+{
+public void run()
+{
+for(int i=0;i<2;i++)
+{
+System.out.println("Hello Thread-1");
+}
+}
+}
+
+class ThreadOp
+{
+public static void main(String args[])
+{
+thread t=new thread();
+t.start();
+for(int i=0;i<2;i++)
+{
+Thread.yield();
+System.out.println("Hello yeild thread");
+}
+}
+}
\ No newline at end of file
diff --git a/ThreadOp1.class b/ThreadOp1.class
new file mode 100644
index 0000000..46cfc16
Binary files /dev/null and b/ThreadOp1.class differ
diff --git a/ThreadOp1.java b/ThreadOp1.java
new file mode 100644
index 0000000..76de1de
--- /dev/null
+++ b/ThreadOp1.java
@@ -0,0 +1,21 @@
+class MyThread extends Thread
+{
+public void run()
+{
+System.out.println("Hello run whats going on");
+}
+}
+
+class ThreadOp1
+{
+public static void main(String args[])
+{
+MyThread t=new MyThread();
+t.start();
+for(int i=0;i<2;i++)
+{
+Thread.yield();
+System.out.println(Thread.currentThread().getName()+" in control");
+}
+}
+}
diff --git a/ThreadOp2.class b/ThreadOp2.class
new file mode 100644
index 0000000..31863e5
Binary files /dev/null and b/ThreadOp2.class differ
diff --git a/ThreadOp2.java b/ThreadOp2.java
new file mode 100644
index 0000000..f804fe6
--- /dev/null
+++ b/ThreadOp2.java
@@ -0,0 +1,34 @@
+class MyThread implements Runnable
+{
+public void run()
+{
+for(int i=0;i<3;i++)
+{
+System.out.println(Thread.currentThread().getName());
+try
+{
+Thread.sleep(1000);
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+
+}
+
+}
+}
+class ThreadOp2
+{
+public static void main(String args[]) throws Exception
+{
+MyThread t1=new MyThread();
+Thread t2=new Thread(t1);
+t2.start();
+
+Thread.sleep(1000);
+System.out.println("Start Another Thread.........");
+Thread t3=new Thread(t1);
+t3.start();
+}
+}
\ No newline at end of file
diff --git a/ThreadOp4.class b/ThreadOp4.class
new file mode 100644
index 0000000..049df39
Binary files /dev/null and b/ThreadOp4.class differ
diff --git a/ThreadOp4.java b/ThreadOp4.java
new file mode 100644
index 0000000..8cf1250
--- /dev/null
+++ b/ThreadOp4.java
@@ -0,0 +1,26 @@
+class thread implements Runnable
+{
+public void run()
+{
+Thread t=Thread.currentThread();
+System.out.println("Hello team whats going on");
+System.out.println(t.getName());
+System.out.println("Is Alive:"+t.isAlive());
+}
+}
+
+class ThreadOp4
+{
+public static void main(String args[]) throws Exception
+{
+thread t=new thread();
+Thread t1=new Thread(t);
+t1.start();
+
+t1.join(1000);
+System.out.println("Join the thread after 1s");
+System.out.println(t1.getName());
+System.out.println(t1.isAlive());
+
+}
+}
\ No newline at end of file
diff --git a/ThreadSend.class b/ThreadSend.class
new file mode 100644
index 0000000..78f9199
Binary files /dev/null and b/ThreadSend.class differ
diff --git a/ThreadStuff.class b/ThreadStuff.class
new file mode 100644
index 0000000..eebd6d9
Binary files /dev/null and b/ThreadStuff.class differ
diff --git a/ThreadSyn.class b/ThreadSyn.class
new file mode 100644
index 0000000..9e97954
Binary files /dev/null and b/ThreadSyn.class differ
diff --git a/ThreadThree$1.class b/ThreadThree$1.class
new file mode 100644
index 0000000..05b7374
Binary files /dev/null and b/ThreadThree$1.class differ
diff --git a/ThreadThree$2.class b/ThreadThree$2.class
new file mode 100644
index 0000000..259b56c
Binary files /dev/null and b/ThreadThree$2.class differ
diff --git a/ThreadThree.class b/ThreadThree.class
new file mode 100644
index 0000000..cb57f83
Binary files /dev/null and b/ThreadThree.class differ
diff --git a/ThreadThree.java b/ThreadThree.java
new file mode 100644
index 0000000..139bc65
--- /dev/null
+++ b/ThreadThree.java
@@ -0,0 +1,92 @@
+import java.util.*;
+class ThreadThree
+{
+public static void main(String args[])
+{
+company c=new company();
+Thread t1=new Thread(new Runnable()
+{
+public void run()
+{
+int i=1;
+while(i<5)
+{
+try
+{
+c.produce();
+i++;
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+}
+}
+});
+
+Thread t2=new Thread(new Runnable()
+{
+public void run()
+{
+int i=1;
+while(i<5)
+{
+try
+{
+c.consumer();
+i++;
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+}
+}
+});
+
+t1.start();
+t2.start();
+}
+
+}
+
+class company
+{
+String s;
+void produce()throws Exception
+{
+Scanner sc=new Scanner(System.in);
+synchronized(this)
+{
+System.out.println("producer is start...What u wanna to produce");
+s=sc.next();
+System.out.println("You are produced :"+s);
+wait();
+}
+}
+
+void consumer() throws Exception
+{
+Thread.sleep(1000);
+String k;
+Scanner sc=new Scanner(System.in);
+synchronized(this)
+{
+System.out.println("consumer start...Want your permission to running..");
+k=sc.nextLine();
+if(k.equals("yes"))
+{
+System.out.println("You are consumed :"+s);
+notify();
+Thread.sleep(2000);
+}
+else
+{
+System.out.println("You are not consumed anything...");
+notify();
+Thread.sleep(2000);
+}
+
+}
+}
+}
diff --git a/ThreadTwo$1.class b/ThreadTwo$1.class
new file mode 100644
index 0000000..63b7d1f
Binary files /dev/null and b/ThreadTwo$1.class differ
diff --git a/ThreadTwo$2.class b/ThreadTwo$2.class
new file mode 100644
index 0000000..6a7e69f
Binary files /dev/null and b/ThreadTwo$2.class differ
diff --git a/ThreadTwo$PC.class b/ThreadTwo$PC.class
new file mode 100644
index 0000000..fa7d5c5
Binary files /dev/null and b/ThreadTwo$PC.class differ
diff --git a/ThreadTwo.class b/ThreadTwo.class
new file mode 100644
index 0000000..a145597
Binary files /dev/null and b/ThreadTwo.class differ
diff --git a/ThreadTwo.java b/ThreadTwo.java
new file mode 100644
index 0000000..13badc4
--- /dev/null
+++ b/ThreadTwo.java
@@ -0,0 +1,79 @@
+import java.util.*;
+class ThreadTwo
+{
+public static void main(String args[])
+{
+PC pc=new PC();
+Thread t1=new Thread(new Runnable()
+{
+public void run()
+{
+int i=1;
+while(i<5)
+{
+try
+{
+pc.produce();
+Thread.sleep(1000);
+i++;
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+}
+}
+});
+
+Thread t2=new Thread(new Runnable()
+{
+public void run()
+{
+int i=1;
+while(i<5)
+{
+try
+{
+pc.consumer();
+Thread.sleep(1000);
+i++;
+}
+catch(Exception e)
+{
+e.printStackTrace();
+}
+}
+}
+});
+
+t1.start();
+t2.start();
+}
+
+static class PC
+{
+void produce() throws Exception
+{
+synchronized(this)
+{
+System.out.println("Producer is start...");
+wait();
+System.out.println("Consumer Finished...");
+}
+}
+
+void consumer() throws Exception
+{
+Thread.sleep(1000);
+Scanner sc=new Scanner(System.in);
+synchronized(this)
+{
+System.out.println("Consumer want something from u");
+sc.nextLine();
+System.out.println("Key Access");
+notify();
+Thread.sleep(2000);
+}
+}
+}
+}
diff --git a/ThreadValue.class b/ThreadValue.class
new file mode 100644
index 0000000..ab34eb6
Binary files /dev/null and b/ThreadValue.class differ
diff --git a/ThreadValue.java b/ThreadValue.java
new file mode 100644
index 0000000..f7d189c
--- /dev/null
+++ b/ThreadValue.java
@@ -0,0 +1,22 @@
+class Multi
+{
+private int i=0;
+public void increment()
+{
+i++;
+}
+
+int getValue()
+{
+return i;
+}
+}
+class ThreadValue
+{
+public static void main(String args[])
+{
+Multi m=new Multi();
+m.increment();
+System.out.println(m.getValue());
+}
+}
\ No newline at end of file
diff --git a/Time1.class b/Time1.class
new file mode 100644
index 0000000..a5b7401
Binary files /dev/null and b/Time1.class differ
diff --git a/Time1.java b/Time1.java
new file mode 100644
index 0000000..83cd7c7
--- /dev/null
+++ b/Time1.java
@@ -0,0 +1,10 @@
+import java.time.*;
+class Time1
+{
+public static void main(String args[])
+{
+ZoneId z=ZoneId.of("Asia/Kolkata");
+Clock cl=Clock.tickMinutes(z);
+System.out.println(cl.instant());
+}
+}
\ No newline at end of file
diff --git a/Time2.class b/Time2.class
new file mode 100644
index 0000000..de77840
Binary files /dev/null and b/Time2.class differ
diff --git a/Time2.java b/Time2.java
new file mode 100644
index 0000000..7c53194
--- /dev/null
+++ b/Time2.java
@@ -0,0 +1,11 @@
+import java.time.*;
+class Time2
+{
+public static void main(String args[])
+{
+ZoneId z=ZoneId.of("Europe/Paris");
+System.out.println(z);
+Clock c=Clock.tickMinutes(z);
+System.out.println(c.instant());
+}
+}
diff --git a/Time3.class b/Time3.class
new file mode 100644
index 0000000..a23e177
Binary files /dev/null and b/Time3.class differ
diff --git a/Time3.java b/Time3.java
new file mode 100644
index 0000000..27ffeea
--- /dev/null
+++ b/Time3.java
@@ -0,0 +1,11 @@
+import java.time.*;
+class Time3
+{
+public static void main(String args[])
+{
+ZoneId z=ZoneId.of("Asia/Tokyo");
+Clock c=Clock.tickMinutes(z);
+ZonedDateTime t=c.instant().atZone(c.getZone());
+System.out.println(t);
+}
+}
diff --git a/Time4.class b/Time4.class
new file mode 100644
index 0000000..b854456
Binary files /dev/null and b/Time4.class differ
diff --git a/Time4.java b/Time4.java
new file mode 100644
index 0000000..6a1e4f0
--- /dev/null
+++ b/Time4.java
@@ -0,0 +1,11 @@
+import java.time.*;
+class Time4
+{
+public static void main(String args[])
+{
+ZoneId z=ZoneId.of("Asia/Karachi");
+Clock c=Clock.tickMinutes(z);
+ZonedDateTime t=c.instant().atZone(c.getZone());
+System.out.println(t.toString());
+}
+}
diff --git a/Time5.class b/Time5.class
new file mode 100644
index 0000000..87e260a
Binary files /dev/null and b/Time5.class differ
diff --git a/Time5.java b/Time5.java
new file mode 100644
index 0000000..dc1e962
--- /dev/null
+++ b/Time5.java
@@ -0,0 +1,16 @@
+import java.time.*;
+class Time5
+{
+public static void main(String args[])
+{
+Clock c=Clock.systemUTC();
+System.out.println(c);
+ZonedDateTime t=c.instant().atZone(c.getZone());
+System.out.println(t);
+
+ZoneId z=ZoneId.of("Asia/Kolkata");
+Clock base=c.withZone(z);
+ZonedDateTime t1=base.instant().atZone(base.getZone());
+System.out.println(t1.toString());
+}
+}
\ No newline at end of file
diff --git a/TopMaximum.class b/TopMaximum.class
new file mode 100644
index 0000000..b5bc2d1
Binary files /dev/null and b/TopMaximum.class differ
diff --git a/TopMaximum.java b/TopMaximum.java
new file mode 100644
index 0000000..19649f8
--- /dev/null
+++ b/TopMaximum.java
@@ -0,0 +1,27 @@
+import java.util.*;
+class TopMaximum
+{
+public static void main(String args[])
+{
+int a[]={32,12,33,45,67,44};
+int n=a.length;
+int max=Integer.MIN_VALUE;
+int smax=0;
+int j=1;
+for(int i=0;i<n;i++)
+{
+if(a[i]>max)
+{
+max=a[i];
+}
+
+if(a[j]<max)
+{
+smax=a[j];
+j++;
+}
+}
+System.out.println("First Maximum="+max);
+System.out.println("Second Maximum="+smax);
+}
+}
\ No newline at end of file
diff --git a/TreeMap1.class b/TreeMap1.class
new file mode 100644
index 0000000..03c0cf1
Binary files /dev/null and b/TreeMap1.class differ
diff --git a/TreeMap1.java b/TreeMap1.java
new file mode 100644
index 0000000..12c27d3
--- /dev/null
+++ b/TreeMap1.java
@@ -0,0 +1,13 @@
+import java.util.*;
+class TreeMap1
+{
+public static void main(String args[])
+{
+Map<Integer,Integer> map=new TreeMap<>(Collections.reverseOrder());
+map.put(2,90);
+map.put(4,89);
+map.put(1,23);
+map.put(2,67);
+System.out.println(map);
+}
+}
\ No newline at end of file
diff --git a/TreeMap2.class b/TreeMap2.class
new file mode 100644
index 0000000..2eab3ca
Binary files /dev/null and b/TreeMap2.class differ
diff --git a/TreeMap2.java b/TreeMap2.java
new file mode 100644
index 0000000..671782d
--- /dev/null
+++ b/TreeMap2.java
@@ -0,0 +1,25 @@
+import java.util.*;
+class TreeMap2
+{
+public static void main(String args[])
+{
+TreeMap<Integer,String> map=new TreeMap<>(Collections.reverseOrder());
+map.put(10,"gaurav");
+map.put(2,"sujit");
+map.put(3,"kumar");
+map.put(11,"ankit");
+System.out.println("treeMap is:"+map);
+if(map.containsKey(12))
+{
+System.out.println("Yes");
+}
+
+else
+{
+System.out.println("NO");
+}
+
+map.remove(2);
+System.out.println(map);
+}
+}
\ No newline at end of file
diff --git a/TreeMap3.class b/TreeMap3.class
new file mode 100644
index 0000000..bf981c2
Binary files /dev/null and b/TreeMap3.class differ
diff --git a/TreeMap3.java b/TreeMap3.java
new file mode 100644
index 0000000..cabcda9
--- /dev/null
+++ b/TreeMap3.java
@@ -0,0 +1,26 @@
+import java.util.*;
+class TreeMap3
+{
+static ArrayList<Integer> l=new ArrayList<>();
+static void flatten(List<Integer> list)
+{
+for(Integer i:list)
+{
+l.add(i);
+}
+}
+public static void main(String args[])
+{
+Map<Integer,List<Integer>> map=new HashMap<>();
+map.put(1,Arrays.asList(1,2));
+map.put(2,Arrays.asList(3,4,5));
+System.out.println(map);
+for(Map.Entry<Integer,List<Integer>> m:map.entrySet())
+{
+List<Integer> k=m.getValue();
+flatten(k);
+}
+
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/Treemap.java b/Treemap.java
new file mode 100644
index 0000000..406cc07
--- /dev/null
+++ b/Treemap.java
@@ -0,0 +1,13 @@
+import java.util.*;
+class TreeMap
+{
+public static void main(String args[])
+{
+Map<Integer,Integer> map=new TreeMap<>();
+map.put(2,90);
+map.put(4,89);
+map.put(1,23);
+map.put(2,67);
+System.out.println(map);
+}
+}
\ No newline at end of file
diff --git a/Unique.class b/Unique.class
new file mode 100644
index 0000000..e34d34e
Binary files /dev/null and b/Unique.class differ
diff --git a/Unique.java b/Unique.java
new file mode 100644
index 0000000..f18ec83
--- /dev/null
+++ b/Unique.java
@@ -0,0 +1,15 @@
+import java.util.*;
+class Unique
+{
+public static void main(String args[])
+{
+String s="Morning";
+Set<Character> set=new HashSet<>();
+char c[]=s.toCharArray();
+for(int i=0;i<c.length;i++)
+{
+set.add(c[i]);
+}
+System.out.println(set);
+}
+}
\ No newline at end of file
diff --git a/Valid.java b/Valid.java
new file mode 100644
index 0000000..a57b526
--- /dev/null
+++ b/Valid.java
@@ -0,0 +1,38 @@
+import java.util.*;
+class Valid
+{
+static boolean validParen(String s)
+{
+Stack<Character> st=new Stack<>();
+char c[]=s.charArray();
+for(char k:c)
+{
+if(k=='(' || k=='[' || k=='{')
+{
+st.push(k);
+}
+else
+{
+if(st.isEmpty())
+return false;
+
+if(k==')' && st.peek()!='(' )
+return false;
+
+if(k==']' && st.peek()!='[' )
+return false;
+
+if(k=='}' && st.peek()!='{')
+return false;
+
+st.pop();
+}
+}
+return st.isEmpty();
+}
+public static void main(String args[])
+{
+String s="()";
+System.out.println(validParen(s));
+}
+}
\ No newline at end of file
diff --git a/Value.class b/Value.class
new file mode 100644
index 0000000..946af9c
Binary files /dev/null and b/Value.class differ
diff --git a/Value.java b/Value.java
new file mode 100644
index 0000000..1ce43c7
--- /dev/null
+++ b/Value.java
@@ -0,0 +1,28 @@
+import java.util.*;
+class sujit
+{
+String name;
+int count=0;
+void getValue(String name,List<String> l)
+{
+synchronized(this)
+{
+this.name=name;
+count++;
+}
+l.add(name);
+System.out.println(count);
+}
+}
+
+class Value
+{
+public static void main(String args[])
+{
+sujit s=new sujit();
+List<String> l=new ArrayList<>();
+s.getValue("gaurav",l);
+System.out.println(s.name);
+System.out.println(l);
+}
+}
diff --git a/Vikash.class b/Vikash.class
new file mode 100644
index 0000000..1404d46
Binary files /dev/null and b/Vikash.class differ
diff --git a/Wrapper.class b/Wrapper.class
new file mode 100644
index 0000000..5bb36e7
Binary files /dev/null and b/Wrapper.class differ
diff --git a/Zone1.class b/Zone1.class
new file mode 100644
index 0000000..0933e74
Binary files /dev/null and b/Zone1.class differ
diff --git a/Zone1.java b/Zone1.java
new file mode 100644
index 0000000..e5e1fe3
--- /dev/null
+++ b/Zone1.java
@@ -0,0 +1,15 @@
+import java.time.*;
+class Zone1
+{
+public static void main(String args[])
+{
+Clock c=Clock.systemUTC();
+ZonedDateTime t=c.instant().atZone(c.getZone());
+System.out.println(t.toString());
+
+ZoneId z=ZoneId.of("Asia/Tokyo");
+Clock c2=c.withZone(z);
+ZonedDateTime t2=c2.instant().atZone(c2.getZone());
+System.out.println(t2);
+}
+}
\ No newline at end of file
diff --git a/Zone2.class b/Zone2.class
new file mode 100644
index 0000000..9c8a5a2
Binary files /dev/null and b/Zone2.class differ
diff --git a/Zone2.java b/Zone2.java
new file mode 100644
index 0000000..12609ae
--- /dev/null
+++ b/Zone2.java
@@ -0,0 +1,17 @@
+import java.time.*;
+class Zone2
+{
+public static void main(String args[])
+{
+ZoneId z1=ZoneId.of("Asia/Kolkata");
+Clock c=Clock.tickMinutes(z1);
+System.out.println(c);
+ZonedDateTime t=c.instant().atZone(c.getZone());
+System.out.println(t.toString());
+
+ZoneId z=ZoneId.of("America/Chicago");
+Clock c1=c.withZone(z);
+ZonedDateTime t1=c1.instant().atZone(c1.getZone());
+System.out.println(t1.toString());
+}
+}
\ No newline at end of file
diff --git a/Zone4.java b/Zone4.java
new file mode 100644
index 0000000..c6b98f5
--- /dev/null
+++ b/Zone4.java
@@ -0,0 +1,11 @@
+import java.time.*;
+class zone4
+{
+public static void main(String args[])
+{
+Clock c=Clock.systemUTC();
+Instant i=c.instant();
+ZonedDateTime d=i.atZone(c.getZone());
+System.out.println(d.toString());
+}
+}
\ No newline at end of file
diff --git a/abstract.java b/abstract.java
new file mode 100644
index 0000000..facaa6c
--- /dev/null
+++ b/abstract.java
@@ -0,0 +1,13 @@
+import java.util.*;
+class abstract1
+{
+public static void main(String args[])
+{
+AbstractSet<Integer> set=new TreeSet<>();
+set.add(12);
+set.add(11);
+set.add(4);
+set.add(2);
+System.out.println(set);
+}
+}
\ No newline at end of file
diff --git a/abstract1.class b/abstract1.class
new file mode 100644
index 0000000..0f1a7b1
Binary files /dev/null and b/abstract1.class differ
diff --git a/abstract1.java b/abstract1.java
new file mode 100644
index 0000000..87afad9
--- /dev/null
+++ b/abstract1.java
@@ -0,0 +1,29 @@
+import java.util.*;
+class abstract1
+{
+public static void main(String args[])
+{
+AbstractSet<Integer> set=new TreeSet<>();
+set.add(12);
+set.add(11);
+set.add(4);
+set.add(2);
+System.out.println(set);
+Iterator i=set.iterator();
+while(i.hasNext())
+{
+System.out.println(i.next());
+}
+
+AbstractSet<Integer> set1=new TreeSet<>();
+set1.add(10);
+set1.add(5);
+set1.add(4);
+set1.add(6);
+
+set.addAll(set1);
+System.out.println(set);
+set.removeAll(set1);
+System.out.println(set);
+}
+}
\ No newline at end of file
diff --git a/abstract3.class b/abstract3.class
new file mode 100644
index 0000000..64debf8
Binary files /dev/null and b/abstract3.class differ
diff --git a/abstract3.java b/abstract3.java
new file mode 100644
index 0000000..323f872
--- /dev/null
+++ b/abstract3.java
@@ -0,0 +1,29 @@
+import java.util.*;
+class abstract3
+{
+public static void main(String args[])
+{
+AbstractCollection<Object> a=new ArrayList<>();
+a.add("sujit");
+a.add(10);
+a.add("gaurav");
+a.add("kumar");
+a.add("kushal");
+System.out.println(a);
+
+AbstractCollection<String> a1=new ArrayList<>();
+a1.add("NIT");
+a1.add("GITA");
+a1.add("GIT");
+a1.add("KIIT");
+System.out.println(a1);
+System.out.println(a1.size());
+
+AbstractCollection<Integer> a3=new TreeSet<>();
+a3.add(1);
+a3.add(2);
+a3.add(4);
+a3.add(5);
+System.out.println(a3);
+}
+}
\ No newline at end of file
diff --git a/abstract4.java b/abstract4.java
new file mode 100644
index 0000000..a1d2ca3
--- /dev/null
+++ b/abstract4.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class Abstract4
+{
+public static void main(String args[])
+{
+AbstractCollection<String> a=new TreeSet<>();
+a.add("sujit");
+a.add("gaurav");
+a.add("kumar");
+a.add("ksuhal");
+
+System.out.println(a);
+
+AbstractCollection<String> a1=new TreeSet<>();
+
+a1.addAll(a);
+System.out.println(a1);
+}
+
+}
\ No newline at end of file
diff --git a/alphabets.class b/alphabets.class
new file mode 100644
index 0000000..42ebfb6
Binary files /dev/null and b/alphabets.class differ
diff --git a/alphabets.java b/alphabets.java
new file mode 100644
index 0000000..9c14bae
--- /dev/null
+++ b/alphabets.java
@@ -0,0 +1,15 @@
+class alphabets
+{
+static boolean isAlphabets(String s)
+{
+return((s!=null) && (s!="") &&(s.chars().allMatch(Character::isLetter)));
+}
+public static void main(String args[])
+{
+String s="kumar";
+System.out.println(isAlphabets(s));
+
+String k="gaurav12";
+System.out.println(isAlphabets(k));
+}
+}
\ No newline at end of file
diff --git a/anagram.class b/anagram.class
new file mode 100644
index 0000000..2585af9
Binary files /dev/null and b/anagram.class differ
diff --git a/anagram.java b/anagram.java
new file mode 100644
index 0000000..42d2d95
--- /dev/null
+++ b/anagram.java
@@ -0,0 +1,37 @@
+class anagram 
+{
+public static void main(String args[])
+{
+String a="cat";
+String b="abt";
+boolean isAnagram=false;
+boolean visited[]=new boolean[b.length()];
+if(a.length()==b.length())
+{
+for(int i=0;i<a.length();i++)
+{
+char c=a.charAt(i);
+
+for(int j=0;j<b.length();j++)
+{
+if(b.charAt(j)==c && !visited[j])
+{
+visited[j]=true;
+isAnagram=true;
+break;
+}
+}
+if(!isAnagram)
+break;
+}
+}
+if(isAnagram)
+{
+System.out.println("Anagram");
+}
+else
+{
+System.out.println("Not Anagram");
+}
+}
+}
\ No newline at end of file
diff --git a/anagram1.class b/anagram1.class
new file mode 100644
index 0000000..e78f9ab
Binary files /dev/null and b/anagram1.class differ
diff --git a/anagram1.java b/anagram1.java
new file mode 100644
index 0000000..ce08857
--- /dev/null
+++ b/anagram1.java
@@ -0,0 +1,36 @@
+class anagram1
+{
+public static void main(String args[])
+{
+String a="cat";
+String b="abt";
+boolean isAnagram=false;
+boolean visited[]=new boolean[a.length()];
+if(a.length()==b.length())
+{
+for(int i=0;i<a.length();i++)
+{
+char c=a.charAt(i);
+for(int j=0;j<b.length();j++)
+{
+if(b.charAt(j)==c && !visited[j])
+{
+visited[j]=true;
+isAnagram=true;
+break;
+}
+}
+if(!isAnagram)
+break;
+}
+}
+
+if(isAnagram)
+{
+System.out.println("anagram");
+}else
+{
+System.out.println("Not angram");
+}
+}
+}
\ No newline at end of file
diff --git a/baba.class b/baba.class
new file mode 100644
index 0000000..4bf4b4e
Binary files /dev/null and b/baba.class differ
diff --git a/baby.class b/baby.class
new file mode 100644
index 0000000..8dd1d50
Binary files /dev/null and b/baby.class differ
diff --git a/biodata.class b/biodata.class
new file mode 100644
index 0000000..0dcb48a
Binary files /dev/null and b/biodata.class differ
diff --git a/biodata.java b/biodata.java
new file mode 100644
index 0000000..671a754
--- /dev/null
+++ b/biodata.java
@@ -0,0 +1,44 @@
+import java.util.*;
+class Student
+{
+int roll;
+String name;
+Student(int roll,String name)
+{
+this.roll=roll;
+this.name=name;
+}
+
+public String toString()
+{
+return("Roll="+this.roll+" Name=" +this.name);
+}
+}
+
+class sortByRoll implements Comparator<Student>
+{
+public int compare(Student a,Student b)
+{
+return a.roll-b.roll;
+}
+}
+class biodata
+{
+public static void main(String args[])
+{
+Student a[]={new Student(2,"gaurav"),new Student(1,"Ankit"),
+              new Student(3,"kushal")};
+
+for(int i=0;i<a.length;i++)
+{
+System.out.println(a[i]+" ");
+}
+
+System.out.println("Sorted by Roll-------------");
+Arrays.sort(a,new sortByRoll());
+for(int i=0;i<a.length;i++)
+{
+System.out.println(a[i]);
+}
+}
+}
\ No newline at end of file
diff --git a/blockLinked.class b/blockLinked.class
new file mode 100644
index 0000000..823f5c3
Binary files /dev/null and b/blockLinked.class differ
diff --git a/blockLinked.java b/blockLinked.java
new file mode 100644
index 0000000..f56c53a
--- /dev/null
+++ b/blockLinked.java
@@ -0,0 +1,13 @@
+import java.util.concurrent.*;
+import java.util.*;
+class blockLinked
+{
+public static void main(String args[])
+{
+PriorityBlockingQueue<Integer> l=new PriorityBlockingQueue<>(3,Comparator.reverseOrder());
+l.add(12);
+l.add(30);
+l.add(9);
+System.out.println("Linked Queue is:"+l);
+}
+}
diff --git a/bubble.class b/bubble.class
new file mode 100644
index 0000000..7f7e3c2
Binary files /dev/null and b/bubble.class differ
diff --git a/bubble.java b/bubble.java
new file mode 100644
index 0000000..d81a458
--- /dev/null
+++ b/bubble.java
@@ -0,0 +1,22 @@
+import java.util.*;
+class bubble
+{
+public static void main(String args[])
+{
+int a[]={10,2,3,-1,4};
+int n=a.length;
+for(int i=0;i<n-1;i++)
+{
+for(int j=0;j<n-1;j++)
+{
+if(a[j+1]<a[j])
+{
+int temp=a[j+1];
+a[j+1]=a[j];
+a[j]=temp;
+}
+}
+}
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/bubble3.class b/bubble3.class
new file mode 100644
index 0000000..f96a58a
Binary files /dev/null and b/bubble3.class differ
diff --git a/bubble3.java b/bubble3.java
new file mode 100644
index 0000000..4b6ae2c
--- /dev/null
+++ b/bubble3.java
@@ -0,0 +1,25 @@
+class bubble3
+{
+public static void main(String args[])
+{
+int a[]={10,11,2,3,4};
+int n=a.length;
+for(int i=0;i<n;i++)
+{
+for(int j=0;j<n-1;j++)
+{
+if(a[j+1]<a[j])
+{
+int temp=a[j+1];
+a[j+1]=a[j];
+a[j]=temp;
+}
+}
+}
+for(int i=0;i<n;i++)
+{
+
+System.out.print(a[i]+" ");
+}
+}
+}
\ No newline at end of file
diff --git a/bubble31.class b/bubble31.class
new file mode 100644
index 0000000..65d49f9
Binary files /dev/null and b/bubble31.class differ
diff --git a/bubble31.java b/bubble31.java
new file mode 100644
index 0000000..0978579
--- /dev/null
+++ b/bubble31.java
@@ -0,0 +1,22 @@
+import java.util.*;
+class bubble31
+{
+public static void main(String args[])
+{
+int a[]={12,3,2,4,1};
+int n=a.length;
+for(int i=0;i<n;i++)
+{
+for(int j=0;j<n-1;j++)
+{
+if(a[j+1]<a[j])
+{
+int temp=a[j+1];
+a[j+1]=a[i];
+a[i]=temp;
+}
+}
+}
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/byteToHexa.class b/byteToHexa.class
new file mode 100644
index 0000000..8fdd3dc
Binary files /dev/null and b/byteToHexa.class differ
diff --git a/byteToHexa.java b/byteToHexa.java
new file mode 100644
index 0000000..03de01d
--- /dev/null
+++ b/byteToHexa.java
@@ -0,0 +1,16 @@
+class byteToHexa
+{
+static void convertHexa(byte a[])
+{
+for(byte i:a)
+{
+String k=String.format("%03X",i);
+System.out.print(k);
+}
+}
+public static void main(String args[])
+{
+byte a[]={1,2,3,4};
+convertHexa(a);
+}
+}
\ No newline at end of file
diff --git a/calendar.class b/calendar.class
new file mode 100644
index 0000000..afee8d4
Binary files /dev/null and b/calendar.class differ
diff --git a/calendar.java b/calendar.java
new file mode 100644
index 0000000..5bc7d2e
--- /dev/null
+++ b/calendar.java
@@ -0,0 +1,15 @@
+import java.util.*;
+import java.time.*;
+class calendar
+{
+public static void main(String args[])
+{
+Calendar c=new GregorianCalendar(2020,07,28);
+int day=c.get(Calendar.DAY_OF_MONTH);
+int month=c.get(Calendar.MONTH);
+int year=c.get(Calendar.YEAR);
+System.out.println("Day="+day);
+System.out.println("Month="+month);
+System.out.println("Year="+year);
+}
+}
\ No newline at end of file
diff --git a/calendar1.class b/calendar1.class
new file mode 100644
index 0000000..e131bf3
Binary files /dev/null and b/calendar1.class differ
diff --git a/calendar1.java b/calendar1.java
new file mode 100644
index 0000000..bdfec86
--- /dev/null
+++ b/calendar1.java
@@ -0,0 +1,14 @@
+import java.util.*;
+class calendar1
+{
+public static void main(String args[])
+{
+Calendar c=new GregorianCalendar(2021,01,25);
+int day=c.get(Calendar.DAY_OF_MONTH);
+int month=c.get(Calendar.MONTH);
+int year=c.get(Calendar.YEAR);
+System.out.println("Day="+day);
+System.out.println("Month="+month);
+System.out.println("Year="+year);
+}
+}
\ No newline at end of file
diff --git a/calendar2.class b/calendar2.class
new file mode 100644
index 0000000..5c0d3bf
Binary files /dev/null and b/calendar2.class differ
diff --git a/calendar2.java b/calendar2.java
new file mode 100644
index 0000000..d7f8c4d
--- /dev/null
+++ b/calendar2.java
@@ -0,0 +1,20 @@
+import java.util.*;
+import java.time.*;
+class calendar2
+{
+static void findDate(String s)
+{
+String a[]=s.split("-");
+String year=a[0];
+String month=a[1];
+String day=a[2];
+System.out.println("Day="+day);
+System.out.println("Year="+year);
+System.out.println("Month="+month);
+}
+public static void main(String args[])
+{
+String s="2021-02-23";
+findDate(s);
+}
+}
\ No newline at end of file
diff --git a/cat.txt b/cat.txt
new file mode 100644
index 0000000..136e4d5
Binary files /dev/null and b/cat.txt differ
diff --git a/celcius.class b/celcius.class
new file mode 100644
index 0000000..ad323dc
Binary files /dev/null and b/celcius.class differ
diff --git a/celcius.java b/celcius.java
new file mode 100644
index 0000000..ed692a6
--- /dev/null
+++ b/celcius.java
@@ -0,0 +1,14 @@
+class celcius
+{
+public static void main(String args[])
+{
+//convert celcius to fahrenheight
+float cel=5;
+cel=cel*9/5+32;
+System.out.println("the celcius to fahrenheight is:"+cel+" f");
+
+float fahren=40;
+fahren=(fahren-32)*5/9;
+System.out.println("the fahrenheight to celcius is:"+fahren);
+}
+}
\ No newline at end of file
diff --git a/checkAlphabets.class b/checkAlphabets.class
new file mode 100644
index 0000000..0df1b70
Binary files /dev/null and b/checkAlphabets.class differ
diff --git a/checkAlphabets.java b/checkAlphabets.java
new file mode 100644
index 0000000..30130b4
--- /dev/null
+++ b/checkAlphabets.java
@@ -0,0 +1,13 @@
+//check if a String contains only alphabets or not using regex
+class checkAlphabets
+{
+static boolean isAlphabets(String s)
+{
+return((s!=null) && (s!="") &&(s.matches("^[a-zA-Z0-9]*$")));
+}
+public static void main(String args[])
+{
+String s="kumar12";
+System.out.println(isAlphabets(s));
+}
+}
\ No newline at end of file
diff --git a/checkAlphabets.txt b/checkAlphabets.txt
new file mode 100644
index 0000000..10b2a9b
--- /dev/null
+++ b/checkAlphabets.txt
@@ -0,0 +1,13 @@
+//check if a String contains only alphabets or not using regex
+class checkAlphabets
+{
+static boolean isAlphabets(String s)
+{
+return((s!=null) && (s!="") &&(s.matches("[a-zA-Z]");
+}
+public static void main(String args[])
+{
+String s="kumar";
+System.out.println(isAlphabets(s));
+}
+}
\ No newline at end of file
diff --git a/child1.class b/child1.class
new file mode 100644
index 0000000..134c180
Binary files /dev/null and b/child1.class differ
diff --git a/chutiya.class b/chutiya.class
new file mode 100644
index 0000000..34f70f2
Binary files /dev/null and b/chutiya.class differ
diff --git a/chutiya.java b/chutiya.java
new file mode 100644
index 0000000..ae427f3
--- /dev/null
+++ b/chutiya.java
@@ -0,0 +1,14 @@
+import java.util.*;
+enum gaurav
+{
+JAVA,PYTHON,HTML,CSS,JAVASCRIPT;
+}
+
+class chutiya
+{
+public static void main(String args[])
+{
+Set<gaurav> s1=EnumSet.of(gaurav.JAVA,gaurav.PYTHON,gaurav.HTML,gaurav.CSS);
+System.out.println("Set is:"+s1);
+}
+}
\ No newline at end of file
diff --git a/chutiya1.class b/chutiya1.class
new file mode 100644
index 0000000..bf7e194
Binary files /dev/null and b/chutiya1.class differ
diff --git a/chutiya1.java b/chutiya1.java
new file mode 100644
index 0000000..ec6f2ff
--- /dev/null
+++ b/chutiya1.java
@@ -0,0 +1,14 @@
+import java.util.*;
+enum sujit
+{
+CSE,MECH,ECE,EEE,CIVIL;
+}
+
+class chutiya1
+{
+public static void main(String args[])
+{
+Set<sujit> s=EnumSet.of(sujit.CSE,sujit.MECH,sujit.ECE,sujit.CIVIL);
+System.out.println("the set is:"+s);
+}
+}
\ No newline at end of file
diff --git a/circle1.class b/circle1.class
new file mode 100644
index 0000000..3c5ad83
Binary files /dev/null and b/circle1.class differ
diff --git a/circle1.java b/circle1.java
new file mode 100644
index 0000000..2ed29f6
--- /dev/null
+++ b/circle1.java
@@ -0,0 +1,45 @@
+abstract class sujit
+{
+String color;
+abstract double area();
+public abstract String toString();
+
+sujit(String color)
+{
+this.color=color;
+}
+
+String getColor()
+{
+return color;
+}
+}
+
+class Circle extends sujit
+{
+double radius;
+Circle(String color,double radius)
+{
+super(color);
+this.radius=radius;
+} 
+
+double area()
+{
+return Math.PI*Math.pow(radius,2);
+}
+
+public String toString()
+{
+return("Color= "+super.color+" Area="+area());
+}
+}
+
+class circle1
+{
+public static void main(String args[])
+{
+Circle c=new Circle("blue",2.3);
+System.out.println(c.toString());
+}
+}
diff --git a/circle3.class b/circle3.class
new file mode 100644
index 0000000..2cd7df6
Binary files /dev/null and b/circle3.class differ
diff --git a/circle3.java b/circle3.java
new file mode 100644
index 0000000..2e8192c
--- /dev/null
+++ b/circle3.java
@@ -0,0 +1,44 @@
+abstract class shape
+{
+String name;
+abstract double area();
+public abstract String toString();
+shape(String name)
+{
+this.name=name;
+}
+
+String getName()
+{
+return name;
+}
+}
+
+class Circle extends shape
+{
+double radius;
+Circle(double radius,String name)
+{
+super(name);
+this.radius=radius;
+}
+
+double area()
+{
+return Math.PI*Math.pow(radius,2);
+}
+
+public String toString()
+{
+return("Name="+super.name+" Area=="+area());
+}
+}
+
+class circle3
+{
+public static void main(String args[])
+{
+Circle c=new Circle(287.2,"Circle");
+System.out.println(c.toString());
+}
+}
diff --git a/clock1.class b/clock1.class
new file mode 100644
index 0000000..8165174
Binary files /dev/null and b/clock1.class differ
diff --git a/clock1.java b/clock1.java
new file mode 100644
index 0000000..22c459a
--- /dev/null
+++ b/clock1.java
@@ -0,0 +1,17 @@
+import java.time.*;
+class clock1
+{
+public static void main(String args[])
+{
+ZoneId z=ZoneId.of("Asia/Tokyo");
+Clock c=Clock.tickMinutes(z);
+ZonedDateTime z1=c.instant().atZone(c.getZone());
+System.out.println(z1.toString());
+
+ZoneId z2=ZoneId.of("Asia/Kolkata");
+Clock c1=c.withZone(z2);
+ZonedDateTime d1=c1.instant().atZone(c1.getZone());
+
+System.out.println(d1.toString());
+}
+}
\ No newline at end of file
diff --git a/clock12,java.txt b/clock12,java.txt
new file mode 100644
index 0000000..af5cce3
--- /dev/null
+++ b/clock12,java.txt
@@ -0,0 +1,10 @@
+import java.time.*;
+class clock12
+{
+public static void main(String args[])
+{
+Clock c1=Clock.systemUTC();
+Instant i=Instant.now(c1);
+System.out.println(i);
+}
+}
\ No newline at end of file
diff --git a/clock13.class b/clock13.class
new file mode 100644
index 0000000..29a4f3c
Binary files /dev/null and b/clock13.class differ
diff --git a/clock13.java b/clock13.java
new file mode 100644
index 0000000..283d9af
--- /dev/null
+++ b/clock13.java
@@ -0,0 +1,10 @@
+import java.time.*;
+class clock13
+{
+public static void main(String args[])
+{
+Clock c1=Clock.systemUTC();
+Instant i=Instant.now(c1);
+System.out.println(i);
+}
+}
\ No newline at end of file
diff --git a/clock2.class b/clock2.class
new file mode 100644
index 0000000..5d2fbc0
Binary files /dev/null and b/clock2.class differ
diff --git a/clock2.java b/clock2.java
new file mode 100644
index 0000000..7c3e418
--- /dev/null
+++ b/clock2.java
@@ -0,0 +1,16 @@
+import java.time.*;
+class clock2
+{
+public static void main(String args[])
+{
+ZoneId z=ZoneId.of("Asia/Kolkata");
+Clock c=Clock.system(z);
+System.out.println(c);
+Instant i =c.instant();
+System.out.println(i);
+
+ZonedDateTime z2=i.atZone(c.getZone());
+System.out.println(z2);
+
+}
+}
diff --git a/clock3.class b/clock3.class
new file mode 100644
index 0000000..d89f754
Binary files /dev/null and b/clock3.class differ
diff --git a/clock3.java b/clock3.java
new file mode 100644
index 0000000..b99c4b8
--- /dev/null
+++ b/clock3.java
@@ -0,0 +1,13 @@
+import java.time.*;
+class clock3
+{
+public static void main(String args[])
+{
+ZoneId z=ZoneId.of("Asia/Tokyo");
+Clock c=Clock.system(z);
+Instant i=c.instant();
+System.out.println(i);
+ZonedDateTime zone=i.atZone(c.getZone());
+System.out.println(zone);
+}
+}
\ No newline at end of file
diff --git a/clock4.class b/clock4.class
new file mode 100644
index 0000000..62e6e1b
Binary files /dev/null and b/clock4.class differ
diff --git a/clock4.java b/clock4.java
new file mode 100644
index 0000000..d5ffefe
--- /dev/null
+++ b/clock4.java
@@ -0,0 +1,12 @@
+import java.time.*;
+class clock4
+{
+public static void main(String args[])
+{
+ZoneId z=ZoneId.of("US/Arizona");
+Clock c=Clock.system(z);
+Instant i=c.instant();
+ZonedDateTime zone=i.atZone(c.getZone());
+System.out.println(zone);
+}
+}
diff --git a/clock5.class b/clock5.class
new file mode 100644
index 0000000..68d221f
Binary files /dev/null and b/clock5.class differ
diff --git a/clock5.java b/clock5.java
new file mode 100644
index 0000000..7b6e94f
--- /dev/null
+++ b/clock5.java
@@ -0,0 +1,10 @@
+import java.time.*;
+class clock5
+{
+public static void main(String args[])
+{
+ZoneId z=ZoneId.of("Asia/Kolkata");
+Clock c=Clock.tickSeconds(z);
+System.out.println(c.instant());
+}
+}
\ No newline at end of file
diff --git a/clock6.java b/clock6.java
new file mode 100644
index 0000000..5185b56
--- /dev/null
+++ b/clock6.java
@@ -0,0 +1,8 @@
+import java.time.*;
+class clock6
+{
+ZoneId z=ZoneId.of("Europe/Paris");
+Clock c=Clock.tickSeconds(z);
+System.out.println(c.instant());
+}
+}
\ No newline at end of file
diff --git a/clone.class b/clone.class
new file mode 100644
index 0000000..6454860
Binary files /dev/null and b/clone.class differ
diff --git a/clone.java b/clone.java
new file mode 100644
index 0000000..9ad5155
--- /dev/null
+++ b/clone.java
@@ -0,0 +1,9 @@
+class clone
+{
+public static void main(String args[])
+{
+int a[]={1,2,3,4};
+int b[]=a.clone();
+System.out.println(a==b);
+}
+}
\ No newline at end of file
diff --git a/cognizant.txt b/cognizant.txt
new file mode 100644
index 0000000..d2dc0dd
--- /dev/null
+++ b/cognizant.txt
@@ -0,0 +1 @@
+https://www.techgig.com/codegladiators/result/YnBTRklyOHdCaUFYdVV5NWR6RlBudz09
\ No newline at end of file
diff --git a/collage3.class b/collage3.class
new file mode 100644
index 0000000..74bebfe
Binary files /dev/null and b/collage3.class differ
diff --git a/collage3.java b/collage3.java
new file mode 100644
index 0000000..dd754aa
--- /dev/null
+++ b/collage3.java
@@ -0,0 +1,45 @@
+class collage
+{
+String name;
+int roll;
+int age;
+collage(String name,int roll,int age)
+{
+this.name=name;
+this.roll=roll;
+this.age=age;
+}
+void print()
+{
+System.out.println("Name="+name+" Roll="+roll+" Age="+age);
+}
+}
+
+class wrapper
+{
+collage c;
+wrapper(collage c)
+{
+this.c=c;
+}
+}
+
+class collage3
+{
+static void swap(wrapper w1,wrapper w2)
+{
+collage temp=w1.c;
+w1.c=w2.c;
+w2.c=temp;
+}
+public static void main(String args[])
+{
+collage c1=new collage("gaurav",153,23);
+collage c2=new collage("kushal",156,20);
+wrapper w1=new wrapper(c1);
+wrapper w2=new wrapper(c2);
+swap(w1,w2);
+w1.c.print();
+w2.c.print();
+}
+}
\ No newline at end of file
diff --git a/comma.class b/comma.class
new file mode 100644
index 0000000..384073d
Binary files /dev/null and b/comma.class differ
diff --git a/comma.java b/comma.java
new file mode 100644
index 0000000..57826af
--- /dev/null
+++ b/comma.java
@@ -0,0 +1,16 @@
+//convert ArrayList to comma separated String in java
+import java.util.*;
+class comma
+{
+public static void main(String args[])
+{
+ArrayList<String> l=new ArrayList<>();
+l.add("sujit");
+l.add("kumar");
+l.add("gaurav");
+l.add("kushal");
+
+String s=String.join(",",l);
+System.out.println("String  is:"+s);
+}
+}
\ No newline at end of file
diff --git a/common.class b/common.class
new file mode 100644
index 0000000..393a0c4
Binary files /dev/null and b/common.class differ
diff --git a/common.java b/common.java
new file mode 100644
index 0000000..c25b5e9
--- /dev/null
+++ b/common.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class common
+{
+public static void main(String args[])
+{
+Set<String> s=new HashSet<>();
+s.add("gaurav");
+s.add("kushal");
+s.add("kunal");
+Set<String> s1=new HashSet<>();
+s1.add("gaurav");
+s1.add("kunal");
+s1.add("Ankit");
+
+//common element is
+s.retainAll(s1);
+System.out.println("the element is:"+s);
+
+}
+}
diff --git a/company.class b/company.class
new file mode 100644
index 0000000..f4c9bc3
Binary files /dev/null and b/company.class differ
diff --git a/compare.class b/compare.class
new file mode 100644
index 0000000..36a103f
Binary files /dev/null and b/compare.class differ
diff --git a/compare.java b/compare.java
new file mode 100644
index 0000000..e5a64bc
--- /dev/null
+++ b/compare.java
@@ -0,0 +1,26 @@
+//compare two Array
+class compare
+{
+static boolean compareArray(float a[],float b[],float c[])
+{
+if(a.length!=c.length)
+return false;
+
+for(int i=0;i<a.length;i++)
+{
+if(a[i]!=c[i])
+{
+return false;
+}
+}
+return true;
+}
+public static void main(String args[])
+{
+float a[]=new float[]{1.2f,3.2f,4.2f};
+float b[]=new float[]{2.2f,2.1f,12f};
+float c[]=new float[]{1.2f,3.2f,4.2f};
+
+System.out.println(compareArray(a,b,c));
+}
+}
\ No newline at end of file
diff --git a/compareArray.class b/compareArray.class
new file mode 100644
index 0000000..4298082
Binary files /dev/null and b/compareArray.class differ
diff --git a/compareArray.java b/compareArray.java
new file mode 100644
index 0000000..f34a668
--- /dev/null
+++ b/compareArray.java
@@ -0,0 +1,12 @@
+import java.util.*;
+class compareArray
+{
+public static void main(String args[])
+{
+int a[]={12,1,2,3,4};
+System.out.println("Original Array is:"+Arrays.toString(a));
+
+int b[]=Arrays.copyOf(a,10);
+System.out.println("copy Array is:"+Arrays.toString(b));
+}
+}
\ No newline at end of file
diff --git a/compareLinked$Node.class b/compareLinked$Node.class
new file mode 100644
index 0000000..1a043e9
Binary files /dev/null and b/compareLinked$Node.class differ
diff --git a/compareLinked.class b/compareLinked.class
new file mode 100644
index 0000000..c93f5c4
Binary files /dev/null and b/compareLinked.class differ
diff --git a/compareLinked.java b/compareLinked.java
new file mode 100644
index 0000000..92f57c1
--- /dev/null
+++ b/compareLinked.java
@@ -0,0 +1,103 @@
+class compareLinked
+{
+static Node head;
+static Node head1;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.println("LinkedList is:"+temp.data);
+temp=temp.next;
+}
+}
+
+void print1()
+{
+Node temp=head1;
+while(temp!=null)
+{
+System.out.println(temp.data);
+temp=temp.next;
+}
+}
+
+void insert(int data)
+{
+Node x=new Node(data);
+if(head1==null)
+{
+head1=x;
+return;
+}
+Node temp=head1;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+static boolean compare(Node head,Node head1)
+{
+Node temp1=head;
+Node temp2=head1;
+while(temp1!=null && temp2!=null)
+{
+if(temp1.data!=temp2.data)
+{
+break;
+}
+
+if(temp1.next==null && temp2.next==null)
+return true; 
+}
+return false;
+}
+
+public static void main(String args[])
+{
+compareLinked l=new compareLinked();
+l.append(10);
+l.append(20);
+l.append(30);
+System.out.println("First List l1 is:");
+l.print();
+
+compareLinked l1=new compareLinked();
+System.out.println("\nSecond list is");
+l1.insert(10);
+l1.insert(20);
+l1.insert(30);
+l1.print1();
+
+System.out.println(compare(head,head1));
+}
+}
\ No newline at end of file
diff --git a/compareValues.class b/compareValues.class
new file mode 100644
index 0000000..89e75c2
Binary files /dev/null and b/compareValues.class differ
diff --git a/compareValues.java b/compareValues.java
new file mode 100644
index 0000000..9d25361
--- /dev/null
+++ b/compareValues.java
@@ -0,0 +1,17 @@
+import java.util.*;
+class compareValues
+{
+public static void main(String args[])
+{
+int a[]=new int[]{1,2,3,4};
+int b[]=new int[]{1,2,3,4};
+if(Arrays.equals(a,b))
+{
+System.out.println("Yes");
+}
+else{
+System.out.println("No");
+}
+
+}
+}
diff --git a/compo.class b/compo.class
new file mode 100644
index 0000000..1215822
Binary files /dev/null and b/compo.class differ
diff --git a/compo.java b/compo.java
new file mode 100644
index 0000000..cb65350
--- /dev/null
+++ b/compo.java
@@ -0,0 +1,47 @@
+import java.util.*;
+class Book
+{
+String title;
+String author;
+Book(String title,String author)
+{
+this.title=title;
+this.author=author;
+}
+}
+
+class Library
+{
+List<Book> books;
+Library(List<Book> books)
+{
+this.books=books;
+}
+
+List<Book> getBook()
+{
+return books;
+}
+}
+
+class compo
+{
+public static void main(String args[])
+{
+Book b1=new Book("Ram chandra","gaurav");
+Book b2=new Book("Sparks","Kushal");
+Book b3=new Book("Thomar","kumar");
+
+List<Book> l=new ArrayList<>();
+l.add(b1);
+l.add(b2);
+l.add(b3);
+
+Library l1=new Library(l);
+List<Book> b=l1.getBook();
+for(Book bo:b)
+{
+System.out.println("Title="+bo.title+" Author="+bo.author);
+}
+}
+}
\ No newline at end of file
diff --git a/concurrent.class b/concurrent.class
new file mode 100644
index 0000000..aec7810
Binary files /dev/null and b/concurrent.class differ
diff --git a/concurrent.java b/concurrent.java
new file mode 100644
index 0000000..07c1df8
--- /dev/null
+++ b/concurrent.java
@@ -0,0 +1,34 @@
+import java.util.concurrent.*;
+import java.util.*;
+class concurrent
+{
+public static void main(String args[])
+{
+ConcurrentHashMap<Integer,String> map=new ConcurrentHashMap<>();
+map.put(1,"gaurav");
+map.put(2,"kushal");
+map.put(3,"sujit");
+System.out.println("Map is:"+map);
+
+map.putIfAbsent(4,"kumar");
+map.putIfAbsent(5,"vikash");
+
+System.out.println(map);
+map.remove(2);
+map.putIfAbsent(6,"lucky");
+System.out.println(map);
+
+ConcurrentHashMap<Integer,String> map1=new ConcurrentHashMap<>();
+map1.putAll(map);
+System.out.println("Map is :"+map1);
+//String removeVal=map.remove(1);
+//System.out.println("Remove value is:"+removeVal);
+
+System.out.println(map.get(1));
+for(Map.Entry<Integer,String> m:map.entrySet())
+{
+System.out.print("Key="+m.getKey()+":");
+System.out.println("Value="+m.getValue());
+}
+}
+}
\ No newline at end of file
diff --git a/convertArray.class b/convertArray.class
new file mode 100644
index 0000000..d735f07
Binary files /dev/null and b/convertArray.class differ
diff --git a/convertArray.java b/convertArray.java
new file mode 100644
index 0000000..fa81cc5
--- /dev/null
+++ b/convertArray.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class convertArray
+{
+public static void main(String args[])
+{
+Set<String> s=new HashSet<>();
+s.add("kumar");
+s.add("kushal");
+s.add("sujit");
+System.out.println("the set is:"+s);
+String str[]=new String[s.size()];
+int i=0;
+for(String k:s)
+{
+str[i]=k;
+i++;
+}
+System.out.println(Arrays.toString(str));
+}
+}
\ No newline at end of file
diff --git a/convertArray1.class b/convertArray1.class
new file mode 100644
index 0000000..640624e
Binary files /dev/null and b/convertArray1.class differ
diff --git a/convertArray1.java b/convertArray1.java
new file mode 100644
index 0000000..5675ba9
--- /dev/null
+++ b/convertArray1.java
@@ -0,0 +1,15 @@
+import java.util.*;
+class convertArray1
+{
+public static void main(String args[])
+{
+ArrayList<Integer> l=new ArrayList<>();
+l.add(10);
+l.add(5);
+l.add(3);
+l.add(5);
+
+Object b[]=l.toArray();
+System.out.println(Arrays.toString(b));
+}
+}
\ No newline at end of file
diff --git a/convertArrayString.class b/convertArrayString.class
new file mode 100644
index 0000000..f84e21c
Binary files /dev/null and b/convertArrayString.class differ
diff --git a/convertArrayString.java b/convertArrayString.java
new file mode 100644
index 0000000..031caca
--- /dev/null
+++ b/convertArrayString.java
@@ -0,0 +1,16 @@
+//Convert set of String to String array using Stream
+import java.util.*;
+class convertArrayString
+{
+static String[] convertArray(Set<String> s)
+{
+String k[]=s.stream().toArray(String[]::new);
+return k;
+}
+public static void main(String args[])
+{
+Set<String> s=new HashSet<>(Arrays.asList("sujit","kumar","gaurav"));
+String y[]=convertArray(s);
+System.out.println(Arrays.toString(y));
+}
+}
\ No newline at end of file
diff --git a/convertByte.class b/convertByte.class
new file mode 100644
index 0000000..e44c9af
Binary files /dev/null and b/convertByte.class differ
diff --git a/convertByte.java b/convertByte.java
new file mode 100644
index 0000000..ed2927c
--- /dev/null
+++ b/convertByte.java
@@ -0,0 +1,18 @@
+import java.util.*;
+class convertByte
+{
+public static void main(String args[])
+{
+try
+{
+String s="gaurav";
+byte b[]=s.getBytes("US-ASCII");
+System.out.println(Arrays.toString(b));
+}
+catch(Exception e)
+{
+System.out.println(e);
+}
+
+}
+}
\ No newline at end of file
diff --git a/convertLinked.class b/convertLinked.class
new file mode 100644
index 0000000..2f9d73b
Binary files /dev/null and b/convertLinked.class differ
diff --git a/convertLinked.java b/convertLinked.java
new file mode 100644
index 0000000..bd6f9d3
--- /dev/null
+++ b/convertLinked.java
@@ -0,0 +1,14 @@
+import java.util.*;
+class convertLinked
+{
+public static void main(String args[])
+{
+int a[]={1,2,3,4,5,3};
+Set<Integer> s=new LinkedHashSet<>();
+for(int i:a)
+{
+s.add(i);
+}
+System.out.println("LinkedHashSet is:"+s);
+}
+}
\ No newline at end of file
diff --git a/convertSet.class b/convertSet.class
new file mode 100644
index 0000000..8aa9b8a
Binary files /dev/null and b/convertSet.class differ
diff --git a/convertSet.java b/convertSet.java
new file mode 100644
index 0000000..5c5b8eb
--- /dev/null
+++ b/convertSet.java
@@ -0,0 +1,21 @@
+import java.util.*;
+class convertSet
+{
+static Set<String> convertArrayToSet(String s[])
+{
+Set<String> set=new HashSet<>();
+for(int i=0;i<s.length;i++)
+{
+set.add(s[i]);
+}
+return set;
+}
+public static void main(String args[])
+{
+String a[]={"sujit","kumar","gaurav","kushal"};
+Set<String> k=convertArrayToSet(a);
+System.out.println("Set is:"+k);
+k.remove("kushal");
+System.out.println(k);
+}
+}
\ No newline at end of file
diff --git a/convertSet1.class b/convertSet1.class
new file mode 100644
index 0000000..2dc9acc
Binary files /dev/null and b/convertSet1.class differ
diff --git a/convertSet1.java b/convertSet1.java
new file mode 100644
index 0000000..117eee9
--- /dev/null
+++ b/convertSet1.java
@@ -0,0 +1,16 @@
+import java.util.*;
+class convertSet1
+{
+static void convertToSet(String s[])
+{
+Set<String> set=new HashSet<>();
+Collections.addAll(set,s);
+System.out.println("the set is:"+set);
+
+}
+public static void main(String args[])
+{
+String s[]={"kushal","kumar","sujit","hello"};
+convertToSet(s);
+}
+}
\ No newline at end of file
diff --git a/convertToByte.class b/convertToByte.class
new file mode 100644
index 0000000..bf6de77
Binary files /dev/null and b/convertToByte.class differ
diff --git a/convertToByte.java b/convertToByte.java
new file mode 100644
index 0000000..0f7b56a
--- /dev/null
+++ b/convertToByte.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class convertToByte
+{
+public static void main(String args[])
+{
+try
+{
+String s="Gaurav";
+byte b[]=s.getBytes("US-ASCII");
+System.out.print(Arrays.toString(b));
+}
+catch(Exception e)
+{
+System.out.println(e);
+}
+
+
+}
+}
\ No newline at end of file
diff --git a/copyList$Node.class b/copyList$Node.class
new file mode 100644
index 0000000..6c9dffb
Binary files /dev/null and b/copyList$Node.class differ
diff --git a/copyList.class b/copyList.class
new file mode 100644
index 0000000..bc4d5ee
Binary files /dev/null and b/copyList.class differ
diff --git a/copyList.java b/copyList.java
new file mode 100644
index 0000000..708b47f
--- /dev/null
+++ b/copyList.java
@@ -0,0 +1,59 @@
+class copyList
+{
+Node head;
+class Node
+{
+Node next;
+int data;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node k=new Node(data);
+if(head==null)
+{
+head=k;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=k;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void Copy(int head1)
+{
+Node temp=head1;
+Node k= new Node(-1)
+}
+
+public static void main(String args[])
+{
+copyList l=new copyList();
+l.append(10);
+l.append(20);
+l.append(30);
+l.append(40);
+l.print();
+l.Copy(l.head);
+}
+}
\ No newline at end of file
diff --git a/countDigit.class b/countDigit.class
new file mode 100644
index 0000000..8c07ca6
Binary files /dev/null and b/countDigit.class differ
diff --git a/countDigit.java b/countDigit.java
new file mode 100644
index 0000000..22d75cc
--- /dev/null
+++ b/countDigit.java
@@ -0,0 +1,16 @@
+class countDigit
+{
+public static void main(String args[])
+{
+String s="gaurav23";
+int count=0;
+for(int i=0;i<s.length();i++)
+{
+if(s.charAt(i)>=48 && s.charAt(i)<=57)
+{
+count+=1;
+}
+}
+System.out.println("the total number of digit digit is:"+count);
+}
+}
\ No newline at end of file
diff --git a/countVowels.class b/countVowels.class
new file mode 100644
index 0000000..1b4b5ca
Binary files /dev/null and b/countVowels.class differ
diff --git a/countVowels.java b/countVowels.java
new file mode 100644
index 0000000..fc6384d
--- /dev/null
+++ b/countVowels.java
@@ -0,0 +1,18 @@
+class countVowels
+{
+public static void main(String args[])
+{
+String s="Gaurav";
+int count=0;
+s=s.toLowerCase();
+for(int i=0;i<s.length();i++)
+{
+if(s.charAt(i)=='a' || s.charAt(i)=='e'|| s.charAt(i)=='i'||s.charAt(i)=='o'||
+s.charAt(i)=='u')
+{
+count+=1;
+}
+}
+System.out.println(count);
+}
+}
\ No newline at end of file
diff --git a/countVowels1.java b/countVowels1.java
new file mode 100644
index 0000000..fc5cd30
--- /dev/null
+++ b/countVowels1.java
@@ -0,0 +1,29 @@
+import java.util.*;
+class CountVowels1
+{
+public static void main(String args[])
+{
+String s="Gaurav";
+List<Character> vo=new ArrayList<>();
+vo.add('a');
+vo.add('e');
+vo.add('i');
+vo.add('o');
+vo.add('u');
+char c[]=s.toCharArray();
+int co=0;
+int v=0;
+for(int i=0;i<c.length;i++)
+{
+if(vo.contains(c[i]))
+{
+v++;
+}
+else
+{
+co++;
+}
+}
+System.out.println("the vowels is:"+v+"\n and consonants is:"+co);
+}
+}
\ No newline at end of file
diff --git a/cycle$Node.class b/cycle$Node.class
new file mode 100644
index 0000000..ccf5885
Binary files /dev/null and b/cycle$Node.class differ
diff --git a/cycle.class b/cycle.class
new file mode 100644
index 0000000..c9e4cb8
Binary files /dev/null and b/cycle.class differ
diff --git a/cycle.java b/cycle.java
new file mode 100644
index 0000000..fd952bb
--- /dev/null
+++ b/cycle.java
@@ -0,0 +1,71 @@
+class cycle
+{
+static Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+boolean check(Node head)
+{
+if(head==null || head.next==null)
+{
+return false;
+}
+Node A=head;
+Node B= head.next;
+while(A!=B)
+{
+if(B==null || B.next==null)
+return false;
+else{
+A=A.next;
+B=B.next.next;
+}
+}
+return true;
+}
+
+public static void main(String args[])
+{
+cycle c=new cycle();
+c.append(10);
+c.append(20);
+c.append(30);
+c.append(40);
+c.print();
+System.out.println(c.check(head));
+}
+}
\ No newline at end of file
diff --git a/defaultZone.class b/defaultZone.class
new file mode 100644
index 0000000..69d6332
Binary files /dev/null and b/defaultZone.class differ
diff --git a/defaultZone.java b/defaultZone.java
new file mode 100644
index 0000000..56e5e2d
--- /dev/null
+++ b/defaultZone.java
@@ -0,0 +1,11 @@
+import java.time.*;
+class defaultZone
+{
+public static void main(String args[])
+{
+Clock c=Clock.systemDefaultZone();
+Instant i=c.instant();
+ZonedDateTime d=i.atZone(c.getZone());
+System.out.println(d.toString());
+}
+}
\ No newline at end of file
diff --git a/defaultZone1.class b/defaultZone1.class
new file mode 100644
index 0000000..f546f28
Binary files /dev/null and b/defaultZone1.class differ
diff --git a/defaultZone1.java b/defaultZone1.java
new file mode 100644
index 0000000..7251585
--- /dev/null
+++ b/defaultZone1.java
@@ -0,0 +1,11 @@
+import java.time.*;
+class defaultZone1
+{
+public static void main(String args[])
+{
+Clock c=Clock.systemDefaultZone();
+Instant i=c.instant();
+ZonedDateTime z=i.atZone(c.getZone());
+System.out.println(z.toString());
+}
+}
\ No newline at end of file
diff --git a/details1.class b/details1.class
new file mode 100644
index 0000000..f410fe7
Binary files /dev/null and b/details1.class differ
diff --git a/details1.java b/details1.java
new file mode 100644
index 0000000..4c6d183
--- /dev/null
+++ b/details1.java
@@ -0,0 +1,37 @@
+class Bank
+{
+String name;
+Bank(String name)
+{
+this.name=name;
+}
+
+String getName()
+{
+return name;
+}
+}
+
+class Emp
+{
+String name;
+Emp(String name)
+{
+this.name=name;
+}
+
+String getName()
+{
+return name;
+}
+}
+
+class details1
+{
+public static void main(String args[])
+{
+Emp e=new Emp("BOI");
+Bank b=new Bank("Gaurav");
+System.out.println("Name="+e.getName()+" Emp="+b.getName());
+}
+}
\ No newline at end of file
diff --git a/details2.class b/details2.class
new file mode 100644
index 0000000..6193857
Binary files /dev/null and b/details2.class differ
diff --git a/details2.java b/details2.java
new file mode 100644
index 0000000..956d8f2
--- /dev/null
+++ b/details2.java
@@ -0,0 +1,37 @@
+class Collage
+{
+String name;
+Collage(String name)
+{
+this.name=name;
+}
+
+String getName()
+{
+return name;
+}
+}
+
+class sujit
+{
+String empName;
+sujit(String empName)
+{
+this.empName=empName;
+}
+
+String getEmp()
+{
+return empName;
+}
+}
+
+class details2
+{
+public static void main(String args[])
+{
+Collage c=new Collage("Google");
+sujit s=new sujit("gaurav");
+System.out.println(s.getEmp()+" is an  Emp of "+c.getName());
+}
+}
\ No newline at end of file
diff --git a/dict.class b/dict.class
new file mode 100644
index 0000000..1557689
Binary files /dev/null and b/dict.class differ
diff --git a/dict.java b/dict.java
new file mode 100644
index 0000000..05808b7
--- /dev/null
+++ b/dict.java
@@ -0,0 +1,25 @@
+import java.util.*;
+class dict
+{
+public static void main(String args[])
+{
+Dictionary d=new Hashtable();
+d.put("gaurav","cse");
+d.put("sujit","kumar");
+d.put("kushal","Das");
+d.put("Ankit","Mech");
+d.put("Aman","Collage");
+System.out.println("The value is:"+d);
+
+Enumeration e=d.elements();
+while(e.hasMoreElements())
+{
+System.out.println(e.nextElement());
+}
+System.out.println("Size="+d.size());
+System.out.println(d.get("gaurav"));
+System.out.println(d.isEmpty());
+d.remove("Ankit");
+System.out.println("The dict is:"+d);
+}
+}
\ No newline at end of file
diff --git a/dict1.class b/dict1.class
new file mode 100644
index 0000000..66297db
Binary files /dev/null and b/dict1.class differ
diff --git a/dict1.java b/dict1.java
new file mode 100644
index 0000000..d1bed6b
--- /dev/null
+++ b/dict1.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class dict1
+{
+public static void main(String args[])
+{
+Dictionary d=new Hashtable();
+d.put(1,"gaurav");
+d.put(2,"sujit");
+d.put(3,"kumar");
+System.out.println("Key and value is:"+d);
+
+Enumeration e=d.elements();
+while(e.hasMoreElements())
+{
+System.out.println(e.nextElement());
+}
+System.out.println("Size="+d.size());
+System.out.println(d.get(2));
+}
+}
\ No newline at end of file
diff --git a/diff.class b/diff.class
new file mode 100644
index 0000000..9b2f1c4
Binary files /dev/null and b/diff.class differ
diff --git a/diff.java b/diff.java
new file mode 100644
index 0000000..cbb0c9d
--- /dev/null
+++ b/diff.java
@@ -0,0 +1,17 @@
+import java.util.*;
+class diff
+{
+public static void main(String args[])
+{
+Set<Integer> set=new HashSet<>();
+set.add(1);
+set.add(2);
+set.add(3);
+Set<Integer> set1=new HashSet<>();
+set1.add(1);
+set1.add(2);
+set1.add(4);
+set.removeAll(set1);
+System.out.println(set);
+}
+}
\ No newline at end of file
diff --git a/div.class b/div.class
new file mode 100644
index 0000000..3514190
Binary files /dev/null and b/div.class differ
diff --git a/div.java b/div.java
new file mode 100644
index 0000000..27c13a5
--- /dev/null
+++ b/div.java
@@ -0,0 +1,19 @@
+class div
+{
+public static void main(String args[])
+{
+int a=1;
+int b=2;
+if(a<b)
+{
+double x=Double.valueOf(a)/Double.valueOf(b);
+System.out.println(Double.toString(x));
+}
+else
+{
+int x=a/b;
+System.out.println(Integer.toString(x));
+}
+
+}
+}
\ No newline at end of file
diff --git a/dog.txt b/dog.txt
new file mode 100644
index 0000000..68adabf
Binary files /dev/null and b/dog.txt differ
diff --git a/duplicate.class b/duplicate.class
new file mode 100644
index 0000000..924efd5
Binary files /dev/null and b/duplicate.class differ
diff --git a/duplicate.java b/duplicate.java
new file mode 100644
index 0000000..3c9345d
--- /dev/null
+++ b/duplicate.java
@@ -0,0 +1,23 @@
+import java.util.*;
+class duplicate
+{
+public static void main(String args[])
+{
+int a[]={1,3,4,4,2};
+Map<Integer,Integer> map=new HashMap<>();
+int n=a.length;
+for(int i=0;i<n;i++)
+{
+map.put(a[i],map.getOrDefault(a[i],0)+1);
+}
+
+for(Integer k:map.keySet())
+{
+if(map.get(k)!=1)
+{
+System.out.println(k);
+}
+}
+
+}
+}
\ No newline at end of file
diff --git a/duration1.class b/duration1.class
new file mode 100644
index 0000000..57b6c52
Binary files /dev/null and b/duration1.class differ
diff --git a/duration1.jaav.txt b/duration1.jaav.txt
new file mode 100644
index 0000000..5714a79
--- /dev/null
+++ b/duration1.jaav.txt
@@ -0,0 +1,11 @@
+import java.time.*;
+class duration1
+{
+public static void main(String args[])
+{
+Duration d=Duration.parse("P2DT3H4M");
+
+Duration d1=Duration.ofDays(10);
+System.out.println(d.equals(d1));
+}
+}
\ No newline at end of file
diff --git a/duration1.java b/duration1.java
new file mode 100644
index 0000000..5714a79
--- /dev/null
+++ b/duration1.java
@@ -0,0 +1,11 @@
+import java.time.*;
+class duration1
+{
+public static void main(String args[])
+{
+Duration d=Duration.parse("P2DT3H4M");
+
+Duration d1=Duration.ofDays(10);
+System.out.println(d.equals(d1));
+}
+}
\ No newline at end of file
diff --git a/duration2.class b/duration2.class
new file mode 100644
index 0000000..3a27b50
Binary files /dev/null and b/duration2.class differ
diff --git a/duration2.java b/duration2.java
new file mode 100644
index 0000000..0c9bdf1
--- /dev/null
+++ b/duration2.java
@@ -0,0 +1,14 @@
+import java.time.*;
+class duration2
+{
+public static void main(String args[])
+{
+Duration d=Duration.ofHours(5);
+System.out.println(d);
+
+Duration d2=Duration.ofHours(6);
+System.out.println(d2);
+
+System.out.println(d.equals(d2));
+}
+}
\ No newline at end of file
diff --git a/duration3.class b/duration3.class
new file mode 100644
index 0000000..be42507
Binary files /dev/null and b/duration3.class differ
diff --git a/duration3.java b/duration3.java
new file mode 100644
index 0000000..7497087
--- /dev/null
+++ b/duration3.java
@@ -0,0 +1,13 @@
+import java.time.*;
+class duration3
+{
+public static void main(String args[])
+{
+Duration d=Duration.ofHours(10);
+System.out.println(d);
+
+Duration d2=Duration.ofHours(10);
+System.out.println(d2);
+System.out.println(d.equals(d2));
+}
+}
\ No newline at end of file
diff --git a/duration4.class b/duration4.class
new file mode 100644
index 0000000..b6398f3
Binary files /dev/null and b/duration4.class differ
diff --git a/duration4.java b/duration4.java
new file mode 100644
index 0000000..0736fe1
--- /dev/null
+++ b/duration4.java
@@ -0,0 +1,10 @@
+import java.time.*;
+class duration4
+{
+public static void main(String args[])
+{
+Duration d=Duration.parse("P3DT5H4M");
+System.out.println("Duration is:"+d);
+System.out.println("Number of hours is:"+d.toHours());
+}
+}
diff --git a/duration5.class b/duration5.class
new file mode 100644
index 0000000..b978898
Binary files /dev/null and b/duration5.class differ
diff --git a/duration5.java b/duration5.java
new file mode 100644
index 0000000..53ba52c
--- /dev/null
+++ b/duration5.java
@@ -0,0 +1,10 @@
+import java.time.*;
+class duration5
+{
+public static void main(String args[])
+{
+Duration d=Duration.ofHours(20);
+System.out.println(d.toHours());
+}
+}
+																																																		
\ No newline at end of file
diff --git a/enum6.class b/enum6.class
new file mode 100644
index 0000000..2dee1c5
Binary files /dev/null and b/enum6.class differ
diff --git a/enum6.java b/enum6.java
new file mode 100644
index 0000000..2c09afd
--- /dev/null
+++ b/enum6.java
@@ -0,0 +1,23 @@
+import java.util.*;
+enum sujit
+{
+GFG,JAVA,PYTHON,WATER,KUSHAL,BABU;
+}
+
+class enum6
+{
+public static void main(String arg[])
+{
+Set<sujit> s=EnumSet.range(sujit.GFG,sujit.KUSHAL);
+System.out.println("the value is:"+s);
+
+Set<sujit> set=EnumSet.range(sujit.GFG,sujit.WATER);
+System.out.println("the set is:"+set);
+
+Set<sujit> s3=EnumSet.range(sujit.JAVA,sujit.KUSHAL);	
+System.out.println("the value is:"+s3);
+Set<sujit> s4=EnumSet.of(sujit.GFG,sujit.JAVA,sujit.PYTHON,sujit.WATER);
+System.out.println("the value is:"+s4);
+
+}
+}
\ No newline at end of file
diff --git a/enumIterate.class b/enumIterate.class
new file mode 100644
index 0000000..d6bba87
Binary files /dev/null and b/enumIterate.class differ
diff --git a/enumIterate.java b/enumIterate.java
new file mode 100644
index 0000000..8facc82
--- /dev/null
+++ b/enumIterate.java
@@ -0,0 +1,24 @@
+import java.util.*;
+class enumIterate
+{
+public static void main(String args[])
+{
+Vector v=new Vector();
+v.add("sujit");
+v.add("kushal");
+v.add("kumar");
+v.add("vikash");
+System.out.println(v);
+
+v.forEach(e->System.out.println(e));
+
+ArrayList<Integer> l=new ArrayList<>();
+l.add(90);
+l.add(10);
+l.add(20);
+l.add(30);
+System.out.println(l);
+
+l.forEach(e->System.out.println(e));
+}
+}
\ No newline at end of file
diff --git a/equals1.class b/equals1.class
new file mode 100644
index 0000000..412d1ca
Binary files /dev/null and b/equals1.class differ
diff --git a/equals1.java b/equals1.java
new file mode 100644
index 0000000..c0daaf7
--- /dev/null
+++ b/equals1.java
@@ -0,0 +1,19 @@
+import java.time.*;
+class equals1
+{
+public static void main(String args[])
+{
+ZoneId z=ZoneId.of("Asia/Tokyo");
+Clock c=Clock.system(z);
+ZonedDateTime z1=c.instant().atZone(c.getZone());
+System.out.println(z1.toString());
+
+Clock c2=Clock.systemDefaultZone();
+ZonedDateTime z2=c2.instant().atZone(c2.getZone());
+System.out.println(z2.toString());
+
+boolean res=c.equals(c2);
+System.out.println("Is it equals:"+res);
+
+}
+}
\ No newline at end of file
diff --git a/equals3.class b/equals3.class
new file mode 100644
index 0000000..2813408
Binary files /dev/null and b/equals3.class differ
diff --git a/equals3.java b/equals3.java
new file mode 100644
index 0000000..928dc95
--- /dev/null
+++ b/equals3.java
@@ -0,0 +1,22 @@
+class Student
+{
+String name;
+int roll;
+Student(String name,int roll)
+{
+this.name=name;
+this.roll=roll;
+}
+public String toString()
+{
+return String.format(name+" "+roll);
+}
+}
+class equals3
+{
+public static void main(String args[])
+{
+Student s1=new Student("gaurav",125);
+System.out.println(s1);
+}
+}
\ No newline at end of file
diff --git a/equals4.java b/equals4.java
new file mode 100644
index 0000000..db22894
--- /dev/null
+++ b/equals4.java
@@ -0,0 +1,25 @@
+class Collage
+{
+String name;
+int roll;
+Collage(String name,int roll)
+{
+this.name=name;
+this.roll=roll;
+}
+
+public String toString()
+{
+return String.format(name+" "+roll);
+}
+
+}
+
+class equals4
+{
+public static void main(String args[])
+{
+Collage c=new Collage("gaurav",10);
+System.out.println(c);
+}
+}
\ No newline at end of file
diff --git a/findArea.class b/findArea.class
new file mode 100644
index 0000000..8bced5a
Binary files /dev/null and b/findArea.class differ
diff --git a/findArea.java b/findArea.java
new file mode 100644
index 0000000..0b02b59
--- /dev/null
+++ b/findArea.java
@@ -0,0 +1,47 @@
+abstract class  Shape
+{
+String color;
+abstract double area();
+public abstract String toString();
+
+Shape(String color)
+{
+this.color=color;
+}
+
+public String getColor()
+{
+return color;
+}
+}
+
+
+class Circle extends Shape
+{
+double radius;
+Circle(String color,double radius)
+{
+super(color);
+this.radius=radius;
+}
+
+double area()
+{
+return(Math.PI*Math.pow(radius,2));
+}
+
+
+public String toString()
+{
+return("Color is:"+super.getColor()+"  and area is:"+area());
+}
+}
+
+class findArea
+{
+public static void main(String args[])
+{
+Circle c=new Circle("Blue",10);
+System.out.println(c.toString());
+}
+}
\ No newline at end of file
diff --git a/findArea1.class b/findArea1.class
new file mode 100644
index 0000000..700f405
Binary files /dev/null and b/findArea1.class differ
diff --git a/findArea1.java b/findArea1.java
new file mode 100644
index 0000000..0070b51
--- /dev/null
+++ b/findArea1.java
@@ -0,0 +1,48 @@
+abstract class Shape
+{
+String shape;
+abstract double area();
+public abstract String toString();
+
+Shape(String shape)
+{
+this.shape=shape;
+}
+
+public String getShape()
+{
+return shape;
+}
+
+}
+
+class Rectangle extends Shape
+{
+int length;
+int breadth;
+Rectangle(String shape,int length,int breadth)
+{
+super(shape);
+this.length=length;
+this.breadth=breadth;
+}
+
+double area()
+{
+return(0.5*length*breadth);
+}
+
+public String toString()
+{
+return("Shape="+super.getShape()+" and area is:"+area());
+}
+}
+
+class findArea1
+{
+public static void main(String args[])
+{
+Rectangle r=new Rectangle("rectangle",10,20);
+System.out.println(r.toString());
+}
+}
\ No newline at end of file
diff --git a/findArea4.class b/findArea4.class
new file mode 100644
index 0000000..0a20bed
Binary files /dev/null and b/findArea4.class differ
diff --git a/findArea4.java b/findArea4.java
new file mode 100644
index 0000000..186e27f
--- /dev/null
+++ b/findArea4.java
@@ -0,0 +1,44 @@
+abstract class Shape
+{
+String shape;
+abstract double area();
+public abstract String toString();
+Shape(String shape)
+{
+this.shape=shape;
+}
+
+String getShape()
+{
+return shape;
+}
+}
+
+class Square extends Shape
+{
+double side;
+Square(String shape,double side)
+{
+super(shape);
+this.side=side;
+}
+
+double area()
+{
+return Math.pow(side,2);
+}
+
+public String toString()
+{
+return("Shape="+super.getShape()+" area="+area());
+}
+}
+
+class findArea4
+{
+public static void main(String args[])
+{
+Square s=new Square("square",10);
+System.out.println(s.toString());
+}
+}
\ No newline at end of file
diff --git a/findDuplicate1.java b/findDuplicate1.java
new file mode 100644
index 0000000..62dd0e5
--- /dev/null
+++ b/findDuplicate1.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class findDuplicate1
+{
+public static void main(String args[])
+{
+String s="Gaurav";
+List<Character> l=new ArrayList<>();
+char c[]=s.toCharArray();
+for(int i=0;i<c.length;i++)
+{
+if(!l.contains(c[i]))
+{
+l.add(c[i]);
+}
+}
+
+System.out.println(Arrays.toString(c));
+}
+}
\ No newline at end of file
diff --git a/findMissing.class b/findMissing.class
new file mode 100644
index 0000000..a97e1a4
Binary files /dev/null and b/findMissing.class differ
diff --git a/findMissing.java b/findMissing.java
new file mode 100644
index 0000000..6085c32
--- /dev/null
+++ b/findMissing.java
@@ -0,0 +1,32 @@
+//Find the missing number in a sorted array in java
+
+import java.util.*;
+class findMissing
+{
+public static void main(String args[])
+{
+Scanner sc=new Scanner(System.in);
+int n=sc.nextInt();
+int a[]=new int[n];
+int j=0;
+String sum="";
+for(int i=0;i<n;i++)
+{
+a[i]=sc.nextInt();
+}
+
+for(int i=0;i<n;i++)
+{
+if(a[i]==j)
+{
+j++;
+}
+else
+{
+sum+=j+" ";
+j++;
+}
+}
+System.out.println("The missing number is:"+sum);
+}
+}
\ No newline at end of file
diff --git a/first.class b/first.class
new file mode 100644
index 0000000..460cdb5
Binary files /dev/null and b/first.class differ
diff --git a/frequancy.class b/frequancy.class
new file mode 100644
index 0000000..cf3fcad
Binary files /dev/null and b/frequancy.class differ
diff --git a/frequancy.java b/frequancy.java
new file mode 100644
index 0000000..fc3cacf
--- /dev/null
+++ b/frequancy.java
@@ -0,0 +1,13 @@
+import java.util.*;
+class  frequancy
+{
+public static void main(String args[])
+{
+List<String> l=new ArrayList<>();
+l.add("gaurav");
+l.add("kumar");
+l.add("sujit");
+l.add("sujit");
+System.out.println(Collections.frequency(l,"sujit"));
+}
+}
\ No newline at end of file
diff --git a/frequancy1.java b/frequancy1.java
new file mode 100644
index 0000000..ea183a2
--- /dev/null
+++ b/frequancy1.java
@@ -0,0 +1,10 @@
+import java.util.*;
+class frequancy1
+{
+public static void main(String args[])
+{
+Integer a[]={10,20,10,12,10,22,11,10};
+int freq=Collections.frequancy(Arrays.asList(a),10));
+System.out.printn(freq);
+}
+}
\ No newline at end of file
diff --git a/gaurav.class b/gaurav.class
new file mode 100644
index 0000000..c4781d7
Binary files /dev/null and b/gaurav.class differ
diff --git a/gaurav.txt b/gaurav.txt
new file mode 100644
index 0000000..506219a
Binary files /dev/null and b/gaurav.txt differ
diff --git a/gfg.class b/gfg.class
new file mode 100644
index 0000000..b44f968
Binary files /dev/null and b/gfg.class differ
diff --git a/hello.class b/hello.class
new file mode 100644
index 0000000..fd00d0a
Binary files /dev/null and b/hello.class differ
diff --git a/highest.class b/highest.class
new file mode 100644
index 0000000..3f282a7
Binary files /dev/null and b/highest.class differ
diff --git a/highest.java b/highest.java
new file mode 100644
index 0000000..85c27e7
--- /dev/null
+++ b/highest.java
@@ -0,0 +1,26 @@
+import java.util.*;
+class highest
+{
+public static void main(String args[])
+{
+HashMap<String,Integer> map=new HashMap<>();
+map.put("gaurav",10);
+map.put("ankit",20);
+map.put("aman",30);
+map.put("suraj",50);
+map.put("sujit",40);
+System.out.println(map);
+Map.Entry<String,Integer> max=null;
+for(Map.Entry<String,Integer> m:map.entrySet())
+{
+if(max==null || m.getKey().compareTo(max.getKey())>0)
+{
+max=m;
+
+}
+
+}
+System.out.println(max);
+}
+
+}
\ No newline at end of file
diff --git a/human.class b/human.class
new file mode 100644
index 0000000..3948df4
Binary files /dev/null and b/human.class differ
diff --git a/human.java b/human.java
new file mode 100644
index 0000000..c021bc6
--- /dev/null
+++ b/human.java
@@ -0,0 +1,20 @@
+class sujit
+{
+int x=10;
+}
+
+class kushal extends sujit
+{
+int x=20;
+}
+
+class human
+{
+public static void main(String args[])
+{
+sujit s=new sujit();
+System.out.println(s.x);
+kushal k=new kushal();
+System.out.println(k.x);
+}
+}
\ No newline at end of file
diff --git a/human1.java b/human1.java
new file mode 100644
index 0000000..0617b80
--- /dev/null
+++ b/human1.java
@@ -0,0 +1,18 @@
+class kumar
+{
+int y=100;
+}
+
+class sujit extends kumar
+{
+int y=99;
+}
+
+class human1
+{
+public static void main(String args[])
+{
+kumar k=new kumar();
+System.out.println(k.x);
+}
+}
\ No newline at end of file
diff --git a/hushMap.class b/hushMap.class
new file mode 100644
index 0000000..f58b157
Binary files /dev/null and b/hushMap.class differ
diff --git a/hushMap.java b/hushMap.java
new file mode 100644
index 0000000..d5ea28d
--- /dev/null
+++ b/hushMap.java
@@ -0,0 +1,14 @@
+import java.util.*;
+class hushMap
+{
+public static void main(String args[])
+{
+HashMap<Integer,Integer> k=new HashMap<>();
+k.put(10,1);
+k.put(20,2);
+k.put(30,3);
+k.put(50,4);
+System.out.println("Size of Map is:"+k.size());
+System.out.println("Map is:"+k);
+}
+}
\ No newline at end of file
diff --git a/immu.class b/immu.class
new file mode 100644
index 0000000..3114f97
Binary files /dev/null and b/immu.class differ
diff --git a/immu.java b/immu.java
new file mode 100644
index 0000000..0e2972a
--- /dev/null
+++ b/immu.java
@@ -0,0 +1,18 @@
+import java.util.*;
+class immu
+{
+static void immutable(Map<Integer,String> map)
+{
+map=Collections.unmodifiableMap(map);
+map.put(5,"kushal");
+System.out.println(map);
+}
+public static void main(String args[])
+{
+Map<Integer,String> map=new HashMap<>();
+map.put(1,"gaurav");
+map.put(2,"sujit");
+map.put(3,"vikash");
+immutable(map);
+}
+}
\ No newline at end of file
diff --git a/immuta.class b/immuta.class
new file mode 100644
index 0000000..12590d7
Binary files /dev/null and b/immuta.class differ
diff --git a/immuta.java b/immuta.java
new file mode 100644
index 0000000..8e37f8f
--- /dev/null
+++ b/immuta.java
@@ -0,0 +1,13 @@
+import java.util.*;
+class immuta
+{
+public static void main(String args[])
+{
+Map<Integer,Integer> map=Map.ofEntries(Map.entry(1,20),Map.entry(2,30),
+                            Map.entry(3,40),Map.entry(4,50));
+
+//map.put(5,30);
+System.out.println("Immutable map is:"+map);
+}
+}
+      
\ No newline at end of file
diff --git a/immuta1.class b/immuta1.class
new file mode 100644
index 0000000..45943e5
Binary files /dev/null and b/immuta1.class differ
diff --git a/immuta1.java b/immuta1.java
new file mode 100644
index 0000000..999fb09
--- /dev/null
+++ b/immuta1.java
@@ -0,0 +1,18 @@
+import java.util.*;
+class immuta1
+{
+public static void main(String args[])
+{
+Map<Integer,String> map=new HashMap<>();
+map.put(1,"gaurav");
+map.put(2,"sujit");
+map.put(3,"kumar");
+map.put(4,"kushal");
+map.put(5,"vikash");
+System.out.println("Map is: " +map);
+
+Map<Integer,String> map1=Map.copyOf(map);
+map1.put(6,"kunal");
+System.out.println("Another map is:"+map1);
+}
+}
\ No newline at end of file
diff --git a/inter.class b/inter.class
new file mode 100644
index 0000000..33963c8
Binary files /dev/null and b/inter.class differ
diff --git a/inter.java b/inter.java
new file mode 100644
index 0000000..88a7000
--- /dev/null
+++ b/inter.java
@@ -0,0 +1,33 @@
+interface one
+{
+public void run();
+}
+
+interface two
+{
+public void read();
+}
+
+class sujit implements one,two
+{
+public void run()
+{
+System.out.println("I am doing my work");
+}
+
+public void read()
+{
+System.out.println("I am walking");
+}
+}
+
+class inter
+{
+public static void main(String args[])
+{
+sujit s=new sujit();
+s.run();
+s.read();
+
+}
+}
\ No newline at end of file
diff --git a/interf.class b/interf.class
new file mode 100644
index 0000000..20ef993
Binary files /dev/null and b/interf.class differ
diff --git a/interf.java b/interf.java
new file mode 100644
index 0000000..24faae1
--- /dev/null
+++ b/interf.java
@@ -0,0 +1,32 @@
+interface car
+{
+public void drive();
+}
+
+interface motor
+{
+public void walk();
+}
+
+class kumar implements car,motor
+{
+public void drive()
+{
+System.out.println("Hello friend,how can i drive this");
+}
+
+public void walk()
+{
+System.out.println("Hello walk! what's the fuck");
+}
+}
+
+class interf
+{
+public static void main(String args[])
+{
+kumar k=new kumar();
+k.drive();
+k.walk();
+}
+}
\ No newline at end of file
diff --git a/intersec$Node.class b/intersec$Node.class
new file mode 100644
index 0000000..a2a3c0b
Binary files /dev/null and b/intersec$Node.class differ
diff --git a/intersec.class b/intersec.class
new file mode 100644
index 0000000..31a5e34
Binary files /dev/null and b/intersec.class differ
diff --git a/intersec.java b/intersec.java
new file mode 100644
index 0000000..11775a1
--- /dev/null
+++ b/intersec.java
@@ -0,0 +1,94 @@
+import java.util.*;
+class intersec
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+intersec intersection(Node head1,Node head2)
+{
+if(head1==null && head2==null)
+{
+System.out.println("null");
+}
+Node temp1=head1;
+Node temp2=head2;
+HashSet<Integer> set=new HashSet<>();
+intersec s3=new intersec();
+while(temp1!=null)
+{
+set.add(temp1.data);
+temp1=temp1.next;
+}
+
+while(temp2!=null)
+{
+
+if(set.contains(temp2.data))
+{
+s3.append(temp2.data);
+}
+temp2=temp2.next;
+}
+return s3;
+}
+public static void main(String args[])
+{
+intersec s=new intersec();
+intersec s1=new intersec();
+
+intersec l1=new intersec();
+intersec l2=new intersec();
+
+s.append(10);
+s.append(20);
+s.append(30);
+s.append(40);
+System.out.println("first list is:");
+s.print();
+System.out.println("Second list is:");
+s1.append(10);
+s1.append(25);
+s1.append(40);
+s1.print();
+System.out.println("Intersection of two linkedlist");
+l2=l1.intersection(s.head,s1.head);
+l2.print();
+}
+}
\ No newline at end of file
diff --git a/jagged.class b/jagged.class
new file mode 100644
index 0000000..fe625c3
Binary files /dev/null and b/jagged.class differ
diff --git a/jagged.java b/jagged.java
new file mode 100644
index 0000000..6ff8d9f
--- /dev/null
+++ b/jagged.java
@@ -0,0 +1,29 @@
+class jagged
+{
+public static void main(String args[])
+{
+int a[][]=new int[2][];
+a[0]=new int[2];
+a[1]=new int[2];
+int count=0;
+for(int i=0;i<a.length;i++)
+{
+for(int j=0;j<a[i].length;j++)
+{
+a[i][j]=count;
+count++;
+}
+}
+
+System.out.println("Display the array is:");
+for(int i=0;i<a.length;i++)
+{
+for(int j=0;j<a[i].length;j++)
+{
+System.out.print(a[i][j]+" ");
+}
+System.out.println();
+}
+
+}
+}
\ No newline at end of file
diff --git a/javaReflect.class b/javaReflect.class
new file mode 100644
index 0000000..7776e9e
Binary files /dev/null and b/javaReflect.class differ
diff --git a/javaReflect.java b/javaReflect.java
new file mode 100644
index 0000000..50d9e8f
--- /dev/null
+++ b/javaReflect.java
@@ -0,0 +1,21 @@
+import java.lang.reflect.Array;
+import java.util.*;
+class javaReflect
+{
+public static void main(String args[])
+{
+int size=5;
+int a[]=(int[])Array.newInstance(int.class,size);
+System.out.println(Arrays.toString(a));
+Array.setInt(a,0,10);
+Array.setInt(a,1,20);
+Array.setInt(a,2,30);
+Array.setInt(a,3,50);
+Array.setInt(a,4,90);
+System.out.println(Arrays.toString(a));
+System.out.println("At position at index 0:"+Array.getInt(a,0));
+System.out.println("At position at index 1:"+Array.getInt(a,1));
+System.out.println("At position at index 2:"+Array.getInt(a,2));
+System.out.println("At position at index 3:"+Array.getInt(a,3));
+}
+}
\ No newline at end of file
diff --git a/keep.class b/keep.class
new file mode 100644
index 0000000..8416140
Binary files /dev/null and b/keep.class differ
diff --git a/keep.java b/keep.java
new file mode 100644
index 0000000..ce8cb3f
--- /dev/null
+++ b/keep.java
@@ -0,0 +1,28 @@
+class keep extends Thread
+{
+public static void main(String args[])
+{
+Thread t1=Thread.currentThread();
+System.out.println("current thread is:"+t1.getName());
+System.out.println("Priority is:"+t1.getPriority());
+t1.setPriority(MAX_PRIORITY);
+System.out.println("max priority is:"+t1.getPriority());
+t1.setName("kushal");
+System.out.println("after change:"+t1.getName());
+
+childthread c=new childthread();
+System.out.println("child prority is:"+c.getPriority());
+c.setPriority(MIN_PRIORITY);
+System.out.println("Child priority is:"+c.getPriority());
+c.start();
+}
+}
+
+class childthread extends Thread
+{
+public void run()
+{
+System.out.println("child thread");
+}
+
+}
\ No newline at end of file
diff --git a/kumar.class b/kumar.class
new file mode 100644
index 0000000..93db23d
Binary files /dev/null and b/kumar.class differ
diff --git a/kumar1.class b/kumar1.class
new file mode 100644
index 0000000..5665525
Binary files /dev/null and b/kumar1.class differ
diff --git a/kumar1.java b/kumar1.java
new file mode 100644
index 0000000..cdc5c6b
--- /dev/null
+++ b/kumar1.java
@@ -0,0 +1,52 @@
+class Gaurav
+{
+void eat()
+{
+System.out.println("I am not eating");
+}
+
+void driving()
+{
+System.out.println("I am driving a car");
+}
+
+void read()
+{
+
+System.out.println("I am reading something");
+}
+
+}
+
+class vikash extends Gaurav
+{
+void run()
+{
+System.out.println("I gonna run");
+}
+
+void sleep()
+{
+System.out.println("Hello can i sleep with you");
+}
+}
+
+class kumar1 extends vikash
+{
+void run()
+{
+System.out.println("kumar is running");
+}
+public static void main(String args[])
+{
+kumar1 k=new kumar1();
+k.run();
+k.sleep();
+k.driving();
+
+vikash v=new vikash();
+v.eat();
+v.driving();
+v.read();
+}
+}
\ No newline at end of file
diff --git a/kumar2.class b/kumar2.class
new file mode 100644
index 0000000..86e7a0d
Binary files /dev/null and b/kumar2.class differ
diff --git a/kumar2.java b/kumar2.java
new file mode 100644
index 0000000..18af887
--- /dev/null
+++ b/kumar2.java
@@ -0,0 +1,33 @@
+class sujit
+{
+void read()
+{
+System.out.println("Hello i am doing something");
+}
+
+void play()
+{
+System.out.println("I gonna play");
+}
+}
+
+class gaurav extends sujit
+{
+void  sleep()
+{
+System.out.println("I am sleeping");
+}
+}
+
+class kumar2 extends sujit
+{
+void dance()
+{
+System.out.println("Dance is the favourite part of my life");
+}
+public static void main(String args[])
+{
+kumar2 k=new kumar2();
+k.dance();
+}
+}
\ No newline at end of file
diff --git a/kumarKo.class b/kumarKo.class
new file mode 100644
index 0000000..314694f
Binary files /dev/null and b/kumarKo.class differ
diff --git a/kumarKo.java b/kumarKo.java
new file mode 100644
index 0000000..dbac87e
--- /dev/null
+++ b/kumarKo.java
@@ -0,0 +1,25 @@
+class Teacher
+{
+String name;
+String collage;
+Teacher()
+{
+this("gaurav","NIT");
+System.out.println("Another constructor will called");
+}
+
+Teacher(String name,String collage)
+{
+this.name=name;
+this.collage=collage;
+}
+}
+
+class kumarKo
+{
+public static void main(String args[])
+{
+Teacher t=new Teacher();
+System.out.println("Name="+t.name+" and collage="+t.collage);
+}
+}
\ No newline at end of file
diff --git a/kumarThis.class b/kumarThis.class
new file mode 100644
index 0000000..f4b1fe8
Binary files /dev/null and b/kumarThis.class differ
diff --git a/kumarThis.java b/kumarThis.java
new file mode 100644
index 0000000..27139b0
--- /dev/null
+++ b/kumarThis.java
@@ -0,0 +1,24 @@
+class Student
+{
+int a;
+int b;
+Student(int a)
+{
+this(10,20);
+System.out.println("Another constructor will called "+a);
+}
+
+Student(int a,int b)
+{
+System.out.println("a="+a+" and b="+b);
+}
+
+}
+
+class kumarThis
+{
+public static void main(String args[])
+{
+Student s=new Student(12);
+}
+}
\ No newline at end of file
diff --git a/kushal.class b/kushal.class
new file mode 100644
index 0000000..69fbdc3
Binary files /dev/null and b/kushal.class differ
diff --git a/kv.txt b/kv.txt
new file mode 100644
index 0000000..48c24e0
--- /dev/null
+++ b/kv.txt
@@ -0,0 +1 @@
+https://kvsonlineadmission.kvs.gov.in/application.html
\ No newline at end of file
diff --git a/linkedHash1.class b/linkedHash1.class
new file mode 100644
index 0000000..41aff51
Binary files /dev/null and b/linkedHash1.class differ
diff --git a/linkedHash1.java b/linkedHash1.java
new file mode 100644
index 0000000..01d8f79
--- /dev/null
+++ b/linkedHash1.java
@@ -0,0 +1,18 @@
+import java.util.*;
+class linkedHash1
+{
+public static void main(String args[])
+{
+LinkedHashSet<Integer> set=new LinkedHashSet<>();
+set.add(1);
+set.add(10);
+set.add(12);
+set.add(13);
+System.out.println(set);
+Iterator i=set.iterator();
+while(i.hasNext())
+{
+System.out.println(i.next());
+}
+}
+}
\ No newline at end of file
diff --git a/load.class b/load.class
new file mode 100644
index 0000000..e323047
Binary files /dev/null and b/load.class differ
diff --git a/load.java b/load.java
new file mode 100644
index 0000000..72ee588
--- /dev/null
+++ b/load.java
@@ -0,0 +1,30 @@
+class Student
+{
+void show()
+{
+System.out.println("I will show you something");
+
+}
+
+void show(byte a)
+{
+System.out.println("The value is:"+a);
+}
+
+void show(int a)
+{
+System.out.println("The value is:"+a);
+}
+}
+
+class load
+{
+public static void main(String args[])
+{
+Student s=new Student();
+s.show();
+byte a=52;
+s.show(a);
+s.show(123);
+}
+}
\ No newline at end of file
diff --git a/map3.class b/map3.class
new file mode 100644
index 0000000..5bce3c6
Binary files /dev/null and b/map3.class differ
diff --git a/map3.java b/map3.java
new file mode 100644
index 0000000..7d81bd8
--- /dev/null
+++ b/map3.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class map3
+{
+public static void main(String args[])
+{
+HashMap<Integer,String> map=new HashMap<>();
+map.put(1,"gaurav");
+map.put(2,"sujit");
+map.put(3,"kushal");
+System.out.println("Map is:"+map);
+
+Iterator i=map.entrySet().iterator();
+while(i.hasNext())
+{
+Map.Entry m=(Map.Entry)i.next();
+int x=(int)m.getKey()+10;
+System.out.println(x+": "+m.getValue());
+}
+}
+}
\ No newline at end of file
diff --git a/matchString.class b/matchString.class
new file mode 100644
index 0000000..3758492
Binary files /dev/null and b/matchString.class differ
diff --git a/matchString.java b/matchString.java
new file mode 100644
index 0000000..de71c47
--- /dev/null
+++ b/matchString.java
@@ -0,0 +1,18 @@
+class matchString
+{
+public static void main(String args[])
+{
+String s="geeksforgeeks";
+String k="geekus";
+boolean x=s.contains(k);
+if(x)
+{
+System.out.println("Pattern found");
+}
+else
+{
+System.out.println("Pattern Not Found");
+}
+
+}
+}
\ No newline at end of file
diff --git a/maxKey.class b/maxKey.class
new file mode 100644
index 0000000..f9b485a
Binary files /dev/null and b/maxKey.class differ
diff --git a/maxKey.java b/maxKey.java
new file mode 100644
index 0000000..f47ec78
--- /dev/null
+++ b/maxKey.java
@@ -0,0 +1,24 @@
+import java.util.*;
+class maxKey
+{
+public static void main(String args[])
+{
+Map<Integer,Integer> map=new HashMap<>();
+map.put(2,10);
+map.put('
+5,20);
+map.put(4,30);
+System.out.println("Map is:"+map);
+
+Map.Entry<Integer,Integer> entryMax=null;
+for(Map.Entry<Integer,Integer> m:map.entrySet())
+{
+if(entryMax==null|| m.getKey().compareTo(entryMax.getKey())>0)
+{
+entryMax=m;
+}
+}
+System.out.println("Highest Entry is:"+entryMax);
+
+}
+}
diff --git a/merge.class b/merge.class
new file mode 100644
index 0000000..49cc2dc
Binary files /dev/null and b/merge.class differ
diff --git a/merge.java b/merge.java
new file mode 100644
index 0000000..25f0d28
--- /dev/null
+++ b/merge.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class merge
+{
+public static void main(String args[])
+{
+int a[]={1,2,3,4,5};
+int b[]={5,10,23,45};
+ArrayList<Integer> l=new ArrayList<>();
+for(int i:a)
+{
+l.add(i);
+}
+for(int j:b)
+{
+l.add(j);
+}
+System.out.println(l);
+}
+}
\ No newline at end of file
diff --git a/merge3.java b/merge3.java
new file mode 100644
index 0000000..8c2b102
--- /dev/null
+++ b/merge3.java
@@ -0,0 +1,64 @@
+class merge4
+{
+int array[];
+int length;
+int temp[];
+public static void main(String args[])
+{
+int a[]={4,5,2,1,9};
+merge4 m=new merge4();
+m.ArraySort(a);
+
+for(int i=0;i<a.length;i++)
+{
+System.out.print(a[i]+" ");
+}
+}
+
+void ArraySort(int a[])
+{
+this.array=a;
+this.length=a.length;
+this.temp=new int[length];
+divide(0,length-1);
+}
+
+void divide(int lower,int higher)
+{
+int middle=lower+(higher-lower)/2;
+divide(lower,middle);
+divide(middle+1,higher);
+merge(lower,middle,higher);
+}
+
+void merge(int lower,int middle,int higher)
+{
+for(int i=lower;i<higher;i++)
+{
+temp[i]=array[i];
+}
+int i=lower;
+int j=middle+1;
+int k=lower;
+while(i<=middle && j<=higher)
+{
+if(temp[i]<=temp[j])
+{
+array[k]=temp[i];
+i++;
+}
+else
+{
+array[k]=temp[j];
+j++;
+}
+k++;
+}
+while(i<=middle)
+{
+array[k]=temp[i];
+i++;
+k++;
+}
+}
+}
diff --git a/merge4.class b/merge4.class
new file mode 100644
index 0000000..1972635
Binary files /dev/null and b/merge4.class differ
diff --git a/mid$Node.class b/mid$Node.class
new file mode 100644
index 0000000..75dbc67
Binary files /dev/null and b/mid$Node.class differ
diff --git a/mid.class b/mid.class
new file mode 100644
index 0000000..0e482fc
Binary files /dev/null and b/mid.class differ
diff --git a/mid.java b/mid.java
new file mode 100644
index 0000000..2bc53df
--- /dev/null
+++ b/mid.java
@@ -0,0 +1,66 @@
+class mid
+{
+Node head;
+class Node
+{
+Node next;
+int data;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Node middle()
+{
+Node slow=head;
+Node fast=head.next;
+while(fast!=null && fast.next!=null)
+{
+slow=slow.next;
+fast=fast.next.next;
+}
+Node mid=slow.next;
+slow.next=null;
+return mid;
+}
+
+public static void main(String args[])
+{
+mid s=new mid();
+s.append(4);
+s.append(3);
+s.append(2);
+s.append(1);
+s.print();
+Node k=s.middle();
+System.out.println(k);
+}
+}                                                             
\ No newline at end of file
diff --git a/mili.class b/mili.class
new file mode 100644
index 0000000..cd80c8f
Binary files /dev/null and b/mili.class differ
diff --git a/mili.java b/mili.java
new file mode 100644
index 0000000..b2b7947
--- /dev/null
+++ b/mili.java
@@ -0,0 +1,10 @@
+import java.time.*;
+class mili
+{
+public static void main(String args[])
+{
+Clock c=Clock.systemDefaultZone();
+long miliSecond=c.millis();
+System.out.println("The miliseconds is:"+miliSecond);
+}
+}
\ No newline at end of file
diff --git a/mili1.class b/mili1.class
new file mode 100644
index 0000000..6d4b501
Binary files /dev/null and b/mili1.class differ
diff --git a/mili1.java b/mili1.java
new file mode 100644
index 0000000..167dcb6
--- /dev/null
+++ b/mili1.java
@@ -0,0 +1,11 @@
+import java.time.*;
+class mili1
+{
+public static void main(String args[])
+{
+ZoneId z=ZoneId.of("Asia/Tokyo");
+Clock c=Clock.system(z);
+long miliSeconds =c.millis();
+System.out.println("The time is:"+miliSeconds);
+}
+}
\ No newline at end of file
diff --git a/moto.class b/moto.class
new file mode 100644
index 0000000..429118d
Binary files /dev/null and b/moto.class differ
diff --git a/moto.java b/moto.java
new file mode 100644
index 0000000..4f7492c
--- /dev/null
+++ b/moto.java
@@ -0,0 +1,38 @@
+class Bicycle
+{
+int gear;
+int speed;
+Bicycle(int gear,int speed)
+{
+this.gear=gear;
+this.speed=speed;
+}
+public String toString()
+{
+return("Gear="+gear+" Speed="+speed);
+}
+}
+
+class motor extends Bicycle
+{
+int height;
+motor(int gear,int speed,int height)
+{
+super(gear,speed);
+this.height=height;
+}
+
+public String toString()
+{
+return(super.toString()+" Height="+height);
+}
+}
+
+class moto
+{
+public static void main(String args[])
+{
+motor m=new motor(2,4,30);
+System.out.println(m.toString());
+}
+}
\ No newline at end of file
diff --git a/moto1.class b/moto1.class
new file mode 100644
index 0000000..fca2c8d
Binary files /dev/null and b/moto1.class differ
diff --git a/moto1.java b/moto1.java
new file mode 100644
index 0000000..55be536
--- /dev/null
+++ b/moto1.java
@@ -0,0 +1,41 @@
+class Bicycle
+{
+int gear;
+int speed;
+Bicycle(int gear,int speed)
+{
+this.gear=gear;
+this.speed=speed;
+}
+
+public String toString()
+{
+return("Gear="+gear+" Speed="+speed);
+}
+}
+
+class Bike extends Bicycle
+{
+int height;
+Bike(int gear,int speed,int height)
+{
+super(gear,speed);
+this.height=height;
+}
+
+public String toString()
+{
+return(super.toString()+" Height="+height);
+}
+}
+
+class moto1
+{
+public static void main(String args[])
+{
+Bike b=new Bike(6,5,20);
+Bike b1=new Bike(10,3,30);
+System.out.println(b.toString());
+System.out.println(b1.toString());
+}
+}
\ No newline at end of file
diff --git a/motor.class b/motor.class
new file mode 100644
index 0000000..9eb486c
Binary files /dev/null and b/motor.class differ
diff --git a/mul.class b/mul.class
new file mode 100644
index 0000000..0d611f3
Binary files /dev/null and b/mul.class differ
diff --git a/mul.java b/mul.java
new file mode 100644
index 0000000..dc33fe5
--- /dev/null
+++ b/mul.java
@@ -0,0 +1,16 @@
+class mul
+{
+public static void main(String args[])
+{
+int a[][]={{1,2,3},{4,5,6},{7,8,9}};
+for(int i=0;i<a.length;i++)
+{
+for(int j=0;j<a[i].length;j++)
+{
+System.out.print(a[i][j]+" ");
+}
+System.out.println();
+}
+
+}
+}
\ No newline at end of file
diff --git a/multi.class b/multi.class
new file mode 100644
index 0000000..e87bc7c
Binary files /dev/null and b/multi.class differ
diff --git a/multi.java b/multi.java
new file mode 100644
index 0000000..de85fda
--- /dev/null
+++ b/multi.java
@@ -0,0 +1,18 @@
+//-----------------Sum of Arrays Values------------------
+class multi
+{
+static int sumArray(int a[])
+{
+int sum=0;
+for(int i=0;i<a.length;i++)
+{
+sum+=a[i];
+}
+return sum;
+}
+public static void main(String args[])
+{
+int a[]={12,2,3,4,5};
+System.out.println(sumArray(a));
+}
+}
\ No newline at end of file
diff --git a/multi1.class b/multi1.class
new file mode 100644
index 0000000..87c38fb
Binary files /dev/null and b/multi1.class differ
diff --git a/multi1.java b/multi1.java
new file mode 100644
index 0000000..47297d4
--- /dev/null
+++ b/multi1.java
@@ -0,0 +1,46 @@
+class sujit
+{
+void eat()
+{
+System.out.println("He is eating now");
+}
+void read()
+{
+System.out.println("He is very Brillient");
+}
+}
+
+class gaurav extends sujit
+{
+void eat()
+{
+System.out.println("He is also eating everyThing");
+}
+
+void dance()
+{
+System.out.println("I am doing dance");
+}
+}
+
+class kumar extends gaurav
+{
+void coder()
+{
+System.out.println("I am doing code");
+}
+void sleep()
+{
+System.out.println("I gonna sleep");
+}
+}
+
+class multi1
+{
+public static void main(String args[])
+{
+kumar k=new kumar();
+k.coder();
+k.eat();
+}
+}
\ No newline at end of file
diff --git a/multilevel.class b/multilevel.class
new file mode 100644
index 0000000..2c487bc
Binary files /dev/null and b/multilevel.class differ
diff --git a/multilevel.java b/multilevel.java
new file mode 100644
index 0000000..3b12c1e
--- /dev/null
+++ b/multilevel.java
@@ -0,0 +1,47 @@
+class sujit
+{
+void run()
+{
+System.out.println("I am running very fast");
+}
+
+void sleep()
+{
+System.out.println("I am sleeping");
+}
+}
+
+class gaurav extends sujit
+{
+void eat()
+{
+System.out.println("I am eating");
+}
+
+void read()
+{
+System.out.println("I am reading");
+}
+}
+
+class kumar extends sujit
+{
+void run()
+{
+System.out.println("I am not running");
+}
+
+void write()
+{
+System.out.println("I am writing");
+}
+}
+
+class multilevel
+{
+public static void main(String args[])
+{
+kumar k=new kumar();
+k.run();
+}
+}
\ No newline at end of file
diff --git a/myStack.class b/myStack.class
new file mode 100644
index 0000000..0616062
Binary files /dev/null and b/myStack.class differ
diff --git a/myStack.java b/myStack.java
new file mode 100644
index 0000000..15bc5cc
--- /dev/null
+++ b/myStack.java
@@ -0,0 +1,30 @@
+import java.util.*;
+class myStack
+{
+public static void main(String args[])
+{
+Vector<Integer> v=new Vector<>();
+v.add(10);
+v.add(20);
+v.add(30);
+v.add(40);
+System.out.println("Vector is:"+v);
+v.remove(2);
+System.out.println("Vector is:"+v);
+for(int i=0;i<v.size();i++)
+{
+System.out.println("Elements in vector:"+v.get(i));
+}
+v.add(1,60);
+System.out.println(v);
+v.set(1,90);
+v.set(2,100);
+System.out.println(v);
+System.out.print("iterating through vector:");
+Iterator i=v.iterator();
+while(i.hasNext())
+{
+System.out.println(i.next());
+}
+}
+}
\ No newline at end of file
diff --git a/nit.txt b/nit.txt
new file mode 100644
index 0000000..2170c11
Binary files /dev/null and b/nit.txt differ
diff --git a/normalSet.class b/normalSet.class
new file mode 100644
index 0000000..97b8ba7
Binary files /dev/null and b/normalSet.class differ
diff --git a/normalSet.java b/normalSet.java
new file mode 100644
index 0000000..c85aabd
--- /dev/null
+++ b/normalSet.java
@@ -0,0 +1,33 @@
+import java.util.*;
+class normalSet
+{
+public static void main(String args[])
+{
+Set<Integer> s=new HashSet<>();
+s.addAll(Arrays.asList(new Integer[]{1,2,3,4}));
+System.out.println(s);
+
+Set<Integer> s1=new HashSet<>();
+s1.addAll(Arrays.asList(new Integer[]{2,1,4,5,6}));
+System.out.println("The set is:"+s1);
+
+Set<String> s2=new HashSet<>();
+s2.addAll(Arrays.asList(new String[]{"gaurav","kushal","kumar","sujit"}));
+System.out.println("the set  is:"+s2);
+s2.remove("kushal");
+System.out.println("the set is :"+s2);
+s2.remove("sujit");
+System.out.println("the set is:"+s2);
+
+Iterator i=s.iterator();
+while(i.hasNext())
+{
+System.out.println(i.next());
+}
+System.out.println("Iterating in another way:");
+for(Integer in:s1)
+{
+System.out.println(in);
+}
+}
+}
\ No newline at end of file
diff --git a/object1.class b/object1.class
new file mode 100644
index 0000000..5cad5aa
Binary files /dev/null and b/object1.class differ
diff --git a/object1.java b/object1.java
new file mode 100644
index 0000000..47f645e
--- /dev/null
+++ b/object1.java
@@ -0,0 +1,20 @@
+class object1
+{
+public static void main(String args[])
+{
+Object y;
+y="gaurav";
+System.out.println("Hello! i am kumar gaurav");
+
+y=142;
+System.out.println(y);
+y=679.98;
+System.out.println(y);
+
+y=true;
+System.out.println(y);
+
+y=67;
+System.out.println(y);
+}
+}
\ No newline at end of file
diff --git a/one.class b/one.class
new file mode 100644
index 0000000..3a707e8
Binary files /dev/null and b/one.class differ
diff --git a/orderList$Node.class b/orderList$Node.class
new file mode 100644
index 0000000..764dbe5
Binary files /dev/null and b/orderList$Node.class differ
diff --git a/orderList.class b/orderList.class
new file mode 100644
index 0000000..ce5ffca
Binary files /dev/null and b/orderList.class differ
diff --git a/orderList.java b/orderList.java
new file mode 100644
index 0000000..7c2bd98
--- /dev/null
+++ b/orderList.java
@@ -0,0 +1,71 @@
+class orderList
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void arrange()
+{
+Node head1=head;
+Node head2=head.next;
+Node odd=head1;
+Node even=head2;
+while(even!=null && even.next!=null)
+{
+odd.next=odd.next.next;
+even.next=even.next.next;
+odd=odd.next;
+even=even.next;
+}
+odd.next=head2;
+}
+
+public static void main(String args[])
+{
+orderList l=new orderList();
+l.append(1);
+l.append(4);
+l.append(5);
+l.append(6);
+l.append(7);
+l.append(9);
+l.print();
+l.arrange();
+l.print();
+}
+}
\ No newline at end of file
diff --git a/outer$inner.class b/outer$inner.class
new file mode 100644
index 0000000..9c158c9
Binary files /dev/null and b/outer$inner.class differ
diff --git a/outer$nested.class b/outer$nested.class
new file mode 100644
index 0000000..9b0a795
Binary files /dev/null and b/outer$nested.class differ
diff --git a/palin13.class b/palin13.class
new file mode 100644
index 0000000..438a1a2
Binary files /dev/null and b/palin13.class differ
diff --git a/palin13.java b/palin13.java
new file mode 100644
index 0000000..1ce86fc
--- /dev/null
+++ b/palin13.java
@@ -0,0 +1,24 @@
+class palin13
+{
+public static void main(String args[])
+{
+int n=121;
+int rem=0;
+int rev=0;
+int temp=n;
+while(temp>0)
+{
+rem=temp%10;
+rev=rev*10+rem;
+temp=temp/10;
+}
+if(n==rev)
+{
+System.out.println("the number is palindrome");
+}
+else
+{
+System.out.println("the number is not palindrom");
+}
+}
+}
\ No newline at end of file
diff --git a/palin2$Node.class b/palin2$Node.class
new file mode 100644
index 0000000..70e7171
Binary files /dev/null and b/palin2$Node.class differ
diff --git a/palin2.class b/palin2.class
new file mode 100644
index 0000000..1a87ac3
Binary files /dev/null and b/palin2.class differ
diff --git a/palin2.java b/palin2.java
new file mode 100644
index 0000000..87c5d10
--- /dev/null
+++ b/palin2.java
@@ -0,0 +1,70 @@
+class palin2
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void remove()
+{
+Node temp=head;
+while(temp!=null)
+{
+Node prev=temp;
+while(prev!=null && temp.data==prev.data)
+{
+prev=prev.next;
+}
+temp.next=prev;
+temp=temp.next;
+}
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+}
+
+public static void main(String args[])
+{
+palin2 p=new palin2();
+p.append(10);
+p.append(10);
+p.append(10);
+p.append(20);
+p.append(30);
+p.print();
+p.remove();
+System.out.println("\nremoveing duplicate elements");
+p.print();
+}
+}
\ No newline at end of file
diff --git a/parser.class b/parser.class
new file mode 100644
index 0000000..f1741db
Binary files /dev/null and b/parser.class differ
diff --git a/parser.java b/parser.java
new file mode 100644
index 0000000..6372462
--- /dev/null
+++ b/parser.java
@@ -0,0 +1,38 @@
+import java.util.*;
+class parser
+{
+static String remove(String s,int k)
+{
+if(s.length()<=k)return "0";
+char c[]=s.toCharArray();
+int top=-1;
+for(int i=0;i<c.length;i++)
+{
+while(top>=0 && c[top]>c[i] && k>0)
+{
+top--;
+k--;
+}
+top++;
+c[top]=c[i];
+}
+
+int i=0;
+while(i<=top && c[i]=='0')i++;
+
+String str="";
+for(int j=i;j<digit;j++)
+{
+str+=c[j];
+} 
+
+if(str.equals(""))return "0";
+return str;
+}
+public static void main(String args[])
+{
+String s="1432219";
+int k=3;
+System.out.println(remove(s,k));
+}
+}
diff --git a/partition$Node.class b/partition$Node.class
new file mode 100644
index 0000000..83c2a27
Binary files /dev/null and b/partition$Node.class differ
diff --git a/partition.class b/partition.class
new file mode 100644
index 0000000..1eeabc7
Binary files /dev/null and b/partition.class differ
diff --git a/partition.java b/partition.java
new file mode 100644
index 0000000..149010d
--- /dev/null
+++ b/partition.java
@@ -0,0 +1,80 @@
+class partition
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Node partition(int x)
+{
+Node s=new Node(-1);
+Node head1=new Node(-1);
+Node b=head1;
+Node temp=head;
+while(temp!=null)
+{
+if(temp.data>=x)
+{
+b.next=temp;
+b=b.next;
+}
+else
+{
+s.next=temp;
+s=s.next;
+}
+temp=temp.next;
+}
+b.next=null;
+s.next=head1.next;
+return s.next;
+}
+
+public static void main(String args[])
+{
+partition p=new partition();
+p.append(1);
+p.append(4);
+p.append(3);
+p.append(2);
+p.append(5);
+p.append(2);
+p.print();
+Node i=p.partition(3);
+p.print();
+}
+}
\ No newline at end of file
diff --git a/path.class b/path.class
new file mode 100644
index 0000000..08ffdde
Binary files /dev/null and b/path.class differ
diff --git a/path.java b/path.java
new file mode 100644
index 0000000..83a9629
--- /dev/null
+++ b/path.java
@@ -0,0 +1,13 @@
+class path
+{
+public static void main(String args[])
+{
+String s="/gaurav/";
+for(int i=0;i<s.length()-1;i++)
+{
+System.out.print(s.charAt(i));
+}
+
+
+}
+}
\ No newline at end of file
diff --git a/pattern.class b/pattern.class
new file mode 100644
index 0000000..62ac74e
Binary files /dev/null and b/pattern.class differ
diff --git a/pattern.java b/pattern.java
new file mode 100644
index 0000000..8f60da9
--- /dev/null
+++ b/pattern.java
@@ -0,0 +1,20 @@
+class pattern
+{
+public static void main(String args[])
+{
+int n=5;
+for(int i=1;i<=n;i++)
+{
+for(int j=1;j<=i-1;j++)
+{
+System.out.print("  ");
+}
+
+for(int j=1;j<=n-i+1;j++)
+{
+System.out.print("* ");
+}
+System.out.println();
+}
+}
+}
\ No newline at end of file
diff --git a/pattern1.class b/pattern1.class
new file mode 100644
index 0000000..718b504
Binary files /dev/null and b/pattern1.class differ
diff --git a/pattern1.java b/pattern1.java
new file mode 100644
index 0000000..4ad5b86
--- /dev/null
+++ b/pattern1.java
@@ -0,0 +1,15 @@
+class pattern1
+{
+public static void main(String args[])
+{
+int n=5;
+for(int i=1;i<=n;i++)
+{
+for(int j=1;j<=n-i+1;j++)
+{
+System.out.print("* ");
+}
+System.out.println();
+}
+}
+}
\ No newline at end of file
diff --git a/pattern2.class b/pattern2.class
new file mode 100644
index 0000000..554022f
Binary files /dev/null and b/pattern2.class differ
diff --git a/pattern2.java b/pattern2.java
new file mode 100644
index 0000000..765022b
--- /dev/null
+++ b/pattern2.java
@@ -0,0 +1,20 @@
+class pattern2
+{
+public static void main(String args[])
+{
+int n=5;
+for(int i=1;i<=n;i++)
+{
+for(int j=1;j<=n-i;j++)
+{
+System.out.print("  ");
+}
+
+for(int j=1;j<=i;j++)
+{
+System.out.print("* ");
+}
+System.out.println();
+}
+}
+}
diff --git a/permu1.class b/permu1.class
new file mode 100644
index 0000000..2f9a0b1
Binary files /dev/null and b/permu1.class differ
diff --git a/permu1.java b/permu1.java
new file mode 100644
index 0000000..d2bf8e5
--- /dev/null
+++ b/permu1.java
@@ -0,0 +1,37 @@
+//print the whole permutation of the given string
+class permu1
+{
+static void permutation(String s,int l,int h)
+{
+if(l==h)
+{
+System.out.println(s);
+return;
+}
+
+
+for(int i=l;i<=h;i++)
+{
+s=swap(s,l,i);
+permutation(s,l+1,h);
+s=swap(s,l,i);
+}
+}
+
+
+static String swap(String s,int l,int i)
+{
+char c[]=s.toCharArray();
+char temp=c[l];
+c[l]=c[i];
+c[i]=temp;
+return String.valueOf(c);
+}
+
+public static void main(String args[])
+{
+String s="abc";
+permutation(s,0,s.length()-1);
+
+}
+}
\ No newline at end of file
diff --git a/permut.class b/permut.class
new file mode 100644
index 0000000..1649548
Binary files /dev/null and b/permut.class differ
diff --git a/permut.java b/permut.java
new file mode 100644
index 0000000..82cfdfc
--- /dev/null
+++ b/permut.java
@@ -0,0 +1,26 @@
+class permut
+{
+static int missingNumber(int a[],int low,int high)
+{
+while(low<=high)
+{
+int mid=(low+high)/2;
+if(a[mid]!=mid+1 && a[mid-1]==mid)
+return mid+1;
+
+if(a[mid]!=mid+1)
+high=mid-1;
+else
+low=mid+1;
+}
+return -1;
+}
+public static void main(String args[])
+{
+int a[]={1,2,4,5};
+int low=0;
+int high=a.length-1;
+int k=missingNumber(a,low,high);
+System.out.println("the missing number is:"+k);
+}
+}
\ No newline at end of file
diff --git a/permutation.class b/permutation.class
new file mode 100644
index 0000000..6207f3b
Binary files /dev/null and b/permutation.class differ
diff --git a/permutation.java b/permutation.java
new file mode 100644
index 0000000..ee3a0e9
--- /dev/null
+++ b/permutation.java
@@ -0,0 +1,40 @@
+//Find all permutation of a array
+import java.util.*;
+class permutation
+{
+static List<List<Integer>> findPermutation(int a[])
+{
+List<List<Integer>> l=new ArrayList<>();
+boolean visited[]=new boolean[a.length];
+backtrack(l,a,new ArrayList(),visited);
+return l;
+}
+
+static void backtrack(List<List<Integer>> l,int a[],List<Integer> cur,boolean visited[])
+{
+if(cur.size()==a.length)
+{
+l.add(new ArrayList(cur));
+return;
+}
+for(int i=0;i<a.length;i++)
+{
+if(visited[i]==true)
+{
+continue;
+}
+
+cur.add(a[i]);
+visited[i]=true;
+backtrack(l,a,cur,visited);
+cur.remove(cur.size()-1);
+visited[i]=false;
+
+}
+}
+public static void main(String args[])
+{
+int a[]={1,2,3};
+System.out.println(findPermutation(a));
+}
+}
\ No newline at end of file
diff --git a/permutation1.java b/permutation1.java
new file mode 100644
index 0000000..34bddd8
--- /dev/null
+++ b/permutation1.java
@@ -0,0 +1,39 @@
+import java.util.*;
+class Permutation1
+{
+static void permutation(String s,int l,int h)
+{
+Set<String> set=new HashSet<>();
+if(l==h)
+{
+if(set.contains(s))
+return;
+
+set.add(s);
+System.out.println(s);
+return;
+}
+
+for(int i=l;i<=h;i++)
+{
+s=swap(s,l,i);
+permutation(s,l+1,h);
+s=swap(s,l,i);
+}
+
+}
+
+static String swap(String s,int l,int h)
+{
+char c[]=s.toCharArray();
+char temp=c[l];
+c[l]=c[h];
+c[h]=temp;
+return String.valueOf(c);
+}
+public static void main(String args[])
+{
+String s="abc";
+permutation(s,0,s.length()-1);
+}
+}
\ No newline at end of file
diff --git a/power1.class b/power1.class
new file mode 100644
index 0000000..48d474a
Binary files /dev/null and b/power1.class differ
diff --git a/power1.java b/power1.java
new file mode 100644
index 0000000..70795b3
--- /dev/null
+++ b/power1.java
@@ -0,0 +1,18 @@
+import java.util.*;
+class power1
+{
+public static void main(String args[])
+{
+Scanner sc=new Scanner(System.in);
+System.out.println("Enter the first number:");
+int a=sc.nextInt();
+System.out.println("Enter the second number:");
+int b=sc.nextInt();
+int pow=1;
+for(int i=0;i<b;i++)
+{
+pow=pow*a;
+}
+System.out.println("The pow of a number is:"+pow);
+}
+}
\ No newline at end of file
diff --git a/prem.txt b/prem.txt
new file mode 100644
index 0000000..f1739bb
Binary files /dev/null and b/prem.txt differ
diff --git a/producer.class b/producer.class
new file mode 100644
index 0000000..583daba
Binary files /dev/null and b/producer.class differ
diff --git a/reflect.class b/reflect.class
new file mode 100644
index 0000000..f01e079
Binary files /dev/null and b/reflect.class differ
diff --git a/reflect.java b/reflect.java
new file mode 100644
index 0000000..58c5023
--- /dev/null
+++ b/reflect.java
@@ -0,0 +1,18 @@
+import java.lang.reflect.Array;
+import java.util.*;
+class reflect
+{
+public static void main(String args[])
+{
+double x[]=(double[])Array.newInstance(double.class,5);
+Array.setDouble(x,0,10);
+Array.setDouble(x,1,20);
+Array.setDouble(x,2,30);
+Array.setDouble(x,3,40);
+System.out.println(Arrays.toString(x));
+System.out.println("At index 0:"+Array.getDouble(x,0));
+System.out.println("At index 1:"+Array.getDouble(x,1));
+System.out.println("At index 2:"+Array.getDouble(x,2));
+System.out.println("At index 3:"+Array.getDouble(x,3));
+}
+}
\ No newline at end of file
diff --git a/reflect1.class b/reflect1.class
new file mode 100644
index 0000000..9579612
Binary files /dev/null and b/reflect1.class differ
diff --git a/reflect1.java b/reflect1.java
new file mode 100644
index 0000000..562dfdf
--- /dev/null
+++ b/reflect1.java
@@ -0,0 +1,13 @@
+import java.lang.reflect.Array;
+import java.util.*;
+class reflect1
+{
+public static void main(String args[])
+{
+int a[]=new int[3];
+Array.setInt(a,0,10);
+Array.setInt(a,1,20);
+System.out.println(Arrays.toString(a));
+System.out.println("At index:"+Array.getInt(a,0));
+}
+}
\ No newline at end of file
diff --git a/remove$Node.class b/remove$Node.class
new file mode 100644
index 0000000..92286c5
Binary files /dev/null and b/remove$Node.class differ
diff --git a/remove.class b/remove.class
new file mode 100644
index 0000000..be9a085
Binary files /dev/null and b/remove.class differ
diff --git a/remove.java b/remove.java
new file mode 100644
index 0000000..6ea8471
--- /dev/null
+++ b/remove.java
@@ -0,0 +1,74 @@
+import java.util.*;
+class remove
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void remove()
+{
+HashSet<Integer> s=new HashSet<>();
+Node temp=head;
+Node prev=null;
+while(temp!=null)
+{
+if(s.contains(temp.data))
+prev.next=temp.next;
+else
+{
+s.add(temp.data);
+prev=temp;
+}
+temp=temp.next;
+}
+}
+
+public static void main(String args[])
+{
+remove r=new remove();
+r.append(20);
+r.append(10);
+r.append(30);
+r.append(10);
+r.append(40);
+r.print();
+r.remove();
+System.out.println("\nAfter removing the data");
+r.print();
+}
+}
\ No newline at end of file
diff --git a/remove1$Node.class b/remove1$Node.class
new file mode 100644
index 0000000..711d296
Binary files /dev/null and b/remove1$Node.class differ
diff --git a/remove1.class b/remove1.class
new file mode 100644
index 0000000..710e26f
Binary files /dev/null and b/remove1.class differ
diff --git a/remove1.java b/remove1.java
new file mode 100644
index 0000000..e08d4a5
--- /dev/null
+++ b/remove1.java
@@ -0,0 +1,65 @@
+import java.util.*;
+class remove1
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void push(int data)
+{
+Node x=new Node(data);
+x.next=head;
+head=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+void remove()
+{
+Node temp=head;
+Node prev=null;
+HashSet<Integer> s=new HashSet<>();
+while(temp!=null)
+{
+if(s.contains(temp.data))
+{
+prev.next=temp.next;
+}
+else
+{
+s.add(temp.data);
+prev=temp;
+}
+temp=temp.next;
+}
+}
+public static void main(String args[])
+{
+remove1 r=new remove1();
+r.push(40);
+r.push(30);
+r.push(20);
+r.push(30);
+r.push(20);
+r.push(25);
+r.print();
+r.remove();
+System.out.println("\nAfter removing the data");
+r.print();
+}
+}
diff --git a/remove2.class b/remove2.class
new file mode 100644
index 0000000..9ceb48a
Binary files /dev/null and b/remove2.class differ
diff --git a/remove2.java b/remove2.java
new file mode 100644
index 0000000..5cf05a7
--- /dev/null
+++ b/remove2.java
@@ -0,0 +1,29 @@
+class remove2
+{
+static int remove(int a[])
+{
+int i=0;
+int j=1;
+if(a.length==0)
+return 0;
+
+while(i<a.length && j<a.length)
+{
+if(a[i]==a[j])
+{
+j++;
+}
+else
+{
+i++;
+a[i]=a[j];
+}
+}
+return i+1;
+}
+public static void main(String args[])
+{
+int a[]={1,2,2,3,4};
+System.out.println(remove(a));
+}
+}
\ No newline at end of file
diff --git a/remove4.class b/remove4.class
new file mode 100644
index 0000000..61dd865
Binary files /dev/null and b/remove4.class differ
diff --git a/remove4.java b/remove4.java
new file mode 100644
index 0000000..ca1d7f4
--- /dev/null
+++ b/remove4.java
@@ -0,0 +1,26 @@
+class remove4
+{
+static int remove(int a[],int val)
+{
+int i=0;
+int j=1;
+while(i<a.length && j<a.length)
+{
+if(a[j]==val)
+j++;
+else
+{
+i++;
+a[i]=a[j];
+j++;
+}
+}
+return i+1;
+}
+public static void main(String args[])
+{
+int a[]={1,2,2,3,3,3,4,3};
+int val=3;
+System.out.println(remove(a,val));
+}
+}
\ No newline at end of file
diff --git a/removeAll.class b/removeAll.class
new file mode 100644
index 0000000..8e68821
Binary files /dev/null and b/removeAll.class differ
diff --git a/removeAll.java b/removeAll.java
new file mode 100644
index 0000000..3b708d4
--- /dev/null
+++ b/removeAll.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class removeAll
+{
+public static void main(String args[])
+{
+ArrayList<Integer> l=new ArrayList<>();
+l.add(10);
+l.add(20);
+l.add(30);
+l.add(40);
+
+ArrayList<Integer> l1=new ArrayList<>();
+l1.add(10);
+l1.add(20);
+l1.add(70);
+
+l.removeAll(l1);
+System.out.println("List is:"+l);
+}
+}
\ No newline at end of file
diff --git a/removeDup.class b/removeDup.class
new file mode 100644
index 0000000..8a2d936
Binary files /dev/null and b/removeDup.class differ
diff --git a/removeDup.java b/removeDup.java
new file mode 100644
index 0000000..a2be462
--- /dev/null
+++ b/removeDup.java
@@ -0,0 +1,14 @@
+import java.util.*;
+class removeDup
+{
+public static void main(String args[])
+{
+int a[]={1,2,3,1,2};
+Set<Integer> s=new HashSet<>();
+for(int i:a)
+{
+s.add(i);
+}
+System.out.println(s);
+}
+}
diff --git a/removeDuplicate$Node.class b/removeDuplicate$Node.class
new file mode 100644
index 0000000..3109360
Binary files /dev/null and b/removeDuplicate$Node.class differ
diff --git a/removeDuplicate.class b/removeDuplicate.class
new file mode 100644
index 0000000..98f2d5f
Binary files /dev/null and b/removeDuplicate.class differ
diff --git a/removeDuplicate.java b/removeDuplicate.java
new file mode 100644
index 0000000..9fa5eb5
--- /dev/null
+++ b/removeDuplicate.java
@@ -0,0 +1,57 @@
+class removeDuplicate
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void push(int data)
+{
+Node x=new Node(data);
+x.next=head;
+head=x;
+}
+
+void remove()
+{
+Node temp=head;
+while(temp!=null)
+{
+Node prev=temp;
+while(prev!=null && temp.data==prev.data)
+{
+prev=prev.next;
+}
+temp.next=prev;
+temp=temp.next;
+}
+
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.println(temp.data);
+temp=temp.next;
+}
+}
+
+public static void main(String args[])
+{
+removeDuplicate r=new removeDuplicate();
+r.push(30);
+r.push(20);
+r.push(10);
+r.push(10);
+r.remove();
+r.print();
+}
+}
\ No newline at end of file
diff --git a/removeElements.class b/removeElements.class
new file mode 100644
index 0000000..16a6593
Binary files /dev/null and b/removeElements.class differ
diff --git a/removeElements.java b/removeElements.java
new file mode 100644
index 0000000..86c95d0
--- /dev/null
+++ b/removeElements.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class removeElements
+{
+public static void main(String args[])
+{
+ArrayList<Integer> l=new ArrayList<>(Arrays.asList(1,2,3,4,5,6,4,4));
+ArrayList<Integer>l1=new ArrayList<>();
+Iterator i=l.iterator();
+while(i.hasNext())
+{
+Integer k=(Integer)i.next();
+if(k==4)
+{
+l1.add(k);
+}
+}
+l.removeAll(l1);
+System.out.println("the list is:"+l);
+}
+}
\ No newline at end of file
diff --git a/replace1.class b/replace1.class
new file mode 100644
index 0000000..6b2d2b4
Binary files /dev/null and b/replace1.class differ
diff --git a/replace1.java b/replace1.java
new file mode 100644
index 0000000..1f726f7
--- /dev/null
+++ b/replace1.java
@@ -0,0 +1,11 @@
+//replace space with %20;
+class replace1
+{
+public static void main(String args[])
+{
+String s="hello kumar gaurav may i help you";
+String k="%20";
+String y=s.replace(" ",k);
+System.out.println("The string is:"+y);
+}
+}
\ No newline at end of file
diff --git a/resume.txt b/resume.txt
new file mode 100644
index 0000000..cac5c7b
--- /dev/null
+++ b/resume.txt
@@ -0,0 +1 @@
+https://resume.workruit.com/app/editor/index.html
\ No newline at end of file
diff --git a/revers$Node.class b/revers$Node.class
new file mode 100644
index 0000000..d66e681
Binary files /dev/null and b/revers$Node.class differ
diff --git a/revers.class b/revers.class
new file mode 100644
index 0000000..5f1e09a
Binary files /dev/null and b/revers.class differ
diff --git a/revers.java b/revers.java
new file mode 100644
index 0000000..b0f2cf1
--- /dev/null
+++ b/revers.java
@@ -0,0 +1,75 @@
+class revers
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Node reverse(int left,int right)
+{
+Node head1=new Node(-1);
+Node prev=head1;
+prev.next=head;
+for(int i=0;i<left-1;i++)
+{
+prev=prev.next;
+}
+Node cur=prev.next;
+while(left<right)
+{
+Node temp=cur.next;
+cur.next=temp.next;
+temp.next=prev.next;
+prev.next=temp;
+left++;
+}
+return head1.next;
+}
+
+public static void main(String args[])
+{
+revers r=new revers();
+r.append(1);
+r.append(2);
+r.append(3);
+r.append(4);
+r.append(5);
+r.print();
+Node x=r.reverse(2,4);
+r.print();
+}
+}
\ No newline at end of file
diff --git a/reverseLink$Node.class b/reverseLink$Node.class
new file mode 100644
index 0000000..bea9cb1
Binary files /dev/null and b/reverseLink$Node.class differ
diff --git a/reverseLink.class b/reverseLink.class
new file mode 100644
index 0000000..e912e96
Binary files /dev/null and b/reverseLink.class differ
diff --git a/reverseLink.java b/reverseLink.java
new file mode 100644
index 0000000..0b25a73
--- /dev/null
+++ b/reverseLink.java
@@ -0,0 +1,75 @@
+class reverseLink
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void reverse()
+{
+Node temp=head;
+Node prev=null;
+Node next=null;
+while(temp!=null)
+{                                                                                       
+next=temp.next;
+temp.next=prev;
+prev=temp;
+temp=next;
+}
+temp=prev;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+public static void main(String args[])
+{
+reverseLink r=new reverseLink();
+r.append(10);
+r.append(20);
+r.append(30);
+r.append(40);
+r.print();
+System.out.println("reverse Linkedlist");
+r.reverse();
+}
+}
\ No newline at end of file
diff --git a/reverseLinked$Node.class b/reverseLinked$Node.class
new file mode 100644
index 0000000..db8d7fd
Binary files /dev/null and b/reverseLinked$Node.class differ
diff --git a/reverseLinked.class b/reverseLinked.class
new file mode 100644
index 0000000..378cfb3
Binary files /dev/null and b/reverseLinked.class differ
diff --git a/reverseLinked.java b/reverseLinked.java
new file mode 100644
index 0000000..20622fb
--- /dev/null
+++ b/reverseLinked.java
@@ -0,0 +1,74 @@
+class reverseLinked
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void reverse()
+{
+Node temp=head;
+Node prev=null;
+Node next=null;
+while(temp!=null)
+{
+next=temp.next;
+temp.next=prev;
+prev=temp;
+temp=next;
+}
+temp=prev;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+public static void main(String args[])
+{
+reverseLinked r=new reverseLinked();
+r.append(10);
+r.append(11);
+r.append(12);
+r.append(13);
+r.append(14);
+r.print();
+r.reverse();
+}
+}
\ No newline at end of file
diff --git a/reverseString1.class b/reverseString1.class
new file mode 100644
index 0000000..5afb950
Binary files /dev/null and b/reverseString1.class differ
diff --git a/reverseString1.java b/reverseString1.java
new file mode 100644
index 0000000..8158025
--- /dev/null
+++ b/reverseString1.java
@@ -0,0 +1,17 @@
+class reverseString1
+{
+static String reverse(String s)
+{
+if(s==null || s.length<=1)
+{
+return s;
+}
+
+return reverse(s.substring(1))+s.charAt(0);
+}
+public static void main(String args[])
+{
+String s="gaurav";
+System.out.println(reverse(s));
+}
+}
\ No newline at end of file
diff --git a/reverseWord1.class b/reverseWord1.class
new file mode 100644
index 0000000..d889a1b
Binary files /dev/null and b/reverseWord1.class differ
diff --git a/reverseWord1.java b/reverseWord1.java
new file mode 100644
index 0000000..3652420
--- /dev/null
+++ b/reverseWord1.java
@@ -0,0 +1,21 @@
+import java.util.*;
+class reverseWord1
+{
+public static void main(String args[])
+{
+String s="gaurav";
+Set<Character> set=new LinkedHashSet<>();
+for(int i=0;i<s.length();i++)
+{
+set.add(s.charAt(i));
+}
+
+String h="";
+for(Character k:set)
+{
+h+=k;
+}
+
+System.out.println("after remove duplicate:-"+h);
+}
+}
diff --git a/rotate$Node.class b/rotate$Node.class
new file mode 100644
index 0000000..cf07164
Binary files /dev/null and b/rotate$Node.class differ
diff --git a/rotate.class b/rotate.class
new file mode 100644
index 0000000..a47fc67
Binary files /dev/null and b/rotate.class differ
diff --git a/rotate.java b/rotate.java
new file mode 100644
index 0000000..8ef94b5
--- /dev/null
+++ b/rotate.java
@@ -0,0 +1,81 @@
+class rotate
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Node rotate(int k)
+{
+Node temp=head;
+int len=0;
+if(head==null || k==0)
+return head;
+while(temp.next!=null)
+{
+len++;
+temp=temp.next;
+}
+len++;
+temp.next=head;
+
+temp=head;
+int rotatePoint=len-k%len;
+while(rotatePoint>1)
+{
+temp=temp.next;
+rotatePoint--;
+}
+
+head=temp.next;
+temp.next=null;
+return head;
+
+}
+
+public static void main(String args[])
+{
+rotate r=new rotate();
+r.append(1);
+r.append(2);
+r.append(3);
+r.append(4);
+r.append(5);
+r.print();
+Node x=r.rotate(2);
+r.print();
+}
+}
\ No newline at end of file
diff --git a/searchArray.class b/searchArray.class
new file mode 100644
index 0000000..8ada3dc
Binary files /dev/null and b/searchArray.class differ
diff --git a/searchArray.java b/searchArray.java
new file mode 100644
index 0000000..08608bc
--- /dev/null
+++ b/searchArray.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class searchArray
+{
+public static void main(String args[])
+{
+int a[]={1,2,3,4,5};
+int key=6;
+int index=Arrays.binarySearch(a,key);
+if(index>0)
+{
+System.out.println("Element found at index:"+index);
+}
+else
+{
+System.out.println("Element not found:"+index);
+}
+
+}
+}
\ No newline at end of file
diff --git a/select.class b/select.class
new file mode 100644
index 0000000..24c4c94
Binary files /dev/null and b/select.class differ
diff --git a/select.java b/select.java
new file mode 100644
index 0000000..c4f33b2
--- /dev/null
+++ b/select.java
@@ -0,0 +1,25 @@
+import java.util.*;
+class select
+{
+public static void main(String args[])
+{
+int a[]={-1,-5,4,2,5,3};
+int n=a.length;
+for(int i=0;i<n-1;i++)
+{
+int min=i;
+for(int j=i;j<n;j++)
+{
+if(a[j]<a[min])
+{
+min=j;
+}
+}
+
+int temp=a[i];
+a[i]=a[min];
+a[min]=temp;
+}
+System.out.println(Arrays.toString(a));
+}
+}
diff --git a/selection.class b/selection.class
new file mode 100644
index 0000000..28fb296
Binary files /dev/null and b/selection.class differ
diff --git a/selection.java b/selection.java
new file mode 100644
index 0000000..4bb9233
--- /dev/null
+++ b/selection.java
@@ -0,0 +1,25 @@
+import java.util.*;
+class selection
+{
+public static void main(String args[])
+{
+int a[]={1,4,5,2,3};
+int n=a.length;
+for(int i=0;i<n;i++)
+{
+int min=i;
+for(int j=i;j<n;j++)
+{
+if(a[j]<a[min])
+{
+min=j;
+}
+}
+int temp=a[i];
+a[i]=a[min];
+a[min]=temp;
+}
+
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/selectionSort.class b/selectionSort.class
new file mode 100644
index 0000000..39bd13c
Binary files /dev/null and b/selectionSort.class differ
diff --git a/selectionSort.java b/selectionSort.java
new file mode 100644
index 0000000..54727c0
--- /dev/null
+++ b/selectionSort.java
@@ -0,0 +1,24 @@
+//Selection sort
+import java.util.*;
+class selectionSort
+{
+public static void main(String args[])
+{
+int a[]={2,4,3,5,1};
+for(int i=0;i<a.length;i++)
+{
+int min=i;
+for(int j=i;j<a.length;j++)
+{
+if(a[j]<a[min])
+{
+min=j;
+}
+}
+int temp=a[i];
+a[i]=a[min];
+a[min]=temp;
+}
+System.out.println(Arrays.toString(a));
+}
+}
\ No newline at end of file
diff --git a/setInteger.class b/setInteger.class
new file mode 100644
index 0000000..4d6f0a4
Binary files /dev/null and b/setInteger.class differ
diff --git a/setInteger.java b/setInteger.java
new file mode 100644
index 0000000..184a46a
--- /dev/null
+++ b/setInteger.java
@@ -0,0 +1,18 @@
+//convert set of String to set of Integer
+import java.util.*;
+import java.util.stream.*;
+class setInteger
+{
+static void convertSetToInteger(Set<String> set)
+{
+Set<Integer> setofint=set.stream().map(k->Integer.parseInt(k)).
+                       collect(Collectors.toSet());
+
+System.out.println(setofint);
+}
+public static void main(String args[])
+{
+Set<String> set=new HashSet<>(Arrays.asList("1","2","3","4","5"));
+convertSetToInteger(set);
+}
+}
\ No newline at end of file
diff --git a/setOfString.class b/setOfString.class
new file mode 100644
index 0000000..a7742d5
Binary files /dev/null and b/setOfString.class differ
diff --git a/setOfString.java b/setOfString.java
new file mode 100644
index 0000000..52f03ac
--- /dev/null
+++ b/setOfString.java
@@ -0,0 +1,11 @@
+import java.util.*;
+class setOfString
+{
+public static void main(String args[])
+{
+Set<String> set=new HashSet<>(Arrays.asList("gaurav","kushal","kumar","sujit"));
+System.out.println("the String is:"+set);
+String s=String.join(" ,",set);
+System.out.println("Set of String is:"+s);
+}
+}
\ No newline at end of file
diff --git a/shape.class b/shape.class
new file mode 100644
index 0000000..62b59bb
Binary files /dev/null and b/shape.class differ
diff --git a/shape1.class b/shape1.class
new file mode 100644
index 0000000..e74fa22
Binary files /dev/null and b/shape1.class differ
diff --git a/shape1.java b/shape1.java
new file mode 100644
index 0000000..c58ac17
--- /dev/null
+++ b/shape1.java
@@ -0,0 +1,48 @@
+abstract class shape
+{
+String name;
+abstract double area();
+public abstract String toString();
+
+shape(String name)
+{
+this.name=name;
+}
+
+String getName()
+{
+return name;
+}
+}
+
+class Rectangle extends shape
+{
+int length;
+int breadth;
+Rectangle(String name,int length,int breadth)
+{
+super(name);
+this.length=length;
+this.breadth=breadth;
+}
+
+double area()
+{
+return length*breadth;
+}
+
+public String toString()
+{
+return("Name="+super.name+" Area="+ area());
+}
+}
+
+class shape1
+{
+public static void main(String args[])
+{
+Rectangle r=new Rectangle("Rectangle",10,20);
+System.out.println(r.toString());
+}
+}
+
diff --git a/simple.class b/simple.class
new file mode 100644
index 0000000..5d0a963
Binary files /dev/null and b/simple.class differ
diff --git a/simple.java b/simple.java
new file mode 100644
index 0000000..ac464cf
--- /dev/null
+++ b/simple.java
@@ -0,0 +1,20 @@
+class simple implements Runnable
+{
+public void run()
+{
+Thread t=Thread.currentThread();
+System.out.println("Current thread is:"+t.getName());
+System.out.println("isAlive:"+t.isAlive());
+}
+public static void main(String args[]) throws Exception
+{
+simple s=new simple();
+Thread t=new Thread(s);
+t.start();
+
+t.join(2000); //wait for thread.
+System.out.println("join the thread");
+System.out.println(t.getName());
+System.out.println(t.isAlive());
+}
+}
\ No newline at end of file
diff --git a/single.class b/single.class
new file mode 100644
index 0000000..502a6c4
Binary files /dev/null and b/single.class differ
diff --git a/single.java b/single.java
new file mode 100644
index 0000000..f81e624
--- /dev/null
+++ b/single.java
@@ -0,0 +1,35 @@
+class Dog
+{
+void bark()
+{
+System.out.println("It is barking");
+}
+
+void eat()
+{
+System.out.println("I am eating");
+}
+}
+
+class baby extends Dog
+{
+void bark()
+{
+System.out.println("It is not barking");
+}
+
+void sleep()
+{
+System.out.println("He is very boring");
+}
+}
+
+class single
+{
+public static void main(String args[])
+{
+baby b=new baby();
+b.bark();
+b.eat();
+}
+}
diff --git a/sortByRoll.class b/sortByRoll.class
new file mode 100644
index 0000000..ed1a5f3
Binary files /dev/null and b/sortByRoll.class differ
diff --git a/sortList$Node.class b/sortList$Node.class
new file mode 100644
index 0000000..37f32f1
Binary files /dev/null and b/sortList$Node.class differ
diff --git a/sortList.class b/sortList.class
new file mode 100644
index 0000000..5ae51ee
Binary files /dev/null and b/sortList.class differ
diff --git a/sortList.java b/sortList.java
new file mode 100644
index 0000000..b8e51ac
--- /dev/null
+++ b/sortList.java
@@ -0,0 +1,77 @@
+class sortList
+{
+Node head;
+class Node
+{
+Node next;
+int data;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void sort()
+{
+Node temp=head;
+while(temp!=null)
+{
+Node prev=temp;
+while(prev!=null)
+{
+if(temp.data>prev.data)
+{
+int k=temp.data;
+temp.data=prev.data;
+prev.data=k;
+prev=prev.next;
+}
+else
+{
+prev=prev.next;
+}
+}
+temp=temp.next;
+}
+}
+
+
+
+public static void main(String args[])
+{
+sortList s=new sortList();
+s.append(10);
+s.append(3);
+s.append(2);
+s.append(1);
+s.print();
+s.sort();
+s.print();
+}
+}
\ No newline at end of file
diff --git a/sortedMap2.class b/sortedMap2.class
new file mode 100644
index 0000000..257edf2
Binary files /dev/null and b/sortedMap2.class differ
diff --git a/sortedMap2.java b/sortedMap2.java
new file mode 100644
index 0000000..9041e20
--- /dev/null
+++ b/sortedMap2.java
@@ -0,0 +1,29 @@
+import java.util.*;
+class sortedMap2
+{
+public static void main(String args[])
+{
+System.out.println("Initialize a sorted map using generics");
+SortedMap<String,String> map=new TreeMap<>();
+map.put("gaurav","CSE");
+map.put("kumar","mech");
+map.put("kushal","Das");
+map.put("vikash","cse");
+System.out.println(map);
+
+System.out.println("Default initialization:-");
+SortedMap sm=new TreeMap();
+
+sm.put(3,"kumar");
+sm.put(1,"NIT");
+sm.put(2,"GIT");
+System.out.println("SortedMap is:"+sm);
+
+System.out.println("Another map");
+SortedMap map1=new TreeMap();
+map1.put("cse",10);
+map1.put("mech",5);
+map1.put("ece",4);
+System.out.println(map1);
+}
+}
\ No newline at end of file
diff --git a/split$Node.class b/split$Node.class
new file mode 100644
index 0000000..8b9f7c1
Binary files /dev/null and b/split$Node.class differ
diff --git a/split.class b/split.class
new file mode 100644
index 0000000..4b030d0
Binary files /dev/null and b/split.class differ
diff --git a/split.java b/split.java
new file mode 100644
index 0000000..1842370
--- /dev/null
+++ b/split.java
@@ -0,0 +1,63 @@
+class split
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+int ConvertDecimal()
+{
+Node temp=head;
+int res=temp.data;
+while(temp.next!=null)
+{
+res=res*2+temp.next.data;
+temp=temp.next;
+}
+return res;
+}
+
+public static void main(String args[])
+{
+split s=new split();
+s.append(1);
+s.append(0);
+s.append(1);
+s.print();
+System.out.println(s.ConvertDecimal());
+}
+}
\ No newline at end of file
diff --git a/studen.class b/studen.class
new file mode 100644
index 0000000..f22d463
Binary files /dev/null and b/studen.class differ
diff --git a/studen.java b/studen.java
new file mode 100644
index 0000000..c05544d
--- /dev/null
+++ b/studen.java
@@ -0,0 +1,84 @@
+import java.util.*;
+class Student
+{
+String name;
+int roll;
+String dept;
+Student(String name,int roll,String dept)
+{
+this.name=name;
+this.roll=roll;
+this.dept=dept;
+}
+}
+
+class Department
+{
+String name;
+List<Student> l;
+Department(List<Student> l,String name)
+{
+this.l=l;
+this.name=name;
+}
+
+List<Student> getStudent()
+{
+return l;
+}
+}
+
+class Institute
+{
+String name;
+List<Department> dept;
+Institute(String name,List<Department> dept)
+{
+this.name=name;
+this.dept=dept;
+}
+
+int getTotalStudent()
+{
+int noOfStudent=0;
+for(Department d:dept)
+{
+List<Student> l=d.getStudent();
+for(Student s:l)
+{
+noOfStudent+=1;
+}
+}
+return noOfStudent;
+}
+}
+
+class studen
+{
+public static void main(String args[])
+{
+Student s1=new Student("gaurav",153,"CSE");
+Student s2=new Student("kumar",156,"CSE");
+Student s3=new Student("Ankit",145,"MECH");
+Student s4=new Student("vikash",12,"MECH");
+
+List<Student> cse=new ArrayList<>();
+cse.add(s1);
+cse.add(s2);
+
+List<Student> mech=new ArrayList<>();
+mech.add(s3);
+mech.add(s4);
+
+Department  CSE=new Department(cse,"CSE");
+Department MECH=new Department(mech, "MECH");
+
+List<Department> dept=new ArrayList<>();
+dept.add(CSE);
+dept.add(MECH);
+
+Institute ins=new Institute("NIT",dept);
+System.out.println("Toatal number of student is:"+ins.getTotalStudent());
+}
+}
+
diff --git a/studen1.class b/studen1.class
new file mode 100644
index 0000000..c4e23dd
Binary files /dev/null and b/studen1.class differ
diff --git a/studen1.java b/studen1.java
new file mode 100644
index 0000000..65a630c
--- /dev/null
+++ b/studen1.java
@@ -0,0 +1,86 @@
+import java.util.*;
+class Student
+{
+String name;
+int roll;
+String dept;
+Student(String name,int roll,String dept)
+{
+this.name=name;
+this.roll=roll;
+this.dept=dept;
+}
+}
+
+class Department
+{
+String name;
+List<Student> l;
+Department(String name,List<Student> l)
+{
+this.name=name;
+this.l=l;
+}
+
+List<Student> getStudent()
+{
+return l;
+}
+}
+
+class Institute
+{
+String name;
+List<Department> dept;
+Institute(String name,List<Department> dept)
+{
+this.name=name;
+this.dept=dept;
+}
+
+int getTotalStudent()
+{
+int noOfStudent=0;
+for(Department d:dept)
+{
+List<Student> l=d.getStudent();
+for(Student s:l)
+{
+noOfStudent+=1;
+}
+}
+return noOfStudent;
+}
+}
+
+
+class studen1
+{
+public static void main(String args[])
+{
+Student s1=new Student("gaurav",153,"cse");
+Student s2=new Student("kushal",253,"cse");
+Student s3=new Student("Ankit",637,"mech");
+Student s4=new Student("vishal",78,"mech");
+
+List<Student> cse=new ArrayList<>();
+cse.add(s1);
+cse.add(s2);
+
+List<Student> mech=new ArrayList<>();
+mech.add(s3);
+mech.add(s4);
+
+Department CSE=new Department("CSE",cse);
+Department MECH=new Department("MECH",mech);
+
+List<Department> dept=new ArrayList<>();
+dept.add(CSE);
+dept.add(MECH);
+
+Institute ins=new Institute("NIT",dept);
+System.out.println("Total number of student is:"+ins.getTotalStudent());
+}
+}
+
+
diff --git a/substring.class b/substring.class
new file mode 100644
index 0000000..d64ecb5
Binary files /dev/null and b/substring.class differ
diff --git a/substring.java b/substring.java
new file mode 100644
index 0000000..b2d8498
--- /dev/null
+++ b/substring.java
@@ -0,0 +1,14 @@
+import java.util.regex.*;
+class substring
+{
+public static void main(String args[])
+{
+String s="Hello kumar how 'can i help for you'";
+Pattern p=Pattern.compile(".*'([^']*)'.*");
+Matcher m=p.matcher(s);
+if(m.matches())
+{
+System.out.println("Single Quates:"+m.group(1));
+}
+}
+}
diff --git a/sujit.class b/sujit.class
new file mode 100644
index 0000000..35a6686
Binary files /dev/null and b/sujit.class differ
diff --git a/sujit1.class b/sujit1.class
new file mode 100644
index 0000000..85fe3a1
Binary files /dev/null and b/sujit1.class differ
diff --git a/sujit1.java b/sujit1.java
new file mode 100644
index 0000000..381115b
--- /dev/null
+++ b/sujit1.java
@@ -0,0 +1,24 @@
+class sujit1 extends Thread
+{
+public void run()
+{
+System.out.println("hello kumar");
+}
+
+public static void main(String args[])
+{
+Thread t=Thread.currentThread();
+sujit1 s=new sujit1();
+sujit1 s1=new sujit1();
+System.out.println(s.getPriority());
+System.out.println(s1.getPriority());
+s.start();
+System.out.println(t.getName());
+s.setPriority(10);
+System.out.println(s.getPriority());
+s1.setPriority(MIN_PRIORITY);
+System.out.println(s1.getPriority());
+s.setPriority(MAX_PRIORITY);
+System.out.println(s.getPriority());
+}
+}
diff --git a/swap$Node.class b/swap$Node.class
new file mode 100644
index 0000000..2c0c481
Binary files /dev/null and b/swap$Node.class differ
diff --git a/swap.class b/swap.class
new file mode 100644
index 0000000..7b44920
Binary files /dev/null and b/swap.class differ
diff --git a/swap.java b/swap.java
new file mode 100644
index 0000000..1880942
--- /dev/null
+++ b/swap.java
@@ -0,0 +1,74 @@
+class swap
+{
+static Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void push(int data)
+{
+Node x=new Node(data);
+x.next=head;
+head=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println();
+}
+
+Node swapData(Node head,int x,int y)
+{
+Node temp=head;
+Node a=null;
+Node b=null;
+while(head.next!=null)
+{
+if((head.next).data==x)
+{
+a=head.next;
+}
+else if((head.next).data==y)
+{
+b=head.next;
+}
+head=head.next;
+}
+
+if(a!=null && b!=null)
+{
+Node k=a.next;
+a.next=b.next;
+b.next=k;
+k=a.next.next;
+a.next.next=b.next.next;
+b.next.next=k;
+}
+return temp; 
+}
+
+public static void main(String args[])
+{
+swap s=new swap();
+s.push(10);
+s.push(20);
+s.push(30);
+s.push(40);
+s.push(50);
+s.print();
+s.swapData(head,40,20);
+s.print();
+}
+}
\ No newline at end of file
diff --git a/swap3.class b/swap3.class
new file mode 100644
index 0000000..3dc5f2c
Binary files /dev/null and b/swap3.class differ
diff --git a/swap3.java b/swap3.java
new file mode 100644
index 0000000..ddfad8f
--- /dev/null
+++ b/swap3.java
@@ -0,0 +1,16 @@
+import java.util.*;
+class swap3
+{
+public static void main(String args[])
+{
+List<Integer> l=new ArrayList<>();
+l.add(1);
+l.add(2);
+l.add(3);
+l.add(4);
+for(int i=l.size()-1;i>=0;i--)
+{
+System.out.println(l.get(i));
+}
+}
+}
\ No newline at end of file
diff --git a/swapLast$Node.class b/swapLast$Node.class
new file mode 100644
index 0000000..4524fb7
Binary files /dev/null and b/swapLast$Node.class differ
diff --git a/swapLast.class b/swapLast.class
new file mode 100644
index 0000000..be4f677
Binary files /dev/null and b/swapLast.class differ
diff --git a/swapLast.java b/swapLast.java
new file mode 100644
index 0000000..7675b70
--- /dev/null
+++ b/swapLast.java
@@ -0,0 +1,70 @@
+class swapLast
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void swapLast()
+{
+Node temp=head;
+Node prev=null;
+while(temp.next!=null)
+{
+prev=temp;
+temp=temp.next;
+}
+
+Node y=new Node(temp.data);
+y.next=head;
+head=y;
+prev.next=null;
+}
+
+public static void main(String args[])
+{
+swapLast l=new swapLast();
+l.append(10);
+l.append(20);
+l.append(30);
+l.append(40);
+l.append(80);
+l.print();
+l.swapLast();
+System.out.println("After the swap");
+l.print();
+}
+}
\ No newline at end of file
diff --git a/swapNodes$Node.class b/swapNodes$Node.class
new file mode 100644
index 0000000..31b0a36
Binary files /dev/null and b/swapNodes$Node.class differ
diff --git a/swapNodes.class b/swapNodes.class
new file mode 100644
index 0000000..74ce08e
Binary files /dev/null and b/swapNodes.class differ
diff --git a/swapNodes.java b/swapNodes.java
new file mode 100644
index 0000000..c9b4cf9
--- /dev/null
+++ b/swapNodes.java
@@ -0,0 +1,88 @@
+class swapNodes
+{
+static Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void swap(Node head,int x,int y)
+{
+Node temp=head;
+Node a=null;
+Node b=null;
+while(temp.next!=null)
+{
+if((temp.next).data==x)
+{
+a=temp;
+}
+else if((temp.next).data==y)
+{
+b=temp;
+}
+temp=temp.next;
+}
+
+if(a!=null && b!=null)
+{
+Node k=a.next;
+a.next=b.next;
+b.next=k;
+k=a.next.next;
+a.next.next=b.next.next;
+b.next.next=k;
+} 
+temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+public static void main(String args[])
+{
+swapNodes s=new swapNodes();
+s.append(10);
+s.append(20);
+s.append(30);
+s.append(40);
+s.print();
+s.swap(head,20,40);
+}
+}
\ No newline at end of file
diff --git a/swapNodes1$Node.class b/swapNodes1$Node.class
new file mode 100644
index 0000000..b45faed
Binary files /dev/null and b/swapNodes1$Node.class differ
diff --git a/swapNodes1.class b/swapNodes1.class
new file mode 100644
index 0000000..4377ae3
Binary files /dev/null and b/swapNodes1.class differ
diff --git a/swapNodes1.java b/swapNodes1.java
new file mode 100644
index 0000000..3efbe94
--- /dev/null
+++ b/swapNodes1.java
@@ -0,0 +1,89 @@
+class swapNodes1
+{
+static Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void swap(Node head,int x,int y)
+{
+Node temp=head;
+if(x==y)
+System.out.println("null");
+
+Node a=null;
+Node b=null;
+while(temp.next!=null)
+{
+if((temp.next).data==x)
+{
+a=temp;
+}
+else if((temp.next).data==y)
+{
+b=temp;
+}
+temp=temp.next;
+}
+if(a!=null && b!=null)
+{
+Node k=a.next;
+a.next=b.next;
+b.next=k;
+k=a.next.next;
+a.next.next=b.next.next;
+b.next.next=k;
+}
+temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+public static void main(String args[])
+{
+swapNodes1 s=new swapNodes1();
+s.append(10);
+s.append(30);
+s.append(20);
+s.append(60);
+s.print();
+s.swap(head,30,20);
+}
+}
\ No newline at end of file
diff --git a/swapObj1.class b/swapObj1.class
new file mode 100644
index 0000000..c10b499
Binary files /dev/null and b/swapObj1.class differ
diff --git a/swapObj1.java b/swapObj1.java
new file mode 100644
index 0000000..f4726d1
--- /dev/null
+++ b/swapObj1.java
@@ -0,0 +1,28 @@
+class Car
+{
+int no;
+Car(int no)
+{
+this.no=no;
+}
+
+}
+
+
+class swapObj1
+{
+static void swap(Car c1,Car c2)
+{
+int temp=c1.no;
+c1.no=c2.no;
+c2.no=temp;
+}
+public static void main(String args[])
+{
+Car c1=new Car(10);
+Car c2=new Car(20);
+swap(c1,c2);
+System.out.println("c1="+c1.no);
+System.out.println("c2="+c2.no);
+}
+}
\ No newline at end of file
diff --git a/swapPair$Node.class b/swapPair$Node.class
new file mode 100644
index 0000000..b82ceb5
Binary files /dev/null and b/swapPair$Node.class differ
diff --git a/swapPair.class b/swapPair.class
new file mode 100644
index 0000000..f26e371
Binary files /dev/null and b/swapPair.class differ
diff --git a/swapPair.java b/swapPair.java
new file mode 100644
index 0000000..b11df2c
--- /dev/null
+++ b/swapPair.java
@@ -0,0 +1,66 @@
+class swapPair
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void swap()
+{
+Node temp=head;
+while(temp!=null && temp.next!=null)
+{
+int k=temp.data;
+temp.data=temp.next.data;
+temp.next.data=k;
+temp=temp.next.next;
+}
+}
+
+public static void main(String args[])
+{
+swapPair s=new swapPair();
+s.append(10);
+s.append(20);
+s.append(30);
+s.append(40);
+s.print();
+s.swap();
+System.out.println("After swaping the pair");
+s.print();
+}
+}
\ No newline at end of file
diff --git a/swapPair1.java b/swapPair1.java
new file mode 100644
index 0000000..a82e53b
--- /dev/null
+++ b/swapPair1.java
@@ -0,0 +1,56 @@
+class swapPair1
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+void push(int data)
+{
+Node x=new Node(data);
+x.next=head;
+head=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Node swap()
+{
+Node temp=head;
+
+while(temp!=null && temp.next!=null)
+{
+int x=temp.data;
+temp.data=temp.next.data;
+temp.next.data=x;
+temp=temp.next.next;
+}
+return head;
+}
+
+public static void main(String args[])
+{
+swapPair1 s=new swapPair1();
+s.push(10);
+s.push(20);
+s.push(30);
+s.print();
+Node k=s.swap();
+s.print();
+}
+}
\ No newline at end of file
diff --git a/swapPair2$Node.class b/swapPair2$Node.class
new file mode 100644
index 0000000..26834e3
Binary files /dev/null and b/swapPair2$Node.class differ
diff --git a/swapPair2.class b/swapPair2.class
new file mode 100644
index 0000000..eade54d
Binary files /dev/null and b/swapPair2.class differ
diff --git a/swapPair2.java b/swapPair2.java
new file mode 100644
index 0000000..f9df431
--- /dev/null
+++ b/swapPair2.java
@@ -0,0 +1,57 @@
+class swapPair2
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void push(int data)
+{
+Node x=new Node(data);
+x.next=head;
+head=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+Node swap()
+{
+Node temp=head;
+while(temp!=null && temp.next!=null)
+{
+int x=temp.data;
+temp.data=temp.next.data;
+temp.next.data=x;
+temp=temp.next.next;
+}
+return head;
+}
+
+public static void main(String args[])
+{
+swapPair2 s=new swapPair2();
+s.push(1);
+s.push(2);
+s.push(3);
+s.push(4);
+s.print();
+Node k=s.swap();
+s.print();
+}
+}
\ No newline at end of file
diff --git a/swapTwo.class b/swapTwo.class
new file mode 100644
index 0000000..a825bc5
Binary files /dev/null and b/swapTwo.class differ
diff --git a/swapTwo.java b/swapTwo.java
new file mode 100644
index 0000000..7382730
--- /dev/null
+++ b/swapTwo.java
@@ -0,0 +1,13 @@
+class swapTwo
+{
+public static void main(String args[])
+{
+int a=10;
+int b=20;
+a=a+b;
+b=a-b;
+a=a-b;
+System.out.println("The value a is:"+a);
+System.out.println("b="+b);
+}
+}
\ No newline at end of file
diff --git a/swapfront$Node.class b/swapfront$Node.class
new file mode 100644
index 0000000..500071b
Binary files /dev/null and b/swapfront$Node.class differ
diff --git a/swapfront.class b/swapfront.class
new file mode 100644
index 0000000..ff64b45
Binary files /dev/null and b/swapfront.class differ
diff --git a/swapfront.java b/swapfront.java
new file mode 100644
index 0000000..a6394a8
--- /dev/null
+++ b/swapfront.java
@@ -0,0 +1,68 @@
+class swapfront
+{
+Node head;
+class Node
+{
+int data;
+Node next;
+Node(int d)
+{
+data=d;
+next=null;
+}
+}
+
+void append(int data)
+{
+Node x=new Node(data);
+if(head==null)
+{
+head=x;
+return ;
+}
+Node temp=head;
+while(temp.next!=null)
+{
+temp=temp.next;
+}
+temp.next=x;
+}
+
+void print()
+{
+Node temp=head;
+while(temp!=null)
+{
+System.out.print(temp.data+"->");
+temp=temp.next;
+}
+System.out.println("null");
+}
+
+void swap()
+{
+Node temp=head;
+Node prev=null;
+while(temp.next!=null)
+{
+prev=temp;
+temp=temp.next;
+}
+prev.next=null;
+temp.next=head;
+head=temp;
+}
+
+public static void main(String args[])
+{
+swapfront s=new swapfront();
+s.append(10);
+s.append(20);
+s.append(30);
+s.append(40);
+s.print();
+s.swap();
+System.out.println("After swap the data");
+s.print();
+}
+}
\ No newline at end of file
diff --git a/synchro.class b/synchro.class
new file mode 100644
index 0000000..4b88cff
Binary files /dev/null and b/synchro.class differ
diff --git a/synchro.java b/synchro.java
new file mode 100644
index 0000000..96e9342
--- /dev/null
+++ b/synchro.java
@@ -0,0 +1,45 @@
+class Sender
+{
+public void send(String msg)
+{
+System.out.println("Sending..."+msg);
+try
+{
+Thread.sleep(1000);
+}
+catch(Exception e)
+{
+System.out.println("Exception occur");
+}
+System.out.println(msg+" Sent");
+}
+}
+
+class ThreadSend extends Thread
+{
+String msg;
+Sender sender;
+ThreadSend(String msg,Sender sender)
+{
+this.msg=msg;
+this.sender=sender;
+}
+
+public void run()
+{
+synchronized(sender)
+{
+sender.send(msg);
+}
+}
+}
+
+class synchro
+{
+public static void main(String args[])
+{
+Sender sd=new Sender();
+ThreadSend t=new ThreadSend("hiii",sd);
+t.start();
+}
+}
\ No newline at end of file
diff --git a/synchro1.class b/synchro1.class
new file mode 100644
index 0000000..2a7991b
Binary files /dev/null and b/synchro1.class differ
diff --git a/synchro1.java b/synchro1.java
new file mode 100644
index 0000000..191f178
--- /dev/null
+++ b/synchro1.java
@@ -0,0 +1,55 @@
+import java.util.*;
+class Sender
+{
+public void Send(String msg) 
+{
+System.out.println("Sending..."+msg);
+try
+{
+Thread.sleep(1000);
+}
+catch(Exception e)
+{
+System.out.println("Exception occur");
+}
+System.out.println(msg+" Sent");
+}
+}
+
+class ThreadSend extends Thread
+{
+String msg;
+Sender sender;
+ThreadSend(String msg,Sender sender)
+{
+this.msg=msg;
+this.sender=sender;
+}
+
+public void run()
+{
+synchronized(sender)
+{
+sender.Send(msg);
+}
+}
+}
+
+class synchro1
+{
+public static void main(String args[]) throws Exception
+{
+Scanner sc=new Scanner(System.in);
+
+Sender snd=new Sender();
+for(int i=0;i<4;i++)
+{
+System.out.println("What you wanna to send");
+String s=sc.nextLine();
+ThreadSend t=new ThreadSend(s,snd);
+t.start();
+t.join();
+System.out.println();
+}
+}
+}
diff --git a/synchro2.class b/synchro2.class
new file mode 100644
index 0000000..ad176ed
Binary files /dev/null and b/synchro2.class differ
diff --git a/synchro2.java b/synchro2.java
new file mode 100644
index 0000000..49c8e5a
--- /dev/null
+++ b/synchro2.java
@@ -0,0 +1,56 @@
+import java.util.*;
+class Sender
+{
+void Send(String msg)
+{
+System.out.println(msg+" Sending....");
+try
+{
+Thread.sleep(1000);
+}
+catch(Exception e)
+{
+System.out.println("Error:");
+}
+System.out.println(msg+".... Sent");
+}
+}
+
+class ThreadStuff extends Thread
+{
+String msg;
+Sender sender;
+
+ThreadStuff(String msg,Sender sender)
+{
+this.msg=msg;
+this.sender=sender;
+}
+
+public void run()
+{
+synchronized(sender)
+{
+sender.Send(msg);
+}
+}
+}
+
+class synchro2
+{
+public static void main(String args[])throws Exception
+{
+Scanner sc=new Scanner(System.in);
+Sender snd=new Sender();
+for(int i=0;i<4;i++)
+{
+System.out.println("What you wanna to send?");
+String s=sc.nextLine();
+ThreadStuff t=new ThreadStuff(s,snd);
+t.start();
+t.join();
+System.out.println();
+}
+
+}
+}
\ No newline at end of file
diff --git a/table.class b/table.class
new file mode 100644
index 0000000..8afda09
Binary files /dev/null and b/table.class differ
diff --git a/table.java b/table.java
new file mode 100644
index 0000000..f8bc3f3
--- /dev/null
+++ b/table.java
@@ -0,0 +1,14 @@
+import java.util.*;
+class table
+{
+public static void main(String args[])
+{
+Scanner sc=new Scanner(System.in);
+System.out.println("Enter the number");
+int n=sc.nextInt();
+for(int i=1;i<=10;i++)
+{
+System.out.print((n*i)+" ");
+}
+}
+}
\ No newline at end of file
diff --git a/table1.class b/table1.class
new file mode 100644
index 0000000..44a6c31
Binary files /dev/null and b/table1.class differ
diff --git a/table1.java b/table1.java
new file mode 100644
index 0000000..19711a8
--- /dev/null
+++ b/table1.java
@@ -0,0 +1,14 @@
+class table1
+{
+public static void main(String args[])
+{
+for(int i=1;i<=5;i++)
+{
+for(int j=1;j<=10;j++)
+{
+System.out.print((i*j)+" ");
+}
+System.out.println();
+}
+}
+}
\ No newline at end of file
diff --git a/task.java b/task.java
new file mode 100644
index 0000000..b1e6580
--- /dev/null
+++ b/task.java
@@ -0,0 +1,65 @@
+import java.util.*;
+import java.util.concurrent.*;
+import java.text.*;
+class Task implements Runnable
+{
+String name;
+Task(String name)
+{
+this.name=name;
+}
+
+public void run()
+{
+try
+{
+for(int i=0;i<=5;i++)
+{
+if(i==0)
+{
+Date d=new Date();
+SimpleDateFormat ft=new SimpleDateFormat("hh:mm:ss");
+System.out.println("Initialization time for task name="+name+"=" +ft.format(d));
+}
+else
+{
+Date d=new Date();
+SimpleDateFormat ft=new SimpleDateFormat("hh:mm:ss");
+System.out.println("Exceuting time for task name " +name+ " "+ ft.format(d));
+}
+Thread.sleep(1000);
+}
+System.out.println(name+" complete");
+}
+
+catch(InterruptedException e)
+{
+e.printStackTrace();
+}
+}
+}
+
+class task
+{
+static int MAX_T=3;
+public static void main(String args[])
+{
+Runnable t1=new Task("task 1");
+Runnable t2=new Task("task 2");
+Runnable t3=new Task("task 3");
+Runnable t4=new Task("task4");
+Runnable t5=new Task("task 5");
+
+ExecutorService pool=Executors.newFixedThreadPool(MAX_T);
+
+pool.execute(t1);
+pool.execute(t2);
+pool.execute(t3);
+pool.execute(t4);
+pool.execute(t5);
+
+pool.shutdown();
+}
+} 
+
+ 
\ No newline at end of file
diff --git a/teacher.class b/teacher.class
new file mode 100644
index 0000000..110345e
Binary files /dev/null and b/teacher.class differ
diff --git a/teacher.java b/teacher.java
new file mode 100644
index 0000000..24ad56a
--- /dev/null
+++ b/teacher.java
@@ -0,0 +1,29 @@
+class Student
+{
+int roll;
+String name;
+Student(int roll,String name)
+{
+this.roll=roll;
+this.name=name;
+}
+
+public int getRoll()
+{
+return roll;
+}
+
+public String getName()
+{
+return name;
+}
+}
+
+class teacher
+{
+public static void main(String args[])
+{
+Student s=new Student(1,"sujit");
+System.out.println("Roll="+s.getRoll()+"Name="+s.getName());
+}
+}
\ No newline at end of file
diff --git a/thread.class b/thread.class
new file mode 100644
index 0000000..fa2468e
Binary files /dev/null and b/thread.class differ
diff --git a/thread1.class b/thread1.class
new file mode 100644
index 0000000..42d4c11
Binary files /dev/null and b/thread1.class differ
diff --git a/thread1.java b/thread1.java
new file mode 100644
index 0000000..6ad1bb4
--- /dev/null
+++ b/thread1.java
@@ -0,0 +1,26 @@
+class sujit extends Thread
+{
+public void run()
+{
+try
+{
+System.out.println("thread:"+Thread.currentThread().getId()+" is running");
+}
+
+catch(Exception e)
+{
+System.out.println(e);
+}
+}
+}
+
+class thread1
+{
+public static void main(String args[])
+{
+sujit s=new sujit();
+s.start();
+sujit s1=new sujit();
+s1.start();
+}
+}
\ No newline at end of file
diff --git a/thread2.class b/thread2.class
new file mode 100644
index 0000000..1359678
Binary files /dev/null and b/thread2.class differ
diff --git a/thread2.java b/thread2.java
new file mode 100644
index 0000000..b2b1757
--- /dev/null
+++ b/thread2.java
@@ -0,0 +1,24 @@
+class kushal implements Runnable
+{
+public void run()
+{
+try
+{
+System.out.println("Thread:"+Thread.currentThread().getId()+" is running");
+}
+
+catch(Exception e)
+{
+System.out.println(e);
+}
+}
+}
+
+class thread2
+{
+public static void main(String args[])
+{
+Thread th=new Thread(new kushal());
+th.start();
+}
+}
diff --git a/thread3.class b/thread3.class
new file mode 100644
index 0000000..b60a1d2
Binary files /dev/null and b/thread3.class differ
diff --git a/thread3.java b/thread3.java
new file mode 100644
index 0000000..60ba35d
--- /dev/null
+++ b/thread3.java
@@ -0,0 +1,23 @@
+class sujit implements Runnable
+{
+public void run()
+{
+try
+{
+System.out.println("Thread:"+Thread.currentThread().getId()+" is running");
+}
+catch(Exception e)
+{
+System.out.println(e);
+}
+
+}
+}
+class thread3
+{
+public static void main(String args[])
+{
+Thread th=new Thread(new sujit());
+th.start();
+}
+}
\ No newline at end of file
diff --git a/traingle.class b/traingle.class
new file mode 100644
index 0000000..1d816b0
Binary files /dev/null and b/traingle.class differ
diff --git a/traingle.java b/traingle.java
new file mode 100644
index 0000000..59a318c
--- /dev/null
+++ b/traingle.java
@@ -0,0 +1,39 @@
+import java.util.*;
+class traingle
+{
+static int arrayTraingle(List<List<Integer>> l)
+{
+List<Integer> list=new ArrayList(l.get(l.size()-1));
+
+for(int i=l.size()-2;i>=0;i--)
+{
+for(int j=0;j<i+1;j++)
+{
+int x=l.get(i).get(j)+Math.min(list.get(j),list.get(j+1));
+list.add(j,x);
+System.out.println(list);
+}
+}
+
+return 0;
+}
+public static void main(String args[])
+{
+List<List<Integer>> l=new ArrayList<>();
+List<Integer> l1=new ArrayList<>();
+l1.add(-1);
+l.add(new ArrayList(l1));
+List<Integer> l2=new ArrayList<>();
+l2.add(2);
+l2.add(3);
+l.add(new ArrayList(l2));
+
+List<Integer> l3=new ArrayList<>();
+l3.add(1);
+l3.add(-1);
+l3.add(-3);
+
+l.add(new ArrayList(l3));
+System.out.println(arrayTraingle(l));
+}
+}
\ No newline at end of file
diff --git a/trap.class b/trap.class
new file mode 100644
index 0000000..56273c1
Binary files /dev/null and b/trap.class differ
diff --git a/trap.java b/trap.java
new file mode 100644
index 0000000..ce7f1cd
--- /dev/null
+++ b/trap.java
@@ -0,0 +1,34 @@
+import java.util.*;
+class trap
+{
+public static void main(String args[])
+{
+int a[]={0,1,0,2,1,0,1,3,2,1,2,1};
+int n=a.length;
+int left[]=new int[n];
+int right[]=new int[n];
+int max=0;
+int result=0;
+for(int i=0;i<n;i++)
+{
+max=Math.max(max,a[i]);
+left[i]=max;
+}
+
+max=0;
+for(int i=n-1;i>=0;i--)
+{
+max=Math.max(max,a[i]);
+right[i]=max;
+}
+
+for(int i=0;i<n;i++)
+{
+int total=Math.min(left[i],right[i])-a[i];
+result+=total;
+}
+
+System.out.println(Arrays.toString(left));
+System.out.println(Arrays.toString(right));
+}
+}
\ No newline at end of file
diff --git a/treeSet2.class b/treeSet2.class
new file mode 100644
index 0000000..cbc245c
Binary files /dev/null and b/treeSet2.class differ
diff --git a/treeSet2.java b/treeSet2.java
new file mode 100644
index 0000000..ee779a1
--- /dev/null
+++ b/treeSet2.java
@@ -0,0 +1,13 @@
+import java.util.*;
+class treeSet2
+{
+public static void main(String args[])
+{
+Set<Integer> s=new TreeSet<>();
+s.add(10);
+s.add(12);
+s.add(1);
+s.add(2);
+System.out.println("The set is:"+s);
+}
+}
\ No newline at end of file
diff --git a/treeset1.class b/treeset1.class
new file mode 100644
index 0000000..7ebd2e8
Binary files /dev/null and b/treeset1.class differ
diff --git a/treeset1.java b/treeset1.java
new file mode 100644
index 0000000..ec79611
--- /dev/null
+++ b/treeset1.java
@@ -0,0 +1,23 @@
+import java.util.*;
+class treeset1
+{
+public static void main(String args[])
+{
+Set<Integer> set=new TreeSet<>();
+set.add(10);
+set.add(2);
+set.add(1);
+set.add(3);
+System.out.println(set);
+Iterator i=set.iterator();
+while(i.hasNext())
+{
+System.out.println(i.next());
+}
+Iterator i1=set.descendingIterator();
+while(i1.hasNext())
+{
+System.out.println(i1.next());
+}
+}
+}
\ No newline at end of file
diff --git a/turnMathod.class b/turnMathod.class
new file mode 100644
index 0000000..947a615
Binary files /dev/null and b/turnMathod.class differ
diff --git a/turnMethod.class b/turnMethod.class
new file mode 100644
index 0000000..e9cb33e
Binary files /dev/null and b/turnMethod.class differ
diff --git a/turnMethod.java b/turnMethod.java
new file mode 100644
index 0000000..f3fc285
--- /dev/null
+++ b/turnMethod.java
@@ -0,0 +1,36 @@
+class Student
+{
+protected void dance()
+{
+System.out.println("Hello i am doing dance in parent");
+}
+
+private void show()
+{
+System.out.println("Private methods are not overridden");
+}
+}
+
+class teacher extends Student
+{
+public void dance()
+{
+System.out.println("I am doing dance in child");
+}
+
+private void show()
+{
+System.out.println("hello how are you");
+}
+}
+
+class turnMethod
+{
+public static void main(String args[])
+{
+Student s=new Student();
+s.dance();
+teacher t=new teacher();
+t.dance();
+}
+}
\ No newline at end of file
diff --git a/two.class b/two.class
new file mode 100644
index 0000000..da28d4e
Binary files /dev/null and b/two.class differ
diff --git a/value1.class b/value1.class
new file mode 100644
index 0000000..4faf9dd
Binary files /dev/null and b/value1.class differ
diff --git a/value1.java b/value1.java
new file mode 100644
index 0000000..bc428c7
--- /dev/null
+++ b/value1.java
@@ -0,0 +1,25 @@
+class gaurav
+{
+String name;
+int roll;
+void getValue(String name,int roll)
+{
+synchronized(this)
+{
+this.name=name;
+this.roll=roll;
+}
+System.out.println("Hello gaurav how can i help you");
+}
+}
+
+class value1
+{
+public static void main(String args[])
+{
+gaurav g=new gaurav();
+g.getValue("Ankit",13);
+System.out.println(g.name);
+System.out.println(g.roll);
+}
+}
\ No newline at end of file
diff --git a/viko.txt b/viko.txt
new file mode 100644
index 0000000..40daa52
Binary files /dev/null and b/viko.txt differ
diff --git a/weak.class b/weak.class
new file mode 100644
index 0000000..48b4c30
Binary files /dev/null and b/weak.class differ
diff --git a/weak.java b/weak.java
new file mode 100644
index 0000000..7f94956
--- /dev/null
+++ b/weak.java
@@ -0,0 +1,29 @@
+import java.util.*;
+class weak
+{
+public static void main(String args[])
+{
+Map<Integer,String> weak=new WeakHashMap<>();
+weak.put(1,"kushal");
+weak.put(3,"kumar");
+weak.put(5,"aman");
+weak.put(2,"sujit");
+weak.put(6,"Ankit");
+System.out.println("Map is"+weak);
+
+if(weak.containsValue("kumar"))
+{
+System.out.println("Yes! it is present");
+}
+if(weak.containsKey(4))
+{
+System.out.println("Yes it is exist");
+}
+
+System.out.println(weak.isEmpty());
+
+weak.clear();
+System.out.println("Map is:"+weak);
+System.out.println("Is it empty:"+weak.isEmpty());
+}
+}
\ No newline at end of file
diff --git a/weak2.class b/weak2.class
new file mode 100644
index 0000000..2e2ac42
Binary files /dev/null and b/weak2.class differ
diff --git a/weak2.java b/weak2.java
new file mode 100644
index 0000000..b1cb056
--- /dev/null
+++ b/weak2.java
@@ -0,0 +1,26 @@
+import java.util.*;
+class weak2
+{
+public static void main(String args[])
+{
+Map<Integer,String> map=new WeakHashMap<>();
+map.put(1,"gaurav");
+map.put(2,"kushal");
+map.put(3,"kumar");
+map.put(4,"vikash");
+System.out.println(map);
+
+Set s=map.entrySet();
+System.out.println("Set is:"+s);
+
+Set s1=map.keySet();
+System.out.println("Set Key:"+s1);
+
+Collection s2=map.values();
+System.out.println("Map values in Set:"+s2);
+Map<Integer,String> map2=new WeakHashMap<>();
+map2.putAll(map);
+System.out.println(map2);
+System.out.println(map2.size());
+}
+}
\ No newline at end of file
diff --git a/zone4.class b/zone4.class
new file mode 100644
index 0000000..42e8f7d
Binary files /dev/null and b/zone4.class differ