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("
Sorted 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("
Original 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("
Sorted 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循环来访问元素的唯一先决条件。