import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.TreeSet;

public class ObjectOverride {

	public static class NameAge implements Comparable {
		public String _name;
		public int    _age;
		public NameAge(String name, int age) {
			_name = name;
			_age  = age;
		}
		@Override
		public String toString() {
			return _name + ": " + _age;
		}

		@Override
		public boolean equals(Object o) {
			if (!(o instanceof NameAge))
				return false;
			NameAge n = (NameAge)o;
			//String s2 = (String)o; // o is not a String!  ClassCastException
			return _name.equals(n._name) && _age == n._age;
		}

		// Rule: return 1  if this should come after o
		//       return -1 if this should come before o
		//       return 0 if equals() say these are equal!
		@Override
		public int compareTo(Object o) {
			if (!(o instanceof NameAge))
				return 1; // Just consistently choose 1 or -1

			NameAge n = (NameAge)o;

			if (!this._name.equals(n._name))
				// Compare Strings if not equal
				return -this._name.compareTo(n._name);

			else if (this._age != n._age)
				// Compare ages if not equal
				return -(this._age - n._age);

			return 0; // Must be equal
		}

	}

	// Try commenting out toString() and equals() above
	public static void main1(String[] args) {
		NameAge n1 = new NameAge("Scott", 38);
		NameAge n2 = new NameAge("Penny", 1);
		NameAge n3 = new NameAge("Scott", 38);

		System.out.println("toString()");
		System.out.println(n1);
		System.out.println(n2);
		System.out.println(n3);

		System.out.println("Simple ==");
		System.out.println(n1 == n1);
		System.out.println(n1 == n2);
		System.out.println(n1 == n3);

		System.out.println("equals()");
		System.out.println(n1.equals(n1));
		System.out.println(n1.equals(n2));
		System.out.println(n1.equals(n3));
	}

	// Try commenting out toString() and equals() above
	public static void main2(String[] args) {
		NameAge n1 = new NameAge("Scott", 38);
		NameAge n2 = new NameAge("Penny", 1);
		NameAge n3 = new NameAge("Scott", 38);

		ArrayList<NameAge> l = new ArrayList<NameAge>();
		l.add(n1);
		l.add(n2);
		System.out.println(l);
		System.out.println(n1 + " :: " + l.contains(n1) + " / " + l.indexOf(n1));
		System.out.println(n2 + " :: " + l.contains(n2) + " / " + l.indexOf(n2));
		System.out.println(n3 + " :: " + l.contains(n3) + " / " + l.indexOf(n3));

		// Why does the following line work?
		TreeSet<NameAge> t = new TreeSet<NameAge>(l);
		//Collection<NameAge> h = new TreeSet<NameAge>(l);

		System.out.println(t);

		// Explore other abstractions for Collectons<E>, e.g., Iterable<E>
		// This is why we can use a for-each loop with collections
		for (NameAge na : t)
			System.out.println(" - " + na);

		System.out.println(n1 + " :: " + t.contains(n1));
		System.out.println(n2 + " :: " + t.contains(n2));
		System.out.println(n3 + " :: " + t.contains(n3));
	}

	// Try commenting out toString() and equals() and compareTo() above
	public static void main3(String[] args) {
		NameAge n1 = new NameAge("Scott", 38);
		NameAge n2 = new NameAge("Penny", 1);
		NameAge n3 = new NameAge("Scott", 38);
		NameAge n4 = new NameAge("Scott", 28);

		TreeSet<NameAge> t = new TreeSet<NameAge>();
		t.add(n1);
		t.add(n2);
		t.add(n3);
		t.add(n4);
		System.out.println(t);

		// How could we reverse the order

		// Explore other abstractions for Collectons<E>, e.g., Iterable<E>
		// This is why we can use a for-each loop with collections
		for (NameAge na : t)
			System.out.println(" - " + na);

		System.out.println(n1 + " :: " + t.contains(n1));
		System.out.println(n2 + " :: " + t.contains(n2));
		System.out.println(n3 + " :: " + t.contains(n3));
		System.out.println(n4 + " :: " + t.contains(n4));

		NameAge n5 = new NameAge("Noah", 5);
		System.out.println(n5 + " :: " + t.contains(n5));
	}

	// Fun with arrays
	public static void main4(String[] args) {
		NameAge[] array = new NameAge[] { new NameAge("Scott", 38), new NameAge("Penny", 1),
				                          new NameAge("Scott", 38), new NameAge("Scott", 28)};

		for (NameAge na : array)
			System.out.println(" - " + na);

		System.out.println("\nSorted:");

		// Sorting works for primimitives and any
		// object that implements Comparable
		Arrays.sort(array);
		for (NameAge na : array)
			System.out.println(" - " + na);

		System.out.println("=====================");

		///////////////////////////////////////////////////////////////

		// We can copy an entire array to a new one of different length
		NameAge[] array2 = Arrays.copyOf(array, array.length*2);
		for (NameAge na : array2)
			System.out.println(" - " + na);

		System.out.println("=====================");

		///////////////////////////////////////////////////////////////

		// We can convert arrays to Collections and back
		ArrayList<NameAge> list = new ArrayList<NameAge>(Arrays.asList(array2));
		System.out.println(list);

		NameAge[] array3 = list.toArray(new NameAge[list.size()]);
		for (NameAge na : array3)
			System.out.println(" - " + na);

//		TreeSet<NameAge> tree = new TreeSet<NameAge>(Arrays.asList(array2));
//		System.out.println(list);
//		System.out.println(tree);
	}

	public static void main(String[] args) {
		Double a = 2.0;
		Double b = 2.0;
		System.out.println(a == b); // No method call or operator
		                            // == is address equality

		System.out.println(a.equals(b)); // Explicitly invoke equals() call

		System.out.println(a + 0 == b + 0); // Operator invokes call
		                                    // d.doubleValue() + 0 == e.doubleValue() + 0
		                                    // then primitive comparison
	}
}