├── Diff web app and dist app.jpg
├── abstrInterference
    ├── AB.java
    ├── Abstract2.java
    ├── Ads.java
    ├── Ads2.java
    ├── Defaultmethod.java
    ├── Interf18.java
    ├── MultipleInheriStatic.java
    ├── MultipleInheritance.java
    └── StaticMethod.java
├── arrayMethods
    ├── ArrayPrintingDemo.java
    ├── ArraySortDEmo.java
    ├── ArrayofStrings.java
    ├── ArraysDottoString.java
    ├── BinarySearch.java
    ├── BinaryString.java
    ├── ComparatorForArray.java
    ├── CompareArrays.java
    ├── ContainsInArray.java
    ├── CopyOfArray.java
    ├── LinearSearch.java
    ├── PairSearch.java
    ├── StringToArray.java
    └── commaSeparatedStringToArray.java
├── assertion
    └── AssertDemo.java
├── bruteForceAlgorithm
    └── FindPair.java
├── classProperties
    └── ClassFields.java
├── codility
    ├── BinaryGap.java
    ├── CyclicRotation.java
    ├── CyclicRotation1.java
    ├── FrogJmp.java
    ├── FrogJmp2.java
    ├── FrogRiverOne.java
    ├── MissingInteger.java
    ├── MissingInteger1.java
    ├── OddOccurrencesInArray.java
    ├── OddOccurrencesInArray1.java
    ├── PermutationCheck.java
    ├── PermutationMissingElement.java
    ├── PermutationMissingElement1.java
    ├── Practice.java
    ├── TapeEquilibrium.java
    └── package-info.java
├── collection
    ├── AddArray.java
    ├── ArrayList1.java
    ├── ArrayToList.java
    ├── BinarySearch.java
    ├── ComparatorDemo.java
    ├── HashMapDemo.java
    ├── HashSetDemo.java
    ├── ReadingArrayList.java
    └── TreeSetDemo.java
├── factorymethods
    └── UnmodifiableCollection.java
├── generics
    ├── TestGen.java
    └── TestGen2.java
├── immutable
    ├── ImmutableDemo.java
    └── ImmutableStudent.java
├── immutableVsFinal
    └── ImmutableVsFinal.java
├── input
    ├── ArrayInputDemo.java
    ├── BufferedInput.java
    ├── ScannerDemo.java
    ├── ToCheckInput.java
    └── TwoDArrayInout.java
├── java8
    └── ForEach.java
├── practice
    └── StringDemo.java
├── predicate
    ├── PredCollDemo.java
    └── PredicateDemo.java
├── projects
    ├── ExtractMailIDFrmFile.java
    └── ExtractMobFrmFile.java
├── regex
    ├── RegFileNames.java
    ├── RegJavaIdentifier.java
    ├── RegMailID.java
    ├── RegMobNum.java
    ├── Regex1.java
    └── RegexDemo.java
├── singleton
    ├── RuntimeFactoryMethod.java
    ├── Singleton.java
    ├── Singleton2.java
    └── TestSingleton.java
├── stream
    └── StreamDemoList.java
├── validation
    ├── Validation.java
    └── ValidationOld.java
├── vararg
    ├── HeapPollution.java
    └── VarArg.java
└── wrapper
    ├── package-info.java
    └── wrapper.java


/Diff web app and dist app.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kendalerishi/Java/2fabdbf7f1aa7d87fc4bbe9c0e107ca201105e79/Diff web app and dist app.jpg


--------------------------------------------------------------------------------
/abstrInterference/AB.java:
--------------------------------------------------------------------------------
 1 | package abstrInterference;
 2 | 
 3 | abstract class Abstract1 
 4 | {
 5 | 	Abstract1(){System.out.println("DEF");};
 6 | 	private static String a1()
 7 | 	{return "Hi a1";}
 8 | 	
 9 | 	abstract void a2();
10 | 	/*{
11 | 		
12 | 	}
13 | 	*/
14 | 	public static String goa(){System.out.println("Goa1");return "goa";}
15 | 	
16 | }
17 | 
18 | public class AB extends Abstract1 
19 | {
20 | 	AB(){super.goa();
21 | 		 this.goa();
22 | 		}
23 | 	
24 | 	public static String goa(){System.out.println("Goa2");return "jik";}
25 | 	void a2(){}
26 | 	//public void a3(){ System.out.println("Hji");}
27 | 	
28 | 	public static void main(String[] args)
29 | 	{
30 | 		AB ab = new AB();
31 | 		
32 | 		//goa();
33 | 		//System.out.println(goa());
34 | 		
35 | 	}	
36 | }


--------------------------------------------------------------------------------
/abstrInterference/Abstract2.java:
--------------------------------------------------------------------------------
 1 | package abstrInterference;
 2 | 
 3 | abstract class C 
 4 | {
 5 | 	abstract int a1();
 6 | 	abstract int a3();
 7 | 	void a4()
 8 | 	{}
 9 | }
10 | 
11 | abstract class A extends C
12 | {
13 | 	abstract int a2();
14 | 	int a1()
15 | 	{
16 | 		return 10;
17 | 	}
18 | 	
19 | 	int a3()
20 | 	{
21 | 		return 10;
22 | 	}
23 | 	
24 | 	abstract void a4();
25 | }
26 | 
27 | class Abstract2 extends A
28 | {
29 | 	
30 | int a2()
31 | {
32 | 	System.out.println("Hi");
33 | 	return 0;}
34 | void a4()
35 | {}
36 | 
37 | /*void a1()
38 | {}*/
39 | 
40 | public static void main(String[] args)
41 | {
42 | 	Abstract2 b1 = new Abstract2();
43 | 	b1.a3();
44 | }
45 | 
46 | }
47 | 


--------------------------------------------------------------------------------
/abstrInterference/Ads.java:
--------------------------------------------------------------------------------
  1 | package abstrInterference;
  2 | 
  3 | import java.io.FileReader;
  4 | import java.util.*;
  5 | 
  6 | public class Ads 
  7 | {
  8 | 	public static ArrayList<String> data()
  9 | 	{
 10 | 		int[] array = new int[4];
 11 | 		String s1=("12, Ram, Eng, 1200");
 12 | 		String s2=("08, Sita, Test, 800");
 13 | 		String s3=("11, Shyam, Eng, 1900");
 14 | 		String s4=("05, Gita, Test, 350");
 15 | 		ArrayList<String> inputData = new ArrayList<String>();
 16 | 		inputData.add(s1);
 17 | 		inputData.add(s2);
 18 | 		inputData.add(s3);
 19 | 		inputData.add(s4);
 20 | 		return inputData;
 21 | 	}
 22 | 
 23 | 	public static void main (String[] args) 
 24 | 	{
 25 | 	        
 26 | 		processData1(Ads.data());
 27 | 	        
 28 | 	   
 29 | 	}
 30 | 	  public static Map<String,Integer> processData(ArrayList<String> array)
 31 | 	  {
 32 | 		
 33 | 		ArrayList<String> al = data();
 34 | 		List<String> alId = new ArrayList<String>();
 35 | 		for(int i=0;i<al.size();i++)
 36 | 		{
 37 | 			alId.add(i,(((al.get(i)).split(",")))[0]);
 38 | 			
 39 | 		}
 40 | 		for(int i=0;i<alId.size();i++)
 41 | 		{
 42 | 			System.out.println(alId.get(i));
 43 | 		}
 44 | 		
 45 | 		
 46 | 		  
 47 | 		HashMap<String,Integer> retVal = new HashMap<String,Integer>();
 48 | 		return retVal;
 49 | 	  }
 50 | 	
 51 | 
 52 | 	  public static void processData1(ArrayList<String> array)
 53 | 	  {
 54 | 		
 55 | 		ArrayList<String> al = data();
 56 | 		List<String> alId = new ArrayList<String>();
 57 | 		for(int i=0;i<al.size();i++)
 58 | 		{
 59 | 			alId.add(i,(((al.get(i)).split(",")))[0]);
 60 | 			
 61 | 		}
 62 | 		
 63 | 		List<String> alDept = new ArrayList<String>();
 64 | 		for(int i=0;i<al.size();i++)
 65 | 		{
 66 | 			alDept.add(i,(((al.get(i)).split(",")))[2]);
 67 | 			
 68 | 		}
 69 | 		
 70 | 		List<String> alSal = new ArrayList<String>();
 71 | 		for(int i=0;i<al.size();i++)
 72 | 		{
 73 | 			alSal.add(i,(((al.get(i)).split(",")))[3]);
 74 | 			
 75 | 		}
 76 | 		
 77 | 		for(int i=0;i<alId.size();i++)
 78 | 		{
 79 | 			System.out.println(alId.get(i)+"\t"+alDept.get(i)+"\t\t"+alSal.get(i));
 80 | 		}
 81 | 		
 82 | 		HashMap<Integer,String> hmSal = new HashMap<Integer,String>();
 83 | 		//int MaxSal=Integer.parseInt(alSal.get(0));
 84 | 		for(int i=0;i<alId.size();i++)
 85 | 		{	
 86 | 			hmSal.put(Integer.valueOf(alId.get(i)), alSal.get(i));
 87 | 		}
 88 | 		Set s = hmSal.keySet();
 89 | 		System.out.println(s);
 90 | 		TreeSet ts = new TreeSet();
 91 | 		for(int i=0;i<s.size();i++)
 92 | 		{
 93 | 			ts.add(s);
 94 | 		}
 95 | 		System.out.println("TreeSet  " + ts);
 96 | 		Collection c = hmSal.values();
 97 | 		System.out.println(c);
 98 | 		
 99 | 		
100 | 		
101 | 	  }
102 | }
103 | 


--------------------------------------------------------------------------------
/abstrInterference/Ads2.java:
--------------------------------------------------------------------------------
  1 | package abstrInterference;
  2 | 
  3 | import java.io.FileReader;
  4 | import java.util.*;
  5 | 
  6 | public class Ads2 
  7 | {
  8 | 	public static void main (String[] args) 
  9 | 	{
 10 | 		HashMap<String,Integer> retVal = (HashMap)processData(data1());
 11 | 		for(Map.Entry<String,Integer> e: retVal.entrySet())
 12 |         System.out.println(e.getKey() + ": " + e.getValue());
 13 | 		
 14 | 		//processData2(data1());
 15 | 	}
 16 | 	public static ArrayList<String> data1()
 17 | 	{
 18 | 		int[] array = new int[4];
 19 | 		String s1=("129, Ram, Eng, 1200");
 20 | 		String s2=("080, Sita, Test, 800");
 21 | 		String s3=("12, Shyam, Eng, 1900");
 22 | 		String s4=("15, Gita, Test, 350");
 23 | 		ArrayList<String> inputData1 = new ArrayList<String>();
 24 | 		inputData1.add(s1);
 25 | 		inputData1.add(s2);
 26 | 		inputData1.add(s3);
 27 | 		inputData1.add(s4);
 28 | 		return inputData1;
 29 | 	}
 30 | 
 31 | 	  public static Map<String,Integer> processData(ArrayList<String> array)
 32 | 	  {  
 33 | 		  ArrayList<String> al = data1();
 34 | 		  List<String> alAl = new ArrayList<String>();
 35 | 			
 36 | 			for(int i=0;i<al.size();i++)
 37 | 			{	
 38 | 				alAl.addAll(Arrays.asList((al.get(i)).split(",")));
 39 | 			}
 40 | 			
 41 | 			System.out.println(alAl);
 42 | 			
 43 | 			List<String> alAll = new ArrayList<String>();
 44 | 			for(int i=0;i<alAl.size();i++)
 45 | 			{
 46 | 				alAll.add(alAl.get(i).trim());
 47 | 			}
 48 | 			alAl=null;
 49 | 			System.out.println(alAll);
 50 | 		
 51 | 		int maxEngId=0;			//(int)Integer.parseInt(alAll.get(0));
 52 | 		int maxTestId=0;
 53 | 		int maxEngSal=0;
 54 | 		int maxTestSal=0;
 55 | 		String dept1=null;
 56 | 		String dept2=null;
 57 | 		
 58 | 		
 59 | 		for(int i=0;i<alAll.size();i=i+4)              // 15 elements Hence size+1
 60 | 		{
 61 | 			if(((alAll.get(i+2)).equals("Eng"))&&(Integer.parseInt(alAll.get(i))>maxEngId))
 62 | 			{
 63 | 				maxEngId=Integer.parseInt(alAll.get(i));
 64 | 				dept1=alAll.get(i+2);
 65 | 				maxEngSal=Integer.parseInt(alAll.get(i+3));
 66 | 			}	
 67 | 			
 68 | 			if(((alAll.get(i+2)).equals("Test"))&&(Integer.parseInt(alAll.get(i))>maxTestId))
 69 | 			{
 70 | 				maxTestId=Integer.parseInt(alAll.get(i));
 71 | 				dept2=alAll.get(i+2);
 72 | 				maxTestSal=Integer.parseInt(alAll.get(i+3));
 73 | 			}	
 74 | 		}
 75 | 		System.out.println("Dept"+"\t"+"Id"+"\t"+"Salary");
 76 | 		System.out.println(dept1 + "\t" + maxEngId+"\t"+maxEngSal);
 77 | 		System.out.println(dept2 + "\t" + maxTestId+"\t"+maxTestSal);
 78 | 			
 79 | 		
 80 | 		HashMap<String,Integer> retVal = new HashMap<String,Integer>();
 81 | 		retVal.put(dept1, maxEngSal);
 82 | 		retVal.put(dept2, maxTestSal);
 83 | 		return retVal;
 84 | 				
 85 | 	  }
 86 | 	  
 87 | 	  public static void processData2(ArrayList<String> array)
 88 | 	  {
 89 | 		  	ArrayList<String> al = data1();
 90 | 			List<String> alAl = new ArrayList<String>();
 91 | 			/* This adds last array of ArrayList al to s */
 92 | //			String[] s=new String[al.get(0).length()];;
 93 | //			for(int i=0;i<al.size();i++)
 94 | //			{
 95 | //				s =al.get(i).split(","); 
 96 | //			}
 97 | //			for(String i:s)
 98 | //			{System.out.println(i);}
 99 | 			
100 | 			for(int i=0;i<al.size();i++)
101 | 			{	
102 | 				alAl.addAll(Arrays.asList((al.get(i)).split(",")));
103 | 			}
104 | 			System.out.println(alAl);
105 | 			
106 | 			List<String> alAll = new ArrayList<String>();
107 | 			for(int i=0;i<alAl.size();i++)
108 | 			{
109 | 				alAll.add(alAl.get(i).trim());
110 | 			}
111 | 			alAl=null;
112 | 			System.out.println(alAll);
113 | 		//	System.out.println(alAll.size());    //16
114 | 		//	System.out.println(alAll.get(15));                           // 0 to 15 elements
115 | 		int maxEngId=0;			//(int)Integer.parseInt(alAll.get(0));
116 | 		int maxTestId=0;
117 | 		int maxEngSal=0;
118 | 		int maxTestSal=0;
119 | 		String dept1=null;
120 | 		String dept2=null;
121 | 		
122 | 		//for(int j=0;j<alAll.size()/4;j+=4)
123 | 		//System.out.println(alAll.get(2));
124 | 		for(int i=0;i<alAll.size();i=i+4)              // 15 elements Hence size+1
125 | 		{
126 | 			//System.out.println(i);
127 | 			if(((alAll.get(i+2)).equals("Eng"))&&(Integer.parseInt(alAll.get(i))>maxEngId))
128 | 			{
129 | 				maxEngId=Integer.parseInt(alAll.get(i));
130 | 				dept1=alAll.get(i+2);
131 | 				maxEngSal=Integer.parseInt(alAll.get(i+3));
132 | 			}	
133 | 			
134 | 			if(((alAll.get(i+2)).equals("Test"))&&(Integer.parseInt(alAll.get(i))>maxTestId))
135 | 			{
136 | 				maxTestId=Integer.parseInt(alAll.get(i));
137 | 				dept2=alAll.get(i+2);
138 | 				maxTestSal=Integer.parseInt(alAll.get(i+3));
139 | 			}	
140 | 		}
141 | 		System.out.println("Dept"+"\t"+"Id"+"\t"+"Salary");
142 | 		System.out.println(dept1 + "\t" + maxEngId+"\t"+maxEngSal);
143 | 		System.out.println(dept2 + "\t" + maxTestId+"\t"+maxTestSal);
144 | 		//System.out.println(maxEngId);
145 | 		//System.out.println(maxTestId);
146 | 		
147 | //		int maxEngSal = (int)Integer.parseInt(alAll.get(3));
148 | //		int maxTestSal = (int)Integer.parseInt(alAll.get(3));
149 | //	  
150 | //		for(int i=2;i<alAll.size()/4;i+=4)
151 | //		{
152 | //			for(int j=3;j<alAll.size()/4;j+=4)
153 | //			{	
154 | //				if(alAll.get(i).equals("Eng"))
155 | //				maxId=((int)Integer.parseInt(alAll.get(i)));
156 | //			}
157 | //		}
158 | 	  
159 | 	  }
160 | 	  
161 | }
162 | 


