Java基础之泛型——使用二叉树进行排序（TryBinaryTree）

控制台程序。

1、实现针对容器类的基于集合的循环

为了让容器类类型的对象能够在基于集合的for循环中可用，类必须并且只需要满足一个要求——必须实现泛型接口java.lang.Iterable<>。接口Iterable<T>是声明了单个方法iterable<T>接口并且提供对iterable()方法的实现。

 import java.util.Iterator;

 public class LinkedList<T> implements Iterable<T> {

   // Returns an iterator for this list
   public Iterator<T> iterator() {
     return new ListIterator();                                         // Create iterator of the inner class type
   }

   // Default constructor - creates an empty list
   public LinkedList() {}

   // Constructor to create a list containing one object
   public LinkedList(T item) {
     if(item != null) {
       current = end = start = new ListItem(item);                      // item is the start and end
     }
   }

   // Construct a linked list from an array of objects
   public LinkedList(T[] items) {
     if(items != null) {
       // Add the items to the list
       for(int i = 0; i < items.length; ++i) {
         addItem(items[i]);
       }
       current = start;
     }
   }

   // Add an item object to the list
   public void addItem(T item) {
     ListItem newEnd = new ListItem(item);                              // Create a new ListItem
     if(start == null) {                                                // Is the list empty?
       start = end = newEnd;                                            // Yes, so new element is start and end
     } else {                                                           // No, so append new element
       end.next = newEnd;                                               // Set next variable for old end
       end = newEnd;                                                    // Store new item as end
     }
   }
   // Get the first object in the list
   public T getFirst() {
     current = start;
     return start == null ? null : start.item;
   }

   // Get the next object in the list
   public T getNext() {
     if(current != null) {
       current = current.next;                                          // Get the reference to the next item
     }
     return current == null ? null : current.item;
   }

   private ListItem start = null;                                       // First ListItem in the list
   private ListItem end = null;                                         // Last ListItem in the list
   private ListItem current = null;                                     // The current item for iterating

   private class ListItem {

     // Constructor
     public ListItem(T item) {
       this.item = item;                                                // Store the item
       next = null;                                                     // Set next as end point
     }

     // Return class name & object
     @Override
     public String toString() {
       return "ListItem " + item ;
     }

     ListItem next;                                                    // Refers to next item in the list
     T item;                                                           // The item for this ListItem
   }

   private class ListIterator implements Iterator<T> {
     // Constructor
     public ListIterator() {
       nextElement = getFirst();
     }

     // Method to test whether more elements are available
     public boolean hasNext() {
       return nextElement != null;
     }

     // Method to return the next available object from the linked list
     public T next() {
       T element = nextElement;
       if(element == null) {
         throw new java.util.NoSuchElementException();
       }
       nextElement = getNext();
         return element;
     }

     // Method to remove the last element retrieved from the linked list
     // You don't want to support this operation for the linked list
     // so just throw the exception
     public void remove() {
       throw new UnsupportedOperationException("Remove not supported for LinkedList<>");
     }

     private T nextElement;
   }
 }

泛型LinkedList<>类类型现在实现了泛型接口类型Iterable<>，并且它们共享通用的类型参数。所以可以通过简单地实现Iterable<>接口并使用基于集合的for循环来定义包含任意类型对象集合的类，并且提供用于对内容进行迭代的功能。接口会自动被定制成能使用特定容器包含的任意类型对象。

