OCJP Collections

BackingCollection.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


public class BackingCollection {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		
		list.add(7);
		list.add(4);
		
		Integer[] array = new Integer[1];
		array = list.toArray(array);
		
		list.add(3);
		for (Integer integer : array) {
			System.out.print(integer);
		}
		
		System.out.println();
		
		List<Integer> backedList = Arrays.asList(array);
		for (Integer integer : backedList) {
			System.out.print(integer);
		}
		
		System.out.println();
		array[0] = 3;
		for (Integer integer : backedList) {
			System.out.print(integer);
		}
		
		backedList.set(1, 5);
		System.out.println();
		for (Integer integer : array) {
			System.out.print(integer);
		}
	}
}

CollectionsHierarchy.java

import java.util.*;

public class CollectionsHierarchy {

	List arrayList = new ArrayList();
	List vector = new Vector();
	List linkedList = new LinkedList();
	
	Queue queue = new LinkedList();
	Queue priorityQueue = new PriorityQueue();
	
	HashSet linkedHashSet = new LinkedHashSet();
	Set hashSet = new HashSet();
	
	NavigableSet treeSet = new TreeSet();
	SortedSet sortedSet = treeSet;
	Set set = sortedSet;
	
	Collection collection = arrayList;
	Collection collection2 = queue;
	Collection collection3 = set;
	
	Map hashtable= new Hashtable();
	HashMap linkedHashMap = new LinkedHashMap();
	Map hashMap = new HashMap();
	
	NavigableMap treeMap = new TreeMap();
	SortedMap sortedMap = treeMap;
	Map map = treeMap;
}

NavigableSetsAndMaps.java

import java.util.*;

public class NavigableSetsAndMaps {
	public static void main(String[] args) {
		TreeSet<Integer> treeSet = new TreeSet<Integer>(Arrays.asList(1, 2, 3,
				4, 5, 6, 7, 8, 9));
		TreeMap<Integer, Integer> treeMap = new TreeMap<Integer, Integer>();
		treeMap.put(1, 1);
		treeMap.put(2, 2);
		treeMap.put(3, 3);
		treeMap.put(4, 4);
		treeMap.put(5, 5);
		treeMap.put(6, 6);
		treeMap.put(7, 7);
		treeMap.put(8, 8);
		treeMap.put(9, 9);

		NavigableSet<Integer> descendingSet = treeSet.descendingSet();
		NavigableMap<Integer, Integer> descendingMap = treeMap.descendingMap();

		SortedSet<Integer> headSet = treeSet.headSet(5);
		SortedMap<Integer, Integer> headMap = treeMap.headMap(5);

		SortedSet<Integer> tailSet = treeSet.tailSet(5);
		SortedMap<Integer, Integer> tailMap = treeMap.tailMap(5);

		System.out.println("treeSet.ceiling(0): " + treeSet.ceiling(0));
		System.out.println("treeMap.ceilingKey(0): " + treeMap.ceilingKey(0));

		System.out.println("treeSet.higher(5): " + treeSet.higher(5));
		System.out.println("treeMap.higherKey(5): " + treeMap.higherKey(5));

		System.out.println("treeSet.floor(10): " + treeSet.floor(10));
		System.out.println("treeMap.floorKey(10): " + treeMap.floorKey(10));

		System.out.println("treeSet.lower(5): " + treeSet.lower(5));
		System.out.println("treeMap.lowerKey(5): " + treeMap.lowerKey(5));

		System.out.println();

		System.out.println("treeSet.pollFirst(): " + treeSet.pollFirst());
		System.out.println("treeMap.pollFirstEntry(): "
				+ treeMap.pollFirstEntry());

		System.out.println("treeSet.pollLast(): " + treeSet.pollLast());
		System.out.println("treeMap.pollLastEntry(): "
				+ treeMap.pollLastEntry());

		System.out.println();

		System.out.println("descendingSet: " + descendingSet);
		System.out.println("descendingMap: " + descendingMap);

		System.out.println("headSet: " + headSet);
		System.out.println("headMap: " + headMap);

		System.out.println("tailSet: " + tailSet);
		System.out.println("tailMap: " + tailMap);

	}
}

PriorityQueueUsage.java

import java.util.Arrays;
import java.util.PriorityQueue;

public class PriorityQueueUsage {
	public static void main(String[] args) {

		PriorityQueue<Integer> pq = new PriorityQueue<Integer>(Arrays.asList(8, 3, 2, 6, 5, 9, 1));
		System.out.println("size: " +pq.size());
		pq.offer(4);
		pq.add(7);
		System.out.println("size: " +pq.size());
		
		System.out.println("peek: "+pq.peek());
		System.out.println("poll: "+pq.poll());
		System.out.println("remove: "+pq.remove());
		System.out.println("size: " +pq.size());
		
		for (Integer integer : pq) {
			System.out.print(integer.toString() + " ");
		}
		
		System.out.println();
		
		int size = pq.size();
		for(int i=0; i < size; i++) {
			System.out.print(pq.poll() + " ");
		}
	}
}

Sorting.java

import java.util.ArrayList;
import java.util.Comparator;

class OldFashionSortable implements Comparable {
	private int val;
	
	public OldFashionSortable(int i) {
		val = i;
	}
	
	@Override
	public int compareTo(Object arg) {
		// not checking,  since ClassCastException indicates that other classes are not
		// "mutually comparable" to OldFashionSortable
		// if (arg instanceof OldFashionSortable) {  
			return ((OldFashionSortable) arg).val - val;
	}
	
}

class Sortable implements Comparable<Sortable> {
	private int val;

	public Sortable(int i) {
		val = i;
	}
	
	@Override
	public int compareTo(Sortable o) {
		return o.val - val;
	}
	
}

class NotSortable {
	private int val;

	public NotSortable(int i) {
		val = i;
	}
	
}

public class Sorting {
	public static void main (String [] args) {
		ArrayList<Sortable> sortableArray = new ArrayList<Sortable>();
		ArrayList<NotSortable> notSortableArray = new ArrayList<NotSortable>();
		
		//public static <T extends Comparable<? super T>> void sort(List<T> list)
		java.util.Collections.sort(sortableArray);
		//java.util.Collections.sort(notSortableArray);  Need to use Comparator
		java.util.Collections.sort(notSortableArray, new Comparator<NotSortable>() {
			@Override
			public int compare(NotSortable o1, NotSortable o2) {return 0;}
		});
		
		java.util.Arrays.sort( new int[] {3,2,1} );
	}
}