JAVA类集合框架练习例题

import java.util.ConcurrentModificationException;
import java.util.NoSuchElementException;

    public class TreeSet<E> {
        /**
         * 用于对该集合中的元素进行排序的比较器，如果该集合使用其元素的自然顺序，则为null
         * @return
         * 返回用于对该集合中的元素进行排序的比较器如果该集合使用其元素的自然排序，则返回null。
         */
        public Comparator<? super E> comparator() {
            return tree.comparator() ;
        }
        /**
         * 一个数组，其运行时组件类型为Object，包含此集合中的所有元素
         * @return
         * 返回包含此集合中所有元素的数组。
         */
        public Object[] toArray(){
            return tree.toArray() ;
        }
        /**
         * 此集合中元素大于或等于fromElement的部分的视图
         * @param fromElement
         * 返回集的低端
         * @param inclusive
         * 如果要在返回的视图中包括低端端点，则为true
         * @return
         * 返回此集合中元素大于（或等于，如果inclusive为true）fromElement的部分的视图。
         */
        public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
            return tree.tailSet(fromElement, inclusive);
        }
        /**
         * 此集合中元素大于或等于fromElement的部分的视图
         * @param fromElement
         * 返回集的低端（含低端）
         * @return
         * 返回此集合中元素大于或等于fromElement的部分的视图。
         */
        public SortedSet<E> tailSet(E fromElement) {
            return tree.tailSet(fromElement) ;
        }
        public SortedSet<E> subSet(E e1 , E e2) {
            return tree.subSet(e1, e2) ;
        }
        /**
         * @return
         * 返回此集合中的元素数（其基数）。
         */
        public int size() {
            return tree.size() ;
        }
        /**
         * 从该映射中删除密钥的映射（可选操作）。
         * @param e
         * 要从映射中删除其映射的键
         * @return
         * 与key关联的上一个值，如果key没有映射，则为null。
         */
        public boolean remove(E e) {
            return tree.remove(e) ;
        }
        /**
         * 检索并删除最后一个（最高）元素，如果此集合为空，则返回null。
         * @return
         * 最后一个元素，如果此集合为空，则为null
         */
        public E pollLast() {
            return tree.pollLast() ;
        }
        /**
         * 检索并删除第一个（最低）元素，如果此集合为空，则返回null。
         * @return
         * 第一个元素，如果此集合为空，则为null
         */
        public E pollFirst() {
            return tree.pollFirst() ;
        }
        /**
         * 返回该集合中最大的元素，该元素严格小于给定的元素，如果没有这样的元素，则返回null。
         * @param e
         * 要匹配的值
         * @return
         * 小于e的最大元素，如果没有这样的元素，则为null
         */
        public E lower(E e) {
            return tree.lower(e) ;
        }
        /**
         * 返回此映射中当前的最后一个（最高）键
         * @return
         * 此地图中当前的最后一个（最高）键
         */
        public E  last() {
            return tree.lastKey() ;
        }
        /**
         * 如果此映射不包含键值映射，则返回{@code true}。
         * @return
         * {@code true}如果此映射不包含键值映射
         */
        public boolean isEmpty() {
            return tree.isEmpty() == true ;
        }
        /**
         * 大于e的最小元素，如果没有这样的元素，则为null
         */
        public E higher(E e) {
            return tree.higher(e) ;
        }
        /**
         * @return
         * 小于或等于e的最大元素，如果没有这样的元素，则为null
         */
        public E floor(E e) {
            return tree.floor(e) ;
        }
        /**
         * @return
         * 此集合中当前的第一个（最低）元素
         */
        public E first() {
            return tree.first() ;
        }
        /**
         * @return
         * 如果此集合包含指定的元素，则为true
         */
        public boolean contains(Object o) {
            return tree.contains(o) ;
        }
        /**
         * 回此集合中大于或等于给定元素的最小元素，如果没有此类元素，则返回null。
         * @param e
         * 要匹配的值
         * @return
         * 大于或等于e的最小元素，如果没有这样的元素，则为null
         */
        public E ceiling(E e) {
            return tree.ceiling(e) ;
        }
        /**
         * 返回此{@code TreeSet1}实例的浅层副本。
         * @return 
         * 复制品
         */
        public Object clone() {
            return tree.clone() ;
        }
        /**
         * 如果指定的元素尚未存在，则将其添加到此集合。
         * @param e
         * 要检查此集合中是否包含的对象
         * @return
         * 如果此集合包含指定的元素,就返回true
         */
        public boolean add(E e) {
            return tree.add(e) ;
        }
        private transient TreeSet1<E> tree ;
        public TreeSet() {
            this.tree = new TreeSet1<>() ;
        }
        public synchronized String toString() {
            return tree.toString() ;
        }
        public Iterator<E> integer() {
            return tree.iterator() ;
        }
        /**
         * 集合器
         * @author Administrator
         *
         * @param <E>
         */
        public static class TreeSet1<E> extends AbstractSet<E> implements NavigableSet<E> ,Cloneable{
            /**
             * 用于对该集合中的元素进行排序的比较器，如果该集合使用其元素的自然顺序，则为null
             * @return
             * 返回用于对该集合中的元素进行排序的比较器
             * 如果该集合使用其元素的自然排序，则返回null。
             */
            public Comparator<? super E> comparator() {
                return m.comparator() ;
            }
            /**
             * 此集合中元素大于或等于fromElement的部分的视图
             * @param fromElement
             * 返回集的低端
             * @param inclusive
             * 如果要在返回的视图中包括低端端点，则为true
             * @return
             * 返回此集合中元素大于（或等于，如果inclusive为true）fromElement的部分的视图。
             */
            public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
                return new TreeSet1<>(m.tailMap(fromElement, inclusive));
            }
            /**
             * 此集合中元素大于或等于fromElement的部分的视图
             * @param fromElement
             * 返回集的低端（含低端）
             * @return
             * 返回此集合中元素大于或等于fromElement的部分的视图。
             */
            public SortedSet<E> tailSet(E fromElement) {
                return tailSet(fromElement, true);
            }
            /**
             * 此集合中元素范围从包含的元素到排除的元素部分的视图
             * @param fromElement
             * 返回集的低端
             * @param fromInclusive
             * 如果要在返回的视图中包括低端端点，则为true
             * @param toElement
             * 返回集的高端
             * @param toInclusive
             * 如果要在返回的视图中包括高端端点，则为true
             * @return
             * 返回此集合中元素范围从Element到toElement的部分的视图。
             * 如果fromElement和toElement相等，则返回的集为空
             */
            public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,E toElement,boolean toInclusive) {
                return new TreeSet1<>(m.subMap(fromElement, fromInclusive,toElement,toInclusive));
            }
            /**
             * 此集合中的元素范围从包含的元素到排除的元素部分的视图
             * @param fromElement
             * 返回集的低端（含低端）
             * @param toElement
             * 返回集的高端（独占）
             * @return
             * 返回此集合中元素范围从fromElement，inclusive到toElement，
             * exclusive的部分的视图。（如果fromElement和toElement相等，则返回的集为空。）
             */
            public SortedSet<E> subSet(E fromElement, E toElement) {
                return subSet(fromElement, true, toElement, false);
            }
            /**
             * 从该映射中删除密钥的映射（可选操作）。
             * @param o
             * 要从映射中删除其映射的键
             * @return
             * 与key关联的上一个值，如果key没有映射，则为null。
             */
            public boolean remove(Object o) {
                return m.remove(o)==PRESENT;
            }
            /**
             * 检索并删除最后一个（最高）元素，如果此集合为空，则返回null。
             * @return
             * 最后一个元素，如果此集合为空，则为null
             */
            public E pollLast() {
                Map.Entry<E,?> e = m.pollLastEntry();
                return (e == null) ? null : e.getKey();
            }
            /**
             * 检索并删除第一个（最低）元素，如果此集合为空，则返回null。
             * @return
             * 第一个元素，如果此集合为空，则为null
             */
            public E pollFirst() {
                Map.Entry<E,?> e = m.pollFirstEntry();
                return (e == null) ? null : e.getKey();
            }
            /**
             * 返回该集合中最大的元素，该元素严格小于给定的元素，如果没有这样的元素，则返回null。
             * @param e
             * 要匹配的值
             * @return
             * 小于e的最大元素，如果没有这样的元素，则为null
             */
            public E lower(E e) {
                return m.lowerKey(e) ;
            }
            /**
             * 返回此映射中当前的最后一个（最高）键。
             * @return
             * 此地图中当前的最后一个（最高）键
             */
            public E lastKey() {
                return m.lastKey() ;
            }
            /**
             * 如果此集合不包含任何元素，则返回true。
             * @return
             * 如果此集合不包含元素，则为true
             */
            public boolean isEmpty() {
                return m.isEmpty() ;
            }
            /**
             * 返回此集合中的元素数（其基数）。
             */
            public int size() {
                return m.size();
            }
             TreeMap1<E,Object> map ;
            
            /**
             * @return
             * 大于e的最小元素，如果没有这样的元素，则为null
             */
            public E higher(E e) {
                return m.higherKey(e) ;
            }
            /**
             * @return
             * 小于或等于e的最大元素，如果没有这样的元素，则为null
             */
            public E floor(E e) {
                return m.floorKey(e) ;
            }
            /**
             * @return
             * 此集合中当前的第一个（最低）元素
             */
            public E first() {
                return m.firstKey() ;
            }
            /**
             * 如果此集合包含指定的元素，则返回{@code true}。
             * @param o
             * @return
             */
            public boolean contains(Object o) {
                return m.containsKey(o);
            }
            /**
             * 回此集合中大于或等于给定元素的最小元素，如果没有此类元素，则返回null。
             * @param e
             * 要匹配的值
             * @return
             * 大于或等于e的最小元素，如果没有这样的元素，则为null
             */
            public E ceiling(E e) {
                return m.ceilingKey(e) ;
            }
            @SuppressWarnings("unchecked")
            public Object clone() {
                TreeSet1<E> clone;
                try {
                    clone = (TreeSet1<E>) super.clone();
                } catch (CloneNotSupportedException e) {
                    throw new InternalError(e);
                }
                /*构造一个新的树映射，其中包含与指定的排序映射相同的映射，
                 * 并使用相同的顺序，可以不要这个*/
                clone.m = new TreeMap1<>(m);
                return clone;
            }
            private static final Object PRESENT = new Object() ;
            /**
             * 背景地图。
             */
            private transient NavigableMap<E, Object> m ;
            public TreeSet1(NavigableMap<E,Object> m) {
                this.m = m ;
            }
            public TreeSet1() {
                this(new TreeMap1<>()) ;
            }
            public boolean add( E e ) {
                return m.put(e , PRESENT) == null ;
            } 
            public Iterator<E> iterator() {
                return m.navigableKeySet().iterator() ;
            }
        }
        public interface SortedMap<K,V> extends Map<K,V>{
            /**
             * 用于对该映射中的键进行排序的比较器，如果该映射使用其键的自然顺序，则为null
             * @return
             */
            Comparator<? super K> comparator();
            /**
             * 返回此映射中当前的第一个（最低）键。
             * @return
             * 此地图中当前的第一个（最低）键
             */
            K firstKey();
            /**
             * 返回此映射中当前的最后一个（最高）键
             * @return
             * 此地图中当前的最后一个（最高）键
             */
            K lastKey();
        }
        public interface NavigableMap<K,V> extends SortedMap<K,V>{
            
            /**
             * 此地图中关键帧大于（或等于，如果包含为真）fromKey部分的视图
             * @param fromkey
             * 返回的映射中键的低端
             * @param inclusive
             * 如果要在返回的视图中包括低端端点，则为true
             * @return
             * 返回此映射中键大于（或等于，如果inclusive为true）fromKey的部分的视图。
             */
            NavigableMap<K,V> tailMap(K fromkey , boolean inclusive) ;
            /**
             * 返回此地图中关键帧范围从fromKey到toKey的部分的视图。
             * 如果fromKey和toKey相等，则返回的映射为空
             * @param fromKey
             * 返回的映射中键的低端
             * @param fromInclusive
             * 如果要在返回的视图中包括低端端点，则为true
             * @param toKey
             * 返回的映射中键的高端
             * @param toInclusive
             * 如果要在返回的视图中包括高端端点，则为true
             * @return
             * 此地图的关键帧范围从from Key到toKey的部分视图
             */
            NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,K toKey,   boolean toInclusive);
            /**
             * 移除并返回与此映射中最大键关联的键值映射，如果映射为空，则返回null。
             * @return
             * 已删除此映射的最后一个条目，如果此映射为空，则为null
             */
            Map.Entry<K,V> pollLastEntry();
            /**
             * 移除并返回与此映射中最小键关联的键值映射，如果映射为空，则返回{@code null}。
             * @return
             * 已删除此映射的第一个条目，如果此映射为空，则为null
             */
            Map.Entry<K,V> pollFirstEntry();
            /**
             * 返回严格小于给定密钥的最大密钥，如果没有此类密钥，则返回null。
             * @param key
             * 钥匙