code examples from Java Generics and Collections book

Author: benblack86

.classpath

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <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="lib" path="libs/commons-codec-1.7.jar"/>
 	<classpathentry kind="output" path="bin"/>

resources/MultipleBounds.file.in.txt

@@ -0,0 +1 @@
+Hello World

resources/MultipleBounds.file.out.txt

@@ -0,0 +1 @@
+Hello World

src/benblack86/java/Bridge.java

@@ -0,0 +1,28 @@
+package benblack86.java;
+
+import java.lang.reflect.Method;
+
+public class Bridge {
+	public static void main(String[] args) {
+		for(Method m : Point.class.getMethods()) {
+			if(m.getName().equals("clone") || m.getName().equals("compareTo")) {
+				System.out.println(m.toGenericString());
+			}
+		}
+	}
+
+}
+
+class Point implements Comparable<Point> {
+
+	@Override
+	public int compareTo(Point point) {
+		return 0;
+	}
+	
+	@Override
+	public Point clone() {
+		return new Point();
+	}
+	
+}

src/benblack86/java/MultipleBounds.java

@@ -0,0 +1,39 @@
+package benblack86.java;
+
+import java.io.Closeable;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.CharBuffer;
+
+
+public class MultipleBounds {
+
+	public static void main(String[] args) {
+		try {
+			FileReader r = new FileReader("resources/MultipleBounds.file.in.txt");
+			FileWriter w = new FileWriter("resources/MultipleBounds.file.out.txt");
+			
+			copy(r, w);
+		
+		} catch(Throwable t) {
+			t.printStackTrace();
+		}
+	}
+
+	public static <S extends Readable & Closeable, T extends Appendable & Closeable> void copy(S src, T trg) throws IOException {
+		try {
+			CharBuffer buf = CharBuffer.allocate(32);
+			
+			while(src.read(buf) >= 0) {
+				buf.flip(); // prepare buffer for writing
+				trg.append(buf);
+				buf.clear(); // prepare buffer for reading
+			}
+		} finally {
+			// not good design as resources should be open and closed in the same block
+			src.close();
+			trg.close();
+		}
+	}
+}

src/benblack86/java/StaticNestedClass.java

@@ -0,0 +1,96 @@
+package benblack86.java;
+
+import java.util.AbstractCollection;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public class StaticNestedClass {
+	/*
+	 * Nested classes: way of logically grouping classes that are only used in one
+	 * place, increase encapsulation, lead to more readable and maintainable code
+	 * Static: cannot refer directly to instance variables or methods defined in
+	 * its enclosing class, behave like top level classes, more efficient
+	 */
+	
+	public static void main(String args[]) { 
+		Collection<String> items = new LinkedCollection<String>();
+		items.add("hello");
+		items.add("world");
+		
+		for(String item : items) {
+			System.out.println(item);
+		}
+	}
+}
+
+
+class LinkedCollection<E> extends AbstractCollection<E> {
+	private static class Node<T> {
+		private T element;
+		private Node<T> next = null;
+		
+		private Node(T element) {
+			this.element = element;
+		}
+	}
+	
+	private Node<E> first = new Node<E>(null);
+	private Node<E> last = first;
+	private int size = 0;
+	
+	public LinkedCollection() {}
+	
+	public LinkedCollection(Collection<? extends E> collection) {
+		// extends E means we can get elements out of the collection
+		this.addAll(collection);
+	}
+
+	@Override
+	public int size() {
+		return this.size;
+	}
+	
+	@Override
+	public boolean add(E element) {
+		this.last.next = new Node<E>(element);
+		this.last = this.last.next;
+		this.size++;
+		return true;
+	}
+	
+	private static class LinkedIterator<T> implements Iterator<T> {
+		private Node<T> current;
+		
+		public LinkedIterator(Node<T> first) {
+			this.current = first;
+		}
+		
+		@Override
+		public boolean hasNext() {
+			return current.next != null;
+		}
+
+		@Override
+		public T next() {
+			if (hasNext()) {
+				current = current.next;
+				return current.element;
+			} else {
+				throw new NoSuchElementException();
+			}
+		}
+
+		@Override
+		public void remove() {
+			throw new UnsupportedOperationException();
+		}
+		
+	}
+	
+	@Override
+	public Iterator<E> iterator() {
+		return new LinkedIterator<E>(first);
+	}
+
+}

src/benblack86/java/Varargs.java

@@ -0,0 +1,23 @@
+package benblack86.java;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Varargs {
+	public static void main(String[] args) {
+		System.out.println(Varargs.toList(new String[]{"one", "two"}));
+		// System.out.println(Varargs.toList(null)); runtime exception
+		System.out.println(Varargs.toList(new Object[]{null}));
+		System.out.println(Varargs.toList(new Object[]{}));
+	}
+	
+	public static <T> List<T> toList(T... array) {
+		List<T> list = new ArrayList<T>();
+		
+		for(T element : array) {
+			list.add(element);
+		}
+		
+		return list;
+	}
+}

src/benblack86/java/Wildcards.java

@@ -0,0 +1,37 @@
+package benblack86.java;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Wildcards {
+
+	/*
+	 * The Get and Put principle: use an extends wildcard when you only get values
+	 * out of a structure, use a super wildcard when you only put values into a
+	 * structure, and don't use a wildcard when you both get and put.
+	 * 
+	 */
+	public static void main(String[] args) {
+		List<Number> items = new ArrayList<Number>();
+		items.add(3);
+		items.add(8.0);
+		items.add(989898979879879879l);
+		
+		System.out.println(items);
+		
+		List<Double> more = Arrays.asList(3.0, 3.9, 8.0);
+		
+		Wildcards.copy(items, more);
+		
+		System.out.println(items);
+	}
+	
+	
+	public static <T> void copy(List<? super T> dest, List<? extends T> src) {
+		for(T element : src) {
+			dest.add(element);
+		}
+	}
+
+}