--------------------------------------------------------------------------------
/abstrInterference/Defaultmethod.java:
--------------------------------------------------------------------------------
 1 | package abstrInterference;
 2 | 
 3 | interface Addition
 4 | {
 5 | 	default void add()
 6 | 	{
 7 | 		System.out.println("Interface addition method.");
 8 | 	}
 9 | 
10 | }
11 | 
12 | public class Defaultmethod implements Addition
13 | {
14 | 	
15 | 
16 | 	public void Dm1()
17 | 	{
18 | //		Addition ad1 = new Addition(){};
19 | //		ad1.add();
20 | 		Addition.super.add();
21 | 		add();
22 | 		Defaultmethod dmo1 = new Defaultmethod();
23 | 		dmo1.add();
24 | 		Addition dmo2 = new Defaultmethod();
25 | 		dmo2.add();		
26 | 	}
27 | //	public void add()
28 | //	{
29 | //		System.out.println("Class addition method.");
30 | //	}
31 | 		
32 | 	public static void main(String[] args)
33 | 	{
34 | 		// TODO Auto-generated method stub
35 | 		Addition ad1 = new Addition(){};
36 | 		ad1.add();
37 | 		
38 | 		
39 | 		
40 | 		Defaultmethod dmo = new Defaultmethod ();
41 | 		dmo.add();
42 | 		
43 | 
44 | 	}
45 | 
46 | }
47 | 
48 | class  Defaultmethod2
49 | {
50 | 
51 | 	public void dm2()
52 | 	{
53 | 		Addition ad1 = new Addition(){};
54 | 		ad1.add();
55 | 		
56 | 
57 | 	}
58 | }
59 | 


--------------------------------------------------------------------------------
/abstrInterference/Interf18.java:
--------------------------------------------------------------------------------
 1 | package abstrInterference;
 2 | 
 3 | interface x 
 4 | {
 5 | 	default void a1()
 6 | 	{
 7 | 		System.out.println("def-a1-x");
 8 | 	}
 9 | 	
10 | 	static void a2()
11 | 	{
12 | 		System.out.println("stat-a2");
13 | 	}
14 | 	public static void m1(){}
15 | }
16 | interface y 
17 | {
18 | 	default void a1()
19 | 	{
20 | 		System.out.println("def-a1-y");
21 | 	}
22 | 	
23 | 	static void a2()
24 | 	{
25 | 		System.out.println("stat-a2");
26 | 	}
27 | }
28 | 
29 | public class Interf18 implements x,y
30 | {
31 | 	
32 | 	public void a1()
33 | 	{
34 | 		a1();
35 | 		Interf18 i1 = new Interf18();
36 | 		i1.a1();
37 | 		x.super.a1();
38 | 		x.a2();
39 | 		x.super.a1();
40 | 		y.super.a1();
41 | 	}
42 | 	public void m1(){}
43 | 	public static void main(String[] args)
44 | 	{
45 | 		Interf18 i1 = new Interf18();
46 | 		i1.a1();
47 | 		x.a2();
48 | 		y.a2();
49 | 	
50 | 	}
51 | }
52 | 
53 | class Z implements x
54 | {
55 | 	public void a1()
56 | 	{
57 | 		
58 | 	}
59 | 	void a4()
60 | 	{
61 | 		x x1 = new x(){};
62 | 		
63 | 	}
64 | }
65 | class DF
66 | {
67 | 	void d()
68 | 	{
69 | 		x x1 = new x(){};
70 | 		x1.a1();
71 | 	}
72 | 	public static void main(String[] args)
73 | 	{
74 | 		// x o1 = new x();				// Cannot instantiate the type x
75 | 		DF d1 = new DF();
76 | 		x.a2();
77 | 		x x1 = new x(){};
78 | 		x1.a1();
79 | 	}
80 | }


--------------------------------------------------------------------------------
/abstrInterference/MultipleInheriStatic.java:
--------------------------------------------------------------------------------
 1 | package abstrInterference;
 2 | 
 3 | interface Left1
 4 | {
 5 | 	static void m1()
 6 | 	{
 7 | 		System.out.println("Left : m1()");
 8 | 	}
 9 | }
10 | 
11 | interface Right1
12 | {
13 | 	static void m1()
14 | 	{
15 | 		System.out.println("Right : m1()");
16 | 	}
17 | }
18 | 
19 | public class MultipleInheriStatic
20 | {
21 | 
22 | 	public static void m1(){}
23 | 	public void a1()
24 | 	{
25 | 		Left1.m1();
26 | 		Right1.m1();
27 | 		
28 | 	}
29 | 	
30 | 	public static void main(String[] args) 
31 | 	{
32 | 		// TODO Auto-generated method stub
33 | 
34 | 	}
35 | 
36 | }
37 | 


--------------------------------------------------------------------------------
/abstrInterference/MultipleInheritance.java:
--------------------------------------------------------------------------------
 1 | package abstrInterference;
 2 | 
 3 | interface Left
 4 | {
 5 | 	default void m1()
 6 | 	{
 7 | 		System.out.println("Left : m1()");
 8 | 	}
 9 | }
10 | 
11 | interface Right
12 | {
13 | 	default void m1()
14 | 	{
15 | 		System.out.println("Right : m1()");
16 | 	}
17 | }
18 | 
19 | public class MultipleInheritance implements Left,Right
20 | {
21 | 	public void m1()
22 | 	{
23 | 		System.out.println("MultipleInheritance : m1()");
24 | 	}
25 | 	
26 | 	public void m2()
27 | 	{
28 | 		m1();
29 | 		MultipleInheritance MI1 = new MultipleInheritance();
30 | 		Left l1 = new MultipleInheritance();
31 | 		Right r1 = new MultipleInheritance();
32 | 		Left l2 = new Left(){};
33 | 		Right r2 = new Right(){};
34 | 		MI1.m1();
35 | 		MI1.m2();
36 | 		l1.m1();
37 | 		// l1.m2();    // CE
38 | 		r1.m1();
39 | 		//r1.m2();       // CE
40 | 		l2.m1();
41 | 		r2.m1();
42 | 		Left.super.m1();
43 | 		Right.super.m1();
44 | 	
45 | 	
46 | 	}
47 | 
48 | 	public static void main(String[] args) 
49 | 	{
50 | 		// TODO Auto-generated method stub
51 | 		// m1();            // CE
52 | 		MultipleInheritance MI1 = new MultipleInheritance();
53 | 		Left l1 = new MultipleInheritance();
54 | 		Right r1 = new MultipleInheritance();
55 | 		Left l2 = new Left(){};
56 | 		Right r2 = new Right(){};
57 | 		MI1.m1();
58 | 		MI1.m2();
59 | 		l1.m1();
60 | 		// l1.m2();    // CE
61 | 		r1.m1();
62 | 		//r1.m2();       // CE
63 | 		l2.m1();
64 | 		r2.m1();
65 | 
66 | 	}
67 | 
68 | }
69 | 


--------------------------------------------------------------------------------
/abstrInterference/StaticMethod.java:
--------------------------------------------------------------------------------
 1 | package abstrInterference;
 2 | 
 3 | 
 4 | interface Addition1
 5 | {
 6 | 	static void add1()
 7 | 	{
 8 | 		System.out.println("Interface addition method.");
 9 | 	}
10 | 	public default void m2()
11 | 	{
12 | 		
13 | 	}
14 | 
15 | }
16 | 
17 | public class StaticMethod implements Addition1
18 | {
19 | 
20 | 	public void Sm1()
21 | 	{
22 | 		//add1();		// CE
23 | 	Addition1.add1();
24 | 	StaticMethod st = new StaticMethod();
25 | 	//st.add1();   // CE
26 | 	Addition1 ad1 = new StaticMethod();
27 | 	//ad1.add1();   //CE
28 | 	//Addition1.super.add1();       // CE 
29 | 	Addition1 ad2 = new Addition1(){};
30 | 	// ad2.add1();    //CE
31 | 	}
32 | 
33 | 	public void add1()
34 | 	{
35 | 		System.out.println("Class addition method.");
36 | 	}
37 | 		
38 | 	public static void main(String[] args)
39 | 	{
40 | 		// TODO Auto-generated method stub
41 | 	//add1();		// CE
42 | 	Addition1.add1();
43 | 	StaticMethod st = new StaticMethod();
44 | 	//st.add1();   // CE
45 | 	Addition1 ad1 = new StaticMethod();
46 | 	//ad1.add1();   //CE
47 | 	//Addition1.super.add1();       // CE 
48 | 	Addition1 ad2 = new Addition1(){};
49 | 	//ad2.add1();    // CE
50 | 	}
51 | 
52 | }
53 |  class B
54 |  {
55 | 	 public void m()
56 | 	 {
57 | 	 Addition1 ad2 = new Addition1(){};
58 | 	 ad2.m2();
59 | 	 // ad2.add1();   // CE
60 | 	 Addition1.add1();
61 | 	 
62 | 	 }
63 | 	 
64 | 	 public static void main(String[] args)
65 | 		{
66 | 		 Addition1 ad2 = new Addition1(){};
67 | 		 ad2.m2();
68 | 		 Addition1.add1();
69 | 		}
70 | }
71 | 	 
72 | 


--------------------------------------------------------------------------------
/arrayMethods/ArrayPrintingDemo.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | public class ArrayPrintingDemo 
 4 | {
 5 | 
 6 | 	public static void main(String[] args) 
 7 | 	{
 8 | 	
 9 | 	}
10 | 	
11 | 	public static void regPrint(int[] data)
12 | 	{
13 | 		for(int i=0;i<data.length;i++)
14 | 		{
15 | 			System.out.println(data[i]);
16 | 		}
17 | 	}
18 | 	
19 | 	public static void enhancedPrint(int[] data)
20 | 	{
21 | 		for(int i : data)
22 | 		{
23 | 			System.out.println(i);
24 | 		}
25 | 	}
26 | }
27 | 


--------------------------------------------------------------------------------
/arrayMethods/ArraySortDEmo.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | import java.util.Arrays;
 4 | 
 5 | public class ArraySortDEmo
 6 | {
 7 | 
 8 | 	public static void main(String[] args)
 9 | 	{
10 | 		int [] arr = {21,54,1,65,15,8,9,78,13,0};
11 | 		int [] arr2 = {21,54,1,65,15,8,9,78,13,0};
12 | 		System.out.println(arr.length);
13 | 		Arrays.sort(arr);
14 | 		System.out.println("Sorted array is :" + Arrays.toString(arr));
15 | 		Arrays.sort(arr2,1,5);
16 | 		System.out.println("Sorted array from index 1 to 6 ie. 54 to 8 is : " + Arrays.toString(arr2));
17 | 	}
18 | 
19 | }
20 | 


--------------------------------------------------------------------------------
/arrayMethods/ArrayofStrings.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.Arrays;
 5 | 
 6 | public class ArrayofStrings
 7 | {
 8 | 
 9 | 	public static void main(String[] args)
10 | 	{
11 | 		String[] data = {"Ram,1,Pune,Eng,1000","Sita,2,Mumbai,Test,2000","Geeta,3,Latur,Eng,3000","Shyam,4,Goa,Test,4000",
12 | 				"Babita,5,Jammu,Eng,5000"};
13 | 		//System.out.println(data.length);
14 | 		solution(data);
15 | 	}
16 | 	
17 | 	public static void solution(String[] data)
18 | 	{
19 | 		String[] name=new String[data.length];
20 | 		int[] id=new int[data.length];
21 | 		String[] dept=new String[data.length];
22 | 		String[] city=new String[data.length];
23 | 		int[] sal=new int[data.length];
24 | 		for(int i=0;i<data.length;i++)
25 | 		{
26 | 		name[i] = (data[i].split(","))[0];
27 | 		id[i] = Integer.parseInt((data[i].split(","))[1]);
28 | 		city[i] = (data[i].split(","))[2];
29 | 		dept[i] = (data[i].split(","))[3];
30 | 		sal[i] = Integer.parseInt((data[i].split(","))[4]);
31 | 		}
32 | 		System.out.println("Name"+"\t"+"Id"+"\t"+"City"+"\t"+"Dept"+"\t"+"Sal");
33 | 		for(int i=0;i<data.length;i++)
34 | 		{
35 | 		System.out.println(name[i]+"\t"+id[i]+"\t"+city[i]+"\t"+dept[i]+"\t"+sal[i]);	
36 | 		}
37 | 		ArrayList alName = new ArrayList<String>(Arrays.asList(name));
38 | //		for(String s:name)
39 | //		{
40 | //			System.out.println(s);
41 | //		}
42 | //		for(int s:id)
43 | //		{
44 | //			System.out.println(s);
45 | //		}
46 | //		for(String s:city)
47 | //		{
48 | //			System.out.println(s);
49 | //		}
50 | //		for(String s:dept)
51 | //		{
52 | //			System.out.println(s);
53 | //		}
54 | //		for(int s:sal)
55 | //		{
56 | //			System.out.println(s);
57 | //		}
58 | 	}
59 | }


