java的一些特殊标示符

Question

兄弟看java jdk帮助和java源代码时发现里面有些从来没用过的特殊符号。不解，那位前辈指点一下。
    下面是java TreeSet的源码
    
    public class TreeSet<E>
    extends AbstractSet<E>
    implements SortedSet<E>, Cloneable, java.io.Serializable
{
    private transient SortedMap<E,Object> m; // The backing Map
    private transient Set<E> keySet; // The keySet view of the backing Map    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();   
    private TreeSet(SortedMap<E,Object> m) {
        this.m = m;
        keySet = m.keySet();
    }       public TreeSet() {
this(new TreeMap<E,Object>());
    }        public TreeSet(Comparator<? super E> c) {
this(new TreeMap<E,Object>(c));
    }       public TreeSet(Collection<? extends E> c) {
        this();
        addAll(c);
    }       public TreeSet(SortedSet<E> s) {
        this(s.comparator());
addAll(s);
    }
    public Iterator<E> iterator() {
return keySet.iterator();
    }      public int size() {
return m.size();
    }
    public boolean isEmpty() {
return m.isEmpty();
    }      public boolean contains(Object o) {
return m.containsKey(o);
    }       public boolean add(E o) {
return m.put(o, PRESENT)==null;
    }      public boolean remove(Object o) {
return m.remove(o)==PRESENT;
    }        public void clear() {
m.clear();
    }       public  boolean addAll(Collection<? extends E> c) {
        // Use linear-time version if applicable
        if (m.size()==0 && c.size() > 0 &&
    // FIXME(VFORCE) Work-around for bug in compiler
    c instanceof SortedSet &&
            m instanceof TreeMap) {
            SortedSet<Map.Entry<E, Object>> set = (SortedSet<Map.Entry<E, Object>>) (SortedSet) c;
            TreeMap<E,Object> map = (TreeMap<E, Object>) m;
            Comparator<? super E> cc = (Comparator<E>) set.comparator();
            Comparator<? super E> mc = map.comparator();
            if (cc==mc || (cc != null && cc.equals(mc))) {
                map.addAllForTreeSet(set, PRESENT);
                return true;
            }
        }
        return super.addAll(c);
    }    public SortedSet<E> subSet(E fromElement, E toElement) {
return new TreeSet<E>(m.subMap(fromElement, toElement));
    }       public SortedSet<E> headSet(E toElement) {
return new TreeSet<E>(m.headMap(toElement));
    }       public SortedSet<E> tailSet(E fromElement) {
return new TreeSet<E>(m.tailMap(fromElement));
    }        public Comparator<? super E> comparator() {
        return m.comparator();
    }        public E first() {
        return m.firstKey();
    }       public E last() {
        return m.lastKey();
    }       public Object clone() {
        TreeSet<E> clone = null;
try {
    clone = (TreeSet<E>) super.clone();
} catch (CloneNotSupportedException e) {
    throw new InternalError();
}        clone.m = new TreeMap<E,Object>(m);
        clone.keySet = clone.m.keySet();        return clone;
    }       private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
// Write out any hidden stuff
s.defaultWriteObject();        // Write out Comparator
        s.writeObject(m.comparator());        // Write out size
        s.writeInt(m.size()); // Write out all elements in the proper order.
for (Iterator i=m.keySet().iterator(); i.hasNext(); )
            s.writeObject(i.next());
    }    /**
     * Reconstitute the <tt>TreeSet</tt> instance from a stream (that is,
     * deserialize it).
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
// Read in any hidden stuff
s.defaultReadObject();        // Read in Comparator
        Comparator<E> c = (Comparator<E>) s.readObject();        // Create backing TreeMap and keySet view
TreeMap<E,Object> tm;
if (c==null)
    tm = new TreeMap<E,Object>();
else
    tm = new TreeMap<E,Object>(c);
m = tm;
        keySet = m.keySet();        // Read in size
        int size = s.readInt();        tm.readTreeSet(size, s, PRESENT);
    }    private static final long serialVersionUID = -2479143000061671589L;
}问题1：public class TreeSet<E>                    <E>是什么意思
问题2：private transient SortedMap<E,Object> m;   <E,Object>是什么意思
问题3：public TreeSet(Collection<? extends E> c)  <? extends E>是什么意思 

Answer 1

E是type
<E,Object>分别表示这个map的key value对类型
<? extends E>字面理解是未知对象继承自E

Answer 2

jdk1.5开始出现的"泛型"
和c++里的模板差不多

Answer 3

那为什么用E来表示，而不用其他的比如Object。E有什么意义呢？

Answer 4

E可以看成是Element的缩写
没什么特别意义的
你也可以用T,S,K什么的

Answer 5

用范型，存的什么类型，取出来的就是什么类型，不用强制转换
如果用Object，取出的是Object，你要强制转换成你存的那个类型才行