Generics and Collections

Author: turingfly

Java-8/src/genericsAndCollections/ArrayAndArrayList.java

@@ -0,0 +1,29 @@
+package genericsAndCollections;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 7, 2017 5:06:24 PM
+ * 
+ *         An ArrayList cannot contain primitives.
+ *         An Array can contain objects and primitives.
+ */
+public class ArrayAndArrayList {
+	public void test() {
+		String[] array = { "a", "b" }; // [a, b]
+		// convert an Array to a List
+		List<String> list = Arrays.asList(array); // [a, b]
+		// You can change the element in either the array or the list.
+		// Changes are reflected in both, since they are backed by the same data.
+		array[0] = "c";
+		// convert a List to an Array
+		
+		String[] array2 = (String[]) list.toArray(); // [c, b]
+		
+		// list.remove(1); throws UnsupportedOperationException
+		// list is not resizable because it is backed by the underlying array.
+	}
+}

Java-8/src/genericsAndCollections/ComparingMultipleFields.java

@@ -0,0 +1,41 @@
+package genericsAndCollections;
+
+import java.util.Comparator;
+
+/**
+ * 
+ * @author chengfeili
+ * Jun 7, 2017 9:22:16 PM
+ *
+ */
+
+public class ComparingMultipleFields implements Comparator<Squirrel> {
+	public int compare(Squirrel s1, Squirrel s2) {
+		Comparator<Squirrel> c = Comparator.comparing(s -> s.getSpecies());
+		c = c.thenComparingInt(s -> s.getWeight());
+		return c.compare(s1, s2);
+	}
+}
+
+class Squirrel {
+	private int weight;
+	private String species;
+
+	public Squirrel(String theSpecies) {
+		if (theSpecies == null)
+			throw new IllegalArgumentException();
+		species = theSpecies;
+	}
+
+	public int getWeight() {
+		return weight;
+	}
+
+	public void setWeight(int weight) {
+		this.weight = weight;
+	}
+
+	public String getSpecies() {
+		return species;
+	}
+}

Java-8/src/genericsAndCollections/GenericBound.java

@@ -0,0 +1,87 @@
+package genericsAndCollections;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 7, 2017 6:12:41 PM
+ *
+ *         A bounded parameter type is a generic type that specifies a bound for
+ *         the generic. A wildcard generic type is an unknown generic type
+ *         represented with a question mark ( ? ).
+ * 
+ *         class A {} 
+ *         class B extends A { } 
+ *         class C extends B { }
+ * 
+ *         List<?> list1 = new ArrayList<A>(); 
+ *         List<? extends A> list2 = new ArrayList<A>(); 
+ *         List<? super A> list3 = new ArrayList<A>(); 
+ *         List<? extends B> list4 = new ArrayList<A>(); It has an upper-bounded wildcard that allows ArrayList<B> or ArrayList<C> to be referenced.
+ *         List<? super B> list5 = new ArrayList<A>(); 
+ *         List<?> list6 = new ArrayList<? extends A>(); The problem is that you need to know what
+ *         that type will be when instantiating the ArrayList.
+ * 
+ */
+public class GenericBound {
+	/*
+	 * We can’t write List<Object> l = new ArrayList<String>(); because Java is
+	 * trying to protect us from a runtime exception.
+	 */
+	public static void printList(List<Object> list) {
+		for (Object x : list)
+			System.out.println(x);
+	}
+
+	// 1. Unbounded Wildcards
+	public static void printList1(List<?> list) {
+		for (Object x : list)
+			System.out.println(x);
+	}
+
+	/**
+	 * 2. Upper-Bounded Wildcards
+	 * The upper-bounded wildcard says that any class
+	 * that extends Number or Number itself can be used as the formal parameter type:
+	 * 
+	 * static class Sparrow extends Bird { } 
+	 * static class Bird { } 
+	 * public static void main(String[] args) {
+	 * List<? extends Bird> birds = new ArrayList <Bird>(); 
+	 * birds.add(new Sparrow()); // DOES NOT COMPILE birds.add(new
+	 * Bird()); // DOES NOT COMPILE
+	 * 
+	 * The problem stems from the fact that Java doesn’t know what type List<?
+	 * extends Bird> really is. It could be List<Bird> or List<Sparrow> or some
+	 * other generic type that hasn’t even been written yet. Line 7 doesn’t
+	 * compile because we can’t add a Sparrow to List<Bird> , and line 8 doesn’t
+	 * compile because we can’t add a Bird to List<Sparrow> .
+	 * 
+	 * private void groupOfFlyers(List<? extends Flyer> flyer) {}Note that we
+	 * used the keyword extends rather than implements .
+	 */
+	public static long total(List<? extends Number> list) {
+
+		// ArrayList<Number> list = new ArrayList<Integer>(); // DOES NOT
+		// COMPILE
+		long count = 0;
+		for (Number number : list)
+			count += number.longValue();
+		return count;
+	}
+
+	// 3. Lower-Bounded Wildcards
+	public static void addSound(List<? super String> list) {
+		list.add("quack");
+	}
+
+	public static void main(String[] args) {
+		List<String> keywords = new ArrayList<>();
+		keywords.add("java");
+		// printList(keywords); Does not compile
+		// List<String> cannot be assigned to List<Object>
+		printList1(keywords);
+	}
+}

Java-8/src/genericsAndCollections/GenericClass.java

