more book ideas

Author: benblack86

.classpath

@@ -2,7 +2,7 @@
 <classpath>
 	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="src" path="resources"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
 	<classpathentry kind="lib" path="libs/commons-codec-1.7.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

src/benblack86/collection/MergeCollections.java

@@ -0,0 +1,54 @@
+package benblack86.collection;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+public class MergeCollections {
+	public static void main(String[] args) {
+		Collection<Double> list1 = Arrays.asList(1.0, 5.0, 10.0);
+		Collection<Double> list2 = Arrays.asList(7.0, 8.0, 100.0, 101.0);
+		
+		System.out.println(MergeCollections.merge(list1, list2));
+		
+	}
+	
+	
+	public static <T extends Comparable<? super T>> List<T> merge(Collection<? extends T> c1, Collection<? extends T> c2) {
+		List<T> mergedList = new ArrayList<T>();
+		Iterator<? extends T> itr1 = c1.iterator();
+		Iterator<? extends T> itr2 = c2.iterator();
+		T element1 = getNextElement(itr1);
+		T element2 = getNextElement(itr2);
+		
+		while (element1 != null || element2 != null) {
+			boolean useElement1 = (element2 == null || element1 != null && element1.compareTo(element2) < 0);
+			
+			if(useElement1) {
+				mergedList.add(element1);
+				element1 = getNextElement(itr1);
+			} else {
+				mergedList.add(element2);
+				element2 = getNextElement(itr2);
+			}
+		}
+		
+		return mergedList;
+	}
+	
+	private static <E> E getNextElement(Iterator<E> itr) {
+		if (itr.hasNext()) {
+			E element = itr.next();
+			
+			if (element == null) {
+				throw new NullPointerException();
+			}
+			
+			return element;
+		}
+		
+		return null;
+	}
+}

src/benblack86/java/Reflection.java

@@ -0,0 +1,71 @@
+package benblack86.java;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+
+public class Reflection {
+
+	public static void main(String[] args) {
+		try {
+			System.out.println(GenericReflection.newInstance(new String()));
+			
+			System.out.println(GenericReflection.getComponentType(new String[0]));
+			
+			System.out.println(Arrays.toString(GenericReflection.newArray(String.class, 10)));
+			
+			System.out.println(Arrays.toString(GenericReflection.newArray(new Integer[0], 100)));
+			
+			Collection<String> items = new ArrayList<String>();
+			items.add("hi");
+			Collection<String> items2 = Reflection.copy(items);
+			items.add("bye");
+			System.out.println(items2);
+			
+		} catch (Throwable t) {
+			t.printStackTrace();
+		}
+	}
+	
+	public static <T, C extends Collection<T>> C copy(C collection) throws Exception {
+		// GenericReflection class hides the unchecked cast
+		C copy = GenericReflection.newInstance(collection);
+		copy.addAll(collection);
+		return copy;
+	}
+
+}
+
+/*
+ * The idea is to encapsulate unchecked casts into a number of library methods
+ */
+class GenericReflection {
+	@SuppressWarnings("unchecked")
+	public static <T> T newInstance(T obj) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, SecurityException, NoSuchMethodException {
+		// can only handle zero-argument constructors
+		Object newObj = obj.getClass().getConstructor(new Class<?>[]{}).newInstance();
+		return (T)newObj; // unchecked cast
+	}
+	
+	@SuppressWarnings("unchecked")
+	public static <T> Class<? extends T> getComponentType(T[] a) {
+		Class<?> k = a.getClass().getComponentType();
+		return (Class<? extends T>)k; // unchecked cast
+	}
+	
+	@SuppressWarnings("unchecked")
+	public static <T> T[] newArray(Class<? extends T> k, int size) {
+		if (k.isPrimitive()) {
+			throw new IllegalArgumentException("Argument cannot be primitive");
+		}
+		
+		Object a = Array.newInstance(k, size);
+		return (T[])a; // unchecked cast
+	}
+	
+	public static <T> T[] newArray(T[] a, int size) {
+		return GenericReflection.newArray(GenericReflection.getComponentType(a), size);
+	}
+}

src/benblack86/java/Reification.java

@@ -0,0 +1,75 @@
+package benblack86.java;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+public class Reification {
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		Collection<String> collection = Arrays.asList("hi", "there");
+		List<String> list = Reification.asList(collection);
+		System.out.println(list);
+		
+		List<Object> objects = Arrays.<Object>asList("three", "four");
+		List<String> strings = Reification.promote(objects);
+		System.out.println(strings);
+		
+		String[] stringArray = Reification.toArray(strings, new String[0]);
+		System.out.println(Arrays.toString(stringArray));
+		
+		String[] stringArray2 = Reification.toArray(strings, String.class);
+		System.out.println(Arrays.toString(stringArray2));
+	}
+
+	public static <T> List<T> asList(Collection<T> collection) {
+		// cannot do List<T> as information is erased
+		if (collection instanceof List<?>) {
+			// can cast using T as the argument expects T
+			return (List<T>) collection;
+		} else {
+			throw new IllegalArgumentException("Argument not a list");
+		}
+	}
+	
+	@SuppressWarnings("unchecked")
+	public static List<String> promote(List<Object> objs) {
+		for (Object obj : objs) {
+			if (!(obj instanceof String)) {
+				throw new ClassCastException();
+			}
+		}
+		
+		return (List<String>)(List<?>)objs; // unchecked cast
+	}
+	
+	@SuppressWarnings("unchecked")
+	public static <T> T[] toArray(Collection<T> collection, T[] a) {
+		if (a.length < collection.size()) {
+			a = (T[])Array.newInstance(a.getClass().getComponentType(), collection.size()); // unchecked cast
+		}
+		
+		int i = 0;
+		for(T element : collection) {
+			a[i++] = element;
+		}
+		
+		return a;
+	}
+	
+	@SuppressWarnings("unchecked")
+	public static <T> T[] toArray(Collection<T> collection, Class<T> c) {
+		T[] a = (T[])Array.newInstance(c, collection.size()); // unchecked cast
+		
+		int i = 0;
+		for(T element : collection) {
+			a[i++] = element;
+		}
+		
+		return a;
+	}
+}

