关于java一个简单语法问题<K,V>

Question

某些类的定义如类ArrayList<E>和类HashMap<K,V>后面那个<>究竟是怎么个语法啊。
因为E，K，V这三个参数既不是类也不是基本数据类型，java怎么就能解析它们呢？我用其它字母代替它定义会有什么结果？
比如: ArrayList<S>和类HashMap<G,W>？
注意：我也明白<>中参数的意义，E指元素，K指key键索引，V指vaule键值。
但是是不是自己定义的类也可以用这个语法。
哪位大侠能不能用自己定义的类来解释一下这个语法？

Answer 1

此回复为自动发出,仅用于显示而已，并无任何其他特殊作用
楼主【redbridge】截止到2008-06-25 23:45:08的历史汇总数据(不包括此帖)：
发帖数:20                 发帖分:650                
结贴数:19                 结贴分:640                
未结数:1                  未结分:10                 
结贴率:95.00 %            结分率:98.46 %            
值得尊敬

Answer 2

那是泛型,后面的<E,F>是两个任意类的名称
比如ArrayList<E> list=new ArrayList<String>();
HashMap<K,V> map=new HashMap<String,Long>();
由于jdk1.4里面提供的arraylist只能对object进行操作,存取需要强制转换很麻烦,1.5的时候就增加了泛型来解决这个问题

Answer 3

泛型比如,你定义一个ArrayList,你希望这个ArrayList中放的数据全部都是String类型的,那么你就可以定义为:
ArrayList<String>,这样的好处是当你用ArrayList的方法返回其中的元素时,返回的元素类型本身就已经是String类型了,而JAVA1.5以前没有使用泛型,返回的类型就是Object,这样的话还得你自己强制转换成String.HashMap同理.

Answer 4

这是泛型参数哦，是 JDK 1.5 新增的语言特性，属于语言级别的，不属于 API 级别的东西。E、K、V 什么的你当然可以用成其他的字母了，这里用这些只是为了能一目了然。你自己写的泛型类的话，使用 C、S、D、N 都是可以的。下面这个是官方的泛型教程，有兴趣的话可以看看。
http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

Answer 5

一个非常简单的小例子：public class GenericTest {    public static void main(String[] args) {
        
        HelloWorld<String> hello = new HelloWorld<String>();        
        // 由于指定了泛型参数为 String 类型，因此 T 就使用 String 来代替了
        // setName 中的参数只能是 String 类型的了
        hello.setName("hi");
        System.out.println(hello.getName());
        
        HelloWorld<Integer> integer = new HelloWorld<Integer>();
        integer.setName(new Integer(5));
        System.out.println(integer.getName());
    }
}class HelloWorld<T> {
    private T name;
    public T getName() {
        return name;
    }
    public void setName(T name) {
        this.name = name;
    }    
}

Answer 6

在<>里写了类型,<String>,在底下参数就为String类型了

Answer 7

继续请教，下面是HashMap类的putAll方法。
请教1：其参数(Map<? extends K, ? extends V> m)是什么意思呢？怎么解析？
请教2：后面的for循环又如何解析呢？
         for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
            Map.Entry<? extends K, ? extends V> e = i.next();
            put(e.getKey(), e.getValue());
        }
public void putAll(Map<? extends K, ? extends V> m) {
        int numKeysToBeAdded = m.size();
        if (numKeysToBeAdded == 0)
            return;        /*
         * Expand the map if the map if the number of mappings to be added
         * is greater than or equal to threshold.  This is conservative; the
         * obvious condition is (m.size() + size) >= threshold, but this
         * condition could result in a map with twice the appropriate capacity,
         * if the keys to be added overlap with the keys already in this map.
         * By using the conservative calculation, we subject ourself
         * to at most one extra resize.
         */
        if (numKeysToBeAdded > threshold) {
            int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
            if (targetCapacity > MAXIMUM_CAPACITY)
                targetCapacity = MAXIMUM_CAPACITY;
            int newCapacity = table.length;
            while (newCapacity < targetCapacity)
                newCapacity <<= 1;
            if (newCapacity > table.length)
                resize(newCapacity);
        }        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
            Map.Entry<? extends K, ? extends V> e = i.next();
            put(e.getKey(), e.getValue());
        }
    }

Answer 8

Map <? extends K, ? extends V><>中的两个参数的用法其实和我们平常所说的继承差不多,比如说,你定义Map<? extends Integer,? extends String>,意思就是说,你的这个Map里,第一个参数(即键)必须是Integer或其子类才行,其他的类型都不可以,第二个参数同理.for (Iterator <? extends Map.Entry <? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); )
和for(int i=0;i++;)类比,Iterator <? extends Map.Entry <? extends K, ? extends V>> i = m.entrySet().iterator()就相当于int i=0,而i.hasNext()就相当于i++,这是一个很普通的循环啊!!!
PS:楼主这可是一帖多问啊!!!

Answer 9

强行设定了arraylist对象中存储的类型,这样可以减少错误