@@ -0,0 +1,35 @@
+package genericsAndCollections;
+
+/**
+ * 
+ * @author chengfeili Jun 7, 2017 5:44:24 PM
+ * 
+ *            When you instantiate the class, you tell the compiler what T
+ *            should be for that particular instance.
+ */
+public class GenericClass<T> {
+	private T contents;
+
+	public T emptyCrate() {
+		return contents;
+	}
+
+	public void packCrate(T contents) {
+		this.contents = contents;
+	}
+	// Generic Method
+	public static <T> GenericClass<T> ship(T t) {
+		System.out.println("Preparing " + t);
+		return new GenericClass<T>();
+		}
+}
+
+class SizeLimitedCrate<T, U> {
+	private T contents;
+	private U sizeLimit;
+
+	public SizeLimitedCrate(T contents, U sizeLimit) {
+		this.contents = contents;
+		this.sizeLimit = sizeLimit;
+	}
+}

Java-8/src/genericsAndCollections/GenericInterface.java

@@ -0,0 +1,50 @@
+package genericsAndCollections;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 7, 2017 5:47:33 PM
+ *
+ *         3 ways a class can approach implementing this interface
+ * 
+ *         Here are the things that you can’t do with generics. (And by “can’t,”
+ *         we mean without resorting to contortions like passing in a class
+ *         object.) 
+ *         1. Call the constructor. new T() is not allowed because at
+ *         runtime it would be new Object() . 
+ *         2. Create an array of that static type. This one is the most annoying, but it makes sense
+ *         because you’d be creating an array of Object s. 
+ *         3. Call instanceof . This is not allowed because at runtime List<Integer> and List
+ *         <String> look the same to Java thanks to type erasure. 
+ *         4.Use a primitive type as a generic type parameter. This isn’t a big deal
+ *         because you can use the wrapper class instead. If you want a type of
+ *         int , just use Integer.
+ *         5. Create a static variable as a generic type parameter. 
+ *         This is not allowed because the type is linked to the
+ *         instance of the class.
+ */
+public interface GenericInterface<T> {
+	void ship(T t);
+}
+
+class Robot {
+
+}
+
+// Method 1: specify the generic type in the class
+class ShippableRobotCrate implements GenericInterface<Robot> {
+	public void ship(Robot t) {
+	}
+}
+
+// Method 2: create a generic class
+class ShippableAbstractCrate<U> implements GenericInterface<U> {
+	public void ship(U t) {
+	}
+}
+
+// Method 3: not use generics at all.
+class ShippableCrate implements GenericInterface {
+	public void ship(Object t) {
+	}
+}

Java-8/src/genericsAndCollections/SearchingAndSorting.java

@@ -0,0 +1,34 @@
+package genericsAndCollections;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * 
+ * @author chengfeili
+ * Jun 7, 2017 5:19:13 PM
+ *
+ *
+ */
+public class SearchingAndSorting {
+	static class A {
+		int id;
+	}
+	public void test() {
+		int[] nums = {6, 9, 1, 8};
+		Arrays.sort(nums); // [1, 6, 8, 9]
+		System.out.println(Arrays.binarySearch(nums, 6)); // 1
+		System.out.println(Arrays.binarySearch(nums, 3)); // -2  ( -1 -1 )
+	}
+	public void test2() {
+		List<A> list = new ArrayList<>();
+		list.add(new A());
+		// Collections.sort(list); Does not compile
+		Comparator<A> c = (a, b) -> a.id - b.id;
+		Collections.sort(list, c);
+		
+	}
+}

Java-8/src/genericsAndCollections/UsingComparable.java

@@ -0,0 +1,39 @@
+package genericsAndCollections;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 7, 2017 8:56:49 PM
+ *
+ */
+public class UsingComparable implements Comparable<UsingComparable> {
+
+	private String name;
+
+	public UsingComparable(String name) {
+		// TODO Auto-generated constructor stub
+		this.name = name;
+	}
+
+	public String toString() {
+		return name;
+	}
+
+	@Override
+	public int compareTo(UsingComparable o) {
+		// TODO Auto-generated method stub
+		return name.compareTo(o.name); // call String's compareTo
+	}
+
+	public static void main(String[] args) {
+		List<UsingComparable> list = new ArrayList<>();
+		list.add(new UsingComparable("b"));
+		list.add(new UsingComparable("a"));
+		Collections.sort(list); // sort by name
+		System.out.println(list); // [a, b]
+	}
+}

Java-8/src/genericsAndCollections/UsingComparable1.java

@@ -0,0 +1,27 @@
+package genericsAndCollections;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 7, 2017 9:07:21 PM
+ *
+ *         Remember that id – a.id sorts in ascending order and a.id – id sorts
+ *         in descending order.
+ */
+public class UsingComparable1 implements Comparable<UsingComparable1> {
+	private int id;
+
+	public int compareTo(UsingComparable1 a) {
+		return id - a.id;
+	}
+
+	public static void main(String[] args) {
+		UsingComparable1 a1 = new UsingComparable1();
+		UsingComparable1 a2 = new UsingComparable1();
+		a1.id = 5;
+		a2.id = 7;
+		System.out.println(a1.compareTo(a2)); // -2
+		System.out.println(a1.compareTo(a1)); // 0
+		System.out.println(a2.compareTo(a1)); // 2
+	}
+}