2、定义二叉树泛型类

 public class BinaryTree<T extends Comparable<T>> {

   // Add a value to the tree
   public void add(T value) {
     if(root == null) {                                                 // If there's no root node
       root = new Node(value);                                          // store it in the root
     } else {                                                           // Otherwise...
       add(value, root);                                                // add it recursively
     }
   }

   // Recursive insertion of an object
   private void add(T value, Node node) {
     int comparison = node.obj.compareTo(value);
     if(comparison == 0) {                                              // If it is equal to the current node
       ++node.count;                                                    // just increment the count
       return;
     }
     if(comparison > 0) {                                               // If it's less than the current node
       if(node.left == null) {                                          // and the left child node is null
         node.left = new Node(value);                                   // Store it as the left child node
       } else {                                                         // Otherwise...
         add(value, node.left);                                         // ... call add() again at the left node
       }
     } else {                                                           // It must be greater than the current node
       if(node.right == null) {                                         // so it must go to the right...
         node.right = new Node(value);                                  // store it as the right node
       } else {                                                         // ...or when right node is not null
         add(value, node.right);                                        // ...call add() again at the right node
       }
     }
   }

   // Create a list containing the values from the tree in sequence
   public LinkedList<T> sort() {
     LinkedList<T> values = new LinkedList<>();                         // Create a linked list
     treeSort(root, values);                                            // Sort the objects into the list
     return values;
   }

   // Extract the tree nodes in sequence
   private void treeSort(Node node, LinkedList<T> values) {
     if(node != null) {                                                 // If the current node isn't null
       treeSort(node.left, values);                                     // process its left child node

       // List the duplicate objects for the current node
       for(int i = 0 ; i < node.count ; ++i) {
         values.addItem(node.obj);
        }
       treeSort(node.right, values);                                    // Now process the right child node
     }
   }

   private Node root;                                                   // The root node

   // Private inner class defining nodes
   private class Node {
     Node(T value) {
       obj = value;
       count = 1;
     }

     T obj;                                                             // Object stored in the node
     int count;                                                         // Count of identical objects
     Node left;                                                         // The left child node
     Node right;                                                        // The right child node
   }
 }

使用类型参数（用来约束参数化接口类型Comparable<T>的实现）来定义BinaryTree<T>。因此，使用BinaryTree<T>类型的任何类型参数都必须实现Comparable<T>接口。如果不这样做，代码就不会编译。这样可以确保添加到BinaryTree<T>对象的所有对象都有可用的Comparable()方法。

3、尝试使用BianaryTree<>对象对整数和字符串进行排序

 public class TryBinaryTree {
   public static void main(String[] args) {
     int[] numbers = new int[30];
     for(int i = 0 ; i < numbers.length ; ++i) {
       numbers[i] = (int)(1000.0*Math.random());                        // Random integers 0 to 999
     }

     // List starting integer values
     int count = 0;
     System.out.println("Original values are:");
     for(int number : numbers) {
       System.out.printf("%6d", number);
       if(++count%6 == 0) {
         System.out.println();
       }
     }

     // Create the tree and add the integers to it
     BinaryTree<Integer> tree = new BinaryTree<>();
     for(int number:numbers) {
       tree.add(number);
     }

     // Get sorted values
     LinkedList<Integer> values = tree.sort();
     count = 0;
     System.out.println("\nSorted values are:");
     for(Integer value : values) {
       System.out.printf("%6d", value);
       if(++count%6 == 0) {
         System.out.println();
       }
     }

     // Create an array of words to be sorted
     String[] words = {"vacillate", "procrastinate", "arboreal", "syzygy",
                       "xenocracy", "zygote"       , "mephitic", "soporific",
                       "grisly"   , "gristly" };

     // List the words
     System.out.println("\nOriginal word sequence:");
     for(String word : words) {
       System.out.printf("%-15s", word);
       if(++count%5 == 0) {
         System.out.println();
       }
     }

     // Create the tree and insert the words
     BinaryTree<String> cache = new BinaryTree<>();
     for(String word : words) {
       cache.add(word);
     }

     // Sort the words
     LinkedList<String> sortedWords = cache.sort();

     // List the sorted words
     System.out.println("\nSorted word sequence:");
     count = 0;
     for(String word : sortedWords) {
       System.out.printf("%-15s", word);
       if(++count%5 == 0) {
         System.out.println();
       }
     }
   }
 }

这里之所以能使用基于集合的for循环，是因为LinkedList<T>类型实现了Iterable<T>接口，这是让容器能使用这个for循环来访问元素的唯一先决条件。