--------------------------------------------------------------------------------
/arrayMethods/ArraysDottoString.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | import java.util.Arrays;
 4 | 
 5 | public class ArraysDottoString {
 6 | 
 7 | 	public static void main(String[] args)
 8 | 	{
 9 | 		// TODO Auto-generated method stub
10 | 		int[] a = {1,2,3};
11 | 		String s2 = Arrays.toString(a);
12 | 		System.out.println(s2);
13 | 		System.out.println(s2.length());
14 | 		char[] b = {'a','b','c'};
15 | 		String s3= Arrays.toString(b);
16 | 		System.out.println(s3);
17 | 
18 | 	}
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/arrayMethods/BinarySearch.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | import java.util.Arrays;
 4 | 
 5 | public class BinarySearch
 6 | {
 7 | 	public static void main(String[] args) 
 8 | 	{
 9 | 		int[] array = {1,2,3,4,6,7};
10 | 		int key = 7;
11 | 		byte[] array1 = {10,20,30,40,60,70};
12 | 		byte key1 = 45;
13 | 		System.out.println(Arrays.binarySearch(array,key));
14 | 		System.out.println(Arrays.binarySearch(array1,key1));
15 | 	}
16 | }
17 | 


--------------------------------------------------------------------------------
/arrayMethods/BinaryString.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | public class BinaryString 
 4 | {
 5 | 
 6 | 	public static void main(String[] args) 
 7 | 	{
 8 | 		int l = 32;
 9 | 		System.out.println(Integer.toBinaryString(l));
10 | 		
11 | 		int m = 15;
12 | 		System.out.println(Integer.toBinaryString(m));
13 | 
14 | 	}
15 | 
16 | }
17 | 


--------------------------------------------------------------------------------
/arrayMethods/ComparatorForArray.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | import java.util.*; 
 4 | import java.lang.*; 
 5 | import java.io.*; 
 6 |   
 7 | // A class to represent a student. 
 8 | class Student 
 9 | { 
10 |     int rollno; 
11 |     String name, address; 
12 |   
13 |     // Constructor 
14 |     public Student(int rollno, String name, 
15 |                    String address) 
16 |     { 
17 |         this.rollno = rollno; 
18 |         this.name = name; 
19 |         this.address = address; 
20 |     } 
21 |   
22 |     // Used to print student details in main() 
23 |     public String toString() 
24 |     { 
25 |         return this.rollno + " "
26 |             + this.name + " "
27 |             + this.address; 
28 |     } 
29 | } 
30 |   
31 | class Sortbyroll implements Comparator<Student> 
32 | { 
33 |   
34 |     // Used for sorting in ascending order of 
35 |     // roll number 
36 |     public int compare(Student a, Student b) 
37 |     { 
38 |         return a.rollno - b.rollno; 
39 |     } 
40 | } 
41 |   
42 | // Driver class 
43 | class ComparatorForArray 
44 | { 
45 |     public static void main(String[] args) 
46 |     { 
47 |         Student[] arr = { new Student(111, "bbbb", "london"), 
48 |                           new Student(131, "aaaa", "nyc"), 
49 |                           new Student(121, "cccc", "jaipur") }; 
50 |   
51 |         System.out.println("Unsorted"); 
52 |         for (int i = 0; i < arr.length; i++) 
53 |             System.out.println(arr[i]); 
54 |   
55 |         Arrays.sort(arr, new Sortbyroll()); 
56 |   
57 |         System.out.println("\nSorted by rollno"); 
58 |         for (int i = 0; i < arr.length; i++) 
59 |             System.out.println(arr[i]); 
60 |     } 
61 | } 
62 | 


--------------------------------------------------------------------------------
/arrayMethods/CompareArrays.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | import java.util.Arrays; 
 4 | 
 5 | public class CompareArrays { 
 6 |     public static void main(String[] args) 
 7 |     { 
 8 |   
 9 |         // Get the Array 
10 |         int intArr[] = { 10, 20, 15, 22, 35 }; 
11 |   
12 |         // Get the second Array 
13 |         int intArr1[] = { 10, 15, 22 }; 
14 |   
15 |         // To compare both arrays 
16 |         //System.out.println("Integer Arrays on comparison: "
17 |        //                    + Arrays.compareUnsigned(intArr, intArr1)); 
18 |     } 
19 | } 
20 | 


--------------------------------------------------------------------------------
/arrayMethods/ContainsInArray.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | import java.util.Arrays;
 4 | 
 5 | public class ContainsInArray 
 6 | {
 7 | 	public static void main(String[] args) 
 8 | 	{
 9 | 		Integer[] array = {1,2,3,4,6,7};
10 | 		int key = 7;
11 | 		String[] array2= {"ab","cd","ef"};
12 | 		String key2 = "ab";
13 | 		System.out.println(Arrays.asList(array).contains(key));
14 | 		System.out.println(Arrays.asList(array2).contains(key2));
15 | 	}
16 | }


--------------------------------------------------------------------------------
/arrayMethods/CopyOfArray.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | import java.util.Arrays;
 4 | 
 5 | public class CopyOfArray
 6 | {
 7 | 	public static void main(String[] args) 
 8 | 	{
 9 | 		int[] array1 = {1,2,3,4,5};
10 | 		System.out.println(Arrays.copyOf(array1,10));
11 | 		System.out.println(Arrays.toString(Arrays.copyOf(array1, 10)));
12 | 		System.out.println(Arrays.toString(Arrays.copyOf(array1, 3)));
13 | 		int[] x = Arrays.copyOf(array1, 5);
14 | 		System.out.println(Arrays.toString(x));
15 | 	}
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/arrayMethods/LinearSearch.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | public class LinearSearch 
 4 | {
 5 | 
 6 | 	public static void main(String[] args) 
 7 | 	{
 8 | 		int[] array = {1,2,3,4,6,7};
 9 | 		int key = 7;
10 | 		int key1 = 14;
11 | 		System.out.println(solution(array, key));
12 | 		System.out.println(solution(array, key1));
13 | 	}
14 | 	
15 | 	public static String solution(int[] array, int key)
16 | 	{
17 | 		for(int i : array)
18 | 		{
19 | 			if(i==key)
20 | 			return ("Key found at : "+i);	
21 | 		}
22 | 		return ("Key not found.");
23 | 	}
24 | 
25 | }
26 | 


--------------------------------------------------------------------------------
/arrayMethods/PairSearch.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.Arrays;
 5 | import java.util.HashSet;
 6 | import java.util.Iterator;
 7 | import java.util.List;
 8 | import java.util.Set;
 9 | import java.util.stream.Collectors;
10 | 
11 | public class PairSearch {
12 | 	
13 | 	public int x;
14 | 	public int y;
15 | 		 
16 | 	     @Override
17 | 	     public String toString() {
18 | 	     return "[x = " + x + ", y=" + y + "]";
19 | 	     }
20 | 
21 | 
22 | 	public static void main(String[] args) {
23 | 		// TODO Auto-generated method stub
24 | 
25 | 		int[] a = {4, 9, 0, 34, 7, 22, 3, 10, 1, 5, 12, 55, 89, 32, 53, 62};
26 | 	    int target = 111;
27 | //	    Integer[] a1 = 
28 | 	    
29 | 	    PairSearch result = new PairSearch();
30 | 	    Set<Integer> set = new HashSet<>();
31 | 	    List al = new ArrayList(Arrays.asList(a));
32 | 	    Set s1 = new HashSet(Arrays.asList(a));
33 | 	    for(int i=0;i<a.length;i++)
34 | 	    {
35 | 	    	set.add(Integer.valueOf(a[i]));
36 | 	    }
37 | 	    System.out.println(set);
38 | 	    System.out.println(s1);
39 | 	    System.out.println(al);
40 | 	    Iterator ir = s1.iterator();
41 | 	    while(ir.hasNext())
42 | 	    {
43 | 	    	System.out.println(ir.next());
44 | 	    }
45 | 	    
46 | 	    for(int i=0;i<set.size();i++)
47 | 	    {	
48 | //	    if(set.contains(target-a[i]))
49 | //	    	{
50 | //	    		result.x = target-a[i];
51 | //	    		result.y = a[i];
52 | //	    		break;
53 | //	    	}
54 | //	    }
55 | 	    if(s1.contains(target-a[i]))
56 |     	{
57 |     		result.x = target-a[i];
58 |     		result.y = a[i];
59 |     		break;
60 |     	}
61 |     }
62 | //	    List<Integer> list = Arrays.stream(a).boxed().collect(Collectors.toList());
63 | System.out.println(result);	
64 | 	}
65 | }
66 | 


--------------------------------------------------------------------------------
/arrayMethods/StringToArray.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | 
 4 | public class StringToArray 
 5 | {
 6 | 
 7 | 	public static void main(String[] args)
 8 | 	{
 9 | 		String str = "Hello World";
10 | 		solution(str);
11 | 		System.out.println();
12 | 		solution(str);
13 | 	}
14 | 	
15 | 	public static void solution(String data)
16 | 	{
17 | 		char[] resArray = new char[data.length()];
18 | 		for(int i=0;i<data.length();i++)
19 | 		{
20 | 			resArray[i]=data.charAt(i);
21 | 		}
22 | 		//System.out.println(resArray);
23 | 		for(char c:resArray)
24 | 		{
25 | 			System.out.print(c);
26 | 		}
27 | 	}
28 | 	
29 | 	public static void solution2(String data)
30 | 	{
31 | 		char[] resArray = new char[data.length()];
32 | 		resArray = data.toCharArray();
33 | 		for(char c:resArray)
34 | 		{
35 | 			System.out.print(c);
36 | 		}
37 | 	}
38 | }


--------------------------------------------------------------------------------
/arrayMethods/commaSeparatedStringToArray.java:
--------------------------------------------------------------------------------
 1 | package arrayMethods;
 2 | 
 3 | import java.util.Arrays;
 4 | import java.util.StringTokenizer;
 5 | 
 6 | public class commaSeparatedStringToArray
 7 | {
 8 | 	public static void main(String[] args)
 9 | 	{
10 | 		String csv = "Ram,Sita,Shyam,Geeta";
11 | 		String[] strArray = csv.split(",");
12 | 		System.out.println(csv);
13 | 		System.out.println(Arrays.toString(strArray));
14 | 		System.out.println(strArray[3]);
15 | 		String s1=" ram";
16 | //		System.out.println(s1.trim());
17 | 		
18 | 		StringTokenizer st = new StringTokenizer(csv,",");
19 | 		while(st.hasMoreElements())
20 | 		{
21 | 			System.out.println(st.nextToken());
22 | 		}
23 | 
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/assertion/AssertDemo.java:
--------------------------------------------------------------------------------
 1 | package assertion;
 2 | 
 3 | public class AssertDemo {
 4 | 
 5 | 	public static void main(String[] args) {
 6 | 		// TODO Auto-generated method stub
 7 | 		Test t1 = new Test();
 8 | 		int x = 10;
 9 | 		assert(x>20);
10 | 		System.out.println(x);
11 | 		assert(t1.add(10,20)==40);
12 | 		System.out.println(t1.add(10,20));
13 | 		
14 | 	}
15 | }
16 | 
17 | class Test{
18 | 	public int add(int a, int b){
19 | 		return a+b;
20 | 	}
21 | }
22 | 


--------------------------------------------------------------------------------
/bruteForceAlgorithm/FindPair.java:
--------------------------------------------------------------------------------
 1 | package bruteForceAlgorithm;
 2 | 
 3 | import java.util.HashSet;
 4 | import java.util.Set;
 5 | 
 6 | public class FindPair 
 7 | {
 8 | 	private static class Pair {
 9 |         public int x;
10 |         public int y;
11 |  
12 |         @Override
13 |         public String toString() {
14 |             return "[x = " + x + ", y=" + y + "]";
15 |         }
16 |     }
17 | 	public static void main(String[] args) {
18 | 		 
19 | 	    int[] a = {4, 9, 0, 34, 7, 22, 3, 10, 1, 5, 12, 55, 89, 32, 53, 62};
20 | 	    int target = 111;
21 | 	    Pair result = new Pair();
22 | 	    Set<Integer> set = new HashSet<Integer>();
23 | 	 
24 | 	    for (int i = 0; i < a.length; i++) {
25 | 	 
26 | 	        if (set.contains(target - a[i])) {
27 | 	            result.x = target - a[i];
28 | 	            result.y = a[i];
29 | 	            break;
30 | 	        }
31 | 	        set.add(a[i]);
32 | 	 
33 | 	    }
34 | 	 
35 | 	    System.out.println("pair = [" + result + "]");
36 | 	}
37 | 
38 | }
39 | 


--------------------------------------------------------------------------------
/classProperties/ClassFields.java:
--------------------------------------------------------------------------------
 1 | package classProperties;
 2 | 
 3 | import java.lang.reflect.Field;
 4 | class Test
 5 | {
 6 | 	int age =0;
 7 | 	String name = "Ram"; 
 8 | //	int age;
 9 | //	String name;
10 | }
11 | 
12 | public class ClassFields extends Test
13 | {
14 | 	public static void main(String[] args) throws ClassNotFoundException , NoSuchFieldException
15 | 	{
16 | 		//Test t = new Test();
17 | 		System.out.println("Hello");
18 | 	    Class cls = Class.forName("Test");
19 | 	    Field field1 = cls.getField("age");
20 | 	    System.out.println(field1);
21 | 	    Field[] field = cls.getFields();
22 | 	    for(Field f:field)
23 | 	    {
24 | 	    	System.out.println("Hi");
25 | 	    	System.out.println(f);
26 | 	    }
27 | 	}
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/codility/BinaryGap.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.List;
 5 | import java.util.Scanner;
 6 | 
 7 | public class BinaryGap 
 8 | {
 9 | public static void main(String [] args)
10 | {
11 | 		Scanner sc = new Scanner(System.in);
12 | 		System.out.println("Enter the number :");
13 | 		int n = sc.nextInt();
14 | 		int longestBinaryGap = solution(n);
15 | 		System.out.println("Longest binary gap is : "+longestBinaryGap);
16 | }
17 | 
18 |   public static int solution(int N) 
19 | {
20 |     String binaryString = Integer.toBinaryString(N);
21 |    
22 |     int longestBinaryGap = 0;
23 |     List<Integer> onesList = new ArrayList<Integer>();
24 |    
25 |     for(int i=0; i<binaryString.length(); i++) 
26 |     {
27 |       if(binaryString.charAt(i) == '0') 
28 |     	  continue;
29 |       onesList.add(i);    
30 |     }
31 | 
32 |     for(int i=0; i<onesList.size() - 1; i++) 
33 |     {
34 |       //subtract 1 so that don't count 1's next to each other as having any gap
35 |       int indicesDiff = onesList.get(i+1) - onesList.get(i) - 1;
36 |      
37 |       longestBinaryGap = Math.max(longestBinaryGap, indicesDiff);
38 |     }
39 |     return longestBinaryGap;
40 |   }
41 | }


--------------------------------------------------------------------------------
/codility/CyclicRotation.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class CyclicRotation 
 6 | {
 7 | 
 8 | 	public static void main(String[] args) 
 9 | 	{
10 | 		Scanner sc = new Scanner((System.in));
11 | 		System.out.println("Enter the array size");
12 | 		int n = sc.nextInt();
13 | 		System.out.println("Enter the array : ");
14 | 		int data[] = new int[n];
15 | 		for (int i=0;i<n;i++)
16 | 		{
17 | 		data[i] = sc.nextInt();
18 | 		}
19 | 		System.out.println("Enter the rotation : ");
20 | 		int k = sc.nextInt();
21 | 		int[] finalArray = solution(data,k);
22 | 		for(int i:finalArray)
23 | 		{
24 | 			System.out.println(i);
25 | 		}
26 | 		sc.close();
27 | 	
28 | 	}
29 | 	  public static int[] solution(int[] A, int K) 
30 | 	  {
31 | 	    int [] rotatedA = new int[A.length];
32 | 	   
33 | 	    for(int i=0; i<A.length; i++)
34 | 	    {
35 | 	      //rotated index needs to "wrap" around end of array
36 | 	      int rotatedIndex = (i + K) % A.length;
37 | 
38 | 	      rotatedA[rotatedIndex] = A[i];
39 | 	    }
40 | 	    return rotatedA;
41 | 	  }
42 | }


--------------------------------------------------------------------------------
/codility/CyclicRotation1.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class CyclicRotation1 
 6 | {
 7 | 	
 8 | 	public static void main(String[] args) 
 9 | 	{
10 | 		// TODO Auto-generated method stub
11 | 		Scanner sc = new Scanner((System.in));
12 | 		System.out.println("Enter the array size");
13 | 		int n = sc.nextInt();
14 | 		System.out.println("Enter the array : ");
15 | 		int data[] = new int[n];
16 | 		for (int i=0;i<n;i++)
17 | 		{
18 | 		data[i] = sc.nextInt();
19 | 		}
20 | 		int[] finalArray = cyclicRotation(data);
21 | 		for(int i:finalArray)
22 | 		{
23 | 			System.out.println(i);
24 | 		}
25 | 
26 | 	}
27 | 	
28 | 	public static int[] cyclicRotation(int[] data)
29 | 	{
30 | 		Scanner sc = new Scanner((System.in));
31 | 		System.out.println("Enter the rotation : ");
32 | 		int k = sc.nextInt();
33 | 		for(int j=0; j<=k;j++)
34 | 		{
35 | 			for(int i=0;i<data.length;i++)
36 | 			{
37 | 				if(i == data.length-1)
38 | 				{
39 | 					data[data.length-1]=data[0];
40 | 				}
41 | 				else
42 | 				{
43 | 					int x= data[i+1];
44 | 					data[i+1]=data[i];
45 | 				}
46 | 			}
47 | 		}
48 | 		return data;
49 | 	}
50 | }


--------------------------------------------------------------------------------
/codility/FrogJmp.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class FrogJmp 
 6 | {
 7 | 	public static void main(String[] args) 
 8 | 	{
 9 | 	long startTime=System.nanoTime();
10 | 	Scanner sc = new Scanner((System.in));
11 | 	System.out.println("Enter the current position : ");
12 | 	int X = sc.nextInt();
13 | 	System.out.println("Enter the position to reach : ");
14 | 	int Y = sc.nextInt();
15 | 	System.out.println("Enter the distance frog can travel in one jump  : ");
16 | 	int D = sc.nextInt();
17 | 	int jumpsRequired = new FrogJmp().solution(X, Y, D);
18 | 	System.out.println(jumpsRequired);
19 | 	} 
20 | 	
21 | 	public static int solution(int X, int Y, int D) 
22 | 	  {
23 | 	    int distanceToJump = Y - X;
24 | 	    int jumpsRequired = distanceToJump / D;
25 | 	    if(distanceToJump % D != 0) 
26 | 	    {
27 | 	      jumpsRequired++; //only add extra jump if remainder exists
28 | 	    }
29 | 	    return jumpsRequired;
30 | 	  }
31 | }


--------------------------------------------------------------------------------
/codility/FrogJmp2.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | //My Solution
 4 | public class FrogJmp2 
 5 | {
 6 | 	public static void main(String[] args) 
 7 | 	{
 8 | 		int X = 3;
 9 | 		int Y = 999111321;
10 | 		int D = 7;
11 | 		System.out.println(solution(X,Y,D));
12 | 		
13 | 	}
14 | 
15 | 	public static int solution(int X, int Y, int D) 
16 | 	{
17 | 		int K=D;
18 | 		while(true)
19 | 		{
20 | 			D=D+K;
21 | 			if(X==Y)
22 | 				return 0;
23 | 			if(X+D>=Y)
24 | 				return D/K;
25 | 		}
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/codility/FrogRiverOne.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.HashSet;
 4 | import java.util.Scanner;
 5 | 
 6 | public class FrogRiverOne 
 7 | {
 8 | 	public static void main(String[] args) 
 9 | 	{
10 | 		Scanner sc = new Scanner((System.in));
11 | 		System.out.println("Enter frog distance : ");
12 | 		int X = sc.nextInt();
13 | 		System.out.println("Enter the array size");
14 | 		int n = sc.nextInt();
15 | 		System.out.println("Enter the array : ");
16 | 		int A[] = new int[n];
17 | 		for (int i=0;i<n;i++)
18 | 		{
19 | 		A[i] = sc.nextInt();
20 | 		}
21 | 		System.out.println(new FrogRiverOne().solution(X, A));
22 | 		
23 | 	}
24 | 	
25 | 	public int solution(int X, int[] A) 
26 | 	{
27 |         HashSet set = new HashSet();
28 |         for(int i=0; i < A.length; i++)
29 |         {
30 |             if(A[i] <= X) set.add(A[i]);
31 |             if(set.size() == X) return i;
32 |         }
33 |         return -1;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/codility/MissingInteger.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.Set;
 4 | import java.util.TreeSet;
 5 | import java.util.Scanner;
 6 | 
 7 | public class MissingInteger 
 8 | {
 9 |   public static void main(String[] args)
10 |   {
11 | 	  Scanner sc = new Scanner((System.in));
12 | 		System.out.println("Enter the array size");
13 | 		int n = sc.nextInt();
14 | 		System.out.println("Enter the array : ");
15 | 		int A[] = new int[n];
16 | 		for (int i=0;i<n;i++)
17 | 		{
18 | 		A[i] = sc.nextInt();
19 | 		}
20 | 		System.out.println(new MissingInteger().solution(A));
21 |   }
22 | 
23 |   public int solution(int[] A) 
24 |   {
25 |     Set<Integer> testedSet = new TreeSet<Integer>();
26 |     Set<Integer> perfectSet = new TreeSet<Integer>();
27 |    
28 |     for(int i=0; i<A.length; i++) 
29 |     {
30 |       testedSet.add(A[i]);   //convert array to set to get rid of duplicates, order int's
31 |       perfectSet.add(i+1);  //create perfect set so can find missing int
32 |     }
33 |    
34 |     for(int current : perfectSet) 
35 |     {
36 |       if(!testedSet.contains(current))
37 |       {
38 |         return current;
39 |       }
40 |     }
41 | 
42 |     if(perfectSet.size() == testedSet.size()) 
43 |     {
44 |       return perfectSet.size() + 1;  //e.g. {1, 2, 3} should return 4
45 |     }
46 |    
47 |     return 1; //default - e.g. if A array has negative values or just a single positive value like 10
48 |   }
49 | }


--------------------------------------------------------------------------------
/codility/MissingInteger1.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.Arrays;
 4 | import java.util.Scanner;
 5 | 
 6 | class MissingInteger1 
 7 | {
 8 | 	public static void main(String[] args)
 9 | 	{
10 | //		Scanner sc = new Scanner(System.in);
11 | //	    System.out.println("Please enter length of String array");
12 | //	    int length = sc.nextInt();
13 | //
14 | //	    // create a String array to save user input
15 | //	    String[] input = new String[length];
16 | //
17 | //	    // loop over array to save user input
18 | //	    System.out.println("Please enter array elements");
19 | //	    for (int i = 0; i < length; i++) 
20 | //	    {
21 | //	      String userInput = sc.next();
22 | //	      input[i] = userInput;
23 | //	    }
24 | 	    
25 | 	    int[] A = {1,1,2};
26 | 		
27 | 		MissingInteger1 mi = new MissingInteger1();
28 | 		System.out.println(mi.solution(A));
29 | 	}
30 | 	
31 |     public int solution(int[] A) 
32 |     {
33 |         Arrays.sort(A);
34 |         int res = 1;
35 |         if(A.length == 1 && A[0] != 1) return 1;
36 |         if(A.length == 1 && A[0] == 1) return 2;
37 |         if(A.length > 1 && A[0] > 1) return 1;
38 |         
39 |         for(int i=0; i < A.length; i++)
40 |         {
41 |             if(A[i] > 0 && A[i] < 100001)
42 |             {
43 |                 if(i < A.length-1 && A[i+1]-A[i] == 0)
44 |                 {
45 |                     res = A[i] + 1;
46 |                 } else if(i < A.length-1 && A[i+1]-A[i] == 1)
47 |                 {
48 |                     res = A[i+1] + 1;
49 |                 } else if(i < A.length-1 && A[i+1]-A[i] > 1)
50 |                 {
51 |                     return A[i] + 1;
52 |                 }
53 |             }
54 |         }
55 |         return res;
56 |     }
57 | }


--------------------------------------------------------------------------------
/codility/OddOccurrencesInArray.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class OddOccurrencesInArray 
 6 | {
 7 | 	//int num;
 8 | 
 9 | 	public static void main(String[] args) 
10 | 	{
11 | 		
12 | 		Scanner sc = new Scanner((System.in));
13 | 		System.out.println("Enter the array size");
14 | 		int n;
15 | 		/* Since we need only odd number of elements in array, if user enters an even number of elements,
16 | 		we will ask to re-enter again.*/
17 | 		while(true)
18 | 		{
19 | 			n = sc.nextInt();
20 | 			if(n%2!=0)
21 | 				break;
22 | 			else
23 | 				System.out.println("Please enter an odd size");
24 | 				continue;
25 | 		}
26 | 		System.out.println("Enter the array elements : ");
27 | 		int A[] = new int[n];
28 | 		for (int i=0;i<n;i++)
29 | 		{
30 | 			A[i] = sc.nextInt();
31 | 		}
32 | 		
33 | 		System.out.println(new OddOccurrencesInArray().solution(A));	
34 | 	}
35 | 	
36 | 	// This method has the main logic and returns the required number
37 | 	public int solution(int[] A)
38 | 	{
39 | 		int num=0;
40 | 		for(int i=0;i<A.length;i++)
41 | 		{
42 | 			for(int j=0;j<A.length;j++)
43 | 			{
44 | 				if(A[i]==A[j])
45 | 				{
46 | 					num++;
47 | 				}
48 | 			}
49 | 			if(num%2!=0)
50 | 			{
51 | 				num = A[i];
52 | 				return num;
53 | 				//break;
54 | 			}
55 | 		}
56 | 		throw new RuntimeException("It may be an input which does not contain any unpaired value.");
57 | 	}
58 | }


--------------------------------------------------------------------------------
/codility/OddOccurrencesInArray1.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.Collection;
 4 | import java.util.HashMap;
 5 | import java.util.Scanner;
 6 | import java.util.Set;
 7 | 
 8 | public class OddOccurrencesInArray1 
 9 | {
10 | 	public static void main(String[] args)
11 | 	{
12 | 		
13 | 
14 | 		Scanner sc = new Scanner((System.in));
15 | 		System.out.println("Enter the array size");
16 | 		int n;
17 | 		/* Since we need only odd number of elements in array, if user enters an even number of elements,
18 | 		we will ask to re-enter again.*/
19 | 		while(true)
20 | 		{
21 | 			n = sc.nextInt();
22 | 			if(n%2!=0)
23 | 				break;
24 | 			else
25 | 				System.out.println("Please enter an odd size");
26 | 				continue;
27 | 		}
28 | 		System.out.println("Enter the array elements : ");
29 | 		int A[] = new int[n];
30 | 		for (int i=0;i<n;i++)
31 | 		{
32 | 			A[i] = sc.nextInt();
33 | 		}
34 | 		
35 | 		System.out.println(new OddOccurrencesInArray().solution(A));	
36 | 
37 | 		
38 | 	}
39 | 	public static int solution(int[] A) {
40 | 	    HashMap <Integer, Integer> occurrencesMap = new HashMap<Integer, Integer>();
41 | 	   
42 | 	    for(int i=0; i<A.length; i++) {
43 | 	      if(occurrencesMap.containsKey(A[i])) {
44 | 	        int occurrences = occurrencesMap.get(A[i]);
45 | 	        occurrences++;
46 | 	        occurrencesMap.put(A[i], occurrences); //increment occurrence counter and store it
47 | 	      }
48 | 	      else {
49 | 	        occurrencesMap.put(A[i], 1); //1st occurrences of this value
50 | 	      }
51 | 	    }
52 | 	    
53 | 	    //System.out.println(occurrencesMap);
54 | 	    Set<Integer> keySet = occurrencesMap.keySet();
55 | 	    //System.out.println(keySet);
56 | 	    
57 | 	      for(int currentKey : keySet)
58 | 	      {
59 | 	      int occurrences = occurrencesMap.get(currentKey);
60 | 	    //System.out.println(occurrencesMap.get(currentKey));
61 | 	     
62 | 	    //if occurs odd number of times, we found the unpaired value - no need to continue checking
63 | 	      if(occurrences % 2 != 0) 
64 | 	    	return  currentKey;
65 | 	      }
66 | 	      
67 | 	    //should never get to here
68 | 	    throw new RuntimeException("It may be an input which does not contain any unpaired value.");
69 | 	  }
70 | }


--------------------------------------------------------------------------------
/codility/PermutationCheck.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.HashSet;
 4 | import java.util.Scanner;
 5 | import java.util.Set;
 6 | 
 7 | public class PermutationCheck
 8 | {
 9 | 
10 | 	public static void main(String[] args)
11 | 	{
12 | 		Scanner sc = new Scanner((System.in));
13 | 		System.out.println("Enter the array size");
14 | 		int n = sc.nextInt();
15 | 		System.out.println("Enter the array : ");
16 | 		int A[] = new int[n];
17 | 		for (int i=0;i<n;i++)
18 | 		{
19 | 		A[i] = sc.nextInt();
20 | 		}
21 | 		System.out.println(new PermutationCheck().solution(A));
22 | 	}
23 | 	public int solution(int[] A)
24 | 	{
25 | 	    Set<Integer> testedSet = new HashSet<Integer>();
26 | 	    Set<Integer> perfectSet = new HashSet<Integer>();
27 | 	   
28 | 	    for(int i=0; i<A.length; i++)
29 | 	    {
30 | 	      testedSet.add(A[i]);
31 | 	      perfectSet.add(i+1); // create set with values start from 1 to A.length
32 | 	    }
33 | 	   
34 | 	    for(int current : perfectSet) 
35 | 	    {
36 | 	      //as soon as find 1 element missing return false
37 | 	      if(!testedSet.contains(current)) 
38 | 	    	  return 0;
39 | 	    }
40 | 	    return 1;
41 | 	}
42 | }


--------------------------------------------------------------------------------
/codility/PermutationMissingElement.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.Arrays;
 4 | import java.util.Collections;
 5 | import java.util.HashSet;
 6 | import java.util.Scanner;
 7 | import java.util.Set;
 8 | 
 9 | public class PermutationMissingElement
10 | {
11 | 
12 |   public static void main(String[] args) 
13 |   {
14 | 		Scanner sc = new Scanner((System.in));
15 | 		System.out.println("Enter the array size");
16 | 		int n = sc.nextInt();
17 | 		System.out.println("Enter the array : ");
18 | 		int A[] = new int[n];
19 | 		for (int i=0;i<n;i++)
20 | 		{
21 | 		A[i] = sc.nextInt();
22 | 		}	
23 | 		System.out.println(new PermutationMissingElement().solution(A));
24 |   }
25 | 	
26 |   public int solution(int[] A)
27 |   {
28 |     int max = A.length + 1;
29 |    
30 |     //load array elements into array so would be quick to check if elements exist
31 |     Set incompleteSet = new HashSet();
32 |     for(int i=0; i<A.length; i++)
33 |     {
34 |       incompleteSet.add(A[i]);
35 |     }
36 |  
37 |     for(int i=1; i<max+1; i++) 
38 |     {
39 |       if(!incompleteSet.contains(i))
40 |       {
41 |         return (i);
42 |       }
43 |     }
44 |     throw new RuntimeException("shouldn't reach here");
45 |   }
46 | }


--------------------------------------------------------------------------------
/codility/PermutationMissingElement1.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.Arrays;
 4 | import java.util.Collections;
 5 | import java.util.HashSet;
 6 | import java.util.Scanner;
 7 | import java.util.Set;
 8 | 
 9 | public class PermutationMissingElement1
10 | {
11 | 
12 |   public static void main(String[] args) 
13 |   {
14 | 		Scanner sc = new Scanner((System.in));
15 | 		System.out.println("Enter the array size");
16 | 		int n = sc.nextInt();
17 | 		System.out.println("Enter the array : ");
18 | 		int A[] = new int[n];
19 | 		for (int i=0;i<n;i++)
20 | 		{
21 | 		A[i] = sc.nextInt();
22 | 		}	
23 | 		System.out.println(new PermutationMissingElement().solution(A));
24 |   }
25 | 	
26 |   public int solution(int[] A)
27 |   {
28 |     int max = A.length + 1;
29 |    
30 |     Arrays.sort(A);
31 |     for(int i=1; i<max+1; i++) 
32 |     {
33 |       if(Arrays.binarySearch(A, i)<0)
34 |       {
35 |         return (i);
36 |       }
37 |     }
38 |     throw new RuntimeException("shouldn't reach here");
39 |   }
40 | }


--------------------------------------------------------------------------------
/codility/Practice.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.HashSet;
 4 | import java.util.Scanner;
 5 | import java.util.Set;
 6 | 
 7 | public class Practice {
 8 | 
 9 | 	public static void main(String[] args) {
10 | 		Scanner sc = new Scanner(System.in);
11 | 		System.out.println("Please enter frog distance :");
12 | 		int x = sc.nextInt();
13 | 		System.out.println("Please enter array size :");
14 | 		int n = sc.nextInt();
15 | 		int[] A = new int[n];
16 | 		System.out.println("Please enter array :");
17 | 			for(int i=0;i<n;i++)
18 | 			{
19 | 				A[i]=sc.nextInt();
20 | 			}
21 | 			int y =solution(x,A); 
22 | 			if(y>=0)
23 | 				System.out.println(y);
24 | 			else
25 | 				System.out.println("Invalid Input");
26 | 	}
27 | 
28 | 	public static int solution(int x, int[] A){
29 | 	
30 | 		Set perSet = new HashSet();
31 | 		Set reqSet = new HashSet();
32 | 		for(int i=1;i<=x;i++)
33 | 		{
34 | 			reqSet.add(i);
35 | 		}
36 | 		
37 | 		for(int p=0;p<A.length;p++)
38 | 		{
39 | 			perSet.add(A[p]);
40 | 			if(perSet.size()<reqSet.size())
41 | 				continue;
42 | 		
43 | 			if(perSet.containsAll(reqSet))
44 | 				return p;
45 | 		}
46 | 		return -1;
47 | 		
48 | 	}
49 | 	
50 | }
51 | 


--------------------------------------------------------------------------------
/codility/TapeEquilibrium.java:
--------------------------------------------------------------------------------
 1 | package codility;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class TapeEquilibrium
 6 | {
 7 | 	public static void main(String[] args) 
 8 | 	{
 9 | 		Scanner sc = new Scanner((System.in));
10 | 		System.out.println("Enter the array size");
11 | 		int n = sc.nextInt();
12 | 		System.out.println("Enter the array : ");
13 | 		int A[] = new int[n];
14 | 		for (int i=0;i<n;i++)
15 | 		{
16 | 		A[i] = sc.nextInt();
17 | 		}
18 | 		System.out.println("Minimal difference that can be achieved in given array is : "+new TapeEquilibrium().solution(A));
19 | 		
20 | 	}
21 | 	
22 | 	public int solution(int[] A) 
23 | 	{
24 | 		long sumAllElements =0;
25 | 		for(int i=0;i<A.length;i++)
26 | 		{
27 | 			sumAllElements = sumAllElements + A[i];
28 | 		}
29 | 		int currentDifference = Integer.MAX_VALUE;
30 | 		int minDifference = Integer.MAX_VALUE;
31 | 		long sumFirstPart=0;
32 | 		long sumSecondPart=0;
33 | 		for(int p=0;p<A.length;p++)
34 | 		{
35 | 			sumFirstPart = sumFirstPart+A[p];
36 | 			sumSecondPart = sumAllElements-sumFirstPart;
37 | 		    currentDifference = (int) Math.abs(sumFirstPart-sumSecondPart);
38 | 		    minDifference = Math.min(currentDifference, minDifference);
39 | 		}
40 | 		
41 | 		return minDifference;
42 | 		
43 | 	}
44 | 
45 | }
46 | 


--------------------------------------------------------------------------------
/codility/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 |  * 
3 |  */
4 | /**
5 |  * @author hp
6 |  *
7 |  */
8 | package codility;


--------------------------------------------------------------------------------
/collection/AddArray.java:
--------------------------------------------------------------------------------
 1 | package collection;
 2 | 
 3 | import java.util.Collections;
 4 | import java.util.HashSet;
 5 | import java.util.Iterator;
 6 | import java.util.Set;
 7 | 
 8 | public class AddArray 
 9 | {
10 | 	public static void main(String[] args) 
11 | 	{
12 | 		Integer [] array= {1,2,3,4,5,6,7};
13 | 		Set<Integer> set = new HashSet<Integer>();
14 | 		Collections.addAll(set,array);
15 | 		System.out.println(set);
16 | 		Iterator ir = set.iterator();
17 | 		System.out.println(set);
18 | 		while(ir.hasNext())
19 | 		{
20 | 			System.out.print(ir.next());
21 | 		}
22 | 	}
23 | }


--------------------------------------------------------------------------------
/collection/ArrayList1.java:
--------------------------------------------------------------------------------
 1 | package collection;
 2 | import java.util.ArrayList;
 3 | import java.util.Collections;
 4 | import java.util.Comparator;
 5 | 
 6 | public class ArrayList1 
 7 | {
 8 | 
 9 | 	public static void main(String[] args) 
10 | 	{
11 | 		ArrayList<Integer> al = new ArrayList<Integer>();
12 | 		al.add(1);
13 | 		al.add(4);
14 | 		al.add(7);
15 | 		al.add(2);
16 | 		al.add(3);
17 | 		ArrayList<Integer> all = new ArrayList<Integer>();
18 | 		al.add(10);
19 | 		al.add(20);
20 | 		ArrayList al1 = new ArrayList();
21 | 		al1.add(10);
22 | 		al1.add(0);
23 | 		al1.add(0);
24 | 		al1.add(1);
25 | 		//al1.addAll(1,al);
26 | 		//System.out.println(al.removeAll(al1));
27 | 		//al.clear();
28 | 		//al.retainAll(al1);
29 | //		System.out.println(al);
30 | 		System.out.println(al1);
31 | //		System.out.println(al.contains(1));
32 | //		System.out.println(al1.size());
33 | //		//object[] objects = al.toArray();
34 | //		
35 | 		Integer[] al2 = al.toArray(new Integer[al.size()]);
36 | 		for(int i=0;i<al2.length;i++)
37 | 		{
38 | 			System.out.print(al2[i]);
39 | 		}
40 | //		int[] al3 = new int[al2.length];
41 | ////		System.out.println( );
42 | ////		System.out.println("al3 is :"+Arrays.toString(al2));
43 | //		for(int i=0;i<al2.length;i++)
44 | //		{
45 | //			al3[i]=al2[i].intValue();
46 | //		}
47 | //		System.out.println( );
48 | //		System.out.println("al3 is :");
49 | //		for(int i=0;i<al2.length;i++)
50 | //		{
51 | //			System.out.print(al3[i]);
52 | //		}
53 | //		
54 | //		Object[] al4 = al1.toArray();
55 | //		System.out.println();
56 | //		System.out.println("Elements of al4 as Array: "+ Arrays.toString(al4)); 
57 | 		
58 | 		Integer[] i1 = new Integer[al.size()];
59 | 		i1=al.toArray(i1);
60 | 		for(int i=0;i<i1.length;i++)
61 | 		{
62 | 			System.out.println(i1[i]);
63 | 		}
64 | //		System.out.println(al);
65 | 		Collections.copy(al,all);
66 | 		System.out.println(al);
67 | 		System.out.println(al1);
68 | 		System.out.println(Collections.max(al));
69 | 		Collections.replaceAll(al,20, 200);
70 | 		System.out.println(al);
71 | 		Collections.reverse(al);
72 | 		System.out.println(al);
73 | 		Collections.reverseOrder();
74 | 		System.out.println(al);
75 | //		Collections.sort(al,Collections.reverseOrder());
76 | //		System.out.println(al);
77 | 		Comparator comp =Collections.reverseOrder(null);
78 | 		Collections.sort(al,comp);
79 | 		System.out.println(al);
80 | 	}
81 | 	
82 | 	
83 | }
84 | 


--------------------------------------------------------------------------------
/collection/ArrayToList.java:
--------------------------------------------------------------------------------
 1 | package collection;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.Arrays;
 5 | import java.util.List;
 6 | 
 7 | public class ArrayToList 
 8 | {
 9 | 	public static void main(String[] args) 
10 | 	{
11 | 		// TODO Auto-generated method stub
12 | 		String[] s1 = {"Ram", "Sita", "Shyam"};
13 | 		//String s1[] = new String[] {"Ram", "Sita", "Shyam"};
14 | 		List<String> list = Arrays.asList(s1);
15 | 		System.out.println("This list is : "+ list);
16 | 		
17 | 		// we are not creating List object. We are just viewing Array in List format.
18 | 		s1[2]="Lakhan";
19 | 		System.out.println("This list is : "+ list);
20 | 		list.set(2, "Rajesh");
21 | 		System.out.println("This list is : "+ list);
22 | 		
23 | 		//ArrayList<String> al = new ArrayList<String>();
24 | 		String[] sa = {"ram","sham","babita"};
25 | 		ArrayList<String> al=new ArrayList<String>(Arrays.asList(sa));
26 | 		System.out.println(al);
27 | //		String j = Arrays.toString(sa);
28 | //		System.out.println("New string j = "+j);
29 | //		System.out.println(j.charAt(10));
30 | //		for(int i=sa.length-1;i>=0;i--)
31 | //		{
32 | //			System.out.println(sa[i]);
33 | //		}
34 | //		for(int i=j.length()-1;i>=0;i--)
35 | //		{
36 | //			System.out.print(j.charAt(i));
37 | //		}
38 | //		System.out.println("");
39 | 		int[] ar = {1,2,3,4,5};
40 | 		int[] arr = {1,2,3,4,5,6};
41 | 		System.out.println(Arrays.toString(Arrays.copyOf(ar,15)));
42 | 		
43 | 		
44 | 	
45 | 	}
46 | }
47 | 


--------------------------------------------------------------------------------
/collection/BinarySearch.java:
--------------------------------------------------------------------------------
 1 | package collection;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.Collections;
 5 | 
 6 | public class BinarySearch 
 7 | {
 8 | 	public static void main(String[] args) 
 9 | 	{  
10 |         //Create list         
11 |           ArrayList<Integer> arrlist = new ArrayList<Integer>();  
12 |           arrlist.add(10);  
13 |           arrlist.add(-20);  
14 |           arrlist.add(30);  
15 |           arrlist.add(-40);  
16 |           arrlist.add(50);  
17 |           //Print List  
18 |           System.out.println("Provided List are: "+arrlist);  
19 |           //Search the list for key '-20'
20 | //          Collections.sort(arrlist,Collections.reverseOrder());
21 | //          System.out.println(arrlist);
22 |           int index = Collections.binarySearch(arrlist, -20,  Collections.reverseOrder());       
23 |           System.out.println("Index '-20' is available at position: "+index); 
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/collection/ComparatorDemo.java:
--------------------------------------------------------------------------------
 1 | package collection;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.Collections;
 5 | import java.util.Comparator;
 6 | import java.util.List;
 7 | 
 8 | public class ComparatorDemo
 9 | {
10 | 	public static void main(String[] args) 
11 | 	{
12 | 		List<Integer> al = new ArrayList<Integer>();
13 | 		al.add(10);
14 | 		al.add(20);
15 | 		al.add(5);
16 | 		al.add(40);
17 | 		al.add(13);
18 | 		Collections.sort(al);
19 | 		System.out.println(al);
20 | 		Collections.sort(al,new MyComparator());
21 | 		System.out.println(al);
22 | 	}
23 | }
24 | 
25 | class MyComparator implements Comparator
26 | {
27 | 	public int compare(Object obj1, Object obj2)
28 | 	{
29 | 		Integer i1 = (Integer)obj1;
30 | 		Integer i2 = (Integer)obj2;
31 | 		return -i1.compareTo(i2);
32 | 	}
33 | }
34 | 


--------------------------------------------------------------------------------
/collection/HashMapDemo.java:
--------------------------------------------------------------------------------
 1 | package collection;
 2 | 
 3 | import java.util.Collection;
 4 | import java.util.HashMap;
 5 | import java.util.Iterator;
 6 | import java.util.Map;
 7 | import java.util.Map.Entry;
 8 | //import java.util.*;
 9 | import java.util.Set;
10 | import java.lang.*;
11 | 
12 | public class HashMapDemo
13 | {
14 | 
15 | 	public static void main(String[] args) 
16 | 	{
17 | 		// TODO Auto-generated method stub
18 | 		HashMap<Integer,String> hm = new HashMap<Integer,String>();
19 | 		hm.put(1, "Ram");
20 | 		hm.put(2, "Sita");
21 | 		hm.put(3, "Shyam");
22 | 		hm.put(4, "Geeta");
23 | 
24 | 		System.out.println(hm);
25 | 		
26 | 		hm.put(1, "Rama");
27 | 		
28 | 		System.out.println(hm);
29 | 		System.out.println(hm.get(3));
30 | 		
31 | 		Set s = hm.keySet();
32 | 		System.out.println(s);
33 | 		
34 | 		Collection c = hm.values();
35 | 		System.out.println(c);
36 | 		
37 | 		Set se = hm.entrySet();
38 | 		System.out.println(se);
39 | 		
40 | 		Iterator itr = se.iterator();
41 | 		//Entry me;
42 | 		while(itr.hasNext())
43 | 		{
44 | 			Map.Entry me = (Map.Entry)itr.next();
45 | 		//	me = (Entry)itr.next();
46 | 			System.out.println(me.getKey() + "........."+me.getValue());
47 | 				if(me.getKey().equals("1"))
48 | 					{
49 | 					  me.setValue("Ram");
50 | 					}
51 | 		}
52 | 		System.out.println(hm);
53 | 	}
54 | 
55 | }


--------------------------------------------------------------------------------
/collection/HashSetDemo.java:
--------------------------------------------------------------------------------
 1 | package collection;
 2 | 
 3 | import java.util.Collections;
 4 | import java.util.HashSet;
 5 | 
 6 | public class HashSetDemo 
 7 | {
 8 | 
 9 | 	public static void main(String[] args)
10 | 	{
11 | 		// TODO Auto-generated method stub
12 | 		HashSet hs = new HashSet();
13 | //		hs.add("B");
14 | //		hs.add(null);
15 | //		hs.add("Z");
16 | //		hs.add("A");
17 | //		hs.add(10);
18 | //		hs.add("D");
19 | //		hs.add("C");
20 | //		System.out.println(hs);
21 | //		System.out.println(hs);
22 | //		System.out.println(hs);
23 | 		hs.add(10);
24 | 		System.out.println(hs);	
25 | 		
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/collection/ReadingArrayList.java:
--------------------------------------------------------------------------------
 1 | package collection;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.Iterator;
 5 | 
 6 | public class ReadingArrayList 
 7 | {
 8 | 
 9 | 	public static void main(String[] args) 
10 | 	{
11 | 		ArrayList data = new ArrayList();
12 | 		data.add(12);
13 | 		data.add("Ram");
14 | 		data.add(25);
15 | 		data.add(true);
16 | 		
17 | 		// Reading arraylist mathod --- 1
18 | 		System.out.println(data);
19 | 		
20 | 		// Reading arraylist mathod --- 2 -- separate elements
21 | 		for(int i=0;i<data.size();i++)
22 | 		{
23 | 			System.out.println(data.get(i));
24 | 		}
25 | 		
26 | 		System.out.println("Iterator -----");
27 | 		// Reading arraylist mathod --- 3 -- Iterator
28 | 		Iterator ir = data.iterator();
29 | 		while(ir.hasNext())
30 | 		{
31 | 			System.out.println(ir.next());
32 | 		}		
33 | 	}
34 | }
35 | 


--------------------------------------------------------------------------------
/collection/TreeSetDemo.java:
--------------------------------------------------------------------------------
 1 | package collection;
 2 | 
 3 | import java.util.TreeSet;
 4 | 
 5 | public class TreeSetDemo 
 6 | {
 7 | 
 8 | 	public static void main(String[] args)
 9 | 	{
10 | 		// TODO Auto-generated method stub
11 | 		TreeSet ts = new TreeSet();
12 | 		ts.add(new StringBuffer("Ram"));
13 | 		ts.add(new StringBuffer("Rams"));
14 | 		System.out.println(ts);
15 | 		
16 | 	}
17 | 
18 | }
19 | 


--------------------------------------------------------------------------------
/factorymethods/UnmodifiableCollection.java:
--------------------------------------------------------------------------------
 1 | package factorymethods;
 2 | 
 3 | import java.sql.Connection;
 4 | import java.util.ArrayList;
 5 | import java.util.Collections;
 6 | import java.util.List;
 7 | 
 8 | public class UnmodifiableCollection 
 9 | {
10 | 	public static void m1()
11 | 	{
12 | 		List<String> l1 = new ArrayList<String>();
13 | 		l1.add("Ram");
14 | 		l1.add("Sita");
15 | 		l1.add("Shyam");
16 | 		l1.add("Geeta");
17 | 		List<String> l2 = Collections.unmodifiableList(l1);
18 | 		System.out.println(l2);
19 | 		System.out.println(String.class.getClass());
20 | 		System.out.println(Connection.class.getClass());
21 | 		System.out.println(ArrayList.class.getClass());
22 | //	code in Java-9
23 | //	List<list> l12 = List.of("ab","cd","ef","gh");
24 | 	}
25 | 	public static void main(String[] args) 
26 | 	{
27 | 		m1();
28 | 	}
29 | }
30 | 


--------------------------------------------------------------------------------
/generics/TestGen.java:
--------------------------------------------------------------------------------
 1 | package generics;
 2 | 
 3 | class MyGen<T>{
 4 | 	T obj;
 5 | 	static int count;
 6 | 	{
 7 | 		count++;
 8 | 	}
 9 | 	void add(T obj)
10 | 	    {
11 | 			this.obj=obj;
12 | 		}
13 | 	T get(){
14 | 		return obj;
15 | 	}
16 | }
17 | public class TestGen {
18 | 
19 | 	public static void main(String[] args) {
20 | 		// TODO Auto-generated method stub
21 | 
22 | 		MyGen<Integer> mg = new MyGen<Integer>();
23 | //		mg.add(10);
24 | //		System.out.println(mg.obj);
25 | //		mg.add(20);
26 | //		System.out.println(mg.obj);
27 | 		mg.add(30);
28 | //		mg.add("Ram");
29 | 		System.out.println(mg.obj);
30 | 		System.out.println(mg.get());
31 | 		MyGen<String> mg1 = new MyGen<String>();
32 | 		mg1.add("Ram");
33 | 		System.out.println(mg1.obj);
34 | 		System.out.println("No. of objects created : "+ mg.count);
35 | 		
36 | 		
37 | 	}
38 | 
39 | }
40 | 


--------------------------------------------------------------------------------
/generics/TestGen2.java:
--------------------------------------------------------------------------------
 1 | package generics;
 2 | 
 3 | 
 4 | class MyGen1<T>{
 5 | 
 6 | 	T obj;
 7 | //	MyGen1(){
 8 | //		this.obj = obj;			// not required
 9 | //	}
10 | 	MyGen1(T obj){this.obj = obj;}
11 | 	public T get(){
12 | 		return obj;
13 | 	}
14 | }
15 | 
16 | public class TestGen2 {
17 | 
18 | 	public static void main(String[] args) {
19 | 		// TODO Auto-generated method stub
20 | 		MyGen1<Integer> mg1 = new MyGen1<Integer>(10);
21 | 		System.out.println(mg1.get());
22 | 		
23 | 		
24 | 	}
25 | 
26 | }
27 | 


--------------------------------------------------------------------------------
/immutable/ImmutableDemo.java:
--------------------------------------------------------------------------------
 1 | package immutable;
 2 | 
 3 | final class ImmutableDemo 
 4 | {	
 5 | 	private final int age;
 6 | 	
 7 | 	ImmutableDemo(int age)
 8 | 	{
 9 | 		this.age=age;
10 | 	}
11 | 	
12 | 	public ImmutableDemo test(int age)
13 | 	{
14 | 		if(this.age==age)
15 | 			return this;
16 | 		else
17 | 			return (new ImmutableDemo(age));
18 | 	}
19 | 		
20 | 	public static void main(String[] args) 
21 | 	{
22 | 		// TODO Auto-generated method stub
23 | 
24 | 		ImmutableDemo im1 = new ImmutableDemo(10);
25 | 		ImmutableDemo im2 = new ImmutableDemo(20);
26 | 		ImmutableDemo im3 = new ImmutableDemo(10);
27 | 		ImmutableDemo im4 = im1.test(10);
28 | 		System.out.println(im1==im2);
29 | 		System.out.println(im1==im3);
30 | 		System.out.println(im1==im4);
31 | 		System.out.println(im4.age);
32 | 		System.out.println(im1.age);
33 | 		System.out.println(im1==im4);
34 | 		System.out.println(im4.age);
35 | 	}
36 | 
37 | }
38 | 


--------------------------------------------------------------------------------
/immutable/ImmutableStudent.java:
--------------------------------------------------------------------------------
 1 | package immutable;
 2 | 
 3 | public final class ImmutableStudent 
 4 | {
 5 |     private final int id;
 6 |     private final String name;
 7 |     public ImmutableStudent(int id, String name) 
 8 |     {
 9 |         this.name = name;
10 |         this.id = id;
11 |     }
12 |     public int getId() 
13 |     {
14 |         return id;
15 |     }
16 |     public String getName() 
17 |     {
18 |         return name;
19 |     }
20 |     
21 |     public static void main(String[] args) 
22 | 	{
23 |     	ImmutableStudent is1 = new ImmutableStudent(10,"Ram");
24 |     	ImmutableStudent is2 = new ImmutableStudent(11,"sita");
25 |     	ImmutableStudent is3 = new ImmutableStudent(10,"Ram");
26 | //    	is1.id=50;    	
27 |     	ImmutableStudent is4 =is1;
28 |     	System.out.println(is1==is2);
29 |     	System.out.println(is1==is3);
30 |     	System.out.println(is1.equals(is2));
31 |     	System.out.println(is1.equals(is3));
32 |     	System.out.println(is1==is4);
33 |     	System.out.println(is1.equals(is4));
34 |     	
35 | 	}
36 | }
37 | 


--------------------------------------------------------------------------------
/immutableVsFinal/ImmutableVsFinal.java:
--------------------------------------------------------------------------------
 1 | package immutableVsFinal;
 2 | 
 3 | import java.awt.List;
 4 | import java.util.ArrayList;
 5 | import java.util.Collections;
 6 | 
 7 | public class ImmutableVsFinal {
 8 | 
 9 | 	public static void main(String[] args) 
10 | 	{
11 | 		ArrayList al = new ArrayList();
12 | 		al.add(10);
13 | 		al.add("Raj");
14 | 		al.add(20);
15 | 		al.add("Ravi");
16 | 		System.out.println(al);
17 | 		//ArrayList al1 = Collections.unmodifiableList(al);
18 | 		
19 | 		
20 | 	}
21 | 
22 | }
23 | 


--------------------------------------------------------------------------------
/input/ArrayInputDemo.java:
--------------------------------------------------------------------------------
 1 | package input;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class ArrayInputDemo 
 6 | {
 7 | 
 8 | 	public static void main(String[] args) 
 9 | 	{
10 | 		Scanner sc = new Scanner(System.in);
11 | 		System.out.println("Please enter array size : ");
12 | 		int s = sc.nextInt();
13 | 		int[] age = new int[s];
14 | 		System.out.println("Please enter array elements : ");
15 | 		for(int i=0;i<age.length;i++)
16 | 		{
17 | 			age[i]=sc.nextInt();
18 | 		}
19 | 		sc.close();
20 | 			
21 | 	}
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/input/BufferedInput.java:
--------------------------------------------------------------------------------
 1 | package input;
 2 | 
 3 | //import java.io.*;
 4 | import java.io.BufferedReader;
 5 | import java.io.IOException;
 6 | import java.io.InputStreamReader;
 7 | 
 8 | public class BufferedInput
 9 | {
10 | 	public static void main(String[] args) throws IOException
11 | 	{
12 | 		InputStreamReader ir = new InputStreamReader(System.in);
13 | 		BufferedReader br = new BufferedReader(ir);
14 | 		System.out.println("Enter values :");
15 | 		String name = br.readLine();
16 | 		int x = br.read();
17 | 		
18 | 		System.out.println(x);
19 | 		System.out.println(name);
20 | 	}
21 | 		
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/input/ScannerDemo.java:
--------------------------------------------------------------------------------
 1 | package input;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class ScannerDemo {
 6 | 
 7 | 	public static void main(String[] args) 
 8 | 	{
 9 | 		// TODO Auto-generated method stub
10 | 		//System.out.println("Enter number and name : ");
11 | 		Scanner sc = new Scanner(System.in);
12 | 		System.out.println("Enter name and number: ");
13 | 		String name = sc.nextLine();
14 | 		int num = sc.nextInt();
15 | //		System.out.println("Enter name : ");
16 | 		System.out.println(name);
17 | 		System.out.println(num);
18 | 	}
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/input/ToCheckInput.java:
--------------------------------------------------------------------------------
 1 | package input;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class ToCheckInput 
 6 | {
 7 | 
 8 | 	public static void main(String[] args) 
 9 | 	{
10 | 		int num;
11 | 		Scanner sc = new Scanner(System.in);
12 | 	  while(true)
13 | 	  {  
14 | 		System.out.println("Please enter positive integer : ");
15 | 		num = sc.nextInt();
16 | 		if(num<0)
17 | 			System.out.println("Please enter positive number.");
18 | 		else
19 | 			break;
20 | 	  }
21 | 	  sc.close();
22 | 	}
23 | 
24 | }


--------------------------------------------------------------------------------
/input/TwoDArrayInout.java:
--------------------------------------------------------------------------------
 1 | package input;
 2 | 
 3 | import java.util.Arrays;
 4 | import java.util.Scanner;
 5 | 
 6 | public class TwoDArrayInout 
 7 | {
 8 | 	public static void main(String[] args)
 9 | 	{
10 | 		Scanner sc = new Scanner(System.in);
11 | 		System.out.println("Please enter number of rows and columns : ");
12 | 		int rows = sc.nextInt();
13 | 		int columns = sc.nextInt();
14 | 		int[][] age = new int[rows][columns];
15 | 		System.out.println("Please enter array elements : ");
16 | 	for(int i=0;i<rows;i++)
17 | 	  {	
18 | 		for(int j=0;j<columns;j++)
19 | 		{
20 | 			age[i][j]=sc.nextInt();
21 | 		}
22 | 	  }	
23 | 	// print the array
24 | 	for (int i = 0; i < age.length; i++) 
25 |         // Loop through all elements of current row 
26 |         for (int j = 0; j < age[i].length; j++) 
27 |             System.out.print(age[i][j] + " "); 
28 | 	}
29 | }
30 | 


--------------------------------------------------------------------------------
/java8/ForEach.java:
--------------------------------------------------------------------------------
 1 | package java8;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.List;
 5 | 
 6 | public class ForEach 
 7 | {
 8 | 	public static void main(String[] args) 
 9 | 	{
10 | 		List<Integer> al = new ArrayList<Integer>();
11 | 		al.add(10);
12 | 		al.add(20);
13 | 		al.add(30);
14 | 		al.add(40);
15 | 		
16 | //	for(int i:al)
17 | //	{
18 | //		System.out.println(i);
19 | //	}
20 | 	al.forEach(i->System.out.println(i));
21 | 	al.forEach(System.out::println);
22 | 	al.forEach(ForEach::doubleIt);
23 | 	}
24 | 	
25 | 	public static void doubleIt(int i)
26 | 	{
27 | 		System.out.println(i*i);
28 | 	}
29 | }
30 | 


--------------------------------------------------------------------------------
/practice/StringDemo.java:
--------------------------------------------------------------------------------
 1 | package practice;
 2 | 
 3 | public class StringDemo 
 4 | {
 5 | 
 6 | 	public static void main(String[] args)
 7 | 	{
 8 | 		// TODO Auto-generated method stub
 9 | 		String s1="0";
10 | 		String s2=" ";
11 | //		if(s1.equals(""))
12 | //			System.out.println("Cond 1 True");
13 | //		else
14 | //			System.out.println("False");
15 | //		if(s1.equals(null))
16 | //			System.out.println("Cond 1 True");
17 | //		else
18 | //			System.out.println("False");
19 | //		System.out.println(s1.isEmpty());
20 | //		
21 | //		if(s2.equals(""))
22 | //			System.out.println("Cond 1 True");
23 | //		else
24 | //			System.out.println("False");
25 | //		if(s2.equals(null))
26 | //			System.out.println("Cond 1 True");
27 | //		else
28 | //			System.out.println("False");
29 | //		System.out.println(s2.isEmpty());
30 | 		if((int)s1.charAt(0)==48)
31 | 			System.out.println("0 found");
32 | 		
33 | 
34 | 
35 | 
36 | 	}
37 | 
38 | }
39 | 


--------------------------------------------------------------------------------
/predicate/PredCollDemo.java:
--------------------------------------------------------------------------------
 1 | package predicate;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.Scanner;
 5 | import java.util.function.Predicate;
 6 | 
 7 | public class PredCollDemo {
 8 | 
 9 | 	public static void main(String[] args) {
10 | 		// TODO Auto-generated method stub
11 | 
12 | 		
13 | 		Scanner sc = new Scanner(System.in);
14 | 		System.out.println("Enter the size of arraylist: ");
15 | 		int x = sc.nextInt();
16 | //		ArrayList<Integer> al = new ArrayList<Integer>();
17 | 		ArrayList al = new ArrayList();
18 | 		System.out.println(al.size());
19 | 		System.out.println("Enter the arraylist elements: ");
20 | 		for(int i=0;i<x;i++)
21 | 		{
22 | //			System.out.println("Hi1");
23 | 			int y = sc.nextInt();
24 | 			al.add(y);
25 | //			System.out.println("Hi");
26 | 		}
27 | //		System.out.println(al);
28 | 	
29 | 		Predicate<ArrayList> p = arl -> arl.isEmpty();
30 | 		System.out.println(p.test(al));
31 | 		
32 | 	}
33 | 
34 | }
35 | 


--------------------------------------------------------------------------------
/predicate/PredicateDemo.java:
--------------------------------------------------------------------------------
 1 | package predicate;
 2 | 
 3 | import java.util.Scanner;
 4 | import java.util.function.Predicate;
 5 | 
 6 | public class PredicateDemo {
 7 | 
 8 | 	public static void main(String[] args) {
 9 | 		// TODO Auto-generated method stub
10 | 
11 | 		Scanner sc = new Scanner(System.in);
12 | 		System.out.println("Enter the number: ");
13 | 		int x = sc.nextInt();
14 | 		System.out.println("Enter the number to compare : ");
15 | 		int y = sc.nextInt();
16 | 		Predicate<Integer> P = (I) -> (I>x);
17 | 		System.out.println(P.test(y));
18 | 		
19 | 	}
20 | 
21 | }
22 | 


--------------------------------------------------------------------------------
/projects/ExtractMailIDFrmFile.java:
--------------------------------------------------------------------------------
 1 | package projects;
 2 | 
 3 | import java.io.BufferedReader;
 4 | import java.io.File;
 5 | import java.io.FileReader;
 6 | import java.io.IOException;
 7 | import java.io.PrintWriter;
 8 | import java.util.regex.Matcher;
 9 | import java.util.regex.Pattern;
10 | 
11 | public class ExtractMailIDFrmFile {
12 | 
13 | 	public static void main(String[] args) throws IOException{
14 | 		mobileNo(new File("Data.txt"));
15 | 		mailID(new File("Data.txt"));
16 | 		
17 | 	}
18 | 	
19 | 	public static void mobileNo(File f){
20 | 		try{
21 | //			File f = new File("Mobile.txt");	
22 | //			f.createNewFile();
23 | //			System.out.println(f.exists());
24 | 			PrintWriter out = new PrintWriter("Mobile.txt");
25 | 			FileReader fr = new FileReader(f);
26 | 			BufferedReader br = new BufferedReader(fr);
27 | 			int count=0;
28 | 			Pattern p = Pattern.compile("(0|91)?[7-9][0-9]{9}");
29 | 			String line = br.readLine();
30 | 				while(line!=null)
31 | 				{
32 | 					Matcher m = p.matcher(line);
33 | 					while(m.find())
34 | 					{
35 | 						count++;
36 | 						out.println(m.group());
37 | //						System.out.println(m.group());
38 | 					}
39 | 					line=br.readLine();
40 | 				}
41 | //				System.out.print("Total mobile numbers found : "+count);
42 | 				out.print("Total mobile numbers found : "+count);
43 | 				out.flush();
44 | 				br.close();
45 | 			}
46 | 			catch(IOException ie){
47 | 				ie.printStackTrace();
48 | 			}		
49 | 	}	
50 | 	
51 | 	public static void mailID(File f){
52 | 		try{
53 | //			File f = new File("Mobile.txt");	
54 | //			f.createNewFile();
55 | //			System.out.println(f.exists());
56 | 			PrintWriter out = new PrintWriter("MailID.txt");
57 | 			FileReader fr = new FileReader(f);
58 | 			BufferedReader br = new BufferedReader(fr);
59 | 			int count=0;
60 | 			Pattern p = Pattern.compile("[a-zA-Z][a-zA-Z0-9.-]{4}@[a-zA-Z0-9]+.[a-zA-Z]*{15}");
61 | 			String line = br.readLine();
62 | 				while(line!=null)
63 | 				{
64 | 					Matcher m = p.matcher(line);
65 | 					while(m.find())
66 | 					{
67 | 						count++;
68 | 						out.println(m.group());
69 | //						System.out.println(m.group());
70 | 					}
71 | 					line=br.readLine();
72 | 				}
73 | //				System.out.print("Total mail IDs found : "+count);
74 | 				out.print("Total mail IDs found : "+count);
75 | 				out.flush();
76 | 				br.close();
77 | 			}
78 | 			catch(IOException ie){
79 | 				ie.printStackTrace();
80 | 			}		
81 | 	}	
82 | }


--------------------------------------------------------------------------------
/projects/ExtractMobFrmFile.java:
--------------------------------------------------------------------------------
 1 | package projects;
 2 | 
 3 | import java.io.*;
 4 | import java.util.regex.*;
 5 | 
 6 | public class ExtractMobFrmFile {
 7 | 
 8 | 	public static void main(String[] args) {
 9 | 		
10 | 		try{
11 | 		FileReader fr = new FileReader("Data.txt");
12 | 		BufferedReader br = new BufferedReader(fr);
13 | 		File f = new File("Mobile.txt");	
14 | 		f.createNewFile();
15 | 		//System.out.println(f.exists());
16 | 		PrintWriter out = new PrintWriter(f);
17 | 		int count=0;
18 | 		Pattern p = Pattern.compile("(0|91)?[7-9][0-9]{9}");
19 | 		String line = br.readLine();
20 | 			while(line!=null)
21 | 			{
22 | 				Matcher m = p.matcher(line);
23 | 				while(m.find())
24 | 				{
25 | 					count++;
26 | 					out.println(m.group());
27 | //					System.out.println(m.group());
28 | 				}
29 | 				line=br.readLine();
30 | 			}
31 | //			System.out.print("Total mobile numbers found : "+count);
32 | 			out.print("Total mobile numbers found : "+count);
33 | 			out.flush();
34 | 			br.close();
35 | 		}
36 | 		catch(IOException ie){
37 | 			ie.printStackTrace();
38 | 		}
39 | 	}
40 | 	
41 | 	
42 | 
43 | }
44 | 


--------------------------------------------------------------------------------
/regex/RegFileNames.java:
--------------------------------------------------------------------------------
 1 | package regex;
 2 | 
 3 | import java.io.File;
 4 | import java.util.regex.*;
 5 | 
 6 | public class RegFileNames {
 7 | 
 8 | 	public static void main(String[] args) {
 9 | 		
10 | 		File f = new File("F:\\Eclipse\\PRACT");
11 | 		txtFinder(f);
12 | 		
13 | 	}
14 | 	
15 | 	public static void txtFinder(File f){
16 | 		int count=0;
17 | 		Pattern p = Pattern.compile("[a-zA-Z0-9-.$]+.txt");
18 | 		String[] listFile = f.list();
19 | 		for(String name:listFile)
20 | 		{
21 | 			Matcher m = p.matcher(name);
22 | 			while(m.find())
23 | 			{
24 | 				count++;
25 | 				System.out.println(name);
26 | 			}
27 | //			if(m.find()&&m.group().equals(name))
28 | //			{
29 | //				count++;
30 | //				System.out.println(name);
31 | //			}
32 | 		}
33 | 		System.out.println("Number of text files is : "+count);
34 | 	}
35 | }
36 | 


--------------------------------------------------------------------------------
/regex/RegJavaIdentifier.java:
--------------------------------------------------------------------------------
 1 | package regex;
 2 | 
 3 | import java.util.regex.*;
 4 | 
 5 | public class RegJavaIdentifier {
 6 | 
 7 | 	public static void main(String[] args) {
 8 | 		validator("Ashok");
 9 | 		validator("Ashok-");
10 | 		validator("=Ashok");
11 | 		validator("?Ashok");
12 | 	}
13 | 
14 | 	public static void validator(String x){
15 | 		
16 | 		Pattern p = Pattern.compile("[a-zA-Z][a-zA-Z0-9-#]+");
17 | 		Matcher m = p.matcher(x);
18 | 		if(m.find()&&m.group().equals(x))
19 | 		{
20 | 			System.out.println("Valid");
21 | 		}
22 | 		else
23 | 		{
24 | 			System.out.println("Invalid");
25 | 		}
26 | 	}
27 | 	
28 | }
29 | 


--------------------------------------------------------------------------------
/regex/RegMailID.java:
--------------------------------------------------------------------------------
 1 | package regex;
 2 | 
 3 | import java.util.regex.Matcher;
 4 | import java.util.regex.Pattern;
 5 | 
 6 | public class RegMailID {
 7 | 
 8 | 	public static void main(String[] args) {
 9 | 		String x = "rishi@gmail.com";
10 | 		System.out.println(x.length());
11 | 		validator(x);
12 | 	}
13 | 
14 | 	public static void validator(String x){
15 | 		Pattern p = Pattern.compile("[a-zA-Z][a-zA-Z0-9.-]{4..}@[a-zA-Z0-9]+.[a-zA-Z]*{15}");
16 | 		Matcher m = p.matcher(x);
17 | 		if(m.find()&&m.group().equals(x))
18 | 		{
19 | 			System.out.println("Valid");
20 | 		}
21 | 		else
22 | 		{
23 | 			System.out.println("Invalid");
24 | 		}
25 | 	}	
26 | }
27 | 


--------------------------------------------------------------------------------
/regex/RegMobNum.java:
--------------------------------------------------------------------------------
 1 | package regex;
 2 | 
 3 | import java.util.regex.*;
 4 | 
 5 | public class RegMobNum {
 6 | 
 7 | 	public static void main(String[] args) {
 8 | 	
 9 | 		validator("919850767571");
10 | 		validator("6850767571");
11 | 		validator("08507675712");
12 | 	}
13 | 
14 | 	public static void validator(String x){
15 | 		Pattern p = Pattern.compile("(0|91)?[7-9][0-9]{9}");
16 | 		Matcher m = p.matcher(x);
17 | 		if(m.find()&&m.group().equals(x))
18 | 		{
19 | 			System.out.println("Valid");
20 | 		}
21 | 		else
22 | 		{
23 | 			System.out.println("Invalid");
24 | 		}
25 | 	}	
26 | }
27 | 


--------------------------------------------------------------------------------
/regex/Regex1.java:
--------------------------------------------------------------------------------
 1 | package regex;
 2 | 
 3 | import java.util.regex.*;
 4 | 
 5 | public class Regex1 {
 6 | 
 7 | 	public static void main(String[] args) {
 8 | //		
 9 | //		String x = "ab";
10 | //		String y = "ababdfabbbab";
11 | 		String s1 = "I love India";
12 | 		validate("ab", "ababbdaabab");	
13 | 		
14 | 		String[] s = s1.split("\\s");
15 | 		for(String x:s)
16 | 		{	System.out.println(x);}
17 | 	}
18 | 	
19 | 	public static void validate(String x , String y) {
20 | 		
21 | 		Pattern p = Pattern.compile(x);
22 | 		Matcher m = p.matcher(y);
23 | 		while(m.find()){
24 | 			System.out.println(m.start()+ " " + m.group());
25 | 			}
26 | 	}
27 | 
28 | 	
29 | }
30 | 


--------------------------------------------------------------------------------
/regex/RegexDemo.java:
--------------------------------------------------------------------------------
 1 | package regex;
 2 | import java.util.Scanner;
 3 | import java.util.regex.*;
 4 | 
 5 | public class RegexDemo 
 6 | {
 7 | 
 8 | 	public static void main(String[] args)
 9 | 	{
10 | 		// TODO Auto-generated method stub
11 | 
12 | 		Scanner sc = new Scanner(System.in);
13 | //		System.out.println("Enter the mobile number : ");
14 | //		String smob = sc.nextLine();
15 | //		System.out.println("Enter the pattern to find : ");
16 | //		String spat = sc.nextLine();
17 | //		Pattern p = Pattern.compile(spat);
18 | //		Matcher m = p.matcher(smob);
19 | //		Matcher m = p.matcher("a0B9b@Xr#_7kT%");
20 | //		Matcher m = p.matcher("abcdefghijklmnopqrstuvwxyzabcdrfjklmn");
21 | //		
22 | //		int count=0;
23 | //		System.out.println("start"+"\t"+"ends"+"\t"+"Group");
24 | //		while(m.find())
25 | //		{
26 | //			count++;
27 | //			System.out.println(m.start() +"\t"+m.end()+"\t"+m.group());
28 | //		}
29 | //		System.out.println("No. of occurrence : "+ count);
30 | 		System.out.println(Pattern.matches("[amn]+", "aa"));
31 | 		System.out.println(Pattern.matches("[amn]?", "a"));//true (a or m or n comes one time)  
32 | 		System.out.println(Pattern.matches("[amn]?", "aaa"));//false (a comes more than one time)  
33 | 		//System.out.println(p.pattern());
34 | 	}
35 | 
36 | }
37 | 


--------------------------------------------------------------------------------
/singleton/RuntimeFactoryMethod.java:
--------------------------------------------------------------------------------
 1 | package singleton;
 2 | 
 3 | import java.util.Date;
 4 | 
 5 | public class RuntimeFactoryMethod 
 6 | {
 7 | 	public static void main(String[] args) 
 8 | 	{
 9 | 		Runtime r = Runtime.getRuntime();
10 | 		System.out.println("Total  "+ r.totalMemory());
11 | 		System.out.println("Free   "+r.freeMemory());
12 | 		for(int i=0;i<10000;i++)
13 | 		{
14 | 			Date d = new Date();
15 | 			d=null;
16 | 		}
17 | 		System.out.println("New Free 1  "+r.freeMemory());
18 | 		r.gc();
19 | 		System.out.println("New Free   "+r.freeMemory());
20 | 	}
21 | 	
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/singleton/Singleton.java:
--------------------------------------------------------------------------------
 1 | package singleton;
 2 | 
 3 | public class Singleton 
 4 | {
 5 | 	private static Singleton s = null;
 6 | 	private Singleton(){};
 7 | 	
 8 | 	public static Singleton getSingleton()
 9 | 	{
10 | 		// this is a factory method
11 | 	if(s==null)
12 | 	{
13 | 		s=new Singleton();
14 | 	}
15 | 	return s;	
16 | 	}
17 | 	
18 | 	public void output()
19 | 	{
20 | 		System.out.println("Hi");
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/singleton/Singleton2.java:
--------------------------------------------------------------------------------
 1 | package singleton;
 2 | 
 3 | // Another way of creating singleton class
 4 | public class Singleton2 
 5 | {
 6 | 	private static Singleton2 s2 = new Singleton2();
 7 | 	private Singleton2()
 8 | 	{}
 9 | 	
10 | 	public static Singleton2 getSingleton2()
11 | 	{
12 | 		return s2;
13 | 	}
14 | 
15 | }


--------------------------------------------------------------------------------
/singleton/TestSingleton.java:
--------------------------------------------------------------------------------
 1 | package singleton;
 2 | 
 3 | public class TestSingleton 
 4 | {
 5 | 	public static void main(String[] args) 
 6 | 	{
 7 | 		Singleton t = Singleton.getSingleton();
 8 | 		Singleton t1 = Singleton.getSingleton();
 9 | 		System.out.println(t.equals(t1));
10 | 		System.out.println(t==t1);
11 | 		t.output();
12 | 		t1.output();
13 | 		System.out.println(t.hashCode());
14 | 		System.out.println(t1.hashCode());
15 | 	}
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/stream/StreamDemoList.java:
--------------------------------------------------------------------------------
 1 | package stream;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.List;
 5 | import java.util.stream.Collectors;
 6 | 
 7 | public class StreamDemoList {
 8 | 
 9 | 	public static void main(String[] args) {
10 | 		// TODO Auto-generated method stub
11 | 
12 | 		ArrayList<Integer> al = new ArrayList<Integer>();
13 | 		al.add(10);
14 | 		al.add(20);
15 | 		al.add(30);
16 | 		al.add(15);
17 | 		al.add(25);
18 | 		al.add(35);
19 | 		List<Integer> alOdd = al.stream().filter(I->I%2!=0).collect(Collectors.toList());  // adds only those objects which fulfil condition
20 | 		System.out.println(alOdd);
21 | 		al.forEach(x->System.out.println(x));
22 | 		List<Integer> alsquare = al.stream().map(I->I*I).collect(Collectors.toList()); // add all objects after calculation
23 | 		System.out.println(alsquare);
24 | //		List<Integer> al2Elements = al.stream().flatMap(I->Stream.of(I*I,I*I*I)).collect(Collectors.toList());
25 | 		
26 | 	}
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------
/validation/Validation.java:
--------------------------------------------------------------------------------
  1 | package validation;
  2 | 
  3 | import java.util.function.Predicate;
  4 | 
  5 | public class Validation {
  6 | 	public static void main(String[] args)
  7 | 	{
  8 | 		long l = System.nanoTime();
  9 | 		System.out.println();
 10 | 		String data = "rishismile";
 11 | 		Validation1 v1 = new Validation1();
 12 | 		System.out.println(v1.usernamevalidator(data));
 13 | 		System.out.println(System.nanoTime()-l);
 14 | 	}
 15 | 	
 16 |     public boolean usernamevalidator(String data)
 17 | 	{
 18 |     	Predicate<String> p = data1 -> (data1.length() >=5 && data1.length() <=10);
 19 |     	p.test(data);
 20 | //		if(!(data.length() >=5 && data.length() <=10))
 21 | //		{
 22 | //			return false;
 23 | //		}
 24 | 		
 25 | 		for(int i=0;i<data.length();i++)
 26 | 		{
 27 | 			int asciivalue = data.charAt(i);
 28 | 			
 29 | 			if(i==0)
 30 | 			{
 31 | 				if(!(asciivalue >=65 && asciivalue <=90) && !(asciivalue >=97 && asciivalue <=122)) 	
 32 | 				{
 33 | 					return false;
 34 | 				}
 35 | 			}
 36 | 			if(!(asciivalue >=65 && asciivalue <=90)  && !(asciivalue >=97 && asciivalue <=122) && !(asciivalue >=48 && asciivalue <=57) && (asciivalue!=46) && (asciivalue!=45) && (asciivalue!=95)) 
 37 | 			{
 38 | 				return false;
 39 | 			}
 40 | 		}
 41 | 		return true;
 42 | 	}
 43 |     public boolean emailvalidator(String data)
 44 |     {
 45 |         
 46 |         int atindex = data.indexOf("@"); 
 47 |         int dotindex= data.indexOf(".");
 48 | 
 49 |         if(atindex < 0 )
 50 |         {
 51 |             return false;
 52 |             //System.out.println("@ sign does not exist");
 53 |         }
 54 |                 
 55 |         /*if(dotindex < atindex )
 56 |         {
 57 |             return false;
 58 |             //System.out.println("dot is before @ sign");
 59 |         }*/
 60 |         String com = data.substring(dotindex + 1);
 61 |         
 62 |         if(!(com.equals("com")))
 63 |         {
 64 |             //System.out.println("string not end with com=="+com);
 65 |              return false;
 66 |         }
 67 |         String username = data.substring(0, atindex);
 68 |         if(!(username.length() >=5 && username.length() <=10))
 69 |         {
 70 |             return false;
 71 |             //System.out.println("length in between 5 to 10  =>1");
 72 |         }
 73 |         for(int i=0;i< username.length() ; i++)
 74 |         {
 75 |             int asciivalue = username.charAt(i);
 76 |             if(i==0)
 77 |             {
 78 |                 if(!(asciivalue >=97 && asciivalue <=122) && !(asciivalue >=65 && asciivalue <=90))     
 79 |                 {
 80 |                     return false;
 81 |                     //System.out.println("first character must be alphabet 1");
 82 |                 }
 83 |             }
 84 | 	    else
 85 |             {
 86 | 		if(!(asciivalue >=65 && asciivalue <=90)  && !(asciivalue >=97 && asciivalue <=122) && !(asciivalue >=48 && asciivalue <=57) && (asciivalue!=46) && (asciivalue!=45) && (asciivalue!=95)) 
 87 | 		{
 88 | 			return false;
 89 | 			//System.out.println("incorrext condition");
 90 | 		}
 91 |             } 
 92 |         }
 93 |         String domainname = data.substring(atindex+1, dotindex);
 94 | 
 95 |         if(!(domainname.length() >=5 && domainname.length() <=10))
 96 |         {
 97 |             return false;
 98 |             //System.out.println("length in between 5 to 10 = >2");
 99 |         }
100 |         for(int i=0;i< domainname.length() ; i++)
101 |         {
102 |             int asciivalue = domainname.charAt(i);
103 |             
104 |             if(i==0)
105 |             {
106 | 		if(!(asciivalue >=97 && asciivalue <=122) && !(asciivalue >=65 && asciivalue <=90))     
107 |                 {
108 |                     return false;
109 |                     //System.out.println("first character must be alphabet 1");
110 |                 }
111 |             }
112 |             else
113 |             {
114 |                 if(!(asciivalue >=65 && asciivalue <=90)  && !(asciivalue >=97 && asciivalue <=122) && !(asciivalue >=48 && asciivalue <=57)) 
115 | 		{
116 | 			return false;
117 | 			//System.out.println("incorrext condition");
118 | 		}
119 |             }
120 |         }
121 | 
122 |         return true;
123 |     }
124 |    public boolean datevalidator(String data)
125 |     {
126 | 	if(!(data.length() ==10))
127 | 	{
128 | 		return false;
129 | 	}
130 | 	for(int i=0;i<data.length();i++)
131 | 	{
132 | 		int asciivalue = data.charAt(i);
133 | 			//System.out.println(asciivalue+"====");
134 | 		if(i==2 || i==5)
135 | 		{	
136 |                     int asciivalue2 = data.charAt(2);
137 |                     if(!(asciivalue ==47 || asciivalue ==92 || asciivalue ==46 || asciivalue ==45)) 	
138 |                     {
139 | 			//System.out.println("incorrect symbol");
140 |                         return false;
141 |                     }
142 |                     else if( asciivalue2  != asciivalue && i==5)
143 |                     {
144 | 			//System.out.println("not match 2nd symbol with 5th");
145 | 			return false;	
146 |                     }
147 | 		}
148 | 		else if(!(asciivalue >=48 && asciivalue <=57))
149 | 		{
150 | 				//System.out.println("not number");	
151 | 				return false;
152 | 		}
153 | 			
154 | 	}
155 | 		return true;
156 |     }
157 |     public boolean passwordValidation(String password,String confirmPassword)
158 |     {
159 |         if(password.equals(confirmPassword))
160 |         {
161 |             return true;
162 |         }
163 |         return false;
164 |     }
165 |    
166 | }
167 | 


--------------------------------------------------------------------------------
/validation/ValidationOld.java:
--------------------------------------------------------------------------------
  1 | package validation;
  2 | 
  3 | public class ValidationOld{
  4 | 	
  5 | 	public static void main(String[] args)
  6 | 	{
  7 | 		long l = System.nanoTime();
  8 | 		System.out.println();
  9 | 		String data = "rishismile";
 10 | 		Validation1 v1 = new Validation1();
 11 | 		System.out.println(v1.usernamevalidator(data));
 12 | 		System.out.println(System.nanoTime()-l);
 13 | 	}
 14 | 	
 15 | }
 16 | class Validation1 {
 17 |     public boolean usernamevalidator(String data)
 18 | 	{
 19 | 		if(!(data.length() >=5 && data.length() <=10))
 20 | 		{
 21 | 			return false;
 22 | 		}
 23 | 		
 24 | 		for(int i=0;i<data.length();i++)
 25 | 		{
 26 | 			int asciivalue = data.charAt(i);
 27 | 			
 28 | 			if(i==0)
 29 | 			{
 30 | 				if(!(asciivalue >=65 && asciivalue <=90) && !(asciivalue >=97 && asciivalue <=122)) 	
 31 | 				{
 32 | 					return false;
 33 | 				}
 34 | 			}
 35 | 			if(!(asciivalue >=65 && asciivalue <=90)  && !(asciivalue >=97 && asciivalue <=122) && !(asciivalue >=48 && asciivalue <=57) && (asciivalue!=46) && (asciivalue!=45) && (asciivalue!=95)) 
 36 | 			{
 37 | 				return false;
 38 | 			}
 39 | 		}
 40 | 		return true;
 41 | 	}
 42 |     public boolean emailvalidator(String data)
 43 |     {
 44 |         
 45 |         int atindex = data.indexOf("@"); 
 46 |         int dotindex= data.indexOf(".");
 47 | 
 48 |         if(atindex < 0 )
 49 |         {
 50 |             return false;
 51 |             //System.out.println("@ sign does not exist");
 52 |         }
 53 |                 
 54 |         /*if(dotindex < atindex )
 55 |         {
 56 |             return false;
 57 |             //System.out.println("dot is before @ sign");
 58 |         }*/
 59 |         String com = data.substring(dotindex + 1);
 60 |         
 61 |         if(!(com.equals("com")))
 62 |         {
 63 |             //System.out.println("string not end with com=="+com);
 64 |              return false;
 65 |         }
 66 |         String username = data.substring(0, atindex);
 67 |         if(!(username.length() >=5 && username.length() <=10))
 68 |         {
 69 |             return false;
 70 |             //System.out.println("length in between 5 to 10  =>1");
 71 |         }
 72 |         for(int i=0;i< username.length() ; i++)
 73 |         {
 74 |             int asciivalue = username.charAt(i);
 75 |             if(i==0)
 76 |             {
 77 |                 if(!(asciivalue >=97 && asciivalue <=122) && !(asciivalue >=65 && asciivalue <=90))     
 78 |                 {
 79 |                     return false;
 80 |                     //System.out.println("first character must be alphabet 1");
 81 |                 }
 82 |             }
 83 | 	    else
 84 |             {
 85 | 		if(!(asciivalue >=65 && asciivalue <=90)  && !(asciivalue >=97 && asciivalue <=122) && !(asciivalue >=48 && asciivalue <=57) && (asciivalue!=46) && (asciivalue!=45) && (asciivalue!=95)) 
 86 | 		{
 87 | 			return false;
 88 | 			//System.out.println("incorrext condition");
 89 | 		}
 90 |             } 
 91 |         }
 92 |         String domainname = data.substring(atindex+1, dotindex);
 93 | 
 94 |         if(!(domainname.length() >=5 && domainname.length() <=10))
 95 |         {
 96 |             return false;
 97 |             //System.out.println("length in between 5 to 10 = >2");
 98 |         }
 99 |         for(int i=0;i< domainname.length() ; i++)
100 |         {
101 |             int asciivalue = domainname.charAt(i);
102 |             
103 |             if(i==0)
104 |             {
105 | 		if(!(asciivalue >=97 && asciivalue <=122) && !(asciivalue >=65 && asciivalue <=90))     
106 |                 {
107 |                     return false;
108 |                     //System.out.println("first character must be alphabet 1");
109 |                 }
110 |             }
111 |             else
112 |             {
113 |                 if(!(asciivalue >=65 && asciivalue <=90)  && !(asciivalue >=97 && asciivalue <=122) && !(asciivalue >=48 && asciivalue <=57)) 
114 | 		{
115 | 			return false;
116 | 			//System.out.println("incorrext condition");
117 | 		}
118 |             }
119 |         }
120 | 
121 |         return true;
122 |     }
123 |    public boolean datevalidator(String data)
124 |     {
125 | 	if(!(data.length() ==10))
126 | 	{
127 | 		return false;
128 | 	}
129 | 	for(int i=0;i<data.length();i++)
130 | 	{
131 | 		int asciivalue = data.charAt(i);
132 | 			//System.out.println(asciivalue+"====");
133 | 		if(i==2 || i==5)
134 | 		{	
135 |                     int asciivalue2 = data.charAt(2);
136 |                     if(!(asciivalue ==47 || asciivalue ==92 || asciivalue ==46 || asciivalue ==45)) 	
137 |                     {
138 | 			//System.out.println("incorrect symbol");
139 |                         return false;
140 |                     }
141 |                     else if( asciivalue2  != asciivalue && i==5)
142 |                     {
143 | 			//System.out.println("not match 2nd symbol with 5th");
144 | 			return false;	
145 |                     }
146 | 		}
147 | 		else if(!(asciivalue >=48 && asciivalue <=57))
148 | 		{
149 | 				//System.out.println("not number");	
150 | 				return false;
151 | 		}
152 | 			
153 | 	}
154 | 		return true;
155 |     }
156 |     public boolean passwordValidation(String password,String confirmPassword)
157 |     {
158 |         if(password.equals(confirmPassword))
159 |         {
160 |             return true;
161 |         }
162 |         return false;
163 |     }
164 |    
165 | }
166 | 
167 | 


--------------------------------------------------------------------------------
/vararg/HeapPollution.java:
--------------------------------------------------------------------------------
 1 | package vararg;
 2 | 
 3 | import java.util.ArrayList;
 4 | 
 5 | public class HeapPollution 
 6 | {
 7 | 	@SafeVarargs
 8 | 	public static void display(ArrayList<String>...pr)
 9 | 	{
10 | 		for(ArrayList<String> x:pr)
11 | 		{
12 | 		System.out.println(x);
13 | 		}
14 | 	}
15 | 	
16 | 	public static void main(String[] args) 
17 | 	{
18 | 		ArrayList<String> al = new ArrayList<String>();
19 | 		al.add("Raj");
20 | 		al.add("Rama");
21 | 		display(al);
22 | 	}
23 | 
24 | }
25 | 


--------------------------------------------------------------------------------
/vararg/VarArg.java:
--------------------------------------------------------------------------------
 1 | package vararg;
 2 | 
 3 | import java.util.ArrayList;
 4 | 
 5 | public class VarArg 
 6 | {
 7 | 	public static void m1()
 8 | 	{
 9 | 		Integer i =100;
10 | 		String s1 = String.valueOf(i);
11 | 		
12 | 	}
13 | 	
14 | 	public static void sum(int... x)     // or sum(int[] x) anyone will work
15 | 	{
16 | 		int sum=0;
17 | 		for(int i=0;i<x.length;i++)
18 | 		{
19 | 			sum=sum+x[i];
20 | 		}
21 | 		System.out.println(sum);
22 | 	}
23 | 
24 | 	public static void main(String[] args) 
25 | 	{
26 | 		sum();
27 | 		sum(10);
28 | 		sum(10,20);
29 | 		sum(10,20,30);
30 | 		sum(10,20,30,40);
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/wrapper/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 |  * 
3 |  */
4 | /**
5 |  * @author hp
6 |  *
7 |  */
8 | package wrapper;


--------------------------------------------------------------------------------
/wrapper/wrapper.java:
--------------------------------------------------------------------------------
 1 | package wrapper;
 2 | 
 3 | public class wrapper {
 4 | 
 5 | 	public static void main(String[] args)
 6 | 	{
 7 | 		// TODO Auto-generated method stub
 8 | 		Integer I1 = new Integer(200);
 9 | 		int i1 = 100;
10 | 		String s1 = "300";
11 | 	//	Primitive to string and wrapper
12 | 		String s2 = String.valueOf(i1);
13 | 		//String s4 = i1.toString();
14 | 		//Integer I2 = Integer.valueOf(i1);
15 | 		Integer I2=i1;
16 | 		System.out.println(I2);
17 | 	// 	Wrapper to primitive and string
18 | 		//int i2 = I1.intValue();
19 | 		int i2=I1;
20 | 		System.out.println(i2);
21 | 		String s3 = I1.toString();
22 | 	//  String to primitive and wrapper	
23 | 		int i3 = Integer.parseInt(s1);
24 | 		Integer I3 = Integer.valueOf(s1);
25 | 		
26 | 	}
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------