src/benblack86/java/Varargs.java

@@ -11,6 +11,7 @@ public static void main(String[] args) {
 		System.out.println(Varargs.toList(new Object[]{}));
 	}
 
+	@SafeVarargs
 	public static <T> List<T> toList(T... array) {
 		List<T> list = new ArrayList<T>();
 

src/benblack86/java/Wildcards.java

@@ -13,6 +13,7 @@ public class Wildcards {
 	 * 
 	 */
 	public static void main(String[] args) {
+		// cannot use Arrays.asList as it returns a structure that can not be added to
 		List<Number> items = new ArrayList<Number>();
 		items.add(3);
 		items.add(8.0);

src/benblack86/pattern/Functions.java

@@ -0,0 +1,61 @@
+package benblack86.pattern;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Functions {
+
+	/*
+	 * Function pattern: converts arbitrary method into an object
+	 */
+	
+	public static void main(String[] args) {
+		Function<String, Integer, Error> length = new Function<String, Integer, Error>() {
+			public Integer apply(String s) {
+				return s.length();
+			}
+		};
+		
+		Function<String, Class<?>, ClassNotFoundException> forName = new Function<String, Class<?>, ClassNotFoundException>() {
+			public Class<?> apply(String s) throws ClassNotFoundException {
+				return Class.forName(s);
+			}
+		};
+		
+		Function<String, Method, Exception> getRunMethod = new Function<String, Method, Exception>() {
+			public Method apply(String s) throws ClassNotFoundException, NoSuchMethodException {
+				return Class.forName(s).getMethod("run");
+			}
+		};
+		
+		try {
+			List<String> strings = Arrays.asList("java.lang.Thread", "java.lang.Runnable");
+			
+			System.out.println(applyAll(length, strings));
+			
+			System.out.println(applyAll(forName, strings));
+			
+			System.out.println(applyAll(getRunMethod, strings));
+			
+		} catch(Throwable t) {
+			t.printStackTrace();
+		}
+	}
+
+	public static <A, B, X extends Throwable> List<B> applyAll(Function<A, B, X> f, List<A> list) throws X {
+		List<B> results = new ArrayList<B>();
+		
+		for(A a : list) {
+			results.add(f.apply(a));
+		}
+		
+		return results;
+	}
+}
+
+interface Function<A, B, X extends Throwable> {
+	public B apply(A a) throws X;
+}
+

src/benblack86/pattern/Interpreter.java

@@ -0,0 +1,76 @@
+package benblack86.pattern;
+
+public class Interpreter {
+	/*
+	 * Interpreter design pattern: specifies how to evaluate sentences in a language
+	 */
+	
+	public static void main(String[] args) {
+		Exp<Integer> e = Exp.left(Exp.pair(Exp.plus(Exp.num(3), Exp.num(4)), Exp.num(5)));
+		
+		System.out.println(e.eval());
+	}
+
+}
+
+class Pair<A, B> {
+	private final A left;
+	private final B right;
+	
+	public Pair(A left, B right) {
+		this.left = left;
+		this.right = right;
+	}
+	
+	public A left() {
+		return left;
+	}
+	
+	public B right() {
+		return right;
+	}
+}
+
+abstract class Exp<T> {
+	abstract public T eval();
+	
+	public static Exp<Integer> num(final int i) {
+		return new Exp<Integer>() {
+			public Integer eval() {
+				return i;
+			}
+		};
+	}
+	
+	public static Exp<Integer> plus(final Exp<Integer> e1, final Exp<Integer> e2) {
+		return new Exp<Integer>() {
+			public Integer eval() {
+				return e1.eval()+e2.eval();
+			}
+		};
+	}
+	
+	public static <A, B> Exp<Pair<A, B>> pair(final Exp<A> e1, final Exp<B> e2) {
+		return new Exp<Pair<A, B>>() {
+			public Pair<A, B> eval() {
+				return new Pair<A, B>(e1.eval(), e2.eval());
+			}
+		};
+	}
+	
+	public static <A, B> Exp<A> left(final Exp<Pair<A, B>> e) {
+		return new Exp<A>() {
+			public A eval() {
+				return e.eval().left();
+			}
+		};
+	}
+	
+	public static <A, B> Exp<B> right(final Exp<Pair<A, B>> e) {
+		return new Exp<B>() {
+			public B eval() {
+				return e.eval().right();
+			}
+		};
+	}
+}