ArraryUnorderedList无法解析为某种类型

Question

我正在尝试使用Array实现创建二叉树。但是，在Eclipse中，我收到错误消息“ArrayUnorderedList＆lt; T＆gt;无法解析为类型”。我不知道为什么我收到这个错误。任何帮助将不胜感激。所有这些都是基于Java的。如果我需要了解更多细节，请告诉我。

package jsjf;

import java.util.*;
import jsjf.exceptions.ElementNotFoundException;
import jsjf.exceptions.EmptyCollectionException;

public class ArrayCSBinaryTree<T> implements BinaryTreeADT<T>, Iterable<T> {
    private static final int DEFAULT_CAPACITY = 50;

    protected BinaryTreeNode<T> root; 
    protected int count;
    protected T[] tree;
    protected int modCount;

    @SuppressWarnings("unchecked")
    public ArrayCSBinaryTree() {
    root = null;
    count = 0;
    tree = (T[]) new Object[DEFAULT_CAPACITY];
    }

    public ArrayCSBinaryTree(T element) 
    {
        root = new BinaryTreeNode<T>(element);
    }

    @SuppressWarnings("unchecked")
    public ArrayCSBinaryTree(T element, ArrayCSBinaryTree<T> left, 
            ArrayCSBinaryTree<T> right) {

        root = new BinaryTreeNode<T>(element);
        root.setLeft(left.root);
        root.setRight(right.root);
        count = 1;
        tree = (T[]) new Object[DEFAULT_CAPACITY];
        tree[0] = element;
    }

    protected void expandCapacity() {
        tree = Arrays.copyOf(tree, tree.length * 2);
    }

    public T getRootElement() throws EmptyCollectionException {
        if (isEmpty())
            throw new EmptyCollectionException("ArrayBinaryTree");

        return tree[0];
    }

    public boolean isEmpty() {
        return (count == 0);
    }

    public int size() {
        return count;
    }

    public int getHeight() {
        return height(root);
    }

    private int height(BinaryTreeNode<T> node) {
        if (node == null) {
            return 0;
        } else {
            int leftHeight = height(node.getLeft());
            int rightHeight = height(node.getRight());
            return (1 + Math.max(leftHeight, rightHeight));
        }
    }

    public boolean contains(T targetElement) {
        T temp;
        boolean found = false;

        try {
            temp = find(targetElement);
            found = true;
        } catch (Exception ElementNotFoundException) {
            found = false;
        }

        return found;
    }

    public T find(T targetElement) throws ElementNotFoundException {
        T temp = null;
        boolean found = false;

        for (int i = 0; i < tree.length && !found; i++)
            if (tree[i] != null)
                if (targetElement.equals(tree[i])) {
                    found = true;
                    temp = tree[i];
                }

        if (!found)
            throw new ElementNotFoundException("ArrayCSBinaryTree");

        return temp;
    }

    public String toString() {
        ArrayUnorderedList<T> templist = new ArrayUnorderedList<T>();
        inOrder(0, templist);

        return templist.toString();
    }

    public Iterator<T> iterator() {
        return this.iteratorInOrder();
    }

    public Iterator<T> iteratorInOrder() {
        ArrayUnorderedList<T> templist = new ArrayUnorderedList<T>();
        inOrder(0, templist);

        return new TreeIterator(templist.iterator());
    }

    protected void inOrder(int node, ArrayUnorderedList<T> templist) {
        if (node < tree.length)
            if (tree[node] != null) {
                inOrder(node * 2 + 1, templist);
                templist.addToRear(tree[node]);
                inOrder((node + 1) * 2, templist);
            }
    }

    public Iterator<T> iteratorPreOrder() {
        ArrayUnorderedList<T> templist = new ArrayUnorderedList<T>();
        preOrder(0, templist);

        return new TreeIterator(templist.iterator());
    }

    protected void preOrder(int node, ArrayUnorderedList<T> templist) {
        if (node < tree.length)
            if (tree[node] != null) {
                templist.addToRear(tree[node]);
                preOrder(node * 2 + 1, templist);
                preOrder((node + 1) * 2, templist);
            }
    }

    public Iterator<T> iteratorPostOrder() {
        ArrayUnorderedList<T> templist = new ArrayUnorderedList<T>();
        postOrder(0, templist);

        return new TreeIterator(templist.iterator());
    }

    protected void postOrder(int node, ArrayUnorderedList<T> templist) {
        if (node < tree.length)
            if (tree[node] != null) {
                postOrder(node * 2 + 1, templist);
                postOrder((node + 1) * 2, templist);
                templist.addToRear(tree[node]);
            }
    }

    public Iterator<T> iteratorLevelOrder() {
        ArrayUnorderedList<T> templist = new ArrayUnorderedList<T>();
        int ct = 0;
        int i = 0;

        while (ct < count) {
            if (tree[i] != null) {
                templist.addToRear(tree[i]);
                ct++;
            }
            i++;
        }

        return new TreeIterator(templist.iterator());
    }

    private class TreeIterator implements Iterator<T> {
        private int expectedModCount;
        private Iterator<T> iter;

        public TreeIterator(Iterator<T> iter) {
            this.iter = iter;
            expectedModCount = modCount;
        }

        public boolean hasNext() throws ConcurrentModificationException {
            if (!(modCount == expectedModCount))
                throw new ConcurrentModificationException();

            return (iter.hasNext());
        }

        public T next() throws NoSuchElementException {
            if (hasNext())
                return (iter.next());
            else
                throw new NoSuchElementException();
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }
    }
}