java demo

Author: Juude

Diff for: .classpath

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

Diff for: .project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>JavaPractices</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

Diff for: .settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,12 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.7

Diff for: .settings/org.eclipse.ltk.core.refactoring.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=false

Diff for: bin/net/juude/java/generics/CollectionUtils$1.class

@@ -0,0 +1,51 @@
+package net.juude.java.generics;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+
+public class CollectionUtils {
+	
+	@SuppressWarnings("unchecked")
+	public static <T> Collection<T> filter(Collection<T> collection, Predicate<T> predicate) {
+		if(collection == null || predicate == null) {
+			return null;
+		}
+		Collection<T> resultCollections = null; 
+		try {
+			resultCollections = collection.getClass().newInstance();
+		} catch (InstantiationException e) {
+			e.printStackTrace();
+			return null;
+		} catch (IllegalAccessException e) {
+			e.printStackTrace();
+			return null;
+		}
+		for(T item : collection) {
+			if(predicate.apply(item)) {
+				resultCollections.add(item);
+			}
+		}
+		return resultCollections;
+	}
+	
+	public static void main(String[] args) {
+		ArrayList<String> strings= new ArrayList<String>();
+		strings.add("a");
+		strings.add("b");
+		strings.add("abd");
+		strings.add("c");
+		strings.add("jlsf");
+		strings.add("f");
+		strings.add(null);
+		strings.add("null");
+		Collection<String> s = filter(strings, new Predicate<String>() {
+			@Override
+			public boolean apply(String input) {
+				return input != null && input.length() == 1;
+			}
+		});
+		System.out.println(strings);
+		System.out.println(s + "  " + s.getClass());
+	}
+}

Diff for: bin/net/juude/java/generics/CollectionUtils.class

@@ -0,0 +1,50 @@
+package net.juude.java.generics;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Why generics
+ * 1. type cast
+ * 2. type check 
+ * 		1. bound 
+ *      2. 
+ * 3. 
+ * */
+public class Generics<T> {
+	private T mValue;
+	
+	public Generics() {
+	}
+	
+	public void setValue(T value) {
+		mValue = value;
+	}
+	
+	public T getValue() {
+		return mValue;
+	}
+	
+	public static void main(String[] args) {
+		
+		//int value
+		Generics<Integer> intValue = new Generics<Integer>();
+		intValue.setValue(100);
+		System.out.println("intValue : " + intValue.getValue());
+		
+		//String this will not compile
+		//intValue.setValue("ff");
+		
+		//bounds
+		Generics<? extends Number> numValue = new Generics<Integer>(); //ok
+		//Generics<? extends Number> numValue2 = new Generics<String>();//error
+
+	}
+	
+	private void testLinkedHashMap() {
+		LinkedHashMap map = new LinkedHashMap();
+		map.put(1, "fsf");
+		map.put("sdf", "");
+	}
+}

Diff for: bin/net/juude/java/generics/Generics.class

@@ -0,0 +1,21 @@
+package net.juude.java.generics;
+
+/**
+ * Determines a true or false value for a given input.
+ *
+ * <p>The {@link Predicates} class provides common predicates and related utilities.
+ *
+ * <p>See the Guava User Guide article on <a href=
+ * "http://code.google.com/p/guava-libraries/wiki/FunctionalExplained">the use of {@code
+ * Predicate}</a>.
+ *
+ * @author Kevin Bourrillion
+ * @since 2.0
+ */
+public interface Predicate<T> {
+
+  boolean apply( T input);
+
+  @Override
+  boolean equals(Object object);
+}

Diff for: bin/net/juude/java/generics/Predicate.class

@@ -0,0 +1,41 @@
+package net.juude.java.math;
+
+public class Angle {
+	
+	public static void main(String[] args) {
+		float[] startPoint = new float[]{-1, -1};
+		float[] endPoint = new float[] {-2, -2};
+		System.out.println(" angle" + getAngle(startPoint, endPoint));
+		
+		float[] startPoint2 = new float[]{0, 0};
+		float[] endPoint2 = new float[] {0.8660254037844386f, 0.5f};
+		System.out.println(" angle2 : " + getAngle(startPoint2, endPoint2));
+		
+		
+		System.out.println(" differnece of 1 and 359 is : " + getAngleDifference(1, 359));
+		System.out.println(" differnece of 359 and 1 is : " + getAngleDifference(359, 1));
+		System.out.println(" differnece of 30 and 180 is : " + getAngleDifference(30, 180));
+
+	}
+	
+	//get angle of the line
+	public static double getAngle(float[] startAngle, float[] endAngle) {
+		float distance = (float) Math.sqrt((endAngle[0] - startAngle[0]) * (endAngle[0] - startAngle[0]) + (endAngle[1] - startAngle[1]) * (endAngle[1] - startAngle[1]));
+		if(distance == 0) {
+			return 0;
+		}
+		float sinx = (endAngle[1] - startAngle[1])/distance;
+		float cosx =  (endAngle[0] - startAngle[0])/distance;
+		return Math.atan2(sinx, cosx)/Math.PI*180;
+	}
+	
+	public static float getAngleDifference(float firstAngle, float secondAngle) {
+		float difference = secondAngle - firstAngle;
+		if(difference > 180) {
+			difference -= 360;
+		}else if(difference < -180) {
+			difference += 360;
+		}
+		return difference;
+	}
+}